git.iko.soy/typeable/yaml
on master help sign in
swap
5f5462d10 ahead, 0 behind
21 files changed+30−12880
since splitsnapshots
unifiedsplit
.github/workflows/tests.yml+1−5 libyaml/ChangeLog.md+5 libyaml/copy-libyaml.sh−10 libyaml/libyaml.cabal+6−20 libyaml/libyaml_src/LICENSE−20 libyaml/libyaml_src/api.c−1402 libyaml/libyaml_src/dumper.c−394 libyaml/libyaml_src/emitter.c−2324 libyaml/libyaml_src/loader.c−444 libyaml/libyaml_src/parser.c−1372 libyaml/libyaml_src/reader.c−469 libyaml/libyaml_src/scanner.c−3589 libyaml/libyaml_src/writer.c−141 libyaml/libyaml_src/yaml.h−1978 libyaml/libyaml_src/yaml_private.h−690 libyaml/package.yaml+6−17 libyaml/src/Text/Libyaml.hs+1−1 libyaml/vendor/libyaml−1 stack.yaml+4−1 yaml/package.yaml+1−1 yaml/src/Data/Yaml/Config.hs+6−1
.github/workflows/tests.yml+1−5
@@ -14,16 +14,12 @@ jobs:
1414 fail-fast: false
1515 matrix:
1616 os: [ubuntu-latest, macos-latest, windows-latest]
17− resolver: [nightly, lts-20, lts-15, lts-14, lts-12, lts-11]
17+ resolver: [nightly, lts-22, lts-20, lts-17]
1818 exclude:
1919 - os: windows-latest
2020 resolver: lts-15
2121 - os: windows-latest
2222 resolver: nightly
23− include:
24− - os: ubuntu-latest
25− resolver: lts-9
26− # problems on macOS and Windows (https://github.com/snoyberg/yaml/pull/216#issuecomment-1585522312)
2723
2824 steps:
2925 - name: Clone project
libyaml/ChangeLog.md+5
@@ -1,5 +1,10 @@
11# Changelog for libyaml
22
3+## 0.1.4
4+
5+* Use libyaml-clib for the cbits
6+* Use pkg-config to link to system yaml
7+
38## 0.1.3
49
510* Correct signature for `fclose`
libyaml/copy-libyaml.shdeleted−10
@@ -1,10 +0,0 @@
1−#!/usr/bin/env bash
2−
3−set -ex
4−
5−rm -rf libyaml_src
6−mkdir -p libyaml_src
7−cp vendor/libyaml/LICENSE libyaml_src
8−cp vendor/libyaml/src/*.c libyaml_src
9−cp vendor/libyaml/src/*.h libyaml_src
10−cp vendor/libyaml/include/*.h libyaml_src
libyaml/libyaml.cabal+6−20
@@ -1,13 +1,11 @@
11cabal-version: 1.12
22
3−-- This file has been generated from package.yaml by hpack version 0.35.1.
3+-- This file has been generated from package.yaml by hpack version 0.36.0.
44--
55-- see: https://github.com/sol/hpack
6−--
7−-- hash: a4a2ff005241200ba50deeae68beae02301af696425274c2ed0c3cb59b07d0ac
86
97name: libyaml
10−version: 0.1.3
8+version: 0.1.4
119synopsis: Low-level, streaming YAML interface.
1210description: README and API documentation are available at <https://www.stackage.org/package/libyaml>
1311category: Text
@@ -21,9 +19,6 @@ license-file: LICENSE
2119build-type: Simple
2220extra-source-files:
2321 include/helper.h
24− libyaml_src/yaml_private.h
25− libyaml_src/yaml.h
26− libyaml_src/LICENSE
2722 README.md
2823 ChangeLog.md
2924
@@ -62,20 +57,11 @@ library
6257 if flag(no-unicode)
6358 cpp-options: -D__NO_UNICODE__
6459 if !(flag(system-libyaml))
65− include-dirs:
66− libyaml_src
67− c-sources:
68− libyaml_src/api.c
69− libyaml_src/dumper.c
70− libyaml_src/emitter.c
71− libyaml_src/loader.c
72− libyaml_src/parser.c
73− libyaml_src/reader.c
74− libyaml_src/scanner.c
75− libyaml_src/writer.c
60+ build-depends:
61+ libyaml-clib
7662 else
77− extra-libraries:
78− yaml
63+ pkgconfig-depends:
64+ yaml-0.1
7965 if os(windows)
8066 cpp-options: -DWINDOWS
8167 build-depends:
libyaml/libyaml_src/LICENSEdeleted−20
@@ -1,20 +0,0 @@
1−Copyright (c) 2017-2019 Ingy döt Net
2−Copyright (c) 2006-2016 Kirill Simonov
3−
4−Permission is hereby granted, free of charge, to any person obtaining a copy of
5−this software and associated documentation files (the "Software"), to deal in
6−the Software without restriction, including without limitation the rights to
7−use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
8−of the Software, and to permit persons to whom the Software is furnished to do
9−so, subject to the following conditions:
10−
11−The above copyright notice and this permission notice shall be included in all
12−copies or substantial portions of the Software.
13−
14−THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15−IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16−FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17−AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18−LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19−OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20−SOFTWARE.
libyaml/libyaml_src/api.cdeleted−1402
@@ -1,1402 +0,0 @@
1−
2−#include "yaml_private.h"
3−
4−/*
5− * Get the library version.
6− */
7−
8−YAML_DECLARE(const char *)
9−yaml_get_version_string(void)
10−{
11− return YAML_VERSION_STRING;
12−}
13−
14−/*
15− * Get the library version numbers.
16− */
17−
18−YAML_DECLARE(void)
19−yaml_get_version(int *major, int *minor, int *patch)
20−{
21− *major = YAML_VERSION_MAJOR;
22− *minor = YAML_VERSION_MINOR;
23− *patch = YAML_VERSION_PATCH;
24−}
25−
26−/*
27− * Allocate a dynamic memory block.
28− */
29−
30−YAML_DECLARE(void *)
31−yaml_malloc(size_t size)
32−{
33− return malloc(size ? size : 1);
34−}
35−
36−/*
37− * Reallocate a dynamic memory block.
38− */
39−
40−YAML_DECLARE(void *)
41−yaml_realloc(void *ptr, size_t size)
42−{
43− return ptr ? realloc(ptr, size ? size : 1) : malloc(size ? size : 1);
44−}
45−
46−/*
47− * Free a dynamic memory block.
48− */
49−
50−YAML_DECLARE(void)
51−yaml_free(void *ptr)
52−{
53− if (ptr) free(ptr);
54−}
55−
56−/*
57− * Duplicate a string.
58− */
59−
60−YAML_DECLARE(yaml_char_t *)
61−yaml_strdup(const yaml_char_t *str)
62−{
63− if (!str)
64− return NULL;
65−
66−/*
67− * Haskell yaml package: added to support _WIN64
68− */
69−#if _WIN64
70− return (yaml_char_t *)_strdup((char *)str);
71−#else
72− return (yaml_char_t *)strdup((char *)str);
73−#endif
74−}
75−
76−/*
77− * Extend a string.
78− */
79−
80−YAML_DECLARE(int)
81−yaml_string_extend(yaml_char_t **start,
82− yaml_char_t **pointer, yaml_char_t **end)
83−{
84− yaml_char_t *new_start = (yaml_char_t *)yaml_realloc((void*)*start, (*end - *start)*2);
85−
86− if (!new_start) return 0;
87−
88− memset(new_start + (*end - *start), 0, *end - *start);
89−
90− *pointer = new_start + (*pointer - *start);
91− *end = new_start + (*end - *start)*2;
92− *start = new_start;
93−
94− return 1;
95−}
96−
97−/*
98− * Append a string B to a string A.
99− */
100−
101−YAML_DECLARE(int)
102−yaml_string_join(
103− yaml_char_t **a_start, yaml_char_t **a_pointer, yaml_char_t **a_end,
104− yaml_char_t **b_start, yaml_char_t **b_pointer, SHIM(yaml_char_t **b_end))
105−{
106− UNUSED_PARAM(b_end)
107− if (*b_start == *b_pointer)
108− return 1;
109−
110− while (*a_end - *a_pointer <= *b_pointer - *b_start) {
111− if (!yaml_string_extend(a_start, a_pointer, a_end))
112− return 0;
113− }
114−
115− memcpy(*a_pointer, *b_start, *b_pointer - *b_start);
116− *a_pointer += *b_pointer - *b_start;
117−
118− return 1;
119−}
120−
121−/*
122− * Extend a stack.
123− */
124−
125−YAML_DECLARE(int)
126−yaml_stack_extend(void **start, void **top, void **end)
127−{
128− void *new_start = yaml_realloc(*start, ((char *)*end - (char *)*start)*2);
129−
130− if (!new_start) return 0;
131−
132− *top = (char *)new_start + ((char *)*top - (char *)*start);
133− *end = (char *)new_start + ((char *)*end - (char *)*start)*2;
134− *start = new_start;
135−
136− return 1;
137−}
138−
139−/*
140− * Extend or move a queue.
141− */
142−
143−YAML_DECLARE(int)
144−yaml_queue_extend(void **start, void **head, void **tail, void **end)
145−{
146− /* Check if we need to resize the queue. */
147−
148− if (*start == *head && *tail == *end) {
149− void *new_start = yaml_realloc(*start,
150− ((char *)*end - (char *)*start)*2);
151−
152− if (!new_start) return 0;
153−
154− *head = (char *)new_start + ((char *)*head - (char *)*start);
155− *tail = (char *)new_start + ((char *)*tail - (char *)*start);
156− *end = (char *)new_start + ((char *)*end - (char *)*start)*2;
157− *start = new_start;
158− }
159−
160− /* Check if we need to move the queue at the beginning of the buffer. */
161−
162− if (*tail == *end) {
163− if (*head != *tail) {
164− memmove(*start, *head, (char *)*tail - (char *)*head);
165− }
166− *tail = (char *)*tail - (char *)*head + (char *)*start;
167− *head = *start;
168− }
169−
170− return 1;
171−}
172−
173−
174−/*
175− * Create a new parser object.
176− */
177−
178−YAML_DECLARE(int)
179−yaml_parser_initialize(yaml_parser_t *parser)
180−{
181− assert(parser); /* Non-NULL parser object expected. */
182−
183− memset(parser, 0, sizeof(yaml_parser_t));
184− if (!BUFFER_INIT(parser, parser->raw_buffer, INPUT_RAW_BUFFER_SIZE))
185− goto error;
186− if (!BUFFER_INIT(parser, parser->buffer, INPUT_BUFFER_SIZE))
187− goto error;
188− if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_SIZE, yaml_token_t*))
189− goto error;
190− if (!STACK_INIT(parser, parser->indents, int*))
191− goto error;
192− if (!STACK_INIT(parser, parser->simple_keys, yaml_simple_key_t*))
193− goto error;
194− if (!STACK_INIT(parser, parser->states, yaml_parser_state_t*))
195− goto error;
196− if (!STACK_INIT(parser, parser->marks, yaml_mark_t*))
197− goto error;
198− if (!STACK_INIT(parser, parser->tag_directives, yaml_tag_directive_t*))
199− goto error;
200−
201− return 1;
202−
203−error:
204−
205− BUFFER_DEL(parser, parser->raw_buffer);
206− BUFFER_DEL(parser, parser->buffer);
207− QUEUE_DEL(parser, parser->tokens);
208− STACK_DEL(parser, parser->indents);
209− STACK_DEL(parser, parser->simple_keys);
210− STACK_DEL(parser, parser->states);
211− STACK_DEL(parser, parser->marks);
212− STACK_DEL(parser, parser->tag_directives);
213−
214− return 0;
215−}
216−
217−/*
218− * Destroy a parser object.
219− */
220−
221−YAML_DECLARE(void)
222−yaml_parser_delete(yaml_parser_t *parser)
223−{
224− assert(parser); /* Non-NULL parser object expected. */
225−
226− BUFFER_DEL(parser, parser->raw_buffer);
227− BUFFER_DEL(parser, parser->buffer);
228− while (!QUEUE_EMPTY(parser, parser->tokens)) {
229− yaml_token_delete(&DEQUEUE(parser, parser->tokens));
230− }
231− QUEUE_DEL(parser, parser->tokens);
232− STACK_DEL(parser, parser->indents);
233− STACK_DEL(parser, parser->simple_keys);
234− STACK_DEL(parser, parser->states);
235− STACK_DEL(parser, parser->marks);
236− while (!STACK_EMPTY(parser, parser->tag_directives)) {
237− yaml_tag_directive_t tag_directive = POP(parser, parser->tag_directives);
238− yaml_free(tag_directive.handle);
239− yaml_free(tag_directive.prefix);
240− }
241− STACK_DEL(parser, parser->tag_directives);
242−
243− memset(parser, 0, sizeof(yaml_parser_t));
244−}
245−
246−/*
247− * String read handler.
248− */
249−
250−static int
251−yaml_string_read_handler(void *data, unsigned char *buffer, size_t size,
252− size_t *size_read)
253−{
254− yaml_parser_t *parser = (yaml_parser_t *)data;
255−
256− if (parser->input.string.current == parser->input.string.end) {
257− *size_read = 0;
258− return 1;
259− }
260−
261− if (size > (size_t)(parser->input.string.end
262− - parser->input.string.current)) {
263− size = parser->input.string.end - parser->input.string.current;
264− }
265−
266− memcpy(buffer, parser->input.string.current, size);
267− parser->input.string.current += size;
268− *size_read = size;
269− return 1;
270−}
271−
272−/*
273− * File read handler.
274− */
275−
276−static int
277−yaml_file_read_handler(void *data, unsigned char *buffer, size_t size,
278− size_t *size_read)
279−{
280− yaml_parser_t *parser = (yaml_parser_t *)data;
281−
282− *size_read = fread(buffer, 1, size, parser->input.file);
283− return !ferror(parser->input.file);
284−}
285−
286−/*
287− * Set a string input.
288− */
289−
290−YAML_DECLARE(void)
291−yaml_parser_set_input_string(yaml_parser_t *parser,
292− const unsigned char *input, size_t size)
293−{
294− assert(parser); /* Non-NULL parser object expected. */
295− assert(!parser->read_handler); /* You can set the source only once. */
296− assert(input); /* Non-NULL input string expected. */
297−
298− parser->read_handler = yaml_string_read_handler;
299− parser->read_handler_data = parser;
300−
301− parser->input.string.start = input;
302− parser->input.string.current = input;
303− parser->input.string.end = input+size;
304−}
305−
306−/*
307− * Set a file input.
308− */
309−
310−YAML_DECLARE(void)
311−yaml_parser_set_input_file(yaml_parser_t *parser, FILE *file)
312−{
313− assert(parser); /* Non-NULL parser object expected. */
314− assert(!parser->read_handler); /* You can set the source only once. */
315− assert(file); /* Non-NULL file object expected. */
316−
317− parser->read_handler = yaml_file_read_handler;
318− parser->read_handler_data = parser;
319−
320− parser->input.file = file;
321−}
322−
323−/*
324− * Set a generic input.
325− */
326−
327−YAML_DECLARE(void)
328−yaml_parser_set_input(yaml_parser_t *parser,
329− yaml_read_handler_t *handler, void *data)
330−{
331− assert(parser); /* Non-NULL parser object expected. */
332− assert(!parser->read_handler); /* You can set the source only once. */
333− assert(handler); /* Non-NULL read handler expected. */
334−
335− parser->read_handler = handler;
336− parser->read_handler_data = data;
337−}
338−
339−/*
340− * Set the source encoding.
341− */
342−
343−YAML_DECLARE(void)
344−yaml_parser_set_encoding(yaml_parser_t *parser, yaml_encoding_t encoding)
345−{
346− assert(parser); /* Non-NULL parser object expected. */
347− assert(!parser->encoding); /* Encoding is already set or detected. */
348−
349− parser->encoding = encoding;
350−}
351−
352−/*
353− * Create a new emitter object.
354− */
355−
356−YAML_DECLARE(int)
357−yaml_emitter_initialize(yaml_emitter_t *emitter)
358−{
359− assert(emitter); /* Non-NULL emitter object expected. */
360−
361− memset(emitter, 0, sizeof(yaml_emitter_t));
362− if (!BUFFER_INIT(emitter, emitter->buffer, OUTPUT_BUFFER_SIZE))
363− goto error;
364− if (!BUFFER_INIT(emitter, emitter->raw_buffer, OUTPUT_RAW_BUFFER_SIZE))
365− goto error;
366− if (!STACK_INIT(emitter, emitter->states, yaml_emitter_state_t*))
367− goto error;
368− if (!QUEUE_INIT(emitter, emitter->events, INITIAL_QUEUE_SIZE, yaml_event_t*))
369− goto error;
370− if (!STACK_INIT(emitter, emitter->indents, int*))
371− goto error;
372− if (!STACK_INIT(emitter, emitter->tag_directives, yaml_tag_directive_t*))
373− goto error;
374−
375− return 1;
376−
377−error:
378−
379− BUFFER_DEL(emitter, emitter->buffer);
380− BUFFER_DEL(emitter, emitter->raw_buffer);
381− STACK_DEL(emitter, emitter->states);
382− QUEUE_DEL(emitter, emitter->events);
383− STACK_DEL(emitter, emitter->indents);
384− STACK_DEL(emitter, emitter->tag_directives);
385−
386− return 0;
387−}
388−
389−/*
390− * Destroy an emitter object.
391− */
392−
393−YAML_DECLARE(void)
394−yaml_emitter_delete(yaml_emitter_t *emitter)
395−{
396− assert(emitter); /* Non-NULL emitter object expected. */
397−
398− BUFFER_DEL(emitter, emitter->buffer);
399− BUFFER_DEL(emitter, emitter->raw_buffer);
400− STACK_DEL(emitter, emitter->states);
401− while (!QUEUE_EMPTY(emitter, emitter->events)) {
402− yaml_event_delete(&DEQUEUE(emitter, emitter->events));
403− }
404− QUEUE_DEL(emitter, emitter->events);
405− STACK_DEL(emitter, emitter->indents);
406− while (!STACK_EMPTY(empty, emitter->tag_directives)) {
407− yaml_tag_directive_t tag_directive = POP(emitter, emitter->tag_directives);
408− yaml_free(tag_directive.handle);
409− yaml_free(tag_directive.prefix);
410− }
411− STACK_DEL(emitter, emitter->tag_directives);
412− yaml_free(emitter->anchors);
413−
414− memset(emitter, 0, sizeof(yaml_emitter_t));
415−}
416−
417−/*
418− * String write handler.
419− */
420−
421−static int
422−yaml_string_write_handler(void *data, unsigned char *buffer, size_t size)
423−{
424− yaml_emitter_t *emitter = (yaml_emitter_t *)data;
425−
426− if (emitter->output.string.size - *emitter->output.string.size_written
427− < size) {
428− memcpy(emitter->output.string.buffer
429− + *emitter->output.string.size_written,
430− buffer,
431− emitter->output.string.size
432− - *emitter->output.string.size_written);
433− *emitter->output.string.size_written = emitter->output.string.size;
434− return 0;
435− }
436−
437− memcpy(emitter->output.string.buffer
438− + *emitter->output.string.size_written, buffer, size);
439− *emitter->output.string.size_written += size;
440− return 1;
441−}
442−
443−/*
444− * File write handler.
445− */
446−
447−static int
448−yaml_file_write_handler(void *data, unsigned char *buffer, size_t size)
449−{
450− yaml_emitter_t *emitter = (yaml_emitter_t *)data;
451−
452− return (fwrite(buffer, 1, size, emitter->output.file) == size);
453−}
454−/*
455− * Set a string output.
456− */
457−
458−YAML_DECLARE(void)
459−yaml_emitter_set_output_string(yaml_emitter_t *emitter,
460− unsigned char *output, size_t size, size_t *size_written)
461−{
462− assert(emitter); /* Non-NULL emitter object expected. */
463− assert(!emitter->write_handler); /* You can set the output only once. */
464− assert(output); /* Non-NULL output string expected. */
465−
466− emitter->write_handler = yaml_string_write_handler;
467− emitter->write_handler_data = emitter;
468−
469− emitter->output.string.buffer = output;
470− emitter->output.string.size = size;
471− emitter->output.string.size_written = size_written;
472− *size_written = 0;
473−}
474−
475−/*
476− * Set a file output.
477− */
478−
479−YAML_DECLARE(void)
480−yaml_emitter_set_output_file(yaml_emitter_t *emitter, FILE *file)
481−{
482− assert(emitter); /* Non-NULL emitter object expected. */
483− assert(!emitter->write_handler); /* You can set the output only once. */
484− assert(file); /* Non-NULL file object expected. */
485−
486− emitter->write_handler = yaml_file_write_handler;
487− emitter->write_handler_data = emitter;
488−
489− emitter->output.file = file;
490−}
491−
492−/*
493− * Set a generic output handler.
494− */
495−
496−YAML_DECLARE(void)
497−yaml_emitter_set_output(yaml_emitter_t *emitter,
498− yaml_write_handler_t *handler, void *data)
499−{
500− assert(emitter); /* Non-NULL emitter object expected. */
501− assert(!emitter->write_handler); /* You can set the output only once. */
502− assert(handler); /* Non-NULL handler object expected. */
503−
504− emitter->write_handler = handler;
505− emitter->write_handler_data = data;
506−}
507−
508−/*
509− * Set the output encoding.
510− */
511−
512−YAML_DECLARE(void)
513−yaml_emitter_set_encoding(yaml_emitter_t *emitter, yaml_encoding_t encoding)
514−{
515− assert(emitter); /* Non-NULL emitter object expected. */
516− assert(!emitter->encoding); /* You can set encoding only once. */
517−
518− emitter->encoding = encoding;
519−}
520−
521−/*
522− * Set the canonical output style.
523− */
524−
525−YAML_DECLARE(void)
526−yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical)
527−{
528− assert(emitter); /* Non-NULL emitter object expected. */
529−
530− emitter->canonical = (canonical != 0);
531−}
532−
533−/*
534− * Set the indentation increment.
535− */
536−
537−YAML_DECLARE(void)
538−yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent)
539−{
540− assert(emitter); /* Non-NULL emitter object expected. */
541−
542− emitter->best_indent = (1 < indent && indent < 10) ? indent : 2;
543−}
544−
545−/*
546− * Set the preferred line width.
547− */
548−
549−YAML_DECLARE(void)
550−yaml_emitter_set_width(yaml_emitter_t *emitter, int width)
551−{
552− assert(emitter); /* Non-NULL emitter object expected. */
553−
554− emitter->best_width = (width >= 0) ? width : -1;
555−}
556−
557−/*
558− * Set if unescaped non-ASCII characters are allowed.
559− */
560−
561−YAML_DECLARE(void)
562−yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode)
563−{
564− assert(emitter); /* Non-NULL emitter object expected. */
565−
566− emitter->unicode = (unicode != 0);
567−}
568−
569−/*
570− * Set the preferred line break character.
571− */
572−
573−YAML_DECLARE(void)
574−yaml_emitter_set_break(yaml_emitter_t *emitter, yaml_break_t line_break)
575−{
576− assert(emitter); /* Non-NULL emitter object expected. */
577−
578− emitter->line_break = line_break;
579−}
580−
581−/*
582− * Destroy a token object.
583− */
584−
585−YAML_DECLARE(void)
586−yaml_token_delete(yaml_token_t *token)
587−{
588− assert(token); /* Non-NULL token object expected. */
589−
590− switch (token->type)
591− {
592− case YAML_TAG_DIRECTIVE_TOKEN:
593− yaml_free(token->data.tag_directive.handle);
594− yaml_free(token->data.tag_directive.prefix);
595− break;
596−
597− case YAML_ALIAS_TOKEN:
598− yaml_free(token->data.alias.value);
599− break;
600−
601− case YAML_ANCHOR_TOKEN:
602− yaml_free(token->data.anchor.value);
603− break;
604−
605− case YAML_TAG_TOKEN:
606− yaml_free(token->data.tag.handle);
607− yaml_free(token->data.tag.suffix);
608− break;
609−
610− case YAML_SCALAR_TOKEN:
611− yaml_free(token->data.scalar.value);
612− break;
613−
614− default:
615− break;
616− }
617−
618− memset(token, 0, sizeof(yaml_token_t));
619−}
620−
621−/*
622− * Check if a string is a valid UTF-8 sequence.
623− *
624− * Check 'reader.c' for more details on UTF-8 encoding.
625− */
626−
627−static int
628−yaml_check_utf8(yaml_char_t *start, size_t length)
629−{
630− yaml_char_t *end = start+length;
631− yaml_char_t *pointer = start;
632−
633− while (pointer < end) {
634− unsigned char octet;
635− unsigned int width;
636− unsigned int value;
637− size_t k;
638−
639− octet = pointer[0];
640− width = (octet & 0x80) == 0x00 ? 1 :
641− (octet & 0xE0) == 0xC0 ? 2 :
642− (octet & 0xF0) == 0xE0 ? 3 :
643− (octet & 0xF8) == 0xF0 ? 4 : 0;
644− value = (octet & 0x80) == 0x00 ? octet & 0x7F :
645− (octet & 0xE0) == 0xC0 ? octet & 0x1F :
646− (octet & 0xF0) == 0xE0 ? octet & 0x0F :
647− (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
648− if (!width) return 0;
649− if (pointer+width > end) return 0;
650− for (k = 1; k < width; k ++) {
651− octet = pointer[k];
652− if ((octet & 0xC0) != 0x80) return 0;
653− value = (value << 6) + (octet & 0x3F);
654− }
655− if (!((width == 1) ||
656− (width == 2 && value >= 0x80) ||
657− (width == 3 && value >= 0x800) ||
658− (width == 4 && value >= 0x10000))) return 0;
659−
660− pointer += width;
661− }
662−
663− return 1;
664−}
665−
666−/*
667− * Create STREAM-START.
668− */
669−
670−YAML_DECLARE(int)
671−yaml_stream_start_event_initialize(yaml_event_t *event,
672− yaml_encoding_t encoding)
673−{
674− yaml_mark_t mark = { 0, 0, 0 };
675−
676− assert(event); /* Non-NULL event object is expected. */
677−
678− STREAM_START_EVENT_INIT(*event, encoding, mark, mark);
679−
680− return 1;
681−}
682−
683−/*
684− * Create STREAM-END.
685− */
686−
687−YAML_DECLARE(int)
688−yaml_stream_end_event_initialize(yaml_event_t *event)
689−{
690− yaml_mark_t mark = { 0, 0, 0 };
691−
692− assert(event); /* Non-NULL event object is expected. */
693−
694− STREAM_END_EVENT_INIT(*event, mark, mark);
695−
696− return 1;
697−}
698−
699−/*
700− * Create DOCUMENT-START.
701− */
702−
703−YAML_DECLARE(int)
704−yaml_document_start_event_initialize(yaml_event_t *event,
705− yaml_version_directive_t *version_directive,
706− yaml_tag_directive_t *tag_directives_start,
707− yaml_tag_directive_t *tag_directives_end,
708− int implicit)
709−{
710− struct {
711− yaml_error_type_t error;
712− } context;
713− yaml_mark_t mark = { 0, 0, 0 };
714− yaml_version_directive_t *version_directive_copy = NULL;
715− struct {
716− yaml_tag_directive_t *start;
717− yaml_tag_directive_t *end;
718− yaml_tag_directive_t *top;
719− } tag_directives_copy = { NULL, NULL, NULL };
720− yaml_tag_directive_t value = { NULL, NULL };
721−
722− assert(event); /* Non-NULL event object is expected. */
723− assert((tag_directives_start && tag_directives_end) ||
724− (tag_directives_start == tag_directives_end));
725− /* Valid tag directives are expected. */
726−
727− if (version_directive) {
728− version_directive_copy = YAML_MALLOC_STATIC(yaml_version_directive_t);
729− if (!version_directive_copy) goto error;
730− version_directive_copy->major = version_directive->major;
731− version_directive_copy->minor = version_directive->minor;
732− }
733−
734− if (tag_directives_start != tag_directives_end) {
735− yaml_tag_directive_t *tag_directive;
736− if (!STACK_INIT(&context, tag_directives_copy, yaml_tag_directive_t*))
737− goto error;
738− for (tag_directive = tag_directives_start;
739− tag_directive != tag_directives_end; tag_directive ++) {
740− assert(tag_directive->handle);
741− assert(tag_directive->prefix);
742− if (!yaml_check_utf8(tag_directive->handle,
743− strlen((char *)tag_directive->handle)))
744− goto error;
745− if (!yaml_check_utf8(tag_directive->prefix,
746− strlen((char *)tag_directive->prefix)))
747− goto error;
748− value.handle = yaml_strdup(tag_directive->handle);
749− value.prefix = yaml_strdup(tag_directive->prefix);
750− if (!value.handle || !value.prefix) goto error;
751− if (!PUSH(&context, tag_directives_copy, value))
752− goto error;
753− value.handle = NULL;
754− value.prefix = NULL;
755− }
756− }
757−
758− DOCUMENT_START_EVENT_INIT(*event, version_directive_copy,
759− tag_directives_copy.start, tag_directives_copy.top,
760− implicit, mark, mark);
761−
762− return 1;
763−
764−error:
765− yaml_free(version_directive_copy);
766− while (!STACK_EMPTY(context, tag_directives_copy)) {
767− yaml_tag_directive_t value = POP(context, tag_directives_copy);
768− yaml_free(value.handle);
769− yaml_free(value.prefix);
770− }
771− STACK_DEL(context, tag_directives_copy);
772− yaml_free(value.handle);
773− yaml_free(value.prefix);
774−
775− return 0;
776−}
777−
778−/*
779− * Create DOCUMENT-END.
780− */
781−
782−YAML_DECLARE(int)
783−yaml_document_end_event_initialize(yaml_event_t *event, int implicit)
784−{
785− yaml_mark_t mark = { 0, 0, 0 };
786−
787− assert(event); /* Non-NULL emitter object is expected. */
788−
789− DOCUMENT_END_EVENT_INIT(*event, implicit, mark, mark);
790−
791− return 1;
792−}
793−
794−/*
795− * Create ALIAS.
796− */
797−
798−YAML_DECLARE(int)
799−yaml_alias_event_initialize(yaml_event_t *event, yaml_char_t *anchor)
800−{
801− yaml_mark_t mark = { 0, 0, 0 };
802− yaml_char_t *anchor_copy = NULL;
803−
804− assert(event); /* Non-NULL event object is expected. */
805− assert(anchor); /* Non-NULL anchor is expected. */
806−
807− if (!yaml_check_utf8(anchor, strlen((char *)anchor))) return 0;
808−
809− anchor_copy = yaml_strdup(anchor);
810− if (!anchor_copy)
811− return 0;
812−
813− ALIAS_EVENT_INIT(*event, anchor_copy, mark, mark);
814−
815− return 1;
816−}
817−
818−/*
819− * Create SCALAR.
820− */
821−
822−YAML_DECLARE(int)
823−yaml_scalar_event_initialize(yaml_event_t *event,
824− yaml_char_t *anchor, yaml_char_t *tag,
825− yaml_char_t *value, int length,
826− int plain_implicit, int quoted_implicit,
827− yaml_scalar_style_t style)
828−{
829− yaml_mark_t mark = { 0, 0, 0 };
830− yaml_char_t *anchor_copy = NULL;
831− yaml_char_t *tag_copy = NULL;
832− yaml_char_t *value_copy = NULL;
833−
834− assert(event); /* Non-NULL event object is expected. */
835− /* following line added for Haskell yaml library */
836− if (!value && !length) value = (unsigned char*)"";
837− assert(value); /* Non-NULL anchor is expected. */
838−
839− if (anchor) {
840− if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
841− anchor_copy = yaml_strdup(anchor);
842− if (!anchor_copy) goto error;
843− }
844−
845− if (tag) {
846− if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
847− tag_copy = yaml_strdup(tag);
848− if (!tag_copy) goto error;
849− }
850−
851− if (length < 0) {
852− length = strlen((char *)value);
853− }
854−
855− if (!yaml_check_utf8(value, length)) goto error;
856− value_copy = YAML_MALLOC(length+1);
857− if (!value_copy) goto error;
858− memcpy(value_copy, value, length);
859− value_copy[length] = '\0';
860−
861− SCALAR_EVENT_INIT(*event, anchor_copy, tag_copy, value_copy, length,
862− plain_implicit, quoted_implicit, style, mark, mark);
863−
864− return 1;
865−
866−error:
867− yaml_free(anchor_copy);
868− yaml_free(tag_copy);
869− yaml_free(value_copy);
870−
871− return 0;
872−}
873−
874−/*
875− * Create SEQUENCE-START.
876− */
877−
878−YAML_DECLARE(int)
879−yaml_sequence_start_event_initialize(yaml_event_t *event,
880− yaml_char_t *anchor, yaml_char_t *tag, int implicit,
881− yaml_sequence_style_t style)
882−{
883− yaml_mark_t mark = { 0, 0, 0 };
884− yaml_char_t *anchor_copy = NULL;
885− yaml_char_t *tag_copy = NULL;
886−
887− assert(event); /* Non-NULL event object is expected. */
888−
889− if (anchor) {
890− if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
891− anchor_copy = yaml_strdup(anchor);
892− if (!anchor_copy) goto error;
893− }
894−
895− if (tag) {
896− if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
897− tag_copy = yaml_strdup(tag);
898− if (!tag_copy) goto error;
899− }
900−
901− SEQUENCE_START_EVENT_INIT(*event, anchor_copy, tag_copy,
902− implicit, style, mark, mark);
903−
904− return 1;
905−
906−error:
907− yaml_free(anchor_copy);
908− yaml_free(tag_copy);
909−
910− return 0;
911−}
912−
913−/*
914− * Create SEQUENCE-END.
915− */
916−
917−YAML_DECLARE(int)
918−yaml_sequence_end_event_initialize(yaml_event_t *event)
919−{
920− yaml_mark_t mark = { 0, 0, 0 };
921−
922− assert(event); /* Non-NULL event object is expected. */
923−
924− SEQUENCE_END_EVENT_INIT(*event, mark, mark);
925−
926− return 1;
927−}
928−
929−/*
930− * Create MAPPING-START.
931− */
932−
933−YAML_DECLARE(int)
934−yaml_mapping_start_event_initialize(yaml_event_t *event,
935− yaml_char_t *anchor, yaml_char_t *tag, int implicit,
936− yaml_mapping_style_t style)
937−{
938− yaml_mark_t mark = { 0, 0, 0 };
939− yaml_char_t *anchor_copy = NULL;
940− yaml_char_t *tag_copy = NULL;
941−
942− assert(event); /* Non-NULL event object is expected. */
943−
944− if (anchor) {
945− if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
946− anchor_copy = yaml_strdup(anchor);
947− if (!anchor_copy) goto error;
948− }
949−
950− if (tag) {
951− if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
952− tag_copy = yaml_strdup(tag);
953− if (!tag_copy) goto error;
954− }
955−
956− MAPPING_START_EVENT_INIT(*event, anchor_copy, tag_copy,
957− implicit, style, mark, mark);
958−
959− return 1;
960−
961−error:
962− yaml_free(anchor_copy);
963− yaml_free(tag_copy);
964−
965− return 0;
966−}
967−
968−/*
969− * Create MAPPING-END.
970− */
971−
972−YAML_DECLARE(int)
973−yaml_mapping_end_event_initialize(yaml_event_t *event)
974−{
975− yaml_mark_t mark = { 0, 0, 0 };
976−
977− assert(event); /* Non-NULL event object is expected. */
978−
979− MAPPING_END_EVENT_INIT(*event, mark, mark);
980−
981− return 1;
982−}
983−
984−/*
985− * Destroy an event object.
986− */
987−
988−YAML_DECLARE(void)
989−yaml_event_delete(yaml_event_t *event)
990−{
991− yaml_tag_directive_t *tag_directive;
992−
993− assert(event); /* Non-NULL event object expected. */
994−
995− switch (event->type)
996− {
997− case YAML_DOCUMENT_START_EVENT:
998− yaml_free(event->data.document_start.version_directive);
999− for (tag_directive = event->data.document_start.tag_directives.start;
1000− tag_directive != event->data.document_start.tag_directives.end;
1001− tag_directive++) {
1002− yaml_free(tag_directive->handle);
1003− yaml_free(tag_directive->prefix);
1004− }
1005− yaml_free(event->data.document_start.tag_directives.start);
1006− break;
1007−
1008− case YAML_ALIAS_EVENT:
1009− yaml_free(event->data.alias.anchor);
1010− break;
1011−
1012− case YAML_SCALAR_EVENT:
1013− yaml_free(event->data.scalar.anchor);
1014− yaml_free(event->data.scalar.tag);
1015− yaml_free(event->data.scalar.value);
1016− break;
1017−
1018− case YAML_SEQUENCE_START_EVENT:
1019− yaml_free(event->data.sequence_start.anchor);
1020− yaml_free(event->data.sequence_start.tag);
1021− break;
1022−
1023− case YAML_MAPPING_START_EVENT:
1024− yaml_free(event->data.mapping_start.anchor);
1025− yaml_free(event->data.mapping_start.tag);
1026− break;
1027−
1028− default:
1029− break;
1030− }
1031−
1032− memset(event, 0, sizeof(yaml_event_t));
1033−}
1034−
1035−/*
1036− * Create a document object.
1037− */
1038−
1039−YAML_DECLARE(int)
1040−yaml_document_initialize(yaml_document_t *document,
1041− yaml_version_directive_t *version_directive,
1042− yaml_tag_directive_t *tag_directives_start,
1043− yaml_tag_directive_t *tag_directives_end,
1044− int start_implicit, int end_implicit)
1045−{
1046− struct {
1047− yaml_error_type_t error;
1048− } context;
1049− struct {
1050− yaml_node_t *start;
1051− yaml_node_t *end;
1052− yaml_node_t *top;
1053− } nodes = { NULL, NULL, NULL };
1054− yaml_version_directive_t *version_directive_copy = NULL;
1055− struct {
1056− yaml_tag_directive_t *start;
1057− yaml_tag_directive_t *end;
1058− yaml_tag_directive_t *top;
1059− } tag_directives_copy = { NULL, NULL, NULL };
1060− yaml_tag_directive_t value = { NULL, NULL };
1061− yaml_mark_t mark = { 0, 0, 0 };
1062−
1063− assert(document); /* Non-NULL document object is expected. */
1064− assert((tag_directives_start && tag_directives_end) ||
1065− (tag_directives_start == tag_directives_end));
1066− /* Valid tag directives are expected. */
1067−
1068− if (!STACK_INIT(&context, nodes, yaml_node_t*)) goto error;
1069−
1070− if (version_directive) {
1071− version_directive_copy = YAML_MALLOC_STATIC(yaml_version_directive_t);
1072− if (!version_directive_copy) goto error;
1073− version_directive_copy->major = version_directive->major;
1074− version_directive_copy->minor = version_directive->minor;
1075− }
1076−
1077− if (tag_directives_start != tag_directives_end) {
1078− yaml_tag_directive_t *tag_directive;
1079− if (!STACK_INIT(&context, tag_directives_copy, yaml_tag_directive_t*))
1080− goto error;
1081− for (tag_directive = tag_directives_start;
1082− tag_directive != tag_directives_end; tag_directive ++) {
1083− assert(tag_directive->handle);
1084− assert(tag_directive->prefix);
1085− if (!yaml_check_utf8(tag_directive->handle,
1086− strlen((char *)tag_directive->handle)))
1087− goto error;
1088− if (!yaml_check_utf8(tag_directive->prefix,
1089− strlen((char *)tag_directive->prefix)))
1090− goto error;
1091− value.handle = yaml_strdup(tag_directive->handle);
1092− value.prefix = yaml_strdup(tag_directive->prefix);
1093− if (!value.handle || !value.prefix) goto error;
1094− if (!PUSH(&context, tag_directives_copy, value))
1095− goto error;
1096− value.handle = NULL;
1097− value.prefix = NULL;
1098− }
1099− }
1100−
1101− DOCUMENT_INIT(*document, nodes.start, nodes.end, version_directive_copy,
1102− tag_directives_copy.start, tag_directives_copy.top,
1103− start_implicit, end_implicit, mark, mark);
1104−
1105− return 1;
1106−
1107−error:
1108− STACK_DEL(&context, nodes);
1109− yaml_free(version_directive_copy);
1110− while (!STACK_EMPTY(&context, tag_directives_copy)) {
1111− yaml_tag_directive_t value = POP(&context, tag_directives_copy);
1112− yaml_free(value.handle);
1113− yaml_free(value.prefix);
1114− }
1115− STACK_DEL(&context, tag_directives_copy);
1116− yaml_free(value.handle);
1117− yaml_free(value.prefix);
1118−
1119− return 0;
1120−}
1121−
1122−/*
1123− * Destroy a document object.
1124− */
1125−
1126−YAML_DECLARE(void)
1127−yaml_document_delete(yaml_document_t *document)
1128−{
1129− struct {
1130− yaml_error_type_t error;
1131− } context;
1132− yaml_tag_directive_t *tag_directive;
1133−
1134− context.error = YAML_NO_ERROR; /* Eliminate a compliler warning. */
1135−
1136− assert(document); /* Non-NULL document object is expected. */
1137−
1138− while (!STACK_EMPTY(&context, document->nodes)) {
1139− yaml_node_t node = POP(&context, document->nodes);
1140− yaml_free(node.tag);
1141− switch (node.type) {
1142− case YAML_SCALAR_NODE:
1143− yaml_free(node.data.scalar.value);
1144− break;
1145− case YAML_SEQUENCE_NODE:
1146− STACK_DEL(&context, node.data.sequence.items);
1147− break;
1148− case YAML_MAPPING_NODE:
1149− STACK_DEL(&context, node.data.mapping.pairs);
1150− break;
1151− default:
1152− assert(0); /* Should not happen. */
1153− }
1154− }
1155− STACK_DEL(&context, document->nodes);
1156−
1157− yaml_free(document->version_directive);
1158− for (tag_directive = document->tag_directives.start;
1159− tag_directive != document->tag_directives.end;
1160− tag_directive++) {
1161− yaml_free(tag_directive->handle);
1162− yaml_free(tag_directive->prefix);
1163− }
1164− yaml_free(document->tag_directives.start);
1165−
1166− memset(document, 0, sizeof(yaml_document_t));
1167−}
1168−
1169−/**
1170− * Get a document node.
1171− */
1172−
1173−YAML_DECLARE(yaml_node_t *)
1174−yaml_document_get_node(yaml_document_t *document, int index)
1175−{
1176− assert(document); /* Non-NULL document object is expected. */
1177−
1178− if (index > 0 && document->nodes.start + index <= document->nodes.top) {
1179− return document->nodes.start + index - 1;
1180− }
1181− return NULL;
1182−}
1183−
1184−/**
1185− * Get the root object.
1186− */
1187−
1188−YAML_DECLARE(yaml_node_t *)
1189−yaml_document_get_root_node(yaml_document_t *document)
1190−{
1191− assert(document); /* Non-NULL document object is expected. */
1192−
1193− if (document->nodes.top != document->nodes.start) {
1194− return document->nodes.start;
1195− }
1196− return NULL;
1197−}
1198−
1199−/*
1200− * Add a scalar node to a document.
1201− */
1202−
1203−YAML_DECLARE(int)
1204−yaml_document_add_scalar(yaml_document_t *document,
1205− yaml_char_t *tag, yaml_char_t *value, int length,
1206− yaml_scalar_style_t style)
1207−{
1208− struct {
1209− yaml_error_type_t error;
1210− } context;
1211− yaml_mark_t mark = { 0, 0, 0 };
1212− yaml_char_t *tag_copy = NULL;
1213− yaml_char_t *value_copy = NULL;
1214− yaml_node_t node;
1215−
1216− assert(document); /* Non-NULL document object is expected. */
1217− assert(value); /* Non-NULL value is expected. */
1218−
1219− if (!tag) {
1220− tag = (yaml_char_t *)YAML_DEFAULT_SCALAR_TAG;
1221− }
1222−
1223− if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
1224− tag_copy = yaml_strdup(tag);
1225− if (!tag_copy) goto error;
1226−
1227− if (length < 0) {
1228− length = strlen((char *)value);
1229− }
1230−
1231− if (!yaml_check_utf8(value, length)) goto error;
1232− value_copy = YAML_MALLOC(length+1);
1233− if (!value_copy) goto error;
1234− memcpy(value_copy, value, length);
1235− value_copy[length] = '\0';
1236−
1237− SCALAR_NODE_INIT(node, tag_copy, value_copy, length, style, mark, mark);
1238− if (!PUSH(&context, document->nodes, node)) goto error;
1239−
1240− return document->nodes.top - document->nodes.start;
1241−
1242−error:
1243− yaml_free(tag_copy);
1244− yaml_free(value_copy);
1245−
1246− return 0;
1247−}
1248−
1249−/*
1250− * Add a sequence node to a document.
1251− */
1252−
1253−YAML_DECLARE(int)
1254−yaml_document_add_sequence(yaml_document_t *document,
1255− yaml_char_t *tag, yaml_sequence_style_t style)
1256−{
1257− struct {
1258− yaml_error_type_t error;
1259− } context;
1260− yaml_mark_t mark = { 0, 0, 0 };
1261− yaml_char_t *tag_copy = NULL;
1262− struct {
1263− yaml_node_item_t *start;
1264− yaml_node_item_t *end;
1265− yaml_node_item_t *top;
1266− } items = { NULL, NULL, NULL };
1267− yaml_node_t node;
1268−
1269− assert(document); /* Non-NULL document object is expected. */
1270−
1271− if (!tag) {
1272− tag = (yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG;
1273− }
1274−
1275− if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
1276− tag_copy = yaml_strdup(tag);
1277− if (!tag_copy) goto error;
1278−
1279− if (!STACK_INIT(&context, items, yaml_node_item_t*)) goto error;
1280−
1281− SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end,
1282− style, mark, mark);
1283− if (!PUSH(&context, document->nodes, node)) goto error;
1284−
1285− return document->nodes.top - document->nodes.start;
1286−
1287−error:
1288− STACK_DEL(&context, items);
1289− yaml_free(tag_copy);
1290−
1291− return 0;
1292−}
1293−
1294−/*
1295− * Add a mapping node to a document.
1296− */
1297−
1298−YAML_DECLARE(int)
1299−yaml_document_add_mapping(yaml_document_t *document,
1300− yaml_char_t *tag, yaml_mapping_style_t style)
1301−{
1302− struct {
1303− yaml_error_type_t error;
1304− } context;
1305− yaml_mark_t mark = { 0, 0, 0 };
1306− yaml_char_t *tag_copy = NULL;
1307− struct {
1308− yaml_node_pair_t *start;
1309− yaml_node_pair_t *end;
1310− yaml_node_pair_t *top;
1311− } pairs = { NULL, NULL, NULL };
1312− yaml_node_t node;
1313−
1314− assert(document); /* Non-NULL document object is expected. */
1315−
1316− if (!tag) {
1317− tag = (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG;
1318− }
1319−
1320− if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
1321− tag_copy = yaml_strdup(tag);
1322− if (!tag_copy) goto error;
1323−
1324− if (!STACK_INIT(&context, pairs, yaml_node_pair_t*)) goto error;
1325−
1326− MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end,
1327− style, mark, mark);
1328− if (!PUSH(&context, document->nodes, node)) goto error;
1329−
1330− return document->nodes.top - document->nodes.start;
1331−
1332−error:
1333− STACK_DEL(&context, pairs);
1334− yaml_free(tag_copy);
1335−
1336− return 0;
1337−}
1338−
1339−/*
1340− * Append an item to a sequence node.
1341− */
1342−
1343−YAML_DECLARE(int)
1344−yaml_document_append_sequence_item(yaml_document_t *document,
1345− int sequence, int item)
1346−{
1347− struct {
1348− yaml_error_type_t error;
1349− } context;
1350−
1351− assert(document); /* Non-NULL document is required. */
1352− assert(sequence > 0
1353− && document->nodes.start + sequence <= document->nodes.top);
1354− /* Valid sequence id is required. */
1355− assert(document->nodes.start[sequence-1].type == YAML_SEQUENCE_NODE);
1356− /* A sequence node is required. */
1357− assert(item > 0 && document->nodes.start + item <= document->nodes.top);
1358− /* Valid item id is required. */
1359−
1360− if (!PUSH(&context,
1361− document->nodes.start[sequence-1].data.sequence.items, item))
1362− return 0;
1363−
1364− return 1;
1365−}
1366−
1367−/*
1368− * Append a pair of a key and a value to a mapping node.
1369− */
1370−
1371−YAML_DECLARE(int)
1372−yaml_document_append_mapping_pair(yaml_document_t *document,
1373− int mapping, int key, int value)
1374−{
1375− struct {
1376− yaml_error_type_t error;
1377− } context;
1378−
1379− yaml_node_pair_t pair;
1380−
1381− assert(document); /* Non-NULL document is required. */
1382− assert(mapping > 0
1383− && document->nodes.start + mapping <= document->nodes.top);
1384− /* Valid mapping id is required. */
1385− assert(document->nodes.start[mapping-1].type == YAML_MAPPING_NODE);
1386− /* A mapping node is required. */
1387− assert(key > 0 && document->nodes.start + key <= document->nodes.top);
1388− /* Valid key id is required. */
1389− assert(value > 0 && document->nodes.start + value <= document->nodes.top);
1390− /* Valid value id is required. */
1391−
1392− pair.key = key;
1393− pair.value = value;
1394−
1395− if (!PUSH(&context,
1396− document->nodes.start[mapping-1].data.mapping.pairs, pair))
1397− return 0;
1398−
1399− return 1;
1400−}
1401−
1402−
libyaml/libyaml_src/dumper.cdeleted−394
@@ -1,394 +0,0 @@
1−
2−#include "yaml_private.h"
3−
4−/*
5− * API functions.
6− */
7−
8−YAML_DECLARE(int)
9−yaml_emitter_open(yaml_emitter_t *emitter);
10−
11−YAML_DECLARE(int)
12−yaml_emitter_close(yaml_emitter_t *emitter);
13−
14−YAML_DECLARE(int)
15−yaml_emitter_dump(yaml_emitter_t *emitter, yaml_document_t *document);
16−
17−/*
18− * Clean up functions.
19− */
20−
21−static void
22−yaml_emitter_delete_document_and_anchors(yaml_emitter_t *emitter);
23−
24−/*
25− * Anchor functions.
26− */
27−
28−static void
29−yaml_emitter_anchor_node(yaml_emitter_t *emitter, int index);
30−
31−static yaml_char_t *
32−yaml_emitter_generate_anchor(yaml_emitter_t *emitter, int anchor_id);
33−
34−
35−/*
36− * Serialize functions.
37− */
38−
39−static int
40−yaml_emitter_dump_node(yaml_emitter_t *emitter, int index);
41−
42−static int
43−yaml_emitter_dump_alias(yaml_emitter_t *emitter, yaml_char_t *anchor);
44−
45−static int
46−yaml_emitter_dump_scalar(yaml_emitter_t *emitter, yaml_node_t *node,
47− yaml_char_t *anchor);
48−
49−static int
50−yaml_emitter_dump_sequence(yaml_emitter_t *emitter, yaml_node_t *node,
51− yaml_char_t *anchor);
52−
53−static int
54−yaml_emitter_dump_mapping(yaml_emitter_t *emitter, yaml_node_t *node,
55− yaml_char_t *anchor);
56−
57−/*
58− * Issue a STREAM-START event.
59− */
60−
61−YAML_DECLARE(int)
62−yaml_emitter_open(yaml_emitter_t *emitter)
63−{
64− yaml_event_t event;
65− yaml_mark_t mark = { 0, 0, 0 };
66−
67− assert(emitter); /* Non-NULL emitter object is required. */
68− assert(!emitter->opened); /* Emitter should not be opened yet. */
69−
70− STREAM_START_EVENT_INIT(event, YAML_ANY_ENCODING, mark, mark);
71−
72− if (!yaml_emitter_emit(emitter, &event)) {
73− return 0;
74− }
75−
76− emitter->opened = 1;
77−
78− return 1;
79−}
80−
81−/*
82− * Issue a STREAM-END event.
83− */
84−
85−YAML_DECLARE(int)
86−yaml_emitter_close(yaml_emitter_t *emitter)
87−{
88− yaml_event_t event;
89− yaml_mark_t mark = { 0, 0, 0 };
90−
91− assert(emitter); /* Non-NULL emitter object is required. */
92− assert(emitter->opened); /* Emitter should be opened. */
93−
94− if (emitter->closed) return 1;
95−
96− STREAM_END_EVENT_INIT(event, mark, mark);
97−
98− if (!yaml_emitter_emit(emitter, &event)) {
99− return 0;
100− }
101−
102− emitter->closed = 1;
103−
104− return 1;
105−}
106−
107−/*
108− * Dump a YAML document.
109− */
110−
111−YAML_DECLARE(int)
112−yaml_emitter_dump(yaml_emitter_t *emitter, yaml_document_t *document)
113−{
114− yaml_event_t event;
115− yaml_mark_t mark = { 0, 0, 0 };
116−
117− assert(emitter); /* Non-NULL emitter object is required. */
118− assert(document); /* Non-NULL emitter object is expected. */
119−
120− emitter->document = document;
121−
122− if (!emitter->opened) {
123− if (!yaml_emitter_open(emitter)) goto error;
124− }
125−
126− if (STACK_EMPTY(emitter, document->nodes)) {
127− if (!yaml_emitter_close(emitter)) goto error;
128− yaml_emitter_delete_document_and_anchors(emitter);
129− return 1;
130− }
131−
132− assert(emitter->opened); /* Emitter should be opened. */
133−
134− emitter->anchors = (yaml_anchors_t*)yaml_malloc(sizeof(*(emitter->anchors))
135− * (document->nodes.top - document->nodes.start));
136− if (!emitter->anchors) goto error;
137− memset(emitter->anchors, 0, sizeof(*(emitter->anchors))
138− * (document->nodes.top - document->nodes.start));
139−
140− DOCUMENT_START_EVENT_INIT(event, document->version_directive,
141− document->tag_directives.start, document->tag_directives.end,
142− document->start_implicit, mark, mark);
143− if (!yaml_emitter_emit(emitter, &event)) goto error;
144−
145− yaml_emitter_anchor_node(emitter, 1);
146− if (!yaml_emitter_dump_node(emitter, 1)) goto error;
147−
148− DOCUMENT_END_EVENT_INIT(event, document->end_implicit, mark, mark);
149− if (!yaml_emitter_emit(emitter, &event)) goto error;
150−
151− yaml_emitter_delete_document_and_anchors(emitter);
152−
153− return 1;
154−
155−error:
156−
157− yaml_emitter_delete_document_and_anchors(emitter);
158−
159− return 0;
160−}
161−
162−/*
163− * Clean up the emitter object after a document is dumped.
164− */
165−
166−static void
167−yaml_emitter_delete_document_and_anchors(yaml_emitter_t *emitter)
168−{
169− int index;
170−
171− if (!emitter->anchors) {
172− yaml_document_delete(emitter->document);
173− emitter->document = NULL;
174− return;
175− }
176−
177− for (index = 0; emitter->document->nodes.start + index
178− < emitter->document->nodes.top; index ++) {
179− yaml_node_t node = emitter->document->nodes.start[index];
180− if (!emitter->anchors[index].serialized) {
181− yaml_free(node.tag);
182− if (node.type == YAML_SCALAR_NODE) {
183− yaml_free(node.data.scalar.value);
184− }
185− }
186− if (node.type == YAML_SEQUENCE_NODE) {
187− STACK_DEL(emitter, node.data.sequence.items);
188− }
189− if (node.type == YAML_MAPPING_NODE) {
190− STACK_DEL(emitter, node.data.mapping.pairs);
191− }
192− }
193−
194− STACK_DEL(emitter, emitter->document->nodes);
195− yaml_free(emitter->anchors);
196−
197− emitter->anchors = NULL;
198− emitter->last_anchor_id = 0;
199− emitter->document = NULL;
200−}
201−
202−/*
203− * Check the references of a node and assign the anchor id if needed.
204− */
205−
206−static void
207−yaml_emitter_anchor_node(yaml_emitter_t *emitter, int index)
208−{
209− yaml_node_t *node = emitter->document->nodes.start + index - 1;
210− yaml_node_item_t *item;
211− yaml_node_pair_t *pair;
212−
213− emitter->anchors[index-1].references ++;
214−
215− if (emitter->anchors[index-1].references == 1) {
216− switch (node->type) {
217− case YAML_SEQUENCE_NODE:
218− for (item = node->data.sequence.items.start;
219− item < node->data.sequence.items.top; item ++) {
220− yaml_emitter_anchor_node(emitter, *item);
221− }
222− break;
223− case YAML_MAPPING_NODE:
224− for (pair = node->data.mapping.pairs.start;
225− pair < node->data.mapping.pairs.top; pair ++) {
226− yaml_emitter_anchor_node(emitter, pair->key);
227− yaml_emitter_anchor_node(emitter, pair->value);
228− }
229− break;
230− default:
231− break;
232− }
233− }
234−
235− else if (emitter->anchors[index-1].references == 2) {
236− emitter->anchors[index-1].anchor = (++ emitter->last_anchor_id);
237− }
238−}
239−
240−/*
241− * Generate a textual representation for an anchor.
242− */
243−
244−#define ANCHOR_TEMPLATE "id%03d"
245−#define ANCHOR_TEMPLATE_LENGTH 16
246−
247−static yaml_char_t *
248−yaml_emitter_generate_anchor(SHIM(yaml_emitter_t *emitter), int anchor_id)
249−{
250− yaml_char_t *anchor = YAML_MALLOC(ANCHOR_TEMPLATE_LENGTH);
251−
252− if (!anchor) return NULL;
253−
254− sprintf((char *)anchor, ANCHOR_TEMPLATE, anchor_id);
255−
256− return anchor;
257−}
258−
259−/*
260− * Serialize a node.
261− */
262−
263−static int
264−yaml_emitter_dump_node(yaml_emitter_t *emitter, int index)
265−{
266− yaml_node_t *node = emitter->document->nodes.start + index - 1;
267− int anchor_id = emitter->anchors[index-1].anchor;
268− yaml_char_t *anchor = NULL;
269−
270− if (anchor_id) {
271− anchor = yaml_emitter_generate_anchor(emitter, anchor_id);
272− if (!anchor) return 0;
273− }
274−
275− if (emitter->anchors[index-1].serialized) {
276− return yaml_emitter_dump_alias(emitter, anchor);
277− }
278−
279− emitter->anchors[index-1].serialized = 1;
280−
281− switch (node->type) {
282− case YAML_SCALAR_NODE:
283− return yaml_emitter_dump_scalar(emitter, node, anchor);
284− case YAML_SEQUENCE_NODE:
285− return yaml_emitter_dump_sequence(emitter, node, anchor);
286− case YAML_MAPPING_NODE:
287− return yaml_emitter_dump_mapping(emitter, node, anchor);
288− default:
289− assert(0); /* Could not happen. */
290− break;
291− }
292−
293− return 0; /* Could not happen. */
294−}
295−
296−/*
297− * Serialize an alias.
298− */
299−
300−static int
301−yaml_emitter_dump_alias(yaml_emitter_t *emitter, yaml_char_t *anchor)
302−{
303− yaml_event_t event;
304− yaml_mark_t mark = { 0, 0, 0 };
305−
306− ALIAS_EVENT_INIT(event, anchor, mark, mark);
307−
308− return yaml_emitter_emit(emitter, &event);
309−}
310−
311−/*
312− * Serialize a scalar.
313− */
314−
315−static int
316−yaml_emitter_dump_scalar(yaml_emitter_t *emitter, yaml_node_t *node,
317− yaml_char_t *anchor)
318−{
319− yaml_event_t event;
320− yaml_mark_t mark = { 0, 0, 0 };
321−
322− int plain_implicit = (strcmp((char *)node->tag,
323− YAML_DEFAULT_SCALAR_TAG) == 0);
324− int quoted_implicit = (strcmp((char *)node->tag,
325− YAML_DEFAULT_SCALAR_TAG) == 0);
326−
327− SCALAR_EVENT_INIT(event, anchor, node->tag, node->data.scalar.value,
328− node->data.scalar.length, plain_implicit, quoted_implicit,
329− node->data.scalar.style, mark, mark);
330−
331− return yaml_emitter_emit(emitter, &event);
332−}
333−
334−/*
335− * Serialize a sequence.
336− */
337−
338−static int
339−yaml_emitter_dump_sequence(yaml_emitter_t *emitter, yaml_node_t *node,
340− yaml_char_t *anchor)
341−{
342− yaml_event_t event;
343− yaml_mark_t mark = { 0, 0, 0 };
344−
345− int implicit = (strcmp((char *)node->tag, YAML_DEFAULT_SEQUENCE_TAG) == 0);
346−
347− yaml_node_item_t *item;
348−
349− SEQUENCE_START_EVENT_INIT(event, anchor, node->tag, implicit,
350− node->data.sequence.style, mark, mark);
351− if (!yaml_emitter_emit(emitter, &event)) return 0;
352−
353− for (item = node->data.sequence.items.start;
354− item < node->data.sequence.items.top; item ++) {
355− if (!yaml_emitter_dump_node(emitter, *item)) return 0;
356− }
357−
358− SEQUENCE_END_EVENT_INIT(event, mark, mark);
359− if (!yaml_emitter_emit(emitter, &event)) return 0;
360−
361− return 1;
362−}
363−
364−/*
365− * Serialize a mapping.
366− */
367−
368−static int
369−yaml_emitter_dump_mapping(yaml_emitter_t *emitter, yaml_node_t *node,
370− yaml_char_t *anchor)
371−{
372− yaml_event_t event;
373− yaml_mark_t mark = { 0, 0, 0 };
374−
375− int implicit = (strcmp((char *)node->tag, YAML_DEFAULT_MAPPING_TAG) == 0);
376−
377− yaml_node_pair_t *pair;
378−
379− MAPPING_START_EVENT_INIT(event, anchor, node->tag, implicit,
380− node->data.mapping.style, mark, mark);
381− if (!yaml_emitter_emit(emitter, &event)) return 0;
382−
383− for (pair = node->data.mapping.pairs.start;
384− pair < node->data.mapping.pairs.top; pair ++) {
385− if (!yaml_emitter_dump_node(emitter, pair->key)) return 0;
386− if (!yaml_emitter_dump_node(emitter, pair->value)) return 0;
387− }
388−
389− MAPPING_END_EVENT_INIT(event, mark, mark);
390− if (!yaml_emitter_emit(emitter, &event)) return 0;
391−
392− return 1;
393−}
394−
libyaml/libyaml_src/emitter.cdeleted−2324
@@ -1,2324 +0,0 @@
1−
2−#include "yaml_private.h"
3−
4−/*
5− * Flush the buffer if needed.
6− */
7−
8−#define FLUSH(emitter) \
9− ((emitter->buffer.pointer+5 < emitter->buffer.end) \
10− || yaml_emitter_flush(emitter))
11−
12−/*
13− * Put a character to the output buffer.
14− */
15−
16−#define PUT(emitter,value) \
17− (FLUSH(emitter) \
18− && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \
19− emitter->column++, \
20− 1))
21−
22−/*
23− * Put a line break to the output buffer.
24− */
25−
26−#define PUT_BREAK(emitter) \
27− (FLUSH(emitter) \
28− && ((emitter->line_break == YAML_CR_BREAK ? \
29− (*(emitter->buffer.pointer++) = (yaml_char_t) '\r') : \
30− emitter->line_break == YAML_LN_BREAK ? \
31− (*(emitter->buffer.pointer++) = (yaml_char_t) '\n') : \
32− emitter->line_break == YAML_CRLN_BREAK ? \
33− (*(emitter->buffer.pointer++) = (yaml_char_t) '\r', \
34− *(emitter->buffer.pointer++) = (yaml_char_t) '\n') : 0), \
35− emitter->column = 0, \
36− emitter->line ++, \
37− 1))
38−
39−/*
40− * Copy a character from a string into buffer.
41− */
42−
43−#define WRITE(emitter,string) \
44− (FLUSH(emitter) \
45− && (COPY(emitter->buffer,string), \
46− emitter->column ++, \
47− 1))
48−
49−/*
50− * Copy a line break character from a string into buffer.
51− */
52−
53−#define WRITE_BREAK(emitter,string) \
54− (FLUSH(emitter) \
55− && (CHECK(string,'\n') ? \
56− (PUT_BREAK(emitter), \
57− string.pointer ++, \
58− 1) : \
59− (COPY(emitter->buffer,string), \
60− emitter->column = 0, \
61− emitter->line ++, \
62− 1)))
63−
64−/*
65− * API functions.
66− */
67−
68−YAML_DECLARE(int)
69−yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event);
70−
71−/*
72− * Utility functions.
73− */
74−
75−static int
76−yaml_emitter_set_emitter_error(yaml_emitter_t *emitter, const char *problem);
77−
78−static int
79−yaml_emitter_need_more_events(yaml_emitter_t *emitter);
80−
81−static int
82−yaml_emitter_append_tag_directive(yaml_emitter_t *emitter,
83− yaml_tag_directive_t value, int allow_duplicates);
84−
85−static int
86−yaml_emitter_increase_indent(yaml_emitter_t *emitter,
87− int flow, int indentless);
88−
89−/*
90− * State functions.
91− */
92−
93−static int
94−yaml_emitter_state_machine(yaml_emitter_t *emitter, yaml_event_t *event);
95−
96−static int
97−yaml_emitter_emit_stream_start(yaml_emitter_t *emitter,
98− yaml_event_t *event);
99−
100−static int
101−yaml_emitter_emit_document_start(yaml_emitter_t *emitter,
102− yaml_event_t *event, int first);
103−
104−static int
105−yaml_emitter_emit_document_content(yaml_emitter_t *emitter,
106− yaml_event_t *event);
107−
108−static int
109−yaml_emitter_emit_document_end(yaml_emitter_t *emitter,
110− yaml_event_t *event);
111−
112−static int
113−yaml_emitter_emit_flow_sequence_item(yaml_emitter_t *emitter,
114− yaml_event_t *event, int first);
115−
116−static int
117−yaml_emitter_emit_flow_mapping_key(yaml_emitter_t *emitter,
118− yaml_event_t *event, int first);
119−
120−static int
121−yaml_emitter_emit_flow_mapping_value(yaml_emitter_t *emitter,
122− yaml_event_t *event, int simple);
123−
124−static int
125−yaml_emitter_emit_block_sequence_item(yaml_emitter_t *emitter,
126− yaml_event_t *event, int first);
127−
128−static int
129−yaml_emitter_emit_block_mapping_key(yaml_emitter_t *emitter,
130− yaml_event_t *event, int first);
131−
132−static int
133−yaml_emitter_emit_block_mapping_value(yaml_emitter_t *emitter,
134− yaml_event_t *event, int simple);
135−
136−static int
137−yaml_emitter_emit_node(yaml_emitter_t *emitter, yaml_event_t *event,
138− int root, int sequence, int mapping, int simple_key);
139−
140−static int
141−yaml_emitter_emit_alias(yaml_emitter_t *emitter, yaml_event_t *event);
142−
143−static int
144−yaml_emitter_emit_scalar(yaml_emitter_t *emitter, yaml_event_t *event);
145−
146−static int
147−yaml_emitter_emit_sequence_start(yaml_emitter_t *emitter, yaml_event_t *event);
148−
149−static int
150−yaml_emitter_emit_mapping_start(yaml_emitter_t *emitter, yaml_event_t *event);
151−
152−/*
153− * Checkers.
154− */
155−
156−static int
157−yaml_emitter_check_empty_document(yaml_emitter_t *emitter);
158−
159−static int
160−yaml_emitter_check_empty_sequence(yaml_emitter_t *emitter);
161−
162−static int
163−yaml_emitter_check_empty_mapping(yaml_emitter_t *emitter);
164−
165−static int
166−yaml_emitter_check_simple_key(yaml_emitter_t *emitter);
167−
168−static int
169−yaml_emitter_select_scalar_style(yaml_emitter_t *emitter, yaml_event_t *event);
170−
171−/*
172− * Processors.
173− */
174−
175−static int
176−yaml_emitter_process_anchor(yaml_emitter_t *emitter);
177−
178−static int
179−yaml_emitter_process_tag(yaml_emitter_t *emitter);
180−
181−static int
182−yaml_emitter_process_scalar(yaml_emitter_t *emitter);
183−
184−/*
185− * Analyzers.
186− */
187−
188−static int
189−yaml_emitter_analyze_version_directive(yaml_emitter_t *emitter,
190− yaml_version_directive_t version_directive);
191−
192−static int
193−yaml_emitter_analyze_tag_directive(yaml_emitter_t *emitter,
194− yaml_tag_directive_t tag_directive);
195−
196−static int
197−yaml_emitter_analyze_anchor(yaml_emitter_t *emitter,
198− yaml_char_t *anchor, int alias);
199−
200−static int
201−yaml_emitter_analyze_tag(yaml_emitter_t *emitter,
202− yaml_char_t *tag);
203−
204−static int
205−yaml_emitter_analyze_scalar(yaml_emitter_t *emitter,
206− yaml_char_t *value, size_t length);
207−
208−static int
209−yaml_emitter_analyze_event(yaml_emitter_t *emitter,
210− yaml_event_t *event);
211−
212−/*
213− * Writers.
214− */
215−
216−static int
217−yaml_emitter_write_bom(yaml_emitter_t *emitter);
218−
219−static int
220−yaml_emitter_write_indent(yaml_emitter_t *emitter);
221−
222−static int
223−yaml_emitter_write_indicator(yaml_emitter_t *emitter,
224− const char *indicator, int need_whitespace,
225− int is_whitespace, int is_indention);
226−
227−static int
228−yaml_emitter_write_anchor(yaml_emitter_t *emitter,
229− yaml_char_t *value, size_t length);
230−
231−static int
232−yaml_emitter_write_tag_handle(yaml_emitter_t *emitter,
233− yaml_char_t *value, size_t length);
234−
235−static int
236−yaml_emitter_write_tag_content(yaml_emitter_t *emitter,
237− yaml_char_t *value, size_t length, int need_whitespace);
238−
239−static int
240−yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter,
241− yaml_char_t *value, size_t length, int allow_breaks);
242−
243−static int
244−yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter,
245− yaml_char_t *value, size_t length, int allow_breaks);
246−
247−static int
248−yaml_emitter_write_double_quoted_scalar(yaml_emitter_t *emitter,
249− yaml_char_t *value, size_t length, int allow_breaks);
250−
251−static int
252−yaml_emitter_write_block_scalar_hints(yaml_emitter_t *emitter,
253− yaml_string_t string);
254−
255−static int
256−yaml_emitter_write_literal_scalar(yaml_emitter_t *emitter,
257− yaml_char_t *value, size_t length);
258−
259−static int
260−yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter,
261− yaml_char_t *value, size_t length);
262−
263−/*
264− * Set an emitter error and return 0.
265− */
266−
267−static int
268−yaml_emitter_set_emitter_error(yaml_emitter_t *emitter, const char *problem)
269−{
270− emitter->error = YAML_EMITTER_ERROR;
271− emitter->problem = problem;
272−
273− return 0;
274−}
275−
276−/*
277− * Emit an event.
278− */
279−
280−YAML_DECLARE(int)
281−yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event)
282−{
283− if (!ENQUEUE(emitter, emitter->events, *event)) {
284− yaml_event_delete(event);
285− return 0;
286− }
287−
288− while (!yaml_emitter_need_more_events(emitter)) {
289− if (!yaml_emitter_analyze_event(emitter, emitter->events.head))
290− return 0;
291− if (!yaml_emitter_state_machine(emitter, emitter->events.head))
292− return 0;
293− yaml_event_delete(&DEQUEUE(emitter, emitter->events));
294− }
295−
296− return 1;
297−}
298−
299−/*
300− * Check if we need to accumulate more events before emitting.
301− *
302− * We accumulate extra
303− * - 1 event for DOCUMENT-START
304− * - 2 events for SEQUENCE-START
305− * - 3 events for MAPPING-START
306− */
307−
308−static int
309−yaml_emitter_need_more_events(yaml_emitter_t *emitter)
310−{
311− int level = 0;
312− int accumulate = 0;
313− yaml_event_t *event;
314−
315− if (QUEUE_EMPTY(emitter, emitter->events))
316− return 1;
317−
318− switch (emitter->events.head->type) {
319− case YAML_DOCUMENT_START_EVENT:
320− accumulate = 1;
321− break;
322− case YAML_SEQUENCE_START_EVENT:
323− accumulate = 2;
324− break;
325− case YAML_MAPPING_START_EVENT:
326− accumulate = 3;
327− break;
328− default:
329− return 0;
330− }
331−
332− if (emitter->events.tail - emitter->events.head > accumulate)
333− return 0;
334−
335− for (event = emitter->events.head; event != emitter->events.tail; event ++) {
336− switch (event->type) {
337− case YAML_STREAM_START_EVENT:
338− case YAML_DOCUMENT_START_EVENT:
339− case YAML_SEQUENCE_START_EVENT:
340− case YAML_MAPPING_START_EVENT:
341− level += 1;
342− break;
343− case YAML_STREAM_END_EVENT:
344− case YAML_DOCUMENT_END_EVENT:
345− case YAML_SEQUENCE_END_EVENT:
346− case YAML_MAPPING_END_EVENT:
347− level -= 1;
348− break;
349− default:
350− break;
351− }
352− if (!level)
353− return 0;
354− }
355−
356− return 1;
357−}
358−
359−/*
360− * Append a directive to the directives stack.
361− */
362−
363−static int
364−yaml_emitter_append_tag_directive(yaml_emitter_t *emitter,
365− yaml_tag_directive_t value, int allow_duplicates)
366−{
367− yaml_tag_directive_t *tag_directive;
368− yaml_tag_directive_t copy = { NULL, NULL };
369−
370− for (tag_directive = emitter->tag_directives.start;
371− tag_directive != emitter->tag_directives.top; tag_directive ++) {
372− if (strcmp((char *)value.handle, (char *)tag_directive->handle) == 0) {
373− if (allow_duplicates)
374− return 1;
375− return yaml_emitter_set_emitter_error(emitter,
376− "duplicate %TAG directive");
377− }
378− }
379−
380− copy.handle = yaml_strdup(value.handle);
381− copy.prefix = yaml_strdup(value.prefix);
382− if (!copy.handle || !copy.prefix) {
383− emitter->error = YAML_MEMORY_ERROR;
384− goto error;
385− }
386−
387− if (!PUSH(emitter, emitter->tag_directives, copy))
388− goto error;
389−
390− return 1;
391−
392−error:
393− yaml_free(copy.handle);
394− yaml_free(copy.prefix);
395− return 0;
396−}
397−
398−/*
399− * Increase the indentation level.
400− */
401−
402−static int
403−yaml_emitter_increase_indent(yaml_emitter_t *emitter,
404− int flow, int indentless)
405−{
406− if (!PUSH(emitter, emitter->indents, emitter->indent))
407− return 0;
408−
409− if (emitter->indent < 0) {
410− emitter->indent = flow ? emitter->best_indent : 0;
411− }
412− else if (!indentless) {
413− emitter->indent += emitter->best_indent;
414− }
415−
416− return 1;
417−}
418−
419−/*
420− * State dispatcher.
421− */
422−
423−static int
424−yaml_emitter_state_machine(yaml_emitter_t *emitter, yaml_event_t *event)
425−{
426− switch (emitter->state)
427− {
428− case YAML_EMIT_STREAM_START_STATE:
429− return yaml_emitter_emit_stream_start(emitter, event);
430−
431− case YAML_EMIT_FIRST_DOCUMENT_START_STATE:
432− return yaml_emitter_emit_document_start(emitter, event, 1);
433−
434− case YAML_EMIT_DOCUMENT_START_STATE:
435− return yaml_emitter_emit_document_start(emitter, event, 0);
436−
437− case YAML_EMIT_DOCUMENT_CONTENT_STATE:
438− return yaml_emitter_emit_document_content(emitter, event);
439−
440− case YAML_EMIT_DOCUMENT_END_STATE:
441− return yaml_emitter_emit_document_end(emitter, event);
442−
443− case YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE:
444− return yaml_emitter_emit_flow_sequence_item(emitter, event, 1);
445−
446− case YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE:
447− return yaml_emitter_emit_flow_sequence_item(emitter, event, 0);
448−
449− case YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE:
450− return yaml_emitter_emit_flow_mapping_key(emitter, event, 1);
451−
452− case YAML_EMIT_FLOW_MAPPING_KEY_STATE:
453− return yaml_emitter_emit_flow_mapping_key(emitter, event, 0);
454−
455− case YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE:
456− return yaml_emitter_emit_flow_mapping_value(emitter, event, 1);
457−
458− case YAML_EMIT_FLOW_MAPPING_VALUE_STATE:
459− return yaml_emitter_emit_flow_mapping_value(emitter, event, 0);
460−
461− case YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE:
462− return yaml_emitter_emit_block_sequence_item(emitter, event, 1);
463−
464− case YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE:
465− return yaml_emitter_emit_block_sequence_item(emitter, event, 0);
466−
467− case YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE:
468− return yaml_emitter_emit_block_mapping_key(emitter, event, 1);
469−
470− case YAML_EMIT_BLOCK_MAPPING_KEY_STATE:
471− return yaml_emitter_emit_block_mapping_key(emitter, event, 0);
472−
473− case YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE:
474− return yaml_emitter_emit_block_mapping_value(emitter, event, 1);
475−
476− case YAML_EMIT_BLOCK_MAPPING_VALUE_STATE:
477− return yaml_emitter_emit_block_mapping_value(emitter, event, 0);
478−
479− case YAML_EMIT_END_STATE:
480− return yaml_emitter_set_emitter_error(emitter,
481− "expected nothing after STREAM-END");
482−
483− default:
484− assert(1); /* Invalid state. */
485− }
486−
487− return 0;
488−}
489−
490−/*
491− * Expect STREAM-START.
492− */
493−
494−static int
495−yaml_emitter_emit_stream_start(yaml_emitter_t *emitter,
496− yaml_event_t *event)
497−{
498− if (event->type == YAML_STREAM_START_EVENT)
499− {
500− if (!emitter->encoding) {
501− emitter->encoding = event->data.stream_start.encoding;
502− }
503−
504− if (!emitter->encoding) {
505− emitter->encoding = YAML_UTF8_ENCODING;
506− }
507−
508− if (emitter->best_indent < 2 || emitter->best_indent > 9) {
509− emitter->best_indent = 2;
510− }
511−
512− if (emitter->best_width >= 0
513− && emitter->best_width <= emitter->best_indent*2) {
514− emitter->best_width = 80;
515− }
516−
517− if (emitter->best_width < 0) {
518− emitter->best_width = INT_MAX;
519− }
520−
521− if (!emitter->line_break) {
522− emitter->line_break = YAML_LN_BREAK;
523− }
524−
525− emitter->indent = -1;
526−
527− emitter->line = 0;
528− emitter->column = 0;
529− emitter->whitespace = 1;
530− emitter->indention = 1;
531−
532− if (emitter->encoding != YAML_UTF8_ENCODING) {
533− if (!yaml_emitter_write_bom(emitter))
534− return 0;
535− }
536−
537− emitter->state = YAML_EMIT_FIRST_DOCUMENT_START_STATE;
538−
539− return 1;
540− }
541−
542− return yaml_emitter_set_emitter_error(emitter,
543− "expected STREAM-START");
544−}
545−
546−/*
547− * Expect DOCUMENT-START or STREAM-END.
548− */
549−
550−static int
551−yaml_emitter_emit_document_start(yaml_emitter_t *emitter,
552− yaml_event_t *event, int first)
553−{
554− if (event->type == YAML_DOCUMENT_START_EVENT)
555− {
556− yaml_tag_directive_t default_tag_directives[] = {
557− {(yaml_char_t *)"!", (yaml_char_t *)"!"},
558− {(yaml_char_t *)"!!", (yaml_char_t *)"tag:yaml.org,2002:"},
559− {NULL, NULL}
560− };
561− yaml_tag_directive_t *tag_directive;
562− int implicit;
563−
564− if (event->data.document_start.version_directive) {
565− if (!yaml_emitter_analyze_version_directive(emitter,
566− *event->data.document_start.version_directive))
567− return 0;
568− }
569−
570− for (tag_directive = event->data.document_start.tag_directives.start;
571− tag_directive != event->data.document_start.tag_directives.end;
572− tag_directive ++) {
573− if (!yaml_emitter_analyze_tag_directive(emitter, *tag_directive))
574− return 0;
575− if (!yaml_emitter_append_tag_directive(emitter, *tag_directive, 0))
576− return 0;
577− }
578−
579− for (tag_directive = default_tag_directives;
580− tag_directive->handle; tag_directive ++) {
581− if (!yaml_emitter_append_tag_directive(emitter, *tag_directive, 1))
582− return 0;
583− }
584−
585− implicit = event->data.document_start.implicit;
586− if (!first || emitter->canonical) {
587− implicit = 0;
588− }
589−
590− if ((event->data.document_start.version_directive ||
591− (event->data.document_start.tag_directives.start
592− != event->data.document_start.tag_directives.end)) &&
593− emitter->open_ended)
594− {
595− if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0))
596− return 0;
597− if (!yaml_emitter_write_indent(emitter))
598− return 0;
599− }
600−
601− if (event->data.document_start.version_directive) {
602− implicit = 0;
603− if (!yaml_emitter_write_indicator(emitter, "%YAML", 1, 0, 0))
604− return 0;
605− if (!yaml_emitter_write_indicator(emitter, "1.1", 1, 0, 0))
606− return 0;
607− if (!yaml_emitter_write_indent(emitter))
608− return 0;
609− }
610−
611− if (event->data.document_start.tag_directives.start
612− != event->data.document_start.tag_directives.end) {
613− implicit = 0;
614− for (tag_directive = event->data.document_start.tag_directives.start;
615− tag_directive != event->data.document_start.tag_directives.end;
616− tag_directive ++) {
617− if (!yaml_emitter_write_indicator(emitter, "%TAG", 1, 0, 0))
618− return 0;
619− if (!yaml_emitter_write_tag_handle(emitter, tag_directive->handle,
620− strlen((char *)tag_directive->handle)))
621− return 0;
622− if (!yaml_emitter_write_tag_content(emitter, tag_directive->prefix,
623− strlen((char *)tag_directive->prefix), 1))
624− return 0;
625− if (!yaml_emitter_write_indent(emitter))
626− return 0;
627− }
628− }
629−
630− if (yaml_emitter_check_empty_document(emitter)) {
631− implicit = 0;
632− }
633−
634− if (!implicit) {
635− if (!yaml_emitter_write_indent(emitter))
636− return 0;
637− if (!yaml_emitter_write_indicator(emitter, "---", 1, 0, 0))
638− return 0;
639− if (emitter->canonical) {
640− if (!yaml_emitter_write_indent(emitter))
641− return 0;
642− }
643− }
644−
645− emitter->state = YAML_EMIT_DOCUMENT_CONTENT_STATE;
646−
647− return 1;
648− }
649−
650− else if (event->type == YAML_STREAM_END_EVENT)
651− {
652−
653− if (!yaml_emitter_flush(emitter))
654− return 0;
655−
656− emitter->state = YAML_EMIT_END_STATE;
657−
658− return 1;
659− }
660−
661− return yaml_emitter_set_emitter_error(emitter,
662− "expected DOCUMENT-START or STREAM-END");
663−}
664−
665−/*
666− * Expect the root node.
667− */
668−
669−static int
670−yaml_emitter_emit_document_content(yaml_emitter_t *emitter,
671− yaml_event_t *event)
672−{
673− if (!PUSH(emitter, emitter->states, YAML_EMIT_DOCUMENT_END_STATE))
674− return 0;
675−
676− return yaml_emitter_emit_node(emitter, event, 1, 0, 0, 0);
677−}
678−
679−/*
680− * Expect DOCUMENT-END.
681− */
682−
683−static int
684−yaml_emitter_emit_document_end(yaml_emitter_t *emitter,
685− yaml_event_t *event)
686−{
687− if (event->type == YAML_DOCUMENT_END_EVENT)
688− {
689− if (!yaml_emitter_write_indent(emitter))
690− return 0;
691− if (!event->data.document_end.implicit) {
692− if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0))
693− return 0;
694− if (!yaml_emitter_write_indent(emitter))
695− return 0;
696− }
697− if (!yaml_emitter_flush(emitter))
698− return 0;
699−
700− emitter->state = YAML_EMIT_DOCUMENT_START_STATE;
701−
702− while (!STACK_EMPTY(emitter, emitter->tag_directives)) {
703− yaml_tag_directive_t tag_directive = POP(emitter,
704− emitter->tag_directives);
705− yaml_free(tag_directive.handle);
706− yaml_free(tag_directive.prefix);
707− }
708−
709− return 1;
710− }
711−
712− return yaml_emitter_set_emitter_error(emitter,
713− "expected DOCUMENT-END");
714−}
715−
716−/*
717− *
718− * Expect a flow item node.
719− */
720−
721−static int
722−yaml_emitter_emit_flow_sequence_item(yaml_emitter_t *emitter,
723− yaml_event_t *event, int first)
724−{
725− if (first)
726− {
727− if (!yaml_emitter_write_indicator(emitter, "[", 1, 1, 0))
728− return 0;
729− if (!yaml_emitter_increase_indent(emitter, 1, 0))
730− return 0;
731− emitter->flow_level ++;
732− }
733−
734− if (event->type == YAML_SEQUENCE_END_EVENT)
735− {
736− emitter->flow_level --;
737− emitter->indent = POP(emitter, emitter->indents);
738− if (emitter->canonical && !first) {
739− if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0))
740− return 0;
741− if (!yaml_emitter_write_indent(emitter))
742− return 0;
743− }
744− if (!yaml_emitter_write_indicator(emitter, "]", 0, 0, 0))
745− return 0;
746− emitter->state = POP(emitter, emitter->states);
747−
748− return 1;
749− }
750−
751− if (!first) {
752− if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0))
753− return 0;
754− }
755−
756− if (emitter->canonical || emitter->column > emitter->best_width) {
757− if (!yaml_emitter_write_indent(emitter))
758− return 0;
759− }
760− if (!PUSH(emitter, emitter->states, YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE))
761− return 0;
762−
763− return yaml_emitter_emit_node(emitter, event, 0, 1, 0, 0);
764−}
765−
766−/*
767− * Expect a flow key node.
768− */
769−
770−static int
771−yaml_emitter_emit_flow_mapping_key(yaml_emitter_t *emitter,
772− yaml_event_t *event, int first)
773−{
774− if (first)
775− {
776− if (!yaml_emitter_write_indicator(emitter, "{", 1, 1, 0))
777− return 0;
778− if (!yaml_emitter_increase_indent(emitter, 1, 0))
779− return 0;
780− emitter->flow_level ++;
781− }
782−
783− if (event->type == YAML_MAPPING_END_EVENT)
784− {
785− emitter->flow_level --;
786− emitter->indent = POP(emitter, emitter->indents);
787− if (emitter->canonical && !first) {
788− if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0))
789− return 0;
790− if (!yaml_emitter_write_indent(emitter))
791− return 0;
792− }
793− if (!yaml_emitter_write_indicator(emitter, "}", 0, 0, 0))
794− return 0;
795− emitter->state = POP(emitter, emitter->states);
796−
797− return 1;
798− }
799−
800− if (!first) {
801− if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0))
802− return 0;
803− }
804− if (emitter->canonical || emitter->column > emitter->best_width) {
805− if (!yaml_emitter_write_indent(emitter))
806− return 0;
807− }
808−
809− if (!emitter->canonical && yaml_emitter_check_simple_key(emitter))
810− {
811− if (!PUSH(emitter, emitter->states,
812− YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE))
813− return 0;
814−
815− return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 1);
816− }
817− else
818− {
819− if (!yaml_emitter_write_indicator(emitter, "?", 1, 0, 0))
820− return 0;
821− if (!PUSH(emitter, emitter->states,
822− YAML_EMIT_FLOW_MAPPING_VALUE_STATE))
823− return 0;
824−
825− return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0);
826− }
827−}
828−
829−/*
830− * Expect a flow value node.
831− */
832−
833−static int
834−yaml_emitter_emit_flow_mapping_value(yaml_emitter_t *emitter,
835− yaml_event_t *event, int simple)
836−{
837− if (simple) {
838− if (!yaml_emitter_write_indicator(emitter, ":", 0, 0, 0))
839− return 0;
840− }
841− else {
842− if (emitter->canonical || emitter->column > emitter->best_width) {
843− if (!yaml_emitter_write_indent(emitter))
844− return 0;
845− }
846− if (!yaml_emitter_write_indicator(emitter, ":", 1, 0, 0))
847− return 0;
848− }
849− if (!PUSH(emitter, emitter->states, YAML_EMIT_FLOW_MAPPING_KEY_STATE))
850− return 0;
851− return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0);
852−}
853−
854−/*
855− * Expect a block item node.
856− */
857−
858−static int
859−yaml_emitter_emit_block_sequence_item(yaml_emitter_t *emitter,
860− yaml_event_t *event, int first)
861−{
862− if (first)
863− {
864− if (!yaml_emitter_increase_indent(emitter, 0,
865− (emitter->mapping_context && !emitter->indention)))
866− return 0;
867− }
868−
869− if (event->type == YAML_SEQUENCE_END_EVENT)
870− {
871− emitter->indent = POP(emitter, emitter->indents);
872− emitter->state = POP(emitter, emitter->states);
873−
874− return 1;
875− }
876−
877− if (!yaml_emitter_write_indent(emitter))
878− return 0;
879− if (!yaml_emitter_write_indicator(emitter, "-", 1, 0, 1))
880− return 0;
881− if (!PUSH(emitter, emitter->states,
882− YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE))
883− return 0;
884−
885− return yaml_emitter_emit_node(emitter, event, 0, 1, 0, 0);
886−}
887−
888−/*
889− * Expect a block key node.
890− */
891−
892−static int
893−yaml_emitter_emit_block_mapping_key(yaml_emitter_t *emitter,
894− yaml_event_t *event, int first)
895−{
896− if (first)
897− {
898− if (!yaml_emitter_increase_indent(emitter, 0, 0))
899− return 0;
900− }
901−
902− if (event->type == YAML_MAPPING_END_EVENT)
903− {
904− emitter->indent = POP(emitter, emitter->indents);
905− emitter->state = POP(emitter, emitter->states);
906−
907− return 1;
908− }
909−
910− if (!yaml_emitter_write_indent(emitter))
911− return 0;
912−
913− if (yaml_emitter_check_simple_key(emitter))
914− {
915− if (!PUSH(emitter, emitter->states,
916− YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE))
917− return 0;
918−
919− return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 1);
920− }
921− else
922− {
923− if (!yaml_emitter_write_indicator(emitter, "?", 1, 0, 1))
924− return 0;
925− if (!PUSH(emitter, emitter->states,
926− YAML_EMIT_BLOCK_MAPPING_VALUE_STATE))
927− return 0;
928−
929− return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0);
930− }
931−}
932−
933−/*
934− * Expect a block value node.
935− */
936−
937−static int
938−yaml_emitter_emit_block_mapping_value(yaml_emitter_t *emitter,
939− yaml_event_t *event, int simple)
940−{
941− if (simple) {
942− if (!yaml_emitter_write_indicator(emitter, ":", 0, 0, 0))
943− return 0;
944− }
945− else {
946− if (!yaml_emitter_write_indent(emitter))
947− return 0;
948− if (!yaml_emitter_write_indicator(emitter, ":", 1, 0, 1))
949− return 0;
950− }
951− if (!PUSH(emitter, emitter->states,
952− YAML_EMIT_BLOCK_MAPPING_KEY_STATE))
953− return 0;
954−
955− return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0);
956−}
957−
958−/*
959− * Expect a node.
960− */
961−
962−static int
963−yaml_emitter_emit_node(yaml_emitter_t *emitter, yaml_event_t *event,
964− int root, int sequence, int mapping, int simple_key)
965−{
966− emitter->root_context = root;
967− emitter->sequence_context = sequence;
968− emitter->mapping_context = mapping;
969− emitter->simple_key_context = simple_key;
970−
971− switch (event->type)
972− {
973− case YAML_ALIAS_EVENT:
974− return yaml_emitter_emit_alias(emitter, event);
975−
976− case YAML_SCALAR_EVENT:
977− return yaml_emitter_emit_scalar(emitter, event);
978−
979− case YAML_SEQUENCE_START_EVENT:
980− return yaml_emitter_emit_sequence_start(emitter, event);
981−
982− case YAML_MAPPING_START_EVENT:
983− return yaml_emitter_emit_mapping_start(emitter, event);
984−
985− default:
986− return yaml_emitter_set_emitter_error(emitter,
987− "expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS");
988− }
989−
990− return 0;
991−}
992−
993−/*
994− * Expect ALIAS.
995− */
996−
997−static int
998−yaml_emitter_emit_alias(yaml_emitter_t *emitter, SHIM(yaml_event_t *event))
999−{
1000− if (!yaml_emitter_process_anchor(emitter))
1001− return 0;
1002− emitter->state = POP(emitter, emitter->states);
1003−
1004− return 1;
1005−}
1006−
1007−/*
1008− * Expect SCALAR.
1009− */
1010−
1011−static int
1012−yaml_emitter_emit_scalar(yaml_emitter_t *emitter, yaml_event_t *event)
1013−{
1014− if (!yaml_emitter_select_scalar_style(emitter, event))
1015− return 0;
1016− if (!yaml_emitter_process_anchor(emitter))
1017− return 0;
1018− if (!yaml_emitter_process_tag(emitter))
1019− return 0;
1020− if (!yaml_emitter_increase_indent(emitter, 1, 0))
1021− return 0;
1022− if (!yaml_emitter_process_scalar(emitter))
1023− return 0;
1024− emitter->indent = POP(emitter, emitter->indents);
1025− emitter->state = POP(emitter, emitter->states);
1026−
1027− return 1;
1028−}
1029−
1030−/*
1031− * Expect SEQUENCE-START.
1032− */
1033−
1034−static int
1035−yaml_emitter_emit_sequence_start(yaml_emitter_t *emitter, yaml_event_t *event)
1036−{
1037− if (!yaml_emitter_process_anchor(emitter))
1038− return 0;
1039− if (!yaml_emitter_process_tag(emitter))
1040− return 0;
1041−
1042− if (emitter->flow_level || emitter->canonical
1043− || event->data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE
1044− || yaml_emitter_check_empty_sequence(emitter)) {
1045− emitter->state = YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE;
1046− }
1047− else {
1048− emitter->state = YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE;
1049− }
1050−
1051− return 1;
1052−}
1053−
1054−/*
1055− * Expect MAPPING-START.
1056− */
1057−
1058−static int
1059−yaml_emitter_emit_mapping_start(yaml_emitter_t *emitter, yaml_event_t *event)
1060−{
1061− if (!yaml_emitter_process_anchor(emitter))
1062− return 0;
1063− if (!yaml_emitter_process_tag(emitter))
1064− return 0;
1065−
1066− if (emitter->flow_level || emitter->canonical
1067− || event->data.mapping_start.style == YAML_FLOW_MAPPING_STYLE
1068− || yaml_emitter_check_empty_mapping(emitter)) {
1069− emitter->state = YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE;
1070− }
1071− else {
1072− emitter->state = YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE;
1073− }
1074−
1075− return 1;
1076−}
1077−
1078−/*
1079− * Check if the document content is an empty scalar.
1080− */
1081−
1082−static int
1083−yaml_emitter_check_empty_document(SHIM(yaml_emitter_t *emitter))
1084−{
1085− return 0;
1086−}
1087−
1088−/*
1089− * Check if the next events represent an empty sequence.
1090− */
1091−
1092−static int
1093−yaml_emitter_check_empty_sequence(yaml_emitter_t *emitter)
1094−{
1095− if (emitter->events.tail - emitter->events.head < 2)
1096− return 0;
1097−
1098− return (emitter->events.head[0].type == YAML_SEQUENCE_START_EVENT
1099− && emitter->events.head[1].type == YAML_SEQUENCE_END_EVENT);
1100−}
1101−
1102−/*
1103− * Check if the next events represent an empty mapping.
1104− */
1105−
1106−static int
1107−yaml_emitter_check_empty_mapping(yaml_emitter_t *emitter)
1108−{
1109− if (emitter->events.tail - emitter->events.head < 2)
1110− return 0;
1111−
1112− return (emitter->events.head[0].type == YAML_MAPPING_START_EVENT
1113− && emitter->events.head[1].type == YAML_MAPPING_END_EVENT);
1114−}
1115−
1116−/*
1117− * Check if the next node can be expressed as a simple key.
1118− */
1119−
1120−static int
1121−yaml_emitter_check_simple_key(yaml_emitter_t *emitter)
1122−{
1123− yaml_event_t *event = emitter->events.head;
1124− size_t length = 0;
1125−
1126− switch (event->type)
1127− {
1128− case YAML_ALIAS_EVENT:
1129− length += emitter->anchor_data.anchor_length;
1130− break;
1131−
1132− case YAML_SCALAR_EVENT:
1133− if (emitter->scalar_data.multiline)
1134− return 0;
1135− length += emitter->anchor_data.anchor_length
1136− + emitter->tag_data.handle_length
1137− + emitter->tag_data.suffix_length
1138− + emitter->scalar_data.length;
1139− break;
1140−
1141− case YAML_SEQUENCE_START_EVENT:
1142− if (!yaml_emitter_check_empty_sequence(emitter))
1143− return 0;
1144− length += emitter->anchor_data.anchor_length
1145− + emitter->tag_data.handle_length
1146− + emitter->tag_data.suffix_length;
1147− break;
1148−
1149− case YAML_MAPPING_START_EVENT:
1150− if (!yaml_emitter_check_empty_mapping(emitter))
1151− return 0;
1152− length += emitter->anchor_data.anchor_length
1153− + emitter->tag_data.handle_length
1154− + emitter->tag_data.suffix_length;
1155− break;
1156−
1157− default:
1158− return 0;
1159− }
1160−
1161− if (length > 128)
1162− return 0;
1163−
1164− return 1;
1165−}
1166−
1167−/*
1168− * Determine an acceptable scalar style.
1169− */
1170−
1171−static int
1172−yaml_emitter_select_scalar_style(yaml_emitter_t *emitter, yaml_event_t *event)
1173−{
1174− yaml_scalar_style_t style = event->data.scalar.style;
1175− int no_tag = (!emitter->tag_data.handle && !emitter->tag_data.suffix);
1176−
1177− if (no_tag && !event->data.scalar.plain_implicit
1178− && !event->data.scalar.quoted_implicit) {
1179− return yaml_emitter_set_emitter_error(emitter,
1180− "neither tag nor implicit flags are specified");
1181− }
1182−
1183− if (style == YAML_ANY_SCALAR_STYLE)
1184− style = YAML_PLAIN_SCALAR_STYLE;
1185−
1186− if (emitter->canonical)
1187− style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
1188−
1189− if (emitter->simple_key_context && emitter->scalar_data.multiline)
1190− style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
1191−
1192− if (style == YAML_PLAIN_SCALAR_STYLE)
1193− {
1194− if ((emitter->flow_level && !emitter->scalar_data.flow_plain_allowed)
1195− || (!emitter->flow_level && !emitter->scalar_data.block_plain_allowed))
1196− style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
1197− if (!emitter->scalar_data.length
1198− && (emitter->flow_level || emitter->simple_key_context))
1199− style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
1200− if (no_tag && !event->data.scalar.plain_implicit)
1201− style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
1202− }
1203−
1204− if (style == YAML_SINGLE_QUOTED_SCALAR_STYLE)
1205− {
1206− if (!emitter->scalar_data.single_quoted_allowed)
1207− style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
1208− }
1209−
1210− if (style == YAML_LITERAL_SCALAR_STYLE || style == YAML_FOLDED_SCALAR_STYLE)
1211− {
1212− if (!emitter->scalar_data.block_allowed
1213− || emitter->flow_level || emitter->simple_key_context)
1214− style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
1215− }
1216−
1217− if (no_tag && !event->data.scalar.quoted_implicit
1218− && style != YAML_PLAIN_SCALAR_STYLE)
1219− {
1220− emitter->tag_data.handle = (yaml_char_t *)"!";
1221− emitter->tag_data.handle_length = 1;
1222− }
1223−
1224− emitter->scalar_data.style = style;
1225−
1226− return 1;
1227−}
1228−
1229−/*
1230− * Write an achor.
1231− */
1232−
1233−static int
1234−yaml_emitter_process_anchor(yaml_emitter_t *emitter)
1235−{
1236− if (!emitter->anchor_data.anchor)
1237− return 1;
1238−
1239− if (!yaml_emitter_write_indicator(emitter,
1240− (emitter->anchor_data.alias ? "*" : "&"), 1, 0, 0))
1241− return 0;
1242−
1243− return yaml_emitter_write_anchor(emitter,
1244− emitter->anchor_data.anchor, emitter->anchor_data.anchor_length);
1245−}
1246−
1247−/*
1248− * Write a tag.
1249− */
1250−
1251−static int
1252−yaml_emitter_process_tag(yaml_emitter_t *emitter)
1253−{
1254− if (!emitter->tag_data.handle && !emitter->tag_data.suffix)
1255− return 1;
1256−
1257− if (emitter->tag_data.handle)
1258− {
1259− if (!yaml_emitter_write_tag_handle(emitter, emitter->tag_data.handle,
1260− emitter->tag_data.handle_length))
1261− return 0;
1262− if (emitter->tag_data.suffix) {
1263− if (!yaml_emitter_write_tag_content(emitter, emitter->tag_data.suffix,
1264− emitter->tag_data.suffix_length, 0))
1265− return 0;
1266− }
1267− }
1268− else
1269− {
1270− if (!yaml_emitter_write_indicator(emitter, "!<", 1, 0, 0))
1271− return 0;
1272− if (!yaml_emitter_write_tag_content(emitter, emitter->tag_data.suffix,
1273− emitter->tag_data.suffix_length, 0))
1274− return 0;
1275− if (!yaml_emitter_write_indicator(emitter, ">", 0, 0, 0))
1276− return 0;
1277− }
1278−
1279− return 1;
1280−}
1281−
1282−/*
1283− * Write a scalar.
1284− */
1285−
1286−static int
1287−yaml_emitter_process_scalar(yaml_emitter_t *emitter)
1288−{
1289− switch (emitter->scalar_data.style)
1290− {
1291− case YAML_PLAIN_SCALAR_STYLE:
1292− return yaml_emitter_write_plain_scalar(emitter,
1293− emitter->scalar_data.value, emitter->scalar_data.length,
1294− !emitter->simple_key_context);
1295−
1296− case YAML_SINGLE_QUOTED_SCALAR_STYLE:
1297− return yaml_emitter_write_single_quoted_scalar(emitter,
1298− emitter->scalar_data.value, emitter->scalar_data.length,
1299− !emitter->simple_key_context);
1300−
1301− case YAML_DOUBLE_QUOTED_SCALAR_STYLE:
1302− return yaml_emitter_write_double_quoted_scalar(emitter,
1303− emitter->scalar_data.value, emitter->scalar_data.length,
1304− !emitter->simple_key_context);
1305−
1306− case YAML_LITERAL_SCALAR_STYLE:
1307− return yaml_emitter_write_literal_scalar(emitter,
1308− emitter->scalar_data.value, emitter->scalar_data.length);
1309−
1310− case YAML_FOLDED_SCALAR_STYLE:
1311− return yaml_emitter_write_folded_scalar(emitter,
1312− emitter->scalar_data.value, emitter->scalar_data.length);
1313−
1314− default:
1315− assert(1); /* Impossible. */
1316− }
1317−
1318− return 0;
1319−}
1320−
1321−/*
1322− * Check if a %YAML directive is valid.
1323− */
1324−
1325−static int
1326−yaml_emitter_analyze_version_directive(yaml_emitter_t *emitter,
1327− yaml_version_directive_t version_directive)
1328−{
1329− if (version_directive.major != 1 || version_directive.minor != 1) {
1330− return yaml_emitter_set_emitter_error(emitter,
1331− "incompatible %YAML directive");
1332− }
1333−
1334− return 1;
1335−}
1336−
1337−/*
1338− * Check if a %TAG directive is valid.
1339− */
1340−
1341−static int
1342−yaml_emitter_analyze_tag_directive(yaml_emitter_t *emitter,
1343− yaml_tag_directive_t tag_directive)
1344−{
1345− yaml_string_t handle;
1346− yaml_string_t prefix;
1347− size_t handle_length;
1348− size_t prefix_length;
1349−
1350− handle_length = strlen((char *)tag_directive.handle);
1351− prefix_length = strlen((char *)tag_directive.prefix);
1352− STRING_ASSIGN(handle, tag_directive.handle, handle_length);
1353− STRING_ASSIGN(prefix, tag_directive.prefix, prefix_length);
1354−
1355− if (handle.start == handle.end) {
1356− return yaml_emitter_set_emitter_error(emitter,
1357− "tag handle must not be empty");
1358− }
1359−
1360− if (handle.start[0] != '!') {
1361− return yaml_emitter_set_emitter_error(emitter,
1362− "tag handle must start with '!'");
1363− }
1364−
1365− if (handle.end[-1] != '!') {
1366− return yaml_emitter_set_emitter_error(emitter,
1367− "tag handle must end with '!'");
1368− }
1369−
1370− handle.pointer ++;
1371−
1372− while (handle.pointer < handle.end-1) {
1373− if (!IS_ALPHA(handle)) {
1374− return yaml_emitter_set_emitter_error(emitter,
1375− "tag handle must contain alphanumerical characters only");
1376− }
1377− MOVE(handle);
1378− }
1379−
1380− if (prefix.start == prefix.end) {
1381− return yaml_emitter_set_emitter_error(emitter,
1382− "tag prefix must not be empty");
1383− }
1384−
1385− return 1;
1386−}
1387−
1388−/*
1389− * Check if an anchor is valid.
1390− */
1391−
1392−static int
1393−yaml_emitter_analyze_anchor(yaml_emitter_t *emitter,
1394− yaml_char_t *anchor, int alias)
1395−{
1396− size_t anchor_length;
1397− yaml_string_t string;
1398−
1399− anchor_length = strlen((char *)anchor);
1400− STRING_ASSIGN(string, anchor, anchor_length);
1401−
1402− if (string.start == string.end) {
1403− return yaml_emitter_set_emitter_error(emitter, alias ?
1404− "alias value must not be empty" :
1405− "anchor value must not be empty");
1406− }
1407−
1408− while (string.pointer != string.end) {
1409− if (!IS_ALPHA(string)) {
1410− return yaml_emitter_set_emitter_error(emitter, alias ?
1411− "alias value must contain alphanumerical characters only" :
1412− "anchor value must contain alphanumerical characters only");
1413− }
1414− MOVE(string);
1415− }
1416−
1417− emitter->anchor_data.anchor = string.start;
1418− emitter->anchor_data.anchor_length = string.end - string.start;
1419− emitter->anchor_data.alias = alias;
1420−
1421− return 1;
1422−}
1423−
1424−/*
1425− * Check if a tag is valid.
1426− */
1427−
1428−static int
1429−yaml_emitter_analyze_tag(yaml_emitter_t *emitter,
1430− yaml_char_t *tag)
1431−{
1432− size_t tag_length;
1433− yaml_string_t string;
1434− yaml_tag_directive_t *tag_directive;
1435−
1436− tag_length = strlen((char *)tag);
1437− STRING_ASSIGN(string, tag, tag_length);
1438−
1439− if (string.start == string.end) {
1440− return yaml_emitter_set_emitter_error(emitter,
1441− "tag value must not be empty");
1442− }
1443−
1444− for (tag_directive = emitter->tag_directives.start;
1445− tag_directive != emitter->tag_directives.top; tag_directive ++) {
1446− size_t prefix_length = strlen((char *)tag_directive->prefix);
1447− if (prefix_length < (size_t)(string.end - string.start)
1448− && strncmp((char *)tag_directive->prefix, (char *)string.start,
1449− prefix_length) == 0)
1450− {
1451− emitter->tag_data.handle = tag_directive->handle;
1452− emitter->tag_data.handle_length =
1453− strlen((char *)tag_directive->handle);
1454− emitter->tag_data.suffix = string.start + prefix_length;
1455− emitter->tag_data.suffix_length =
1456− (string.end - string.start) - prefix_length;
1457− return 1;
1458− }
1459− }
1460−
1461− emitter->tag_data.suffix = string.start;
1462− emitter->tag_data.suffix_length = string.end - string.start;
1463−
1464− return 1;
1465−}
1466−
1467−/*
1468− * Check if a scalar is valid.
1469− */
1470−
1471−static int
1472−yaml_emitter_analyze_scalar(yaml_emitter_t *emitter,
1473− yaml_char_t *value, size_t length)
1474−{
1475− yaml_string_t string;
1476−
1477− int block_indicators = 0;
1478− int flow_indicators = 0;
1479− int line_breaks = 0;
1480− int special_characters = 0;
1481−
1482− int leading_space = 0;
1483− int leading_break = 0;
1484− int trailing_space = 0;
1485− int trailing_break = 0;
1486− int break_space = 0;
1487− int space_break = 0;
1488−
1489− int preceded_by_whitespace = 0;
1490− int followed_by_whitespace = 0;
1491− int previous_space = 0;
1492− int previous_break = 0;
1493−
1494− STRING_ASSIGN(string, value, length);
1495−
1496− emitter->scalar_data.value = value;
1497− emitter->scalar_data.length = length;
1498−
1499− if (string.start == string.end)
1500− {
1501− emitter->scalar_data.multiline = 0;
1502− emitter->scalar_data.flow_plain_allowed = 0;
1503− emitter->scalar_data.block_plain_allowed = 1;
1504− emitter->scalar_data.single_quoted_allowed = 1;
1505− emitter->scalar_data.block_allowed = 0;
1506−
1507− return 1;
1508− }
1509−
1510− if ((CHECK_AT(string, '-', 0)
1511− && CHECK_AT(string, '-', 1)
1512− && CHECK_AT(string, '-', 2))
1513− || (CHECK_AT(string, '.', 0)
1514− && CHECK_AT(string, '.', 1)
1515− && CHECK_AT(string, '.', 2))) {
1516− block_indicators = 1;
1517− flow_indicators = 1;
1518− }
1519−
1520− preceded_by_whitespace = 1;
1521− followed_by_whitespace = IS_BLANKZ_AT(string, WIDTH(string));
1522−
1523− while (string.pointer != string.end)
1524− {
1525− if (string.start == string.pointer)
1526− {
1527− if (CHECK(string, '#') || CHECK(string, ',')
1528− || CHECK(string, '[') || CHECK(string, ']')
1529− || CHECK(string, '{') || CHECK(string, '}')
1530− || CHECK(string, '&') || CHECK(string, '*')
1531− || CHECK(string, '!') || CHECK(string, '|')
1532− || CHECK(string, '>') || CHECK(string, '\'')
1533− || CHECK(string, '"') || CHECK(string, '%')
1534− || CHECK(string, '@') || CHECK(string, '`')) {
1535− flow_indicators = 1;
1536− block_indicators = 1;
1537− }
1538−
1539− if (CHECK(string, '?') || CHECK(string, ':')) {
1540− flow_indicators = 1;
1541− if (followed_by_whitespace) {
1542− block_indicators = 1;
1543− }
1544− }
1545−
1546− if (CHECK(string, '-') && followed_by_whitespace) {
1547− flow_indicators = 1;
1548− block_indicators = 1;
1549− }
1550− }
1551− else
1552− {
1553− if (CHECK(string, ',') || CHECK(string, '?')
1554− || CHECK(string, '[') || CHECK(string, ']')
1555− || CHECK(string, '{') || CHECK(string, '}')) {
1556− flow_indicators = 1;
1557− }
1558−
1559− if (CHECK(string, ':')) {
1560− flow_indicators = 1;
1561− if (followed_by_whitespace) {
1562− block_indicators = 1;
1563− }
1564− }
1565−
1566− if (CHECK(string, '#') && preceded_by_whitespace) {
1567− flow_indicators = 1;
1568− block_indicators = 1;
1569− }
1570− }
1571−
1572− if (!IS_PRINTABLE(string)
1573− || (!IS_ASCII(string) && !emitter->unicode)) {
1574− special_characters = 1;
1575− }
1576−
1577− if (IS_BREAK(string)) {
1578− line_breaks = 1;
1579− }
1580−
1581− if (IS_SPACE(string))
1582− {
1583− if (string.start == string.pointer) {
1584− leading_space = 1;
1585− }
1586− if (string.pointer+WIDTH(string) == string.end) {
1587− trailing_space = 1;
1588− }
1589− if (previous_break) {
1590− break_space = 1;
1591− }
1592− previous_space = 1;
1593− previous_break = 0;
1594− }
1595− else if (IS_BREAK(string))
1596− {
1597− if (string.start == string.pointer) {
1598− leading_break = 1;
1599− }
1600− if (string.pointer+WIDTH(string) == string.end) {
1601− trailing_break = 1;
1602− }
1603− if (previous_space) {
1604− space_break = 1;
1605− }
1606− previous_space = 0;
1607− previous_break = 1;
1608− }
1609− else
1610− {
1611− previous_space = 0;
1612− previous_break = 0;
1613− }
1614−
1615− preceded_by_whitespace = IS_BLANKZ(string);
1616− MOVE(string);
1617− if (string.pointer != string.end) {
1618− followed_by_whitespace = IS_BLANKZ_AT(string, WIDTH(string));
1619− }
1620− }
1621−
1622− emitter->scalar_data.multiline = line_breaks;
1623−
1624− emitter->scalar_data.flow_plain_allowed = 1;
1625− emitter->scalar_data.block_plain_allowed = 1;
1626− emitter->scalar_data.single_quoted_allowed = 1;
1627− emitter->scalar_data.block_allowed = 1;
1628−
1629− if (leading_space || leading_break || trailing_space || trailing_break) {
1630− emitter->scalar_data.flow_plain_allowed = 0;
1631− emitter->scalar_data.block_plain_allowed = 0;
1632− }
1633−
1634− if (trailing_space) {
1635− emitter->scalar_data.block_allowed = 0;
1636− }
1637−
1638− if (break_space) {
1639− emitter->scalar_data.flow_plain_allowed = 0;
1640− emitter->scalar_data.block_plain_allowed = 0;
1641− emitter->scalar_data.single_quoted_allowed = 0;
1642− }
1643−
1644− if (space_break || special_characters) {
1645− emitter->scalar_data.flow_plain_allowed = 0;
1646− emitter->scalar_data.block_plain_allowed = 0;
1647− emitter->scalar_data.single_quoted_allowed = 0;
1648− emitter->scalar_data.block_allowed = 0;
1649− }
1650−
1651− if (line_breaks) {
1652− emitter->scalar_data.flow_plain_allowed = 0;
1653− emitter->scalar_data.block_plain_allowed = 0;
1654− }
1655−
1656− if (flow_indicators) {
1657− emitter->scalar_data.flow_plain_allowed = 0;
1658− }
1659−
1660− if (block_indicators) {
1661− emitter->scalar_data.block_plain_allowed = 0;
1662− }
1663−
1664− return 1;
1665−}
1666−
1667−/*
1668− * Check if the event data is valid.
1669− */
1670−
1671−static int
1672−yaml_emitter_analyze_event(yaml_emitter_t *emitter,
1673− yaml_event_t *event)
1674−{
1675− emitter->anchor_data.anchor = NULL;
1676− emitter->anchor_data.anchor_length = 0;
1677− emitter->tag_data.handle = NULL;
1678− emitter->tag_data.handle_length = 0;
1679− emitter->tag_data.suffix = NULL;
1680− emitter->tag_data.suffix_length = 0;
1681− emitter->scalar_data.value = NULL;
1682− emitter->scalar_data.length = 0;
1683−
1684− switch (event->type)
1685− {
1686− case YAML_ALIAS_EVENT:
1687− if (!yaml_emitter_analyze_anchor(emitter,
1688− event->data.alias.anchor, 1))
1689− return 0;
1690− return 1;
1691−
1692− case YAML_SCALAR_EVENT:
1693− if (event->data.scalar.anchor) {
1694− if (!yaml_emitter_analyze_anchor(emitter,
1695− event->data.scalar.anchor, 0))
1696− return 0;
1697− }
1698− if (event->data.scalar.tag && (emitter->canonical ||
1699− (!event->data.scalar.plain_implicit
1700− && !event->data.scalar.quoted_implicit))) {
1701− if (!yaml_emitter_analyze_tag(emitter, event->data.scalar.tag))
1702− return 0;
1703− }
1704− if (!yaml_emitter_analyze_scalar(emitter,
1705− event->data.scalar.value, event->data.scalar.length))
1706− return 0;
1707− return 1;
1708−
1709− case YAML_SEQUENCE_START_EVENT:
1710− if (event->data.sequence_start.anchor) {
1711− if (!yaml_emitter_analyze_anchor(emitter,
1712− event->data.sequence_start.anchor, 0))
1713− return 0;
1714− }
1715− if (event->data.sequence_start.tag && (emitter->canonical ||
1716− !event->data.sequence_start.implicit)) {
1717− if (!yaml_emitter_analyze_tag(emitter,
1718− event->data.sequence_start.tag))
1719− return 0;
1720− }
1721− return 1;
1722−
1723− case YAML_MAPPING_START_EVENT:
1724− if (event->data.mapping_start.anchor) {
1725− if (!yaml_emitter_analyze_anchor(emitter,
1726− event->data.mapping_start.anchor, 0))
1727− return 0;
1728− }
1729− if (event->data.mapping_start.tag && (emitter->canonical ||
1730− !event->data.mapping_start.implicit)) {
1731− if (!yaml_emitter_analyze_tag(emitter,
1732− event->data.mapping_start.tag))
1733− return 0;
1734− }
1735− return 1;
1736−
1737− default:
1738− return 1;
1739− }
1740−}
1741−
1742−/*
1743− * Write the BOM character.
1744− */
1745−
1746−static int
1747−yaml_emitter_write_bom(yaml_emitter_t *emitter)
1748−{
1749− if (!FLUSH(emitter)) return 0;
1750−
1751− *(emitter->buffer.pointer++) = (yaml_char_t) '\xEF';
1752− *(emitter->buffer.pointer++) = (yaml_char_t) '\xBB';
1753− *(emitter->buffer.pointer++) = (yaml_char_t) '\xBF';
1754−
1755− return 1;
1756−}
1757−
1758−static int
1759−yaml_emitter_write_indent(yaml_emitter_t *emitter)
1760−{
1761− int indent = (emitter->indent >= 0) ? emitter->indent : 0;
1762−
1763− if (!emitter->indention || emitter->column > indent
1764− || (emitter->column == indent && !emitter->whitespace)) {
1765− if (!PUT_BREAK(emitter)) return 0;
1766− }
1767−
1768− while (emitter->column < indent) {
1769− if (!PUT(emitter, ' ')) return 0;
1770− }
1771−
1772− emitter->whitespace = 1;
1773− emitter->indention = 1;
1774−
1775− return 1;
1776−}
1777−
1778−static int
1779−yaml_emitter_write_indicator(yaml_emitter_t *emitter,
1780− const char *indicator, int need_whitespace,
1781− int is_whitespace, int is_indention)
1782−{
1783− size_t indicator_length;
1784− yaml_string_t string;
1785−
1786− indicator_length = strlen(indicator);
1787− STRING_ASSIGN(string, (yaml_char_t *)indicator, indicator_length);
1788−
1789− if (need_whitespace && !emitter->whitespace) {
1790− if (!PUT(emitter, ' ')) return 0;
1791− }
1792−
1793− while (string.pointer != string.end) {
1794− if (!WRITE(emitter, string)) return 0;
1795− }
1796−
1797− emitter->whitespace = is_whitespace;
1798− emitter->indention = (emitter->indention && is_indention);
1799− emitter->open_ended = 0;
1800−
1801− return 1;
1802−}
1803−
1804−static int
1805−yaml_emitter_write_anchor(yaml_emitter_t *emitter,
1806− yaml_char_t *value, size_t length)
1807−{
1808− yaml_string_t string;
1809− STRING_ASSIGN(string, value, length);
1810−
1811− while (string.pointer != string.end) {
1812− if (!WRITE(emitter, string)) return 0;
1813− }
1814−
1815− emitter->whitespace = 0;
1816− emitter->indention = 0;
1817−
1818− return 1;
1819−}
1820−
1821−static int
1822−yaml_emitter_write_tag_handle(yaml_emitter_t *emitter,
1823− yaml_char_t *value, size_t length)
1824−{
1825− yaml_string_t string;
1826− STRING_ASSIGN(string, value, length);
1827−
1828− if (!emitter->whitespace) {
1829− if (!PUT(emitter, ' ')) return 0;
1830− }
1831−
1832− while (string.pointer != string.end) {
1833− if (!WRITE(emitter, string)) return 0;
1834− }
1835−
1836− emitter->whitespace = 0;
1837− emitter->indention = 0;
1838−
1839− return 1;
1840−}
1841−
1842−static int
1843−yaml_emitter_write_tag_content(yaml_emitter_t *emitter,
1844− yaml_char_t *value, size_t length,
1845− int need_whitespace)
1846−{
1847− yaml_string_t string;
1848− STRING_ASSIGN(string, value, length);
1849−
1850− if (need_whitespace && !emitter->whitespace) {
1851− if (!PUT(emitter, ' ')) return 0;
1852− }
1853−
1854− while (string.pointer != string.end) {
1855− if (IS_ALPHA(string)
1856− || CHECK(string, ';') || CHECK(string, '/')
1857− || CHECK(string, '?') || CHECK(string, ':')
1858− || CHECK(string, '@') || CHECK(string, '&')
1859− || CHECK(string, '=') || CHECK(string, '+')
1860− || CHECK(string, '$') || CHECK(string, ',')
1861− || CHECK(string, '_') || CHECK(string, '.')
1862− || CHECK(string, '~') || CHECK(string, '*')
1863− || CHECK(string, '\'') || CHECK(string, '(')
1864− || CHECK(string, ')') || CHECK(string, '[')
1865− || CHECK(string, ']')) {
1866− if (!WRITE(emitter, string)) return 0;
1867− }
1868− else {
1869− int width = WIDTH(string);
1870− unsigned int value;
1871− while (width --) {
1872− value = *(string.pointer++);
1873− if (!PUT(emitter, '%')) return 0;
1874− if (!PUT(emitter, (value >> 4)
1875− + ((value >> 4) < 10 ? '0' : 'A' - 10)))
1876− return 0;
1877− if (!PUT(emitter, (value & 0x0F)
1878− + ((value & 0x0F) < 10 ? '0' : 'A' - 10)))
1879− return 0;
1880− }
1881− }
1882− }
1883−
1884− emitter->whitespace = 0;
1885− emitter->indention = 0;
1886−
1887− return 1;
1888−}
1889−
1890−static int
1891−yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter,
1892− yaml_char_t *value, size_t length, int allow_breaks)
1893−{
1894− yaml_string_t string;
1895− int spaces = 0;
1896− int breaks = 0;
1897−
1898− STRING_ASSIGN(string, value, length);
1899−
1900− if (!emitter->whitespace) {
1901− if (!PUT(emitter, ' ')) return 0;
1902− }
1903−
1904− while (string.pointer != string.end)
1905− {
1906− if (IS_SPACE(string))
1907− {
1908− if (allow_breaks && !spaces
1909− && emitter->column > emitter->best_width
1910− && !IS_SPACE_AT(string, 1)) {
1911− if (!yaml_emitter_write_indent(emitter)) return 0;
1912− MOVE(string);
1913− }
1914− else {
1915− if (!WRITE(emitter, string)) return 0;
1916− }
1917− spaces = 1;
1918− }
1919− else if (IS_BREAK(string))
1920− {
1921− if (!breaks && CHECK(string, '\n')) {
1922− if (!PUT_BREAK(emitter)) return 0;
1923− }
1924− if (!WRITE_BREAK(emitter, string)) return 0;
1925− emitter->indention = 1;
1926− breaks = 1;
1927− }
1928− else
1929− {
1930− if (breaks) {
1931− if (!yaml_emitter_write_indent(emitter)) return 0;
1932− }
1933− if (!WRITE(emitter, string)) return 0;
1934− emitter->indention = 0;
1935− spaces = 0;
1936− breaks = 0;
1937− }
1938− }
1939−
1940− emitter->whitespace = 0;
1941− emitter->indention = 0;
1942− if (emitter->root_context)
1943− {
1944− emitter->open_ended = 1;
1945− }
1946−
1947− return 1;
1948−}
1949−
1950−static int
1951−yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter,
1952− yaml_char_t *value, size_t length, int allow_breaks)
1953−{
1954− yaml_string_t string;
1955− int spaces = 0;
1956− int breaks = 0;
1957−
1958− STRING_ASSIGN(string, value, length);
1959−
1960− if (!yaml_emitter_write_indicator(emitter, "'", 1, 0, 0))
1961− return 0;
1962−
1963− while (string.pointer != string.end)
1964− {
1965− if (IS_SPACE(string))
1966− {
1967− if (allow_breaks && !spaces
1968− && emitter->column > emitter->best_width
1969− && string.pointer != string.start
1970− && string.pointer != string.end - 1
1971− && !IS_SPACE_AT(string, 1)) {
1972− if (!yaml_emitter_write_indent(emitter)) return 0;
1973− MOVE(string);
1974− }
1975− else {
1976− if (!WRITE(emitter, string)) return 0;
1977− }
1978− spaces = 1;
1979− }
1980− else if (IS_BREAK(string))
1981− {
1982− if (!breaks && CHECK(string, '\n')) {
1983− if (!PUT_BREAK(emitter)) return 0;
1984− }
1985− if (!WRITE_BREAK(emitter, string)) return 0;
1986− emitter->indention = 1;
1987− breaks = 1;
1988− }
1989− else
1990− {
1991− if (breaks) {
1992− if (!yaml_emitter_write_indent(emitter)) return 0;
1993− }
1994− if (CHECK(string, '\'')) {
1995− if (!PUT(emitter, '\'')) return 0;
1996− }
1997− if (!WRITE(emitter, string)) return 0;
1998− emitter->indention = 0;
1999− spaces = 0;
2000− breaks = 0;
2001− }
2002− }
2003−
2004− if (breaks)
2005− if (!yaml_emitter_write_indent(emitter)) return 0;
2006−
2007− if (!yaml_emitter_write_indicator(emitter, "'", 0, 0, 0))
2008− return 0;
2009−
2010− emitter->whitespace = 0;
2011− emitter->indention = 0;
2012−
2013− return 1;
2014−}
2015−
2016−static int
2017−yaml_emitter_write_double_quoted_scalar(yaml_emitter_t *emitter,
2018− yaml_char_t *value, size_t length, int allow_breaks)
2019−{
2020− yaml_string_t string;
2021− int spaces = 0;
2022−
2023− STRING_ASSIGN(string, value, length);
2024−
2025− if (!yaml_emitter_write_indicator(emitter, "\"", 1, 0, 0))
2026− return 0;
2027−
2028− while (string.pointer != string.end)
2029− {
2030− if (!IS_PRINTABLE(string) || (!emitter->unicode && !IS_ASCII(string))
2031− || IS_BOM(string) || IS_BREAK(string)
2032− || CHECK(string, '"') || CHECK(string, '\\'))
2033− {
2034− unsigned char octet;
2035− unsigned int width;
2036− unsigned int value;
2037− int k;
2038−
2039− octet = string.pointer[0];
2040− width = (octet & 0x80) == 0x00 ? 1 :
2041− (octet & 0xE0) == 0xC0 ? 2 :
2042− (octet & 0xF0) == 0xE0 ? 3 :
2043− (octet & 0xF8) == 0xF0 ? 4 : 0;
2044− value = (octet & 0x80) == 0x00 ? octet & 0x7F :
2045− (octet & 0xE0) == 0xC0 ? octet & 0x1F :
2046− (octet & 0xF0) == 0xE0 ? octet & 0x0F :
2047− (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
2048− for (k = 1; k < (int)width; k ++) {
2049− octet = string.pointer[k];
2050− value = (value << 6) + (octet & 0x3F);
2051− }
2052− string.pointer += width;
2053−
2054− if (!PUT(emitter, '\\')) return 0;
2055−
2056− switch (value)
2057− {
2058− case 0x00:
2059− if (!PUT(emitter, '0')) return 0;
2060− break;
2061−
2062− case 0x07:
2063− if (!PUT(emitter, 'a')) return 0;
2064− break;
2065−
2066− case 0x08:
2067− if (!PUT(emitter, 'b')) return 0;
2068− break;
2069−
2070− case 0x09:
2071− if (!PUT(emitter, 't')) return 0;
2072− break;
2073−
2074− case 0x0A:
2075− if (!PUT(emitter, 'n')) return 0;
2076− break;
2077−
2078− case 0x0B:
2079− if (!PUT(emitter, 'v')) return 0;
2080− break;
2081−
2082− case 0x0C:
2083− if (!PUT(emitter, 'f')) return 0;
2084− break;
2085−
2086− case 0x0D:
2087− if (!PUT(emitter, 'r')) return 0;
2088− break;
2089−
2090− case 0x1B:
2091− if (!PUT(emitter, 'e')) return 0;
2092− break;
2093−
2094− case 0x22:
2095− if (!PUT(emitter, '\"')) return 0;
2096− break;
2097−
2098− case 0x5C:
2099− if (!PUT(emitter, '\\')) return 0;
2100− break;
2101−
2102− case 0x85:
2103− if (!PUT(emitter, 'N')) return 0;
2104− break;
2105−
2106− case 0xA0:
2107− if (!PUT(emitter, '_')) return 0;
2108− break;
2109−
2110− case 0x2028:
2111− if (!PUT(emitter, 'L')) return 0;
2112− break;
2113−
2114− case 0x2029:
2115− if (!PUT(emitter, 'P')) return 0;
2116− break;
2117−
2118− default:
2119− if (value <= 0xFF) {
2120− if (!PUT(emitter, 'x')) return 0;
2121− width = 2;
2122− }
2123− else if (value <= 0xFFFF) {
2124− if (!PUT(emitter, 'u')) return 0;
2125− width = 4;
2126− }
2127− else {
2128− if (!PUT(emitter, 'U')) return 0;
2129− width = 8;
2130− }
2131− for (k = (width-1)*4; k >= 0; k -= 4) {
2132− int digit = (value >> k) & 0x0F;
2133− if (!PUT(emitter, digit + (digit < 10 ? '0' : 'A'-10)))
2134− return 0;
2135− }
2136− }
2137− spaces = 0;
2138− }
2139− else if (IS_SPACE(string))
2140− {
2141− if (allow_breaks && !spaces
2142− && emitter->column > emitter->best_width
2143− && string.pointer != string.start
2144− && string.pointer != string.end - 1) {
2145− if (!yaml_emitter_write_indent(emitter)) return 0;
2146− if (IS_SPACE_AT(string, 1)) {
2147− if (!PUT(emitter, '\\')) return 0;
2148− }
2149− MOVE(string);
2150− }
2151− else {
2152− if (!WRITE(emitter, string)) return 0;
2153− }
2154− spaces = 1;
2155− }
2156− else
2157− {
2158− if (!WRITE(emitter, string)) return 0;
2159− spaces = 0;
2160− }
2161− }
2162−
2163− if (!yaml_emitter_write_indicator(emitter, "\"", 0, 0, 0))
2164− return 0;
2165−
2166− emitter->whitespace = 0;
2167− emitter->indention = 0;
2168−
2169− return 1;
2170−}
2171−
2172−static int
2173−yaml_emitter_write_block_scalar_hints(yaml_emitter_t *emitter,
2174− yaml_string_t string)
2175−{
2176− char indent_hint[2];
2177− const char *chomp_hint = NULL;
2178−
2179− if (IS_SPACE(string) || IS_BREAK(string))
2180− {
2181− indent_hint[0] = '0' + (char)emitter->best_indent;
2182− indent_hint[1] = '\0';
2183− if (!yaml_emitter_write_indicator(emitter, indent_hint, 0, 0, 0))
2184− return 0;
2185− }
2186−
2187− emitter->open_ended = 0;
2188−
2189− string.pointer = string.end;
2190− if (string.start == string.pointer)
2191− {
2192− chomp_hint = "-";
2193− }
2194− else
2195− {
2196− do {
2197− string.pointer --;
2198− } while ((*string.pointer & 0xC0) == 0x80);
2199− if (!IS_BREAK(string))
2200− {
2201− chomp_hint = "-";
2202− }
2203− else if (string.start == string.pointer)
2204− {
2205− chomp_hint = "+";
2206− emitter->open_ended = 1;
2207− }
2208− else
2209− {
2210− do {
2211− string.pointer --;
2212− } while ((*string.pointer & 0xC0) == 0x80);
2213− if (IS_BREAK(string))
2214− {
2215− chomp_hint = "+";
2216− emitter->open_ended = 1;
2217− }
2218− }
2219− }
2220−
2221− if (chomp_hint)
2222− {
2223− if (!yaml_emitter_write_indicator(emitter, chomp_hint, 0, 0, 0))
2224− return 0;
2225− }
2226−
2227− return 1;
2228−}
2229−
2230−static int
2231−yaml_emitter_write_literal_scalar(yaml_emitter_t *emitter,
2232− yaml_char_t *value, size_t length)
2233−{
2234− yaml_string_t string;
2235− int breaks = 1;
2236−
2237− STRING_ASSIGN(string, value, length);
2238−
2239− if (!yaml_emitter_write_indicator(emitter, "|", 1, 0, 0))
2240− return 0;
2241− if (!yaml_emitter_write_block_scalar_hints(emitter, string))
2242− return 0;
2243− if (!PUT_BREAK(emitter)) return 0;
2244− emitter->indention = 1;
2245− emitter->whitespace = 1;
2246−
2247− while (string.pointer != string.end)
2248− {
2249− if (IS_BREAK(string))
2250− {
2251− if (!WRITE_BREAK(emitter, string)) return 0;
2252− emitter->indention = 1;
2253− breaks = 1;
2254− }
2255− else
2256− {
2257− if (breaks) {
2258− if (!yaml_emitter_write_indent(emitter)) return 0;
2259− }
2260− if (!WRITE(emitter, string)) return 0;
2261− emitter->indention = 0;
2262− breaks = 0;
2263− }
2264− }
2265−
2266− return 1;
2267−}
2268−
2269−static int
2270−yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter,
2271− yaml_char_t *value, size_t length)
2272−{
2273− yaml_string_t string;
2274− int breaks = 1;
2275− int leading_spaces = 1;
2276−
2277− STRING_ASSIGN(string, value, length);
2278−
2279− if (!yaml_emitter_write_indicator(emitter, ">", 1, 0, 0))
2280− return 0;
2281− if (!yaml_emitter_write_block_scalar_hints(emitter, string))
2282− return 0;
2283− if (!PUT_BREAK(emitter)) return 0;
2284− emitter->indention = 1;
2285− emitter->whitespace = 1;
2286−
2287− while (string.pointer != string.end)
2288− {
2289− if (IS_BREAK(string))
2290− {
2291− if (!breaks && !leading_spaces && CHECK(string, '\n')) {
2292− int k = 0;
2293− while (IS_BREAK_AT(string, k)) {
2294− k += WIDTH_AT(string, k);
2295− }
2296− if (!IS_BLANKZ_AT(string, k)) {
2297− if (!PUT_BREAK(emitter)) return 0;
2298− }
2299− }
2300− if (!WRITE_BREAK(emitter, string)) return 0;
2301− emitter->indention = 1;
2302− breaks = 1;
2303− }
2304− else
2305− {
2306− if (breaks) {
2307− if (!yaml_emitter_write_indent(emitter)) return 0;
2308− leading_spaces = IS_BLANK(string);
2309− }
2310− if (!breaks && IS_SPACE(string) && !IS_SPACE_AT(string, 1)
2311− && emitter->column > emitter->best_width) {
2312− if (!yaml_emitter_write_indent(emitter)) return 0;
2313− MOVE(string);
2314− }
2315− else {
2316− if (!WRITE(emitter, string)) return 0;
2317− }
2318− emitter->indention = 0;
2319− breaks = 0;
2320− }
2321− }
2322−
2323− return 1;
2324−}
libyaml/libyaml_src/loader.cdeleted−444
@@ -1,444 +0,0 @@
1−
2−#include "yaml_private.h"
3−
4−/*
5− * API functions.
6− */
7−
8−YAML_DECLARE(int)
9−yaml_parser_load(yaml_parser_t *parser, yaml_document_t *document);
10−
11−/*
12− * Error handling.
13− */
14−
15−static int
16−yaml_parser_set_composer_error(yaml_parser_t *parser,
17− const char *problem, yaml_mark_t problem_mark);
18−
19−static int
20−yaml_parser_set_composer_error_context(yaml_parser_t *parser,
21− const char *context, yaml_mark_t context_mark,
22− const char *problem, yaml_mark_t problem_mark);
23−
24−
25−/*
26− * Alias handling.
27− */
28−
29−static int
30−yaml_parser_register_anchor(yaml_parser_t *parser,
31− int index, yaml_char_t *anchor);
32−
33−/*
34− * Clean up functions.
35− */
36−
37−static void
38−yaml_parser_delete_aliases(yaml_parser_t *parser);
39−
40−/*
41− * Composer functions.
42− */
43−
44−static int
45−yaml_parser_load_document(yaml_parser_t *parser, yaml_event_t *first_event);
46−
47−static int
48−yaml_parser_load_node(yaml_parser_t *parser, yaml_event_t *first_event);
49−
50−static int
51−yaml_parser_load_alias(yaml_parser_t *parser, yaml_event_t *first_event);
52−
53−static int
54−yaml_parser_load_scalar(yaml_parser_t *parser, yaml_event_t *first_event);
55−
56−static int
57−yaml_parser_load_sequence(yaml_parser_t *parser, yaml_event_t *first_event);
58−
59−static int
60−yaml_parser_load_mapping(yaml_parser_t *parser, yaml_event_t *first_event);
61−
62−/*
63− * Load the next document of the stream.
64− */
65−
66−YAML_DECLARE(int)
67−yaml_parser_load(yaml_parser_t *parser, yaml_document_t *document)
68−{
69− yaml_event_t event;
70−
71− assert(parser); /* Non-NULL parser object is expected. */
72− assert(document); /* Non-NULL document object is expected. */
73−
74− memset(document, 0, sizeof(yaml_document_t));
75− if (!STACK_INIT(parser, document->nodes, yaml_node_t*))
76− goto error;
77−
78− if (!parser->stream_start_produced) {
79− if (!yaml_parser_parse(parser, &event)) goto error;
80− assert(event.type == YAML_STREAM_START_EVENT);
81− /* STREAM-START is expected. */
82− }
83−
84− if (parser->stream_end_produced) {
85− return 1;
86− }
87−
88− if (!yaml_parser_parse(parser, &event)) goto error;
89− if (event.type == YAML_STREAM_END_EVENT) {
90− return 1;
91− }
92−
93− if (!STACK_INIT(parser, parser->aliases, yaml_alias_data_t*))
94− goto error;
95−
96− parser->document = document;
97−
98− if (!yaml_parser_load_document(parser, &event)) goto error;
99−
100− yaml_parser_delete_aliases(parser);
101− parser->document = NULL;
102−
103− return 1;
104−
105−error:
106−
107− yaml_parser_delete_aliases(parser);
108− yaml_document_delete(document);
109− parser->document = NULL;
110−
111− return 0;
112−}
113−
114−/*
115− * Set composer error.
116− */
117−
118−static int
119−yaml_parser_set_composer_error(yaml_parser_t *parser,
120− const char *problem, yaml_mark_t problem_mark)
121−{
122− parser->error = YAML_COMPOSER_ERROR;
123− parser->problem = problem;
124− parser->problem_mark = problem_mark;
125−
126− return 0;
127−}
128−
129−/*
130− * Set composer error with context.
131− */
132−
133−static int
134−yaml_parser_set_composer_error_context(yaml_parser_t *parser,
135− const char *context, yaml_mark_t context_mark,
136− const char *problem, yaml_mark_t problem_mark)
137−{
138− parser->error = YAML_COMPOSER_ERROR;
139− parser->context = context;
140− parser->context_mark = context_mark;
141− parser->problem = problem;
142− parser->problem_mark = problem_mark;
143−
144− return 0;
145−}
146−
147−/*
148− * Delete the stack of aliases.
149− */
150−
151−static void
152−yaml_parser_delete_aliases(yaml_parser_t *parser)
153−{
154− while (!STACK_EMPTY(parser, parser->aliases)) {
155− yaml_free(POP(parser, parser->aliases).anchor);
156− }
157− STACK_DEL(parser, parser->aliases);
158−}
159−
160−/*
161− * Compose a document object.
162− */
163−
164−static int
165−yaml_parser_load_document(yaml_parser_t *parser, yaml_event_t *first_event)
166−{
167− yaml_event_t event;
168−
169− assert(first_event->type == YAML_DOCUMENT_START_EVENT);
170− /* DOCUMENT-START is expected. */
171−
172− parser->document->version_directive
173− = first_event->data.document_start.version_directive;
174− parser->document->tag_directives.start
175− = first_event->data.document_start.tag_directives.start;
176− parser->document->tag_directives.end
177− = first_event->data.document_start.tag_directives.end;
178− parser->document->start_implicit
179− = first_event->data.document_start.implicit;
180− parser->document->start_mark = first_event->start_mark;
181−
182− if (!yaml_parser_parse(parser, &event)) return 0;
183−
184− if (!yaml_parser_load_node(parser, &event)) return 0;
185−
186− if (!yaml_parser_parse(parser, &event)) return 0;
187− assert(event.type == YAML_DOCUMENT_END_EVENT);
188− /* DOCUMENT-END is expected. */
189−
190− parser->document->end_implicit = event.data.document_end.implicit;
191− parser->document->end_mark = event.end_mark;
192−
193− return 1;
194−}
195−
196−/*
197− * Compose a node.
198− */
199−
200−static int
201−yaml_parser_load_node(yaml_parser_t *parser, yaml_event_t *first_event)
202−{
203− switch (first_event->type) {
204− case YAML_ALIAS_EVENT:
205− return yaml_parser_load_alias(parser, first_event);
206− case YAML_SCALAR_EVENT:
207− return yaml_parser_load_scalar(parser, first_event);
208− case YAML_SEQUENCE_START_EVENT:
209− return yaml_parser_load_sequence(parser, first_event);
210− case YAML_MAPPING_START_EVENT:
211− return yaml_parser_load_mapping(parser, first_event);
212− default:
213− assert(0); /* Could not happen. */
214− return 0;
215− }
216−
217− return 0;
218−}
219−
220−/*
221− * Add an anchor.
222− */
223−
224−static int
225−yaml_parser_register_anchor(yaml_parser_t *parser,
226− int index, yaml_char_t *anchor)
227−{
228− yaml_alias_data_t data;
229− yaml_alias_data_t *alias_data;
230−
231− if (!anchor) return 1;
232−
233− data.anchor = anchor;
234− data.index = index;
235− data.mark = parser->document->nodes.start[index-1].start_mark;
236−
237− for (alias_data = parser->aliases.start;
238− alias_data != parser->aliases.top; alias_data ++) {
239− if (strcmp((char *)alias_data->anchor, (char *)anchor) == 0) {
240− yaml_free(anchor);
241− return yaml_parser_set_composer_error_context(parser,
242− "found duplicate anchor; first occurrence",
243− alias_data->mark, "second occurrence", data.mark);
244− }
245− }
246−
247− if (!PUSH(parser, parser->aliases, data)) {
248− yaml_free(anchor);
249− return 0;
250− }
251−
252− return 1;
253−}
254−
255−/*
256− * Compose a node corresponding to an alias.
257− */
258−
259−static int
260−yaml_parser_load_alias(yaml_parser_t *parser, yaml_event_t *first_event)
261−{
262− yaml_char_t *anchor = first_event->data.alias.anchor;
263− yaml_alias_data_t *alias_data;
264−
265− for (alias_data = parser->aliases.start;
266− alias_data != parser->aliases.top; alias_data ++) {
267− if (strcmp((char *)alias_data->anchor, (char *)anchor) == 0) {
268− yaml_free(anchor);
269− return alias_data->index;
270− }
271− }
272−
273− yaml_free(anchor);
274− return yaml_parser_set_composer_error(parser, "found undefined alias",
275− first_event->start_mark);
276−}
277−
278−/*
279− * Compose a scalar node.
280− */
281−
282−static int
283−yaml_parser_load_scalar(yaml_parser_t *parser, yaml_event_t *first_event)
284−{
285− yaml_node_t node;
286− int index;
287− yaml_char_t *tag = first_event->data.scalar.tag;
288−
289− if (!STACK_LIMIT(parser, parser->document->nodes, INT_MAX-1)) goto error;
290−
291− if (!tag || strcmp((char *)tag, "!") == 0) {
292− yaml_free(tag);
293− tag = yaml_strdup((yaml_char_t *)YAML_DEFAULT_SCALAR_TAG);
294− if (!tag) goto error;
295− }
296−
297− SCALAR_NODE_INIT(node, tag, first_event->data.scalar.value,
298− first_event->data.scalar.length, first_event->data.scalar.style,
299− first_event->start_mark, first_event->end_mark);
300−
301− if (!PUSH(parser, parser->document->nodes, node)) goto error;
302−
303− index = parser->document->nodes.top - parser->document->nodes.start;
304−
305− if (!yaml_parser_register_anchor(parser, index,
306− first_event->data.scalar.anchor)) return 0;
307−
308− return index;
309−
310−error:
311− yaml_free(tag);
312− yaml_free(first_event->data.scalar.anchor);
313− yaml_free(first_event->data.scalar.value);
314− return 0;
315−}
316−
317−/*
318− * Compose a sequence node.
319− */
320−
321−static int
322−yaml_parser_load_sequence(yaml_parser_t *parser, yaml_event_t *first_event)
323−{
324− yaml_event_t event;
325− yaml_node_t node;
326− struct {
327− yaml_node_item_t *start;
328− yaml_node_item_t *end;
329− yaml_node_item_t *top;
330− } items = { NULL, NULL, NULL };
331− int index, item_index;
332− yaml_char_t *tag = first_event->data.sequence_start.tag;
333−
334− if (!STACK_LIMIT(parser, parser->document->nodes, INT_MAX-1)) goto error;
335−
336− if (!tag || strcmp((char *)tag, "!") == 0) {
337− yaml_free(tag);
338− tag = yaml_strdup((yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG);
339− if (!tag) goto error;
340− }
341−
342− if (!STACK_INIT(parser, items, yaml_node_item_t*)) goto error;
343−
344− SEQUENCE_NODE_INIT(node, tag, items.start, items.end,
345− first_event->data.sequence_start.style,
346− first_event->start_mark, first_event->end_mark);
347−
348− if (!PUSH(parser, parser->document->nodes, node)) goto error;
349−
350− index = parser->document->nodes.top - parser->document->nodes.start;
351−
352− if (!yaml_parser_register_anchor(parser, index,
353− first_event->data.sequence_start.anchor)) return 0;
354−
355− if (!yaml_parser_parse(parser, &event)) return 0;
356−
357− while (event.type != YAML_SEQUENCE_END_EVENT) {
358− if (!STACK_LIMIT(parser,
359− parser->document->nodes.start[index-1].data.sequence.items,
360− INT_MAX-1)) return 0;
361− item_index = yaml_parser_load_node(parser, &event);
362− if (!item_index) return 0;
363− if (!PUSH(parser,
364− parser->document->nodes.start[index-1].data.sequence.items,
365− item_index)) return 0;
366− if (!yaml_parser_parse(parser, &event)) return 0;
367− }
368−
369− parser->document->nodes.start[index-1].end_mark = event.end_mark;
370−
371− return index;
372−
373−error:
374− yaml_free(tag);
375− yaml_free(first_event->data.sequence_start.anchor);
376− return 0;
377−}
378−
379−/*
380− * Compose a mapping node.
381− */
382−
383−static int
384−yaml_parser_load_mapping(yaml_parser_t *parser, yaml_event_t *first_event)
385−{
386− yaml_event_t event;
387− yaml_node_t node;
388− struct {
389− yaml_node_pair_t *start;
390− yaml_node_pair_t *end;
391− yaml_node_pair_t *top;
392− } pairs = { NULL, NULL, NULL };
393− int index;
394− yaml_node_pair_t pair;
395− yaml_char_t *tag = first_event->data.mapping_start.tag;
396−
397− if (!STACK_LIMIT(parser, parser->document->nodes, INT_MAX-1)) goto error;
398−
399− if (!tag || strcmp((char *)tag, "!") == 0) {
400− yaml_free(tag);
401− tag = yaml_strdup((yaml_char_t *)YAML_DEFAULT_MAPPING_TAG);
402− if (!tag) goto error;
403− }
404−
405− if (!STACK_INIT(parser, pairs, yaml_node_pair_t*)) goto error;
406−
407− MAPPING_NODE_INIT(node, tag, pairs.start, pairs.end,
408− first_event->data.mapping_start.style,
409− first_event->start_mark, first_event->end_mark);
410−
411− if (!PUSH(parser, parser->document->nodes, node)) goto error;
412−
413− index = parser->document->nodes.top - parser->document->nodes.start;
414−
415− if (!yaml_parser_register_anchor(parser, index,
416− first_event->data.mapping_start.anchor)) return 0;
417−
418− if (!yaml_parser_parse(parser, &event)) return 0;
419−
420− while (event.type != YAML_MAPPING_END_EVENT) {
421− if (!STACK_LIMIT(parser,
422− parser->document->nodes.start[index-1].data.mapping.pairs,
423− INT_MAX-1)) return 0;
424− pair.key = yaml_parser_load_node(parser, &event);
425− if (!pair.key) return 0;
426− if (!yaml_parser_parse(parser, &event)) return 0;
427− pair.value = yaml_parser_load_node(parser, &event);
428− if (!pair.value) return 0;
429− if (!PUSH(parser,
430− parser->document->nodes.start[index-1].data.mapping.pairs,
431− pair)) return 0;
432− if (!yaml_parser_parse(parser, &event)) return 0;
433− }
434−
435− parser->document->nodes.start[index-1].end_mark = event.end_mark;
436−
437− return index;
438−
439−error:
440− yaml_free(tag);
441− yaml_free(first_event->data.mapping_start.anchor);
442− return 0;
443−}
444−
libyaml/libyaml_src/parser.cdeleted−1372
@@ -1,1372 +0,0 @@
1−
2−/*
3− * The parser implements the following grammar:
4− *
5− * stream ::= STREAM-START implicit_document? explicit_document* STREAM-END
6− * implicit_document ::= block_node DOCUMENT-END*
7− * explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
8− * block_node_or_indentless_sequence ::=
9− * ALIAS
10− * | properties (block_content | indentless_block_sequence)?
11− * | block_content
12− * | indentless_block_sequence
13− * block_node ::= ALIAS
14− * | properties block_content?
15− * | block_content
16− * flow_node ::= ALIAS
17− * | properties flow_content?
18− * | flow_content
19− * properties ::= TAG ANCHOR? | ANCHOR TAG?
20− * block_content ::= block_collection | flow_collection | SCALAR
21− * flow_content ::= flow_collection | SCALAR
22− * block_collection ::= block_sequence | block_mapping
23− * flow_collection ::= flow_sequence | flow_mapping
24− * block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
25− * indentless_sequence ::= (BLOCK-ENTRY block_node?)+
26− * block_mapping ::= BLOCK-MAPPING_START
27− * ((KEY block_node_or_indentless_sequence?)?
28− * (VALUE block_node_or_indentless_sequence?)?)*
29− * BLOCK-END
30− * flow_sequence ::= FLOW-SEQUENCE-START
31− * (flow_sequence_entry FLOW-ENTRY)*
32− * flow_sequence_entry?
33− * FLOW-SEQUENCE-END
34− * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
35− * flow_mapping ::= FLOW-MAPPING-START
36− * (flow_mapping_entry FLOW-ENTRY)*
37− * flow_mapping_entry?
38− * FLOW-MAPPING-END
39− * flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
40− */
41−
42−#include "yaml_private.h"
43−
44−/*
45− * Peek the next token in the token queue.
46− */
47−
48−#define PEEK_TOKEN(parser) \
49− ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \
50− parser->tokens.head : NULL)
51−
52−/*
53− * Remove the next token from the queue (must be called after PEEK_TOKEN).
54− */
55−
56−#define SKIP_TOKEN(parser) \
57− (parser->token_available = 0, \
58− parser->tokens_parsed ++, \
59− parser->stream_end_produced = \
60− (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \
61− parser->tokens.head ++)
62−
63−/*
64− * Public API declarations.
65− */
66−
67−YAML_DECLARE(int)
68−yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event);
69−
70−/*
71− * Error handling.
72− */
73−
74−static int
75−yaml_parser_set_parser_error(yaml_parser_t *parser,
76− const char *problem, yaml_mark_t problem_mark);
77−
78−static int
79−yaml_parser_set_parser_error_context(yaml_parser_t *parser,
80− const char *context, yaml_mark_t context_mark,
81− const char *problem, yaml_mark_t problem_mark);
82−
83−/*
84− * State functions.
85− */
86−
87−static int
88−yaml_parser_state_machine(yaml_parser_t *parser, yaml_event_t *event);
89−
90−static int
91−yaml_parser_parse_stream_start(yaml_parser_t *parser, yaml_event_t *event);
92−
93−static int
94−yaml_parser_parse_document_start(yaml_parser_t *parser, yaml_event_t *event,
95− int implicit);
96−
97−static int
98−yaml_parser_parse_document_content(yaml_parser_t *parser, yaml_event_t *event);
99−
100−static int
101−yaml_parser_parse_document_end(yaml_parser_t *parser, yaml_event_t *event);
102−
103−static int
104−yaml_parser_parse_node(yaml_parser_t *parser, yaml_event_t *event,
105− int block, int indentless_sequence);
106−
107−static int
108−yaml_parser_parse_block_sequence_entry(yaml_parser_t *parser,
109− yaml_event_t *event, int first);
110−
111−static int
112−yaml_parser_parse_indentless_sequence_entry(yaml_parser_t *parser,
113− yaml_event_t *event);
114−
115−static int
116−yaml_parser_parse_block_mapping_key(yaml_parser_t *parser,
117− yaml_event_t *event, int first);
118−
119−static int
120−yaml_parser_parse_block_mapping_value(yaml_parser_t *parser,
121− yaml_event_t *event);
122−
123−static int
124−yaml_parser_parse_flow_sequence_entry(yaml_parser_t *parser,
125− yaml_event_t *event, int first);
126−
127−static int
128−yaml_parser_parse_flow_sequence_entry_mapping_key(yaml_parser_t *parser,
129− yaml_event_t *event);
130−
131−static int
132−yaml_parser_parse_flow_sequence_entry_mapping_value(yaml_parser_t *parser,
133− yaml_event_t *event);
134−
135−static int
136−yaml_parser_parse_flow_sequence_entry_mapping_end(yaml_parser_t *parser,
137− yaml_event_t *event);
138−
139−static int
140−yaml_parser_parse_flow_mapping_key(yaml_parser_t *parser,
141− yaml_event_t *event, int first);
142−
143−static int
144−yaml_parser_parse_flow_mapping_value(yaml_parser_t *parser,
145− yaml_event_t *event, int empty);
146−
147−/*
148− * Utility functions.
149− */
150−
151−static int
152−yaml_parser_process_empty_scalar(yaml_parser_t *parser,
153− yaml_event_t *event, yaml_mark_t mark);
154−
155−static int
156−yaml_parser_process_directives(yaml_parser_t *parser,
157− yaml_version_directive_t **version_directive_ref,
158− yaml_tag_directive_t **tag_directives_start_ref,
159− yaml_tag_directive_t **tag_directives_end_ref);
160−
161−static int
162−yaml_parser_append_tag_directive(yaml_parser_t *parser,
163− yaml_tag_directive_t value, int allow_duplicates, yaml_mark_t mark);
164−
165−/*
166− * Get the next event.
167− */
168−
169−YAML_DECLARE(int)
170−yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event)
171−{
172− assert(parser); /* Non-NULL parser object is expected. */
173− assert(event); /* Non-NULL event object is expected. */
174−
175− /* Erase the event object. */
176−
177− memset(event, 0, sizeof(yaml_event_t));
178−
179− /* No events after the end of the stream or error. */
180−
181− if (parser->stream_end_produced || parser->error ||
182− parser->state == YAML_PARSE_END_STATE) {
183− return 1;
184− }
185−
186− /* Generate the next event. */
187−
188− return yaml_parser_state_machine(parser, event);
189−}
190−
191−/*
192− * Set parser error.
193− */
194−
195−static int
196−yaml_parser_set_parser_error(yaml_parser_t *parser,
197− const char *problem, yaml_mark_t problem_mark)
198−{
199− parser->error = YAML_PARSER_ERROR;
200− parser->problem = problem;
201− parser->problem_mark = problem_mark;
202−
203− return 0;
204−}
205−
206−static int
207−yaml_parser_set_parser_error_context(yaml_parser_t *parser,
208− const char *context, yaml_mark_t context_mark,
209− const char *problem, yaml_mark_t problem_mark)
210−{
211− parser->error = YAML_PARSER_ERROR;
212− parser->context = context;
213− parser->context_mark = context_mark;
214− parser->problem = problem;
215− parser->problem_mark = problem_mark;
216−
217− return 0;
218−}
219−
220−
221−/*
222− * State dispatcher.
223− */
224−
225−static int
226−yaml_parser_state_machine(yaml_parser_t *parser, yaml_event_t *event)
227−{
228− switch (parser->state)
229− {
230− case YAML_PARSE_STREAM_START_STATE:
231− return yaml_parser_parse_stream_start(parser, event);
232−
233− case YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE:
234− return yaml_parser_parse_document_start(parser, event, 1);
235−
236− case YAML_PARSE_DOCUMENT_START_STATE:
237− return yaml_parser_parse_document_start(parser, event, 0);
238−
239− case YAML_PARSE_DOCUMENT_CONTENT_STATE:
240− return yaml_parser_parse_document_content(parser, event);
241−
242− case YAML_PARSE_DOCUMENT_END_STATE:
243− return yaml_parser_parse_document_end(parser, event);
244−
245− case YAML_PARSE_BLOCK_NODE_STATE:
246− return yaml_parser_parse_node(parser, event, 1, 0);
247−
248− case YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE:
249− return yaml_parser_parse_node(parser, event, 1, 1);
250−
251− case YAML_PARSE_FLOW_NODE_STATE:
252− return yaml_parser_parse_node(parser, event, 0, 0);
253−
254− case YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE:
255− return yaml_parser_parse_block_sequence_entry(parser, event, 1);
256−
257− case YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE:
258− return yaml_parser_parse_block_sequence_entry(parser, event, 0);
259−
260− case YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE:
261− return yaml_parser_parse_indentless_sequence_entry(parser, event);
262−
263− case YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE:
264− return yaml_parser_parse_block_mapping_key(parser, event, 1);
265−
266− case YAML_PARSE_BLOCK_MAPPING_KEY_STATE:
267− return yaml_parser_parse_block_mapping_key(parser, event, 0);
268−
269− case YAML_PARSE_BLOCK_MAPPING_VALUE_STATE:
270− return yaml_parser_parse_block_mapping_value(parser, event);
271−
272− case YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE:
273− return yaml_parser_parse_flow_sequence_entry(parser, event, 1);
274−
275− case YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE:
276− return yaml_parser_parse_flow_sequence_entry(parser, event, 0);
277−
278− case YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE:
279− return yaml_parser_parse_flow_sequence_entry_mapping_key(parser, event);
280−
281− case YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE:
282− return yaml_parser_parse_flow_sequence_entry_mapping_value(parser, event);
283−
284− case YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE:
285− return yaml_parser_parse_flow_sequence_entry_mapping_end(parser, event);
286−
287− case YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE:
288− return yaml_parser_parse_flow_mapping_key(parser, event, 1);
289−
290− case YAML_PARSE_FLOW_MAPPING_KEY_STATE:
291− return yaml_parser_parse_flow_mapping_key(parser, event, 0);
292−
293− case YAML_PARSE_FLOW_MAPPING_VALUE_STATE:
294− return yaml_parser_parse_flow_mapping_value(parser, event, 0);
295−
296− case YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE:
297− return yaml_parser_parse_flow_mapping_value(parser, event, 1);
298−
299− default:
300− assert(1); /* Invalid state. */
301− }
302−
303− return 0;
304−}
305−
306−/*
307− * Parse the production:
308− * stream ::= STREAM-START implicit_document? explicit_document* STREAM-END
309− * ************
310− */
311−
312−static int
313−yaml_parser_parse_stream_start(yaml_parser_t *parser, yaml_event_t *event)
314−{
315− yaml_token_t *token;
316−
317− token = PEEK_TOKEN(parser);
318− if (!token) return 0;
319−
320− if (token->type != YAML_STREAM_START_TOKEN) {
321− return yaml_parser_set_parser_error(parser,
322− "did not find expected <stream-start>", token->start_mark);
323− }
324−
325− parser->state = YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE;
326− STREAM_START_EVENT_INIT(*event, token->data.stream_start.encoding,
327− token->start_mark, token->start_mark);
328− SKIP_TOKEN(parser);
329−
330− return 1;
331−}
332−
333−/*
334− * Parse the productions:
335− * implicit_document ::= block_node DOCUMENT-END*
336− * *
337− * explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
338− * *************************
339− */
340−
341−static int
342−yaml_parser_parse_document_start(yaml_parser_t *parser, yaml_event_t *event,
343− int implicit)
344−{
345− yaml_token_t *token;
346− yaml_version_directive_t *version_directive = NULL;
347− struct {
348− yaml_tag_directive_t *start;
349− yaml_tag_directive_t *end;
350− } tag_directives = { NULL, NULL };
351−
352− token = PEEK_TOKEN(parser);
353− if (!token) return 0;
354−
355− /* Parse extra document end indicators. */
356−
357− if (!implicit)
358− {
359− while (token->type == YAML_DOCUMENT_END_TOKEN) {
360− SKIP_TOKEN(parser);
361− token = PEEK_TOKEN(parser);
362− if (!token) return 0;
363− }
364− }
365−
366− /* Parse an implicit document. */
367−
368− if (implicit && token->type != YAML_VERSION_DIRECTIVE_TOKEN &&
369− token->type != YAML_TAG_DIRECTIVE_TOKEN &&
370− token->type != YAML_DOCUMENT_START_TOKEN &&
371− token->type != YAML_STREAM_END_TOKEN)
372− {
373− if (!yaml_parser_process_directives(parser, NULL, NULL, NULL))
374− return 0;
375− if (!PUSH(parser, parser->states, YAML_PARSE_DOCUMENT_END_STATE))
376− return 0;
377− parser->state = YAML_PARSE_BLOCK_NODE_STATE;
378− DOCUMENT_START_EVENT_INIT(*event, NULL, NULL, NULL, 1,
379− token->start_mark, token->start_mark);
380− return 1;
381− }
382−
383− /* Parse an explicit document. */
384−
385− else if (token->type != YAML_STREAM_END_TOKEN)
386− {
387− yaml_mark_t start_mark, end_mark;
388− start_mark = token->start_mark;
389− if (!yaml_parser_process_directives(parser, &version_directive,
390− &tag_directives.start, &tag_directives.end))
391− return 0;
392− token = PEEK_TOKEN(parser);
393− if (!token) goto error;
394− if (token->type != YAML_DOCUMENT_START_TOKEN) {
395− yaml_parser_set_parser_error(parser,
396− "did not find expected <document start>", token->start_mark);
397− goto error;
398− }
399− if (!PUSH(parser, parser->states, YAML_PARSE_DOCUMENT_END_STATE))
400− goto error;
401− parser->state = YAML_PARSE_DOCUMENT_CONTENT_STATE;
402− end_mark = token->end_mark;
403− DOCUMENT_START_EVENT_INIT(*event, version_directive,
404− tag_directives.start, tag_directives.end, 0,
405− start_mark, end_mark);
406− SKIP_TOKEN(parser);
407− version_directive = NULL;
408− tag_directives.start = tag_directives.end = NULL;
409− return 1;
410− }
411−
412− /* Parse the stream end. */
413−
414− else
415− {
416− parser->state = YAML_PARSE_END_STATE;
417− STREAM_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
418− SKIP_TOKEN(parser);
419− return 1;
420− }
421−
422−error:
423− yaml_free(version_directive);
424− while (tag_directives.start != tag_directives.end) {
425− yaml_free(tag_directives.end[-1].handle);
426− yaml_free(tag_directives.end[-1].prefix);
427− tag_directives.end --;
428− }
429− yaml_free(tag_directives.start);
430− return 0;
431−}
432−
433−/*
434− * Parse the productions:
435− * explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
436− * ***********
437− */
438−
439−static int
440−yaml_parser_parse_document_content(yaml_parser_t *parser, yaml_event_t *event)
441−{
442− yaml_token_t *token;
443−
444− token = PEEK_TOKEN(parser);
445− if (!token) return 0;
446−
447− if (token->type == YAML_VERSION_DIRECTIVE_TOKEN ||
448− token->type == YAML_TAG_DIRECTIVE_TOKEN ||
449− token->type == YAML_DOCUMENT_START_TOKEN ||
450− token->type == YAML_DOCUMENT_END_TOKEN ||
451− token->type == YAML_STREAM_END_TOKEN) {
452− parser->state = POP(parser, parser->states);
453− return yaml_parser_process_empty_scalar(parser, event,
454− token->start_mark);
455− }
456− else {
457− return yaml_parser_parse_node(parser, event, 1, 0);
458− }
459−}
460−
461−/*
462− * Parse the productions:
463− * implicit_document ::= block_node DOCUMENT-END*
464− * *************
465− * explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
466− * *************
467− */
468−
469−static int
470−yaml_parser_parse_document_end(yaml_parser_t *parser, yaml_event_t *event)
471−{
472− yaml_token_t *token;
473− yaml_mark_t start_mark, end_mark;
474− int implicit = 1;
475−
476− token = PEEK_TOKEN(parser);
477− if (!token) return 0;
478−
479− start_mark = end_mark = token->start_mark;
480−
481− if (token->type == YAML_DOCUMENT_END_TOKEN) {
482− end_mark = token->end_mark;
483− SKIP_TOKEN(parser);
484− implicit = 0;
485− }
486−
487− while (!STACK_EMPTY(parser, parser->tag_directives)) {
488− yaml_tag_directive_t tag_directive = POP(parser, parser->tag_directives);
489− yaml_free(tag_directive.handle);
490− yaml_free(tag_directive.prefix);
491− }
492−
493− parser->state = YAML_PARSE_DOCUMENT_START_STATE;
494− DOCUMENT_END_EVENT_INIT(*event, implicit, start_mark, end_mark);
495−
496− return 1;
497−}
498−
499−/*
500− * Parse the productions:
501− * block_node_or_indentless_sequence ::=
502− * ALIAS
503− * *****
504− * | properties (block_content | indentless_block_sequence)?
505− * ********** *
506− * | block_content | indentless_block_sequence
507− * *
508− * block_node ::= ALIAS
509− * *****
510− * | properties block_content?
511− * ********** *
512− * | block_content
513− * *
514− * flow_node ::= ALIAS
515− * *****
516− * | properties flow_content?
517− * ********** *
518− * | flow_content
519− * *
520− * properties ::= TAG ANCHOR? | ANCHOR TAG?
521− * *************************
522− * block_content ::= block_collection | flow_collection | SCALAR
523− * ******
524− * flow_content ::= flow_collection | SCALAR
525− * ******
526− */
527−
528−static int
529−yaml_parser_parse_node(yaml_parser_t *parser, yaml_event_t *event,
530− int block, int indentless_sequence)
531−{
532− yaml_token_t *token;
533− yaml_char_t *anchor = NULL;
534− yaml_char_t *tag_handle = NULL;
535− yaml_char_t *tag_suffix = NULL;
536− yaml_char_t *tag = NULL;
537− yaml_mark_t start_mark, end_mark, tag_mark;
538− int implicit;
539−
540− token = PEEK_TOKEN(parser);
541− if (!token) return 0;
542−
543− if (token->type == YAML_ALIAS_TOKEN)
544− {
545− parser->state = POP(parser, parser->states);
546− ALIAS_EVENT_INIT(*event, token->data.alias.value,
547− token->start_mark, token->end_mark);
548− SKIP_TOKEN(parser);
549− return 1;
550− }
551−
552− else
553− {
554− start_mark = end_mark = token->start_mark;
555−
556− if (token->type == YAML_ANCHOR_TOKEN)
557− {
558− anchor = token->data.anchor.value;
559− start_mark = token->start_mark;
560− end_mark = token->end_mark;
561− SKIP_TOKEN(parser);
562− token = PEEK_TOKEN(parser);
563− if (!token) goto error;
564− if (token->type == YAML_TAG_TOKEN)
565− {
566− tag_handle = token->data.tag.handle;
567− tag_suffix = token->data.tag.suffix;
568− tag_mark = token->start_mark;
569− end_mark = token->end_mark;
570− SKIP_TOKEN(parser);
571− token = PEEK_TOKEN(parser);
572− if (!token) goto error;
573− }
574− }
575− else if (token->type == YAML_TAG_TOKEN)
576− {
577− tag_handle = token->data.tag.handle;
578− tag_suffix = token->data.tag.suffix;
579− start_mark = tag_mark = token->start_mark;
580− end_mark = token->end_mark;
581− SKIP_TOKEN(parser);
582− token = PEEK_TOKEN(parser);
583− if (!token) goto error;
584− if (token->type == YAML_ANCHOR_TOKEN)
585− {
586− anchor = token->data.anchor.value;
587− end_mark = token->end_mark;
588− SKIP_TOKEN(parser);
589− token = PEEK_TOKEN(parser);
590− if (!token) goto error;
591− }
592− }
593−
594− if (tag_handle) {
595− if (!*tag_handle) {
596− tag = tag_suffix;
597− yaml_free(tag_handle);
598− tag_handle = tag_suffix = NULL;
599− }
600− else {
601− yaml_tag_directive_t *tag_directive;
602− for (tag_directive = parser->tag_directives.start;
603− tag_directive != parser->tag_directives.top;
604− tag_directive ++) {
605− if (strcmp((char *)tag_directive->handle, (char *)tag_handle) == 0) {
606− size_t prefix_len = strlen((char *)tag_directive->prefix);
607− size_t suffix_len = strlen((char *)tag_suffix);
608− tag = YAML_MALLOC(prefix_len+suffix_len+1);
609− if (!tag) {
610− parser->error = YAML_MEMORY_ERROR;
611− goto error;
612− }
613− memcpy(tag, tag_directive->prefix, prefix_len);
614− memcpy(tag+prefix_len, tag_suffix, suffix_len);
615− tag[prefix_len+suffix_len] = '\0';
616− yaml_free(tag_handle);
617− yaml_free(tag_suffix);
618− tag_handle = tag_suffix = NULL;
619− break;
620− }
621− }
622− if (!tag) {
623− yaml_parser_set_parser_error_context(parser,
624− "while parsing a node", start_mark,
625− "found undefined tag handle", tag_mark);
626− goto error;
627− }
628− }
629− }
630−
631− implicit = (!tag || !*tag);
632− if (indentless_sequence && token->type == YAML_BLOCK_ENTRY_TOKEN) {
633− end_mark = token->end_mark;
634− parser->state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE;
635− SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit,
636− YAML_BLOCK_SEQUENCE_STYLE, start_mark, end_mark);
637− return 1;
638− }
639− else {
640− if (token->type == YAML_SCALAR_TOKEN) {
641− int plain_implicit = 0;
642− int quoted_implicit = 0;
643− end_mark = token->end_mark;
644− if ((token->data.scalar.style == YAML_PLAIN_SCALAR_STYLE && !tag)
645− || (tag && strcmp((char *)tag, "!") == 0)) {
646− plain_implicit = 1;
647− }
648− else if (!tag) {
649− quoted_implicit = 1;
650− }
651− parser->state = POP(parser, parser->states);
652− SCALAR_EVENT_INIT(*event, anchor, tag,
653− token->data.scalar.value, token->data.scalar.length,
654− plain_implicit, quoted_implicit,
655− token->data.scalar.style, start_mark, end_mark);
656− SKIP_TOKEN(parser);
657− return 1;
658− }
659− else if (token->type == YAML_FLOW_SEQUENCE_START_TOKEN) {
660− end_mark = token->end_mark;
661− parser->state = YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE;
662− SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit,
663− YAML_FLOW_SEQUENCE_STYLE, start_mark, end_mark);
664− return 1;
665− }
666− else if (token->type == YAML_FLOW_MAPPING_START_TOKEN) {
667− end_mark = token->end_mark;
668− parser->state = YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE;
669− MAPPING_START_EVENT_INIT(*event, anchor, tag, implicit,
670− YAML_FLOW_MAPPING_STYLE, start_mark, end_mark);
671− return 1;
672− }
673− else if (block && token->type == YAML_BLOCK_SEQUENCE_START_TOKEN) {
674− end_mark = token->end_mark;
675− parser->state = YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE;
676− SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit,
677− YAML_BLOCK_SEQUENCE_STYLE, start_mark, end_mark);
678− return 1;
679− }
680− else if (block && token->type == YAML_BLOCK_MAPPING_START_TOKEN) {
681− end_mark = token->end_mark;
682− parser->state = YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE;
683− MAPPING_START_EVENT_INIT(*event, anchor, tag, implicit,
684− YAML_BLOCK_MAPPING_STYLE, start_mark, end_mark);
685− return 1;
686− }
687− else if (anchor || tag) {
688− yaml_char_t *value = YAML_MALLOC(1);
689− if (!value) {
690− parser->error = YAML_MEMORY_ERROR;
691− goto error;
692− }
693− value[0] = '\0';
694− parser->state = POP(parser, parser->states);
695− SCALAR_EVENT_INIT(*event, anchor, tag, value, 0,
696− implicit, 0, YAML_PLAIN_SCALAR_STYLE,
697− start_mark, end_mark);
698− return 1;
699− }
700− else {
701− yaml_parser_set_parser_error_context(parser,
702− (block ? "while parsing a block node"
703− : "while parsing a flow node"), start_mark,
704− "did not find expected node content", token->start_mark);
705− goto error;
706− }
707− }
708− }
709−
710−error:
711− yaml_free(anchor);
712− yaml_free(tag_handle);
713− yaml_free(tag_suffix);
714− yaml_free(tag);
715−
716− return 0;
717−}
718−
719−/*
720− * Parse the productions:
721− * block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
722− * ******************** *********** * *********
723− */
724−
725−static int
726−yaml_parser_parse_block_sequence_entry(yaml_parser_t *parser,
727− yaml_event_t *event, int first)
728−{
729− yaml_token_t *token;
730−
731− if (first) {
732− token = PEEK_TOKEN(parser);
733− if (!PUSH(parser, parser->marks, token->start_mark))
734− return 0;
735− SKIP_TOKEN(parser);
736− }
737−
738− token = PEEK_TOKEN(parser);
739− if (!token) return 0;
740−
741− if (token->type == YAML_BLOCK_ENTRY_TOKEN)
742− {
743− yaml_mark_t mark = token->end_mark;
744− SKIP_TOKEN(parser);
745− token = PEEK_TOKEN(parser);
746− if (!token) return 0;
747− if (token->type != YAML_BLOCK_ENTRY_TOKEN &&
748− token->type != YAML_BLOCK_END_TOKEN) {
749− if (!PUSH(parser, parser->states,
750− YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE))
751− return 0;
752− return yaml_parser_parse_node(parser, event, 1, 0);
753− }
754− else {
755− parser->state = YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE;
756− return yaml_parser_process_empty_scalar(parser, event, mark);
757− }
758− }
759−
760− else if (token->type == YAML_BLOCK_END_TOKEN)
761− {
762− parser->state = POP(parser, parser->states);
763− (void)POP(parser, parser->marks);
764− SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
765− SKIP_TOKEN(parser);
766− return 1;
767− }
768−
769− else
770− {
771− return yaml_parser_set_parser_error_context(parser,
772− "while parsing a block collection", POP(parser, parser->marks),
773− "did not find expected '-' indicator", token->start_mark);
774− }
775−}
776−
777−/*
778− * Parse the productions:
779− * indentless_sequence ::= (BLOCK-ENTRY block_node?)+
780− * *********** *
781− */
782−
783−static int
784−yaml_parser_parse_indentless_sequence_entry(yaml_parser_t *parser,
785− yaml_event_t *event)
786−{
787− yaml_token_t *token;
788−
789− token = PEEK_TOKEN(parser);
790− if (!token) return 0;
791−
792− if (token->type == YAML_BLOCK_ENTRY_TOKEN)
793− {
794− yaml_mark_t mark = token->end_mark;
795− SKIP_TOKEN(parser);
796− token = PEEK_TOKEN(parser);
797− if (!token) return 0;
798− if (token->type != YAML_BLOCK_ENTRY_TOKEN &&
799− token->type != YAML_KEY_TOKEN &&
800− token->type != YAML_VALUE_TOKEN &&
801− token->type != YAML_BLOCK_END_TOKEN) {
802− if (!PUSH(parser, parser->states,
803− YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE))
804− return 0;
805− return yaml_parser_parse_node(parser, event, 1, 0);
806− }
807− else {
808− parser->state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE;
809− return yaml_parser_process_empty_scalar(parser, event, mark);
810− }
811− }
812−
813− else
814− {
815− parser->state = POP(parser, parser->states);
816− SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->start_mark);
817− return 1;
818− }
819−}
820−
821−/*
822− * Parse the productions:
823− * block_mapping ::= BLOCK-MAPPING_START
824− * *******************
825− * ((KEY block_node_or_indentless_sequence?)?
826− * *** *
827− * (VALUE block_node_or_indentless_sequence?)?)*
828− *
829− * BLOCK-END
830− * *********
831− */
832−
833−static int
834−yaml_parser_parse_block_mapping_key(yaml_parser_t *parser,
835− yaml_event_t *event, int first)
836−{
837− yaml_token_t *token;
838−
839− if (first) {
840− token = PEEK_TOKEN(parser);
841− if (!PUSH(parser, parser->marks, token->start_mark))
842− return 0;
843− SKIP_TOKEN(parser);
844− }
845−
846− token = PEEK_TOKEN(parser);
847− if (!token) return 0;
848−
849− if (token->type == YAML_KEY_TOKEN)
850− {
851− yaml_mark_t mark = token->end_mark;
852− SKIP_TOKEN(parser);
853− token = PEEK_TOKEN(parser);
854− if (!token) return 0;
855− if (token->type != YAML_KEY_TOKEN &&
856− token->type != YAML_VALUE_TOKEN &&
857− token->type != YAML_BLOCK_END_TOKEN) {
858− if (!PUSH(parser, parser->states,
859− YAML_PARSE_BLOCK_MAPPING_VALUE_STATE))
860− return 0;
861− return yaml_parser_parse_node(parser, event, 1, 1);
862− }
863− else {
864− parser->state = YAML_PARSE_BLOCK_MAPPING_VALUE_STATE;
865− return yaml_parser_process_empty_scalar(parser, event, mark);
866− }
867− }
868−
869− else if (token->type == YAML_BLOCK_END_TOKEN)
870− {
871− parser->state = POP(parser, parser->states);
872− (void)POP(parser, parser->marks);
873− MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
874− SKIP_TOKEN(parser);
875− return 1;
876− }
877−
878− else
879− {
880− return yaml_parser_set_parser_error_context(parser,
881− "while parsing a block mapping", POP(parser, parser->marks),
882− "did not find expected key", token->start_mark);
883− }
884−}
885−
886−/*
887− * Parse the productions:
888− * block_mapping ::= BLOCK-MAPPING_START
889− *
890− * ((KEY block_node_or_indentless_sequence?)?
891− *
892− * (VALUE block_node_or_indentless_sequence?)?)*
893− * ***** *
894− * BLOCK-END
895− *
896− */
897−
898−static int
899−yaml_parser_parse_block_mapping_value(yaml_parser_t *parser,
900− yaml_event_t *event)
901−{
902− yaml_token_t *token;
903−
904− token = PEEK_TOKEN(parser);
905− if (!token) return 0;
906−
907− if (token->type == YAML_VALUE_TOKEN)
908− {
909− yaml_mark_t mark = token->end_mark;
910− SKIP_TOKEN(parser);
911− token = PEEK_TOKEN(parser);
912− if (!token) return 0;
913− if (token->type != YAML_KEY_TOKEN &&
914− token->type != YAML_VALUE_TOKEN &&
915− token->type != YAML_BLOCK_END_TOKEN) {
916− if (!PUSH(parser, parser->states,
917− YAML_PARSE_BLOCK_MAPPING_KEY_STATE))
918− return 0;
919− return yaml_parser_parse_node(parser, event, 1, 1);
920− }
921− else {
922− parser->state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE;
923− return yaml_parser_process_empty_scalar(parser, event, mark);
924− }
925− }
926−
927− else
928− {
929− parser->state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE;
930− return yaml_parser_process_empty_scalar(parser, event, token->start_mark);
931− }
932−}
933−
934−/*
935− * Parse the productions:
936− * flow_sequence ::= FLOW-SEQUENCE-START
937− * *******************
938− * (flow_sequence_entry FLOW-ENTRY)*
939− * * **********
940− * flow_sequence_entry?
941− * *
942− * FLOW-SEQUENCE-END
943− * *****************
944− * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
945− * *
946− */
947−
948−static int
949−yaml_parser_parse_flow_sequence_entry(yaml_parser_t *parser,
950− yaml_event_t *event, int first)
951−{
952− yaml_token_t *token;
953−
954− if (first) {
955− token = PEEK_TOKEN(parser);
956− if (!PUSH(parser, parser->marks, token->start_mark))
957− return 0;
958− SKIP_TOKEN(parser);
959− }
960−
961− token = PEEK_TOKEN(parser);
962− if (!token) return 0;
963−
964− if (token->type != YAML_FLOW_SEQUENCE_END_TOKEN)
965− {
966− if (!first) {
967− if (token->type == YAML_FLOW_ENTRY_TOKEN) {
968− SKIP_TOKEN(parser);
969− token = PEEK_TOKEN(parser);
970− if (!token) return 0;
971− }
972− else {
973− return yaml_parser_set_parser_error_context(parser,
974− "while parsing a flow sequence", POP(parser, parser->marks),
975− "did not find expected ',' or ']'", token->start_mark);
976− }
977− }
978−
979− if (token->type == YAML_KEY_TOKEN) {
980− parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE;
981− MAPPING_START_EVENT_INIT(*event, NULL, NULL,
982− 1, YAML_FLOW_MAPPING_STYLE,
983− token->start_mark, token->end_mark);
984− SKIP_TOKEN(parser);
985− return 1;
986− }
987−
988− else if (token->type != YAML_FLOW_SEQUENCE_END_TOKEN) {
989− if (!PUSH(parser, parser->states,
990− YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE))
991− return 0;
992− return yaml_parser_parse_node(parser, event, 0, 0);
993− }
994− }
995−
996− parser->state = POP(parser, parser->states);
997− (void)POP(parser, parser->marks);
998− SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
999− SKIP_TOKEN(parser);
1000− return 1;
1001−}
1002−
1003−/*
1004− * Parse the productions:
1005− * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
1006− * *** *
1007− */
1008−
1009−static int
1010−yaml_parser_parse_flow_sequence_entry_mapping_key(yaml_parser_t *parser,
1011− yaml_event_t *event)
1012−{
1013− yaml_token_t *token;
1014−
1015− token = PEEK_TOKEN(parser);
1016− if (!token) return 0;
1017−
1018− if (token->type != YAML_VALUE_TOKEN && token->type != YAML_FLOW_ENTRY_TOKEN
1019− && token->type != YAML_FLOW_SEQUENCE_END_TOKEN) {
1020− if (!PUSH(parser, parser->states,
1021− YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE))
1022− return 0;
1023− return yaml_parser_parse_node(parser, event, 0, 0);
1024− }
1025− else {
1026− yaml_mark_t mark = token->end_mark;
1027− SKIP_TOKEN(parser);
1028− parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE;
1029− return yaml_parser_process_empty_scalar(parser, event, mark);
1030− }
1031−}
1032−
1033−/*
1034− * Parse the productions:
1035− * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
1036− * ***** *
1037− */
1038−
1039−static int
1040−yaml_parser_parse_flow_sequence_entry_mapping_value(yaml_parser_t *parser,
1041− yaml_event_t *event)
1042−{
1043− yaml_token_t *token;
1044−
1045− token = PEEK_TOKEN(parser);
1046− if (!token) return 0;
1047−
1048− if (token->type == YAML_VALUE_TOKEN) {
1049− SKIP_TOKEN(parser);
1050− token = PEEK_TOKEN(parser);
1051− if (!token) return 0;
1052− if (token->type != YAML_FLOW_ENTRY_TOKEN
1053− && token->type != YAML_FLOW_SEQUENCE_END_TOKEN) {
1054− if (!PUSH(parser, parser->states,
1055− YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE))
1056− return 0;
1057− return yaml_parser_parse_node(parser, event, 0, 0);
1058− }
1059− }
1060− parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE;
1061− return yaml_parser_process_empty_scalar(parser, event, token->start_mark);
1062−}
1063−
1064−/*
1065− * Parse the productions:
1066− * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
1067− * *
1068− */
1069−
1070−static int
1071−yaml_parser_parse_flow_sequence_entry_mapping_end(yaml_parser_t *parser,
1072− yaml_event_t *event)
1073−{
1074− yaml_token_t *token;
1075−
1076− token = PEEK_TOKEN(parser);
1077− if (!token) return 0;
1078−
1079− parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE;
1080−
1081− MAPPING_END_EVENT_INIT(*event, token->start_mark, token->start_mark);
1082− return 1;
1083−}
1084−
1085−/*
1086− * Parse the productions:
1087− * flow_mapping ::= FLOW-MAPPING-START
1088− * ******************
1089− * (flow_mapping_entry FLOW-ENTRY)*
1090− * * **********
1091− * flow_mapping_entry?
1092− * ******************
1093− * FLOW-MAPPING-END
1094− * ****************
1095− * flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
1096− * * *** *
1097− */
1098−
1099−static int
1100−yaml_parser_parse_flow_mapping_key(yaml_parser_t *parser,
1101− yaml_event_t *event, int first)
1102−{
1103− yaml_token_t *token;
1104−
1105− if (first) {
1106− token = PEEK_TOKEN(parser);
1107− if (!PUSH(parser, parser->marks, token->start_mark))
1108− return 0;
1109− SKIP_TOKEN(parser);
1110− }
1111−
1112− token = PEEK_TOKEN(parser);
1113− if (!token) return 0;
1114−
1115− if (token->type != YAML_FLOW_MAPPING_END_TOKEN)
1116− {
1117− if (!first) {
1118− if (token->type == YAML_FLOW_ENTRY_TOKEN) {
1119− SKIP_TOKEN(parser);
1120− token = PEEK_TOKEN(parser);
1121− if (!token) return 0;
1122− }
1123− else {
1124− return yaml_parser_set_parser_error_context(parser,
1125− "while parsing a flow mapping", POP(parser, parser->marks),
1126− "did not find expected ',' or '}'", token->start_mark);
1127− }
1128− }
1129−
1130− if (token->type == YAML_KEY_TOKEN) {
1131− SKIP_TOKEN(parser);
1132− token = PEEK_TOKEN(parser);
1133− if (!token) return 0;
1134− if (token->type != YAML_VALUE_TOKEN
1135− && token->type != YAML_FLOW_ENTRY_TOKEN
1136− && token->type != YAML_FLOW_MAPPING_END_TOKEN) {
1137− if (!PUSH(parser, parser->states,
1138− YAML_PARSE_FLOW_MAPPING_VALUE_STATE))
1139− return 0;
1140− return yaml_parser_parse_node(parser, event, 0, 0);
1141− }
1142− else {
1143− parser->state = YAML_PARSE_FLOW_MAPPING_VALUE_STATE;
1144− return yaml_parser_process_empty_scalar(parser, event,
1145− token->start_mark);
1146− }
1147− }
1148− else if (token->type != YAML_FLOW_MAPPING_END_TOKEN) {
1149− if (!PUSH(parser, parser->states,
1150− YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE))
1151− return 0;
1152− return yaml_parser_parse_node(parser, event, 0, 0);
1153− }
1154− }
1155−
1156− parser->state = POP(parser, parser->states);
1157− (void)POP(parser, parser->marks);
1158− MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
1159− SKIP_TOKEN(parser);
1160− return 1;
1161−}
1162−
1163−/*
1164− * Parse the productions:
1165− * flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
1166− * * ***** *
1167− */
1168−
1169−static int
1170−yaml_parser_parse_flow_mapping_value(yaml_parser_t *parser,
1171− yaml_event_t *event, int empty)
1172−{
1173− yaml_token_t *token;
1174−
1175− token = PEEK_TOKEN(parser);
1176− if (!token) return 0;
1177−
1178− if (empty) {
1179− parser->state = YAML_PARSE_FLOW_MAPPING_KEY_STATE;
1180− return yaml_parser_process_empty_scalar(parser, event,
1181− token->start_mark);
1182− }
1183−
1184− if (token->type == YAML_VALUE_TOKEN) {
1185− SKIP_TOKEN(parser);
1186− token = PEEK_TOKEN(parser);
1187− if (!token) return 0;
1188− if (token->type != YAML_FLOW_ENTRY_TOKEN
1189− && token->type != YAML_FLOW_MAPPING_END_TOKEN) {
1190− if (!PUSH(parser, parser->states,
1191− YAML_PARSE_FLOW_MAPPING_KEY_STATE))
1192− return 0;
1193− return yaml_parser_parse_node(parser, event, 0, 0);
1194− }
1195− }
1196−
1197− parser->state = YAML_PARSE_FLOW_MAPPING_KEY_STATE;
1198− return yaml_parser_process_empty_scalar(parser, event, token->start_mark);
1199−}
1200−
1201−/*
1202− * Generate an empty scalar event.
1203− */
1204−
1205−static int
1206−yaml_parser_process_empty_scalar(yaml_parser_t *parser, yaml_event_t *event,
1207− yaml_mark_t mark)
1208−{
1209− yaml_char_t *value;
1210−
1211− value = YAML_MALLOC(1);
1212− if (!value) {
1213− parser->error = YAML_MEMORY_ERROR;
1214− return 0;
1215− }
1216− value[0] = '\0';
1217−
1218− SCALAR_EVENT_INIT(*event, NULL, NULL, value, 0,
1219− 1, 0, YAML_PLAIN_SCALAR_STYLE, mark, mark);
1220−
1221− return 1;
1222−}
1223−
1224−/*
1225− * Parse directives.
1226− */
1227−
1228−static int
1229−yaml_parser_process_directives(yaml_parser_t *parser,
1230− yaml_version_directive_t **version_directive_ref,
1231− yaml_tag_directive_t **tag_directives_start_ref,
1232− yaml_tag_directive_t **tag_directives_end_ref)
1233−{
1234− yaml_tag_directive_t default_tag_directives[] = {
1235− {(yaml_char_t *)"!", (yaml_char_t *)"!"},
1236− {(yaml_char_t *)"!!", (yaml_char_t *)"tag:yaml.org,2002:"},
1237− {NULL, NULL}
1238− };
1239− yaml_tag_directive_t *default_tag_directive;
1240− yaml_version_directive_t *version_directive = NULL;
1241− struct {
1242− yaml_tag_directive_t *start;
1243− yaml_tag_directive_t *end;
1244− yaml_tag_directive_t *top;
1245− } tag_directives = { NULL, NULL, NULL };
1246− yaml_token_t *token;
1247−
1248− if (!STACK_INIT(parser, tag_directives, yaml_tag_directive_t*))
1249− goto error;
1250−
1251− token = PEEK_TOKEN(parser);
1252− if (!token) goto error;
1253−
1254− while (token->type == YAML_VERSION_DIRECTIVE_TOKEN ||
1255− token->type == YAML_TAG_DIRECTIVE_TOKEN)
1256− {
1257− if (token->type == YAML_VERSION_DIRECTIVE_TOKEN) {
1258− if (version_directive) {
1259− yaml_parser_set_parser_error(parser,
1260− "found duplicate %YAML directive", token->start_mark);
1261− goto error;
1262− }
1263− if (token->data.version_directive.major != 1
1264− || token->data.version_directive.minor != 1) {
1265− yaml_parser_set_parser_error(parser,
1266− "found incompatible YAML document", token->start_mark);
1267− goto error;
1268− }
1269− version_directive = YAML_MALLOC_STATIC(yaml_version_directive_t);
1270− if (!version_directive) {
1271− parser->error = YAML_MEMORY_ERROR;
1272− goto error;
1273− }
1274− version_directive->major = token->data.version_directive.major;
1275− version_directive->minor = token->data.version_directive.minor;
1276− }
1277−
1278− else if (token->type == YAML_TAG_DIRECTIVE_TOKEN) {
1279− yaml_tag_directive_t value;
1280− value.handle = token->data.tag_directive.handle;
1281− value.prefix = token->data.tag_directive.prefix;
1282−
1283− if (!yaml_parser_append_tag_directive(parser, value, 0,
1284− token->start_mark))
1285− goto error;
1286− if (!PUSH(parser, tag_directives, value))
1287− goto error;
1288− }
1289−
1290− SKIP_TOKEN(parser);
1291− token = PEEK_TOKEN(parser);
1292− if (!token) goto error;
1293− }
1294−
1295− for (default_tag_directive = default_tag_directives;
1296− default_tag_directive->handle; default_tag_directive++) {
1297− if (!yaml_parser_append_tag_directive(parser, *default_tag_directive, 1,
1298− token->start_mark))
1299− goto error;
1300− }
1301−
1302− if (version_directive_ref) {
1303− *version_directive_ref = version_directive;
1304− }
1305− if (tag_directives_start_ref) {
1306− if (STACK_EMPTY(parser, tag_directives)) {
1307− *tag_directives_start_ref = *tag_directives_end_ref = NULL;
1308− STACK_DEL(parser, tag_directives);
1309− }
1310− else {
1311− *tag_directives_start_ref = tag_directives.start;
1312− *tag_directives_end_ref = tag_directives.top;
1313− }
1314− }
1315− else {
1316− STACK_DEL(parser, tag_directives);
1317− }
1318−
1319− if (!version_directive_ref)
1320− yaml_free(version_directive);
1321− return 1;
1322−
1323−error:
1324− yaml_free(version_directive);
1325− while (!STACK_EMPTY(parser, tag_directives)) {
1326− yaml_tag_directive_t tag_directive = POP(parser, tag_directives);
1327− yaml_free(tag_directive.handle);
1328− yaml_free(tag_directive.prefix);
1329− }
1330− STACK_DEL(parser, tag_directives);
1331− return 0;
1332−}
1333−
1334−/*
1335− * Append a tag directive to the directives stack.
1336− */
1337−
1338−static int
1339−yaml_parser_append_tag_directive(yaml_parser_t *parser,
1340− yaml_tag_directive_t value, int allow_duplicates, yaml_mark_t mark)
1341−{
1342− yaml_tag_directive_t *tag_directive;
1343− yaml_tag_directive_t copy = { NULL, NULL };
1344−
1345− for (tag_directive = parser->tag_directives.start;
1346− tag_directive != parser->tag_directives.top; tag_directive ++) {
1347− if (strcmp((char *)value.handle, (char *)tag_directive->handle) == 0) {
1348− if (allow_duplicates)
1349− return 1;
1350− return yaml_parser_set_parser_error(parser,
1351− "found duplicate %TAG directive", mark);
1352− }
1353− }
1354−
1355− copy.handle = yaml_strdup(value.handle);
1356− copy.prefix = yaml_strdup(value.prefix);
1357− if (!copy.handle || !copy.prefix) {
1358− parser->error = YAML_MEMORY_ERROR;
1359− goto error;
1360− }
1361−
1362− if (!PUSH(parser, parser->tag_directives, copy))
1363− goto error;
1364−
1365− return 1;
1366−
1367−error:
1368− yaml_free(copy.handle);
1369− yaml_free(copy.prefix);
1370− return 0;
1371−}
1372−
libyaml/libyaml_src/reader.cdeleted−469
@@ -1,469 +0,0 @@
1−
2−#include "yaml_private.h"
3−
4−/*
5− * Declarations.
6− */
7−
8−static int
9−yaml_parser_set_reader_error(yaml_parser_t *parser, const char *problem,
10− size_t offset, int value);
11−
12−static int
13−yaml_parser_update_raw_buffer(yaml_parser_t *parser);
14−
15−static int
16−yaml_parser_determine_encoding(yaml_parser_t *parser);
17−
18−YAML_DECLARE(int)
19−yaml_parser_update_buffer(yaml_parser_t *parser, size_t length);
20−
21−/*
22− * Set the reader error and return 0.
23− */
24−
25−static int
26−yaml_parser_set_reader_error(yaml_parser_t *parser, const char *problem,
27− size_t offset, int value)
28−{
29− parser->error = YAML_READER_ERROR;
30− parser->problem = problem;
31− parser->problem_offset = offset;
32− parser->problem_value = value;
33−
34− return 0;
35−}
36−
37−/*
38− * Byte order marks.
39− */
40−
41−#define BOM_UTF8 "\xef\xbb\xbf"
42−#define BOM_UTF16LE "\xff\xfe"
43−#define BOM_UTF16BE "\xfe\xff"
44−
45−/*
46− * Determine the input stream encoding by checking the BOM symbol. If no BOM is
47− * found, the UTF-8 encoding is assumed. Return 1 on success, 0 on failure.
48− */
49−
50−static int
51−yaml_parser_determine_encoding(yaml_parser_t *parser)
52−{
53− /* Ensure that we had enough bytes in the raw buffer. */
54−
55− while (!parser->eof
56− && parser->raw_buffer.last - parser->raw_buffer.pointer < 3) {
57− if (!yaml_parser_update_raw_buffer(parser)) {
58− return 0;
59− }
60− }
61−
62− /* Determine the encoding. */
63−
64− if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 2
65− && !memcmp(parser->raw_buffer.pointer, BOM_UTF16LE, 2)) {
66− parser->encoding = YAML_UTF16LE_ENCODING;
67− parser->raw_buffer.pointer += 2;
68− parser->offset += 2;
69− }
70− else if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 2
71− && !memcmp(parser->raw_buffer.pointer, BOM_UTF16BE, 2)) {
72− parser->encoding = YAML_UTF16BE_ENCODING;
73− parser->raw_buffer.pointer += 2;
74− parser->offset += 2;
75− }
76− else if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 3
77− && !memcmp(parser->raw_buffer.pointer, BOM_UTF8, 3)) {
78− parser->encoding = YAML_UTF8_ENCODING;
79− parser->raw_buffer.pointer += 3;
80− parser->offset += 3;
81− }
82− else {
83− parser->encoding = YAML_UTF8_ENCODING;
84− }
85−
86− return 1;
87−}
88−
89−/*
90− * Update the raw buffer.
91− */
92−
93−static int
94−yaml_parser_update_raw_buffer(yaml_parser_t *parser)
95−{
96− size_t size_read = 0;
97−
98− /* Return if the raw buffer is full. */
99−
100− if (parser->raw_buffer.start == parser->raw_buffer.pointer
101− && parser->raw_buffer.last == parser->raw_buffer.end)
102− return 1;
103−
104− /* Return on EOF. */
105−
106− if (parser->eof) return 1;
107−
108− /* Move the remaining bytes in the raw buffer to the beginning. */
109−
110− if (parser->raw_buffer.start < parser->raw_buffer.pointer
111− && parser->raw_buffer.pointer < parser->raw_buffer.last) {
112− memmove(parser->raw_buffer.start, parser->raw_buffer.pointer,
113− parser->raw_buffer.last - parser->raw_buffer.pointer);
114− }
115− parser->raw_buffer.last -=
116− parser->raw_buffer.pointer - parser->raw_buffer.start;
117− parser->raw_buffer.pointer = parser->raw_buffer.start;
118−
119− /* Call the read handler to fill the buffer. */
120−
121− if (!parser->read_handler(parser->read_handler_data, parser->raw_buffer.last,
122− parser->raw_buffer.end - parser->raw_buffer.last, &size_read)) {
123− return yaml_parser_set_reader_error(parser, "input error",
124− parser->offset, -1);
125− }
126− parser->raw_buffer.last += size_read;
127− if (!size_read) {
128− parser->eof = 1;
129− }
130−
131− return 1;
132−}
133−
134−/*
135− * Ensure that the buffer contains at least `length` characters.
136− * Return 1 on success, 0 on failure.
137− *
138− * The length is supposed to be significantly less that the buffer size.
139− */
140−
141−YAML_DECLARE(int)
142−yaml_parser_update_buffer(yaml_parser_t *parser, size_t length)
143−{
144− int first = 1;
145−
146− assert(parser->read_handler); /* Read handler must be set. */
147−
148− /* If the EOF flag is set and the raw buffer is empty, do nothing. */
149−
150− if (parser->eof && parser->raw_buffer.pointer == parser->raw_buffer.last)
151− return 1;
152−
153− /* Return if the buffer contains enough characters. */
154−
155− if (parser->unread >= length)
156− return 1;
157−
158− /* Determine the input encoding if it is not known yet. */
159−
160− if (!parser->encoding) {
161− if (!yaml_parser_determine_encoding(parser))
162− return 0;
163− }
164−
165− /* Move the unread characters to the beginning of the buffer. */
166−
167− if (parser->buffer.start < parser->buffer.pointer
168− && parser->buffer.pointer < parser->buffer.last) {
169− size_t size = parser->buffer.last - parser->buffer.pointer;
170− memmove(parser->buffer.start, parser->buffer.pointer, size);
171− parser->buffer.pointer = parser->buffer.start;
172− parser->buffer.last = parser->buffer.start + size;
173− }
174− else if (parser->buffer.pointer == parser->buffer.last) {
175− parser->buffer.pointer = parser->buffer.start;
176− parser->buffer.last = parser->buffer.start;
177− }
178−
179− /* Fill the buffer until it has enough characters. */
180−
181− while (parser->unread < length)
182− {
183− /* Fill the raw buffer if necessary. */
184−
185− if (!first || parser->raw_buffer.pointer == parser->raw_buffer.last) {
186− if (!yaml_parser_update_raw_buffer(parser)) return 0;
187− }
188− first = 0;
189−
190− /* Decode the raw buffer. */
191−
192− while (parser->raw_buffer.pointer != parser->raw_buffer.last)
193− {
194− unsigned int value = 0, value2 = 0;
195− int incomplete = 0;
196− unsigned char octet;
197− unsigned int width = 0;
198− int low, high;
199− size_t k;
200− size_t raw_unread = parser->raw_buffer.last - parser->raw_buffer.pointer;
201−
202− /* Decode the next character. */
203−
204− switch (parser->encoding)
205− {
206− case YAML_UTF8_ENCODING:
207−
208− /*
209− * Decode a UTF-8 character. Check RFC 3629
210− * (http://www.ietf.org/rfc/rfc3629.txt) for more details.
211− *
212− * The following table (taken from the RFC) is used for
213− * decoding.
214− *
215− * Char. number range | UTF-8 octet sequence
216− * (hexadecimal) | (binary)
217− * --------------------+------------------------------------
218− * 0000 0000-0000 007F | 0xxxxxxx
219− * 0000 0080-0000 07FF | 110xxxxx 10xxxxxx
220− * 0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
221− * 0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
222− *
223− * Additionally, the characters in the range 0xD800-0xDFFF
224− * are prohibited as they are reserved for use with UTF-16
225− * surrogate pairs.
226− */
227−
228− /* Determine the length of the UTF-8 sequence. */
229−
230− octet = parser->raw_buffer.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−
236− /* Check if the leading octet is valid. */
237−
238− if (!width)
239− return yaml_parser_set_reader_error(parser,
240− "invalid leading UTF-8 octet",
241− parser->offset, octet);
242−
243− /* Check if the raw buffer contains an incomplete character. */
244−
245− if (width > raw_unread) {
246− if (parser->eof) {
247− return yaml_parser_set_reader_error(parser,
248− "incomplete UTF-8 octet sequence",
249− parser->offset, -1);
250− }
251− incomplete = 1;
252− break;
253− }
254−
255− /* Decode the leading octet. */
256−
257− value = (octet & 0x80) == 0x00 ? octet & 0x7F :
258− (octet & 0xE0) == 0xC0 ? octet & 0x1F :
259− (octet & 0xF0) == 0xE0 ? octet & 0x0F :
260− (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
261−
262− /* Check and decode the trailing octets. */
263−
264− for (k = 1; k < width; k ++)
265− {
266− octet = parser->raw_buffer.pointer[k];
267−
268− /* Check if the octet is valid. */
269−
270− if ((octet & 0xC0) != 0x80)
271− return yaml_parser_set_reader_error(parser,
272− "invalid trailing UTF-8 octet",
273− parser->offset+k, octet);
274−
275− /* Decode the octet. */
276−
277− value = (value << 6) + (octet & 0x3F);
278− }
279−
280− /* Check the length of the sequence against the value. */
281−
282− if (!((width == 1) ||
283− (width == 2 && value >= 0x80) ||
284− (width == 3 && value >= 0x800) ||
285− (width == 4 && value >= 0x10000)))
286− return yaml_parser_set_reader_error(parser,
287− "invalid length of a UTF-8 sequence",
288− parser->offset, -1);
289−
290− /* Check the range of the value. */
291−
292− if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF)
293− return yaml_parser_set_reader_error(parser,
294− "invalid Unicode character",
295− parser->offset, value);
296−
297− break;
298−
299− case YAML_UTF16LE_ENCODING:
300− case YAML_UTF16BE_ENCODING:
301−
302− low = (parser->encoding == YAML_UTF16LE_ENCODING ? 0 : 1);
303− high = (parser->encoding == YAML_UTF16LE_ENCODING ? 1 : 0);
304−
305− /*
306− * The UTF-16 encoding is not as simple as one might
307− * naively think. Check RFC 2781
308− * (http://www.ietf.org/rfc/rfc2781.txt).
309− *
310− * Normally, two subsequent bytes describe a Unicode
311− * character. However a special technique (called a
312− * surrogate pair) is used for specifying character
313− * values larger than 0xFFFF.
314− *
315− * A surrogate pair consists of two pseudo-characters:
316− * high surrogate area (0xD800-0xDBFF)
317− * low surrogate area (0xDC00-0xDFFF)
318− *
319− * The following formulas are used for decoding
320− * and encoding characters using surrogate pairs:
321− *
322− * U = U' + 0x10000 (0x01 00 00 <= U <= 0x10 FF FF)
323− * U' = yyyyyyyyyyxxxxxxxxxx (0 <= U' <= 0x0F FF FF)
324− * W1 = 110110yyyyyyyyyy
325− * W2 = 110111xxxxxxxxxx
326− *
327− * where U is the character value, W1 is the high surrogate
328− * area, W2 is the low surrogate area.
329− */
330−
331− /* Check for incomplete UTF-16 character. */
332−
333− if (raw_unread < 2) {
334− if (parser->eof) {
335− return yaml_parser_set_reader_error(parser,
336− "incomplete UTF-16 character",
337− parser->offset, -1);
338− }
339− incomplete = 1;
340− break;
341− }
342−
343− /* Get the character. */
344−
345− value = parser->raw_buffer.pointer[low]
346− + (parser->raw_buffer.pointer[high] << 8);
347−
348− /* Check for unexpected low surrogate area. */
349−
350− if ((value & 0xFC00) == 0xDC00)
351− return yaml_parser_set_reader_error(parser,
352− "unexpected low surrogate area",
353− parser->offset, value);
354−
355− /* Check for a high surrogate area. */
356−
357− if ((value & 0xFC00) == 0xD800) {
358−
359− width = 4;
360−
361− /* Check for incomplete surrogate pair. */
362−
363− if (raw_unread < 4) {
364− if (parser->eof) {
365− return yaml_parser_set_reader_error(parser,
366− "incomplete UTF-16 surrogate pair",
367− parser->offset, -1);
368− }
369− incomplete = 1;
370− break;
371− }
372−
373− /* Get the next character. */
374−
375− value2 = parser->raw_buffer.pointer[low+2]
376− + (parser->raw_buffer.pointer[high+2] << 8);
377−
378− /* Check for a low surrogate area. */
379−
380− if ((value2 & 0xFC00) != 0xDC00)
381− return yaml_parser_set_reader_error(parser,
382− "expected low surrogate area",
383− parser->offset+2, value2);
384−
385− /* Generate the value of the surrogate pair. */
386−
387− value = 0x10000 + ((value & 0x3FF) << 10) + (value2 & 0x3FF);
388− }
389−
390− else {
391− width = 2;
392− }
393−
394− break;
395−
396− default:
397− assert(1); /* Impossible. */
398− }
399−
400− /* Check if the raw buffer contains enough bytes to form a character. */
401−
402− if (incomplete) break;
403−
404− /*
405− * Check if the character is in the allowed range:
406− * #x9 | #xA | #xD | [#x20-#x7E] (8 bit)
407− * | #x85 | [#xA0-#xD7FF] | [#xE000-#xFFFD] (16 bit)
408− * | [#x10000-#x10FFFF] (32 bit)
409− */
410−
411− if (! (value == 0x09 || value == 0x0A || value == 0x0D
412− || (value >= 0x20 && value <= 0x7E)
413− || (value == 0x85) || (value >= 0xA0 && value <= 0xD7FF)
414− || (value >= 0xE000 && value <= 0xFFFD)
415− || (value >= 0x10000 && value <= 0x10FFFF)))
416− return yaml_parser_set_reader_error(parser,
417− "control characters are not allowed",
418− parser->offset, value);
419−
420− /* Move the raw pointers. */
421−
422− parser->raw_buffer.pointer += width;
423− parser->offset += width;
424−
425− /* Finally put the character into the buffer. */
426−
427− /* 0000 0000-0000 007F -> 0xxxxxxx */
428− if (value <= 0x7F) {
429− *(parser->buffer.last++) = value;
430− }
431− /* 0000 0080-0000 07FF -> 110xxxxx 10xxxxxx */
432− else if (value <= 0x7FF) {
433− *(parser->buffer.last++) = 0xC0 + (value >> 6);
434− *(parser->buffer.last++) = 0x80 + (value & 0x3F);
435− }
436− /* 0000 0800-0000 FFFF -> 1110xxxx 10xxxxxx 10xxxxxx */
437− else if (value <= 0xFFFF) {
438− *(parser->buffer.last++) = 0xE0 + (value >> 12);
439− *(parser->buffer.last++) = 0x80 + ((value >> 6) & 0x3F);
440− *(parser->buffer.last++) = 0x80 + (value & 0x3F);
441− }
442− /* 0001 0000-0010 FFFF -> 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
443− else {
444− *(parser->buffer.last++) = 0xF0 + (value >> 18);
445− *(parser->buffer.last++) = 0x80 + ((value >> 12) & 0x3F);
446− *(parser->buffer.last++) = 0x80 + ((value >> 6) & 0x3F);
447− *(parser->buffer.last++) = 0x80 + (value & 0x3F);
448− }
449−
450− parser->unread ++;
451− }
452−
453− /* On EOF, put NUL into the buffer and return. */
454−
455− if (parser->eof) {
456− *(parser->buffer.last++) = '\0';
457− parser->unread ++;
458− return 1;
459− }
460−
461− }
462−
463− if (parser->offset >= MAX_FILE_SIZE) {
464− return yaml_parser_set_reader_error(parser, "input is too long",
465− parser->offset, -1);
466− }
467−
468− return 1;
469−}
libyaml/libyaml_src/scanner.cdeleted−3589
@@ -1,3589 +0,0 @@
1−
2−/*
3− * Introduction
4− * ************
5− *
6− * The following notes assume that you are familiar with the YAML specification
7− * (http://yaml.org/spec/cvs/current.html). We mostly follow it, although in
8− * some cases we are less restrictive that it requires.
9− *
10− * The process of transforming a YAML stream into a sequence of events is
11− * divided on two steps: Scanning and Parsing.
12− *
13− * The Scanner transforms the input stream into a sequence of tokens, while the
14− * parser transform the sequence of tokens produced by the Scanner into a
15− * sequence of parsing events.
16− *
17− * The Scanner is rather clever and complicated. The Parser, on the contrary,
18− * is a straightforward implementation of a recursive-descendant parser (or,
19− * LL(1) parser, as it is usually called).
20− *
21− * Actually there are two issues of Scanning that might be called "clever", the
22− * rest is quite straightforward. The issues are "block collection start" and
23− * "simple keys". Both issues are explained below in details.
24− *
25− * Here the Scanning step is explained and implemented. We start with the list
26− * of all the tokens produced by the Scanner together with short descriptions.
27− *
28− * Now, tokens:
29− *
30− * STREAM-START(encoding) # The stream start.
31− * STREAM-END # The stream end.
32− * VERSION-DIRECTIVE(major,minor) # The '%YAML' directive.
33− * TAG-DIRECTIVE(handle,prefix) # The '%TAG' directive.
34− * DOCUMENT-START # '---'
35− * DOCUMENT-END # '...'
36− * BLOCK-SEQUENCE-START # Indentation increase denoting a block
37− * BLOCK-MAPPING-START # sequence or a block mapping.
38− * BLOCK-END # Indentation decrease.
39− * FLOW-SEQUENCE-START # '['
40− * FLOW-SEQUENCE-END # ']'
41− * FLOW-MAPPING-START # '{'
42− * FLOW-MAPPING-END # '}'
43− * BLOCK-ENTRY # '-'
44− * FLOW-ENTRY # ','
45− * KEY # '?' or nothing (simple keys).
46− * VALUE # ':'
47− * ALIAS(anchor) # '*anchor'
48− * ANCHOR(anchor) # '&anchor'
49− * TAG(handle,suffix) # '!handle!suffix'
50− * SCALAR(value,style) # A scalar.
51− *
52− * The following two tokens are "virtual" tokens denoting the beginning and the
53− * end of the stream:
54− *
55− * STREAM-START(encoding)
56− * STREAM-END
57− *
58− * We pass the information about the input stream encoding with the
59− * STREAM-START token.
60− *
61− * The next two tokens are responsible for tags:
62− *
63− * VERSION-DIRECTIVE(major,minor)
64− * TAG-DIRECTIVE(handle,prefix)
65− *
66− * Example:
67− *
68− * %YAML 1.1
69− * %TAG ! !foo
70− * %TAG !yaml! tag:yaml.org,2002:
71− * ---
72− *
73− * The corresponding sequence of tokens:
74− *
75− * STREAM-START(utf-8)
76− * VERSION-DIRECTIVE(1,1)
77− * TAG-DIRECTIVE("!","!foo")
78− * TAG-DIRECTIVE("!yaml","tag:yaml.org,2002:")
79− * DOCUMENT-START
80− * STREAM-END
81− *
82− * Note that the VERSION-DIRECTIVE and TAG-DIRECTIVE tokens occupy a whole
83− * line.
84− *
85− * The document start and end indicators are represented by:
86− *
87− * DOCUMENT-START
88− * DOCUMENT-END
89− *
90− * Note that if a YAML stream contains an implicit document (without '---'
91− * and '...' indicators), no DOCUMENT-START and DOCUMENT-END tokens will be
92− * produced.
93− *
94− * In the following examples, we present whole documents together with the
95− * produced tokens.
96− *
97− * 1. An implicit document:
98− *
99− * 'a scalar'
100− *
101− * Tokens:
102− *
103− * STREAM-START(utf-8)
104− * SCALAR("a scalar",single-quoted)
105− * STREAM-END
106− *
107− * 2. An explicit document:
108− *
109− * ---
110− * 'a scalar'
111− * ...
112− *
113− * Tokens:
114− *
115− * STREAM-START(utf-8)
116− * DOCUMENT-START
117− * SCALAR("a scalar",single-quoted)
118− * DOCUMENT-END
119− * STREAM-END
120− *
121− * 3. Several documents in a stream:
122− *
123− * 'a scalar'
124− * ---
125− * 'another scalar'
126− * ---
127− * 'yet another scalar'
128− *
129− * Tokens:
130− *
131− * STREAM-START(utf-8)
132− * SCALAR("a scalar",single-quoted)
133− * DOCUMENT-START
134− * SCALAR("another scalar",single-quoted)
135− * DOCUMENT-START
136− * SCALAR("yet another scalar",single-quoted)
137− * STREAM-END
138− *
139− * We have already introduced the SCALAR token above. The following tokens are
140− * used to describe aliases, anchors, tag, and scalars:
141− *
142− * ALIAS(anchor)
143− * ANCHOR(anchor)
144− * TAG(handle,suffix)
145− * SCALAR(value,style)
146− *
147− * The following series of examples illustrate the usage of these tokens:
148− *
149− * 1. A recursive sequence:
150− *
151− * &A [ *A ]
152− *
153− * Tokens:
154− *
155− * STREAM-START(utf-8)
156− * ANCHOR("A")
157− * FLOW-SEQUENCE-START
158− * ALIAS("A")
159− * FLOW-SEQUENCE-END
160− * STREAM-END
161− *
162− * 2. A tagged scalar:
163− *
164− * !!float "3.14" # A good approximation.
165− *
166− * Tokens:
167− *
168− * STREAM-START(utf-8)
169− * TAG("!!","float")
170− * SCALAR("3.14",double-quoted)
171− * STREAM-END
172− *
173− * 3. Various scalar styles:
174− *
175− * --- # Implicit empty plain scalars do not produce tokens.
176− * --- a plain scalar
177− * --- 'a single-quoted scalar'
178− * --- "a double-quoted scalar"
179− * --- |-
180− * a literal scalar
181− * --- >-
182− * a folded
183− * scalar
184− *
185− * Tokens:
186− *
187− * STREAM-START(utf-8)
188− * DOCUMENT-START
189− * DOCUMENT-START
190− * SCALAR("a plain scalar",plain)
191− * DOCUMENT-START
192− * SCALAR("a single-quoted scalar",single-quoted)
193− * DOCUMENT-START
194− * SCALAR("a double-quoted scalar",double-quoted)
195− * DOCUMENT-START
196− * SCALAR("a literal scalar",literal)
197− * DOCUMENT-START
198− * SCALAR("a folded scalar",folded)
199− * STREAM-END
200− *
201− * Now it's time to review collection-related tokens. We will start with
202− * flow collections:
203− *
204− * FLOW-SEQUENCE-START
205− * FLOW-SEQUENCE-END
206− * FLOW-MAPPING-START
207− * FLOW-MAPPING-END
208− * FLOW-ENTRY
209− * KEY
210− * VALUE
211− *
212− * The tokens FLOW-SEQUENCE-START, FLOW-SEQUENCE-END, FLOW-MAPPING-START, and
213− * FLOW-MAPPING-END represent the indicators '[', ']', '{', and '}'
214− * correspondingly. FLOW-ENTRY represent the ',' indicator. Finally the
215− * indicators '?' and ':', which are used for denoting mapping keys and values,
216− * are represented by the KEY and VALUE tokens.
217− *
218− * The following examples show flow collections:
219− *
220− * 1. A flow sequence:
221− *
222− * [item 1, item 2, item 3]
223− *
224− * Tokens:
225− *
226− * STREAM-START(utf-8)
227− * FLOW-SEQUENCE-START
228− * SCALAR("item 1",plain)
229− * FLOW-ENTRY
230− * SCALAR("item 2",plain)
231− * FLOW-ENTRY
232− * SCALAR("item 3",plain)
233− * FLOW-SEQUENCE-END
234− * STREAM-END
235− *
236− * 2. A flow mapping:
237− *
238− * {
239− * a simple key: a value, # Note that the KEY token is produced.
240− * ? a complex key: another value,
241− * }
242− *
243− * Tokens:
244− *
245− * STREAM-START(utf-8)
246− * FLOW-MAPPING-START
247− * KEY
248− * SCALAR("a simple key",plain)
249− * VALUE
250− * SCALAR("a value",plain)
251− * FLOW-ENTRY
252− * KEY
253− * SCALAR("a complex key",plain)
254− * VALUE
255− * SCALAR("another value",plain)
256− * FLOW-ENTRY
257− * FLOW-MAPPING-END
258− * STREAM-END
259− *
260− * A simple key is a key which is not denoted by the '?' indicator. Note that
261− * the Scanner still produce the KEY token whenever it encounters a simple key.
262− *
263− * For scanning block collections, the following tokens are used (note that we
264− * repeat KEY and VALUE here):
265− *
266− * BLOCK-SEQUENCE-START
267− * BLOCK-MAPPING-START
268− * BLOCK-END
269− * BLOCK-ENTRY
270− * KEY
271− * VALUE
272− *
273− * The tokens BLOCK-SEQUENCE-START and BLOCK-MAPPING-START denote indentation
274− * increase that precedes a block collection (cf. the INDENT token in Python).
275− * The token BLOCK-END denote indentation decrease that ends a block collection
276− * (cf. the DEDENT token in Python). However YAML has some syntax pecularities
277− * that makes detections of these tokens more complex.
278− *
279− * The tokens BLOCK-ENTRY, KEY, and VALUE are used to represent the indicators
280− * '-', '?', and ':' correspondingly.
281− *
282− * The following examples show how the tokens BLOCK-SEQUENCE-START,
283− * BLOCK-MAPPING-START, and BLOCK-END are emitted by the Scanner:
284− *
285− * 1. Block sequences:
286− *
287− * - item 1
288− * - item 2
289− * -
290− * - item 3.1
291− * - item 3.2
292− * -
293− * key 1: value 1
294− * key 2: value 2
295− *
296− * Tokens:
297− *
298− * STREAM-START(utf-8)
299− * BLOCK-SEQUENCE-START
300− * BLOCK-ENTRY
301− * SCALAR("item 1",plain)
302− * BLOCK-ENTRY
303− * SCALAR("item 2",plain)
304− * BLOCK-ENTRY
305− * BLOCK-SEQUENCE-START
306− * BLOCK-ENTRY
307− * SCALAR("item 3.1",plain)
308− * BLOCK-ENTRY
309− * SCALAR("item 3.2",plain)
310− * BLOCK-END
311− * BLOCK-ENTRY
312− * BLOCK-MAPPING-START
313− * KEY
314− * SCALAR("key 1",plain)
315− * VALUE
316− * SCALAR("value 1",plain)
317− * KEY
318− * SCALAR("key 2",plain)
319− * VALUE
320− * SCALAR("value 2",plain)
321− * BLOCK-END
322− * BLOCK-END
323− * STREAM-END
324− *
325− * 2. Block mappings:
326− *
327− * a simple key: a value # The KEY token is produced here.
328− * ? a complex key
329− * : another value
330− * a mapping:
331− * key 1: value 1
332− * key 2: value 2
333− * a sequence:
334− * - item 1
335− * - item 2
336− *
337− * Tokens:
338− *
339− * STREAM-START(utf-8)
340− * BLOCK-MAPPING-START
341− * KEY
342− * SCALAR("a simple key",plain)
343− * VALUE
344− * SCALAR("a value",plain)
345− * KEY
346− * SCALAR("a complex key",plain)
347− * VALUE
348− * SCALAR("another value",plain)
349− * KEY
350− * SCALAR("a mapping",plain)
351− * BLOCK-MAPPING-START
352− * KEY
353− * SCALAR("key 1",plain)
354− * VALUE
355− * SCALAR("value 1",plain)
356− * KEY
357− * SCALAR("key 2",plain)
358− * VALUE
359− * SCALAR("value 2",plain)
360− * BLOCK-END
361− * KEY
362− * SCALAR("a sequence",plain)
363− * VALUE
364− * BLOCK-SEQUENCE-START
365− * BLOCK-ENTRY
366− * SCALAR("item 1",plain)
367− * BLOCK-ENTRY
368− * SCALAR("item 2",plain)
369− * BLOCK-END
370− * BLOCK-END
371− * STREAM-END
372− *
373− * YAML does not always require to start a new block collection from a new
374− * line. If the current line contains only '-', '?', and ':' indicators, a new
375− * block collection may start at the current line. The following examples
376− * illustrate this case:
377− *
378− * 1. Collections in a sequence:
379− *
380− * - - item 1
381− * - item 2
382− * - key 1: value 1
383− * key 2: value 2
384− * - ? complex key
385− * : complex value
386− *
387− * Tokens:
388− *
389− * STREAM-START(utf-8)
390− * BLOCK-SEQUENCE-START
391− * BLOCK-ENTRY
392− * BLOCK-SEQUENCE-START
393− * BLOCK-ENTRY
394− * SCALAR("item 1",plain)
395− * BLOCK-ENTRY
396− * SCALAR("item 2",plain)
397− * BLOCK-END
398− * BLOCK-ENTRY
399− * BLOCK-MAPPING-START
400− * KEY
401− * SCALAR("key 1",plain)
402− * VALUE
403− * SCALAR("value 1",plain)
404− * KEY
405− * SCALAR("key 2",plain)
406− * VALUE
407− * SCALAR("value 2",plain)
408− * BLOCK-END
409− * BLOCK-ENTRY
410− * BLOCK-MAPPING-START
411− * KEY
412− * SCALAR("complex key")
413− * VALUE
414− * SCALAR("complex value")
415− * BLOCK-END
416− * BLOCK-END
417− * STREAM-END
418− *
419− * 2. Collections in a mapping:
420− *
421− * ? a sequence
422− * : - item 1
423− * - item 2
424− * ? a mapping
425− * : key 1: value 1
426− * key 2: value 2
427− *
428− * Tokens:
429− *
430− * STREAM-START(utf-8)
431− * BLOCK-MAPPING-START
432− * KEY
433− * SCALAR("a sequence",plain)
434− * VALUE
435− * BLOCK-SEQUENCE-START
436− * BLOCK-ENTRY
437− * SCALAR("item 1",plain)
438− * BLOCK-ENTRY
439− * SCALAR("item 2",plain)
440− * BLOCK-END
441− * KEY
442− * SCALAR("a mapping",plain)
443− * VALUE
444− * BLOCK-MAPPING-START
445− * KEY
446− * SCALAR("key 1",plain)
447− * VALUE
448− * SCALAR("value 1",plain)
449− * KEY
450− * SCALAR("key 2",plain)
451− * VALUE
452− * SCALAR("value 2",plain)
453− * BLOCK-END
454− * BLOCK-END
455− * STREAM-END
456− *
457− * YAML also permits non-indented sequences if they are included into a block
458− * mapping. In this case, the token BLOCK-SEQUENCE-START is not produced:
459− *
460− * key:
461− * - item 1 # BLOCK-SEQUENCE-START is NOT produced here.
462− * - item 2
463− *
464− * Tokens:
465− *
466− * STREAM-START(utf-8)
467− * BLOCK-MAPPING-START
468− * KEY
469− * SCALAR("key",plain)
470− * VALUE
471− * BLOCK-ENTRY
472− * SCALAR("item 1",plain)
473− * BLOCK-ENTRY
474− * SCALAR("item 2",plain)
475− * BLOCK-END
476− */
477−
478−#include "yaml_private.h"
479−
480−/*
481− * Ensure that the buffer contains the required number of characters.
482− * Return 1 on success, 0 on failure (reader error or memory error).
483− */
484−
485−#define CACHE(parser,length) \
486− (parser->unread >= (length) \
487− ? 1 \
488− : yaml_parser_update_buffer(parser, (length)))
489−
490−/*
491− * Advance the buffer pointer.
492− */
493−
494−#define SKIP(parser) \
495− (parser->mark.index ++, \
496− parser->mark.column ++, \
497− parser->unread --, \
498− parser->buffer.pointer += WIDTH(parser->buffer))
499−
500−#define SKIP_LINE(parser) \
501− (IS_CRLF(parser->buffer) ? \
502− (parser->mark.index += 2, \
503− parser->mark.column = 0, \
504− parser->mark.line ++, \
505− parser->unread -= 2, \
506− parser->buffer.pointer += 2) : \
507− IS_BREAK(parser->buffer) ? \
508− (parser->mark.index ++, \
509− parser->mark.column = 0, \
510− parser->mark.line ++, \
511− parser->unread --, \
512− parser->buffer.pointer += WIDTH(parser->buffer)) : 0)
513−
514−/*
515− * Copy a character to a string buffer and advance pointers.
516− */
517−
518−#define READ(parser,string) \
519− (STRING_EXTEND(parser,string) ? \
520− (COPY(string,parser->buffer), \
521− parser->mark.index ++, \
522− parser->mark.column ++, \
523− parser->unread --, \
524− 1) : 0)
525−
526−/*
527− * Copy a line break character to a string buffer and advance pointers.
528− */
529−
530−#define READ_LINE(parser,string) \
531− (STRING_EXTEND(parser,string) ? \
532− (((CHECK_AT(parser->buffer,'\r',0) \
533− && CHECK_AT(parser->buffer,'\n',1)) ? /* CR LF -> LF */ \
534− (*((string).pointer++) = (yaml_char_t) '\n', \
535− parser->buffer.pointer += 2, \
536− parser->mark.index += 2, \
537− parser->mark.column = 0, \
538− parser->mark.line ++, \
539− parser->unread -= 2) : \
540− (CHECK_AT(parser->buffer,'\r',0) \
541− || CHECK_AT(parser->buffer,'\n',0)) ? /* CR|LF -> LF */ \
542− (*((string).pointer++) = (yaml_char_t) '\n', \
543− parser->buffer.pointer ++, \
544− parser->mark.index ++, \
545− parser->mark.column = 0, \
546− parser->mark.line ++, \
547− parser->unread --) : \
548− (CHECK_AT(parser->buffer,'\xC2',0) \
549− && CHECK_AT(parser->buffer,'\x85',1)) ? /* NEL -> LF */ \
550− (*((string).pointer++) = (yaml_char_t) '\n', \
551− parser->buffer.pointer += 2, \
552− parser->mark.index ++, \
553− parser->mark.column = 0, \
554− parser->mark.line ++, \
555− parser->unread --) : \
556− (CHECK_AT(parser->buffer,'\xE2',0) && \
557− CHECK_AT(parser->buffer,'\x80',1) && \
558− (CHECK_AT(parser->buffer,'\xA8',2) || \
559− CHECK_AT(parser->buffer,'\xA9',2))) ? /* LS|PS -> LS|PS */ \
560− (*((string).pointer++) = *(parser->buffer.pointer++), \
561− *((string).pointer++) = *(parser->buffer.pointer++), \
562− *((string).pointer++) = *(parser->buffer.pointer++), \
563− parser->mark.index ++, \
564− parser->mark.column = 0, \
565− parser->mark.line ++, \
566− parser->unread --) : 0), \
567− 1) : 0)
568−
569−/*
570− * Public API declarations.
571− */
572−
573−YAML_DECLARE(int)
574−yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token);
575−
576−/*
577− * Error handling.
578− */
579−
580−static int
581−yaml_parser_set_scanner_error(yaml_parser_t *parser, const char *context,
582− yaml_mark_t context_mark, const char *problem);
583−
584−/*
585− * High-level token API.
586− */
587−
588−YAML_DECLARE(int)
589−yaml_parser_fetch_more_tokens(yaml_parser_t *parser);
590−
591−static int
592−yaml_parser_fetch_next_token(yaml_parser_t *parser);
593−
594−/*
595− * Potential simple keys.
596− */
597−
598−static int
599−yaml_parser_stale_simple_keys(yaml_parser_t *parser);
600−
601−static int
602−yaml_parser_save_simple_key(yaml_parser_t *parser);
603−
604−static int
605−yaml_parser_remove_simple_key(yaml_parser_t *parser);
606−
607−static int
608−yaml_parser_increase_flow_level(yaml_parser_t *parser);
609−
610−static int
611−yaml_parser_decrease_flow_level(yaml_parser_t *parser);
612−
613−/*
614− * Indentation treatment.
615− */
616−
617−static int
618−yaml_parser_roll_indent(yaml_parser_t *parser, ptrdiff_t column,
619− ptrdiff_t number, yaml_token_type_t type, yaml_mark_t mark);
620−
621−static int
622−yaml_parser_unroll_indent(yaml_parser_t *parser, ptrdiff_t column);
623−
624−/*
625− * Token fetchers.
626− */
627−
628−static int
629−yaml_parser_fetch_stream_start(yaml_parser_t *parser);
630−
631−static int
632−yaml_parser_fetch_stream_end(yaml_parser_t *parser);
633−
634−static int
635−yaml_parser_fetch_directive(yaml_parser_t *parser);
636−
637−static int
638−yaml_parser_fetch_document_indicator(yaml_parser_t *parser,
639− yaml_token_type_t type);
640−
641−static int
642−yaml_parser_fetch_flow_collection_start(yaml_parser_t *parser,
643− yaml_token_type_t type);
644−
645−static int
646−yaml_parser_fetch_flow_collection_end(yaml_parser_t *parser,
647− yaml_token_type_t type);
648−
649−static int
650−yaml_parser_fetch_flow_entry(yaml_parser_t *parser);
651−
652−static int
653−yaml_parser_fetch_block_entry(yaml_parser_t *parser);
654−
655−static int
656−yaml_parser_fetch_key(yaml_parser_t *parser);
657−
658−static int
659−yaml_parser_fetch_value(yaml_parser_t *parser);
660−
661−static int
662−yaml_parser_fetch_anchor(yaml_parser_t *parser, yaml_token_type_t type);
663−
664−static int
665−yaml_parser_fetch_tag(yaml_parser_t *parser);
666−
667−static int
668−yaml_parser_fetch_block_scalar(yaml_parser_t *parser, int literal);
669−
670−static int
671−yaml_parser_fetch_flow_scalar(yaml_parser_t *parser, int single);
672−
673−static int
674−yaml_parser_fetch_plain_scalar(yaml_parser_t *parser);
675−
676−/*
677− * Token scanners.
678− */
679−
680−static int
681−yaml_parser_scan_to_next_token(yaml_parser_t *parser);
682−
683−static int
684−yaml_parser_scan_directive(yaml_parser_t *parser, yaml_token_t *token);
685−
686−static int
687−yaml_parser_scan_directive_name(yaml_parser_t *parser,
688− yaml_mark_t start_mark, yaml_char_t **name);
689−
690−static int
691−yaml_parser_scan_version_directive_value(yaml_parser_t *parser,
692− yaml_mark_t start_mark, int *major, int *minor);
693−
694−static int
695−yaml_parser_scan_version_directive_number(yaml_parser_t *parser,
696− yaml_mark_t start_mark, int *number);
697−
698−static int
699−yaml_parser_scan_tag_directive_value(yaml_parser_t *parser,
700− yaml_mark_t mark, yaml_char_t **handle, yaml_char_t **prefix);
701−
702−static int
703−yaml_parser_scan_anchor(yaml_parser_t *parser, yaml_token_t *token,
704− yaml_token_type_t type);
705−
706−static int
707−yaml_parser_scan_tag(yaml_parser_t *parser, yaml_token_t *token);
708−
709−static int
710−yaml_parser_scan_tag_handle(yaml_parser_t *parser, int directive,
711− yaml_mark_t start_mark, yaml_char_t **handle);
712−
713−static int
714−yaml_parser_scan_tag_uri(yaml_parser_t *parser, int directive,
715− yaml_char_t *head, yaml_mark_t start_mark, yaml_char_t **uri);
716−
717−static int
718−yaml_parser_scan_uri_escapes(yaml_parser_t *parser, int directive,
719− yaml_mark_t start_mark, yaml_string_t *string);
720−
721−static int
722−yaml_parser_scan_block_scalar(yaml_parser_t *parser, yaml_token_t *token,
723− int literal);
724−
725−static int
726−yaml_parser_scan_block_scalar_breaks(yaml_parser_t *parser,
727− int *indent, yaml_string_t *breaks,
728− yaml_mark_t start_mark, yaml_mark_t *end_mark);
729−
730−static int
731−yaml_parser_scan_flow_scalar(yaml_parser_t *parser, yaml_token_t *token,
732− int single);
733−
734−static int
735−yaml_parser_scan_plain_scalar(yaml_parser_t *parser, yaml_token_t *token);
736−
737−/*
738− * Get the next token.
739− */
740−
741−YAML_DECLARE(int)
742−yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token)
743−{
744− assert(parser); /* Non-NULL parser object is expected. */
745− assert(token); /* Non-NULL token object is expected. */
746−
747− /* Erase the token object. */
748−
749− memset(token, 0, sizeof(yaml_token_t));
750−
751− /* No tokens after STREAM-END or error. */
752−
753− if (parser->stream_end_produced || parser->error) {
754− return 1;
755− }
756−
757− /* Ensure that the tokens queue contains enough tokens. */
758−
759− if (!parser->token_available) {
760− if (!yaml_parser_fetch_more_tokens(parser))
761− return 0;
762− }
763−
764− /* Fetch the next token from the queue. */
765−
766− *token = DEQUEUE(parser, parser->tokens);
767− parser->token_available = 0;
768− parser->tokens_parsed ++;
769−
770− if (token->type == YAML_STREAM_END_TOKEN) {
771− parser->stream_end_produced = 1;
772− }
773−
774− return 1;
775−}
776−
777−/*
778− * Set the scanner error and return 0.
779− */
780−
781−static int
782−yaml_parser_set_scanner_error(yaml_parser_t *parser, const char *context,
783− yaml_mark_t context_mark, const char *problem)
784−{
785− parser->error = YAML_SCANNER_ERROR;
786− parser->context = context;
787− parser->context_mark = context_mark;
788− parser->problem = problem;
789− parser->problem_mark = parser->mark;
790−
791− return 0;
792−}
793−
794−/*
795− * Ensure that the tokens queue contains at least one token which can be
796− * returned to the Parser.
797− */
798−
799−YAML_DECLARE(int)
800−yaml_parser_fetch_more_tokens(yaml_parser_t *parser)
801−{
802− int need_more_tokens;
803−
804− /* While we need more tokens to fetch, do it. */
805−
806− while (1)
807− {
808− /*
809− * Check if we really need to fetch more tokens.
810− */
811−
812− need_more_tokens = 0;
813−
814− if (parser->tokens.head == parser->tokens.tail)
815− {
816− /* Queue is empty. */
817−
818− need_more_tokens = 1;
819− }
820− else
821− {
822− yaml_simple_key_t *simple_key;
823−
824− /* Check if any potential simple key may occupy the head position. */
825−
826− if (!yaml_parser_stale_simple_keys(parser))
827− return 0;
828−
829− for (simple_key = parser->simple_keys.start;
830− simple_key != parser->simple_keys.top; simple_key++) {
831− if (simple_key->possible
832− && simple_key->token_number == parser->tokens_parsed) {
833− need_more_tokens = 1;
834− break;
835− }
836− }
837− }
838−
839− /* We are finished. */
840−
841− if (!need_more_tokens)
842− break;
843−
844− /* Fetch the next token. */
845−
846− if (!yaml_parser_fetch_next_token(parser))
847− return 0;
848− }
849−
850− parser->token_available = 1;
851−
852− return 1;
853−}
854−
855−/*
856− * The dispatcher for token fetchers.
857− */
858−
859−static int
860−yaml_parser_fetch_next_token(yaml_parser_t *parser)
861−{
862− /* Ensure that the buffer is initialized. */
863−
864− if (!CACHE(parser, 1))
865− return 0;
866−
867− /* Check if we just started scanning. Fetch STREAM-START then. */
868−
869− if (!parser->stream_start_produced)
870− return yaml_parser_fetch_stream_start(parser);
871−
872− /* Eat whitespaces and comments until we reach the next token. */
873−
874− if (!yaml_parser_scan_to_next_token(parser))
875− return 0;
876−
877− /* Remove obsolete potential simple keys. */
878−
879− if (!yaml_parser_stale_simple_keys(parser))
880− return 0;
881−
882− /* Check the indentation level against the current column. */
883−
884− if (!yaml_parser_unroll_indent(parser, parser->mark.column))
885− return 0;
886−
887− /*
888− * Ensure that the buffer contains at least 4 characters. 4 is the length
889− * of the longest indicators ('--- ' and '... ').
890− */
891−
892− if (!CACHE(parser, 4))
893− return 0;
894−
895− /* Is it the end of the stream? */
896−
897− if (IS_Z(parser->buffer))
898− return yaml_parser_fetch_stream_end(parser);
899−
900− /* Is it a directive? */
901−
902− if (parser->mark.column == 0 && CHECK(parser->buffer, '%'))
903− return yaml_parser_fetch_directive(parser);
904−
905− /* Is it the document start indicator? */
906−
907− if (parser->mark.column == 0
908− && CHECK_AT(parser->buffer, '-', 0)
909− && CHECK_AT(parser->buffer, '-', 1)
910− && CHECK_AT(parser->buffer, '-', 2)
911− && IS_BLANKZ_AT(parser->buffer, 3))
912− return yaml_parser_fetch_document_indicator(parser,
913− YAML_DOCUMENT_START_TOKEN);
914−
915− /* Is it the document end indicator? */
916−
917− if (parser->mark.column == 0
918− && CHECK_AT(parser->buffer, '.', 0)
919− && CHECK_AT(parser->buffer, '.', 1)
920− && CHECK_AT(parser->buffer, '.', 2)
921− && IS_BLANKZ_AT(parser->buffer, 3))
922− return yaml_parser_fetch_document_indicator(parser,
923− YAML_DOCUMENT_END_TOKEN);
924−
925− /* Is it the flow sequence start indicator? */
926−
927− if (CHECK(parser->buffer, '['))
928− return yaml_parser_fetch_flow_collection_start(parser,
929− YAML_FLOW_SEQUENCE_START_TOKEN);
930−
931− /* Is it the flow mapping start indicator? */
932−
933− if (CHECK(parser->buffer, '{'))
934− return yaml_parser_fetch_flow_collection_start(parser,
935− YAML_FLOW_MAPPING_START_TOKEN);
936−
937− /* Is it the flow sequence end indicator? */
938−
939− if (CHECK(parser->buffer, ']'))
940− return yaml_parser_fetch_flow_collection_end(parser,
941− YAML_FLOW_SEQUENCE_END_TOKEN);
942−
943− /* Is it the flow mapping end indicator? */
944−
945− if (CHECK(parser->buffer, '}'))
946− return yaml_parser_fetch_flow_collection_end(parser,
947− YAML_FLOW_MAPPING_END_TOKEN);
948−
949− /* Is it the flow entry indicator? */
950−
951− if (CHECK(parser->buffer, ','))
952− return yaml_parser_fetch_flow_entry(parser);
953−
954− /* Is it the block entry indicator? */
955−
956− if (CHECK(parser->buffer, '-') && IS_BLANKZ_AT(parser->buffer, 1))
957− return yaml_parser_fetch_block_entry(parser);
958−
959− /* Is it the key indicator? */
960−
961− if (CHECK(parser->buffer, '?')
962− && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))
963− return yaml_parser_fetch_key(parser);
964−
965− /* Is it the value indicator? */
966−
967− if (CHECK(parser->buffer, ':')
968− && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))
969− return yaml_parser_fetch_value(parser);
970−
971− /* Is it an alias? */
972−
973− if (CHECK(parser->buffer, '*'))
974− return yaml_parser_fetch_anchor(parser, YAML_ALIAS_TOKEN);
975−
976− /* Is it an anchor? */
977−
978− if (CHECK(parser->buffer, '&'))
979− return yaml_parser_fetch_anchor(parser, YAML_ANCHOR_TOKEN);
980−
981− /* Is it a tag? */
982−
983− if (CHECK(parser->buffer, '!'))
984− return yaml_parser_fetch_tag(parser);
985−
986− /* Is it a literal scalar? */
987−
988− if (CHECK(parser->buffer, '|') && !parser->flow_level)
989− return yaml_parser_fetch_block_scalar(parser, 1);
990−
991− /* Is it a folded scalar? */
992−
993− if (CHECK(parser->buffer, '>') && !parser->flow_level)
994− return yaml_parser_fetch_block_scalar(parser, 0);
995−
996− /* Is it a single-quoted scalar? */
997−
998− if (CHECK(parser->buffer, '\''))
999− return yaml_parser_fetch_flow_scalar(parser, 1);
1000−
1001− /* Is it a double-quoted scalar? */
1002−
1003− if (CHECK(parser->buffer, '"'))
1004− return yaml_parser_fetch_flow_scalar(parser, 0);
1005−
1006− /*
1007− * Is it a plain scalar?
1008− *
1009− * A plain scalar may start with any non-blank characters except
1010− *
1011− * '-', '?', ':', ',', '[', ']', '{', '}',
1012− * '#', '&', '*', '!', '|', '>', '\'', '\"',
1013− * '%', '@', '`'.
1014− *
1015− * In the block context (and, for the '-' indicator, in the flow context
1016− * too), it may also start with the characters
1017− *
1018− * '-', '?', ':'
1019− *
1020− * if it is followed by a non-space character.
1021− *
1022− * The last rule is more restrictive than the specification requires.
1023− */
1024−
1025− if (!(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '-')
1026− || CHECK(parser->buffer, '?') || CHECK(parser->buffer, ':')
1027− || CHECK(parser->buffer, ',') || CHECK(parser->buffer, '[')
1028− || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '{')
1029− || CHECK(parser->buffer, '}') || CHECK(parser->buffer, '#')
1030− || CHECK(parser->buffer, '&') || CHECK(parser->buffer, '*')
1031− || CHECK(parser->buffer, '!') || CHECK(parser->buffer, '|')
1032− || CHECK(parser->buffer, '>') || CHECK(parser->buffer, '\'')
1033− || CHECK(parser->buffer, '"') || CHECK(parser->buffer, '%')
1034− || CHECK(parser->buffer, '@') || CHECK(parser->buffer, '`')) ||
1035− (CHECK(parser->buffer, '-') && !IS_BLANK_AT(parser->buffer, 1)) ||
1036− (!parser->flow_level &&
1037− (CHECK(parser->buffer, '?') || CHECK(parser->buffer, ':'))
1038− && !IS_BLANKZ_AT(parser->buffer, 1)))
1039− return yaml_parser_fetch_plain_scalar(parser);
1040−
1041− /*
1042− * If we don't determine the token type so far, it is an error.
1043− */
1044−
1045− return yaml_parser_set_scanner_error(parser,
1046− "while scanning for the next token", parser->mark,
1047− "found character that cannot start any token");
1048−}
1049−
1050−/*
1051− * Check the list of potential simple keys and remove the positions that
1052− * cannot contain simple keys anymore.
1053− */
1054−
1055−static int
1056−yaml_parser_stale_simple_keys(yaml_parser_t *parser)
1057−{
1058− yaml_simple_key_t *simple_key;
1059−
1060− /* Check for a potential simple key for each flow level. */
1061−
1062− for (simple_key = parser->simple_keys.start;
1063− simple_key != parser->simple_keys.top; simple_key ++)
1064− {
1065− /*
1066− * The specification requires that a simple key
1067− *
1068− * - is limited to a single line,
1069− * - is shorter than 1024 characters.
1070− */
1071−
1072− if (simple_key->possible
1073− && (simple_key->mark.line < parser->mark.line
1074− || simple_key->mark.index+1024 < parser->mark.index)) {
1075−
1076− /* Check if the potential simple key to be removed is required. */
1077−
1078− if (simple_key->required) {
1079− return yaml_parser_set_scanner_error(parser,
1080− "while scanning a simple key", simple_key->mark,
1081− "could not find expected ':'");
1082− }
1083−
1084− simple_key->possible = 0;
1085− }
1086− }
1087−
1088− return 1;
1089−}
1090−
1091−/*
1092− * Check if a simple key may start at the current position and add it if
1093− * needed.
1094− */
1095−
1096−static int
1097−yaml_parser_save_simple_key(yaml_parser_t *parser)
1098−{
1099− /*
1100− * A simple key is required at the current position if the scanner is in
1101− * the block context and the current column coincides with the indentation
1102− * level.
1103− */
1104−
1105− int required = (!parser->flow_level
1106− && parser->indent == (ptrdiff_t)parser->mark.column);
1107−
1108− /*
1109− * If the current position may start a simple key, save it.
1110− */
1111−
1112− if (parser->simple_key_allowed)
1113− {
1114− yaml_simple_key_t simple_key;
1115− simple_key.possible = 1;
1116− simple_key.required = required;
1117− simple_key.token_number =
1118− parser->tokens_parsed + (parser->tokens.tail - parser->tokens.head);
1119− simple_key.mark = parser->mark;
1120−
1121− if (!yaml_parser_remove_simple_key(parser)) return 0;
1122−
1123− *(parser->simple_keys.top-1) = simple_key;
1124− }
1125−
1126− return 1;
1127−}
1128−
1129−/*
1130− * Remove a potential simple key at the current flow level.
1131− */
1132−
1133−static int
1134−yaml_parser_remove_simple_key(yaml_parser_t *parser)
1135−{
1136− yaml_simple_key_t *simple_key = parser->simple_keys.top-1;
1137−
1138− if (simple_key->possible)
1139− {
1140− /* If the key is required, it is an error. */
1141−
1142− if (simple_key->required) {
1143− return yaml_parser_set_scanner_error(parser,
1144− "while scanning a simple key", simple_key->mark,
1145− "could not find expected ':'");
1146− }
1147− }
1148−
1149− /* Remove the key from the stack. */
1150−
1151− simple_key->possible = 0;
1152−
1153− return 1;
1154−}
1155−
1156−/*
1157− * Increase the flow level and resize the simple key list if needed.
1158− */
1159−
1160−static int
1161−yaml_parser_increase_flow_level(yaml_parser_t *parser)
1162−{
1163− yaml_simple_key_t empty_simple_key = { 0, 0, 0, { 0, 0, 0 } };
1164−
1165− /* Reset the simple key on the next level. */
1166−
1167− if (!PUSH(parser, parser->simple_keys, empty_simple_key))
1168− return 0;
1169−
1170− /* Increase the flow level. */
1171−
1172− if (parser->flow_level == INT_MAX) {
1173− parser->error = YAML_MEMORY_ERROR;
1174− return 0;
1175− }
1176−
1177− parser->flow_level++;
1178−
1179− return 1;
1180−}
1181−
1182−/*
1183− * Decrease the flow level.
1184− */
1185−
1186−static int
1187−yaml_parser_decrease_flow_level(yaml_parser_t *parser)
1188−{
1189− if (parser->flow_level) {
1190− parser->flow_level --;
1191− (void)POP(parser, parser->simple_keys);
1192− }
1193−
1194− return 1;
1195−}
1196−
1197−/*
1198− * Push the current indentation level to the stack and set the new level
1199− * the current column is greater than the indentation level. In this case,
1200− * append or insert the specified token into the token queue.
1201− *
1202− */
1203−
1204−static int
1205−yaml_parser_roll_indent(yaml_parser_t *parser, ptrdiff_t column,
1206− ptrdiff_t number, yaml_token_type_t type, yaml_mark_t mark)
1207−{
1208− yaml_token_t token;
1209−
1210− /* In the flow context, do nothing. */
1211−
1212− if (parser->flow_level)
1213− return 1;
1214−
1215− if (parser->indent < column)
1216− {
1217− /*
1218− * Push the current indentation level to the stack and set the new
1219− * indentation level.
1220− */
1221−
1222− if (!PUSH(parser, parser->indents, parser->indent))
1223− return 0;
1224−
1225− if (column > INT_MAX) {
1226− parser->error = YAML_MEMORY_ERROR;
1227− return 0;
1228− }
1229−
1230− parser->indent = column;
1231−
1232− /* Create a token and insert it into the queue. */
1233−
1234− TOKEN_INIT(token, type, mark, mark);
1235−
1236− if (number == -1) {
1237− if (!ENQUEUE(parser, parser->tokens, token))
1238− return 0;
1239− }
1240− else {
1241− if (!QUEUE_INSERT(parser,
1242− parser->tokens, number - parser->tokens_parsed, token))
1243− return 0;
1244− }
1245− }
1246−
1247− return 1;
1248−}
1249−
1250−/*
1251− * Pop indentation levels from the indents stack until the current level
1252− * becomes less or equal to the column. For each indentation level, append
1253− * the BLOCK-END token.
1254− */
1255−
1256−
1257−static int
1258−yaml_parser_unroll_indent(yaml_parser_t *parser, ptrdiff_t column)
1259−{
1260− yaml_token_t token;
1261−
1262− /* In the flow context, do nothing. */
1263−
1264− if (parser->flow_level)
1265− return 1;
1266−
1267− /* Loop through the indentation levels in the stack. */
1268−
1269− while (parser->indent > column)
1270− {
1271− /* Create a token and append it to the queue. */
1272−
1273− TOKEN_INIT(token, YAML_BLOCK_END_TOKEN, parser->mark, parser->mark);
1274−
1275− if (!ENQUEUE(parser, parser->tokens, token))
1276− return 0;
1277−
1278− /* Pop the indentation level. */
1279−
1280− parser->indent = POP(parser, parser->indents);
1281− }
1282−
1283− return 1;
1284−}
1285−
1286−/*
1287− * Initialize the scanner and produce the STREAM-START token.
1288− */
1289−
1290−static int
1291−yaml_parser_fetch_stream_start(yaml_parser_t *parser)
1292−{
1293− yaml_simple_key_t simple_key = { 0, 0, 0, { 0, 0, 0 } };
1294− yaml_token_t token;
1295−
1296− /* Set the initial indentation. */
1297−
1298− parser->indent = -1;
1299−
1300− /* Initialize the simple key stack. */
1301−
1302− if (!PUSH(parser, parser->simple_keys, simple_key))
1303− return 0;
1304−
1305− /* A simple key is allowed at the beginning of the stream. */
1306−
1307− parser->simple_key_allowed = 1;
1308−
1309− /* We have started. */
1310−
1311− parser->stream_start_produced = 1;
1312−
1313− /* Create the STREAM-START token and append it to the queue. */
1314−
1315− STREAM_START_TOKEN_INIT(token, parser->encoding,
1316− parser->mark, parser->mark);
1317−
1318− if (!ENQUEUE(parser, parser->tokens, token))
1319− return 0;
1320−
1321− return 1;
1322−}
1323−
1324−/*
1325− * Produce the STREAM-END token and shut down the scanner.
1326− */
1327−
1328−static int
1329−yaml_parser_fetch_stream_end(yaml_parser_t *parser)
1330−{
1331− yaml_token_t token;
1332−
1333− /* Force new line. */
1334−
1335− if (parser->mark.column != 0) {
1336− parser->mark.column = 0;
1337− parser->mark.line ++;
1338− }
1339−
1340− /* Reset the indentation level. */
1341−
1342− if (!yaml_parser_unroll_indent(parser, -1))
1343− return 0;
1344−
1345− /* Reset simple keys. */
1346−
1347− if (!yaml_parser_remove_simple_key(parser))
1348− return 0;
1349−
1350− parser->simple_key_allowed = 0;
1351−
1352− /* Create the STREAM-END token and append it to the queue. */
1353−
1354− STREAM_END_TOKEN_INIT(token, parser->mark, parser->mark);
1355−
1356− if (!ENQUEUE(parser, parser->tokens, token))
1357− return 0;
1358−
1359− return 1;
1360−}
1361−
1362−/*
1363− * Produce a VERSION-DIRECTIVE or TAG-DIRECTIVE token.
1364− */
1365−
1366−static int
1367−yaml_parser_fetch_directive(yaml_parser_t *parser)
1368−{
1369− yaml_token_t token;
1370−
1371− /* Reset the indentation level. */
1372−
1373− if (!yaml_parser_unroll_indent(parser, -1))
1374− return 0;
1375−
1376− /* Reset simple keys. */
1377−
1378− if (!yaml_parser_remove_simple_key(parser))
1379− return 0;
1380−
1381− parser->simple_key_allowed = 0;
1382−
1383− /* Create the YAML-DIRECTIVE or TAG-DIRECTIVE token. */
1384−
1385− if (!yaml_parser_scan_directive(parser, &token))
1386− return 0;
1387−
1388− /* Append the token to the queue. */
1389−
1390− if (!ENQUEUE(parser, parser->tokens, token)) {
1391− yaml_token_delete(&token);
1392− return 0;
1393− }
1394−
1395− return 1;
1396−}
1397−
1398−/*
1399− * Produce the DOCUMENT-START or DOCUMENT-END token.
1400− */
1401−
1402−static int
1403−yaml_parser_fetch_document_indicator(yaml_parser_t *parser,
1404− yaml_token_type_t type)
1405−{
1406− yaml_mark_t start_mark, end_mark;
1407− yaml_token_t token;
1408−
1409− /* Reset the indentation level. */
1410−
1411− if (!yaml_parser_unroll_indent(parser, -1))
1412− return 0;
1413−
1414− /* Reset simple keys. */
1415−
1416− if (!yaml_parser_remove_simple_key(parser))
1417− return 0;
1418−
1419− parser->simple_key_allowed = 0;
1420−
1421− /* Consume the token. */
1422−
1423− start_mark = parser->mark;
1424−
1425− SKIP(parser);
1426− SKIP(parser);
1427− SKIP(parser);
1428−
1429− end_mark = parser->mark;
1430−
1431− /* Create the DOCUMENT-START or DOCUMENT-END token. */
1432−
1433− TOKEN_INIT(token, type, start_mark, end_mark);
1434−
1435− /* Append the token to the queue. */
1436−
1437− if (!ENQUEUE(parser, parser->tokens, token))
1438− return 0;
1439−
1440− return 1;
1441−}
1442−
1443−/*
1444− * Produce the FLOW-SEQUENCE-START or FLOW-MAPPING-START token.
1445− */
1446−
1447−static int
1448−yaml_parser_fetch_flow_collection_start(yaml_parser_t *parser,
1449− yaml_token_type_t type)
1450−{
1451− yaml_mark_t start_mark, end_mark;
1452− yaml_token_t token;
1453−
1454− /* The indicators '[' and '{' may start a simple key. */
1455−
1456− if (!yaml_parser_save_simple_key(parser))
1457− return 0;
1458−
1459− /* Increase the flow level. */
1460−
1461− if (!yaml_parser_increase_flow_level(parser))
1462− return 0;
1463−
1464− /* A simple key may follow the indicators '[' and '{'. */
1465−
1466− parser->simple_key_allowed = 1;
1467−
1468− /* Consume the token. */
1469−
1470− start_mark = parser->mark;
1471− SKIP(parser);
1472− end_mark = parser->mark;
1473−
1474− /* Create the FLOW-SEQUENCE-START of FLOW-MAPPING-START token. */
1475−
1476− TOKEN_INIT(token, type, start_mark, end_mark);
1477−
1478− /* Append the token to the queue. */
1479−
1480− if (!ENQUEUE(parser, parser->tokens, token))
1481− return 0;
1482−
1483− return 1;
1484−}
1485−
1486−/*
1487− * Produce the FLOW-SEQUENCE-END or FLOW-MAPPING-END token.
1488− */
1489−
1490−static int
1491−yaml_parser_fetch_flow_collection_end(yaml_parser_t *parser,
1492− yaml_token_type_t type)
1493−{
1494− yaml_mark_t start_mark, end_mark;
1495− yaml_token_t token;
1496−
1497− /* Reset any potential simple key on the current flow level. */
1498−
1499− if (!yaml_parser_remove_simple_key(parser))
1500− return 0;
1501−
1502− /* Decrease the flow level. */
1503−
1504− if (!yaml_parser_decrease_flow_level(parser))
1505− return 0;
1506−
1507− /* No simple keys after the indicators ']' and '}'. */
1508−
1509− parser->simple_key_allowed = 0;
1510−
1511− /* Consume the token. */
1512−
1513− start_mark = parser->mark;
1514− SKIP(parser);
1515− end_mark = parser->mark;
1516−
1517− /* Create the FLOW-SEQUENCE-END of FLOW-MAPPING-END token. */
1518−
1519− TOKEN_INIT(token, type, start_mark, end_mark);
1520−
1521− /* Append the token to the queue. */
1522−
1523− if (!ENQUEUE(parser, parser->tokens, token))
1524− return 0;
1525−
1526− return 1;
1527−}
1528−
1529−/*
1530− * Produce the FLOW-ENTRY token.
1531− */
1532−
1533−static int
1534−yaml_parser_fetch_flow_entry(yaml_parser_t *parser)
1535−{
1536− yaml_mark_t start_mark, end_mark;
1537− yaml_token_t token;
1538−
1539− /* Reset any potential simple keys on the current flow level. */
1540−
1541− if (!yaml_parser_remove_simple_key(parser))
1542− return 0;
1543−
1544− /* Simple keys are allowed after ','. */
1545−
1546− parser->simple_key_allowed = 1;
1547−
1548− /* Consume the token. */
1549−
1550− start_mark = parser->mark;
1551− SKIP(parser);
1552− end_mark = parser->mark;
1553−
1554− /* Create the FLOW-ENTRY token and append it to the queue. */
1555−
1556− TOKEN_INIT(token, YAML_FLOW_ENTRY_TOKEN, start_mark, end_mark);
1557−
1558− if (!ENQUEUE(parser, parser->tokens, token))
1559− return 0;
1560−
1561− return 1;
1562−}
1563−
1564−/*
1565− * Produce the BLOCK-ENTRY token.
1566− */
1567−
1568−static int
1569−yaml_parser_fetch_block_entry(yaml_parser_t *parser)
1570−{
1571− yaml_mark_t start_mark, end_mark;
1572− yaml_token_t token;
1573−
1574− /* Check if the scanner is in the block context. */
1575−
1576− if (!parser->flow_level)
1577− {
1578− /* Check if we are allowed to start a new entry. */
1579−
1580− if (!parser->simple_key_allowed) {
1581− return yaml_parser_set_scanner_error(parser, NULL, parser->mark,
1582− "block sequence entries are not allowed in this context");
1583− }
1584−
1585− /* Add the BLOCK-SEQUENCE-START token if needed. */
1586−
1587− if (!yaml_parser_roll_indent(parser, parser->mark.column, -1,
1588− YAML_BLOCK_SEQUENCE_START_TOKEN, parser->mark))
1589− return 0;
1590− }
1591− else
1592− {
1593− /*
1594− * It is an error for the '-' indicator to occur in the flow context,
1595− * but we let the Parser detect and report about it because the Parser
1596− * is able to point to the context.
1597− */
1598− }
1599−
1600− /* Reset any potential simple keys on the current flow level. */
1601−
1602− if (!yaml_parser_remove_simple_key(parser))
1603− return 0;
1604−
1605− /* Simple keys are allowed after '-'. */
1606−
1607− parser->simple_key_allowed = 1;
1608−
1609− /* Consume the token. */
1610−
1611− start_mark = parser->mark;
1612− SKIP(parser);
1613− end_mark = parser->mark;
1614−
1615− /* Create the BLOCK-ENTRY token and append it to the queue. */
1616−
1617− TOKEN_INIT(token, YAML_BLOCK_ENTRY_TOKEN, start_mark, end_mark);
1618−
1619− if (!ENQUEUE(parser, parser->tokens, token))
1620− return 0;
1621−
1622− return 1;
1623−}
1624−
1625−/*
1626− * Produce the KEY token.
1627− */
1628−
1629−static int
1630−yaml_parser_fetch_key(yaml_parser_t *parser)
1631−{
1632− yaml_mark_t start_mark, end_mark;
1633− yaml_token_t token;
1634−
1635− /* In the block context, additional checks are required. */
1636−
1637− if (!parser->flow_level)
1638− {
1639− /* Check if we are allowed to start a new key (not necessary simple). */
1640−
1641− if (!parser->simple_key_allowed) {
1642− return yaml_parser_set_scanner_error(parser, NULL, parser->mark,
1643− "mapping keys are not allowed in this context");
1644− }
1645−
1646− /* Add the BLOCK-MAPPING-START token if needed. */
1647−
1648− if (!yaml_parser_roll_indent(parser, parser->mark.column, -1,
1649− YAML_BLOCK_MAPPING_START_TOKEN, parser->mark))
1650− return 0;
1651− }
1652−
1653− /* Reset any potential simple keys on the current flow level. */
1654−
1655− if (!yaml_parser_remove_simple_key(parser))
1656− return 0;
1657−
1658− /* Simple keys are allowed after '?' in the block context. */
1659−
1660− parser->simple_key_allowed = (!parser->flow_level);
1661−
1662− /* Consume the token. */
1663−
1664− start_mark = parser->mark;
1665− SKIP(parser);
1666− end_mark = parser->mark;
1667−
1668− /* Create the KEY token and append it to the queue. */
1669−
1670− TOKEN_INIT(token, YAML_KEY_TOKEN, start_mark, end_mark);
1671−
1672− if (!ENQUEUE(parser, parser->tokens, token))
1673− return 0;
1674−
1675− return 1;
1676−}
1677−
1678−/*
1679− * Produce the VALUE token.
1680− */
1681−
1682−static int
1683−yaml_parser_fetch_value(yaml_parser_t *parser)
1684−{
1685− yaml_mark_t start_mark, end_mark;
1686− yaml_token_t token;
1687− yaml_simple_key_t *simple_key = parser->simple_keys.top-1;
1688−
1689− /* Have we found a simple key? */
1690−
1691− if (simple_key->possible)
1692− {
1693−
1694− /* Create the KEY token and insert it into the queue. */
1695−
1696− TOKEN_INIT(token, YAML_KEY_TOKEN, simple_key->mark, simple_key->mark);
1697−
1698− if (!QUEUE_INSERT(parser, parser->tokens,
1699− simple_key->token_number - parser->tokens_parsed, token))
1700− return 0;
1701−
1702− /* In the block context, we may need to add the BLOCK-MAPPING-START token. */
1703−
1704− if (!yaml_parser_roll_indent(parser, simple_key->mark.column,
1705− simple_key->token_number,
1706− YAML_BLOCK_MAPPING_START_TOKEN, simple_key->mark))
1707− return 0;
1708−
1709− /* Remove the simple key. */
1710−
1711− simple_key->possible = 0;
1712−
1713− /* A simple key cannot follow another simple key. */
1714−
1715− parser->simple_key_allowed = 0;
1716− }
1717− else
1718− {
1719− /* The ':' indicator follows a complex key. */
1720−
1721− /* In the block context, extra checks are required. */
1722−
1723− if (!parser->flow_level)
1724− {
1725− /* Check if we are allowed to start a complex value. */
1726−
1727− if (!parser->simple_key_allowed) {
1728− return yaml_parser_set_scanner_error(parser, NULL, parser->mark,
1729− "mapping values are not allowed in this context");
1730− }
1731−
1732− /* Add the BLOCK-MAPPING-START token if needed. */
1733−
1734− if (!yaml_parser_roll_indent(parser, parser->mark.column, -1,
1735− YAML_BLOCK_MAPPING_START_TOKEN, parser->mark))
1736− return 0;
1737− }
1738−
1739− /* Simple keys after ':' are allowed in the block context. */
1740−
1741− parser->simple_key_allowed = (!parser->flow_level);
1742− }
1743−
1744− /* Consume the token. */
1745−
1746− start_mark = parser->mark;
1747− SKIP(parser);
1748− end_mark = parser->mark;
1749−
1750− /* Create the VALUE token and append it to the queue. */
1751−
1752− TOKEN_INIT(token, YAML_VALUE_TOKEN, start_mark, end_mark);
1753−
1754− if (!ENQUEUE(parser, parser->tokens, token))
1755− return 0;
1756−
1757− return 1;
1758−}
1759−
1760−/*
1761− * Produce the ALIAS or ANCHOR token.
1762− */
1763−
1764−static int
1765−yaml_parser_fetch_anchor(yaml_parser_t *parser, yaml_token_type_t type)
1766−{
1767− yaml_token_t token;
1768−
1769− /* An anchor or an alias could be a simple key. */
1770−
1771− if (!yaml_parser_save_simple_key(parser))
1772− return 0;
1773−
1774− /* A simple key cannot follow an anchor or an alias. */
1775−
1776− parser->simple_key_allowed = 0;
1777−
1778− /* Create the ALIAS or ANCHOR token and append it to the queue. */
1779−
1780− if (!yaml_parser_scan_anchor(parser, &token, type))
1781− return 0;
1782−
1783− if (!ENQUEUE(parser, parser->tokens, token)) {
1784− yaml_token_delete(&token);
1785− return 0;
1786− }
1787− return 1;
1788−}
1789−
1790−/*
1791− * Produce the TAG token.
1792− */
1793−
1794−static int
1795−yaml_parser_fetch_tag(yaml_parser_t *parser)
1796−{
1797− yaml_token_t token;
1798−
1799− /* A tag could be a simple key. */
1800−
1801− if (!yaml_parser_save_simple_key(parser))
1802− return 0;
1803−
1804− /* A simple key cannot follow a tag. */
1805−
1806− parser->simple_key_allowed = 0;
1807−
1808− /* Create the TAG token and append it to the queue. */
1809−
1810− if (!yaml_parser_scan_tag(parser, &token))
1811− return 0;
1812−
1813− if (!ENQUEUE(parser, parser->tokens, token)) {
1814− yaml_token_delete(&token);
1815− return 0;
1816− }
1817−
1818− return 1;
1819−}
1820−
1821−/*
1822− * Produce the SCALAR(...,literal) or SCALAR(...,folded) tokens.
1823− */
1824−
1825−static int
1826−yaml_parser_fetch_block_scalar(yaml_parser_t *parser, int literal)
1827−{
1828− yaml_token_t token;
1829−
1830− /* Remove any potential simple keys. */
1831−
1832− if (!yaml_parser_remove_simple_key(parser))
1833− return 0;
1834−
1835− /* A simple key may follow a block scalar. */
1836−
1837− parser->simple_key_allowed = 1;
1838−
1839− /* Create the SCALAR token and append it to the queue. */
1840−
1841− if (!yaml_parser_scan_block_scalar(parser, &token, literal))
1842− return 0;
1843−
1844− if (!ENQUEUE(parser, parser->tokens, token)) {
1845− yaml_token_delete(&token);
1846− return 0;
1847− }
1848−
1849− return 1;
1850−}
1851−
1852−/*
1853− * Produce the SCALAR(...,single-quoted) or SCALAR(...,double-quoted) tokens.
1854− */
1855−
1856−static int
1857−yaml_parser_fetch_flow_scalar(yaml_parser_t *parser, int single)
1858−{
1859− yaml_token_t token;
1860−
1861− /* A plain scalar could be a simple key. */
1862−
1863− if (!yaml_parser_save_simple_key(parser))
1864− return 0;
1865−
1866− /* A simple key cannot follow a flow scalar. */
1867−
1868− parser->simple_key_allowed = 0;
1869−
1870− /* Create the SCALAR token and append it to the queue. */
1871−
1872− if (!yaml_parser_scan_flow_scalar(parser, &token, single))
1873− return 0;
1874−
1875− if (!ENQUEUE(parser, parser->tokens, token)) {
1876− yaml_token_delete(&token);
1877− return 0;
1878− }
1879−
1880− return 1;
1881−}
1882−
1883−/*
1884− * Produce the SCALAR(...,plain) token.
1885− */
1886−
1887−static int
1888−yaml_parser_fetch_plain_scalar(yaml_parser_t *parser)
1889−{
1890− yaml_token_t token;
1891−
1892− /* A plain scalar could be a simple key. */
1893−
1894− if (!yaml_parser_save_simple_key(parser))
1895− return 0;
1896−
1897− /* A simple key cannot follow a flow scalar. */
1898−
1899− parser->simple_key_allowed = 0;
1900−
1901− /* Create the SCALAR token and append it to the queue. */
1902−
1903− if (!yaml_parser_scan_plain_scalar(parser, &token))
1904− return 0;
1905−
1906− if (!ENQUEUE(parser, parser->tokens, token)) {
1907− yaml_token_delete(&token);
1908− return 0;
1909− }
1910−
1911− return 1;
1912−}
1913−
1914−/*
1915− * Eat whitespaces and comments until the next token is found.
1916− */
1917−
1918−static int
1919−yaml_parser_scan_to_next_token(yaml_parser_t *parser)
1920−{
1921− /* Until the next token is not found. */
1922−
1923− while (1)
1924− {
1925− /* Allow the BOM mark to start a line. */
1926−
1927− if (!CACHE(parser, 1)) return 0;
1928−
1929− if (parser->mark.column == 0 && IS_BOM(parser->buffer))
1930− SKIP(parser);
1931−
1932− /*
1933− * Eat whitespaces.
1934− *
1935− * Tabs are allowed:
1936− *
1937− * - in the flow context;
1938− * - in the block context, but not at the beginning of the line or
1939− * after '-', '?', or ':' (complex value).
1940− */
1941−
1942− if (!CACHE(parser, 1)) return 0;
1943−
1944− while (CHECK(parser->buffer,' ') ||
1945− ((parser->flow_level || !parser->simple_key_allowed) &&
1946− CHECK(parser->buffer, '\t'))) {
1947− SKIP(parser);
1948− if (!CACHE(parser, 1)) return 0;
1949− }
1950−
1951− /* Eat a comment until a line break. */
1952−
1953− if (CHECK(parser->buffer, '#')) {
1954− while (!IS_BREAKZ(parser->buffer)) {
1955− SKIP(parser);
1956− if (!CACHE(parser, 1)) return 0;
1957− }
1958− }
1959−
1960− /* If it is a line break, eat it. */
1961−
1962− if (IS_BREAK(parser->buffer))
1963− {
1964− if (!CACHE(parser, 2)) return 0;
1965− SKIP_LINE(parser);
1966−
1967− /* In the block context, a new line may start a simple key. */
1968−
1969− if (!parser->flow_level) {
1970− parser->simple_key_allowed = 1;
1971− }
1972− }
1973− else
1974− {
1975− /* We have found a token. */
1976−
1977− break;
1978− }
1979− }
1980−
1981− return 1;
1982−}
1983−
1984−/*
1985− * Scan a YAML-DIRECTIVE or TAG-DIRECTIVE token.
1986− *
1987− * Scope:
1988− * %YAML 1.1 # a comment \n
1989− * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1990− * %TAG !yaml! tag:yaml.org,2002: \n
1991− * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
1992− */
1993−
1994−int
1995−yaml_parser_scan_directive(yaml_parser_t *parser, yaml_token_t *token)
1996−{
1997− yaml_mark_t start_mark, end_mark;
1998− yaml_char_t *name = NULL;
1999− int major, minor;
2000− yaml_char_t *handle = NULL, *prefix = NULL;
2001−
2002− /* Eat '%'. */
2003−
2004− start_mark = parser->mark;
2005−
2006− SKIP(parser);
2007−
2008− /* Scan the directive name. */
2009−
2010− if (!yaml_parser_scan_directive_name(parser, start_mark, &name))
2011− goto error;
2012−
2013− /* Is it a YAML directive? */
2014−
2015− if (strcmp((char *)name, "YAML") == 0)
2016− {
2017− /* Scan the VERSION directive value. */
2018−
2019− if (!yaml_parser_scan_version_directive_value(parser, start_mark,
2020− &major, &minor))
2021− goto error;
2022−
2023− end_mark = parser->mark;
2024−
2025− /* Create a VERSION-DIRECTIVE token. */
2026−
2027− VERSION_DIRECTIVE_TOKEN_INIT(*token, major, minor,
2028− start_mark, end_mark);
2029− }
2030−
2031− /* Is it a TAG directive? */
2032−
2033− else if (strcmp((char *)name, "TAG") == 0)
2034− {
2035− /* Scan the TAG directive value. */
2036−
2037− if (!yaml_parser_scan_tag_directive_value(parser, start_mark,
2038− &handle, &prefix))
2039− goto error;
2040−
2041− end_mark = parser->mark;
2042−
2043− /* Create a TAG-DIRECTIVE token. */
2044−
2045− TAG_DIRECTIVE_TOKEN_INIT(*token, handle, prefix,
2046− start_mark, end_mark);
2047− }
2048−
2049− /* Unknown directive. */
2050−
2051− else
2052− {
2053− yaml_parser_set_scanner_error(parser, "while scanning a directive",
2054− start_mark, "found unknown directive name");
2055− goto error;
2056− }
2057−
2058− /* Eat the rest of the line including any comments. */
2059−
2060− if (!CACHE(parser, 1)) goto error;
2061−
2062− while (IS_BLANK(parser->buffer)) {
2063− SKIP(parser);
2064− if (!CACHE(parser, 1)) goto error;
2065− }
2066−
2067− if (CHECK(parser->buffer, '#')) {
2068− while (!IS_BREAKZ(parser->buffer)) {
2069− SKIP(parser);
2070− if (!CACHE(parser, 1)) goto error;
2071− }
2072− }
2073−
2074− /* Check if we are at the end of the line. */
2075−
2076− if (!IS_BREAKZ(parser->buffer)) {
2077− yaml_parser_set_scanner_error(parser, "while scanning a directive",
2078− start_mark, "did not find expected comment or line break");
2079− goto error;
2080− }
2081−
2082− /* Eat a line break. */
2083−
2084− if (IS_BREAK(parser->buffer)) {
2085− if (!CACHE(parser, 2)) goto error;
2086− SKIP_LINE(parser);
2087− }
2088−
2089− yaml_free(name);
2090−
2091− return 1;
2092−
2093−error:
2094− yaml_free(prefix);
2095− yaml_free(handle);
2096− yaml_free(name);
2097− return 0;
2098−}
2099−
2100−/*
2101− * Scan the directive name.
2102− *
2103− * Scope:
2104− * %YAML 1.1 # a comment \n
2105− * ^^^^
2106− * %TAG !yaml! tag:yaml.org,2002: \n
2107− * ^^^
2108− */
2109−
2110−static int
2111−yaml_parser_scan_directive_name(yaml_parser_t *parser,
2112− yaml_mark_t start_mark, yaml_char_t **name)
2113−{
2114− yaml_string_t string = NULL_STRING;
2115−
2116− if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
2117−
2118− /* Consume the directive name. */
2119−
2120− if (!CACHE(parser, 1)) goto error;
2121−
2122− while (IS_ALPHA(parser->buffer))
2123− {
2124− if (!READ(parser, string)) goto error;
2125− if (!CACHE(parser, 1)) goto error;
2126− }
2127−
2128− /* Check if the name is empty. */
2129−
2130− if (string.start == string.pointer) {
2131− yaml_parser_set_scanner_error(parser, "while scanning a directive",
2132− start_mark, "could not find expected directive name");
2133− goto error;
2134− }
2135−
2136− /* Check for an blank character after the name. */
2137−
2138− if (!IS_BLANKZ(parser->buffer)) {
2139− yaml_parser_set_scanner_error(parser, "while scanning a directive",
2140− start_mark, "found unexpected non-alphabetical character");
2141− goto error;
2142− }
2143−
2144− *name = string.start;
2145−
2146− return 1;
2147−
2148−error:
2149− STRING_DEL(parser, string);
2150− return 0;
2151−}
2152−
2153−/*
2154− * Scan the value of VERSION-DIRECTIVE.
2155− *
2156− * Scope:
2157− * %YAML 1.1 # a comment \n
2158− * ^^^^^^
2159− */
2160−
2161−static int
2162−yaml_parser_scan_version_directive_value(yaml_parser_t *parser,
2163− yaml_mark_t start_mark, int *major, int *minor)
2164−{
2165− /* Eat whitespaces. */
2166−
2167− if (!CACHE(parser, 1)) return 0;
2168−
2169− while (IS_BLANK(parser->buffer)) {
2170− SKIP(parser);
2171− if (!CACHE(parser, 1)) return 0;
2172− }
2173−
2174− /* Consume the major version number. */
2175−
2176− if (!yaml_parser_scan_version_directive_number(parser, start_mark, major))
2177− return 0;
2178−
2179− /* Eat '.'. */
2180−
2181− if (!CHECK(parser->buffer, '.')) {
2182− return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",
2183− start_mark, "did not find expected digit or '.' character");
2184− }
2185−
2186− SKIP(parser);
2187−
2188− /* Consume the minor version number. */
2189−
2190− if (!yaml_parser_scan_version_directive_number(parser, start_mark, minor))
2191− return 0;
2192−
2193− return 1;
2194−}
2195−
2196−#define MAX_NUMBER_LENGTH 9
2197−
2198−/*
2199− * Scan the version number of VERSION-DIRECTIVE.
2200− *
2201− * Scope:
2202− * %YAML 1.1 # a comment \n
2203− * ^
2204− * %YAML 1.1 # a comment \n
2205− * ^
2206− */
2207−
2208−static int
2209−yaml_parser_scan_version_directive_number(yaml_parser_t *parser,
2210− yaml_mark_t start_mark, int *number)
2211−{
2212− int value = 0;
2213− size_t length = 0;
2214−
2215− /* Repeat while the next character is digit. */
2216−
2217− if (!CACHE(parser, 1)) return 0;
2218−
2219− while (IS_DIGIT(parser->buffer))
2220− {
2221− /* Check if the number is too long. */
2222−
2223− if (++length > MAX_NUMBER_LENGTH) {
2224− return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",
2225− start_mark, "found extremely long version number");
2226− }
2227−
2228− value = value*10 + AS_DIGIT(parser->buffer);
2229−
2230− SKIP(parser);
2231−
2232− if (!CACHE(parser, 1)) return 0;
2233− }
2234−
2235− /* Check if the number was present. */
2236−
2237− if (!length) {
2238− return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",
2239− start_mark, "did not find expected version number");
2240− }
2241−
2242− *number = value;
2243−
2244− return 1;
2245−}
2246−
2247−/*
2248− * Scan the value of a TAG-DIRECTIVE token.
2249− *
2250− * Scope:
2251− * %TAG !yaml! tag:yaml.org,2002: \n
2252− * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
2253− */
2254−
2255−static int
2256−yaml_parser_scan_tag_directive_value(yaml_parser_t *parser,
2257− yaml_mark_t start_mark, yaml_char_t **handle, yaml_char_t **prefix)
2258−{
2259− yaml_char_t *handle_value = NULL;
2260− yaml_char_t *prefix_value = NULL;
2261−
2262− /* Eat whitespaces. */
2263−
2264− if (!CACHE(parser, 1)) goto error;
2265−
2266− while (IS_BLANK(parser->buffer)) {
2267− SKIP(parser);
2268− if (!CACHE(parser, 1)) goto error;
2269− }
2270−
2271− /* Scan a handle. */
2272−
2273− if (!yaml_parser_scan_tag_handle(parser, 1, start_mark, &handle_value))
2274− goto error;
2275−
2276− /* Expect a whitespace. */
2277−
2278− if (!CACHE(parser, 1)) goto error;
2279−
2280− if (!IS_BLANK(parser->buffer)) {
2281− yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive",
2282− start_mark, "did not find expected whitespace");
2283− goto error;
2284− }
2285−
2286− /* Eat whitespaces. */
2287−
2288− while (IS_BLANK(parser->buffer)) {
2289− SKIP(parser);
2290− if (!CACHE(parser, 1)) goto error;
2291− }
2292−
2293− /* Scan a prefix. */
2294−
2295− if (!yaml_parser_scan_tag_uri(parser, 1, NULL, start_mark, &prefix_value))
2296− goto error;
2297−
2298− /* Expect a whitespace or line break. */
2299−
2300− if (!CACHE(parser, 1)) goto error;
2301−
2302− if (!IS_BLANKZ(parser->buffer)) {
2303− yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive",
2304− start_mark, "did not find expected whitespace or line break");
2305− goto error;
2306− }
2307−
2308− *handle = handle_value;
2309− *prefix = prefix_value;
2310−
2311− return 1;
2312−
2313−error:
2314− yaml_free(handle_value);
2315− yaml_free(prefix_value);
2316− return 0;
2317−}
2318−
2319−static int
2320−yaml_parser_scan_anchor(yaml_parser_t *parser, yaml_token_t *token,
2321− yaml_token_type_t type)
2322−{
2323− int length = 0;
2324− yaml_mark_t start_mark, end_mark;
2325− yaml_string_t string = NULL_STRING;
2326−
2327− if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
2328−
2329− /* Eat the indicator character. */
2330−
2331− start_mark = parser->mark;
2332−
2333− SKIP(parser);
2334−
2335− /* Consume the value. */
2336−
2337− if (!CACHE(parser, 1)) goto error;
2338−
2339− while (IS_ALPHA(parser->buffer)) {
2340− if (!READ(parser, string)) goto error;
2341− if (!CACHE(parser, 1)) goto error;
2342− length ++;
2343− }
2344−
2345− end_mark = parser->mark;
2346−
2347− /*
2348− * Check if length of the anchor is greater than 0 and it is followed by
2349− * a whitespace character or one of the indicators:
2350− *
2351− * '?', ':', ',', ']', '}', '%', '@', '`'.
2352− */
2353−
2354− if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?')
2355− || CHECK(parser->buffer, ':') || CHECK(parser->buffer, ',')
2356− || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '}')
2357− || CHECK(parser->buffer, '%') || CHECK(parser->buffer, '@')
2358− || CHECK(parser->buffer, '`'))) {
2359− yaml_parser_set_scanner_error(parser, type == YAML_ANCHOR_TOKEN ?
2360− "while scanning an anchor" : "while scanning an alias", start_mark,
2361− "did not find expected alphabetic or numeric character");
2362− goto error;
2363− }
2364−
2365− /* Create a token. */
2366−
2367− if (type == YAML_ANCHOR_TOKEN) {
2368− ANCHOR_TOKEN_INIT(*token, string.start, start_mark, end_mark);
2369− }
2370− else {
2371− ALIAS_TOKEN_INIT(*token, string.start, start_mark, end_mark);
2372− }
2373−
2374− return 1;
2375−
2376−error:
2377− STRING_DEL(parser, string);
2378− return 0;
2379−}
2380−
2381−/*
2382− * Scan a TAG token.
2383− */
2384−
2385−static int
2386−yaml_parser_scan_tag(yaml_parser_t *parser, yaml_token_t *token)
2387−{
2388− yaml_char_t *handle = NULL;
2389− yaml_char_t *suffix = NULL;
2390− yaml_mark_t start_mark, end_mark;
2391−
2392− start_mark = parser->mark;
2393−
2394− /* Check if the tag is in the canonical form. */
2395−
2396− if (!CACHE(parser, 2)) goto error;
2397−
2398− if (CHECK_AT(parser->buffer, '<', 1))
2399− {
2400− /* Set the handle to '' */
2401−
2402− handle = YAML_MALLOC(1);
2403− if (!handle) goto error;
2404− handle[0] = '\0';
2405−
2406− /* Eat '!<' */
2407−
2408− SKIP(parser);
2409− SKIP(parser);
2410−
2411− /* Consume the tag value. */
2412−
2413− if (!yaml_parser_scan_tag_uri(parser, 0, NULL, start_mark, &suffix))
2414− goto error;
2415−
2416− /* Check for '>' and eat it. */
2417−
2418− if (!CHECK(parser->buffer, '>')) {
2419− yaml_parser_set_scanner_error(parser, "while scanning a tag",
2420− start_mark, "did not find the expected '>'");
2421− goto error;
2422− }
2423−
2424− SKIP(parser);
2425− }
2426− else
2427− {
2428− /* The tag has either the '!suffix' or the '!handle!suffix' form. */
2429−
2430− /* First, try to scan a handle. */
2431−
2432− if (!yaml_parser_scan_tag_handle(parser, 0, start_mark, &handle))
2433− goto error;
2434−
2435− /* Check if it is, indeed, handle. */
2436−
2437− if (handle[0] == '!' && handle[1] != '\0' && handle[strlen((char *)handle)-1] == '!')
2438− {
2439− /* Scan the suffix now. */
2440−
2441− if (!yaml_parser_scan_tag_uri(parser, 0, NULL, start_mark, &suffix))
2442− goto error;
2443− }
2444− else
2445− {
2446− /* It wasn't a handle after all. Scan the rest of the tag. */
2447−
2448− if (!yaml_parser_scan_tag_uri(parser, 0, handle, start_mark, &suffix))
2449− goto error;
2450−
2451− /* Set the handle to '!'. */
2452−
2453− yaml_free(handle);
2454− handle = YAML_MALLOC(2);
2455− if (!handle) goto error;
2456− handle[0] = '!';
2457− handle[1] = '\0';
2458−
2459− /*
2460− * A special case: the '!' tag. Set the handle to '' and the
2461− * suffix to '!'.
2462− */
2463−
2464− if (suffix[0] == '\0') {
2465− yaml_char_t *tmp = handle;
2466− handle = suffix;
2467− suffix = tmp;
2468− }
2469− }
2470− }
2471−
2472− /* Check the character which ends the tag. */
2473−
2474− if (!CACHE(parser, 1)) goto error;
2475−
2476− if (!IS_BLANKZ(parser->buffer)) {
2477− yaml_parser_set_scanner_error(parser, "while scanning a tag",
2478− start_mark, "did not find expected whitespace or line break");
2479− goto error;
2480− }
2481−
2482− end_mark = parser->mark;
2483−
2484− /* Create a token. */
2485−
2486− TAG_TOKEN_INIT(*token, handle, suffix, start_mark, end_mark);
2487−
2488− return 1;
2489−
2490−error:
2491− yaml_free(handle);
2492− yaml_free(suffix);
2493− return 0;
2494−}
2495−
2496−/*
2497− * Scan a tag handle.
2498− */
2499−
2500−static int
2501−yaml_parser_scan_tag_handle(yaml_parser_t *parser, int directive,
2502− yaml_mark_t start_mark, yaml_char_t **handle)
2503−{
2504− yaml_string_t string = NULL_STRING;
2505−
2506− if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
2507−
2508− /* Check the initial '!' character. */
2509−
2510− if (!CACHE(parser, 1)) goto error;
2511−
2512− if (!CHECK(parser->buffer, '!')) {
2513− yaml_parser_set_scanner_error(parser, directive ?
2514− "while scanning a tag directive" : "while scanning a tag",
2515− start_mark, "did not find expected '!'");
2516− goto error;
2517− }
2518−
2519− /* Copy the '!' character. */
2520−
2521− if (!READ(parser, string)) goto error;
2522−
2523− /* Copy all subsequent alphabetical and numerical characters. */
2524−
2525− if (!CACHE(parser, 1)) goto error;
2526−
2527− while (IS_ALPHA(parser->buffer))
2528− {
2529− if (!READ(parser, string)) goto error;
2530− if (!CACHE(parser, 1)) goto error;
2531− }
2532−
2533− /* Check if the trailing character is '!' and copy it. */
2534−
2535− if (CHECK(parser->buffer, '!'))
2536− {
2537− if (!READ(parser, string)) goto error;
2538− }
2539− else
2540− {
2541− /*
2542− * It's either the '!' tag or not really a tag handle. If it's a %TAG
2543− * directive, it's an error. If it's a tag token, it must be a part of
2544− * URI.
2545− */
2546−
2547− if (directive && !(string.start[0] == '!' && string.start[1] == '\0')) {
2548− yaml_parser_set_scanner_error(parser, "while parsing a tag directive",
2549− start_mark, "did not find expected '!'");
2550− goto error;
2551− }
2552− }
2553−
2554− *handle = string.start;
2555−
2556− return 1;
2557−
2558−error:
2559− STRING_DEL(parser, string);
2560− return 0;
2561−}
2562−
2563−/*
2564− * Scan a tag.
2565− */
2566−
2567−static int
2568−yaml_parser_scan_tag_uri(yaml_parser_t *parser, int directive,
2569− yaml_char_t *head, yaml_mark_t start_mark, yaml_char_t **uri)
2570−{
2571− size_t length = head ? strlen((char *)head) : 0;
2572− yaml_string_t string = NULL_STRING;
2573−
2574− if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
2575−
2576− /* Resize the string to include the head. */
2577−
2578− while ((size_t)(string.end - string.start) <= length) {
2579− if (!yaml_string_extend(&string.start, &string.pointer, &string.end)) {
2580− parser->error = YAML_MEMORY_ERROR;
2581− goto error;
2582− }
2583− }
2584−
2585− /*
2586− * Copy the head if needed.
2587− *
2588− * Note that we don't copy the leading '!' character.
2589− */
2590−
2591− if (length > 1) {
2592− memcpy(string.start, head+1, length-1);
2593− string.pointer += length-1;
2594− }
2595−
2596− /* Scan the tag. */
2597−
2598− if (!CACHE(parser, 1)) goto error;
2599−
2600− /*
2601− * The set of characters that may appear in URI is as follows:
2602− *
2603− * '0'-'9', 'A'-'Z', 'a'-'z', '_', '-', ';', '/', '?', ':', '@', '&',
2604− * '=', '+', '$', ',', '.', '!', '~', '*', '\'', '(', ')', '[', ']',
2605− * '%'.
2606− */
2607−
2608− while (IS_ALPHA(parser->buffer) || CHECK(parser->buffer, ';')
2609− || CHECK(parser->buffer, '/') || CHECK(parser->buffer, '?')
2610− || CHECK(parser->buffer, ':') || CHECK(parser->buffer, '@')
2611− || CHECK(parser->buffer, '&') || CHECK(parser->buffer, '=')
2612− || CHECK(parser->buffer, '+') || CHECK(parser->buffer, '$')
2613− || CHECK(parser->buffer, ',') || CHECK(parser->buffer, '.')
2614− || CHECK(parser->buffer, '!') || CHECK(parser->buffer, '~')
2615− || CHECK(parser->buffer, '*') || CHECK(parser->buffer, '\'')
2616− || CHECK(parser->buffer, '(') || CHECK(parser->buffer, ')')
2617− || CHECK(parser->buffer, '[') || CHECK(parser->buffer, ']')
2618− || CHECK(parser->buffer, '%'))
2619− {
2620− /* Check if it is a URI-escape sequence. */
2621−
2622− if (CHECK(parser->buffer, '%')) {
2623− if (!STRING_EXTEND(parser, string))
2624− goto error;
2625−
2626− if (!yaml_parser_scan_uri_escapes(parser,
2627− directive, start_mark, &string)) goto error;
2628− }
2629− else {
2630− if (!READ(parser, string)) goto error;
2631− }
2632−
2633− length ++;
2634− if (!CACHE(parser, 1)) goto error;
2635− }
2636−
2637− /* Check if the tag is non-empty. */
2638−
2639− if (!length) {
2640− if (!STRING_EXTEND(parser, string))
2641− goto error;
2642−
2643− yaml_parser_set_scanner_error(parser, directive ?
2644− "while parsing a %TAG directive" : "while parsing a tag",
2645− start_mark, "did not find expected tag URI");
2646− goto error;
2647− }
2648−
2649− *uri = string.start;
2650−
2651− return 1;
2652−
2653−error:
2654− STRING_DEL(parser, string);
2655− return 0;
2656−}
2657−
2658−/*
2659− * Decode an URI-escape sequence corresponding to a single UTF-8 character.
2660− */
2661−
2662−static int
2663−yaml_parser_scan_uri_escapes(yaml_parser_t *parser, int directive,
2664− yaml_mark_t start_mark, yaml_string_t *string)
2665−{
2666− int width = 0;
2667−
2668− /* Decode the required number of characters. */
2669−
2670− do {
2671−
2672− unsigned char octet = 0;
2673−
2674− /* Check for a URI-escaped octet. */
2675−
2676− if (!CACHE(parser, 3)) return 0;
2677−
2678− if (!(CHECK(parser->buffer, '%')
2679− && IS_HEX_AT(parser->buffer, 1)
2680− && IS_HEX_AT(parser->buffer, 2))) {
2681− return yaml_parser_set_scanner_error(parser, directive ?
2682− "while parsing a %TAG directive" : "while parsing a tag",
2683− start_mark, "did not find URI escaped octet");
2684− }
2685−
2686− /* Get the octet. */
2687−
2688− octet = (AS_HEX_AT(parser->buffer, 1) << 4) + AS_HEX_AT(parser->buffer, 2);
2689−
2690− /* If it is the leading octet, determine the length of the UTF-8 sequence. */
2691−
2692− if (!width)
2693− {
2694− width = (octet & 0x80) == 0x00 ? 1 :
2695− (octet & 0xE0) == 0xC0 ? 2 :
2696− (octet & 0xF0) == 0xE0 ? 3 :
2697− (octet & 0xF8) == 0xF0 ? 4 : 0;
2698− if (!width) {
2699− return yaml_parser_set_scanner_error(parser, directive ?
2700− "while parsing a %TAG directive" : "while parsing a tag",
2701− start_mark, "found an incorrect leading UTF-8 octet");
2702− }
2703− }
2704− else
2705− {
2706− /* Check if the trailing octet is correct. */
2707−
2708− if ((octet & 0xC0) != 0x80) {
2709− return yaml_parser_set_scanner_error(parser, directive ?
2710− "while parsing a %TAG directive" : "while parsing a tag",
2711− start_mark, "found an incorrect trailing UTF-8 octet");
2712− }
2713− }
2714−
2715− /* Copy the octet and move the pointers. */
2716−
2717− *(string->pointer++) = octet;
2718− SKIP(parser);
2719− SKIP(parser);
2720− SKIP(parser);
2721−
2722− } while (--width);
2723−
2724− return 1;
2725−}
2726−
2727−/*
2728− * Scan a block scalar.
2729− */
2730−
2731−static int
2732−yaml_parser_scan_block_scalar(yaml_parser_t *parser, yaml_token_t *token,
2733− int literal)
2734−{
2735− yaml_mark_t start_mark;
2736− yaml_mark_t end_mark;
2737− yaml_string_t string = NULL_STRING;
2738− yaml_string_t leading_break = NULL_STRING;
2739− yaml_string_t trailing_breaks = NULL_STRING;
2740− int chomping = 0;
2741− int increment = 0;
2742− int indent = 0;
2743− int leading_blank = 0;
2744− int trailing_blank = 0;
2745−
2746− if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
2747− if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error;
2748− if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error;
2749−
2750− /* Eat the indicator '|' or '>'. */
2751−
2752− start_mark = parser->mark;
2753−
2754− SKIP(parser);
2755−
2756− /* Scan the additional block scalar indicators. */
2757−
2758− if (!CACHE(parser, 1)) goto error;
2759−
2760− /* Check for a chomping indicator. */
2761−
2762− if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-'))
2763− {
2764− /* Set the chomping method and eat the indicator. */
2765−
2766− chomping = CHECK(parser->buffer, '+') ? +1 : -1;
2767−
2768− SKIP(parser);
2769−
2770− /* Check for an indentation indicator. */
2771−
2772− if (!CACHE(parser, 1)) goto error;
2773−
2774− if (IS_DIGIT(parser->buffer))
2775− {
2776− /* Check that the indentation is greater than 0. */
2777−
2778− if (CHECK(parser->buffer, '0')) {
2779− yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
2780− start_mark, "found an indentation indicator equal to 0");
2781− goto error;
2782− }
2783−
2784− /* Get the indentation level and eat the indicator. */
2785−
2786− increment = AS_DIGIT(parser->buffer);
2787−
2788− SKIP(parser);
2789− }
2790− }
2791−
2792− /* Do the same as above, but in the opposite order. */
2793−
2794− else if (IS_DIGIT(parser->buffer))
2795− {
2796− if (CHECK(parser->buffer, '0')) {
2797− yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
2798− start_mark, "found an indentation indicator equal to 0");
2799− goto error;
2800− }
2801−
2802− increment = AS_DIGIT(parser->buffer);
2803−
2804− SKIP(parser);
2805−
2806− if (!CACHE(parser, 1)) goto error;
2807−
2808− if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-')) {
2809− chomping = CHECK(parser->buffer, '+') ? +1 : -1;
2810−
2811− SKIP(parser);
2812− }
2813− }
2814−
2815− /* Eat whitespaces and comments to the end of the line. */
2816−
2817− if (!CACHE(parser, 1)) goto error;
2818−
2819− while (IS_BLANK(parser->buffer)) {
2820− SKIP(parser);
2821− if (!CACHE(parser, 1)) goto error;
2822− }
2823−
2824− if (CHECK(parser->buffer, '#')) {
2825− while (!IS_BREAKZ(parser->buffer)) {
2826− SKIP(parser);
2827− if (!CACHE(parser, 1)) goto error;
2828− }
2829− }
2830−
2831− /* Check if we are at the end of the line. */
2832−
2833− if (!IS_BREAKZ(parser->buffer)) {
2834− yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
2835− start_mark, "did not find expected comment or line break");
2836− goto error;
2837− }
2838−
2839− /* Eat a line break. */
2840−
2841− if (IS_BREAK(parser->buffer)) {
2842− if (!CACHE(parser, 2)) goto error;
2843− SKIP_LINE(parser);
2844− }
2845−
2846− end_mark = parser->mark;
2847−
2848− /* Set the indentation level if it was specified. */
2849−
2850− if (increment) {
2851− indent = parser->indent >= 0 ? parser->indent+increment : increment;
2852− }
2853−
2854− /* Scan the leading line breaks and determine the indentation level if needed. */
2855−
2856− if (!yaml_parser_scan_block_scalar_breaks(parser, &indent, &trailing_breaks,
2857− start_mark, &end_mark)) goto error;
2858−
2859− /* Scan the block scalar content. */
2860−
2861− if (!CACHE(parser, 1)) goto error;
2862−
2863− while ((int)parser->mark.column == indent && !(IS_Z(parser->buffer)))
2864− {
2865− /*
2866− * We are at the beginning of a non-empty line.
2867− */
2868−
2869− /* Is it a trailing whitespace? */
2870−
2871− trailing_blank = IS_BLANK(parser->buffer);
2872−
2873− /* Check if we need to fold the leading line break. */
2874−
2875− if (!literal && (*leading_break.start == '\n')
2876− && !leading_blank && !trailing_blank)
2877− {
2878− /* Do we need to join the lines by space? */
2879−
2880− if (*trailing_breaks.start == '\0') {
2881− if (!STRING_EXTEND(parser, string)) goto error;
2882− *(string.pointer ++) = ' ';
2883− }
2884−
2885− CLEAR(parser, leading_break);
2886− }
2887− else {
2888− if (!JOIN(parser, string, leading_break)) goto error;
2889− CLEAR(parser, leading_break);
2890− }
2891−
2892− /* Append the remaining line breaks. */
2893−
2894− if (!JOIN(parser, string, trailing_breaks)) goto error;
2895− CLEAR(parser, trailing_breaks);
2896−
2897− /* Is it a leading whitespace? */
2898−
2899− leading_blank = IS_BLANK(parser->buffer);
2900−
2901− /* Consume the current line. */
2902−
2903− while (!IS_BREAKZ(parser->buffer)) {
2904− if (!READ(parser, string)) goto error;
2905− if (!CACHE(parser, 1)) goto error;
2906− }
2907−
2908− /* Consume the line break. */
2909−
2910− if (!CACHE(parser, 2)) goto error;
2911−
2912− if (!READ_LINE(parser, leading_break)) goto error;
2913−
2914− /* Eat the following indentation spaces and line breaks. */
2915−
2916− if (!yaml_parser_scan_block_scalar_breaks(parser,
2917− &indent, &trailing_breaks, start_mark, &end_mark)) goto error;
2918− }
2919−
2920− /* Chomp the tail. */
2921−
2922− if (chomping != -1) {
2923− if (!JOIN(parser, string, leading_break)) goto error;
2924− }
2925− if (chomping == 1) {
2926− if (!JOIN(parser, string, trailing_breaks)) goto error;
2927− }
2928−
2929− /* Create a token. */
2930−
2931− SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start,
2932− literal ? YAML_LITERAL_SCALAR_STYLE : YAML_FOLDED_SCALAR_STYLE,
2933− start_mark, end_mark);
2934−
2935− STRING_DEL(parser, leading_break);
2936− STRING_DEL(parser, trailing_breaks);
2937−
2938− return 1;
2939−
2940−error:
2941− STRING_DEL(parser, string);
2942− STRING_DEL(parser, leading_break);
2943− STRING_DEL(parser, trailing_breaks);
2944−
2945− return 0;
2946−}
2947−
2948−/*
2949− * Scan indentation spaces and line breaks for a block scalar. Determine the
2950− * indentation level if needed.
2951− */
2952−
2953−static int
2954−yaml_parser_scan_block_scalar_breaks(yaml_parser_t *parser,
2955− int *indent, yaml_string_t *breaks,
2956− yaml_mark_t start_mark, yaml_mark_t *end_mark)
2957−{
2958− int max_indent = 0;
2959−
2960− *end_mark = parser->mark;
2961−
2962− /* Eat the indentation spaces and line breaks. */
2963−
2964− while (1)
2965− {
2966− /* Eat the indentation spaces. */
2967−
2968− if (!CACHE(parser, 1)) return 0;
2969−
2970− while ((!*indent || (int)parser->mark.column < *indent)
2971− && IS_SPACE(parser->buffer)) {
2972− SKIP(parser);
2973− if (!CACHE(parser, 1)) return 0;
2974− }
2975−
2976− if ((int)parser->mark.column > max_indent)
2977− max_indent = (int)parser->mark.column;
2978−
2979− /* Check for a tab character messing the indentation. */
2980−
2981− if ((!*indent || (int)parser->mark.column < *indent)
2982− && IS_TAB(parser->buffer)) {
2983− return yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
2984− start_mark, "found a tab character where an indentation space is expected");
2985− }
2986−
2987− /* Have we found a non-empty line? */
2988−
2989− if (!IS_BREAK(parser->buffer)) break;
2990−
2991− /* Consume the line break. */
2992−
2993− if (!CACHE(parser, 2)) return 0;
2994− if (!READ_LINE(parser, *breaks)) return 0;
2995− *end_mark = parser->mark;
2996− }
2997−
2998− /* Determine the indentation level if needed. */
2999−
3000− if (!*indent) {
3001− *indent = max_indent;
3002− if (*indent < parser->indent + 1)
3003− *indent = parser->indent + 1;
3004− if (*indent < 1)
3005− *indent = 1;
3006− }
3007−
3008− return 1;
3009−}
3010−
3011−/*
3012− * Scan a quoted scalar.
3013− */
3014−
3015−static int
3016−yaml_parser_scan_flow_scalar(yaml_parser_t *parser, yaml_token_t *token,
3017− int single)
3018−{
3019− yaml_mark_t start_mark;
3020− yaml_mark_t end_mark;
3021− yaml_string_t string = NULL_STRING;
3022− yaml_string_t leading_break = NULL_STRING;
3023− yaml_string_t trailing_breaks = NULL_STRING;
3024− yaml_string_t whitespaces = NULL_STRING;
3025− int leading_blanks;
3026−
3027− if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
3028− if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error;
3029− if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error;
3030− if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_SIZE)) goto error;
3031−
3032− /* Eat the left quote. */
3033−
3034− start_mark = parser->mark;
3035−
3036− SKIP(parser);
3037−
3038− /* Consume the content of the quoted scalar. */
3039−
3040− while (1)
3041− {
3042− /* Check that there are no document indicators at the beginning of the line. */
3043−
3044− if (!CACHE(parser, 4)) goto error;
3045−
3046− if (parser->mark.column == 0 &&
3047− ((CHECK_AT(parser->buffer, '-', 0) &&
3048− CHECK_AT(parser->buffer, '-', 1) &&
3049− CHECK_AT(parser->buffer, '-', 2)) ||
3050− (CHECK_AT(parser->buffer, '.', 0) &&
3051− CHECK_AT(parser->buffer, '.', 1) &&
3052− CHECK_AT(parser->buffer, '.', 2))) &&
3053− IS_BLANKZ_AT(parser->buffer, 3))
3054− {
3055− yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar",
3056− start_mark, "found unexpected document indicator");
3057− goto error;
3058− }
3059−
3060− /* Check for EOF. */
3061−
3062− if (IS_Z(parser->buffer)) {
3063− yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar",
3064− start_mark, "found unexpected end of stream");
3065− goto error;
3066− }
3067−
3068− /* Consume non-blank characters. */
3069−
3070− if (!CACHE(parser, 2)) goto error;
3071−
3072− leading_blanks = 0;
3073−
3074− while (!IS_BLANKZ(parser->buffer))
3075− {
3076− /* Check for an escaped single quote. */
3077−
3078− if (single && CHECK_AT(parser->buffer, '\'', 0)
3079− && CHECK_AT(parser->buffer, '\'', 1))
3080− {
3081− if (!STRING_EXTEND(parser, string)) goto error;
3082− *(string.pointer++) = '\'';
3083− SKIP(parser);
3084− SKIP(parser);
3085− }
3086−
3087− /* Check for the right quote. */
3088−
3089− else if (CHECK(parser->buffer, single ? '\'' : '"'))
3090− {
3091− break;
3092− }
3093−
3094− /* Check for an escaped line break. */
3095−
3096− else if (!single && CHECK(parser->buffer, '\\')
3097− && IS_BREAK_AT(parser->buffer, 1))
3098− {
3099− if (!CACHE(parser, 3)) goto error;
3100− SKIP(parser);
3101− SKIP_LINE(parser);
3102− leading_blanks = 1;
3103− break;
3104− }
3105−
3106− /* Check for an escape sequence. */
3107−
3108− else if (!single && CHECK(parser->buffer, '\\'))
3109− {
3110− size_t code_length = 0;
3111−
3112− if (!STRING_EXTEND(parser, string)) goto error;
3113−
3114− /* Check the escape character. */
3115−
3116− switch (parser->buffer.pointer[1])
3117− {
3118− case '0':
3119− *(string.pointer++) = '\0';
3120− break;
3121−
3122− case 'a':
3123− *(string.pointer++) = '\x07';
3124− break;
3125−
3126− case 'b':
3127− *(string.pointer++) = '\x08';
3128− break;
3129−
3130− case 't':
3131− case '\t':
3132− *(string.pointer++) = '\x09';
3133− break;
3134−
3135− case 'n':
3136− *(string.pointer++) = '\x0A';
3137− break;
3138−
3139− case 'v':
3140− *(string.pointer++) = '\x0B';
3141− break;
3142−
3143− case 'f':
3144− *(string.pointer++) = '\x0C';
3145− break;
3146−
3147− case 'r':
3148− *(string.pointer++) = '\x0D';
3149− break;
3150−
3151− case 'e':
3152− *(string.pointer++) = '\x1B';
3153− break;
3154−
3155− case ' ':
3156− *(string.pointer++) = '\x20';
3157− break;
3158−
3159− case '"':
3160− *(string.pointer++) = '"';
3161− break;
3162−
3163− case '/':
3164− *(string.pointer++) = '/';
3165− break;
3166−
3167− case '\\':
3168− *(string.pointer++) = '\\';
3169− break;
3170−
3171− case 'N': /* NEL (#x85) */
3172− *(string.pointer++) = '\xC2';
3173− *(string.pointer++) = '\x85';
3174− break;
3175−
3176− case '_': /* #xA0 */
3177− *(string.pointer++) = '\xC2';
3178− *(string.pointer++) = '\xA0';
3179− break;
3180−
3181− case 'L': /* LS (#x2028) */
3182− *(string.pointer++) = '\xE2';
3183− *(string.pointer++) = '\x80';
3184− *(string.pointer++) = '\xA8';
3185− break;
3186−
3187− case 'P': /* PS (#x2029) */
3188− *(string.pointer++) = '\xE2';
3189− *(string.pointer++) = '\x80';
3190− *(string.pointer++) = '\xA9';
3191− break;
3192−
3193− case 'x':
3194− code_length = 2;
3195− break;
3196−
3197− case 'u':
3198− code_length = 4;
3199− break;
3200−
3201− case 'U':
3202− code_length = 8;
3203− break;
3204−
3205− default:
3206− yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar",
3207− start_mark, "found unknown escape character");
3208− goto error;
3209− }
3210−
3211− SKIP(parser);
3212− SKIP(parser);
3213−
3214− /* Consume an arbitrary escape code. */
3215−
3216− if (code_length)
3217− {
3218− unsigned int value = 0;
3219− size_t k;
3220−
3221− /* Scan the character value. */
3222−
3223− if (!CACHE(parser, code_length)) goto error;
3224−
3225− for (k = 0; k < code_length; k ++) {
3226− if (!IS_HEX_AT(parser->buffer, k)) {
3227− yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar",
3228− start_mark, "did not find expected hexdecimal number");
3229− goto error;
3230− }
3231− value = (value << 4) + AS_HEX_AT(parser->buffer, k);
3232− }
3233−
3234− /* Check the value and write the character. */
3235−
3236− if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF) {
3237− yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar",
3238− start_mark, "found invalid Unicode character escape code");
3239− goto error;
3240− }
3241−
3242− if (value <= 0x7F) {
3243− *(string.pointer++) = value;
3244− }
3245− else if (value <= 0x7FF) {
3246− *(string.pointer++) = 0xC0 + (value >> 6);
3247− *(string.pointer++) = 0x80 + (value & 0x3F);
3248− }
3249− else if (value <= 0xFFFF) {
3250− *(string.pointer++) = 0xE0 + (value >> 12);
3251− *(string.pointer++) = 0x80 + ((value >> 6) & 0x3F);
3252− *(string.pointer++) = 0x80 + (value & 0x3F);
3253− }
3254− else {
3255− *(string.pointer++) = 0xF0 + (value >> 18);
3256− *(string.pointer++) = 0x80 + ((value >> 12) & 0x3F);
3257− *(string.pointer++) = 0x80 + ((value >> 6) & 0x3F);
3258− *(string.pointer++) = 0x80 + (value & 0x3F);
3259− }
3260−
3261− /* Advance the pointer. */
3262−
3263− for (k = 0; k < code_length; k ++) {
3264− SKIP(parser);
3265− }
3266− }
3267− }
3268−
3269− else
3270− {
3271− /* It is a non-escaped non-blank character. */
3272−
3273− if (!READ(parser, string)) goto error;
3274− }
3275−
3276− if (!CACHE(parser, 2)) goto error;
3277− }
3278−
3279− /* Check if we are at the end of the scalar. */
3280−
3281− /* Fix for crash unitialized value crash
3282− * Credit for the bug and input is to OSS Fuzz
3283− * Credit for the fix to Alex Gaynor
3284− */
3285− if (!CACHE(parser, 1)) goto error;
3286− if (CHECK(parser->buffer, single ? '\'' : '"'))
3287− break;
3288−
3289− /* Consume blank characters. */
3290−
3291− if (!CACHE(parser, 1)) goto error;
3292−
3293− while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))
3294− {
3295− if (IS_BLANK(parser->buffer))
3296− {
3297− /* Consume a space or a tab character. */
3298−
3299− if (!leading_blanks) {
3300− if (!READ(parser, whitespaces)) goto error;
3301− }
3302− else {
3303− SKIP(parser);
3304− }
3305− }
3306− else
3307− {
3308− if (!CACHE(parser, 2)) goto error;
3309−
3310− /* Check if it is a first line break. */
3311−
3312− if (!leading_blanks)
3313− {
3314− CLEAR(parser, whitespaces);
3315− if (!READ_LINE(parser, leading_break)) goto error;
3316− leading_blanks = 1;
3317− }
3318− else
3319− {
3320− if (!READ_LINE(parser, trailing_breaks)) goto error;
3321− }
3322− }
3323− if (!CACHE(parser, 1)) goto error;
3324− }
3325−
3326− /* Join the whitespaces or fold line breaks. */
3327−
3328− if (leading_blanks)
3329− {
3330− /* Do we need to fold line breaks? */
3331−
3332− if (leading_break.start[0] == '\n') {
3333− if (trailing_breaks.start[0] == '\0') {
3334− if (!STRING_EXTEND(parser, string)) goto error;
3335− *(string.pointer++) = ' ';
3336− }
3337− else {
3338− if (!JOIN(parser, string, trailing_breaks)) goto error;
3339− CLEAR(parser, trailing_breaks);
3340− }
3341− CLEAR(parser, leading_break);
3342− }
3343− else {
3344− if (!JOIN(parser, string, leading_break)) goto error;
3345− if (!JOIN(parser, string, trailing_breaks)) goto error;
3346− CLEAR(parser, leading_break);
3347− CLEAR(parser, trailing_breaks);
3348− }
3349− }
3350− else
3351− {
3352− if (!JOIN(parser, string, whitespaces)) goto error;
3353− CLEAR(parser, whitespaces);
3354− }
3355− }
3356−
3357− /* Eat the right quote. */
3358−
3359− SKIP(parser);
3360−
3361− end_mark = parser->mark;
3362−
3363− /* Create a token. */
3364−
3365− SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start,
3366− single ? YAML_SINGLE_QUOTED_SCALAR_STYLE : YAML_DOUBLE_QUOTED_SCALAR_STYLE,
3367− start_mark, end_mark);
3368−
3369− STRING_DEL(parser, leading_break);
3370− STRING_DEL(parser, trailing_breaks);
3371− STRING_DEL(parser, whitespaces);
3372−
3373− return 1;
3374−
3375−error:
3376− STRING_DEL(parser, string);
3377− STRING_DEL(parser, leading_break);
3378− STRING_DEL(parser, trailing_breaks);
3379− STRING_DEL(parser, whitespaces);
3380−
3381− return 0;
3382−}
3383−
3384−/*
3385− * Scan a plain scalar.
3386− */
3387−
3388−static int
3389−yaml_parser_scan_plain_scalar(yaml_parser_t *parser, yaml_token_t *token)
3390−{
3391− yaml_mark_t start_mark;
3392− yaml_mark_t end_mark;
3393− yaml_string_t string = NULL_STRING;
3394− yaml_string_t leading_break = NULL_STRING;
3395− yaml_string_t trailing_breaks = NULL_STRING;
3396− yaml_string_t whitespaces = NULL_STRING;
3397− int leading_blanks = 0;
3398− int indent = parser->indent+1;
3399−
3400− if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
3401− if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error;
3402− if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error;
3403− if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_SIZE)) goto error;
3404−
3405− start_mark = end_mark = parser->mark;
3406−
3407− /* Consume the content of the plain scalar. */
3408−
3409− while (1)
3410− {
3411− /* Check for a document indicator. */
3412−
3413− if (!CACHE(parser, 4)) goto error;
3414−
3415− if (parser->mark.column == 0 &&
3416− ((CHECK_AT(parser->buffer, '-', 0) &&
3417− CHECK_AT(parser->buffer, '-', 1) &&
3418− CHECK_AT(parser->buffer, '-', 2)) ||
3419− (CHECK_AT(parser->buffer, '.', 0) &&
3420− CHECK_AT(parser->buffer, '.', 1) &&
3421− CHECK_AT(parser->buffer, '.', 2))) &&
3422− IS_BLANKZ_AT(parser->buffer, 3)) break;
3423−
3424− /* Check for a comment. */
3425−
3426− if (CHECK(parser->buffer, '#'))
3427− break;
3428−
3429− /* Consume non-blank characters. */
3430−
3431− while (!IS_BLANKZ(parser->buffer))
3432− {
3433− /* Check for "x:" + one of ',?[]{}' in the flow context. TODO: Fix the test "spec-08-13".
3434− * This is not completely according to the spec
3435− * See http://yaml.org/spec/1.1/#id907281 9.1.3. Plain
3436− */
3437−
3438− if (parser->flow_level
3439− && CHECK(parser->buffer, ':')
3440− && (
3441− CHECK_AT(parser->buffer, ',', 1)
3442− || CHECK_AT(parser->buffer, '?', 1)
3443− || CHECK_AT(parser->buffer, '[', 1)
3444− || CHECK_AT(parser->buffer, ']', 1)
3445− || CHECK_AT(parser->buffer, '{', 1)
3446− || CHECK_AT(parser->buffer, '}', 1)
3447− )
3448− ) {
3449− yaml_parser_set_scanner_error(parser, "while scanning a plain scalar",
3450− start_mark, "found unexpected ':'");
3451− goto error;
3452− }
3453−
3454− /* Check for indicators that may end a plain scalar. */
3455−
3456− if ((CHECK(parser->buffer, ':') && IS_BLANKZ_AT(parser->buffer, 1))
3457− || (parser->flow_level &&
3458− (CHECK(parser->buffer, ',')
3459− || CHECK(parser->buffer, '?') || CHECK(parser->buffer, '[')
3460− || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '{')
3461− || CHECK(parser->buffer, '}'))))
3462− break;
3463−
3464− /* Check if we need to join whitespaces and breaks. */
3465−
3466− if (leading_blanks || whitespaces.start != whitespaces.pointer)
3467− {
3468− if (leading_blanks)
3469− {
3470− /* Do we need to fold line breaks? */
3471−
3472− if (leading_break.start[0] == '\n') {
3473− if (trailing_breaks.start[0] == '\0') {
3474− if (!STRING_EXTEND(parser, string)) goto error;
3475− *(string.pointer++) = ' ';
3476− }
3477− else {
3478− if (!JOIN(parser, string, trailing_breaks)) goto error;
3479− CLEAR(parser, trailing_breaks);
3480− }
3481− CLEAR(parser, leading_break);
3482− }
3483− else {
3484− if (!JOIN(parser, string, leading_break)) goto error;
3485− if (!JOIN(parser, string, trailing_breaks)) goto error;
3486− CLEAR(parser, leading_break);
3487− CLEAR(parser, trailing_breaks);
3488− }
3489−
3490− leading_blanks = 0;
3491− }
3492− else
3493− {
3494− if (!JOIN(parser, string, whitespaces)) goto error;
3495− CLEAR(parser, whitespaces);
3496− }
3497− }
3498−
3499− /* Copy the character. */
3500−
3501− if (!READ(parser, string)) goto error;
3502−
3503− end_mark = parser->mark;
3504−
3505− if (!CACHE(parser, 2)) goto error;
3506− }
3507−
3508− /* Is it the end? */
3509−
3510− if (!(IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)))
3511− break;
3512−
3513− /* Consume blank characters. */
3514−
3515− if (!CACHE(parser, 1)) goto error;
3516−
3517− while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))
3518− {
3519− if (IS_BLANK(parser->buffer))
3520− {
3521− /* Check for tab character that abuse indentation. */
3522−
3523− if (leading_blanks && (int)parser->mark.column < indent
3524− && IS_TAB(parser->buffer)) {
3525− yaml_parser_set_scanner_error(parser, "while scanning a plain scalar",
3526− start_mark, "found a tab character that violate indentation");
3527− goto error;
3528− }
3529−
3530− /* Consume a space or a tab character. */
3531−
3532− if (!leading_blanks) {
3533− if (!READ(parser, whitespaces)) goto error;
3534− }
3535− else {
3536− SKIP(parser);
3537− }
3538− }
3539− else
3540− {
3541− if (!CACHE(parser, 2)) goto error;
3542−
3543− /* Check if it is a first line break. */
3544−
3545− if (!leading_blanks)
3546− {
3547− CLEAR(parser, whitespaces);
3548− if (!READ_LINE(parser, leading_break)) goto error;
3549− leading_blanks = 1;
3550− }
3551− else
3552− {
3553− if (!READ_LINE(parser, trailing_breaks)) goto error;
3554− }
3555− }
3556− if (!CACHE(parser, 1)) goto error;
3557− }
3558−
3559− /* Check indentation level. */
3560−
3561− if (!parser->flow_level && (int)parser->mark.column < indent)
3562− break;
3563− }
3564−
3565− /* Create a token. */
3566−
3567− SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start,
3568− YAML_PLAIN_SCALAR_STYLE, start_mark, end_mark);
3569−
3570− /* Note that we change the 'simple_key_allowed' flag. */
3571−
3572− if (leading_blanks) {
3573− parser->simple_key_allowed = 1;
3574− }
3575−
3576− STRING_DEL(parser, leading_break);
3577− STRING_DEL(parser, trailing_breaks);
3578− STRING_DEL(parser, whitespaces);
3579−
3580− return 1;
3581−
3582−error:
3583− STRING_DEL(parser, string);
3584− STRING_DEL(parser, leading_break);
3585− STRING_DEL(parser, trailing_breaks);
3586− STRING_DEL(parser, whitespaces);
3587−
3588− return 0;
3589−}
libyaml/libyaml_src/writer.cdeleted−141
@@ -1,141 +0,0 @@
1−
2−#include "yaml_private.h"
3−
4−/*
5− * Declarations.
6− */
7−
8−static int
9−yaml_emitter_set_writer_error(yaml_emitter_t *emitter, const char *problem);
10−
11−YAML_DECLARE(int)
12−yaml_emitter_flush(yaml_emitter_t *emitter);
13−
14−/*
15− * Set the writer error and return 0.
16− */
17−
18−static int
19−yaml_emitter_set_writer_error(yaml_emitter_t *emitter, const char *problem)
20−{
21− emitter->error = YAML_WRITER_ERROR;
22− emitter->problem = problem;
23−
24− return 0;
25−}
26−
27−/*
28− * Flush the output buffer.
29− */
30−
31−YAML_DECLARE(int)
32−yaml_emitter_flush(yaml_emitter_t *emitter)
33−{
34− int low, high;
35−
36− assert(emitter); /* Non-NULL emitter object is expected. */
37− assert(emitter->write_handler); /* Write handler must be set. */
38− assert(emitter->encoding); /* Output encoding must be set. */
39−
40− emitter->buffer.last = emitter->buffer.pointer;
41− emitter->buffer.pointer = emitter->buffer.start;
42−
43− /* Check if the buffer is empty. */
44−
45− if (emitter->buffer.start == emitter->buffer.last) {
46− return 1;
47− }
48−
49− /* If the output encoding is UTF-8, we don't need to recode the buffer. */
50−
51− if (emitter->encoding == YAML_UTF8_ENCODING)
52− {
53− if (emitter->write_handler(emitter->write_handler_data,
54− emitter->buffer.start,
55− emitter->buffer.last - emitter->buffer.start)) {
56− emitter->buffer.last = emitter->buffer.start;
57− emitter->buffer.pointer = emitter->buffer.start;
58− return 1;
59− }
60− else {
61− return yaml_emitter_set_writer_error(emitter, "write error");
62− }
63− }
64−
65− /* Recode the buffer into the raw buffer. */
66−
67− low = (emitter->encoding == YAML_UTF16LE_ENCODING ? 0 : 1);
68− high = (emitter->encoding == YAML_UTF16LE_ENCODING ? 1 : 0);
69−
70− while (emitter->buffer.pointer != emitter->buffer.last)
71− {
72− unsigned char octet;
73− unsigned int width;
74− unsigned int value;
75− size_t k;
76−
77− /*
78− * See the "reader.c" code for more details on UTF-8 encoding. Note
79− * that we assume that the buffer contains a valid UTF-8 sequence.
80− */
81−
82− /* Read the next UTF-8 character. */
83−
84− octet = emitter->buffer.pointer[0];
85−
86− width = (octet & 0x80) == 0x00 ? 1 :
87− (octet & 0xE0) == 0xC0 ? 2 :
88− (octet & 0xF0) == 0xE0 ? 3 :
89− (octet & 0xF8) == 0xF0 ? 4 : 0;
90−
91− value = (octet & 0x80) == 0x00 ? octet & 0x7F :
92− (octet & 0xE0) == 0xC0 ? octet & 0x1F :
93− (octet & 0xF0) == 0xE0 ? octet & 0x0F :
94− (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
95−
96− for (k = 1; k < width; k ++) {
97− octet = emitter->buffer.pointer[k];
98− value = (value << 6) + (octet & 0x3F);
99− }
100−
101− emitter->buffer.pointer += width;
102−
103− /* Write the character. */
104−
105− if (value < 0x10000)
106− {
107− emitter->raw_buffer.last[high] = value >> 8;
108− emitter->raw_buffer.last[low] = value & 0xFF;
109−
110− emitter->raw_buffer.last += 2;
111− }
112− else
113− {
114− /* Write the character using a surrogate pair (check "reader.c"). */
115−
116− value -= 0x10000;
117− emitter->raw_buffer.last[high] = 0xD8 + (value >> 18);
118− emitter->raw_buffer.last[low] = (value >> 10) & 0xFF;
119− emitter->raw_buffer.last[high+2] = 0xDC + ((value >> 8) & 0xFF);
120− emitter->raw_buffer.last[low+2] = value & 0xFF;
121−
122− emitter->raw_buffer.last += 4;
123− }
124− }
125−
126− /* Write the raw buffer. */
127−
128− if (emitter->write_handler(emitter->write_handler_data,
129− emitter->raw_buffer.start,
130− emitter->raw_buffer.last - emitter->raw_buffer.start)) {
131− emitter->buffer.last = emitter->buffer.start;
132− emitter->buffer.pointer = emitter->buffer.start;
133− emitter->raw_buffer.last = emitter->raw_buffer.start;
134− emitter->raw_buffer.pointer = emitter->raw_buffer.start;
135− return 1;
136− }
137− else {
138− return yaml_emitter_set_writer_error(emitter, "write error");
139− }
140−}
141−
libyaml/libyaml_src/yaml.hdeleted−1978
@@ -1,1978 +0,0 @@
1−/**
2− * @file yaml.h
3− * @brief Public interface for libyaml.
4− *
5− * Include the header file with the code:
6− * @code
7− * #include <yaml.h>
8− * @endcode
9− */
10−
11−#ifndef YAML_H
12−#define YAML_H
13−
14−#ifdef __cplusplus
15−extern "C" {
16−#endif
17−
18−#include <stdlib.h>
19−#include <stdio.h>
20−#include <string.h>
21−
22−/**
23− * @defgroup export Export Definitions
24− * @{
25− */
26−
27−/** The public API declaration. */
28−
29−#if defined(__MINGW32__)
30−# define YAML_DECLARE(type) type
31−#elif defined(WIN32)
32−# if defined(YAML_DECLARE_STATIC)
33−# define YAML_DECLARE(type) type
34−# elif defined(YAML_DECLARE_EXPORT)
35−# define YAML_DECLARE(type) __declspec(dllexport) type
36−# else
37−# define YAML_DECLARE(type) __declspec(dllimport) type
38−# endif
39−#else
40−# define YAML_DECLARE(type) type
41−#endif
42−
43−/** @} */
44−
45−/**
46− * @defgroup version Version Information
47− * @{
48− */
49−
50−/**
51− * Get the library version as a string.
52− *
53− * @returns The function returns the pointer to a static string of the form
54− * @c "X.Y.Z", where @c X is the major version number, @c Y is a minor version
55− * number, and @c Z is the patch version number.
56− */
57−
58−YAML_DECLARE(const char *)
59−yaml_get_version_string(void);
60−
61−/**
62− * Get the library version numbers.
63− *
64− * @param[out] major Major version number.
65− * @param[out] minor Minor version number.
66− * @param[out] patch Patch version number.
67− */
68−
69−YAML_DECLARE(void)
70−yaml_get_version(int *major, int *minor, int *patch);
71−
72−/** @} */
73−
74−/**
75− * @defgroup basic Basic Types
76− * @{
77− */
78−
79−/** The character type (UTF-8 octet). */
80−typedef unsigned char yaml_char_t;
81−
82−/** The version directive data. */
83−typedef struct yaml_version_directive_s {
84− /** The major version number. */
85− int major;
86− /** The minor version number. */
87− int minor;
88−} yaml_version_directive_t;
89−
90−/** The tag directive data. */
91−typedef struct yaml_tag_directive_s {
92− /** The tag handle. */
93− yaml_char_t *handle;
94− /** The tag prefix. */
95− yaml_char_t *prefix;
96−} yaml_tag_directive_t;
97−
98−/** The stream encoding. */
99−typedef enum yaml_encoding_e {
100− /** Let the parser choose the encoding. */
101− YAML_ANY_ENCODING,
102− /** The default UTF-8 encoding. */
103− YAML_UTF8_ENCODING,
104− /** The UTF-16-LE encoding with BOM. */
105− YAML_UTF16LE_ENCODING,
106− /** The UTF-16-BE encoding with BOM. */
107− YAML_UTF16BE_ENCODING
108−} yaml_encoding_t;
109−
110−/** Line break types. */
111−
112−typedef enum yaml_break_e {
113− /** Let the parser choose the break type. */
114− YAML_ANY_BREAK,
115− /** Use CR for line breaks (Mac style). */
116− YAML_CR_BREAK,
117− /** Use LN for line breaks (Unix style). */
118− YAML_LN_BREAK,
119− /** Use CR LN for line breaks (DOS style). */
120− YAML_CRLN_BREAK
121−} yaml_break_t;
122−
123−/** Many bad things could happen with the parser and emitter. */
124−typedef enum yaml_error_type_e {
125− /** No error is produced. */
126− YAML_NO_ERROR,
127−
128− /** Cannot allocate or reallocate a block of memory. */
129− YAML_MEMORY_ERROR,
130−
131− /** Cannot read or decode the input stream. */
132− YAML_READER_ERROR,
133− /** Cannot scan the input stream. */
134− YAML_SCANNER_ERROR,
135− /** Cannot parse the input stream. */
136− YAML_PARSER_ERROR,
137− /** Cannot compose a YAML document. */
138− YAML_COMPOSER_ERROR,
139−
140− /** Cannot write to the output stream. */
141− YAML_WRITER_ERROR,
142− /** Cannot emit a YAML stream. */
143− YAML_EMITTER_ERROR
144−} yaml_error_type_t;
145−
146−/** The pointer position. */
147−typedef struct yaml_mark_s {
148− /** The position index. */
149− size_t index;
150−
151− /** The position line. */
152− size_t line;
153−
154− /** The position column. */
155− size_t column;
156−} yaml_mark_t;
157−
158−/** @} */
159−
160−/**
161− * @defgroup styles Node Styles
162− * @{
163− */
164−
165−/** Scalar styles. */
166−typedef enum yaml_scalar_style_e {
167− /** Let the emitter choose the style. */
168− YAML_ANY_SCALAR_STYLE,
169−
170− /** The plain scalar style. */
171− YAML_PLAIN_SCALAR_STYLE,
172−
173− /** The single-quoted scalar style. */
174− YAML_SINGLE_QUOTED_SCALAR_STYLE,
175− /** The double-quoted scalar style. */
176− YAML_DOUBLE_QUOTED_SCALAR_STYLE,
177−
178− /** The literal scalar style. */
179− YAML_LITERAL_SCALAR_STYLE,
180− /** The folded scalar style. */
181− YAML_FOLDED_SCALAR_STYLE
182−} yaml_scalar_style_t;
183−
184−/** Sequence styles. */
185−typedef enum yaml_sequence_style_e {
186− /** Let the emitter choose the style. */
187− YAML_ANY_SEQUENCE_STYLE,
188−
189− /** The block sequence style. */
190− YAML_BLOCK_SEQUENCE_STYLE,
191− /** The flow sequence style. */
192− YAML_FLOW_SEQUENCE_STYLE
193−} yaml_sequence_style_t;
194−
195−/** Mapping styles. */
196−typedef enum yaml_mapping_style_e {
197− /** Let the emitter choose the style. */
198− YAML_ANY_MAPPING_STYLE,
199−
200− /** The block mapping style. */
201− YAML_BLOCK_MAPPING_STYLE,
202− /** The flow mapping style. */
203− YAML_FLOW_MAPPING_STYLE
204−/* YAML_FLOW_SET_MAPPING_STYLE */
205−} yaml_mapping_style_t;
206−
207−/** @} */
208−
209−/**
210− * @defgroup tokens Tokens
211− * @{
212− */
213−
214−/** Token types. */
215−typedef enum yaml_token_type_e {
216− /** An empty token. */
217− YAML_NO_TOKEN,
218−
219− /** A STREAM-START token. */
220− YAML_STREAM_START_TOKEN,
221− /** A STREAM-END token. */
222− YAML_STREAM_END_TOKEN,
223−
224− /** A VERSION-DIRECTIVE token. */
225− YAML_VERSION_DIRECTIVE_TOKEN,
226− /** A TAG-DIRECTIVE token. */
227− YAML_TAG_DIRECTIVE_TOKEN,
228− /** A DOCUMENT-START token. */
229− YAML_DOCUMENT_START_TOKEN,
230− /** A DOCUMENT-END token. */
231− YAML_DOCUMENT_END_TOKEN,
232−
233− /** A BLOCK-SEQUENCE-START token. */
234− YAML_BLOCK_SEQUENCE_START_TOKEN,
235− /** A BLOCK-MAPPING-START token. */
236− YAML_BLOCK_MAPPING_START_TOKEN,
237− /** A BLOCK-END token. */
238− YAML_BLOCK_END_TOKEN,
239−
240− /** A FLOW-SEQUENCE-START token. */
241− YAML_FLOW_SEQUENCE_START_TOKEN,
242− /** A FLOW-SEQUENCE-END token. */
243− YAML_FLOW_SEQUENCE_END_TOKEN,
244− /** A FLOW-MAPPING-START token. */
245− YAML_FLOW_MAPPING_START_TOKEN,
246− /** A FLOW-MAPPING-END token. */
247− YAML_FLOW_MAPPING_END_TOKEN,
248−
249− /** A BLOCK-ENTRY token. */
250− YAML_BLOCK_ENTRY_TOKEN,
251− /** A FLOW-ENTRY token. */
252− YAML_FLOW_ENTRY_TOKEN,
253− /** A KEY token. */
254− YAML_KEY_TOKEN,
255− /** A VALUE token. */
256− YAML_VALUE_TOKEN,
257−
258− /** An ALIAS token. */
259− YAML_ALIAS_TOKEN,
260− /** An ANCHOR token. */
261− YAML_ANCHOR_TOKEN,
262− /** A TAG token. */
263− YAML_TAG_TOKEN,
264− /** A SCALAR token. */
265− YAML_SCALAR_TOKEN
266−} yaml_token_type_t;
267−
268−/** The token structure. */
269−typedef struct yaml_token_s {
270−
271− /** The token type. */
272− yaml_token_type_t type;
273−
274− /** The token data. */
275− union {
276−
277− /** The stream start (for @c YAML_STREAM_START_TOKEN). */
278− struct {
279− /** The stream encoding. */
280− yaml_encoding_t encoding;
281− } stream_start;
282−
283− /** The alias (for @c YAML_ALIAS_TOKEN). */
284− struct {
285− /** The alias value. */
286− yaml_char_t *value;
287− } alias;
288−
289− /** The anchor (for @c YAML_ANCHOR_TOKEN). */
290− struct {
291− /** The anchor value. */
292− yaml_char_t *value;
293− } anchor;
294−
295− /** The tag (for @c YAML_TAG_TOKEN). */
296− struct {
297− /** The tag handle. */
298− yaml_char_t *handle;
299− /** The tag suffix. */
300− yaml_char_t *suffix;
301− } tag;
302−
303− /** The scalar value (for @c YAML_SCALAR_TOKEN). */
304− struct {
305− /** The scalar value. */
306− yaml_char_t *value;
307− /** The length of the scalar value. */
308− size_t length;
309− /** The scalar style. */
310− yaml_scalar_style_t style;
311− } scalar;
312−
313− /** The version directive (for @c YAML_VERSION_DIRECTIVE_TOKEN). */
314− struct {
315− /** The major version number. */
316− int major;
317− /** The minor version number. */
318− int minor;
319− } version_directive;
320−
321− /** The tag directive (for @c YAML_TAG_DIRECTIVE_TOKEN). */
322− struct {
323− /** The tag handle. */
324− yaml_char_t *handle;
325− /** The tag prefix. */
326− yaml_char_t *prefix;
327− } tag_directive;
328−
329− } data;
330−
331− /** The beginning of the token. */
332− yaml_mark_t start_mark;
333− /** The end of the token. */
334− yaml_mark_t end_mark;
335−
336−} yaml_token_t;
337−
338−/**
339− * Free any memory allocated for a token object.
340− *
341− * @param[in,out] token A token object.
342− */
343−
344−YAML_DECLARE(void)
345−yaml_token_delete(yaml_token_t *token);
346−
347−/** @} */
348−
349−/**
350− * @defgroup events Events
351− * @{
352− */
353−
354−/** Event types. */
355−typedef enum yaml_event_type_e {
356− /** An empty event. */
357− YAML_NO_EVENT,
358−
359− /** A STREAM-START event. */
360− YAML_STREAM_START_EVENT,
361− /** A STREAM-END event. */
362− YAML_STREAM_END_EVENT,
363−
364− /** A DOCUMENT-START event. */
365− YAML_DOCUMENT_START_EVENT,
366− /** A DOCUMENT-END event. */
367− YAML_DOCUMENT_END_EVENT,
368−
369− /** An ALIAS event. */
370− YAML_ALIAS_EVENT,
371− /** A SCALAR event. */
372− YAML_SCALAR_EVENT,
373−
374− /** A SEQUENCE-START event. */
375− YAML_SEQUENCE_START_EVENT,
376− /** A SEQUENCE-END event. */
377− YAML_SEQUENCE_END_EVENT,
378−
379− /** A MAPPING-START event. */
380− YAML_MAPPING_START_EVENT,
381− /** A MAPPING-END event. */
382− YAML_MAPPING_END_EVENT
383−} yaml_event_type_t;
384−
385−/** The event structure. */
386−typedef struct yaml_event_s {
387−
388− /** The event type. */
389− yaml_event_type_t type;
390−
391− /** The event data. */
392− union {
393−
394− /** The stream parameters (for @c YAML_STREAM_START_EVENT). */
395− struct {
396− /** The document encoding. */
397− yaml_encoding_t encoding;
398− } stream_start;
399−
400− /** The document parameters (for @c YAML_DOCUMENT_START_EVENT). */
401− struct {
402− /** The version directive. */
403− yaml_version_directive_t *version_directive;
404−
405− /** The list of tag directives. */
406− struct {
407− /** The beginning of the tag directives list. */
408− yaml_tag_directive_t *start;
409− /** The end of the tag directives list. */
410− yaml_tag_directive_t *end;
411− } tag_directives;
412−
413− /** Is the document indicator implicit? */
414− int implicit;
415− } document_start;
416−
417− /** The document end parameters (for @c YAML_DOCUMENT_END_EVENT). */
418− struct {
419− /** Is the document end indicator implicit? */
420− int implicit;
421− } document_end;
422−
423− /** The alias parameters (for @c YAML_ALIAS_EVENT). */
424− struct {
425− /** The anchor. */
426− yaml_char_t *anchor;
427− } alias;
428−
429− /** The scalar parameters (for @c YAML_SCALAR_EVENT). */
430− struct {
431− /** The anchor. */
432− yaml_char_t *anchor;
433− /** The tag. */
434− yaml_char_t *tag;
435− /** The scalar value. */
436− yaml_char_t *value;
437− /** The length of the scalar value. */
438− size_t length;
439− /** Is the tag optional for the plain style? */
440− int plain_implicit;
441− /** Is the tag optional for any non-plain style? */
442− int quoted_implicit;
443− /** The scalar style. */
444− yaml_scalar_style_t style;
445− } scalar;
446−
447− /** The sequence parameters (for @c YAML_SEQUENCE_START_EVENT). */
448− struct {
449− /** The anchor. */
450− yaml_char_t *anchor;
451− /** The tag. */
452− yaml_char_t *tag;
453− /** Is the tag optional? */
454− int implicit;
455− /** The sequence style. */
456− yaml_sequence_style_t style;
457− } sequence_start;
458−
459− /** The mapping parameters (for @c YAML_MAPPING_START_EVENT). */
460− struct {
461− /** The anchor. */
462− yaml_char_t *anchor;
463− /** The tag. */
464− yaml_char_t *tag;
465− /** Is the tag optional? */
466− int implicit;
467− /** The mapping style. */
468− yaml_mapping_style_t style;
469− } mapping_start;
470−
471− } data;
472−
473− /** The beginning of the event. */
474− yaml_mark_t start_mark;
475− /** The end of the event. */
476− yaml_mark_t end_mark;
477−
478−} yaml_event_t;
479−
480−/**
481− * Create the STREAM-START event.
482− *
483− * @param[out] event An empty event object.
484− * @param[in] encoding The stream encoding.
485− *
486− * @returns @c 1 if the function succeeded, @c 0 on error.
487− */
488−
489−YAML_DECLARE(int)
490−yaml_stream_start_event_initialize(yaml_event_t *event,
491− yaml_encoding_t encoding);
492−
493−/**
494− * Create the STREAM-END event.
495− *
496− * @param[out] event An empty event object.
497− *
498− * @returns @c 1 if the function succeeded, @c 0 on error.
499− */
500−
501−YAML_DECLARE(int)
502−yaml_stream_end_event_initialize(yaml_event_t *event);
503−
504−/**
505− * Create the DOCUMENT-START event.
506− *
507− * The @a implicit argument is considered as a stylistic parameter and may be
508− * ignored by the emitter.
509− *
510− * @param[out] event An empty event object.
511− * @param[in] version_directive The %YAML directive value or
512− * @c NULL.
513− * @param[in] tag_directives_start The beginning of the %TAG
514− * directives list.
515− * @param[in] tag_directives_end The end of the %TAG directives
516− * list.
517− * @param[in] implicit If the document start indicator is
518− * implicit.
519− *
520− * @returns @c 1 if the function succeeded, @c 0 on error.
521− */
522−
523−YAML_DECLARE(int)
524−yaml_document_start_event_initialize(yaml_event_t *event,
525− yaml_version_directive_t *version_directive,
526− yaml_tag_directive_t *tag_directives_start,
527− yaml_tag_directive_t *tag_directives_end,
528− int implicit);
529−
530−/**
531− * Create the DOCUMENT-END event.
532− *
533− * The @a implicit argument is considered as a stylistic parameter and may be
534− * ignored by the emitter.
535− *
536− * @param[out] event An empty event object.
537− * @param[in] implicit If the document end indicator is implicit.
538− *
539− * @returns @c 1 if the function succeeded, @c 0 on error.
540− */
541−
542−YAML_DECLARE(int)
543−yaml_document_end_event_initialize(yaml_event_t *event, int implicit);
544−
545−/**
546− * Create an ALIAS event.
547− *
548− * @param[out] event An empty event object.
549− * @param[in] anchor The anchor value.
550− *
551− * @returns @c 1 if the function succeeded, @c 0 on error.
552− */
553−
554−YAML_DECLARE(int)
555−yaml_alias_event_initialize(yaml_event_t *event, yaml_char_t *anchor);
556−
557−/**
558− * Create a SCALAR event.
559− *
560− * The @a style argument may be ignored by the emitter.
561− *
562− * Either the @a tag attribute or one of the @a plain_implicit and
563− * @a quoted_implicit flags must be set.
564− *
565− * @param[out] event An empty event object.
566− * @param[in] anchor The scalar anchor or @c NULL.
567− * @param[in] tag The scalar tag or @c NULL.
568− * @param[in] value The scalar value.
569− * @param[in] length The length of the scalar value.
570− * @param[in] plain_implicit If the tag may be omitted for the plain
571− * style.
572− * @param[in] quoted_implicit If the tag may be omitted for any
573− * non-plain style.
574− * @param[in] style The scalar style.
575− *
576− * @returns @c 1 if the function succeeded, @c 0 on error.
577− */
578−
579−YAML_DECLARE(int)
580−yaml_scalar_event_initialize(yaml_event_t *event,
581− yaml_char_t *anchor, yaml_char_t *tag,
582− yaml_char_t *value, int length,
583− int plain_implicit, int quoted_implicit,
584− yaml_scalar_style_t style);
585−
586−/**
587− * Create a SEQUENCE-START event.
588− *
589− * The @a style argument may be ignored by the emitter.
590− *
591− * Either the @a tag attribute or the @a implicit flag must be set.
592− *
593− * @param[out] event An empty event object.
594− * @param[in] anchor The sequence anchor or @c NULL.
595− * @param[in] tag The sequence tag or @c NULL.
596− * @param[in] implicit If the tag may be omitted.
597− * @param[in] style The sequence style.
598− *
599− * @returns @c 1 if the function succeeded, @c 0 on error.
600− */
601−
602−YAML_DECLARE(int)
603−yaml_sequence_start_event_initialize(yaml_event_t *event,
604− yaml_char_t *anchor, yaml_char_t *tag, int implicit,
605− yaml_sequence_style_t style);
606−
607−/**
608− * Create a SEQUENCE-END event.
609− *
610− * @param[out] event An empty event object.
611− *
612− * @returns @c 1 if the function succeeded, @c 0 on error.
613− */
614−
615−YAML_DECLARE(int)
616−yaml_sequence_end_event_initialize(yaml_event_t *event);
617−
618−/**
619− * Create a MAPPING-START event.
620− *
621− * The @a style argument may be ignored by the emitter.
622− *
623− * Either the @a tag attribute or the @a implicit flag must be set.
624− *
625− * @param[out] event An empty event object.
626− * @param[in] anchor The mapping anchor or @c NULL.
627− * @param[in] tag The mapping tag or @c NULL.
628− * @param[in] implicit If the tag may be omitted.
629− * @param[in] style The mapping style.
630− *
631− * @returns @c 1 if the function succeeded, @c 0 on error.
632− */
633−
634−YAML_DECLARE(int)
635−yaml_mapping_start_event_initialize(yaml_event_t *event,
636− yaml_char_t *anchor, yaml_char_t *tag, int implicit,
637− yaml_mapping_style_t style);
638−
639−/**
640− * Create a MAPPING-END event.
641− *
642− * @param[out] event An empty event object.
643− *
644− * @returns @c 1 if the function succeeded, @c 0 on error.
645− */
646−
647−YAML_DECLARE(int)
648−yaml_mapping_end_event_initialize(yaml_event_t *event);
649−
650−/**
651− * Free any memory allocated for an event object.
652− *
653− * @param[in,out] event An event object.
654− */
655−
656−YAML_DECLARE(void)
657−yaml_event_delete(yaml_event_t *event);
658−
659−/** @} */
660−
661−/**
662− * @defgroup nodes Nodes
663− * @{
664− */
665−
666−/** The tag @c !!null with the only possible value: @c null. */
667−#define YAML_NULL_TAG "tag:yaml.org,2002:null"
668−/** The tag @c !!bool with the values: @c true and @c false. */
669−#define YAML_BOOL_TAG "tag:yaml.org,2002:bool"
670−/** The tag @c !!str for string values. */
671−#define YAML_STR_TAG "tag:yaml.org,2002:str"
672−/** The tag @c !!int for integer values. */
673−#define YAML_INT_TAG "tag:yaml.org,2002:int"
674−/** The tag @c !!float for float values. */
675−#define YAML_FLOAT_TAG "tag:yaml.org,2002:float"
676−/** The tag @c !!timestamp for date and time values. */
677−#define YAML_TIMESTAMP_TAG "tag:yaml.org,2002:timestamp"
678−
679−/** The tag @c !!seq is used to denote sequences. */
680−#define YAML_SEQ_TAG "tag:yaml.org,2002:seq"
681−/** The tag @c !!map is used to denote mapping. */
682−#define YAML_MAP_TAG "tag:yaml.org,2002:map"
683−
684−/** The default scalar tag is @c !!str. */
685−#define YAML_DEFAULT_SCALAR_TAG YAML_STR_TAG
686−/** The default sequence tag is @c !!seq. */
687−#define YAML_DEFAULT_SEQUENCE_TAG YAML_SEQ_TAG
688−/** The default mapping tag is @c !!map. */
689−#define YAML_DEFAULT_MAPPING_TAG YAML_MAP_TAG
690−
691−/** Node types. */
692−typedef enum yaml_node_type_e {
693− /** An empty node. */
694− YAML_NO_NODE,
695−
696− /** A scalar node. */
697− YAML_SCALAR_NODE,
698− /** A sequence node. */
699− YAML_SEQUENCE_NODE,
700− /** A mapping node. */
701− YAML_MAPPING_NODE
702−} yaml_node_type_t;
703−
704−/** The forward definition of a document node structure. */
705−typedef struct yaml_node_s yaml_node_t;
706−
707−/** An element of a sequence node. */
708−typedef int yaml_node_item_t;
709−
710−/** An element of a mapping node. */
711−typedef struct yaml_node_pair_s {
712− /** The key of the element. */
713− int key;
714− /** The value of the element. */
715− int value;
716−} yaml_node_pair_t;
717−
718−/** The node structure. */
719−struct yaml_node_s {
720−
721− /** The node type. */
722− yaml_node_type_t type;
723−
724− /** The node tag. */
725− yaml_char_t *tag;
726−
727− /** The node data. */
728− union {
729−
730− /** The scalar parameters (for @c YAML_SCALAR_NODE). */
731− struct {
732− /** The scalar value. */
733− yaml_char_t *value;
734− /** The length of the scalar value. */
735− size_t length;
736− /** The scalar style. */
737− yaml_scalar_style_t style;
738− } scalar;
739−
740− /** The sequence parameters (for @c YAML_SEQUENCE_NODE). */
741− struct {
742− /** The stack of sequence items. */
743− struct {
744− /** The beginning of the stack. */
745− yaml_node_item_t *start;
746− /** The end of the stack. */
747− yaml_node_item_t *end;
748− /** The top of the stack. */
749− yaml_node_item_t *top;
750− } items;
751− /** The sequence style. */
752− yaml_sequence_style_t style;
753− } sequence;
754−
755− /** The mapping parameters (for @c YAML_MAPPING_NODE). */
756− struct {
757− /** The stack of mapping pairs (key, value). */
758− struct {
759− /** The beginning of the stack. */
760− yaml_node_pair_t *start;
761− /** The end of the stack. */
762− yaml_node_pair_t *end;
763− /** The top of the stack. */
764− yaml_node_pair_t *top;
765− } pairs;
766− /** The mapping style. */
767− yaml_mapping_style_t style;
768− } mapping;
769−
770− } data;
771−
772− /** The beginning of the node. */
773− yaml_mark_t start_mark;
774− /** The end of the node. */
775− yaml_mark_t end_mark;
776−
777−};
778−
779−/** The document structure. */
780−typedef struct yaml_document_s {
781−
782− /** The document nodes. */
783− struct {
784− /** The beginning of the stack. */
785− yaml_node_t *start;
786− /** The end of the stack. */
787− yaml_node_t *end;
788− /** The top of the stack. */
789− yaml_node_t *top;
790− } nodes;
791−
792− /** The version directive. */
793− yaml_version_directive_t *version_directive;
794−
795− /** The list of tag directives. */
796− struct {
797− /** The beginning of the tag directives list. */
798− yaml_tag_directive_t *start;
799− /** The end of the tag directives list. */
800− yaml_tag_directive_t *end;
801− } tag_directives;
802−
803− /** Is the document start indicator implicit? */
804− int start_implicit;
805− /** Is the document end indicator implicit? */
806− int end_implicit;
807−
808− /** The beginning of the document. */
809− yaml_mark_t start_mark;
810− /** The end of the document. */
811− yaml_mark_t end_mark;
812−
813−} yaml_document_t;
814−
815−/**
816− * Create a YAML document.
817− *
818− * @param[out] document An empty document object.
819− * @param[in] version_directive The %YAML directive value or
820− * @c NULL.
821− * @param[in] tag_directives_start The beginning of the %TAG
822− * directives list.
823− * @param[in] tag_directives_end The end of the %TAG directives
824− * list.
825− * @param[in] start_implicit If the document start indicator is
826− * implicit.
827− * @param[in] end_implicit If the document end indicator is
828− * implicit.
829− *
830− * @returns @c 1 if the function succeeded, @c 0 on error.
831− */
832−
833−YAML_DECLARE(int)
834−yaml_document_initialize(yaml_document_t *document,
835− yaml_version_directive_t *version_directive,
836− yaml_tag_directive_t *tag_directives_start,
837− yaml_tag_directive_t *tag_directives_end,
838− int start_implicit, int end_implicit);
839−
840−/**
841− * Delete a YAML document and all its nodes.
842− *
843− * @param[in,out] document A document object.
844− */
845−
846−YAML_DECLARE(void)
847−yaml_document_delete(yaml_document_t *document);
848−
849−/**
850− * Get a node of a YAML document.
851− *
852− * The pointer returned by this function is valid until any of the functions
853− * modifying the documents are called.
854− *
855− * @param[in] document A document object.
856− * @param[in] index The node id.
857− *
858− * @returns the node objct or @c NULL if @c node_id is out of range.
859− */
860−
861−YAML_DECLARE(yaml_node_t *)
862−yaml_document_get_node(yaml_document_t *document, int index);
863−
864−/**
865− * Get the root of a YAML document node.
866− *
867− * The root object is the first object added to the document.
868− *
869− * The pointer returned by this function is valid until any of the functions
870− * modifying the documents are called.
871− *
872− * An empty document produced by the parser signifies the end of a YAML
873− * stream.
874− *
875− * @param[in] document A document object.
876− *
877− * @returns the node object or @c NULL if the document is empty.
878− */
879−
880−YAML_DECLARE(yaml_node_t *)
881−yaml_document_get_root_node(yaml_document_t *document);
882−
883−/**
884− * Create a SCALAR node and attach it to the document.
885− *
886− * The @a style argument may be ignored by the emitter.
887− *
888− * @param[in,out] document A document object.
889− * @param[in] tag The scalar tag.
890− * @param[in] value The scalar value.
891− * @param[in] length The length of the scalar value.
892− * @param[in] style The scalar style.
893− *
894− * @returns the node id or @c 0 on error.
895− */
896−
897−YAML_DECLARE(int)
898−yaml_document_add_scalar(yaml_document_t *document,
899− yaml_char_t *tag, yaml_char_t *value, int length,
900− yaml_scalar_style_t style);
901−
902−/**
903− * Create a SEQUENCE node and attach it to the document.
904− *
905− * The @a style argument may be ignored by the emitter.
906− *
907− * @param[in,out] document A document object.
908− * @param[in] tag The sequence tag.
909− * @param[in] style The sequence style.
910− *
911− * @returns the node id or @c 0 on error.
912− */
913−
914−YAML_DECLARE(int)
915−yaml_document_add_sequence(yaml_document_t *document,
916− yaml_char_t *tag, yaml_sequence_style_t style);
917−
918−/**
919− * Create a MAPPING node and attach it to the document.
920− *
921− * The @a style argument may be ignored by the emitter.
922− *
923− * @param[in,out] document A document object.
924− * @param[in] tag The sequence tag.
925− * @param[in] style The sequence style.
926− *
927− * @returns the node id or @c 0 on error.
928− */
929−
930−YAML_DECLARE(int)
931−yaml_document_add_mapping(yaml_document_t *document,
932− yaml_char_t *tag, yaml_mapping_style_t style);
933−
934−/**
935− * Add an item to a SEQUENCE node.
936− *
937− * @param[in,out] document A document object.
938− * @param[in] sequence The sequence node id.
939− * @param[in] item The item node id.
940−*
941− * @returns @c 1 if the function succeeded, @c 0 on error.
942− */
943−
944−YAML_DECLARE(int)
945−yaml_document_append_sequence_item(yaml_document_t *document,
946− int sequence, int item);
947−
948−/**
949− * Add a pair of a key and a value to a MAPPING node.
950− *
951− * @param[in,out] document A document object.
952− * @param[in] mapping The mapping node id.
953− * @param[in] key The key node id.
954− * @param[in] value The value node id.
955−*
956− * @returns @c 1 if the function succeeded, @c 0 on error.
957− */
958−
959−YAML_DECLARE(int)
960−yaml_document_append_mapping_pair(yaml_document_t *document,
961− int mapping, int key, int value);
962−
963−/** @} */
964−
965−/**
966− * @defgroup parser Parser Definitions
967− * @{
968− */
969−
970−/**
971− * The prototype of a read handler.
972− *
973− * The read handler is called when the parser needs to read more bytes from the
974− * source. The handler should write not more than @a size bytes to the @a
975− * buffer. The number of written bytes should be set to the @a length variable.
976− *
977− * @param[in,out] data A pointer to an application data specified by
978− * yaml_parser_set_input().
979− * @param[out] buffer The buffer to write the data from the source.
980− * @param[in] size The size of the buffer.
981− * @param[out] size_read The actual number of bytes read from the source.
982− *
983− * @returns On success, the handler should return @c 1. If the handler failed,
984− * the returned value should be @c 0. On EOF, the handler should set the
985− * @a size_read to @c 0 and return @c 1.
986− */
987−
988−typedef int yaml_read_handler_t(void *data, unsigned char *buffer, size_t size,
989− size_t *size_read);
990−
991−/**
992− * This structure holds information about a potential simple key.
993− */
994−
995−typedef struct yaml_simple_key_s {
996− /** Is a simple key possible? */
997− int possible;
998−
999− /** Is a simple key required? */
1000− int required;
1001−
1002− /** The number of the token. */
1003− size_t token_number;
1004−
1005− /** The position mark. */
1006− yaml_mark_t mark;
1007−} yaml_simple_key_t;
1008−
1009−/**
1010− * The states of the parser.
1011− */
1012−typedef enum yaml_parser_state_e {
1013− /** Expect STREAM-START. */
1014− YAML_PARSE_STREAM_START_STATE,
1015− /** Expect the beginning of an implicit document. */
1016− YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE,
1017− /** Expect DOCUMENT-START. */
1018− YAML_PARSE_DOCUMENT_START_STATE,
1019− /** Expect the content of a document. */
1020− YAML_PARSE_DOCUMENT_CONTENT_STATE,
1021− /** Expect DOCUMENT-END. */
1022− YAML_PARSE_DOCUMENT_END_STATE,
1023− /** Expect a block node. */
1024− YAML_PARSE_BLOCK_NODE_STATE,
1025− /** Expect a block node or indentless sequence. */
1026− YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE,
1027− /** Expect a flow node. */
1028− YAML_PARSE_FLOW_NODE_STATE,
1029− /** Expect the first entry of a block sequence. */
1030− YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE,
1031− /** Expect an entry of a block sequence. */
1032− YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE,
1033− /** Expect an entry of an indentless sequence. */
1034− YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE,
1035− /** Expect the first key of a block mapping. */
1036− YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE,
1037− /** Expect a block mapping key. */
1038− YAML_PARSE_BLOCK_MAPPING_KEY_STATE,
1039− /** Expect a block mapping value. */
1040− YAML_PARSE_BLOCK_MAPPING_VALUE_STATE,
1041− /** Expect the first entry of a flow sequence. */
1042− YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE,
1043− /** Expect an entry of a flow sequence. */
1044− YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE,
1045− /** Expect a key of an ordered mapping. */
1046− YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE,
1047− /** Expect a value of an ordered mapping. */
1048− YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE,
1049− /** Expect the and of an ordered mapping entry. */
1050− YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE,
1051− /** Expect the first key of a flow mapping. */
1052− YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE,
1053− /** Expect a key of a flow mapping. */
1054− YAML_PARSE_FLOW_MAPPING_KEY_STATE,
1055− /** Expect a value of a flow mapping. */
1056− YAML_PARSE_FLOW_MAPPING_VALUE_STATE,
1057− /** Expect an empty value of a flow mapping. */
1058− YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE,
1059− /** Expect nothing. */
1060− YAML_PARSE_END_STATE
1061−} yaml_parser_state_t;
1062−
1063−/**
1064− * This structure holds aliases data.
1065− */
1066−
1067−typedef struct yaml_alias_data_s {
1068− /** The anchor. */
1069− yaml_char_t *anchor;
1070− /** The node id. */
1071− int index;
1072− /** The anchor mark. */
1073− yaml_mark_t mark;
1074−} yaml_alias_data_t;
1075−
1076−/**
1077− * The parser structure.
1078− *
1079− * All members are internal. Manage the structure using the @c yaml_parser_
1080− * family of functions.
1081− */
1082−
1083−typedef struct yaml_parser_s {
1084−
1085− /**
1086− * @name Error handling
1087− * @{
1088− */
1089−
1090− /** Error type. */
1091− yaml_error_type_t error;
1092− /** Error description. */
1093− const char *problem;
1094− /** The byte about which the problem occured. */
1095− size_t problem_offset;
1096− /** The problematic value (@c -1 is none). */
1097− int problem_value;
1098− /** The problem position. */
1099− yaml_mark_t problem_mark;
1100− /** The error context. */
1101− const char *context;
1102− /** The context position. */
1103− yaml_mark_t context_mark;
1104−
1105− /**
1106− * @}
1107− */
1108−
1109− /**
1110− * @name Reader stuff
1111− * @{
1112− */
1113−
1114− /** Read handler. */
1115− yaml_read_handler_t *read_handler;
1116−
1117− /** A pointer for passing to the read handler. */
1118− void *read_handler_data;
1119−
1120− /** Standard (string or file) input data. */
1121− union {
1122− /** String input data. */
1123− struct {
1124− /** The string start pointer. */
1125− const unsigned char *start;
1126− /** The string end pointer. */
1127− const unsigned char *end;
1128− /** The string current position. */
1129− const unsigned char *current;
1130− } string;
1131−
1132− /** File input data. */
1133− FILE *file;
1134− } input;
1135−
1136− /** EOF flag */
1137− int eof;
1138−
1139− /** The working buffer. */
1140− struct {
1141− /** The beginning of the buffer. */
1142− yaml_char_t *start;
1143− /** The end of the buffer. */
1144− yaml_char_t *end;
1145− /** The current position of the buffer. */
1146− yaml_char_t *pointer;
1147− /** The last filled position of the buffer. */
1148− yaml_char_t *last;
1149− } buffer;
1150−
1151− /* The number of unread characters in the buffer. */
1152− size_t unread;
1153−
1154− /** The raw buffer. */
1155− struct {
1156− /** The beginning of the buffer. */
1157− unsigned char *start;
1158− /** The end of the buffer. */
1159− unsigned char *end;
1160− /** The current position of the buffer. */
1161− unsigned char *pointer;
1162− /** The last filled position of the buffer. */
1163− unsigned char *last;
1164− } raw_buffer;
1165−
1166− /** The input encoding. */
1167− yaml_encoding_t encoding;
1168−
1169− /** The offset of the current position (in bytes). */
1170− size_t offset;
1171−
1172− /** The mark of the current position. */
1173− yaml_mark_t mark;
1174−
1175− /**
1176− * @}
1177− */
1178−
1179− /**
1180− * @name Scanner stuff
1181− * @{
1182− */
1183−
1184− /** Have we started to scan the input stream? */
1185− int stream_start_produced;
1186−
1187− /** Have we reached the end of the input stream? */
1188− int stream_end_produced;
1189−
1190− /** The number of unclosed '[' and '{' indicators. */
1191− int flow_level;
1192−
1193− /** The tokens queue. */
1194− struct {
1195− /** The beginning of the tokens queue. */
1196− yaml_token_t *start;
1197− /** The end of the tokens queue. */
1198− yaml_token_t *end;
1199− /** The head of the tokens queue. */
1200− yaml_token_t *head;
1201− /** The tail of the tokens queue. */
1202− yaml_token_t *tail;
1203− } tokens;
1204−
1205− /** The number of tokens fetched from the queue. */
1206− size_t tokens_parsed;
1207−
1208− /* Does the tokens queue contain a token ready for dequeueing. */
1209− int token_available;
1210−
1211− /** The indentation levels stack. */
1212− struct {
1213− /** The beginning of the stack. */
1214− int *start;
1215− /** The end of the stack. */
1216− int *end;
1217− /** The top of the stack. */
1218− int *top;
1219− } indents;
1220−
1221− /** The current indentation level. */
1222− int indent;
1223−
1224− /** May a simple key occur at the current position? */
1225− int simple_key_allowed;
1226−
1227− /** The stack of simple keys. */
1228− struct {
1229− /** The beginning of the stack. */
1230− yaml_simple_key_t *start;
1231− /** The end of the stack. */
1232− yaml_simple_key_t *end;
1233− /** The top of the stack. */
1234− yaml_simple_key_t *top;
1235− } simple_keys;
1236−
1237− /**
1238− * @}
1239− */
1240−
1241− /**
1242− * @name Parser stuff
1243− * @{
1244− */
1245−
1246− /** The parser states stack. */
1247− struct {
1248− /** The beginning of the stack. */
1249− yaml_parser_state_t *start;
1250− /** The end of the stack. */
1251− yaml_parser_state_t *end;
1252− /** The top of the stack. */
1253− yaml_parser_state_t *top;
1254− } states;
1255−
1256− /** The current parser state. */
1257− yaml_parser_state_t state;
1258−
1259− /** The stack of marks. */
1260− struct {
1261− /** The beginning of the stack. */
1262− yaml_mark_t *start;
1263− /** The end of the stack. */
1264− yaml_mark_t *end;
1265− /** The top of the stack. */
1266− yaml_mark_t *top;
1267− } marks;
1268−
1269− /** The list of TAG directives. */
1270− struct {
1271− /** The beginning of the list. */
1272− yaml_tag_directive_t *start;
1273− /** The end of the list. */
1274− yaml_tag_directive_t *end;
1275− /** The top of the list. */
1276− yaml_tag_directive_t *top;
1277− } tag_directives;
1278−
1279− /**
1280− * @}
1281− */
1282−
1283− /**
1284− * @name Dumper stuff
1285− * @{
1286− */
1287−
1288− /** The alias data. */
1289− struct {
1290− /** The beginning of the list. */
1291− yaml_alias_data_t *start;
1292− /** The end of the list. */
1293− yaml_alias_data_t *end;
1294− /** The top of the list. */
1295− yaml_alias_data_t *top;
1296− } aliases;
1297−
1298− /** The currently parsed document. */
1299− yaml_document_t *document;
1300−
1301− /**
1302− * @}
1303− */
1304−
1305−} yaml_parser_t;
1306−
1307−/**
1308− * Initialize a parser.
1309− *
1310− * This function creates a new parser object. An application is responsible
1311− * for destroying the object using the yaml_parser_delete() function.
1312− *
1313− * @param[out] parser An empty parser object.
1314− *
1315− * @returns @c 1 if the function succeeded, @c 0 on error.
1316− */
1317−
1318−YAML_DECLARE(int)
1319−yaml_parser_initialize(yaml_parser_t *parser);
1320−
1321−/**
1322− * Destroy a parser.
1323− *
1324− * @param[in,out] parser A parser object.
1325− */
1326−
1327−YAML_DECLARE(void)
1328−yaml_parser_delete(yaml_parser_t *parser);
1329−
1330−/**
1331− * Set a string input.
1332− *
1333− * Note that the @a input pointer must be valid while the @a parser object
1334− * exists. The application is responsible for destroing @a input after
1335− * destroying the @a parser.
1336− *
1337− * @param[in,out] parser A parser object.
1338− * @param[in] input A source data.
1339− * @param[in] size The length of the source data in bytes.
1340− */
1341−
1342−YAML_DECLARE(void)
1343−yaml_parser_set_input_string(yaml_parser_t *parser,
1344− const unsigned char *input, size_t size);
1345−
1346−/**
1347− * Set a file input.
1348− *
1349− * @a file should be a file object open for reading. The application is
1350− * responsible for closing the @a file.
1351− *
1352− * @param[in,out] parser A parser object.
1353− * @param[in] file An open file.
1354− */
1355−
1356−YAML_DECLARE(void)
1357−yaml_parser_set_input_file(yaml_parser_t *parser, FILE *file);
1358−
1359−/**
1360− * Set a generic input handler.
1361− *
1362− * @param[in,out] parser A parser object.
1363− * @param[in] handler A read handler.
1364− * @param[in] data Any application data for passing to the read
1365− * handler.
1366− */
1367−
1368−YAML_DECLARE(void)
1369−yaml_parser_set_input(yaml_parser_t *parser,
1370− yaml_read_handler_t *handler, void *data);
1371−
1372−/**
1373− * Set the source encoding.
1374− *
1375− * @param[in,out] parser A parser object.
1376− * @param[in] encoding The source encoding.
1377− */
1378−
1379−YAML_DECLARE(void)
1380−yaml_parser_set_encoding(yaml_parser_t *parser, yaml_encoding_t encoding);
1381−
1382−/**
1383− * Scan the input stream and produce the next token.
1384− *
1385− * Call the function subsequently to produce a sequence of tokens corresponding
1386− * to the input stream. The initial token has the type
1387− * @c YAML_STREAM_START_TOKEN while the ending token has the type
1388− * @c YAML_STREAM_END_TOKEN.
1389− *
1390− * An application is responsible for freeing any buffers associated with the
1391− * produced token object using the @c yaml_token_delete function.
1392− *
1393− * An application must not alternate the calls of yaml_parser_scan() with the
1394− * calls of yaml_parser_parse() or yaml_parser_load(). Doing this will break
1395− * the parser.
1396− *
1397− * @param[in,out] parser A parser object.
1398− * @param[out] token An empty token object.
1399− *
1400− * @returns @c 1 if the function succeeded, @c 0 on error.
1401− */
1402−
1403−YAML_DECLARE(int)
1404−yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token);
1405−
1406−/**
1407− * Parse the input stream and produce the next parsing event.
1408− *
1409− * Call the function subsequently to produce a sequence of events corresponding
1410− * to the input stream. The initial event has the type
1411− * @c YAML_STREAM_START_EVENT while the ending event has the type
1412− * @c YAML_STREAM_END_EVENT.
1413− *
1414− * An application is responsible for freeing any buffers associated with the
1415− * produced event object using the yaml_event_delete() function.
1416− *
1417− * An application must not alternate the calls of yaml_parser_parse() with the
1418− * calls of yaml_parser_scan() or yaml_parser_load(). Doing this will break the
1419− * parser.
1420− *
1421− * @param[in,out] parser A parser object.
1422− * @param[out] event An empty event object.
1423− *
1424− * @returns @c 1 if the function succeeded, @c 0 on error.
1425− */
1426−
1427−YAML_DECLARE(int)
1428−yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event);
1429−
1430−/**
1431− * Parse the input stream and produce the next YAML document.
1432− *
1433− * Call this function subsequently to produce a sequence of documents
1434− * constituting the input stream.
1435− *
1436− * If the produced document has no root node, it means that the document
1437− * end has been reached.
1438− *
1439− * An application is responsible for freeing any data associated with the
1440− * produced document object using the yaml_document_delete() function.
1441− *
1442− * An application must not alternate the calls of yaml_parser_load() with the
1443− * calls of yaml_parser_scan() or yaml_parser_parse(). Doing this will break
1444− * the parser.
1445− *
1446− * @param[in,out] parser A parser object.
1447− * @param[out] document An empty document object.
1448− *
1449− * @return @c 1 if the function succeeded, @c 0 on error.
1450− */
1451−
1452−YAML_DECLARE(int)
1453−yaml_parser_load(yaml_parser_t *parser, yaml_document_t *document);
1454−
1455−/** @} */
1456−
1457−/**
1458− * @defgroup emitter Emitter Definitions
1459− * @{
1460− */
1461−
1462−/**
1463− * The prototype of a write handler.
1464− *
1465− * The write handler is called when the emitter needs to flush the accumulated
1466− * characters to the output. The handler should write @a size bytes of the
1467− * @a buffer to the output.
1468− *
1469− * @param[in,out] data A pointer to an application data specified by
1470− * yaml_emitter_set_output().
1471− * @param[in] buffer The buffer with bytes to be written.
1472− * @param[in] size The size of the buffer.
1473− *
1474− * @returns On success, the handler should return @c 1. If the handler failed,
1475− * the returned value should be @c 0.
1476− */
1477−
1478−typedef int yaml_write_handler_t(void *data, unsigned char *buffer, size_t size);
1479−
1480−/** The emitter states. */
1481−typedef enum yaml_emitter_state_e {
1482− /** Expect STREAM-START. */
1483− YAML_EMIT_STREAM_START_STATE,
1484− /** Expect the first DOCUMENT-START or STREAM-END. */
1485− YAML_EMIT_FIRST_DOCUMENT_START_STATE,
1486− /** Expect DOCUMENT-START or STREAM-END. */
1487− YAML_EMIT_DOCUMENT_START_STATE,
1488− /** Expect the content of a document. */
1489− YAML_EMIT_DOCUMENT_CONTENT_STATE,
1490− /** Expect DOCUMENT-END. */
1491− YAML_EMIT_DOCUMENT_END_STATE,
1492− /** Expect the first item of a flow sequence. */
1493− YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE,
1494− /** Expect an item of a flow sequence. */
1495− YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE,
1496− /** Expect the first key of a flow mapping. */
1497− YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE,
1498− /** Expect a key of a flow mapping. */
1499− YAML_EMIT_FLOW_MAPPING_KEY_STATE,
1500− /** Expect a value for a simple key of a flow mapping. */
1501− YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE,
1502− /** Expect a value of a flow mapping. */
1503− YAML_EMIT_FLOW_MAPPING_VALUE_STATE,
1504− /** Expect the first item of a block sequence. */
1505− YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE,
1506− /** Expect an item of a block sequence. */
1507− YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE,
1508− /** Expect the first key of a block mapping. */
1509− YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE,
1510− /** Expect the key of a block mapping. */
1511− YAML_EMIT_BLOCK_MAPPING_KEY_STATE,
1512− /** Expect a value for a simple key of a block mapping. */
1513− YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE,
1514− /** Expect a value of a block mapping. */
1515− YAML_EMIT_BLOCK_MAPPING_VALUE_STATE,
1516− /** Expect nothing. */
1517− YAML_EMIT_END_STATE
1518−} yaml_emitter_state_t;
1519−
1520−
1521−/* This is needed for C++ */
1522−
1523−typedef struct yaml_anchors_s {
1524− /** The number of references. */
1525− int references;
1526− /** The anchor id. */
1527− int anchor;
1528− /** If the node has been emitted? */
1529− int serialized;
1530−} yaml_anchors_t;
1531−
1532−/**
1533− * The emitter structure.
1534− *
1535− * All members are internal. Manage the structure using the @c yaml_emitter_
1536− * family of functions.
1537− */
1538−
1539−typedef struct yaml_emitter_s {
1540−
1541− /**
1542− * @name Error handling
1543− * @{
1544− */
1545−
1546− /** Error type. */
1547− yaml_error_type_t error;
1548− /** Error description. */
1549− const char *problem;
1550−
1551− /**
1552− * @}
1553− */
1554−
1555− /**
1556− * @name Writer stuff
1557− * @{
1558− */
1559−
1560− /** Write handler. */
1561− yaml_write_handler_t *write_handler;
1562−
1563− /** A pointer for passing to the white handler. */
1564− void *write_handler_data;
1565−
1566− /** Standard (string or file) output data. */
1567− union {
1568− /** String output data. */
1569− struct {
1570− /** The buffer pointer. */
1571− unsigned char *buffer;
1572− /** The buffer size. */
1573− size_t size;
1574− /** The number of written bytes. */
1575− size_t *size_written;
1576− } string;
1577−
1578− /** File output data. */
1579− FILE *file;
1580− } output;
1581−
1582− /** The working buffer. */
1583− struct {
1584− /** The beginning of the buffer. */
1585− yaml_char_t *start;
1586− /** The end of the buffer. */
1587− yaml_char_t *end;
1588− /** The current position of the buffer. */
1589− yaml_char_t *pointer;
1590− /** The last filled position of the buffer. */
1591− yaml_char_t *last;
1592− } buffer;
1593−
1594− /** The raw buffer. */
1595− struct {
1596− /** The beginning of the buffer. */
1597− unsigned char *start;
1598− /** The end of the buffer. */
1599− unsigned char *end;
1600− /** The current position of the buffer. */
1601− unsigned char *pointer;
1602− /** The last filled position of the buffer. */
1603− unsigned char *last;
1604− } raw_buffer;
1605−
1606− /** The stream encoding. */
1607− yaml_encoding_t encoding;
1608−
1609− /**
1610− * @}
1611− */
1612−
1613− /**
1614− * @name Emitter stuff
1615− * @{
1616− */
1617−
1618− /** If the output is in the canonical style? */
1619− int canonical;
1620− /** The number of indentation spaces. */
1621− int best_indent;
1622− /** The preferred width of the output lines. */
1623− int best_width;
1624− /** Allow unescaped non-ASCII characters? */
1625− int unicode;
1626− /** The preferred line break. */
1627− yaml_break_t line_break;
1628−
1629− /** The stack of states. */
1630− struct {
1631− /** The beginning of the stack. */
1632− yaml_emitter_state_t *start;
1633− /** The end of the stack. */
1634− yaml_emitter_state_t *end;
1635− /** The top of the stack. */
1636− yaml_emitter_state_t *top;
1637− } states;
1638−
1639− /** The current emitter state. */
1640− yaml_emitter_state_t state;
1641−
1642− /** The event queue. */
1643− struct {
1644− /** The beginning of the event queue. */
1645− yaml_event_t *start;
1646− /** The end of the event queue. */
1647− yaml_event_t *end;
1648− /** The head of the event queue. */
1649− yaml_event_t *head;
1650− /** The tail of the event queue. */
1651− yaml_event_t *tail;
1652− } events;
1653−
1654− /** The stack of indentation levels. */
1655− struct {
1656− /** The beginning of the stack. */
1657− int *start;
1658− /** The end of the stack. */
1659− int *end;
1660− /** The top of the stack. */
1661− int *top;
1662− } indents;
1663−
1664− /** The list of tag directives. */
1665− struct {
1666− /** The beginning of the list. */
1667− yaml_tag_directive_t *start;
1668− /** The end of the list. */
1669− yaml_tag_directive_t *end;
1670− /** The top of the list. */
1671− yaml_tag_directive_t *top;
1672− } tag_directives;
1673−
1674− /** The current indentation level. */
1675− int indent;
1676−
1677− /** The current flow level. */
1678− int flow_level;
1679−
1680− /** Is it the document root context? */
1681− int root_context;
1682− /** Is it a sequence context? */
1683− int sequence_context;
1684− /** Is it a mapping context? */
1685− int mapping_context;
1686− /** Is it a simple mapping key context? */
1687− int simple_key_context;
1688−
1689− /** The current line. */
1690− int line;
1691− /** The current column. */
1692− int column;
1693− /** If the last character was a whitespace? */
1694− int whitespace;
1695− /** If the last character was an indentation character (' ', '-', '?', ':')? */
1696− int indention;
1697− /** If an explicit document end is required? */
1698− int open_ended;
1699−
1700− /** Anchor analysis. */
1701− struct {
1702− /** The anchor value. */
1703− yaml_char_t *anchor;
1704− /** The anchor length. */
1705− size_t anchor_length;
1706− /** Is it an alias? */
1707− int alias;
1708− } anchor_data;
1709−
1710− /** Tag analysis. */
1711− struct {
1712− /** The tag handle. */
1713− yaml_char_t *handle;
1714− /** The tag handle length. */
1715− size_t handle_length;
1716− /** The tag suffix. */
1717− yaml_char_t *suffix;
1718− /** The tag suffix length. */
1719− size_t suffix_length;
1720− } tag_data;
1721−
1722− /** Scalar analysis. */
1723− struct {
1724− /** The scalar value. */
1725− yaml_char_t *value;
1726− /** The scalar length. */
1727− size_t length;
1728− /** Does the scalar contain line breaks? */
1729− int multiline;
1730− /** Can the scalar be expessed in the flow plain style? */
1731− int flow_plain_allowed;
1732− /** Can the scalar be expressed in the block plain style? */
1733− int block_plain_allowed;
1734− /** Can the scalar be expressed in the single quoted style? */
1735− int single_quoted_allowed;
1736− /** Can the scalar be expressed in the literal or folded styles? */
1737− int block_allowed;
1738− /** The output style. */
1739− yaml_scalar_style_t style;
1740− } scalar_data;
1741−
1742− /**
1743− * @}
1744− */
1745−
1746− /**
1747− * @name Dumper stuff
1748− * @{
1749− */
1750−
1751− /** If the stream was already opened? */
1752− int opened;
1753− /** If the stream was already closed? */
1754− int closed;
1755−
1756− /** The information associated with the document nodes. */
1757− yaml_anchors_t *anchors;
1758−
1759− /** The last assigned anchor id. */
1760− int last_anchor_id;
1761−
1762− /** The currently emitted document. */
1763− yaml_document_t *document;
1764−
1765− /**
1766− * @}
1767− */
1768−
1769−} yaml_emitter_t;
1770−
1771−/**
1772− * Initialize an emitter.
1773− *
1774− * This function creates a new emitter object. An application is responsible
1775− * for destroying the object using the yaml_emitter_delete() function.
1776− *
1777− * @param[out] emitter An empty parser object.
1778− *
1779− * @returns @c 1 if the function succeeded, @c 0 on error.
1780− */
1781−
1782−YAML_DECLARE(int)
1783−yaml_emitter_initialize(yaml_emitter_t *emitter);
1784−
1785−/**
1786− * Destroy an emitter.
1787− *
1788− * @param[in,out] emitter An emitter object.
1789− */
1790−
1791−YAML_DECLARE(void)
1792−yaml_emitter_delete(yaml_emitter_t *emitter);
1793−
1794−/**
1795− * Set a string output.
1796− *
1797− * The emitter will write the output characters to the @a output buffer of the
1798− * size @a size. The emitter will set @a size_written to the number of written
1799− * bytes. If the buffer is smaller than required, the emitter produces the
1800− * YAML_WRITE_ERROR error.
1801− *
1802− * @param[in,out] emitter An emitter object.
1803− * @param[in] output An output buffer.
1804− * @param[in] size The buffer size.
1805− * @param[in] size_written The pointer to save the number of written
1806− * bytes.
1807− */
1808−
1809−YAML_DECLARE(void)
1810−yaml_emitter_set_output_string(yaml_emitter_t *emitter,
1811− unsigned char *output, size_t size, size_t *size_written);
1812−
1813−/**
1814− * Set a file output.
1815− *
1816− * @a file should be a file object open for writing. The application is
1817− * responsible for closing the @a file.
1818− *
1819− * @param[in,out] emitter An emitter object.
1820− * @param[in] file An open file.
1821− */
1822−
1823−YAML_DECLARE(void)
1824−yaml_emitter_set_output_file(yaml_emitter_t *emitter, FILE *file);
1825−
1826−/**
1827− * Set a generic output handler.
1828− *
1829− * @param[in,out] emitter An emitter object.
1830− * @param[in] handler A write handler.
1831− * @param[in] data Any application data for passing to the write
1832− * handler.
1833− */
1834−
1835−YAML_DECLARE(void)
1836−yaml_emitter_set_output(yaml_emitter_t *emitter,
1837− yaml_write_handler_t *handler, void *data);
1838−
1839−/**
1840− * Set the output encoding.
1841− *
1842− * @param[in,out] emitter An emitter object.
1843− * @param[in] encoding The output encoding.
1844− */
1845−
1846−YAML_DECLARE(void)
1847−yaml_emitter_set_encoding(yaml_emitter_t *emitter, yaml_encoding_t encoding);
1848−
1849−/**
1850− * Set if the output should be in the "canonical" format as in the YAML
1851− * specification.
1852− *
1853− * @param[in,out] emitter An emitter object.
1854− * @param[in] canonical If the output is canonical.
1855− */
1856−
1857−YAML_DECLARE(void)
1858−yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical);
1859−
1860−/**
1861− * Set the intendation increment.
1862− *
1863− * @param[in,out] emitter An emitter object.
1864− * @param[in] indent The indentation increment (1 < . < 10).
1865− */
1866−
1867−YAML_DECLARE(void)
1868−yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent);
1869−
1870−/**
1871− * Set the preferred line width. @c -1 means unlimited.
1872− *
1873− * @param[in,out] emitter An emitter object.
1874− * @param[in] width The preferred line width.
1875− */
1876−
1877−YAML_DECLARE(void)
1878−yaml_emitter_set_width(yaml_emitter_t *emitter, int width);
1879−
1880−/**
1881− * Set if unescaped non-ASCII characters are allowed.
1882− *
1883− * @param[in,out] emitter An emitter object.
1884− * @param[in] unicode If unescaped Unicode characters are allowed.
1885− */
1886−
1887−YAML_DECLARE(void)
1888−yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode);
1889−
1890−/**
1891− * Set the preferred line break.
1892− *
1893− * @param[in,out] emitter An emitter object.
1894− * @param[in] line_break The preferred line break.
1895− */
1896−
1897−YAML_DECLARE(void)
1898−yaml_emitter_set_break(yaml_emitter_t *emitter, yaml_break_t line_break);
1899−
1900−/**
1901− * Emit an event.
1902− *
1903− * The event object may be generated using the yaml_parser_parse() function.
1904− * The emitter takes the responsibility for the event object and destroys its
1905− * content after it is emitted. The event object is destroyed even if the
1906− * function fails.
1907− *
1908− * @param[in,out] emitter An emitter object.
1909− * @param[in,out] event An event object.
1910− *
1911− * @returns @c 1 if the function succeeded, @c 0 on error.
1912− */
1913−
1914−YAML_DECLARE(int)
1915−yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event);
1916−
1917−/**
1918− * Start a YAML stream.
1919− *
1920− * This function should be used before yaml_emitter_dump() is called.
1921− *
1922− * @param[in,out] emitter An emitter object.
1923− *
1924− * @returns @c 1 if the function succeeded, @c 0 on error.
1925− */
1926−
1927−YAML_DECLARE(int)
1928−yaml_emitter_open(yaml_emitter_t *emitter);
1929−
1930−/**
1931− * Finish a YAML stream.
1932− *
1933− * This function should be used after yaml_emitter_dump() is called.
1934− *
1935− * @param[in,out] emitter An emitter object.
1936− *
1937− * @returns @c 1 if the function succeeded, @c 0 on error.
1938− */
1939−
1940−YAML_DECLARE(int)
1941−yaml_emitter_close(yaml_emitter_t *emitter);
1942−
1943−/**
1944− * Emit a YAML document.
1945− *
1946− * The documen object may be generated using the yaml_parser_load() function
1947− * or the yaml_document_initialize() function. The emitter takes the
1948− * responsibility for the document object and destroys its content after
1949− * it is emitted. The document object is destroyed even if the function fails.
1950− *
1951− * @param[in,out] emitter An emitter object.
1952− * @param[in,out] document A document object.
1953− *
1954− * @returns @c 1 if the function succeeded, @c 0 on error.
1955− */
1956−
1957−YAML_DECLARE(int)
1958−yaml_emitter_dump(yaml_emitter_t *emitter, yaml_document_t *document);
1959−
1960−/**
1961− * Flush the accumulated characters to the output.
1962− *
1963− * @param[in,out] emitter An emitter object.
1964− *
1965− * @returns @c 1 if the function succeeded, @c 0 on error.
1966− */
1967−
1968−YAML_DECLARE(int)
1969−yaml_emitter_flush(yaml_emitter_t *emitter);
1970−
1971−/** @} */
1972−
1973−#ifdef __cplusplus
1974−}
1975−#endif
1976−
1977−#endif /* #ifndef YAML_H */
1978−
libyaml/libyaml_src/yaml_private.hdeleted−690
@@ -1,690 +0,0 @@
1−#if HAVE_CONFIG_H
2−#include "config.h"
3−#endif
4−
5−#include <yaml.h>
6−
7−#include <assert.h>
8−#include <limits.h>
9−#include <stddef.h>
10−
11−/*
12− * Memory management.
13− */
14−
15−YAML_DECLARE(void *)
16−yaml_malloc(size_t size);
17−
18−YAML_DECLARE(void *)
19−yaml_realloc(void *ptr, size_t size);
20−
21−YAML_DECLARE(void)
22−yaml_free(void *ptr);
23−
24−YAML_DECLARE(yaml_char_t *)
25−yaml_strdup(const yaml_char_t *);
26−
27−/*
28− * Reader: Ensure that the buffer contains at least `length` characters.
29− */
30−
31−YAML_DECLARE(int)
32−yaml_parser_update_buffer(yaml_parser_t *parser, size_t length);
33−
34−/*
35− * Scanner: Ensure that the token stack contains at least one token ready.
36− */
37−
38−YAML_DECLARE(int)
39−yaml_parser_fetch_more_tokens(yaml_parser_t *parser);
40−
41−/*
42− * The size of the input raw buffer.
43− */
44−
45−#define INPUT_RAW_BUFFER_SIZE 16384
46−
47−/*
48− * The size of the input buffer.
49− *
50− * It should be possible to decode the whole raw buffer.
51− */
52−
53−#define INPUT_BUFFER_SIZE (INPUT_RAW_BUFFER_SIZE*3)
54−
55−/*
56− * The size of the output buffer.
57− */
58−
59−#define OUTPUT_BUFFER_SIZE 16384
60−
61−/*
62− * The size of the output raw buffer.
63− *
64− * It should be possible to encode the whole output buffer.
65− */
66−
67−#define OUTPUT_RAW_BUFFER_SIZE (OUTPUT_BUFFER_SIZE*2+2)
68−
69−/*
70− * The maximum size of a YAML input file.
71− * This used to be PTRDIFF_MAX, but that's not entirely portable
72− * because stdint.h isn't available on all platforms.
73− * It is not entirely clear why this isn't the maximum value
74− * that can fit into the parser->offset field.
75− */
76−
77−#define MAX_FILE_SIZE (~(size_t)0 / 2)
78−
79−
80−/*
81− * The size of other stacks and queues.
82− */
83−
84−#define INITIAL_STACK_SIZE 16
85−#define INITIAL_QUEUE_SIZE 16
86−#define INITIAL_STRING_SIZE 16
87−
88−/*
89− * Buffer management.
90− */
91−
92−#define BUFFER_INIT(context,buffer,size) \
93− (((buffer).start = (yaml_char_t *)yaml_malloc(size)) ? \
94− ((buffer).last = (buffer).pointer = (buffer).start, \
95− (buffer).end = (buffer).start+(size), \
96− 1) : \
97− ((context)->error = YAML_MEMORY_ERROR, \
98− 0))
99−
100−#define BUFFER_DEL(context,buffer) \
101− (yaml_free((buffer).start), \
102− (buffer).start = (buffer).pointer = (buffer).end = 0)
103−
104−/*
105− * String management.
106− */
107−
108−typedef struct {
109− yaml_char_t *start;
110− yaml_char_t *end;
111− yaml_char_t *pointer;
112−} yaml_string_t;
113−
114−YAML_DECLARE(int)
115−yaml_string_extend(yaml_char_t **start,
116− yaml_char_t **pointer, yaml_char_t **end);
117−
118−YAML_DECLARE(int)
119−yaml_string_join(
120− yaml_char_t **a_start, yaml_char_t **a_pointer, yaml_char_t **a_end,
121− yaml_char_t **b_start, yaml_char_t **b_pointer, yaml_char_t **b_end);
122−
123−#define NULL_STRING { NULL, NULL, NULL }
124−
125−#define STRING(string,length) { (string), (string)+(length), (string) }
126−
127−#define STRING_ASSIGN(value,string,length) \
128− ((value).start = (string), \
129− (value).end = (string)+(length), \
130− (value).pointer = (string))
131−
132−#define STRING_INIT(context,string,size) \
133− (((string).start = YAML_MALLOC(size)) ? \
134− ((string).pointer = (string).start, \
135− (string).end = (string).start+(size), \
136− memset((string).start, 0, (size)), \
137− 1) : \
138− ((context)->error = YAML_MEMORY_ERROR, \
139− 0))
140−
141−#define STRING_DEL(context,string) \
142− (yaml_free((string).start), \
143− (string).start = (string).pointer = (string).end = 0)
144−
145−#define STRING_EXTEND(context,string) \
146− ((((string).pointer+5 < (string).end) \
147− || yaml_string_extend(&(string).start, \
148− &(string).pointer, &(string).end)) ? \
149− 1 : \
150− ((context)->error = YAML_MEMORY_ERROR, \
151− 0))
152−
153−#define CLEAR(context,string) \
154− ((string).pointer = (string).start, \
155− memset((string).start, 0, (string).end-(string).start))
156−
157−#define JOIN(context,string_a,string_b) \
158− ((yaml_string_join(&(string_a).start, &(string_a).pointer, \
159− &(string_a).end, &(string_b).start, \
160− &(string_b).pointer, &(string_b).end)) ? \
161− ((string_b).pointer = (string_b).start, \
162− 1) : \
163− ((context)->error = YAML_MEMORY_ERROR, \
164− 0))
165−
166−/*
167− * String check operations.
168− */
169−
170−/*
171− * Check the octet at the specified position.
172− */
173−
174−#define CHECK_AT(string,octet,offset) \
175− ((string).pointer[offset] == (yaml_char_t)(octet))
176−
177−/*
178− * Check the current octet in the buffer.
179− */
180−
181−#define CHECK(string,octet) (CHECK_AT((string),(octet),0))
182−
183−/*
184− * Check if the character at the specified position is an alphabetical
185− * character, a digit, '_', or '-'.
186− */
187−
188−#define IS_ALPHA_AT(string,offset) \
189− (((string).pointer[offset] >= (yaml_char_t) '0' && \
190− (string).pointer[offset] <= (yaml_char_t) '9') || \
191− ((string).pointer[offset] >= (yaml_char_t) 'A' && \
192− (string).pointer[offset] <= (yaml_char_t) 'Z') || \
193− ((string).pointer[offset] >= (yaml_char_t) 'a' && \
194− (string).pointer[offset] <= (yaml_char_t) 'z') || \
195− (string).pointer[offset] == '_' || \
196− (string).pointer[offset] == '-')
197−
198−#define IS_ALPHA(string) IS_ALPHA_AT((string),0)
199−
200−/*
201− * Check if the character at the specified position is a digit.
202− */
203−
204−#define IS_DIGIT_AT(string,offset) \
205− (((string).pointer[offset] >= (yaml_char_t) '0' && \
206− (string).pointer[offset] <= (yaml_char_t) '9'))
207−
208−#define IS_DIGIT(string) IS_DIGIT_AT((string),0)
209−
210−/*
211− * Get the value of a digit.
212− */
213−
214−#define AS_DIGIT_AT(string,offset) \
215− ((string).pointer[offset] - (yaml_char_t) '0')
216−
217−#define AS_DIGIT(string) AS_DIGIT_AT((string),0)
218−
219−/*
220− * Check if the character at the specified position is a hex-digit.
221− */
222−
223−#define IS_HEX_AT(string,offset) \
224− (((string).pointer[offset] >= (yaml_char_t) '0' && \
225− (string).pointer[offset] <= (yaml_char_t) '9') || \
226− ((string).pointer[offset] >= (yaml_char_t) 'A' && \
227− (string).pointer[offset] <= (yaml_char_t) 'F') || \
228− ((string).pointer[offset] >= (yaml_char_t) 'a' && \
229− (string).pointer[offset] <= (yaml_char_t) 'f'))
230−
231−#define IS_HEX(string) IS_HEX_AT((string),0)
232−
233−/*
234− * Get the value of a hex-digit.
235− */
236−
237−#define AS_HEX_AT(string,offset) \
238− (((string).pointer[offset] >= (yaml_char_t) 'A' && \
239− (string).pointer[offset] <= (yaml_char_t) 'F') ? \
240− ((string).pointer[offset] - (yaml_char_t) 'A' + 10) : \
241− ((string).pointer[offset] >= (yaml_char_t) 'a' && \
242− (string).pointer[offset] <= (yaml_char_t) 'f') ? \
243− ((string).pointer[offset] - (yaml_char_t) 'a' + 10) : \
244− ((string).pointer[offset] - (yaml_char_t) '0'))
245−
246−#define AS_HEX(string) AS_HEX_AT((string),0)
247−
248−/*
249− * Check if the character is ASCII.
250− */
251−
252−#define IS_ASCII_AT(string,offset) \
253− ((string).pointer[offset] <= (yaml_char_t) '\x7F')
254−
255−#define IS_ASCII(string) IS_ASCII_AT((string),0)
256−
257−/*
258− * Check if the character can be printed unescaped.
259− */
260−
261−#define IS_PRINTABLE_AT(string,offset) \
262− (((string).pointer[offset] == 0x0A) /* . == #x0A */ \
263− || ((string).pointer[offset] >= 0x20 /* #x20 <= . <= #x7E */ \
264− && (string).pointer[offset] <= 0x7E) \
265− || ((string).pointer[offset] == 0xC2 /* #0xA0 <= . <= #xD7FF */ \
266− && (string).pointer[offset+1] >= 0xA0) \
267− || ((string).pointer[offset] > 0xC2 \
268− && (string).pointer[offset] < 0xED) \
269− || ((string).pointer[offset] == 0xED \
270− && (string).pointer[offset+1] < 0xA0) \
271− || ((string).pointer[offset] == 0xEE) \
272− || ((string).pointer[offset] == 0xEF /* #xE000 <= . <= #xFFFD */ \
273− && !((string).pointer[offset+1] == 0xBB /* && . != #xFEFF */ \
274− && (string).pointer[offset+2] == 0xBF) \
275− && !((string).pointer[offset+1] == 0xBF \
276− && ((string).pointer[offset+2] == 0xBE \
277− || (string).pointer[offset+2] == 0xBF))))
278−
279−#define IS_PRINTABLE(string) IS_PRINTABLE_AT((string),0)
280−
281−/*
282− * Check if the character at the specified position is NUL.
283− */
284−
285−#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset))
286−
287−#define IS_Z(string) IS_Z_AT((string),0)
288−
289−/*
290− * Check if the character at the specified position is BOM.
291− */
292−
293−#define IS_BOM_AT(string,offset) \
294− (CHECK_AT((string),'\xEF',(offset)) \
295− && CHECK_AT((string),'\xBB',(offset)+1) \
296− && CHECK_AT((string),'\xBF',(offset)+2)) /* BOM (#xFEFF) */
297−
298−#define IS_BOM(string) IS_BOM_AT(string,0)
299−
300−/*
301− * Check if the character at the specified position is space.
302− */
303−
304−#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset))
305−
306−#define IS_SPACE(string) IS_SPACE_AT((string),0)
307−
308−/*
309− * Check if the character at the specified position is tab.
310− */
311−
312−#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset))
313−
314−#define IS_TAB(string) IS_TAB_AT((string),0)
315−
316−/*
317− * Check if the character at the specified position is blank (space or tab).
318− */
319−
320−#define IS_BLANK_AT(string,offset) \
321− (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset)))
322−
323−#define IS_BLANK(string) IS_BLANK_AT((string),0)
324−
325−/*
326− * Check if the character at the specified position is a line break.
327− */
328−
329−#define IS_BREAK_AT(string,offset) \
330− (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \
331− || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \
332− || (CHECK_AT((string),'\xC2',(offset)) \
333− && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \
334− || (CHECK_AT((string),'\xE2',(offset)) \
335− && CHECK_AT((string),'\x80',(offset)+1) \
336− && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \
337− || (CHECK_AT((string),'\xE2',(offset)) \
338− && CHECK_AT((string),'\x80',(offset)+1) \
339− && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */
340−
341−#define IS_BREAK(string) IS_BREAK_AT((string),0)
342−
343−#define IS_CRLF_AT(string,offset) \
344− (CHECK_AT((string),'\r',(offset)) && CHECK_AT((string),'\n',(offset)+1))
345−
346−#define IS_CRLF(string) IS_CRLF_AT((string),0)
347−
348−/*
349− * Check if the character is a line break or NUL.
350− */
351−
352−#define IS_BREAKZ_AT(string,offset) \
353− (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset)))
354−
355−#define IS_BREAKZ(string) IS_BREAKZ_AT((string),0)
356−
357−/*
358− * Check if the character is a line break, space, or NUL.
359− */
360−
361−#define IS_SPACEZ_AT(string,offset) \
362− (IS_SPACE_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset)))
363−
364−#define IS_SPACEZ(string) IS_SPACEZ_AT((string),0)
365−
366−/*
367− * Check if the character is a line break, space, tab, or NUL.
368− */
369−
370−#define IS_BLANKZ_AT(string,offset) \
371− (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset)))
372−
373−#define IS_BLANKZ(string) IS_BLANKZ_AT((string),0)
374−
375−/*
376− * Determine the width of the character.
377− */
378−
379−#define WIDTH_AT(string,offset) \
380− (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \
381− ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \
382− ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \
383− ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0)
384−
385−#define WIDTH(string) WIDTH_AT((string),0)
386−
387−/*
388− * Move the string pointer to the next character.
389− */
390−
391−#define MOVE(string) ((string).pointer += WIDTH((string)))
392−
393−/*
394− * Copy a character and move the pointers of both strings.
395− */
396−
397−#define COPY(string_a,string_b) \
398− ((*(string_b).pointer & 0x80) == 0x00 ? \
399− (*((string_a).pointer++) = *((string_b).pointer++)) : \
400− (*(string_b).pointer & 0xE0) == 0xC0 ? \
401− (*((string_a).pointer++) = *((string_b).pointer++), \
402− *((string_a).pointer++) = *((string_b).pointer++)) : \
403− (*(string_b).pointer & 0xF0) == 0xE0 ? \
404− (*((string_a).pointer++) = *((string_b).pointer++), \
405− *((string_a).pointer++) = *((string_b).pointer++), \
406− *((string_a).pointer++) = *((string_b).pointer++)) : \
407− (*(string_b).pointer & 0xF8) == 0xF0 ? \
408− (*((string_a).pointer++) = *((string_b).pointer++), \
409− *((string_a).pointer++) = *((string_b).pointer++), \
410− *((string_a).pointer++) = *((string_b).pointer++), \
411− *((string_a).pointer++) = *((string_b).pointer++)) : 0)
412−
413−/*
414− * Stack and queue management.
415− */
416−
417−YAML_DECLARE(int)
418−yaml_stack_extend(void **start, void **top, void **end);
419−
420−YAML_DECLARE(int)
421−yaml_queue_extend(void **start, void **head, void **tail, void **end);
422−
423−#define STACK_INIT(context,stack,type) \
424− (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \
425− ((stack).top = (stack).start, \
426− (stack).end = (stack).start+INITIAL_STACK_SIZE, \
427− 1) : \
428− ((context)->error = YAML_MEMORY_ERROR, \
429− 0))
430−
431−#define STACK_DEL(context,stack) \
432− (yaml_free((stack).start), \
433− (stack).start = (stack).top = (stack).end = 0)
434−
435−#define STACK_EMPTY(context,stack) \
436− ((stack).start == (stack).top)
437−
438−#define STACK_LIMIT(context,stack,size) \
439− ((stack).top - (stack).start < (size) ? \
440− 1 : \
441− ((context)->error = YAML_MEMORY_ERROR, \
442− 0))
443−
444−#define PUSH(context,stack,value) \
445− (((stack).top != (stack).end \
446− || yaml_stack_extend((void **)&(stack).start, \
447− (void **)&(stack).top, (void **)&(stack).end)) ? \
448− (*((stack).top++) = value, \
449− 1) : \
450− ((context)->error = YAML_MEMORY_ERROR, \
451− 0))
452−
453−#define POP(context,stack) \
454− (*(--(stack).top))
455−
456−#define QUEUE_INIT(context,queue,size,type) \
457− (((queue).start = (type)yaml_malloc((size)*sizeof(*(queue).start))) ? \
458− ((queue).head = (queue).tail = (queue).start, \
459− (queue).end = (queue).start+(size), \
460− 1) : \
461− ((context)->error = YAML_MEMORY_ERROR, \
462− 0))
463−
464−#define QUEUE_DEL(context,queue) \
465− (yaml_free((queue).start), \
466− (queue).start = (queue).head = (queue).tail = (queue).end = 0)
467−
468−#define QUEUE_EMPTY(context,queue) \
469− ((queue).head == (queue).tail)
470−
471−#define ENQUEUE(context,queue,value) \
472− (((queue).tail != (queue).end \
473− || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \
474− (void **)&(queue).tail, (void **)&(queue).end)) ? \
475− (*((queue).tail++) = value, \
476− 1) : \
477− ((context)->error = YAML_MEMORY_ERROR, \
478− 0))
479−
480−#define DEQUEUE(context,queue) \
481− (*((queue).head++))
482−
483−#define QUEUE_INSERT(context,queue,index,value) \
484− (((queue).tail != (queue).end \
485− || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \
486− (void **)&(queue).tail, (void **)&(queue).end)) ? \
487− (memmove((queue).head+(index)+1,(queue).head+(index), \
488− ((queue).tail-(queue).head-(index))*sizeof(*(queue).start)), \
489− *((queue).head+(index)) = value, \
490− (queue).tail++, \
491− 1) : \
492− ((context)->error = YAML_MEMORY_ERROR, \
493− 0))
494−
495−/*
496− * Token initializers.
497− */
498−
499−#define TOKEN_INIT(token,token_type,token_start_mark,token_end_mark) \
500− (memset(&(token), 0, sizeof(yaml_token_t)), \
501− (token).type = (token_type), \
502− (token).start_mark = (token_start_mark), \
503− (token).end_mark = (token_end_mark))
504−
505−#define STREAM_START_TOKEN_INIT(token,token_encoding,start_mark,end_mark) \
506− (TOKEN_INIT((token),YAML_STREAM_START_TOKEN,(start_mark),(end_mark)), \
507− (token).data.stream_start.encoding = (token_encoding))
508−
509−#define STREAM_END_TOKEN_INIT(token,start_mark,end_mark) \
510− (TOKEN_INIT((token),YAML_STREAM_END_TOKEN,(start_mark),(end_mark)))
511−
512−#define ALIAS_TOKEN_INIT(token,token_value,start_mark,end_mark) \
513− (TOKEN_INIT((token),YAML_ALIAS_TOKEN,(start_mark),(end_mark)), \
514− (token).data.alias.value = (token_value))
515−
516−#define ANCHOR_TOKEN_INIT(token,token_value,start_mark,end_mark) \
517− (TOKEN_INIT((token),YAML_ANCHOR_TOKEN,(start_mark),(end_mark)), \
518− (token).data.anchor.value = (token_value))
519−
520−#define TAG_TOKEN_INIT(token,token_handle,token_suffix,start_mark,end_mark) \
521− (TOKEN_INIT((token),YAML_TAG_TOKEN,(start_mark),(end_mark)), \
522− (token).data.tag.handle = (token_handle), \
523− (token).data.tag.suffix = (token_suffix))
524−
525−#define SCALAR_TOKEN_INIT(token,token_value,token_length,token_style,start_mark,end_mark) \
526− (TOKEN_INIT((token),YAML_SCALAR_TOKEN,(start_mark),(end_mark)), \
527− (token).data.scalar.value = (token_value), \
528− (token).data.scalar.length = (token_length), \
529− (token).data.scalar.style = (token_style))
530−
531−#define VERSION_DIRECTIVE_TOKEN_INIT(token,token_major,token_minor,start_mark,end_mark) \
532− (TOKEN_INIT((token),YAML_VERSION_DIRECTIVE_TOKEN,(start_mark),(end_mark)), \
533− (token).data.version_directive.major = (token_major), \
534− (token).data.version_directive.minor = (token_minor))
535−
536−#define TAG_DIRECTIVE_TOKEN_INIT(token,token_handle,token_prefix,start_mark,end_mark) \
537− (TOKEN_INIT((token),YAML_TAG_DIRECTIVE_TOKEN,(start_mark),(end_mark)), \
538− (token).data.tag_directive.handle = (token_handle), \
539− (token).data.tag_directive.prefix = (token_prefix))
540−
541−/*
542− * Event initializers.
543− */
544−
545−#define EVENT_INIT(event,event_type,event_start_mark,event_end_mark) \
546− (memset(&(event), 0, sizeof(yaml_event_t)), \
547− (event).type = (event_type), \
548− (event).start_mark = (event_start_mark), \
549− (event).end_mark = (event_end_mark))
550−
551−#define STREAM_START_EVENT_INIT(event,event_encoding,start_mark,end_mark) \
552− (EVENT_INIT((event),YAML_STREAM_START_EVENT,(start_mark),(end_mark)), \
553− (event).data.stream_start.encoding = (event_encoding))
554−
555−#define STREAM_END_EVENT_INIT(event,start_mark,end_mark) \
556− (EVENT_INIT((event),YAML_STREAM_END_EVENT,(start_mark),(end_mark)))
557−
558−#define DOCUMENT_START_EVENT_INIT(event,event_version_directive, \
559− event_tag_directives_start,event_tag_directives_end,event_implicit,start_mark,end_mark) \
560− (EVENT_INIT((event),YAML_DOCUMENT_START_EVENT,(start_mark),(end_mark)), \
561− (event).data.document_start.version_directive = (event_version_directive), \
562− (event).data.document_start.tag_directives.start = (event_tag_directives_start), \
563− (event).data.document_start.tag_directives.end = (event_tag_directives_end), \
564− (event).data.document_start.implicit = (event_implicit))
565−
566−#define DOCUMENT_END_EVENT_INIT(event,event_implicit,start_mark,end_mark) \
567− (EVENT_INIT((event),YAML_DOCUMENT_END_EVENT,(start_mark),(end_mark)), \
568− (event).data.document_end.implicit = (event_implicit))
569−
570−#define ALIAS_EVENT_INIT(event,event_anchor,start_mark,end_mark) \
571− (EVENT_INIT((event),YAML_ALIAS_EVENT,(start_mark),(end_mark)), \
572− (event).data.alias.anchor = (event_anchor))
573−
574−#define SCALAR_EVENT_INIT(event,event_anchor,event_tag,event_value,event_length, \
575− event_plain_implicit, event_quoted_implicit,event_style,start_mark,end_mark) \
576− (EVENT_INIT((event),YAML_SCALAR_EVENT,(start_mark),(end_mark)), \
577− (event).data.scalar.anchor = (event_anchor), \
578− (event).data.scalar.tag = (event_tag), \
579− (event).data.scalar.value = (event_value), \
580− (event).data.scalar.length = (event_length), \
581− (event).data.scalar.plain_implicit = (event_plain_implicit), \
582− (event).data.scalar.quoted_implicit = (event_quoted_implicit), \
583− (event).data.scalar.style = (event_style))
584−
585−#define SEQUENCE_START_EVENT_INIT(event,event_anchor,event_tag, \
586− event_implicit,event_style,start_mark,end_mark) \
587− (EVENT_INIT((event),YAML_SEQUENCE_START_EVENT,(start_mark),(end_mark)), \
588− (event).data.sequence_start.anchor = (event_anchor), \
589− (event).data.sequence_start.tag = (event_tag), \
590− (event).data.sequence_start.implicit = (event_implicit), \
591− (event).data.sequence_start.style = (event_style))
592−
593−#define SEQUENCE_END_EVENT_INIT(event,start_mark,end_mark) \
594− (EVENT_INIT((event),YAML_SEQUENCE_END_EVENT,(start_mark),(end_mark)))
595−
596−#define MAPPING_START_EVENT_INIT(event,event_anchor,event_tag, \
597− event_implicit,event_style,start_mark,end_mark) \
598− (EVENT_INIT((event),YAML_MAPPING_START_EVENT,(start_mark),(end_mark)), \
599− (event).data.mapping_start.anchor = (event_anchor), \
600− (event).data.mapping_start.tag = (event_tag), \
601− (event).data.mapping_start.implicit = (event_implicit), \
602− (event).data.mapping_start.style = (event_style))
603−
604−#define MAPPING_END_EVENT_INIT(event,start_mark,end_mark) \
605− (EVENT_INIT((event),YAML_MAPPING_END_EVENT,(start_mark),(end_mark)))
606−
607−/*
608− * Document initializer.
609− */
610−
611−#define DOCUMENT_INIT(document,document_nodes_start,document_nodes_end, \
612− document_version_directive,document_tag_directives_start, \
613− document_tag_directives_end,document_start_implicit, \
614− document_end_implicit,document_start_mark,document_end_mark) \
615− (memset(&(document), 0, sizeof(yaml_document_t)), \
616− (document).nodes.start = (document_nodes_start), \
617− (document).nodes.end = (document_nodes_end), \
618− (document).nodes.top = (document_nodes_start), \
619− (document).version_directive = (document_version_directive), \
620− (document).tag_directives.start = (document_tag_directives_start), \
621− (document).tag_directives.end = (document_tag_directives_end), \
622− (document).start_implicit = (document_start_implicit), \
623− (document).end_implicit = (document_end_implicit), \
624− (document).start_mark = (document_start_mark), \
625− (document).end_mark = (document_end_mark))
626−
627−/*
628− * Node initializers.
629− */
630−
631−#define NODE_INIT(node,node_type,node_tag,node_start_mark,node_end_mark) \
632− (memset(&(node), 0, sizeof(yaml_node_t)), \
633− (node).type = (node_type), \
634− (node).tag = (node_tag), \
635− (node).start_mark = (node_start_mark), \
636− (node).end_mark = (node_end_mark))
637−
638−#define SCALAR_NODE_INIT(node,node_tag,node_value,node_length, \
639− node_style,start_mark,end_mark) \
640− (NODE_INIT((node),YAML_SCALAR_NODE,(node_tag),(start_mark),(end_mark)), \
641− (node).data.scalar.value = (node_value), \
642− (node).data.scalar.length = (node_length), \
643− (node).data.scalar.style = (node_style))
644−
645−#define SEQUENCE_NODE_INIT(node,node_tag,node_items_start,node_items_end, \
646− node_style,start_mark,end_mark) \
647− (NODE_INIT((node),YAML_SEQUENCE_NODE,(node_tag),(start_mark),(end_mark)), \
648− (node).data.sequence.items.start = (node_items_start), \
649− (node).data.sequence.items.end = (node_items_end), \
650− (node).data.sequence.items.top = (node_items_start), \
651− (node).data.sequence.style = (node_style))
652−
653−#define MAPPING_NODE_INIT(node,node_tag,node_pairs_start,node_pairs_end, \
654− node_style,start_mark,end_mark) \
655− (NODE_INIT((node),YAML_MAPPING_NODE,(node_tag),(start_mark),(end_mark)), \
656− (node).data.mapping.pairs.start = (node_pairs_start), \
657− (node).data.mapping.pairs.end = (node_pairs_end), \
658− (node).data.mapping.pairs.top = (node_pairs_start), \
659− (node).data.mapping.style = (node_style))
660−
661−/* Strict C compiler warning helpers */
662−
663−#if defined(__clang__) || defined(__GNUC__)
664−# define HASATTRIBUTE_UNUSED
665−#endif
666−#ifdef HASATTRIBUTE_UNUSED
667−# define __attribute__unused__ __attribute__((__unused__))
668−#else
669−# define __attribute__unused__
670−#endif
671−
672−/* Shim arguments are arguments that must be included in your function,
673− * but serve no purpose inside. Silence compiler warnings. */
674−#define SHIM(a) /*@unused@*/ a __attribute__unused__
675−
676−/* UNUSED_PARAM() marks a shim argument in the body to silence compiler warnings */
677−#ifdef __clang__
678−# define UNUSED_PARAM(a) (void)(a);
679−#else
680−# define UNUSED_PARAM(a) /*@-noeffect*/if (0) (void)(a)/*@=noeffect*/;
681−#endif
682−
683−#define YAML_MALLOC_STATIC(type) (type*)yaml_malloc(sizeof(type))
684−#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size)
685−
686−/* For Haskell yaml package, since we do not use the configure script */
687−#define YAML_VERSION_STRING "0.2.2"
688−#define YAML_VERSION_MAJOR 0
689−#define YAML_VERSION_MINOR 2
690−#define YAML_VERSION_PATCH 2
libyaml/package.yaml+6−17
@@ -1,5 +1,5 @@
11name: libyaml
2−version: 0.1.3
2+version: 0.1.4
33synopsis: Low-level, streaming YAML interface.
44description: README and API documentation are available at <https://www.stackage.org/package/libyaml>
55category: Text
@@ -11,9 +11,6 @@ stability: stable
1111
1212extra-source-files:
1313- include/helper.h
14−- libyaml_src/yaml_private.h
15−- libyaml_src/yaml.h
16−- libyaml_src/LICENSE
1714- README.md
1815- ChangeLog.md
1916
@@ -28,7 +25,7 @@ flags:
2825 default: false
2926
3027dependencies:
31−- base >=4.9.1 && <5 # GHC 8.0.2 and later
28+- base >=4.14 && <5 # GHC 8.10.1 and later
3229- bytestring >=0.9.1.4
3330- conduit >=1.2.8 && <1.4
3431- resourcet >=0.3 && <1.4
@@ -44,19 +41,11 @@ library:
4441 cpp-options: -D__NO_UNICODE__
4542 - condition: ! '!(flag(system-libyaml))'
4643 then:
47− c-sources:
48− - libyaml_src/api.c
49− - libyaml_src/dumper.c
50− - libyaml_src/emitter.c
51− - libyaml_src/loader.c
52− - libyaml_src/parser.c
53− - libyaml_src/reader.c
54− - libyaml_src/scanner.c
55− - libyaml_src/writer.c
56− include-dirs:
57− - libyaml_src
44+ dependencies:
45+ - libyaml-clib
5846 else:
59− extra-libraries: yaml
47+ pkg-config-dependencies:
48+ - yaml-0.1
6049 - condition: os(windows)
6150 cpp-options: -DWINDOWS
6251 dependencies:
libyaml/src/Text/Libyaml.hs+1−1
@@ -776,7 +776,7 @@ encodeWith opts =
776776 close _ fbuf = withForeignPtr fbuf $ \b -> do
777777 ptr' <- c_get_buffer_buff b
778778 len <- c_get_buffer_used b
779− fptr <- newForeignPtr_ $ castPtr ptr'
779+ fptr <- newForeignPtr finalizerFree $ castPtr ptr'
780780 return $ B.fromForeignPtr fptr 0 $ fromIntegral len
781781
782782
libyaml/vendor/libyamldeleted−1

Submodule changed.

stack.yaml+4−1
@@ -1,4 +1,4 @@
1−resolver: nightly-2023-07-10
1+resolver: lts-22.13
22
33flags:
44 yaml:
@@ -7,3 +7,6 @@ flags:
77packages:
88 - yaml
99 - libyaml
10+
11+extra-deps:
12+ - libyaml-clib-0.2.5
yaml/package.yaml+1−1
@@ -34,7 +34,7 @@ flags:
3434 default: true
3535
3636dependencies:
37−- base >=4.9.1 && <5 # GHC 8.0.2 and later, meaning that Data.Semigroup is in base
37+- base >=4.14 && <5 # GHC 8.10.1 and later
3838- bytestring >=0.9.1.4
3939- transformers >=0.1
4040- mtl
yaml/src/Data/Yaml/Config.hs+6−1
@@ -5,7 +5,7 @@
55-- In particular, merging environment variables with yaml values
66--
77-- 'loadYamlSettings' is a high-level API for loading YAML and merging environment variables.
8−-- A yaml value of @_env:ENV_VAR:default@ will lookup the environment variable @ENV_VAR@.
8+-- A yaml value of @_env:ENV_VAR:default@ or just @_env:ENV_VAR@ will lookup the environment variable @ENV_VAR@.
99--
1010-- On a historical note, this code was taken directly from the yesod web framework's configuration module.
1111module Data.Yaml.Config
@@ -185,6 +185,11 @@ requireCustomEnv = RequireCustomEnv
185185--
186186-- > loadYamlSettings ["config/foo.yaml"] [] useEnv
187187--
188+-- Alternatively you can configure settings through the Yaml @Value@ directly in Haskell.
189+-- For example, to load up settings from only from environment variables, you can use:
190+--
191+-- > loadYamlSettings [] [object ["connectionString" .= ("_env:DATABASE_URL" :: String)]] requireEnv
192+--
188193-- @since 0.8.16
189194loadYamlSettings
190195 :: FromJSON settings