diff --git a/Makefile b/Makefile
index b4891dc2f9a6ccfbeb701a6e9d8473b30d1832ca..10ebfcd4fd6cc78dd78e599f6c6bdbed920af59e 100644
--- a/Makefile
+++ b/Makefile
@@ -65,6 +65,7 @@ TARGETS=\
kilo \
libmodbus \
libspng \
+ libyaml \
microstrain \
mini-gmp \
miniz \
diff --git a/README.md b/README.md
index 25d4b47786a6beb42b9f012bdccd94754313f420..9e9c7550aca2ba46656f4b0b3fccefc2c99d2058 100644
--- a/README.md
+++ b/README.md
@@ -137,6 +137,7 @@ when available. We also summarize the license of each directory below.
(see https://github.com/antirez/kilo/blob/master/LICENSE)
- `libmodbus`: LGPL
- `libspng`: BSD 2-clause, see `LICENSE`
+- `libyaml`: MIT, see `License`
- `mibench`: several (see `LICENSE` file inside each subdirectory)
- `mini-gmp`: LGPL or GPL
- `miniz`: MIT
diff --git a/libyaml/.frama-c/GNUmakefile b/libyaml/.frama-c/GNUmakefile
new file mode 100644
index 0000000000000000000000000000000000000000..b4fab5df565db07fda6ec9235ba9f32786a163ae
--- /dev/null
+++ b/libyaml/.frama-c/GNUmakefile
@@ -0,0 +1,100 @@
+# Makefile template for Frama-C/Eva case studies.
+# For details and usage information, see the Frama-C User Manual.
+
+### Prologue. Do not modify this block. #######################################
+-include path.mk
+FRAMAC ?= frama-c
+include $(shell $(FRAMAC)-config -print-share-path)/analysis-scripts/prologue.mk
+###############################################################################
+
+# Edit below as needed. Suggested flags are optional.
+
+MACHDEP = x86_64
+
+## Preprocessing flags (for -cpp-extra-args)
+CPPFLAGS += \
+ -I../include \
+ -DHAVE_CONFIG_H \
+ -DYAML_DECLARE_STATIC \
+
+## General flags
+FCFLAGS += \
+ -add-symbolic-path=..:. \
+ -kernel-warn-key annot:missing-spec=abort \
+ -kernel-warn-key typing:implicit-function-declaration=abort \
+
+## Eva-specific flags
+EVAFLAGS += \
+ -eva-warn-key builtins:missing-spec=abort \
+
+## GUI-only flags
+FCGUIFLAGS += \
+
+## Analysis targets (suffixed with .eva)
+TARGETS = \
+ test-reader.eva \
+ test-version.eva \
+
+# TODO: modify handling of dynamic memory allocation to speed up these tests
+# run-dumper.eva \
+# run-emitter.eva \
+# run-parser-test-suite.eva \
+# run-scanner.eva \
+
+COMMON_SRCS=\
+ ../src/api.c \
+ ../src/dumper.c \
+ ../src/emitter.c \
+ ../src/loader.c \
+ ../src/parser.c \
+ ../src/reader.c \
+ ../src/scanner.c \
+ ../src/writer.c \
+
+### Each target <t>.eva needs a rule <t>.parse with source files as prerequisites
+run-dumper.parse: \
+ $(COMMON_SRCS) \
+ fc_stubs.c \
+ ../tests/run-dumper.c \
+
+run-emitter.parse: \
+ $(COMMON_SRCS) \
+ fc_stubs.c \
+ ../tests/run-emitter.c \
+
+run-emitter-test-suite.parse: \
+ $(COMMON_SRCS) \
+ fc_stubs.c \
+ ../tests/run-emitter-test-suite.c \
+
+run-parser.parse: \
+ $(COMMON_SRCS) \
+ fc_stubs.c \
+ ../tests/run-parser.c \
+
+run-parser-test-suite.parse: \
+ $(COMMON_SRCS) \
+ fc_stubs.c \
+ ../tests/run-parser-test-suite.c \
+
+run-scanner.parse: \
+ $(COMMON_SRCS) \
+ fc_stubs.c \
+ ../tests/run-scanner.c \
+
+run-*.parse: FCFLAGS += -main eva_main
+
+test-reader.parse: \
+ $(COMMON_SRCS) \
+ ../tests/test-reader.c \
+
+test-version.parse: \
+ $(COMMON_SRCS) \
+ ../tests/test-version.c \
+
+### Epilogue. Do not modify this block. #######################################
+include $(shell $(FRAMAC)-config -print-share-path)/analysis-scripts/epilogue.mk
+###############################################################################
+
+# optional, for OSCS
+-include ../../Makefile.common
diff --git a/libyaml/.frama-c/fc_stubs.c b/libyaml/.frama-c/fc_stubs.c
new file mode 100644
index 0000000000000000000000000000000000000000..fad866f2160ba5533c8658794a520c2bf0880962
--- /dev/null
+++ b/libyaml/.frama-c/fc_stubs.c
@@ -0,0 +1,23 @@
+// Stub for a main function which reads arguments from the command line, to be
+// used by the Eva plug-in.
+// This stub emulates non-deterministic input of up to 5 arguments, each up
+// to 256 characters long. This is sufficient to ensure arbitrary input in
+// virtually every case.
+// Do not forget to add option '-main eva_main' in order to use this stub.
+
+#ifdef __FRAMAC__
+# include "__fc_builtin.h"
+int main(int, char **);
+static volatile int nondet;
+int eva_main() {
+ int argc = Frama_C_interval(0, 5);
+ char argv0[256], argv1[256], argv2[256], argv3[256], argv4[256];
+ char *argv[6] = {argv0, argv1, argv2, argv3, argv4, 0};
+ //@ loop unroll 5;
+ for (int i = 0; i < 5; i++) {
+ Frama_C_make_unknown(argv[i], 255);
+ argv[i][255] = 0;
+ }
+ return main(argc, argv);
+}
+#endif // __FRAMAC__
diff --git a/libyaml/.frama-c/path.mk b/libyaml/.frama-c/path.mk
new file mode 120000
index 0000000000000000000000000000000000000000..57620d6d4816c69648f7a48a2ab302665cd5ac66
--- /dev/null
+++ b/libyaml/.frama-c/path.mk
@@ -0,0 +1 @@
+../../path.mk
\ No newline at end of file
diff --git a/libyaml/.frama-c/test-reader.eva/alarms.csv b/libyaml/.frama-c/test-reader.eva/alarms.csv
new file mode 100644
index 0000000000000000000000000000000000000000..4246c28b385aaf60709ebddc68d85672c662d24e
--- /dev/null
+++ b/libyaml/.frama-c/test-reader.eva/alarms.csv
@@ -0,0 +1,148 @@
+directory file line function property kind status property
+FRAMAC_SHARE/libc assert.h 31 __FC_assert precondition Unknown nonnull_c: c ≢ 0
+FRAMAC_SHARE/libc string.h 55 memcmp precondition Unknown valid_s1: valid_read_or_empty(s1, n)
+FRAMAC_SHARE/libc string.h 57 memcmp precondition Unknown initialization: s1: \initialized((char *)s1 + (0 .. n - 1))
+FRAMAC_SHARE/libc string.h 59 memcmp precondition Unknown danglingness: s1: non_escaping(s1, n)
+FRAMAC_SHARE/libc string.h 92 memcpy precondition Unknown valid_dest: valid_or_empty(dest, n)
+FRAMAC_SHARE/libc string.h 93 memcpy precondition Unknown valid_src: valid_read_or_empty(src, n)
+FRAMAC_SHARE/libc string.h 104 memmove precondition Unknown valid_dest: valid_or_empty(dest, n)
+FRAMAC_SHARE/libc string.h 105 memmove precondition Unknown valid_src: valid_read_or_empty(src, n)
+src api.c 235 yaml_parser_delete mem_access Invalid or unreachable \valid_read(parser->tag_directives.top)
+src api.c 254 yaml_string_read_handler ptr_comparison Unknown \pointer_comparable((void *)parser->input.string.current, (void *)parser->input.string.end)
+src api.c 259 yaml_string_read_handler differing_blocks Unknown \base_addr(parser->input.string.end) ≡ \base_addr(parser->input.string.current)
+src api.c 259 yaml_string_read_handler signed_overflow Unknown -9223372036854775808 ≤ parser->input.string.end - parser->input.string.current
+src api.c 259 yaml_string_read_handler signed_overflow Unknown parser->input.string.end - parser->input.string.current ≤ 9223372036854775807
+src api.c 264 yaml_string_read_handler precondition of memcpy Unknown valid_dest: valid_or_empty(dest, n)
+src api.c 264 yaml_string_read_handler precondition of memcpy Unknown valid_src: valid_read_or_empty(src, n)
+src api.c 586 yaml_token_delete precondition of __FC_assert Unknown nonnull_c: c ≢ 0
+src api.c 588 yaml_token_delete initialization Invalid or unreachable \initialized(&token->type)
+src reader.c 56 yaml_parser_determine_encoding dangling_pointer Unknown ¬\dangling(&parser->raw_buffer.last)
+src reader.c 56 yaml_parser_determine_encoding differing_blocks Unknown \base_addr(parser->raw_buffer.last) ≡ \base_addr(parser->raw_buffer.pointer)
+src reader.c 56 yaml_parser_determine_encoding signed_overflow Unknown -9223372036854775808 ≤ parser->raw_buffer.last - parser->raw_buffer.pointer
+src reader.c 56 yaml_parser_determine_encoding signed_overflow Unknown parser->raw_buffer.last - parser->raw_buffer.pointer ≤ 9223372036854775807
+src reader.c 64 yaml_parser_determine_encoding dangling_pointer Unknown ¬\dangling(&parser->raw_buffer.last)
+src reader.c 64 yaml_parser_determine_encoding differing_blocks Unknown \base_addr(parser->raw_buffer.last) ≡ \base_addr(parser->raw_buffer.pointer)
+src reader.c 64 yaml_parser_determine_encoding signed_overflow Unknown -9223372036854775808 ≤ parser->raw_buffer.last - parser->raw_buffer.pointer
+src reader.c 64 yaml_parser_determine_encoding signed_overflow Unknown parser->raw_buffer.last - parser->raw_buffer.pointer ≤ 9223372036854775807
+src reader.c 65 yaml_parser_determine_encoding precondition of memcmp Unknown danglingness: s1: non_escaping(s1, n)
+src reader.c 65 yaml_parser_determine_encoding precondition of memcmp Unknown initialization: s1: \initialized((char *)s1 + (0 .. n - 1))
+src reader.c 65 yaml_parser_determine_encoding precondition of memcmp Unknown valid_s1: valid_read_or_empty(s1, n)
+src reader.c 71 yaml_parser_determine_encoding precondition of memcmp Unknown danglingness: s1: non_escaping(s1, n)
+src reader.c 71 yaml_parser_determine_encoding precondition of memcmp Unknown initialization: s1: \initialized((char *)s1 + (0 .. n - 1))
+src reader.c 71 yaml_parser_determine_encoding precondition of memcmp Unknown valid_s1: valid_read_or_empty(s1, n)
+src reader.c 77 yaml_parser_determine_encoding precondition of memcmp Unknown danglingness: s1: non_escaping(s1, n)
+src reader.c 77 yaml_parser_determine_encoding precondition of memcmp Unknown initialization: s1: \initialized((char *)s1 + (0 .. n - 1))
+src reader.c 77 yaml_parser_determine_encoding precondition of memcmp Unknown valid_s1: valid_read_or_empty(s1, n)
+src reader.c 100 yaml_parser_update_raw_buffer ptr_comparison Unknown \pointer_comparable((void *)parser->raw_buffer.start, (void *)parser->raw_buffer.pointer)
+src reader.c 101 yaml_parser_update_raw_buffer dangling_pointer Unknown ¬\dangling(&parser->raw_buffer.last)
+src reader.c 101 yaml_parser_update_raw_buffer ptr_comparison Unknown \pointer_comparable((void *)parser->raw_buffer.last, (void *)parser->raw_buffer.end)
+src reader.c 111 yaml_parser_update_raw_buffer dangling_pointer Unknown ¬\dangling(&parser->raw_buffer.last)
+src reader.c 111 yaml_parser_update_raw_buffer ptr_comparison Unknown \pointer_comparable((void *)parser->raw_buffer.pointer, (void *)parser->raw_buffer.last)
+src reader.c 112 yaml_parser_update_raw_buffer precondition of memmove Unknown valid_dest: valid_or_empty(dest, n)
+src reader.c 112 yaml_parser_update_raw_buffer precondition of memmove Unknown valid_src: valid_read_or_empty(src, n)
+src reader.c 113 yaml_parser_update_raw_buffer differing_blocks Unknown \base_addr(parser->raw_buffer.last) ≡ \base_addr(parser->raw_buffer.pointer)
+src reader.c 113 yaml_parser_update_raw_buffer signed_overflow Unknown -9223372036854775808 ≤ parser->raw_buffer.last - parser->raw_buffer.pointer
+src reader.c 113 yaml_parser_update_raw_buffer signed_overflow Unknown parser->raw_buffer.last - parser->raw_buffer.pointer ≤ 9223372036854775807
+src reader.c 115 yaml_parser_update_raw_buffer dangling_pointer Unknown ¬\dangling(&parser->raw_buffer.last)
+src reader.c 116 yaml_parser_update_raw_buffer differing_blocks Unknown \base_addr(parser->raw_buffer.pointer) ≡ \base_addr(parser->raw_buffer.start)
+src reader.c 116 yaml_parser_update_raw_buffer signed_overflow Unknown parser->raw_buffer.pointer - parser->raw_buffer.start ≤ 9223372036854775807
+src reader.c 122 yaml_parser_update_raw_buffer differing_blocks Unknown \base_addr(parser->raw_buffer.end) ≡ \base_addr(parser->raw_buffer.last)
+src reader.c 122 yaml_parser_update_raw_buffer signed_overflow Unknown -9223372036854775808 ≤ parser->raw_buffer.end - parser->raw_buffer.last
+src reader.c 122 yaml_parser_update_raw_buffer signed_overflow Unknown parser->raw_buffer.end - parser->raw_buffer.last ≤ 9223372036854775807
+src reader.c 150 yaml_parser_update_buffer dangling_pointer Unknown ¬\dangling(&parser->raw_buffer.last)
+src reader.c 150 yaml_parser_update_buffer ptr_comparison Unknown \pointer_comparable((void *)parser->raw_buffer.pointer, (void *)parser->raw_buffer.last)
+src reader.c 167 yaml_parser_update_buffer ptr_comparison Unknown \pointer_comparable((void *)parser->buffer.start, (void *)parser->buffer.pointer)
+src reader.c 168 yaml_parser_update_buffer dangling_pointer Unknown ¬\dangling(&parser->buffer.last)
+src reader.c 168 yaml_parser_update_buffer ptr_comparison Unknown \pointer_comparable((void *)parser->buffer.pointer, (void *)parser->buffer.last)
+src reader.c 169 yaml_parser_update_buffer differing_blocks Unknown \base_addr(parser->buffer.last) ≡ \base_addr(parser->buffer.pointer)
+src reader.c 169 yaml_parser_update_buffer signed_overflow Unknown parser->buffer.last - parser->buffer.pointer ≤ 9223372036854775807
+src reader.c 170 yaml_parser_update_buffer precondition of memmove Unknown valid_dest: valid_or_empty(dest, n)
+src reader.c 170 yaml_parser_update_buffer precondition of memmove Unknown valid_src: valid_read_or_empty(src, n)
+src reader.c 174 yaml_parser_update_buffer dangling_pointer Unknown ¬\dangling(&parser->buffer.last)
+src reader.c 174 yaml_parser_update_buffer ptr_comparison Unknown \pointer_comparable((void *)parser->buffer.pointer, (void *)parser->buffer.last)
+src reader.c 185 yaml_parser_update_buffer dangling_pointer Unknown ¬\dangling(&parser->raw_buffer.last)
+src reader.c 185 yaml_parser_update_buffer ptr_comparison Unknown \pointer_comparable((void *)parser->raw_buffer.pointer, (void *)parser->raw_buffer.last)
+src reader.c 192 yaml_parser_update_buffer dangling_pointer Unknown ¬\dangling(&parser->raw_buffer.last)
+src reader.c 192 yaml_parser_update_buffer ptr_comparison Unknown \pointer_comparable((void *)parser->raw_buffer.pointer, (void *)parser->raw_buffer.last)
+src reader.c 200 yaml_parser_update_buffer differing_blocks Unknown \base_addr(parser->raw_buffer.last) ≡ \base_addr(parser->raw_buffer.pointer)
+src reader.c 200 yaml_parser_update_buffer signed_overflow Unknown -9223372036854775808 ≤ parser->raw_buffer.last - parser->raw_buffer.pointer
+src reader.c 200 yaml_parser_update_buffer signed_overflow Unknown parser->raw_buffer.last - parser->raw_buffer.pointer ≤ 9223372036854775807
+src reader.c 230 yaml_parser_update_buffer initialization Unknown \initialized(parser->raw_buffer.pointer + 0)
+src reader.c 230 yaml_parser_update_buffer mem_access Unknown \valid_read(parser->raw_buffer.pointer + 0)
+src reader.c 266 yaml_parser_update_buffer initialization Unknown \initialized(parser->raw_buffer.pointer + k)
+src reader.c 266 yaml_parser_update_buffer mem_access Unknown \valid_read(parser->raw_buffer.pointer + k)
+src reader.c 345 yaml_parser_update_buffer initialization Unknown \initialized(parser->raw_buffer.pointer + high)
+src reader.c 345 yaml_parser_update_buffer initialization Unknown \initialized(parser->raw_buffer.pointer + low)
+src reader.c 345 yaml_parser_update_buffer mem_access Unknown \valid_read(parser->raw_buffer.pointer + high)
+src reader.c 345 yaml_parser_update_buffer mem_access Unknown \valid_read(parser->raw_buffer.pointer + low)
+src reader.c 375 yaml_parser_update_buffer initialization Unknown \initialized(parser->raw_buffer.pointer + (int)(high + 2))
+src reader.c 375 yaml_parser_update_buffer initialization Unknown \initialized(parser->raw_buffer.pointer + (int)(low + 2))
+src reader.c 375 yaml_parser_update_buffer mem_access Unknown \valid_read(parser->raw_buffer.pointer + (int)(high + 2))
+src reader.c 375 yaml_parser_update_buffer mem_access Unknown \valid_read(parser->raw_buffer.pointer + (int)(low + 2))
+src reader.c 429 yaml_parser_update_buffer mem_access Unknown \valid(tmp_17)
+src reader.c 433 yaml_parser_update_buffer mem_access Unknown \valid(tmp_18)
+src reader.c 434 yaml_parser_update_buffer mem_access Unknown \valid(tmp_19)
+src reader.c 438 yaml_parser_update_buffer mem_access Unknown \valid(tmp_20)
+src reader.c 439 yaml_parser_update_buffer mem_access Unknown \valid(tmp_21)
+src reader.c 440 yaml_parser_update_buffer mem_access Unknown \valid(tmp_22)
+src reader.c 444 yaml_parser_update_buffer mem_access Unknown \valid(tmp_23)
+src reader.c 445 yaml_parser_update_buffer mem_access Unknown \valid(tmp_24)
+src reader.c 446 yaml_parser_update_buffer mem_access Unknown \valid(tmp_25)
+src reader.c 447 yaml_parser_update_buffer mem_access Unknown \valid(tmp_26)
+src reader.c 456 yaml_parser_update_buffer mem_access Unknown \valid(tmp_27)
+tests test-reader.c 131 check_utf8_sequences mem_access Unknown \valid_read(end)
+tests test-reader.c 133 check_utf8_sequences differing_blocks Unknown \base_addr(end) ≡ \base_addr(start)
+tests test-reader.c 137 check_utf8_sequences signed_overflow Unknown failed + 1 ≤ 2147483647
+tests test-reader.c 147 check_utf8_sequences precondition of printf_va_6 Unknown valid_read_string(param0)
+tests test-reader.c 147 printf_va_6 precondition Unknown valid_read_string(param0)
+tests test-reader.c 151 check_utf8_sequences precondition of printf_va_7 Unknown valid_read_string(param0)
+tests test-reader.c 151 printf_va_7 precondition Unknown valid_read_string(param0)
+tests test-reader.c 177 check_boms mem_access Unknown \valid_read(end)
+tests test-reader.c 180 check_boms differing_blocks Unknown \base_addr(end) ≡ \base_addr(start)
+tests test-reader.c 183 check_boms precondition of printf_va_12 Unknown valid_read_string(param0)
+tests test-reader.c 183 printf_va_12 precondition Unknown valid_read_string(param0)
+tests test-reader.c 184 check_boms signed_overflow Unknown failed + 1 ≤ 2147483647
+tests test-reader.c 189 check_boms signed_overflow Unknown failed + 1 ≤ 2147483647
+tests test-reader.c 191 check_boms precondition of memcmp Unknown danglingness: s1: non_escaping(s1, n)
+tests test-reader.c 191 check_boms precondition of memcmp Unknown initialization: s1: \initialized((char *)s1 + (0 .. n - 1))
+tests test-reader.c 191 check_boms precondition of memcmp Unknown valid_s1: valid_read_or_empty(s1, n)
+tests test-reader.c 192 check_boms precondition of printf_va_14 Unknown valid_read_string(param0)
+tests test-reader.c 192 printf_va_14 precondition Unknown valid_read_string(param0)
+tests test-reader.c 193 check_boms signed_overflow Unknown failed + 1 ≤ 2147483647
+tests test-reader.c 215 check_long_utf8 precondition of __FC_assert Unknown nonnull_c: c ≢ 0
+tests test-reader.c 222 check_long_utf8 signed_overflow Unknown k + 1 ≤ 2147483647
+tests test-reader.c 222 check_long_utf8 mem_access Unknown \valid(buffer + tmp_3)
+tests test-reader.c 223 check_long_utf8 mem_access Unknown \valid(buffer + tmp_4)
+tests test-reader.c 226 check_long_utf8 signed_overflow Unknown k + 1 ≤ 2147483647
+tests test-reader.c 226 check_long_utf8 mem_access Unknown \valid(buffer + tmp_5)
+tests test-reader.c 227 check_long_utf8 mem_access Unknown \valid(buffer + tmp_6)
+tests test-reader.c 235 check_long_utf8 precondition of printf_va_18 Unknown valid_read_string(param0)
+tests test-reader.c 235 printf_va_18 precondition Unknown valid_read_string(param0)
+tests test-reader.c 253 check_long_utf8 initialization Unknown \initialized(parser.buffer.pointer + 0)
+tests test-reader.c 253 check_long_utf8 mem_access Unknown \valid_read(parser.buffer.pointer + 0)
+tests test-reader.c 253 check_long_utf8 initialization Unknown \initialized(parser.buffer.pointer + 1)
+tests test-reader.c 254 check_long_utf8 initialization Unknown \initialized(parser.buffer.pointer + 1)
+tests test-reader.c 265 check_long_utf8 precondition of printf_va_22 Unknown valid_read_string(param0)
+tests test-reader.c 265 printf_va_22 precondition Unknown valid_read_string(param0)
+tests test-reader.c 268 check_long_utf8 initialization Unknown \initialized(parser.buffer.pointer + 0)
+tests test-reader.c 268 check_long_utf8 mem_access Unknown \valid_read(parser.buffer.pointer + 0)
+tests test-reader.c 287 check_long_utf16 precondition of __FC_assert Unknown nonnull_c: c ≢ 0
+tests test-reader.c 293 check_long_utf16 mem_access Unknown \valid(buffer + tmp_2)
+tests test-reader.c 294 check_long_utf16 signed_overflow Unknown k + 1 ≤ 2147483647
+tests test-reader.c 294 check_long_utf16 mem_access Unknown \valid(buffer + tmp_3)
+tests test-reader.c 297 check_long_utf16 mem_access Unknown \valid(buffer + tmp_4)
+tests test-reader.c 298 check_long_utf16 signed_overflow Unknown k + 1 ≤ 2147483647
+tests test-reader.c 298 check_long_utf16 mem_access Unknown \valid(buffer + tmp_5)
+tests test-reader.c 306 check_long_utf16 precondition of printf_va_25 Unknown valid_read_string(param0)
+tests test-reader.c 306 printf_va_25 precondition Unknown valid_read_string(param0)
+tests test-reader.c 324 check_long_utf16 initialization Unknown \initialized(parser.buffer.pointer + 0)
+tests test-reader.c 324 check_long_utf16 mem_access Unknown \valid_read(parser.buffer.pointer + 0)
+tests test-reader.c 324 check_long_utf16 initialization Unknown \initialized(parser.buffer.pointer + 1)
+tests test-reader.c 325 check_long_utf16 initialization Unknown \initialized(parser.buffer.pointer + 1)
+tests test-reader.c 336 check_long_utf16 precondition of printf_va_29 Unknown valid_read_string(param0)
+tests test-reader.c 336 printf_va_29 precondition Unknown valid_read_string(param0)
+tests test-reader.c 339 check_long_utf16 initialization Unknown \initialized(parser.buffer.pointer + 0)
+tests test-reader.c 339 check_long_utf16 mem_access Unknown \valid_read(parser.buffer.pointer + 0)
+tests test-reader.c 353 main signed_overflow Unknown (int)((int)(tmp + tmp_0) + tmp_1) + tmp_2 ≤ 2147483647
+tests test-reader.c 353 main signed_overflow Unknown (int)(tmp + tmp_0) + tmp_1 ≤ 2147483647
+tests test-reader.c 353 main signed_overflow Unknown tmp + tmp_0 ≤ 2147483647
diff --git a/libyaml/.frama-c/test-reader.eva/metrics.log b/libyaml/.frama-c/test-reader.eva/metrics.log
new file mode 100644
index 0000000000000000000000000000000000000000..5a1da3e1a084528a396e89cedd6498646dfaa811
--- /dev/null
+++ b/libyaml/.frama-c/test-reader.eva/metrics.log
@@ -0,0 +1,26 @@
+[metrics] Eva coverage statistics
+=======================
+Syntactically reachable functions = 16 (out of 199)
+Semantically reached functions = 16
+Coverage estimation = 100.0%
+[metrics] References to non-analyzed functions
+------------------------------------
+[metrics] Statements analyzed by Eva
+--------------------------
+946 stmts in analyzed functions, 913 stmts analyzed (96.5%)
+check_boms: 34 stmts out of 34 (100.0%)
+check_long_utf16: 80 stmts out of 80 (100.0%)
+check_long_utf8: 84 stmts out of 84 (100.0%)
+check_utf8_sequences: 43 stmts out of 43 (100.0%)
+main: 7 stmts out of 7 (100.0%)
+yaml_free: 3 stmts out of 3 (100.0%)
+yaml_parser_initialize: 207 stmts out of 207 (100.0%)
+yaml_parser_set_input_string: 9 stmts out of 9 (100.0%)
+yaml_parser_set_reader_error: 6 stmts out of 6 (100.0%)
+yaml_string_read_handler: 13 stmts out of 13 (100.0%)
+yaml_parser_delete: 102 stmts out of 104 (98.1%)
+yaml_parser_update_buffer: 262 stmts out of 270 (97.0%)
+yaml_parser_determine_encoding: 35 stmts out of 38 (92.1%)
+yaml_parser_update_raw_buffer: 22 stmts out of 26 (84.6%)
+yaml_malloc: 4 stmts out of 5 (80.0%)
+yaml_token_delete: 2 stmts out of 17 (11.8%)
diff --git a/libyaml/.frama-c/test-reader.eva/nonterm.log b/libyaml/.frama-c/test-reader.eva/nonterm.log
new file mode 100644
index 0000000000000000000000000000000000000000..06a27c32f961d2fcc44e0d2159729d5c4b40371e
--- /dev/null
+++ b/libyaml/.frama-c/test-reader.eva/nonterm.log
@@ -0,0 +1,30 @@
+src/api.c:235:[nonterm] warning: non-terminating statement
+stack 1: yaml_parser_delete :: tests/test-reader.c:157 <-
+ check_utf8_sequences :: tests/test-reader.c:353 <-
+ main
+stack 2: yaml_parser_delete :: tests/test-reader.c:199 <-
+ check_boms :: tests/test-reader.c:353 <-
+ main
+stack 3: yaml_parser_delete :: tests/test-reader.c:273 <-
+ check_long_utf8 :: tests/test-reader.c:353 <-
+ main
+stack 4: yaml_parser_delete :: tests/test-reader.c:344 <-
+ check_long_utf16 :: tests/test-reader.c:353 <-
+ main
+src/api.c:588:[nonterm] warning: non-terminating switch
+stack 1: yaml_token_delete :: src/api.c:227 <-
+ yaml_parser_delete :: tests/test-reader.c:157 <-
+ check_utf8_sequences :: tests/test-reader.c:353 <-
+ main
+stack 2: yaml_token_delete :: src/api.c:227 <-
+ yaml_parser_delete :: tests/test-reader.c:199 <-
+ check_boms :: tests/test-reader.c:353 <-
+ main
+stack 3: yaml_token_delete :: src/api.c:227 <-
+ yaml_parser_delete :: tests/test-reader.c:273 <-
+ check_long_utf8 :: tests/test-reader.c:353 <-
+ main
+stack 4: yaml_token_delete :: src/api.c:227 <-
+ yaml_parser_delete :: tests/test-reader.c:344 <-
+ check_long_utf16 :: tests/test-reader.c:353 <-
+ main
diff --git a/libyaml/.frama-c/test-reader.eva/warnings.log b/libyaml/.frama-c/test-reader.eva/warnings.log
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/libyaml/.frama-c/test-reader.parse/framac.ast b/libyaml/.frama-c/test-reader.parse/framac.ast
new file mode 100644
index 0000000000000000000000000000000000000000..355de491ed912bd067157a9a1dc52856c24a91f5
--- /dev/null
+++ b/libyaml/.frama-c/test-reader.parse/framac.ast
@@ -0,0 +1,23480 @@
+/* Generated by Frama-C */
+#include "assert.h"
+#include "errno.h"
+#include "stdarg.h"
+#include "stddef.h"
+#include "stdio.h"
+#include "stdlib.h"
+#include "string.h"
+#include "strings.h"
+typedef unsigned char yaml_char_t;
+struct yaml_version_directive_s {
+ int major ;
+ int minor ;
+};
+typedef struct yaml_version_directive_s yaml_version_directive_t;
+struct yaml_tag_directive_s {
+ yaml_char_t *handle ;
+ yaml_char_t *prefix ;
+};
+typedef struct yaml_tag_directive_s yaml_tag_directive_t;
+enum yaml_encoding_e {
+ YAML_ANY_ENCODING = 0,
+ YAML_UTF8_ENCODING = 1,
+ YAML_UTF16LE_ENCODING = 2,
+ YAML_UTF16BE_ENCODING = 3
+};
+typedef enum yaml_encoding_e yaml_encoding_t;
+enum yaml_break_e {
+ YAML_ANY_BREAK = 0,
+ YAML_CR_BREAK = 1,
+ YAML_LN_BREAK = 2,
+ YAML_CRLN_BREAK = 3
+};
+typedef enum yaml_break_e yaml_break_t;
+enum yaml_error_type_e {
+ YAML_NO_ERROR = 0,
+ YAML_MEMORY_ERROR = 1,
+ YAML_READER_ERROR = 2,
+ YAML_SCANNER_ERROR = 3,
+ YAML_PARSER_ERROR = 4,
+ YAML_COMPOSER_ERROR = 5,
+ YAML_WRITER_ERROR = 6,
+ YAML_EMITTER_ERROR = 7
+};
+typedef enum yaml_error_type_e yaml_error_type_t;
+struct yaml_mark_s {
+ size_t index ;
+ size_t line ;
+ size_t column ;
+};
+typedef struct yaml_mark_s yaml_mark_t;
+enum yaml_scalar_style_e {
+ YAML_ANY_SCALAR_STYLE = 0,
+ YAML_PLAIN_SCALAR_STYLE = 1,
+ YAML_SINGLE_QUOTED_SCALAR_STYLE = 2,
+ YAML_DOUBLE_QUOTED_SCALAR_STYLE = 3,
+ YAML_LITERAL_SCALAR_STYLE = 4,
+ YAML_FOLDED_SCALAR_STYLE = 5
+};
+typedef enum yaml_scalar_style_e yaml_scalar_style_t;
+enum yaml_sequence_style_e {
+ YAML_ANY_SEQUENCE_STYLE = 0,
+ YAML_BLOCK_SEQUENCE_STYLE = 1,
+ YAML_FLOW_SEQUENCE_STYLE = 2
+};
+typedef enum yaml_sequence_style_e yaml_sequence_style_t;
+enum yaml_mapping_style_e {
+ YAML_ANY_MAPPING_STYLE = 0,
+ YAML_BLOCK_MAPPING_STYLE = 1,
+ YAML_FLOW_MAPPING_STYLE = 2
+};
+typedef enum yaml_mapping_style_e yaml_mapping_style_t;
+enum yaml_token_type_e {
+ YAML_NO_TOKEN = 0,
+ YAML_STREAM_START_TOKEN = 1,
+ YAML_STREAM_END_TOKEN = 2,
+ YAML_VERSION_DIRECTIVE_TOKEN = 3,
+ YAML_TAG_DIRECTIVE_TOKEN = 4,
+ YAML_DOCUMENT_START_TOKEN = 5,
+ YAML_DOCUMENT_END_TOKEN = 6,
+ YAML_BLOCK_SEQUENCE_START_TOKEN = 7,
+ YAML_BLOCK_MAPPING_START_TOKEN = 8,
+ YAML_BLOCK_END_TOKEN = 9,
+ YAML_FLOW_SEQUENCE_START_TOKEN = 10,
+ YAML_FLOW_SEQUENCE_END_TOKEN = 11,
+ YAML_FLOW_MAPPING_START_TOKEN = 12,
+ YAML_FLOW_MAPPING_END_TOKEN = 13,
+ YAML_BLOCK_ENTRY_TOKEN = 14,
+ YAML_FLOW_ENTRY_TOKEN = 15,
+ YAML_KEY_TOKEN = 16,
+ YAML_VALUE_TOKEN = 17,
+ YAML_ALIAS_TOKEN = 18,
+ YAML_ANCHOR_TOKEN = 19,
+ YAML_TAG_TOKEN = 20,
+ YAML_SCALAR_TOKEN = 21
+};
+typedef enum yaml_token_type_e yaml_token_type_t;
+struct __anonstruct_stream_start_2 {
+ yaml_encoding_t encoding ;
+};
+struct __anonstruct_alias_3 {
+ yaml_char_t *value ;
+};
+struct __anonstruct_anchor_4 {
+ yaml_char_t *value ;
+};
+struct __anonstruct_tag_5 {
+ yaml_char_t *handle ;
+ yaml_char_t *suffix ;
+};
+struct __anonstruct_scalar_6 {
+ yaml_char_t *value ;
+ size_t length ;
+ yaml_scalar_style_t style ;
+};
+struct __anonstruct_version_directive_7 {
+ int major ;
+ int minor ;
+};
+struct __anonstruct_tag_directive_8 {
+ yaml_char_t *handle ;
+ yaml_char_t *prefix ;
+};
+union __anonunion_data_1 {
+ struct __anonstruct_stream_start_2 stream_start ;
+ struct __anonstruct_alias_3 alias ;
+ struct __anonstruct_anchor_4 anchor ;
+ struct __anonstruct_tag_5 tag ;
+ struct __anonstruct_scalar_6 scalar ;
+ struct __anonstruct_version_directive_7 version_directive ;
+ struct __anonstruct_tag_directive_8 tag_directive ;
+};
+struct yaml_token_s {
+ yaml_token_type_t type ;
+ union __anonunion_data_1 data ;
+ yaml_mark_t start_mark ;
+ yaml_mark_t end_mark ;
+};
+typedef struct yaml_token_s yaml_token_t;
+enum yaml_event_type_e {
+ YAML_NO_EVENT = 0,
+ YAML_STREAM_START_EVENT = 1,
+ YAML_STREAM_END_EVENT = 2,
+ YAML_DOCUMENT_START_EVENT = 3,
+ YAML_DOCUMENT_END_EVENT = 4,
+ YAML_ALIAS_EVENT = 5,
+ YAML_SCALAR_EVENT = 6,
+ YAML_SEQUENCE_START_EVENT = 7,
+ YAML_SEQUENCE_END_EVENT = 8,
+ YAML_MAPPING_START_EVENT = 9,
+ YAML_MAPPING_END_EVENT = 10
+};
+typedef enum yaml_event_type_e yaml_event_type_t;
+struct __anonstruct_stream_start_10 {
+ yaml_encoding_t encoding ;
+};
+struct __anonstruct_tag_directives_12 {
+ yaml_tag_directive_t *start ;
+ yaml_tag_directive_t *end ;
+};
+struct __anonstruct_document_start_11 {
+ yaml_version_directive_t *version_directive ;
+ struct __anonstruct_tag_directives_12 tag_directives ;
+ int implicit ;
+};
+struct __anonstruct_document_end_13 {
+ int implicit ;
+};
+struct __anonstruct_alias_14 {
+ yaml_char_t *anchor ;
+};
+struct __anonstruct_scalar_15 {
+ yaml_char_t *anchor ;
+ yaml_char_t *tag ;
+ yaml_char_t *value ;
+ size_t length ;
+ int plain_implicit ;
+ int quoted_implicit ;
+ yaml_scalar_style_t style ;
+};
+struct __anonstruct_sequence_start_16 {
+ yaml_char_t *anchor ;
+ yaml_char_t *tag ;
+ int implicit ;
+ yaml_sequence_style_t style ;
+};
+struct __anonstruct_mapping_start_17 {
+ yaml_char_t *anchor ;
+ yaml_char_t *tag ;
+ int implicit ;
+ yaml_mapping_style_t style ;
+};
+union __anonunion_data_9 {
+ struct __anonstruct_stream_start_10 stream_start ;
+ struct __anonstruct_document_start_11 document_start ;
+ struct __anonstruct_document_end_13 document_end ;
+ struct __anonstruct_alias_14 alias ;
+ struct __anonstruct_scalar_15 scalar ;
+ struct __anonstruct_sequence_start_16 sequence_start ;
+ struct __anonstruct_mapping_start_17 mapping_start ;
+};
+struct yaml_event_s {
+ yaml_event_type_t type ;
+ union __anonunion_data_9 data ;
+ yaml_mark_t start_mark ;
+ yaml_mark_t end_mark ;
+};
+typedef struct yaml_event_s yaml_event_t;
+enum yaml_node_type_e {
+ YAML_NO_NODE = 0,
+ YAML_SCALAR_NODE = 1,
+ YAML_SEQUENCE_NODE = 2,
+ YAML_MAPPING_NODE = 3
+};
+typedef enum yaml_node_type_e yaml_node_type_t;
+struct yaml_node_s;
+typedef struct yaml_node_s yaml_node_t;
+typedef int yaml_node_item_t;
+struct yaml_node_pair_s {
+ int key ;
+ int value ;
+};
+typedef struct yaml_node_pair_s yaml_node_pair_t;
+struct __anonstruct_scalar_19 {
+ yaml_char_t *value ;
+ size_t length ;
+ yaml_scalar_style_t style ;
+};
+struct __anonstruct_items_21 {
+ yaml_node_item_t *start ;
+ yaml_node_item_t *end ;
+ yaml_node_item_t *top ;
+};
+struct __anonstruct_sequence_20 {
+ struct __anonstruct_items_21 items ;
+ yaml_sequence_style_t style ;
+};
+struct __anonstruct_pairs_23 {
+ yaml_node_pair_t *start ;
+ yaml_node_pair_t *end ;
+ yaml_node_pair_t *top ;
+};
+struct __anonstruct_mapping_22 {
+ struct __anonstruct_pairs_23 pairs ;
+ yaml_mapping_style_t style ;
+};
+union __anonunion_data_18 {
+ struct __anonstruct_scalar_19 scalar ;
+ struct __anonstruct_sequence_20 sequence ;
+ struct __anonstruct_mapping_22 mapping ;
+};
+struct yaml_node_s {
+ yaml_node_type_t type ;
+ yaml_char_t *tag ;
+ union __anonunion_data_18 data ;
+ yaml_mark_t start_mark ;
+ yaml_mark_t end_mark ;
+};
+struct __anonstruct_nodes_24 {
+ yaml_node_t *start ;
+ yaml_node_t *end ;
+ yaml_node_t *top ;
+};
+struct __anonstruct_tag_directives_25 {
+ yaml_tag_directive_t *start ;
+ yaml_tag_directive_t *end ;
+};
+struct yaml_document_s {
+ struct __anonstruct_nodes_24 nodes ;
+ yaml_version_directive_t *version_directive ;
+ struct __anonstruct_tag_directives_25 tag_directives ;
+ int start_implicit ;
+ int end_implicit ;
+ yaml_mark_t start_mark ;
+ yaml_mark_t end_mark ;
+};
+typedef struct yaml_document_s yaml_document_t;
+typedef int yaml_read_handler_t(void *data, unsigned char *buffer,
+ size_t size, size_t *size_read);
+struct yaml_simple_key_s {
+ int possible ;
+ int required ;
+ size_t token_number ;
+ yaml_mark_t mark ;
+};
+typedef struct yaml_simple_key_s yaml_simple_key_t;
+enum yaml_parser_state_e {
+ YAML_PARSE_STREAM_START_STATE = 0,
+ YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE = 1,
+ YAML_PARSE_DOCUMENT_START_STATE = 2,
+ YAML_PARSE_DOCUMENT_CONTENT_STATE = 3,
+ YAML_PARSE_DOCUMENT_END_STATE = 4,
+ YAML_PARSE_BLOCK_NODE_STATE = 5,
+ YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE = 6,
+ YAML_PARSE_FLOW_NODE_STATE = 7,
+ YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE = 8,
+ YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE = 9,
+ YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE = 10,
+ YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE = 11,
+ YAML_PARSE_BLOCK_MAPPING_KEY_STATE = 12,
+ YAML_PARSE_BLOCK_MAPPING_VALUE_STATE = 13,
+ YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE = 14,
+ YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE = 15,
+ YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE = 16,
+ YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE = 17,
+ YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE = 18,
+ YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE = 19,
+ YAML_PARSE_FLOW_MAPPING_KEY_STATE = 20,
+ YAML_PARSE_FLOW_MAPPING_VALUE_STATE = 21,
+ YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE = 22,
+ YAML_PARSE_END_STATE = 23
+};
+typedef enum yaml_parser_state_e yaml_parser_state_t;
+struct yaml_alias_data_s {
+ yaml_char_t *anchor ;
+ int index ;
+ yaml_mark_t mark ;
+};
+typedef struct yaml_alias_data_s yaml_alias_data_t;
+struct __anonstruct_string_27 {
+ unsigned char const *start ;
+ unsigned char const *end ;
+ unsigned char const *current ;
+};
+union __anonunion_input_26 {
+ struct __anonstruct_string_27 string ;
+ FILE *file ;
+};
+struct __anonstruct_buffer_28 {
+ yaml_char_t *start ;
+ yaml_char_t *end ;
+ yaml_char_t *pointer ;
+ yaml_char_t *last ;
+};
+struct __anonstruct_raw_buffer_29 {
+ unsigned char *start ;
+ unsigned char *end ;
+ unsigned char *pointer ;
+ unsigned char *last ;
+};
+struct __anonstruct_tokens_30 {
+ yaml_token_t *start ;
+ yaml_token_t *end ;
+ yaml_token_t *head ;
+ yaml_token_t *tail ;
+};
+struct __anonstruct_indents_31 {
+ int *start ;
+ int *end ;
+ int *top ;
+};
+struct __anonstruct_simple_keys_32 {
+ yaml_simple_key_t *start ;
+ yaml_simple_key_t *end ;
+ yaml_simple_key_t *top ;
+};
+struct __anonstruct_states_33 {
+ yaml_parser_state_t *start ;
+ yaml_parser_state_t *end ;
+ yaml_parser_state_t *top ;
+};
+struct __anonstruct_marks_34 {
+ yaml_mark_t *start ;
+ yaml_mark_t *end ;
+ yaml_mark_t *top ;
+};
+struct __anonstruct_tag_directives_35 {
+ yaml_tag_directive_t *start ;
+ yaml_tag_directive_t *end ;
+ yaml_tag_directive_t *top ;
+};
+struct __anonstruct_aliases_36 {
+ yaml_alias_data_t *start ;
+ yaml_alias_data_t *end ;
+ yaml_alias_data_t *top ;
+};
+struct yaml_parser_s {
+ yaml_error_type_t error ;
+ char const *problem ;
+ size_t problem_offset ;
+ int problem_value ;
+ yaml_mark_t problem_mark ;
+ char const *context ;
+ yaml_mark_t context_mark ;
+ yaml_read_handler_t *read_handler ;
+ void *read_handler_data ;
+ union __anonunion_input_26 input ;
+ int eof ;
+ struct __anonstruct_buffer_28 buffer ;
+ size_t unread ;
+ struct __anonstruct_raw_buffer_29 raw_buffer ;
+ yaml_encoding_t encoding ;
+ size_t offset ;
+ yaml_mark_t mark ;
+ int stream_start_produced ;
+ int stream_end_produced ;
+ int flow_level ;
+ struct __anonstruct_tokens_30 tokens ;
+ size_t tokens_parsed ;
+ int token_available ;
+ struct __anonstruct_indents_31 indents ;
+ int indent ;
+ int simple_key_allowed ;
+ struct __anonstruct_simple_keys_32 simple_keys ;
+ struct __anonstruct_states_33 states ;
+ yaml_parser_state_t state ;
+ struct __anonstruct_marks_34 marks ;
+ struct __anonstruct_tag_directives_35 tag_directives ;
+ struct __anonstruct_aliases_36 aliases ;
+ yaml_document_t *document ;
+};
+typedef struct yaml_parser_s yaml_parser_t;
+typedef int yaml_write_handler_t(void *data, unsigned char *buffer,
+ size_t size);
+enum yaml_emitter_state_e {
+ YAML_EMIT_STREAM_START_STATE = 0,
+ YAML_EMIT_FIRST_DOCUMENT_START_STATE = 1,
+ YAML_EMIT_DOCUMENT_START_STATE = 2,
+ YAML_EMIT_DOCUMENT_CONTENT_STATE = 3,
+ YAML_EMIT_DOCUMENT_END_STATE = 4,
+ YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE = 5,
+ YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE = 6,
+ YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE = 7,
+ YAML_EMIT_FLOW_MAPPING_KEY_STATE = 8,
+ YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE = 9,
+ YAML_EMIT_FLOW_MAPPING_VALUE_STATE = 10,
+ YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE = 11,
+ YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE = 12,
+ YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE = 13,
+ YAML_EMIT_BLOCK_MAPPING_KEY_STATE = 14,
+ YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE = 15,
+ YAML_EMIT_BLOCK_MAPPING_VALUE_STATE = 16,
+ YAML_EMIT_END_STATE = 17
+};
+typedef enum yaml_emitter_state_e yaml_emitter_state_t;
+struct yaml_anchors_s {
+ int references ;
+ int anchor ;
+ int serialized ;
+};
+typedef struct yaml_anchors_s yaml_anchors_t;
+struct __anonstruct_string_38 {
+ unsigned char *buffer ;
+ size_t size ;
+ size_t *size_written ;
+};
+union __anonunion_output_37 {
+ struct __anonstruct_string_38 string ;
+ FILE *file ;
+};
+struct __anonstruct_buffer_39 {
+ yaml_char_t *start ;
+ yaml_char_t *end ;
+ yaml_char_t *pointer ;
+ yaml_char_t *last ;
+};
+struct __anonstruct_raw_buffer_40 {
+ unsigned char *start ;
+ unsigned char *end ;
+ unsigned char *pointer ;
+ unsigned char *last ;
+};
+struct __anonstruct_states_41 {
+ yaml_emitter_state_t *start ;
+ yaml_emitter_state_t *end ;
+ yaml_emitter_state_t *top ;
+};
+struct __anonstruct_events_42 {
+ yaml_event_t *start ;
+ yaml_event_t *end ;
+ yaml_event_t *head ;
+ yaml_event_t *tail ;
+};
+struct __anonstruct_indents_43 {
+ int *start ;
+ int *end ;
+ int *top ;
+};
+struct __anonstruct_tag_directives_44 {
+ yaml_tag_directive_t *start ;
+ yaml_tag_directive_t *end ;
+ yaml_tag_directive_t *top ;
+};
+struct __anonstruct_anchor_data_45 {
+ yaml_char_t *anchor ;
+ size_t anchor_length ;
+ int alias ;
+};
+struct __anonstruct_tag_data_46 {
+ yaml_char_t *handle ;
+ size_t handle_length ;
+ yaml_char_t *suffix ;
+ size_t suffix_length ;
+};
+struct __anonstruct_scalar_data_47 {
+ yaml_char_t *value ;
+ size_t length ;
+ int multiline ;
+ int flow_plain_allowed ;
+ int block_plain_allowed ;
+ int single_quoted_allowed ;
+ int block_allowed ;
+ yaml_scalar_style_t style ;
+};
+struct yaml_emitter_s {
+ yaml_error_type_t error ;
+ char const *problem ;
+ yaml_write_handler_t *write_handler ;
+ void *write_handler_data ;
+ union __anonunion_output_37 output ;
+ struct __anonstruct_buffer_39 buffer ;
+ struct __anonstruct_raw_buffer_40 raw_buffer ;
+ yaml_encoding_t encoding ;
+ int canonical ;
+ int best_indent ;
+ int best_width ;
+ int unicode ;
+ yaml_break_t line_break ;
+ struct __anonstruct_states_41 states ;
+ yaml_emitter_state_t state ;
+ struct __anonstruct_events_42 events ;
+ struct __anonstruct_indents_43 indents ;
+ struct __anonstruct_tag_directives_44 tag_directives ;
+ int indent ;
+ int flow_level ;
+ int root_context ;
+ int sequence_context ;
+ int mapping_context ;
+ int simple_key_context ;
+ int line ;
+ int column ;
+ int whitespace ;
+ int indention ;
+ int open_ended ;
+ struct __anonstruct_anchor_data_45 anchor_data ;
+ struct __anonstruct_tag_data_46 tag_data ;
+ struct __anonstruct_scalar_data_47 scalar_data ;
+ int opened ;
+ int closed ;
+ yaml_anchors_t *anchors ;
+ int last_anchor_id ;
+ yaml_document_t *document ;
+};
+typedef struct yaml_emitter_s yaml_emitter_t;
+struct __anonstruct_yaml_string_t_48 {
+ yaml_char_t *start ;
+ yaml_char_t *end ;
+ yaml_char_t *pointer ;
+};
+typedef struct __anonstruct_yaml_string_t_48 yaml_string_t;
+struct __anonstruct_context_49 {
+ yaml_error_type_t error ;
+};
+struct __anonstruct_tag_directives_copy_50 {
+ yaml_tag_directive_t *start ;
+ yaml_tag_directive_t *end ;
+ yaml_tag_directive_t *top ;
+};
+struct __anonstruct_context_51 {
+ yaml_error_type_t error ;
+};
+struct __anonstruct_nodes_52 {
+ yaml_node_t *start ;
+ yaml_node_t *end ;
+ yaml_node_t *top ;
+};
+struct __anonstruct_tag_directives_copy_53 {
+ yaml_tag_directive_t *start ;
+ yaml_tag_directive_t *end ;
+ yaml_tag_directive_t *top ;
+};
+struct __anonstruct_context_54 {
+ yaml_error_type_t error ;
+};
+struct __anonstruct_context_55 {
+ yaml_error_type_t error ;
+};
+struct __anonstruct_items_56 {
+ yaml_node_item_t *start ;
+ yaml_node_item_t *end ;
+ yaml_node_item_t *top ;
+};
+struct __anonstruct_context_57 {
+ yaml_error_type_t error ;
+};
+struct __anonstruct_pairs_58 {
+ yaml_node_pair_t *start ;
+ yaml_node_pair_t *end ;
+ yaml_node_pair_t *top ;
+};
+struct __anonstruct_context_59 {
+ yaml_error_type_t error ;
+};
+struct __anonstruct_context_60 {
+ yaml_error_type_t error ;
+};
+struct loader_ctx {
+ int *start ;
+ int *end ;
+ int *top ;
+};
+struct __anonstruct_items_49 {
+ yaml_node_item_t *start ;
+ yaml_node_item_t *end ;
+ yaml_node_item_t *top ;
+};
+struct __anonstruct_pairs_50 {
+ yaml_node_pair_t *start ;
+ yaml_node_pair_t *end ;
+ yaml_node_pair_t *top ;
+};
+struct __anonstruct_tag_directives_49 {
+ yaml_tag_directive_t *start ;
+ yaml_tag_directive_t *end ;
+};
+struct __anonstruct_tag_directives_50 {
+ yaml_tag_directive_t *start ;
+ yaml_tag_directive_t *end ;
+ yaml_tag_directive_t *top ;
+};
+struct __anonstruct_test_case_48 {
+ char *title ;
+ char *test ;
+ int result ;
+};
+typedef struct __anonstruct_test_case_48 test_case;
+char const *yaml_get_version_string(void);
+
+void yaml_get_version(int *major, int *minor, int *patch);
+
+void yaml_token_delete(yaml_token_t *token);
+
+int yaml_stream_start_event_initialize(yaml_event_t *event,
+ yaml_encoding_t encoding);
+
+int yaml_stream_end_event_initialize(yaml_event_t *event);
+
+int yaml_document_start_event_initialize(yaml_event_t *event,
+ yaml_version_directive_t *version_directive,
+ yaml_tag_directive_t *tag_directives_start,
+ yaml_tag_directive_t *tag_directives_end,
+ int implicit);
+
+int yaml_document_end_event_initialize(yaml_event_t *event, int implicit);
+
+int yaml_alias_event_initialize(yaml_event_t *event,
+ yaml_char_t const *anchor);
+
+int yaml_scalar_event_initialize(yaml_event_t *event,
+ yaml_char_t const *anchor,
+ yaml_char_t const *tag,
+ yaml_char_t const *value, int length,
+ int plain_implicit, int quoted_implicit,
+ yaml_scalar_style_t style);
+
+int yaml_sequence_start_event_initialize(yaml_event_t *event,
+ yaml_char_t const *anchor,
+ yaml_char_t const *tag,
+ int implicit,
+ yaml_sequence_style_t style);
+
+int yaml_sequence_end_event_initialize(yaml_event_t *event);
+
+int yaml_mapping_start_event_initialize(yaml_event_t *event,
+ yaml_char_t const *anchor,
+ yaml_char_t const *tag, int implicit,
+ yaml_mapping_style_t style);
+
+int yaml_mapping_end_event_initialize(yaml_event_t *event);
+
+void yaml_event_delete(yaml_event_t *event);
+
+int yaml_document_initialize(yaml_document_t *document,
+ yaml_version_directive_t *version_directive,
+ yaml_tag_directive_t *tag_directives_start,
+ yaml_tag_directive_t *tag_directives_end,
+ int start_implicit, int end_implicit);
+
+void yaml_document_delete(yaml_document_t *document);
+
+yaml_node_t *yaml_document_get_node(yaml_document_t *document, int index_0);
+
+yaml_node_t *yaml_document_get_root_node(yaml_document_t *document);
+
+int yaml_document_add_scalar(yaml_document_t *document,
+ yaml_char_t const *tag,
+ yaml_char_t const *value, int length,
+ yaml_scalar_style_t style);
+
+int yaml_document_add_sequence(yaml_document_t *document,
+ yaml_char_t const *tag,
+ yaml_sequence_style_t style);
+
+int yaml_document_add_mapping(yaml_document_t *document,
+ yaml_char_t const *tag,
+ yaml_mapping_style_t style);
+
+int yaml_document_append_sequence_item(yaml_document_t *document,
+ int sequence, int item);
+
+int yaml_document_append_mapping_pair(yaml_document_t *document, int mapping,
+ int key, int value);
+
+int yaml_parser_initialize(yaml_parser_t *parser);
+
+void yaml_parser_delete(yaml_parser_t *parser);
+
+void yaml_parser_set_input_string(yaml_parser_t *parser,
+ unsigned char const *input, size_t size);
+
+void yaml_parser_set_input_file(yaml_parser_t *parser, FILE *file);
+
+void yaml_parser_set_input(yaml_parser_t *parser,
+ yaml_read_handler_t *handler, void *data);
+
+void yaml_parser_set_encoding(yaml_parser_t *parser, yaml_encoding_t encoding);
+
+int yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token);
+
+int yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event);
+
+int yaml_parser_load(yaml_parser_t *parser, yaml_document_t *document);
+
+int yaml_emitter_initialize(yaml_emitter_t *emitter);
+
+void yaml_emitter_delete(yaml_emitter_t *emitter);
+
+void yaml_emitter_set_output_string(yaml_emitter_t *emitter,
+ unsigned char *output, size_t size,
+ size_t *size_written);
+
+void yaml_emitter_set_output_file(yaml_emitter_t *emitter, FILE *file);
+
+void yaml_emitter_set_output(yaml_emitter_t *emitter,
+ yaml_write_handler_t *handler, void *data);
+
+void yaml_emitter_set_encoding(yaml_emitter_t *emitter,
+ yaml_encoding_t encoding);
+
+void yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical);
+
+void yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent);
+
+void yaml_emitter_set_width(yaml_emitter_t *emitter, int width);
+
+void yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode);
+
+void yaml_emitter_set_break(yaml_emitter_t *emitter, yaml_break_t line_break);
+
+int yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event);
+
+int yaml_emitter_open(yaml_emitter_t *emitter);
+
+int yaml_emitter_close(yaml_emitter_t *emitter);
+
+int yaml_emitter_dump(yaml_emitter_t *emitter, yaml_document_t *document);
+
+int yaml_emitter_flush(yaml_emitter_t *emitter);
+
+void *yaml_malloc(size_t size);
+
+void *yaml_realloc(void *ptr, size_t size);
+
+void yaml_free(void *ptr);
+
+yaml_char_t *yaml_strdup(yaml_char_t const *str);
+
+int yaml_parser_update_buffer(yaml_parser_t *parser, size_t length);
+
+int yaml_parser_fetch_more_tokens(yaml_parser_t *parser);
+
+int yaml_string_extend(yaml_char_t **start, yaml_char_t **pointer,
+ yaml_char_t **end);
+
+int yaml_string_join(yaml_char_t **a_start, yaml_char_t **a_pointer,
+ yaml_char_t **a_end, yaml_char_t **b_start,
+ yaml_char_t **b_pointer,
+ yaml_char_t **b_end __attribute__((__unused__)));
+
+int yaml_stack_extend(void **start, void **top, void **end);
+
+int yaml_queue_extend(void **start, void **head, void **tail, void **end);
+
+char const *yaml_get_version_string(void)
+{
+ char const *__retres;
+ __retres = "0.2.5";
+ return __retres;
+}
+
+void yaml_get_version(int *major, int *minor, int *patch)
+{
+ *major = 0;
+ *minor = 2;
+ *patch = 5;
+ return;
+}
+
+void *yaml_malloc(size_t size)
+{
+ void *tmp_0;
+ size_t tmp;
+ if (size) tmp = size; else tmp = (unsigned long)1;
+ tmp_0 = malloc(tmp);
+ return tmp_0;
+}
+
+void *yaml_realloc(void *ptr, size_t size)
+{
+ void *tmp_3;
+ if (ptr) {
+ void *tmp_0;
+ size_t tmp;
+ if (size) tmp = size; else tmp = (unsigned long)1;
+ ;
+ tmp_0 = realloc(ptr,tmp);
+ tmp_3 = tmp_0;
+ }
+ else {
+ void *tmp_2;
+ size_t tmp_1;
+ if (size) tmp_1 = size; else tmp_1 = (unsigned long)1;
+ tmp_2 = malloc(tmp_1);
+ tmp_3 = tmp_2;
+ }
+ return tmp_3;
+}
+
+void yaml_free(void *ptr)
+{
+ if (ptr) free(ptr);
+ return;
+}
+
+yaml_char_t *yaml_strdup(yaml_char_t const *str)
+{
+ yaml_char_t *__retres;
+ yaml_char_t *tmp;
+ if (! str) {
+ __retres = (yaml_char_t *)0;
+ goto return_label;
+ }
+ tmp = (yaml_char_t *)strdup((char const *)str);
+ __retres = tmp;
+ return_label: return __retres;
+}
+
+int yaml_string_extend(yaml_char_t **start, yaml_char_t **pointer,
+ yaml_char_t **end)
+{
+ int __retres;
+ yaml_char_t *new_start =
+ yaml_realloc((void *)*start,(unsigned long)((*end - *start) * (long)2));
+ if (! new_start) {
+ __retres = 0;
+ goto return_label;
+ }
+ memset((void *)(new_start + (*end - *start)),0,
+ (unsigned long)(*end - *start));
+ *pointer = new_start + (*pointer - *start);
+ *end = new_start + (*end - *start) * (long)2;
+ *start = new_start;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+int yaml_string_join(yaml_char_t **a_start, yaml_char_t **a_pointer,
+ yaml_char_t **a_end, yaml_char_t **b_start,
+ yaml_char_t **b_pointer,
+ yaml_char_t **b_end __attribute__((__unused__)))
+{
+ int __retres;
+ if (*b_start == *b_pointer) {
+ __retres = 1;
+ goto return_label;
+ }
+ while (*a_end - *a_pointer <= *b_pointer - *b_start) {
+ int tmp;
+ tmp = yaml_string_extend(a_start,a_pointer,a_end);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ memcpy((void *)*a_pointer,(void const *)*b_start,
+ (unsigned long)(*b_pointer - *b_start));
+ *a_pointer += *b_pointer - *b_start;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+int yaml_stack_extend(void **start, void **top, void **end)
+{
+ int __retres;
+ void *new_start;
+ if ((char *)*end - (char *)*start >= (long)(2147483647 / 2)) {
+ __retres = 0;
+ goto return_label;
+ }
+ new_start = yaml_realloc(*start,
+ (unsigned long)(((char *)*end - (char *)*start) * (long)2));
+ if (! new_start) {
+ __retres = 0;
+ goto return_label;
+ }
+ *top = (void *)((char *)new_start + ((char *)*top - (char *)*start));
+ *end = (void *)((char *)new_start + ((char *)*end - (char *)*start) * (long)2);
+ *start = new_start;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+int yaml_queue_extend(void **start, void **head, void **tail, void **end)
+{
+ int __retres;
+ if (*start == *head)
+ if (*tail == *end) {
+ void *new_start =
+ yaml_realloc(*start,
+ (unsigned long)(((char *)*end - (char *)*start) * (long)2));
+ if (! new_start) {
+ __retres = 0;
+ goto return_label;
+ }
+ *head = (void *)((char *)new_start + ((char *)*head - (char *)*start));
+ *tail = (void *)((char *)new_start + ((char *)*tail - (char *)*start));
+ *end = (void *)((char *)new_start + ((char *)*end - (char *)*start) * (long)2);
+ *start = new_start;
+ }
+ if (*tail == *end) {
+ if (*head != *tail) memmove(*start,(void const *)*head,
+ (unsigned long)((char *)*tail - (char *)*head));
+ *tail = (void *)((char *)*start + ((char *)*tail - (char *)*head));
+ *head = *start;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+int yaml_parser_initialize(yaml_parser_t *parser)
+{
+ int __retres;
+ int tmp_2;
+ unsigned char *tmp;
+ int tmp_6;
+ yaml_char_t *tmp_3;
+ int tmp_10;
+ yaml_token_t *tmp_7;
+ int tmp_13;
+ int *tmp_11;
+ int tmp_16;
+ yaml_simple_key_t *tmp_14;
+ int tmp_19;
+ yaml_parser_state_t *tmp_17;
+ int tmp_22;
+ yaml_mark_t *tmp_20;
+ int tmp_25;
+ yaml_tag_directive_t *tmp_23;
+ unsigned char *tmp_27;
+ unsigned char *tmp_26;
+ yaml_char_t *tmp_29;
+ yaml_char_t *tmp_28;
+ yaml_token_t *tmp_32;
+ yaml_token_t *tmp_31;
+ yaml_token_t *tmp_30;
+ int *tmp_34;
+ int *tmp_33;
+ yaml_simple_key_t *tmp_36;
+ yaml_simple_key_t *tmp_35;
+ yaml_parser_state_t *tmp_38;
+ yaml_parser_state_t *tmp_37;
+ yaml_mark_t *tmp_40;
+ yaml_mark_t *tmp_39;
+ yaml_tag_directive_t *tmp_42;
+ yaml_tag_directive_t *tmp_41;
+ __FC_assert(parser != (yaml_parser_t *)0,"src/api.c",179,"parser");
+ memset((void *)parser,0,sizeof(yaml_parser_t));
+ tmp = (unsigned char *)yaml_malloc((unsigned long)16384);
+ parser->raw_buffer.start = tmp;
+ if (tmp) {
+ unsigned char *tmp_1;
+ tmp_1 = parser->raw_buffer.start;
+ parser->raw_buffer.pointer = tmp_1;
+ parser->raw_buffer.last = tmp_1;
+ parser->raw_buffer.end = parser->raw_buffer.start + 16384;
+ tmp_2 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ if (! tmp_2) goto error;
+ tmp_3 = (yaml_char_t *)yaml_malloc((unsigned long)(16384 * 3));
+ parser->buffer.start = tmp_3;
+ if (tmp_3) {
+ yaml_char_t *tmp_5;
+ tmp_5 = parser->buffer.start;
+ parser->buffer.pointer = tmp_5;
+ parser->buffer.last = tmp_5;
+ parser->buffer.end = parser->buffer.start + 16384 * 3;
+ tmp_6 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_6 = 0;
+ }
+ if (! tmp_6) goto error;
+ tmp_7 = (yaml_token_t *)yaml_malloc((unsigned long)16 * sizeof(*(parser->tokens.start)));
+ parser->tokens.start = tmp_7;
+ if (tmp_7) {
+ yaml_token_t *tmp_9;
+ tmp_9 = parser->tokens.start;
+ parser->tokens.tail = tmp_9;
+ parser->tokens.head = tmp_9;
+ parser->tokens.end = parser->tokens.start + 16;
+ tmp_10 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_10 = 0;
+ }
+ if (! tmp_10) goto error;
+ tmp_11 = (int *)yaml_malloc((unsigned long)16 * sizeof(*(parser->indents.start)));
+ parser->indents.start = tmp_11;
+ if (tmp_11) {
+ parser->indents.top = parser->indents.start;
+ parser->indents.end = parser->indents.start + 16;
+ tmp_13 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_13 = 0;
+ }
+ if (! tmp_13) goto error;
+ tmp_14 = (yaml_simple_key_t *)yaml_malloc((unsigned long)16 * sizeof(*(parser->simple_keys.start)));
+ parser->simple_keys.start = tmp_14;
+ if (tmp_14) {
+ parser->simple_keys.top = parser->simple_keys.start;
+ parser->simple_keys.end = parser->simple_keys.start + 16;
+ tmp_16 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_16 = 0;
+ }
+ if (! tmp_16) goto error;
+ tmp_17 = (yaml_parser_state_t *)yaml_malloc((unsigned long)16 * sizeof(*(parser->states.start)));
+ parser->states.start = tmp_17;
+ if (tmp_17) {
+ parser->states.top = parser->states.start;
+ parser->states.end = parser->states.start + 16;
+ tmp_19 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_19 = 0;
+ }
+ if (! tmp_19) goto error;
+ tmp_20 = (yaml_mark_t *)yaml_malloc((unsigned long)16 * sizeof(*(parser->marks.start)));
+ parser->marks.start = tmp_20;
+ if (tmp_20) {
+ parser->marks.top = parser->marks.start;
+ parser->marks.end = parser->marks.start + 16;
+ tmp_22 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_22 = 0;
+ }
+ if (! tmp_22) goto error;
+ tmp_23 = (yaml_tag_directive_t *)yaml_malloc((unsigned long)16 * sizeof(*(parser->tag_directives.start)));
+ parser->tag_directives.start = tmp_23;
+ if (tmp_23) {
+ parser->tag_directives.top = parser->tag_directives.start;
+ parser->tag_directives.end = parser->tag_directives.start + 16;
+ tmp_25 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_25 = 0;
+ }
+ if (! tmp_25) goto error;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)parser->raw_buffer.start);
+ tmp_27 = (unsigned char *)0;
+ parser->raw_buffer.end = tmp_27;
+ tmp_26 = tmp_27;
+ parser->raw_buffer.pointer = tmp_26;
+ parser->raw_buffer.start = tmp_26;
+ yaml_free((void *)parser->buffer.start);
+ tmp_29 = (yaml_char_t *)0;
+ parser->buffer.end = tmp_29;
+ tmp_28 = tmp_29;
+ parser->buffer.pointer = tmp_28;
+ parser->buffer.start = tmp_28;
+ yaml_free((void *)parser->tokens.start);
+ tmp_32 = (yaml_token_t *)0;
+ parser->tokens.end = tmp_32;
+ tmp_31 = tmp_32;
+ parser->tokens.tail = tmp_31;
+ tmp_30 = tmp_31;
+ parser->tokens.head = tmp_30;
+ parser->tokens.start = tmp_30;
+ yaml_free((void *)parser->indents.start);
+ tmp_34 = (int *)0;
+ parser->indents.end = tmp_34;
+ tmp_33 = tmp_34;
+ parser->indents.top = tmp_33;
+ parser->indents.start = tmp_33;
+ yaml_free((void *)parser->simple_keys.start);
+ tmp_36 = (yaml_simple_key_t *)0;
+ parser->simple_keys.end = tmp_36;
+ tmp_35 = tmp_36;
+ parser->simple_keys.top = tmp_35;
+ parser->simple_keys.start = tmp_35;
+ yaml_free((void *)parser->states.start);
+ tmp_38 = (yaml_parser_state_t *)0;
+ parser->states.end = tmp_38;
+ tmp_37 = tmp_38;
+ parser->states.top = tmp_37;
+ parser->states.start = tmp_37;
+ yaml_free((void *)parser->marks.start);
+ tmp_40 = (yaml_mark_t *)0;
+ parser->marks.end = tmp_40;
+ tmp_39 = tmp_40;
+ parser->marks.top = tmp_39;
+ parser->marks.start = tmp_39;
+ yaml_free((void *)parser->tag_directives.start);
+ tmp_42 = (yaml_tag_directive_t *)0;
+ parser->tag_directives.end = tmp_42;
+ tmp_41 = tmp_42;
+ parser->tag_directives.top = tmp_41;
+ parser->tag_directives.start = tmp_41;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+void yaml_parser_delete(yaml_parser_t *parser)
+{
+ unsigned char *tmp_0;
+ unsigned char *tmp;
+ yaml_char_t *tmp_2;
+ yaml_char_t *tmp_1;
+ yaml_token_t *tmp_6;
+ yaml_token_t *tmp_5;
+ yaml_token_t *tmp_4;
+ int *tmp_8;
+ int *tmp_7;
+ yaml_simple_key_t *tmp_10;
+ yaml_simple_key_t *tmp_9;
+ yaml_parser_state_t *tmp_12;
+ yaml_parser_state_t *tmp_11;
+ yaml_mark_t *tmp_14;
+ yaml_mark_t *tmp_13;
+ yaml_tag_directive_t *tmp_16;
+ yaml_tag_directive_t *tmp_15;
+ __FC_assert(parser != (yaml_parser_t *)0,"src/api.c",222,"parser");
+ yaml_free((void *)parser->raw_buffer.start);
+ tmp_0 = (unsigned char *)0;
+ parser->raw_buffer.end = tmp_0;
+ tmp = tmp_0;
+ parser->raw_buffer.pointer = tmp;
+ parser->raw_buffer.start = tmp;
+ yaml_free((void *)parser->buffer.start);
+ tmp_2 = (yaml_char_t *)0;
+ parser->buffer.end = tmp_2;
+ tmp_1 = tmp_2;
+ parser->buffer.pointer = tmp_1;
+ parser->buffer.start = tmp_1;
+ while (! (parser->tokens.head == parser->tokens.tail)) {
+ yaml_token_t *tmp_3;
+ tmp_3 = parser->tokens.head;
+ (parser->tokens.head) ++;
+ ;
+ yaml_token_delete(tmp_3);
+ }
+ yaml_free((void *)parser->tokens.start);
+ tmp_6 = (yaml_token_t *)0;
+ parser->tokens.end = tmp_6;
+ tmp_5 = tmp_6;
+ parser->tokens.tail = tmp_5;
+ tmp_4 = tmp_5;
+ parser->tokens.head = tmp_4;
+ parser->tokens.start = tmp_4;
+ yaml_free((void *)parser->indents.start);
+ tmp_8 = (int *)0;
+ parser->indents.end = tmp_8;
+ tmp_7 = tmp_8;
+ parser->indents.top = tmp_7;
+ parser->indents.start = tmp_7;
+ yaml_free((void *)parser->simple_keys.start);
+ tmp_10 = (yaml_simple_key_t *)0;
+ parser->simple_keys.end = tmp_10;
+ tmp_9 = tmp_10;
+ parser->simple_keys.top = tmp_9;
+ parser->simple_keys.start = tmp_9;
+ yaml_free((void *)parser->states.start);
+ tmp_12 = (yaml_parser_state_t *)0;
+ parser->states.end = tmp_12;
+ tmp_11 = tmp_12;
+ parser->states.top = tmp_11;
+ parser->states.start = tmp_11;
+ yaml_free((void *)parser->marks.start);
+ tmp_14 = (yaml_mark_t *)0;
+ parser->marks.end = tmp_14;
+ tmp_13 = tmp_14;
+ parser->marks.top = tmp_13;
+ parser->marks.start = tmp_13;
+ while (! (parser->tag_directives.start == parser->tag_directives.top)) {
+ (parser->tag_directives.top) --;
+ yaml_tag_directive_t tag_directive = *(parser->tag_directives.top);
+ yaml_free((void *)tag_directive.handle);
+ yaml_free((void *)tag_directive.prefix);
+ }
+ yaml_free((void *)parser->tag_directives.start);
+ tmp_16 = (yaml_tag_directive_t *)0;
+ parser->tag_directives.end = tmp_16;
+ tmp_15 = tmp_16;
+ parser->tag_directives.top = tmp_15;
+ parser->tag_directives.start = tmp_15;
+ memset((void *)parser,0,sizeof(yaml_parser_t));
+ return;
+}
+
+static int yaml_string_read_handler(void *data, unsigned char *buffer,
+ size_t size, size_t *size_read)
+{
+ int __retres;
+ yaml_parser_t *parser = (yaml_parser_t *)data;
+ if (parser->input.string.current == parser->input.string.end) {
+ *size_read = (unsigned long)0;
+ __retres = 1;
+ goto return_label;
+ }
+ if (size > (unsigned long)(parser->input.string.end - parser->input.string.current))
+ size = (unsigned long)(parser->input.string.end - parser->input.string.current);
+ memcpy((void *)buffer,(void const *)parser->input.string.current,size);
+ parser->input.string.current += size;
+ *size_read = size;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_file_read_handler(void *data, unsigned char *buffer,
+ size_t size, size_t *size_read)
+{
+ int tmp_0;
+ int tmp;
+ yaml_parser_t *parser = (yaml_parser_t *)data;
+ *size_read = fread((void *)buffer,(unsigned long)1,size,parser->input.file);
+ tmp = ferror(parser->input.file);
+ if (tmp) tmp_0 = 0; else tmp_0 = 1;
+ return tmp_0;
+}
+
+void yaml_parser_set_input_string(yaml_parser_t *parser,
+ unsigned char const *input, size_t size)
+{
+ __FC_assert(parser != (yaml_parser_t *)0,"src/api.c",292,"parser");
+ __FC_assert(! parser->read_handler != 0,"src/api.c",293,
+ "!parser->read_handler");
+ __FC_assert(input != (unsigned char const *)0,"src/api.c",294,"input");
+ parser->read_handler = & yaml_string_read_handler;
+ parser->read_handler_data = (void *)parser;
+ parser->input.string.start = input;
+ parser->input.string.current = input;
+ parser->input.string.end = input + size;
+ return;
+}
+
+void yaml_parser_set_input_file(yaml_parser_t *parser, FILE *file)
+{
+ __FC_assert(parser != (yaml_parser_t *)0,"src/api.c",311,"parser");
+ __FC_assert(! parser->read_handler != 0,"src/api.c",312,
+ "!parser->read_handler");
+ __FC_assert(file != (FILE *)0,"src/api.c",313,"file");
+ parser->read_handler = & yaml_file_read_handler;
+ parser->read_handler_data = (void *)parser;
+ parser->input.file = file;
+ return;
+}
+
+void yaml_parser_set_input(yaml_parser_t *parser,
+ yaml_read_handler_t *handler, void *data)
+{
+ __FC_assert(parser != (yaml_parser_t *)0,"src/api.c",329,"parser");
+ __FC_assert(! parser->read_handler != 0,"src/api.c",330,
+ "!parser->read_handler");
+ __FC_assert(handler != (yaml_read_handler_t *)0,"src/api.c",331,"handler");
+ parser->read_handler = handler;
+ parser->read_handler_data = data;
+ return;
+}
+
+void yaml_parser_set_encoding(yaml_parser_t *parser, yaml_encoding_t encoding)
+{
+ __FC_assert(parser != (yaml_parser_t *)0,"src/api.c",344,"parser");
+ __FC_assert(! parser->encoding != 0,"src/api.c",345,"!parser->encoding");
+ parser->encoding = encoding;
+ return;
+}
+
+int yaml_emitter_initialize(yaml_emitter_t *emitter)
+{
+ int __retres;
+ int tmp_2;
+ yaml_char_t *tmp;
+ int tmp_6;
+ unsigned char *tmp_3;
+ int tmp_9;
+ yaml_emitter_state_t *tmp_7;
+ int tmp_13;
+ yaml_event_t *tmp_10;
+ int tmp_16;
+ int *tmp_14;
+ int tmp_19;
+ yaml_tag_directive_t *tmp_17;
+ yaml_char_t *tmp_21;
+ yaml_char_t *tmp_20;
+ unsigned char *tmp_23;
+ unsigned char *tmp_22;
+ yaml_emitter_state_t *tmp_25;
+ yaml_emitter_state_t *tmp_24;
+ yaml_event_t *tmp_28;
+ yaml_event_t *tmp_27;
+ yaml_event_t *tmp_26;
+ int *tmp_30;
+ int *tmp_29;
+ yaml_tag_directive_t *tmp_32;
+ yaml_tag_directive_t *tmp_31;
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/api.c",357,"emitter");
+ memset((void *)emitter,0,sizeof(yaml_emitter_t));
+ tmp = (yaml_char_t *)yaml_malloc((unsigned long)16384);
+ emitter->buffer.start = tmp;
+ if (tmp) {
+ yaml_char_t *tmp_1;
+ tmp_1 = emitter->buffer.start;
+ emitter->buffer.pointer = tmp_1;
+ emitter->buffer.last = tmp_1;
+ emitter->buffer.end = emitter->buffer.start + 16384;
+ tmp_2 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ if (! tmp_2) goto error;
+ tmp_3 = (unsigned char *)yaml_malloc((unsigned long)(16384 * 2 + 2));
+ emitter->raw_buffer.start = tmp_3;
+ if (tmp_3) {
+ unsigned char *tmp_5;
+ tmp_5 = emitter->raw_buffer.start;
+ emitter->raw_buffer.pointer = tmp_5;
+ emitter->raw_buffer.last = tmp_5;
+ emitter->raw_buffer.end = emitter->raw_buffer.start + (16384 * 2 + 2);
+ tmp_6 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_6 = 0;
+ }
+ if (! tmp_6) goto error;
+ tmp_7 = (yaml_emitter_state_t *)yaml_malloc((unsigned long)16 * sizeof(*(emitter->states.start)));
+ emitter->states.start = tmp_7;
+ if (tmp_7) {
+ emitter->states.top = emitter->states.start;
+ emitter->states.end = emitter->states.start + 16;
+ tmp_9 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_9 = 0;
+ }
+ if (! tmp_9) goto error;
+ tmp_10 = (yaml_event_t *)yaml_malloc((unsigned long)16 * sizeof(*(emitter->events.start)));
+ emitter->events.start = tmp_10;
+ if (tmp_10) {
+ yaml_event_t *tmp_12;
+ tmp_12 = emitter->events.start;
+ emitter->events.tail = tmp_12;
+ emitter->events.head = tmp_12;
+ emitter->events.end = emitter->events.start + 16;
+ tmp_13 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_13 = 0;
+ }
+ if (! tmp_13) goto error;
+ tmp_14 = (int *)yaml_malloc((unsigned long)16 * sizeof(*(emitter->indents.start)));
+ emitter->indents.start = tmp_14;
+ if (tmp_14) {
+ emitter->indents.top = emitter->indents.start;
+ emitter->indents.end = emitter->indents.start + 16;
+ tmp_16 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_16 = 0;
+ }
+ if (! tmp_16) goto error;
+ tmp_17 = (yaml_tag_directive_t *)yaml_malloc((unsigned long)16 * sizeof(*(emitter->tag_directives.start)));
+ emitter->tag_directives.start = tmp_17;
+ if (tmp_17) {
+ emitter->tag_directives.top = emitter->tag_directives.start;
+ emitter->tag_directives.end = emitter->tag_directives.start + 16;
+ tmp_19 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_19 = 0;
+ }
+ if (! tmp_19) goto error;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)emitter->buffer.start);
+ tmp_21 = (yaml_char_t *)0;
+ emitter->buffer.end = tmp_21;
+ tmp_20 = tmp_21;
+ emitter->buffer.pointer = tmp_20;
+ emitter->buffer.start = tmp_20;
+ yaml_free((void *)emitter->raw_buffer.start);
+ tmp_23 = (unsigned char *)0;
+ emitter->raw_buffer.end = tmp_23;
+ tmp_22 = tmp_23;
+ emitter->raw_buffer.pointer = tmp_22;
+ emitter->raw_buffer.start = tmp_22;
+ yaml_free((void *)emitter->states.start);
+ tmp_25 = (yaml_emitter_state_t *)0;
+ emitter->states.end = tmp_25;
+ tmp_24 = tmp_25;
+ emitter->states.top = tmp_24;
+ emitter->states.start = tmp_24;
+ yaml_free((void *)emitter->events.start);
+ tmp_28 = (yaml_event_t *)0;
+ emitter->events.end = tmp_28;
+ tmp_27 = tmp_28;
+ emitter->events.tail = tmp_27;
+ tmp_26 = tmp_27;
+ emitter->events.head = tmp_26;
+ emitter->events.start = tmp_26;
+ yaml_free((void *)emitter->indents.start);
+ tmp_30 = (int *)0;
+ emitter->indents.end = tmp_30;
+ tmp_29 = tmp_30;
+ emitter->indents.top = tmp_29;
+ emitter->indents.start = tmp_29;
+ yaml_free((void *)emitter->tag_directives.start);
+ tmp_32 = (yaml_tag_directive_t *)0;
+ emitter->tag_directives.end = tmp_32;
+ tmp_31 = tmp_32;
+ emitter->tag_directives.top = tmp_31;
+ emitter->tag_directives.start = tmp_31;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+void yaml_emitter_delete(yaml_emitter_t *emitter)
+{
+ yaml_char_t *tmp_0;
+ yaml_char_t *tmp;
+ unsigned char *tmp_2;
+ unsigned char *tmp_1;
+ yaml_emitter_state_t *tmp_4;
+ yaml_emitter_state_t *tmp_3;
+ yaml_event_t *tmp_8;
+ yaml_event_t *tmp_7;
+ yaml_event_t *tmp_6;
+ int *tmp_10;
+ int *tmp_9;
+ yaml_tag_directive_t *tmp_12;
+ yaml_tag_directive_t *tmp_11;
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/api.c",394,"emitter");
+ yaml_free((void *)emitter->buffer.start);
+ tmp_0 = (yaml_char_t *)0;
+ emitter->buffer.end = tmp_0;
+ tmp = tmp_0;
+ emitter->buffer.pointer = tmp;
+ emitter->buffer.start = tmp;
+ yaml_free((void *)emitter->raw_buffer.start);
+ tmp_2 = (unsigned char *)0;
+ emitter->raw_buffer.end = tmp_2;
+ tmp_1 = tmp_2;
+ emitter->raw_buffer.pointer = tmp_1;
+ emitter->raw_buffer.start = tmp_1;
+ yaml_free((void *)emitter->states.start);
+ tmp_4 = (yaml_emitter_state_t *)0;
+ emitter->states.end = tmp_4;
+ tmp_3 = tmp_4;
+ emitter->states.top = tmp_3;
+ emitter->states.start = tmp_3;
+ while (! (emitter->events.head == emitter->events.tail)) {
+ yaml_event_t *tmp_5;
+ tmp_5 = emitter->events.head;
+ (emitter->events.head) ++;
+ ;
+ yaml_event_delete(tmp_5);
+ }
+ yaml_free((void *)emitter->events.start);
+ tmp_8 = (yaml_event_t *)0;
+ emitter->events.end = tmp_8;
+ tmp_7 = tmp_8;
+ emitter->events.tail = tmp_7;
+ tmp_6 = tmp_7;
+ emitter->events.head = tmp_6;
+ emitter->events.start = tmp_6;
+ yaml_free((void *)emitter->indents.start);
+ tmp_10 = (int *)0;
+ emitter->indents.end = tmp_10;
+ tmp_9 = tmp_10;
+ emitter->indents.top = tmp_9;
+ emitter->indents.start = tmp_9;
+ while (! (emitter->tag_directives.start == emitter->tag_directives.top)) {
+ (emitter->tag_directives.top) --;
+ yaml_tag_directive_t tag_directive = *(emitter->tag_directives.top);
+ yaml_free((void *)tag_directive.handle);
+ yaml_free((void *)tag_directive.prefix);
+ }
+ yaml_free((void *)emitter->tag_directives.start);
+ tmp_12 = (yaml_tag_directive_t *)0;
+ emitter->tag_directives.end = tmp_12;
+ tmp_11 = tmp_12;
+ emitter->tag_directives.top = tmp_11;
+ emitter->tag_directives.start = tmp_11;
+ yaml_free((void *)emitter->anchors);
+ memset((void *)emitter,0,sizeof(yaml_emitter_t));
+ return;
+}
+
+static int yaml_string_write_handler(void *data, unsigned char *buffer,
+ size_t size)
+{
+ int __retres;
+ yaml_emitter_t *emitter = (yaml_emitter_t *)data;
+ if (emitter->output.string.size - *(emitter->output.string.size_written) < size) {
+ memcpy((void *)(emitter->output.string.buffer + *(emitter->output.string.size_written)),
+ (void const *)buffer,
+ emitter->output.string.size - *(emitter->output.string.size_written));
+ *(emitter->output.string.size_written) = emitter->output.string.size;
+ __retres = 0;
+ goto return_label;
+ }
+ memcpy((void *)(emitter->output.string.buffer + *(emitter->output.string.size_written)),
+ (void const *)buffer,size);
+ *(emitter->output.string.size_written) += size;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_file_write_handler(void *data, unsigned char *buffer,
+ size_t size)
+{
+ int __retres;
+ size_t tmp;
+ yaml_emitter_t *emitter = (yaml_emitter_t *)data;
+ tmp = fwrite((void const *)buffer,(unsigned long)1,size,
+ emitter->output.file);
+ ;
+ __retres = tmp == size;
+ return __retres;
+}
+
+void yaml_emitter_set_output_string(yaml_emitter_t *emitter,
+ unsigned char *output, size_t size,
+ size_t *size_written)
+{
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/api.c",460,"emitter");
+ __FC_assert(! emitter->write_handler != 0,"src/api.c",461,
+ "!emitter->write_handler");
+ __FC_assert(output != (unsigned char *)0,"src/api.c",462,"output");
+ emitter->write_handler = & yaml_string_write_handler;
+ emitter->write_handler_data = (void *)emitter;
+ emitter->output.string.buffer = output;
+ emitter->output.string.size = size;
+ emitter->output.string.size_written = size_written;
+ *size_written = (unsigned long)0;
+ return;
+}
+
+void yaml_emitter_set_output_file(yaml_emitter_t *emitter, FILE *file)
+{
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/api.c",480,"emitter");
+ __FC_assert(! emitter->write_handler != 0,"src/api.c",481,
+ "!emitter->write_handler");
+ __FC_assert(file != (FILE *)0,"src/api.c",482,"file");
+ emitter->write_handler = & yaml_file_write_handler;
+ emitter->write_handler_data = (void *)emitter;
+ emitter->output.file = file;
+ return;
+}
+
+void yaml_emitter_set_output(yaml_emitter_t *emitter,
+ yaml_write_handler_t *handler, void *data)
+{
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/api.c",498,"emitter");
+ __FC_assert(! emitter->write_handler != 0,"src/api.c",499,
+ "!emitter->write_handler");
+ __FC_assert(handler != (yaml_write_handler_t *)0,"src/api.c",500,"handler");
+ emitter->write_handler = handler;
+ emitter->write_handler_data = data;
+ return;
+}
+
+void yaml_emitter_set_encoding(yaml_emitter_t *emitter,
+ yaml_encoding_t encoding)
+{
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/api.c",513,"emitter");
+ __FC_assert(! emitter->encoding != 0,"src/api.c",514,"!emitter->encoding");
+ emitter->encoding = encoding;
+ return;
+}
+
+void yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical)
+{
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/api.c",526,"emitter");
+ emitter->canonical = canonical != 0;
+ return;
+}
+
+void yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent)
+{
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/api.c",538,"emitter");
+ if (1 < indent)
+ if (indent < 10) emitter->best_indent = indent;
+ else emitter->best_indent = 2;
+ else emitter->best_indent = 2;
+ return;
+}
+
+void yaml_emitter_set_width(yaml_emitter_t *emitter, int width)
+{
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/api.c",550,"emitter");
+ if (width >= 0) emitter->best_width = width; else emitter->best_width = -1;
+ return;
+}
+
+void yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode)
+{
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/api.c",562,"emitter");
+ emitter->unicode = unicode != 0;
+ return;
+}
+
+void yaml_emitter_set_break(yaml_emitter_t *emitter, yaml_break_t line_break)
+{
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/api.c",574,"emitter");
+ emitter->line_break = line_break;
+ return;
+}
+
+void yaml_token_delete(yaml_token_t *token)
+{
+ __FC_assert(token != (yaml_token_t *)0,"src/api.c",586,"token");
+ switch (token->type) {
+ case (yaml_token_type_t)YAML_TAG_DIRECTIVE_TOKEN:
+ yaml_free((void *)token->data.tag_directive.handle);
+ yaml_free((void *)token->data.tag_directive.prefix);
+ break;
+ case (yaml_token_type_t)YAML_ALIAS_TOKEN:
+ yaml_free((void *)token->data.alias.value);
+ break;
+ case (yaml_token_type_t)YAML_ANCHOR_TOKEN:
+ yaml_free((void *)token->data.anchor.value);
+ break;
+ case (yaml_token_type_t)YAML_TAG_TOKEN:
+ yaml_free((void *)token->data.tag.handle);
+ yaml_free((void *)token->data.tag.suffix);
+ break;
+ case (yaml_token_type_t)YAML_SCALAR_TOKEN:
+ yaml_free((void *)token->data.scalar.value);
+ break;
+ default: break;
+ }
+ memset((void *)token,0,sizeof(yaml_token_t));
+ return;
+}
+
+static int yaml_check_utf8(yaml_char_t const *start, size_t length)
+{
+ int __retres;
+ yaml_char_t const *end = start + length;
+ yaml_char_t const *pointer = start;
+ while (pointer < end) {
+ unsigned char octet;
+ unsigned int width;
+ unsigned int value;
+ size_t k;
+ octet = *(pointer + 0);
+ if (((int)octet & 0x80) == 0x00) width = (unsigned int)1;
+ else {
+ int tmp_1;
+ if (((int)octet & 0xE0) == 0xC0) tmp_1 = 2;
+ else {
+ int tmp_0;
+ if (((int)octet & 0xF0) == 0xE0) tmp_0 = 3;
+ else {
+ int tmp;
+ if (((int)octet & 0xF8) == 0xF0) tmp = 4; else tmp = 0;
+ tmp_0 = tmp;
+ }
+ tmp_1 = tmp_0;
+ }
+ width = (unsigned int)tmp_1;
+ }
+ if (((int)octet & 0x80) == 0x00) value = (unsigned int)((int)octet & 0x7F);
+ else {
+ int tmp_4;
+ if (((int)octet & 0xE0) == 0xC0) tmp_4 = (int)octet & 0x1F;
+ else {
+ int tmp_3;
+ if (((int)octet & 0xF0) == 0xE0) tmp_3 = (int)octet & 0x0F;
+ else {
+ int tmp_2;
+ if (((int)octet & 0xF8) == 0xF0) tmp_2 = (int)octet & 0x07;
+ else tmp_2 = 0;
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ value = (unsigned int)tmp_4;
+ }
+ if (! width) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (pointer + width > end) {
+ __retres = 0;
+ goto return_label;
+ }
+ k = (unsigned long)1;
+ while (k < (size_t)width) {
+ octet = *(pointer + k);
+ if (((int)octet & 0xC0) != 0x80) {
+ __retres = 0;
+ goto return_label;
+ }
+ value = (value << 6) + (unsigned int)((int)octet & 0x3F);
+ k += (size_t)1;
+ }
+ if (! (width == (unsigned int)1))
+ if (width == (unsigned int)2) {
+ if (! (value >= (unsigned int)0x80)) goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if (width == (unsigned int)3) {
+ if (! (value >= (unsigned int)0x800)) goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (width == (unsigned int)4) {
+ if (! (value >= (unsigned int)0x10000)) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ pointer += width;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+int yaml_stream_start_event_initialize(yaml_event_t *event,
+ yaml_encoding_t encoding)
+{
+ int __retres;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ __FC_assert(event != (yaml_event_t *)0,"src/api.c",674,"event");
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_STREAM_START_EVENT;
+ event->start_mark = mark;
+ event->end_mark = mark;
+ event->data.stream_start.encoding = encoding;
+ __retres = 1;
+ return __retres;
+}
+
+int yaml_stream_end_event_initialize(yaml_event_t *event)
+{
+ int __retres;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ __FC_assert(event != (yaml_event_t *)0,"src/api.c",690,"event");
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_STREAM_END_EVENT;
+ event->start_mark = mark;
+ event->end_mark = mark;
+ __retres = 1;
+ return __retres;
+}
+
+int yaml_document_start_event_initialize(yaml_event_t *event,
+ yaml_version_directive_t *version_directive,
+ yaml_tag_directive_t *tag_directives_start,
+ yaml_tag_directive_t *tag_directives_end,
+ int implicit)
+{
+ int __retres;
+ struct __anonstruct_context_49 context;
+ int tmp;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ yaml_version_directive_t *version_directive_copy =
+ (yaml_version_directive_t *)0;
+ struct __anonstruct_tag_directives_copy_50 tag_directives_copy =
+ {.start = (yaml_tag_directive_t *)0,
+ .end = (yaml_tag_directive_t *)0,
+ .top = (yaml_tag_directive_t *)0};
+ yaml_tag_directive_t value =
+ {.handle = (yaml_char_t *)0, .prefix = (yaml_char_t *)0};
+ __FC_assert(event != (yaml_event_t *)0,"src/api.c",720,"event");
+ if (tag_directives_start) {
+ if (tag_directives_end) tmp = 1; else goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (tag_directives_start == tag_directives_end) tmp = 1; else tmp = 0;
+ }
+ __FC_assert(tmp != 0,"src/api.c",721,
+ "(tag_directives_start && tag_directives_end) || (tag_directives_start == tag_directives_end)");
+ if (version_directive) {
+ version_directive_copy = (yaml_version_directive_t *)yaml_malloc(sizeof(yaml_version_directive_t));
+ if (! version_directive_copy) goto error;
+ version_directive_copy->major = version_directive->major;
+ version_directive_copy->minor = version_directive->minor;
+ }
+ if (tag_directives_start != tag_directives_end) {
+ yaml_tag_directive_t *tag_directive;
+ int tmp_2;
+ tag_directives_copy.start = (yaml_tag_directive_t *)yaml_malloc((unsigned long)16 * sizeof(*(tag_directives_copy.start)));
+ if (tag_directives_copy.start) {
+ tag_directives_copy.top = tag_directives_copy.start;
+ tag_directives_copy.end = tag_directives_copy.start + 16;
+ tmp_2 = 1;
+ }
+ else {
+ context.error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ if (! tmp_2) goto error;
+ tag_directive = tag_directives_start;
+ while (tag_directive != tag_directives_end) {
+ {
+ int tmp_4;
+ size_t tmp_3;
+ int tmp_6;
+ size_t tmp_5;
+ int tmp_9;
+ __FC_assert(tag_directive->handle != (yaml_char_t *)0,"src/api.c",
+ 738,"tag_directive->handle");
+ __FC_assert(tag_directive->prefix != (yaml_char_t *)0,"src/api.c",
+ 739,"tag_directive->prefix");
+ tmp_3 = strlen((char const *)tag_directive->handle);
+ ;
+ tmp_4 = yaml_check_utf8((yaml_char_t const *)tag_directive->handle,
+ tmp_3);
+ if (! tmp_4) goto error;
+ tmp_5 = strlen((char const *)tag_directive->prefix);
+ ;
+ tmp_6 = yaml_check_utf8((yaml_char_t const *)tag_directive->prefix,
+ tmp_5);
+ if (! tmp_6) goto error;
+ value.handle = yaml_strdup((yaml_char_t const *)tag_directive->handle);
+ value.prefix = yaml_strdup((yaml_char_t const *)tag_directive->prefix);
+ if (! value.handle) goto error;
+ else
+ if (! value.prefix) goto error;
+ if (tag_directives_copy.top != tag_directives_copy.end) goto _LOR;
+ else {
+ int tmp_7;
+ tmp_7 = yaml_stack_extend((void **)(& tag_directives_copy.start),
+ (void **)(& tag_directives_copy.top),
+ (void **)(& tag_directives_copy.end));
+ if (tmp_7) {
+ yaml_tag_directive_t *tmp_8;
+ _LOR: tmp_8 = tag_directives_copy.top;
+ (tag_directives_copy.top) ++;
+ *tmp_8 = value;
+ tmp_9 = 1;
+ }
+ else {
+ context.error = YAML_MEMORY_ERROR;
+ tmp_9 = 0;
+ }
+ }
+ if (! tmp_9) goto error;
+ value.handle = (yaml_char_t *)0;
+ value.prefix = (yaml_char_t *)0;
+ }
+ tag_directive ++;
+ }
+ }
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_DOCUMENT_START_EVENT;
+ event->start_mark = mark;
+ event->end_mark = mark;
+ event->data.document_start.version_directive = version_directive_copy;
+ event->data.document_start.tag_directives.start = tag_directives_copy.start;
+ event->data.document_start.tag_directives.end = tag_directives_copy.top;
+ event->data.document_start.implicit = implicit;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)version_directive_copy);
+ while (! (tag_directives_copy.start == tag_directives_copy.top)) {
+ (tag_directives_copy.top) --;
+ yaml_tag_directive_t value_0 = *(tag_directives_copy.top);
+ yaml_free((void *)value_0.handle);
+ yaml_free((void *)value_0.prefix);
+ }
+ yaml_free((void *)tag_directives_copy.start);
+ tag_directives_copy.end = (yaml_tag_directive_t *)0;
+ tag_directives_copy.top = tag_directives_copy.end;
+ tag_directives_copy.start = tag_directives_copy.top;
+ yaml_free((void *)value.handle);
+ yaml_free((void *)value.prefix);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int yaml_document_end_event_initialize(yaml_event_t *event, int implicit)
+{
+ int __retres;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ __FC_assert(event != (yaml_event_t *)0,"src/api.c",785,"event");
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_DOCUMENT_END_EVENT;
+ event->start_mark = mark;
+ event->end_mark = mark;
+ event->data.document_end.implicit = implicit;
+ __retres = 1;
+ return __retres;
+}
+
+int yaml_alias_event_initialize(yaml_event_t *event,
+ yaml_char_t const *anchor)
+{
+ int __retres;
+ int tmp_0;
+ size_t tmp;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ yaml_char_t *anchor_copy = (yaml_char_t *)0;
+ __FC_assert(event != (yaml_event_t *)0,"src/api.c",802,"event");
+ __FC_assert(anchor != (yaml_char_t const *)0,"src/api.c",803,"anchor");
+ tmp = strlen((char const *)anchor);
+ ;
+ tmp_0 = yaml_check_utf8(anchor,tmp);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ anchor_copy = yaml_strdup(anchor);
+ if (! anchor_copy) {
+ __retres = 0;
+ goto return_label;
+ }
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_ALIAS_EVENT;
+ event->start_mark = mark;
+ event->end_mark = mark;
+ event->data.alias.anchor = anchor_copy;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+int yaml_scalar_event_initialize(yaml_event_t *event,
+ yaml_char_t const *anchor,
+ yaml_char_t const *tag,
+ yaml_char_t const *value, int length,
+ int plain_implicit, int quoted_implicit,
+ yaml_scalar_style_t style)
+{
+ int __retres;
+ int tmp_4;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ yaml_char_t *anchor_copy = (yaml_char_t *)0;
+ yaml_char_t *tag_copy = (yaml_char_t *)0;
+ yaml_char_t *value_copy = (yaml_char_t *)0;
+ __FC_assert(event != (yaml_event_t *)0,"src/api.c",832,"event");
+ __FC_assert(value != (yaml_char_t const *)0,"src/api.c",833,"value");
+ if (anchor) {
+ int tmp_0;
+ size_t tmp;
+ tmp = strlen((char const *)anchor);
+ ;
+ tmp_0 = yaml_check_utf8(anchor,tmp);
+ if (! tmp_0) goto error;
+ anchor_copy = yaml_strdup(anchor);
+ if (! anchor_copy) goto error;
+ }
+ if (tag) {
+ int tmp_2;
+ size_t tmp_1;
+ tmp_1 = strlen((char const *)tag);
+ ;
+ tmp_2 = yaml_check_utf8(tag,tmp_1);
+ if (! tmp_2) goto error;
+ tag_copy = yaml_strdup(tag);
+ if (! tag_copy) goto error;
+ }
+ if (length < 0) {
+ size_t tmp_3;
+ tmp_3 = strlen((char const *)value);
+ length = (int)tmp_3;
+ }
+ tmp_4 = yaml_check_utf8(value,(unsigned long)length);
+ if (! tmp_4) goto error;
+ value_copy = (yaml_char_t *)yaml_malloc((unsigned long)(length + 1));
+ if (! value_copy) goto error;
+ memcpy((void *)value_copy,(void const *)value,(unsigned long)length);
+ *(value_copy + length) = (unsigned char)'\000';
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_SCALAR_EVENT;
+ event->start_mark = mark;
+ event->end_mark = mark;
+ event->data.scalar.anchor = anchor_copy;
+ event->data.scalar.tag = tag_copy;
+ event->data.scalar.value = value_copy;
+ event->data.scalar.length = (unsigned long)length;
+ event->data.scalar.plain_implicit = plain_implicit;
+ event->data.scalar.quoted_implicit = quoted_implicit;
+ event->data.scalar.style = style;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)anchor_copy);
+ yaml_free((void *)tag_copy);
+ yaml_free((void *)value_copy);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int yaml_sequence_start_event_initialize(yaml_event_t *event,
+ yaml_char_t const *anchor,
+ yaml_char_t const *tag,
+ int implicit,
+ yaml_sequence_style_t style)
+{
+ int __retres;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ yaml_char_t *anchor_copy = (yaml_char_t *)0;
+ yaml_char_t *tag_copy = (yaml_char_t *)0;
+ __FC_assert(event != (yaml_event_t *)0,"src/api.c",883,"event");
+ if (anchor) {
+ int tmp_0;
+ size_t tmp;
+ tmp = strlen((char const *)anchor);
+ ;
+ tmp_0 = yaml_check_utf8(anchor,tmp);
+ if (! tmp_0) goto error;
+ anchor_copy = yaml_strdup(anchor);
+ if (! anchor_copy) goto error;
+ }
+ if (tag) {
+ int tmp_2;
+ size_t tmp_1;
+ tmp_1 = strlen((char const *)tag);
+ ;
+ tmp_2 = yaml_check_utf8(tag,tmp_1);
+ if (! tmp_2) goto error;
+ tag_copy = yaml_strdup(tag);
+ if (! tag_copy) goto error;
+ }
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_SEQUENCE_START_EVENT;
+ event->start_mark = mark;
+ event->end_mark = mark;
+ event->data.sequence_start.anchor = anchor_copy;
+ event->data.sequence_start.tag = tag_copy;
+ event->data.sequence_start.implicit = implicit;
+ event->data.sequence_start.style = style;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)anchor_copy);
+ yaml_free((void *)tag_copy);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int yaml_sequence_end_event_initialize(yaml_event_t *event)
+{
+ int __retres;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ __FC_assert(event != (yaml_event_t *)0,"src/api.c",918,"event");
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_SEQUENCE_END_EVENT;
+ event->start_mark = mark;
+ event->end_mark = mark;
+ __retres = 1;
+ return __retres;
+}
+
+int yaml_mapping_start_event_initialize(yaml_event_t *event,
+ yaml_char_t const *anchor,
+ yaml_char_t const *tag, int implicit,
+ yaml_mapping_style_t style)
+{
+ int __retres;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ yaml_char_t *anchor_copy = (yaml_char_t *)0;
+ yaml_char_t *tag_copy = (yaml_char_t *)0;
+ __FC_assert(event != (yaml_event_t *)0,"src/api.c",938,"event");
+ if (anchor) {
+ int tmp_0;
+ size_t tmp;
+ tmp = strlen((char const *)anchor);
+ ;
+ tmp_0 = yaml_check_utf8(anchor,tmp);
+ if (! tmp_0) goto error;
+ anchor_copy = yaml_strdup(anchor);
+ if (! anchor_copy) goto error;
+ }
+ if (tag) {
+ int tmp_2;
+ size_t tmp_1;
+ tmp_1 = strlen((char const *)tag);
+ ;
+ tmp_2 = yaml_check_utf8(tag,tmp_1);
+ if (! tmp_2) goto error;
+ tag_copy = yaml_strdup(tag);
+ if (! tag_copy) goto error;
+ }
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_MAPPING_START_EVENT;
+ event->start_mark = mark;
+ event->end_mark = mark;
+ event->data.mapping_start.anchor = anchor_copy;
+ event->data.mapping_start.tag = tag_copy;
+ event->data.mapping_start.implicit = implicit;
+ event->data.mapping_start.style = style;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)anchor_copy);
+ yaml_free((void *)tag_copy);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int yaml_mapping_end_event_initialize(yaml_event_t *event)
+{
+ int __retres;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ __FC_assert(event != (yaml_event_t *)0,"src/api.c",973,"event");
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_MAPPING_END_EVENT;
+ event->start_mark = mark;
+ event->end_mark = mark;
+ __retres = 1;
+ return __retres;
+}
+
+void yaml_event_delete(yaml_event_t *event)
+{
+ yaml_tag_directive_t *tag_directive;
+ __FC_assert(event != (yaml_event_t *)0,"src/api.c",989,"event");
+ switch (event->type) {
+ case (yaml_event_type_t)YAML_DOCUMENT_START_EVENT:
+ yaml_free((void *)event->data.document_start.version_directive);
+ tag_directive = event->data.document_start.tag_directives.start;
+ while (tag_directive != event->data.document_start.tag_directives.end) {
+ yaml_free((void *)tag_directive->handle);
+ yaml_free((void *)tag_directive->prefix);
+ tag_directive ++;
+ }
+ yaml_free((void *)event->data.document_start.tag_directives.start);
+ break;
+ case (yaml_event_type_t)YAML_ALIAS_EVENT:
+ yaml_free((void *)event->data.alias.anchor);
+ break;
+ case (yaml_event_type_t)YAML_SCALAR_EVENT:
+ yaml_free((void *)event->data.scalar.anchor);
+ yaml_free((void *)event->data.scalar.tag);
+ yaml_free((void *)event->data.scalar.value);
+ break;
+ case (yaml_event_type_t)YAML_SEQUENCE_START_EVENT:
+ yaml_free((void *)event->data.sequence_start.anchor);
+ yaml_free((void *)event->data.sequence_start.tag);
+ break;
+ case (yaml_event_type_t)YAML_MAPPING_START_EVENT:
+ yaml_free((void *)event->data.mapping_start.anchor);
+ yaml_free((void *)event->data.mapping_start.tag);
+ break;
+ default: break;
+ }
+ memset((void *)event,0,sizeof(yaml_event_t));
+ return;
+}
+
+int yaml_document_initialize(yaml_document_t *document,
+ yaml_version_directive_t *version_directive,
+ yaml_tag_directive_t *tag_directives_start,
+ yaml_tag_directive_t *tag_directives_end,
+ int start_implicit, int end_implicit)
+{
+ int __retres;
+ struct __anonstruct_context_51 context;
+ int tmp;
+ int tmp_1;
+ struct __anonstruct_nodes_52 nodes =
+ {.start = (yaml_node_t *)0,
+ .end = (yaml_node_t *)0,
+ .top = (yaml_node_t *)0};
+ yaml_version_directive_t *version_directive_copy =
+ (yaml_version_directive_t *)0;
+ struct __anonstruct_tag_directives_copy_53 tag_directives_copy =
+ {.start = (yaml_tag_directive_t *)0,
+ .end = (yaml_tag_directive_t *)0,
+ .top = (yaml_tag_directive_t *)0};
+ yaml_tag_directive_t value =
+ {.handle = (yaml_char_t *)0, .prefix = (yaml_char_t *)0};
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ __FC_assert(document != (yaml_document_t *)0,"src/api.c",1059,"document");
+ if (tag_directives_start) {
+ if (tag_directives_end) tmp = 1; else goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (tag_directives_start == tag_directives_end) tmp = 1; else tmp = 0;
+ }
+ __FC_assert(tmp != 0,"src/api.c",1060,
+ "(tag_directives_start && tag_directives_end) || (tag_directives_start == tag_directives_end)");
+ nodes.start = (yaml_node_t *)yaml_malloc((unsigned long)16 * sizeof(*(nodes.start)));
+ if (nodes.start) {
+ nodes.top = nodes.start;
+ nodes.end = nodes.start + 16;
+ tmp_1 = 1;
+ }
+ else {
+ context.error = YAML_MEMORY_ERROR;
+ tmp_1 = 0;
+ }
+ if (! tmp_1) goto error;
+ if (version_directive) {
+ version_directive_copy = (yaml_version_directive_t *)yaml_malloc(sizeof(yaml_version_directive_t));
+ if (! version_directive_copy) goto error;
+ version_directive_copy->major = version_directive->major;
+ version_directive_copy->minor = version_directive->minor;
+ }
+ if (tag_directives_start != tag_directives_end) {
+ yaml_tag_directive_t *tag_directive;
+ int tmp_4;
+ tag_directives_copy.start = (yaml_tag_directive_t *)yaml_malloc((unsigned long)16 * sizeof(*(tag_directives_copy.start)));
+ if (tag_directives_copy.start) {
+ tag_directives_copy.top = tag_directives_copy.start;
+ tag_directives_copy.end = tag_directives_copy.start + 16;
+ tmp_4 = 1;
+ }
+ else {
+ context.error = YAML_MEMORY_ERROR;
+ tmp_4 = 0;
+ }
+ if (! tmp_4) goto error;
+ tag_directive = tag_directives_start;
+ while (tag_directive != tag_directives_end) {
+ {
+ int tmp_6;
+ size_t tmp_5;
+ int tmp_8;
+ size_t tmp_7;
+ int tmp_11;
+ __FC_assert(tag_directive->handle != (yaml_char_t *)0,"src/api.c",
+ 1079,"tag_directive->handle");
+ __FC_assert(tag_directive->prefix != (yaml_char_t *)0,"src/api.c",
+ 1080,"tag_directive->prefix");
+ tmp_5 = strlen((char const *)tag_directive->handle);
+ ;
+ tmp_6 = yaml_check_utf8((yaml_char_t const *)tag_directive->handle,
+ tmp_5);
+ if (! tmp_6) goto error;
+ tmp_7 = strlen((char const *)tag_directive->prefix);
+ ;
+ tmp_8 = yaml_check_utf8((yaml_char_t const *)tag_directive->prefix,
+ tmp_7);
+ if (! tmp_8) goto error;
+ value.handle = yaml_strdup((yaml_char_t const *)tag_directive->handle);
+ value.prefix = yaml_strdup((yaml_char_t const *)tag_directive->prefix);
+ if (! value.handle) goto error;
+ else
+ if (! value.prefix) goto error;
+ if (tag_directives_copy.top != tag_directives_copy.end) goto _LOR;
+ else {
+ int tmp_9;
+ tmp_9 = yaml_stack_extend((void **)(& tag_directives_copy.start),
+ (void **)(& tag_directives_copy.top),
+ (void **)(& tag_directives_copy.end));
+ if (tmp_9) {
+ yaml_tag_directive_t *tmp_10;
+ _LOR: tmp_10 = tag_directives_copy.top;
+ (tag_directives_copy.top) ++;
+ *tmp_10 = value;
+ tmp_11 = 1;
+ }
+ else {
+ context.error = YAML_MEMORY_ERROR;
+ tmp_11 = 0;
+ }
+ }
+ if (! tmp_11) goto error;
+ value.handle = (yaml_char_t *)0;
+ value.prefix = (yaml_char_t *)0;
+ }
+ tag_directive ++;
+ }
+ }
+ memset((void *)document,0,sizeof(yaml_document_t));
+ document->nodes.start = nodes.start;
+ document->nodes.end = nodes.end;
+ document->nodes.top = nodes.start;
+ document->version_directive = version_directive_copy;
+ document->tag_directives.start = tag_directives_copy.start;
+ document->tag_directives.end = tag_directives_copy.top;
+ document->start_implicit = start_implicit;
+ document->end_implicit = end_implicit;
+ document->start_mark = mark;
+ document->end_mark = mark;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)nodes.start);
+ nodes.end = (yaml_node_t *)0;
+ nodes.top = nodes.end;
+ nodes.start = nodes.top;
+ yaml_free((void *)version_directive_copy);
+ while (! (tag_directives_copy.start == tag_directives_copy.top)) {
+ (tag_directives_copy.top) --;
+ yaml_tag_directive_t value_0 = *(tag_directives_copy.top);
+ yaml_free((void *)value_0.handle);
+ yaml_free((void *)value_0.prefix);
+ }
+ yaml_free((void *)tag_directives_copy.start);
+ tag_directives_copy.end = (yaml_tag_directive_t *)0;
+ tag_directives_copy.top = tag_directives_copy.end;
+ tag_directives_copy.start = tag_directives_copy.top;
+ yaml_free((void *)value.handle);
+ yaml_free((void *)value.prefix);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+void yaml_document_delete(yaml_document_t *document)
+{
+ yaml_tag_directive_t *tag_directive;
+ yaml_node_t *tmp_0;
+ yaml_node_t *tmp;
+ __FC_assert(document != (yaml_document_t *)0,"src/api.c",1127,"document");
+ while (! (document->nodes.start == document->nodes.top)) {
+ (document->nodes.top) --;
+ yaml_node_t node = *(document->nodes.top);
+ yaml_free((void *)node.tag);
+ switch (node.type) {
+ case (yaml_node_type_t)YAML_SCALAR_NODE:
+ yaml_free((void *)node.data.scalar.value);
+ break;
+ case (yaml_node_type_t)YAML_SEQUENCE_NODE:
+ yaml_free((void *)node.data.sequence.items.start);
+ node.data.sequence.items.end = (yaml_node_item_t *)0;
+ node.data.sequence.items.top = node.data.sequence.items.end;
+ node.data.sequence.items.start = node.data.sequence.items.top;
+ break;
+ case (yaml_node_type_t)YAML_MAPPING_NODE:
+ yaml_free((void *)node.data.mapping.pairs.start);
+ node.data.mapping.pairs.end = (yaml_node_pair_t *)0;
+ node.data.mapping.pairs.top = node.data.mapping.pairs.end;
+ node.data.mapping.pairs.start = node.data.mapping.pairs.top;
+ break;
+ default: __FC_assert(0 != 0,"src/api.c",1143,"0");
+ }
+ }
+ yaml_free((void *)document->nodes.start);
+ tmp_0 = (yaml_node_t *)0;
+ document->nodes.end = tmp_0;
+ tmp = tmp_0;
+ document->nodes.top = tmp;
+ document->nodes.start = tmp;
+ yaml_free((void *)document->version_directive);
+ tag_directive = document->tag_directives.start;
+ while (tag_directive != document->tag_directives.end) {
+ yaml_free((void *)tag_directive->handle);
+ yaml_free((void *)tag_directive->prefix);
+ tag_directive ++;
+ }
+ yaml_free((void *)document->tag_directives.start);
+ memset((void *)document,0,sizeof(yaml_document_t));
+ return;
+}
+
+yaml_node_t *yaml_document_get_node(yaml_document_t *document, int index_0)
+{
+ yaml_node_t *__retres;
+ __FC_assert(document != (yaml_document_t *)0,"src/api.c",1167,"document");
+ if (index_0 > 0)
+ if (document->nodes.start + index_0 <= document->nodes.top) {
+ __retres = (document->nodes.start + index_0) - 1;
+ goto return_label;
+ }
+ __retres = (yaml_node_t *)0;
+ return_label: return __retres;
+}
+
+yaml_node_t *yaml_document_get_root_node(yaml_document_t *document)
+{
+ yaml_node_t *__retres;
+ __FC_assert(document != (yaml_document_t *)0,"src/api.c",1182,"document");
+ if (document->nodes.top != document->nodes.start) {
+ __retres = document->nodes.start;
+ goto return_label;
+ }
+ __retres = (yaml_node_t *)0;
+ return_label: return __retres;
+}
+
+int yaml_document_add_scalar(yaml_document_t *document,
+ yaml_char_t const *tag,
+ yaml_char_t const *value, int length,
+ yaml_scalar_style_t style)
+{
+ int __retres;
+ struct __anonstruct_context_54 context;
+ yaml_node_t node;
+ int tmp_0;
+ size_t tmp;
+ int tmp_2;
+ int tmp_6;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ yaml_char_t *tag_copy = (yaml_char_t *)0;
+ yaml_char_t *value_copy = (yaml_char_t *)0;
+ __FC_assert(document != (yaml_document_t *)0,"src/api.c",1207,"document");
+ __FC_assert(value != (yaml_char_t const *)0,"src/api.c",1208,"value");
+ if (! tag) tag = (yaml_char_t const *)"tag:yaml.org,2002:str";
+ tmp = strlen((char const *)tag);
+ ;
+ tmp_0 = yaml_check_utf8(tag,tmp);
+ if (! tmp_0) goto error;
+ tag_copy = yaml_strdup(tag);
+ if (! tag_copy) goto error;
+ if (length < 0) {
+ size_t tmp_1;
+ tmp_1 = strlen((char const *)value);
+ length = (int)tmp_1;
+ }
+ tmp_2 = yaml_check_utf8(value,(unsigned long)length);
+ if (! tmp_2) goto error;
+ value_copy = (yaml_char_t *)yaml_malloc((unsigned long)(length + 1));
+ if (! value_copy) goto error;
+ memcpy((void *)value_copy,(void const *)value,(unsigned long)length);
+ *(value_copy + length) = (unsigned char)'\000';
+ memset((void *)(& node),0,sizeof(yaml_node_t));
+ node.type = YAML_SCALAR_NODE;
+ node.tag = tag_copy;
+ node.start_mark = mark;
+ node.end_mark = mark;
+ node.data.scalar.value = value_copy;
+ node.data.scalar.length = (unsigned long)length;
+ node.data.scalar.style = style;
+ if (document->nodes.top != document->nodes.end) goto _LOR;
+ else {
+ int tmp_4;
+ tmp_4 = yaml_stack_extend((void **)(& document->nodes.start),
+ (void **)(& document->nodes.top),
+ (void **)(& document->nodes.end));
+ if (tmp_4) {
+ yaml_node_t *tmp_5;
+ _LOR: tmp_5 = document->nodes.top;
+ (document->nodes.top) ++;
+ *tmp_5 = node;
+ tmp_6 = 1;
+ }
+ else {
+ context.error = YAML_MEMORY_ERROR;
+ tmp_6 = 0;
+ }
+ }
+ if (! tmp_6) goto error;
+ __retres = (int)(document->nodes.top - document->nodes.start);
+ goto return_label;
+ error: yaml_free((void *)tag_copy);
+ yaml_free((void *)value_copy);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int yaml_document_add_sequence(yaml_document_t *document,
+ yaml_char_t const *tag,
+ yaml_sequence_style_t style)
+{
+ int __retres;
+ struct __anonstruct_context_55 context;
+ yaml_node_t node;
+ int tmp_0;
+ size_t tmp;
+ int tmp_2;
+ int tmp_5;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ yaml_char_t *tag_copy = (yaml_char_t *)0;
+ struct __anonstruct_items_56 items =
+ {.start = (yaml_node_item_t *)0,
+ .end = (yaml_node_item_t *)0,
+ .top = (yaml_node_item_t *)0};
+ __FC_assert(document != (yaml_document_t *)0,"src/api.c",1260,"document");
+ if (! tag) tag = (yaml_char_t const *)"tag:yaml.org,2002:seq";
+ tmp = strlen((char const *)tag);
+ ;
+ tmp_0 = yaml_check_utf8(tag,tmp);
+ if (! tmp_0) goto error;
+ tag_copy = yaml_strdup(tag);
+ if (! tag_copy) goto error;
+ items.start = (yaml_node_item_t *)yaml_malloc((unsigned long)16 * sizeof(*(items.start)));
+ if (items.start) {
+ items.top = items.start;
+ items.end = items.start + 16;
+ tmp_2 = 1;
+ }
+ else {
+ context.error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ if (! tmp_2) goto error;
+ memset((void *)(& node),0,sizeof(yaml_node_t));
+ node.type = YAML_SEQUENCE_NODE;
+ node.tag = tag_copy;
+ node.start_mark = mark;
+ node.end_mark = mark;
+ node.data.sequence.items.start = items.start;
+ node.data.sequence.items.end = items.end;
+ node.data.sequence.items.top = items.start;
+ node.data.sequence.style = style;
+ if (document->nodes.top != document->nodes.end) goto _LOR;
+ else {
+ int tmp_3;
+ tmp_3 = yaml_stack_extend((void **)(& document->nodes.start),
+ (void **)(& document->nodes.top),
+ (void **)(& document->nodes.end));
+ if (tmp_3) {
+ yaml_node_t *tmp_4;
+ _LOR: tmp_4 = document->nodes.top;
+ (document->nodes.top) ++;
+ *tmp_4 = node;
+ tmp_5 = 1;
+ }
+ else {
+ context.error = YAML_MEMORY_ERROR;
+ tmp_5 = 0;
+ }
+ }
+ if (! tmp_5) goto error;
+ __retres = (int)(document->nodes.top - document->nodes.start);
+ goto return_label;
+ error: yaml_free((void *)items.start);
+ items.end = (yaml_node_item_t *)0;
+ items.top = items.end;
+ items.start = items.top;
+ yaml_free((void *)tag_copy);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int yaml_document_add_mapping(yaml_document_t *document,
+ yaml_char_t const *tag,
+ yaml_mapping_style_t style)
+{
+ int __retres;
+ struct __anonstruct_context_57 context;
+ yaml_node_t node;
+ int tmp_0;
+ size_t tmp;
+ int tmp_2;
+ int tmp_5;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ yaml_char_t *tag_copy = (yaml_char_t *)0;
+ struct __anonstruct_pairs_58 pairs =
+ {.start = (yaml_node_pair_t *)0,
+ .end = (yaml_node_pair_t *)0,
+ .top = (yaml_node_pair_t *)0};
+ __FC_assert(document != (yaml_document_t *)0,"src/api.c",1305,"document");
+ if (! tag) tag = (yaml_char_t const *)"tag:yaml.org,2002:map";
+ tmp = strlen((char const *)tag);
+ ;
+ tmp_0 = yaml_check_utf8(tag,tmp);
+ if (! tmp_0) goto error;
+ tag_copy = yaml_strdup(tag);
+ if (! tag_copy) goto error;
+ pairs.start = (yaml_node_pair_t *)yaml_malloc((unsigned long)16 * sizeof(*(pairs.start)));
+ if (pairs.start) {
+ pairs.top = pairs.start;
+ pairs.end = pairs.start + 16;
+ tmp_2 = 1;
+ }
+ else {
+ context.error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ if (! tmp_2) goto error;
+ memset((void *)(& node),0,sizeof(yaml_node_t));
+ node.type = YAML_MAPPING_NODE;
+ node.tag = tag_copy;
+ node.start_mark = mark;
+ node.end_mark = mark;
+ node.data.mapping.pairs.start = pairs.start;
+ node.data.mapping.pairs.end = pairs.end;
+ node.data.mapping.pairs.top = pairs.start;
+ node.data.mapping.style = style;
+ if (document->nodes.top != document->nodes.end) goto _LOR;
+ else {
+ int tmp_3;
+ tmp_3 = yaml_stack_extend((void **)(& document->nodes.start),
+ (void **)(& document->nodes.top),
+ (void **)(& document->nodes.end));
+ if (tmp_3) {
+ yaml_node_t *tmp_4;
+ _LOR: tmp_4 = document->nodes.top;
+ (document->nodes.top) ++;
+ *tmp_4 = node;
+ tmp_5 = 1;
+ }
+ else {
+ context.error = YAML_MEMORY_ERROR;
+ tmp_5 = 0;
+ }
+ }
+ if (! tmp_5) goto error;
+ __retres = (int)(document->nodes.top - document->nodes.start);
+ goto return_label;
+ error: yaml_free((void *)pairs.start);
+ pairs.end = (yaml_node_pair_t *)0;
+ pairs.top = pairs.end;
+ pairs.start = pairs.top;
+ yaml_free((void *)tag_copy);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int yaml_document_append_sequence_item(yaml_document_t *document,
+ int sequence, int item)
+{
+ int __retres;
+ struct __anonstruct_context_59 context;
+ int tmp;
+ int tmp_0;
+ int tmp_3;
+ __FC_assert(document != (yaml_document_t *)0,"src/api.c",1342,"document");
+ if (sequence > 0)
+ if (document->nodes.start + sequence <= document->nodes.top) tmp = 1;
+ else tmp = 0;
+ else tmp = 0;
+ __FC_assert(tmp != 0,"src/api.c",1343,
+ "sequence > 0 && document->nodes.start + sequence <= document->nodes.top");
+ __FC_assert(((document->nodes.start + (sequence - 1))->type == (unsigned int)YAML_SEQUENCE_NODE) != 0,
+ "src/api.c",1346,
+ "document->nodes.start[sequence-1].type == YAML_SEQUENCE_NODE");
+ if (item > 0)
+ if (document->nodes.start + item <= document->nodes.top) tmp_0 = 1;
+ else tmp_0 = 0;
+ else tmp_0 = 0;
+ __FC_assert(tmp_0 != 0,"src/api.c",1348,
+ "item > 0 && document->nodes.start + item <= document->nodes.top");
+ if ((document->nodes.start + (sequence - 1))->data.sequence.items.top != (
+ document->nodes.start + (sequence - 1))->data.sequence.items.end)
+ goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_stack_extend((void **)(& (document->nodes.start + (sequence - 1))->data.sequence.items.start),
+ (void **)(& (document->nodes.start + (sequence - 1))->data.sequence.items.top),
+ (void **)(& (document->nodes.start + (sequence - 1))->data.sequence.items.end));
+ if (tmp_1) {
+ yaml_node_item_t *tmp_2;
+ _LOR:
+ tmp_2 = (document->nodes.start + (sequence - 1))->data.sequence.items.top;
+ ((document->nodes.start + (sequence - 1))->data.sequence.items.top) ++;
+ *tmp_2 = item;
+ tmp_3 = 1;
+ }
+ else {
+ context.error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+int yaml_document_append_mapping_pair(yaml_document_t *document, int mapping,
+ int key, int value)
+{
+ int __retres;
+ struct __anonstruct_context_60 context;
+ yaml_node_pair_t pair;
+ int tmp;
+ int tmp_0;
+ int tmp_1;
+ int tmp_4;
+ __FC_assert(document != (yaml_document_t *)0,"src/api.c",1372,"document");
+ if (mapping > 0)
+ if (document->nodes.start + mapping <= document->nodes.top) tmp = 1;
+ else tmp = 0;
+ else tmp = 0;
+ __FC_assert(tmp != 0,"src/api.c",1373,
+ "mapping > 0 && document->nodes.start + mapping <= document->nodes.top");
+ __FC_assert(((document->nodes.start + (mapping - 1))->type == (unsigned int)YAML_MAPPING_NODE) != 0,
+ "src/api.c",1376,
+ "document->nodes.start[mapping-1].type == YAML_MAPPING_NODE");
+ if (key > 0)
+ if (document->nodes.start + key <= document->nodes.top) tmp_0 = 1;
+ else tmp_0 = 0;
+ else tmp_0 = 0;
+ __FC_assert(tmp_0 != 0,"src/api.c",1378,
+ "key > 0 && document->nodes.start + key <= document->nodes.top");
+ if (value > 0)
+ if (document->nodes.start + value <= document->nodes.top) tmp_1 = 1;
+ else tmp_1 = 0;
+ else tmp_1 = 0;
+ __FC_assert(tmp_1 != 0,"src/api.c",1380,
+ "value > 0 && document->nodes.start + value <= document->nodes.top");
+ pair.key = key;
+ pair.value = value;
+ if ((document->nodes.start + (mapping - 1))->data.mapping.pairs.top != (
+ document->nodes.start + (mapping - 1))->data.mapping.pairs.end)
+ goto _LOR;
+ else {
+ int tmp_2;
+ tmp_2 = yaml_stack_extend((void **)(& (document->nodes.start + (mapping - 1))->data.mapping.pairs.start),
+ (void **)(& (document->nodes.start + (mapping - 1))->data.mapping.pairs.top),
+ (void **)(& (document->nodes.start + (mapping - 1))->data.mapping.pairs.end));
+ if (tmp_2) {
+ yaml_node_pair_t *tmp_3;
+ _LOR:
+ tmp_3 = (document->nodes.start + (mapping - 1))->data.mapping.pairs.top;
+ ((document->nodes.start + (mapping - 1))->data.mapping.pairs.top) ++;
+ *tmp_3 = pair;
+ tmp_4 = 1;
+ }
+ else {
+ context.error = YAML_MEMORY_ERROR;
+ tmp_4 = 0;
+ }
+ }
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static void yaml_emitter_delete_document_and_anchors(yaml_emitter_t *emitter);
+
+static void yaml_emitter_anchor_node(yaml_emitter_t *emitter, int index_0);
+
+static yaml_char_t *yaml_emitter_generate_anchor(yaml_emitter_t *emitter __attribute__((
+ __unused__)), int anchor_id);
+
+static int yaml_emitter_dump_node(yaml_emitter_t *emitter, int index_0);
+
+static int yaml_emitter_dump_alias(yaml_emitter_t *emitter,
+ yaml_char_t *anchor);
+
+static int yaml_emitter_dump_scalar(yaml_emitter_t *emitter,
+ yaml_node_t *node, yaml_char_t *anchor);
+
+static int yaml_emitter_dump_sequence(yaml_emitter_t *emitter,
+ yaml_node_t *node, yaml_char_t *anchor);
+
+static int yaml_emitter_dump_mapping(yaml_emitter_t *emitter,
+ yaml_node_t *node, yaml_char_t *anchor);
+
+int yaml_emitter_open(yaml_emitter_t *emitter)
+{
+ int __retres;
+ yaml_event_t event;
+ int tmp;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/dumper.c",67,"emitter");
+ __FC_assert(! emitter->opened != 0,"src/dumper.c",68,"!emitter->opened");
+ memset((void *)(& event),0,sizeof(yaml_event_t));
+ event.type = YAML_STREAM_START_EVENT;
+ event.start_mark = mark;
+ event.end_mark = mark;
+ event.data.stream_start.encoding = YAML_ANY_ENCODING;
+ tmp = yaml_emitter_emit(emitter,& event);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ emitter->opened = 1;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+int yaml_emitter_close(yaml_emitter_t *emitter)
+{
+ int __retres;
+ yaml_event_t event;
+ int tmp;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/dumper.c",91,"emitter");
+ __FC_assert(emitter->opened != 0,"src/dumper.c",92,"emitter->opened");
+ if (emitter->closed) {
+ __retres = 1;
+ goto return_label;
+ }
+ memset((void *)(& event),0,sizeof(yaml_event_t));
+ event.type = YAML_STREAM_END_EVENT;
+ event.start_mark = mark;
+ event.end_mark = mark;
+ tmp = yaml_emitter_emit(emitter,& event);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ emitter->closed = 1;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+int yaml_emitter_dump(yaml_emitter_t *emitter, yaml_document_t *document)
+{
+ int __retres;
+ yaml_event_t event;
+ int tmp_2;
+ int tmp_3;
+ int tmp_4;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/dumper.c",117,"emitter");
+ __FC_assert(document != (yaml_document_t *)0,"src/dumper.c",118,"document");
+ emitter->document = document;
+ if (! emitter->opened) {
+ int tmp;
+ tmp = yaml_emitter_open(emitter);
+ if (! tmp) goto error;
+ }
+ if (document->nodes.start == document->nodes.top) {
+ int tmp_0;
+ tmp_0 = yaml_emitter_close(emitter);
+ if (! tmp_0) goto error;
+ yaml_emitter_delete_document_and_anchors(emitter);
+ __retres = 1;
+ goto return_label;
+ }
+ __FC_assert(emitter->opened != 0,"src/dumper.c",132,"emitter->opened");
+ emitter->anchors = (yaml_anchors_t *)yaml_malloc(sizeof(*(emitter->anchors)) * (unsigned long)(
+ document->nodes.top - document->nodes.start));
+ if (! emitter->anchors) goto error;
+ memset((void *)emitter->anchors,0,
+ sizeof(*(emitter->anchors)) * (unsigned long)(document->nodes.top - document->nodes.start));
+ memset((void *)(& event),0,sizeof(yaml_event_t));
+ event.type = YAML_DOCUMENT_START_EVENT;
+ event.start_mark = mark;
+ event.end_mark = mark;
+ event.data.document_start.version_directive = document->version_directive;
+ event.data.document_start.tag_directives.start = document->tag_directives.start;
+ event.data.document_start.tag_directives.end = document->tag_directives.end;
+ event.data.document_start.implicit = document->start_implicit;
+ tmp_2 = yaml_emitter_emit(emitter,& event);
+ if (! tmp_2) goto error;
+ yaml_emitter_anchor_node(emitter,1);
+ tmp_3 = yaml_emitter_dump_node(emitter,1);
+ if (! tmp_3) goto error;
+ memset((void *)(& event),0,sizeof(yaml_event_t));
+ event.type = YAML_DOCUMENT_END_EVENT;
+ event.start_mark = mark;
+ event.end_mark = mark;
+ event.data.document_end.implicit = document->end_implicit;
+ tmp_4 = yaml_emitter_emit(emitter,& event);
+ if (! tmp_4) goto error;
+ yaml_emitter_delete_document_and_anchors(emitter);
+ __retres = 1;
+ goto return_label;
+ error: yaml_emitter_delete_document_and_anchors(emitter);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static void yaml_emitter_delete_document_and_anchors(yaml_emitter_t *emitter)
+{
+ int index_0;
+ yaml_node_t *tmp_0;
+ yaml_node_t *tmp;
+ if (! emitter->anchors) {
+ yaml_document_delete(emitter->document);
+ emitter->document = (yaml_document_t *)0;
+ goto return_label;
+ }
+ index_0 = 0;
+ while ((emitter->document)->nodes.start + index_0 < (emitter->document)->nodes.top) {
+ {
+ yaml_node_t node = *((emitter->document)->nodes.start + index_0);
+ if (! (emitter->anchors + index_0)->serialized) {
+ yaml_free((void *)node.tag);
+ if (node.type == (unsigned int)YAML_SCALAR_NODE) yaml_free((void *)node.data.scalar.value);
+ }
+ if (node.type == (unsigned int)YAML_SEQUENCE_NODE) {
+ yaml_free((void *)node.data.sequence.items.start);
+ node.data.sequence.items.end = (yaml_node_item_t *)0;
+ node.data.sequence.items.top = node.data.sequence.items.end;
+ node.data.sequence.items.start = node.data.sequence.items.top;
+ }
+ if (node.type == (unsigned int)YAML_MAPPING_NODE) {
+ yaml_free((void *)node.data.mapping.pairs.start);
+ node.data.mapping.pairs.end = (yaml_node_pair_t *)0;
+ node.data.mapping.pairs.top = node.data.mapping.pairs.end;
+ node.data.mapping.pairs.start = node.data.mapping.pairs.top;
+ }
+ }
+ index_0 ++;
+ }
+ yaml_free((void *)(emitter->document)->nodes.start);
+ tmp_0 = (yaml_node_t *)0;
+ (emitter->document)->nodes.end = tmp_0;
+ tmp = tmp_0;
+ (emitter->document)->nodes.top = tmp;
+ (emitter->document)->nodes.start = tmp;
+ yaml_free((void *)emitter->anchors);
+ emitter->anchors = (yaml_anchors_t *)0;
+ emitter->last_anchor_id = 0;
+ emitter->document = (yaml_document_t *)0;
+ return_label: return;
+}
+
+static void yaml_emitter_anchor_node(yaml_emitter_t *emitter, int index_0)
+{
+ yaml_node_item_t *item;
+ yaml_node_pair_t *pair;
+ yaml_node_t *node = ((emitter->document)->nodes.start + index_0) - 1;
+ ((emitter->anchors + (index_0 - 1))->references) ++;
+ if ((emitter->anchors + (index_0 - 1))->references == 1)
+ switch (node->type) {
+ case (yaml_node_type_t)YAML_SEQUENCE_NODE:
+ item = node->data.sequence.items.start;
+ while (item < node->data.sequence.items.top) {
+ yaml_emitter_anchor_node(emitter,*item);
+ item ++;
+ }
+ break;
+ case (yaml_node_type_t)YAML_MAPPING_NODE:
+ pair = node->data.mapping.pairs.start;
+ while (pair < node->data.mapping.pairs.top) {
+ yaml_emitter_anchor_node(emitter,pair->key);
+ yaml_emitter_anchor_node(emitter,pair->value);
+ pair ++;
+ }
+ break;
+ default: break;
+ }
+ else
+ if ((emitter->anchors + (index_0 - 1))->references == 2) {
+ (emitter->last_anchor_id) ++;
+ (emitter->anchors + (index_0 - 1))->anchor = emitter->last_anchor_id;
+ }
+ return;
+}
+
+/*@ requires valid_read_string(format);
+ assigns \result, *(s + (0 ..));
+ assigns \result \from (indirect: *(format + (0 ..))), (indirect: param0);
+ assigns *(s + (0 ..)) \from (indirect: *(format + (0 ..))), param0;
+ */
+int sprintf_va_1(char * __restrict s, char const * __restrict format,
+ int param0);
+
+static yaml_char_t *yaml_emitter_generate_anchor(yaml_emitter_t *emitter __attribute__((
+ __unused__)), int anchor_id)
+{
+ yaml_char_t *__retres;
+ yaml_char_t *anchor = yaml_malloc((unsigned long)16);
+ if (! anchor) {
+ __retres = (yaml_char_t *)0;
+ goto return_label;
+ }
+ sprintf((char *)anchor,"id%03d",anchor_id); /* sprintf_va_1 */
+ __retres = anchor;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_dump_node(yaml_emitter_t *emitter, int index_0)
+{
+ int __retres;
+ yaml_node_t *node = ((emitter->document)->nodes.start + index_0) - 1;
+ int anchor_id = (emitter->anchors + (index_0 - 1))->anchor;
+ yaml_char_t *anchor = (yaml_char_t *)0;
+ if (anchor_id) {
+ anchor = yaml_emitter_generate_anchor(emitter,anchor_id);
+ if (! anchor) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if ((emitter->anchors + (index_0 - 1))->serialized) {
+ int tmp;
+ tmp = yaml_emitter_dump_alias(emitter,anchor);
+ __retres = tmp;
+ goto return_label;
+ }
+ (emitter->anchors + (index_0 - 1))->serialized = 1;
+ switch (node->type) {
+ int tmp_0;
+ int tmp_1;
+ int tmp_2;
+ case (yaml_node_type_t)YAML_SCALAR_NODE:
+ tmp_0 = yaml_emitter_dump_scalar(emitter,node,anchor);
+ __retres = tmp_0;
+ goto return_label;
+ case (yaml_node_type_t)YAML_SEQUENCE_NODE:
+ tmp_1 = yaml_emitter_dump_sequence(emitter,node,anchor);
+ __retres = tmp_1;
+ goto return_label;
+ case (yaml_node_type_t)YAML_MAPPING_NODE:
+ tmp_2 = yaml_emitter_dump_mapping(emitter,node,anchor);
+ __retres = tmp_2;
+ goto return_label;
+ default: __FC_assert(0 != 0,"src/dumper.c",289,"0");
+ break;
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_dump_alias(yaml_emitter_t *emitter,
+ yaml_char_t *anchor)
+{
+ yaml_event_t event;
+ int tmp;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ memset((void *)(& event),0,sizeof(yaml_event_t));
+ event.type = YAML_ALIAS_EVENT;
+ event.start_mark = mark;
+ event.end_mark = mark;
+ event.data.alias.anchor = anchor;
+ tmp = yaml_emitter_emit(emitter,& event);
+ return tmp;
+}
+
+static int yaml_emitter_dump_scalar(yaml_emitter_t *emitter,
+ yaml_node_t *node, yaml_char_t *anchor)
+{
+ yaml_event_t event;
+ int tmp;
+ int tmp_0;
+ int tmp_1;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ tmp = strcmp((char const *)node->tag,"tag:yaml.org,2002:str");
+ int plain_implicit = tmp == 0;
+ tmp_0 = strcmp((char const *)node->tag,"tag:yaml.org,2002:str");
+ int quoted_implicit = tmp_0 == 0;
+ memset((void *)(& event),0,sizeof(yaml_event_t));
+ event.type = YAML_SCALAR_EVENT;
+ event.start_mark = mark;
+ event.end_mark = mark;
+ event.data.scalar.anchor = anchor;
+ event.data.scalar.tag = node->tag;
+ event.data.scalar.value = node->data.scalar.value;
+ event.data.scalar.length = node->data.scalar.length;
+ event.data.scalar.plain_implicit = plain_implicit;
+ event.data.scalar.quoted_implicit = quoted_implicit;
+ event.data.scalar.style = node->data.scalar.style;
+ tmp_1 = yaml_emitter_emit(emitter,& event);
+ return tmp_1;
+}
+
+static int yaml_emitter_dump_sequence(yaml_emitter_t *emitter,
+ yaml_node_t *node, yaml_char_t *anchor)
+{
+ int __retres;
+ yaml_event_t event;
+ int tmp;
+ yaml_node_item_t *item;
+ int tmp_0;
+ int tmp_2;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ tmp = strcmp((char const *)node->tag,"tag:yaml.org,2002:seq");
+ int implicit = tmp == 0;
+ memset((void *)(& event),0,sizeof(yaml_event_t));
+ event.type = YAML_SEQUENCE_START_EVENT;
+ event.start_mark = mark;
+ event.end_mark = mark;
+ event.data.sequence_start.anchor = anchor;
+ event.data.sequence_start.tag = node->tag;
+ event.data.sequence_start.implicit = implicit;
+ event.data.sequence_start.style = node->data.sequence.style;
+ tmp_0 = yaml_emitter_emit(emitter,& event);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ item = node->data.sequence.items.start;
+ while (item < node->data.sequence.items.top) {
+ {
+ int tmp_1;
+ tmp_1 = yaml_emitter_dump_node(emitter,*item);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ item ++;
+ }
+ memset((void *)(& event),0,sizeof(yaml_event_t));
+ event.type = YAML_SEQUENCE_END_EVENT;
+ event.start_mark = mark;
+ event.end_mark = mark;
+ tmp_2 = yaml_emitter_emit(emitter,& event);
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_dump_mapping(yaml_emitter_t *emitter,
+ yaml_node_t *node, yaml_char_t *anchor)
+{
+ int __retres;
+ yaml_event_t event;
+ int tmp;
+ yaml_node_pair_t *pair;
+ int tmp_0;
+ int tmp_3;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ tmp = strcmp((char const *)node->tag,"tag:yaml.org,2002:map");
+ int implicit = tmp == 0;
+ memset((void *)(& event),0,sizeof(yaml_event_t));
+ event.type = YAML_MAPPING_START_EVENT;
+ event.start_mark = mark;
+ event.end_mark = mark;
+ event.data.mapping_start.anchor = anchor;
+ event.data.mapping_start.tag = node->tag;
+ event.data.mapping_start.implicit = implicit;
+ event.data.mapping_start.style = node->data.mapping.style;
+ tmp_0 = yaml_emitter_emit(emitter,& event);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ pair = node->data.mapping.pairs.start;
+ while (pair < node->data.mapping.pairs.top) {
+ {
+ int tmp_1;
+ int tmp_2;
+ tmp_1 = yaml_emitter_dump_node(emitter,pair->key);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_2 = yaml_emitter_dump_node(emitter,pair->value);
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ pair ++;
+ }
+ memset((void *)(& event),0,sizeof(yaml_event_t));
+ event.type = YAML_MAPPING_END_EVENT;
+ event.start_mark = mark;
+ event.end_mark = mark;
+ tmp_3 = yaml_emitter_emit(emitter,& event);
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_set_emitter_error(yaml_emitter_t *emitter,
+ char const *problem);
+
+static int yaml_emitter_need_more_events(yaml_emitter_t *emitter);
+
+static int yaml_emitter_append_tag_directive(yaml_emitter_t *emitter,
+ yaml_tag_directive_t value,
+ int allow_duplicates);
+
+static int yaml_emitter_increase_indent(yaml_emitter_t *emitter, int flow,
+ int indentless);
+
+static int yaml_emitter_state_machine(yaml_emitter_t *emitter,
+ yaml_event_t *event);
+
+static int yaml_emitter_emit_stream_start(yaml_emitter_t *emitter,
+ yaml_event_t *event);
+
+static int yaml_emitter_emit_document_start(yaml_emitter_t *emitter,
+ yaml_event_t *event, int first);
+
+static int yaml_emitter_emit_document_content(yaml_emitter_t *emitter,
+ yaml_event_t *event);
+
+static int yaml_emitter_emit_document_end(yaml_emitter_t *emitter,
+ yaml_event_t *event);
+
+static int yaml_emitter_emit_flow_sequence_item(yaml_emitter_t *emitter,
+ yaml_event_t *event,
+ int first);
+
+static int yaml_emitter_emit_flow_mapping_key(yaml_emitter_t *emitter,
+ yaml_event_t *event, int first);
+
+static int yaml_emitter_emit_flow_mapping_value(yaml_emitter_t *emitter,
+ yaml_event_t *event,
+ int simple);
+
+static int yaml_emitter_emit_block_sequence_item(yaml_emitter_t *emitter,
+ yaml_event_t *event,
+ int first);
+
+static int yaml_emitter_emit_block_mapping_key(yaml_emitter_t *emitter,
+ yaml_event_t *event, int first);
+
+static int yaml_emitter_emit_block_mapping_value(yaml_emitter_t *emitter,
+ yaml_event_t *event,
+ int simple);
+
+static int yaml_emitter_emit_node(yaml_emitter_t *emitter,
+ yaml_event_t *event, int root,
+ int sequence, int mapping, int simple_key);
+
+static int yaml_emitter_emit_alias(yaml_emitter_t *emitter,
+ yaml_event_t *event __attribute__((
+ __unused__)));
+
+static int yaml_emitter_emit_scalar(yaml_emitter_t *emitter,
+ yaml_event_t *event);
+
+static int yaml_emitter_emit_sequence_start(yaml_emitter_t *emitter,
+ yaml_event_t *event);
+
+static int yaml_emitter_emit_mapping_start(yaml_emitter_t *emitter,
+ yaml_event_t *event);
+
+static int yaml_emitter_check_empty_document(yaml_emitter_t *emitter __attribute__((
+ __unused__)));
+
+static int yaml_emitter_check_empty_sequence(yaml_emitter_t *emitter);
+
+static int yaml_emitter_check_empty_mapping(yaml_emitter_t *emitter);
+
+static int yaml_emitter_check_simple_key(yaml_emitter_t *emitter);
+
+static int yaml_emitter_select_scalar_style(yaml_emitter_t *emitter,
+ yaml_event_t *event);
+
+static int yaml_emitter_process_anchor(yaml_emitter_t *emitter);
+
+static int yaml_emitter_process_tag(yaml_emitter_t *emitter);
+
+static int yaml_emitter_process_scalar(yaml_emitter_t *emitter);
+
+static int yaml_emitter_analyze_version_directive(yaml_emitter_t *emitter,
+ yaml_version_directive_t version_directive);
+
+static int yaml_emitter_analyze_tag_directive(yaml_emitter_t *emitter,
+ yaml_tag_directive_t tag_directive);
+
+static int yaml_emitter_analyze_anchor(yaml_emitter_t *emitter,
+ yaml_char_t *anchor, int alias);
+
+static int yaml_emitter_analyze_tag(yaml_emitter_t *emitter, yaml_char_t *tag);
+
+static int yaml_emitter_analyze_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length);
+
+static int yaml_emitter_analyze_event(yaml_emitter_t *emitter,
+ yaml_event_t *event);
+
+static int yaml_emitter_write_bom(yaml_emitter_t *emitter);
+
+static int yaml_emitter_write_indent(yaml_emitter_t *emitter);
+
+static int yaml_emitter_write_indicator(yaml_emitter_t *emitter,
+ char const *indicator,
+ int need_whitespace,
+ int is_whitespace, int is_indention);
+
+static int yaml_emitter_write_anchor(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length);
+
+static int yaml_emitter_write_tag_handle(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length);
+
+static int yaml_emitter_write_tag_content(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length,
+ int need_whitespace);
+
+static int yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length,
+ int allow_breaks);
+
+static int yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value,
+ size_t length,
+ int allow_breaks);
+
+static int yaml_emitter_write_double_quoted_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value,
+ size_t length,
+ int allow_breaks);
+
+static int yaml_emitter_write_block_scalar_hints(yaml_emitter_t *emitter,
+ yaml_string_t string);
+
+static int yaml_emitter_write_literal_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value,
+ size_t length);
+
+static int yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length);
+
+static int yaml_emitter_set_emitter_error(yaml_emitter_t *emitter,
+ char const *problem)
+{
+ int __retres;
+ emitter->error = YAML_EMITTER_ERROR;
+ emitter->problem = problem;
+ __retres = 0;
+ return __retres;
+}
+
+int yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event)
+{
+ int __retres;
+ int tmp_1;
+ if (emitter->events.tail != emitter->events.end) goto _LOR;
+ else {
+ int tmp;
+ tmp = yaml_queue_extend((void **)(& emitter->events.start),
+ (void **)(& emitter->events.head),
+ (void **)(& emitter->events.tail),
+ (void **)(& emitter->events.end));
+ if (tmp) {
+ yaml_event_t *tmp_0;
+ _LOR: tmp_0 = emitter->events.tail;
+ (emitter->events.tail) ++;
+ *tmp_0 = *event;
+ tmp_1 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_1 = 0;
+ }
+ }
+ if (! tmp_1) {
+ yaml_event_delete(event);
+ __retres = 0;
+ goto return_label;
+ }
+ while (1) {
+ int tmp_5;
+ tmp_5 = yaml_emitter_need_more_events(emitter);
+ if (tmp_5) break;
+ {
+ int tmp_2;
+ int tmp_3;
+ yaml_event_t *tmp_4;
+ tmp_2 = yaml_emitter_analyze_event(emitter,emitter->events.head);
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_3 = yaml_emitter_state_machine(emitter,emitter->events.head);
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_4 = emitter->events.head;
+ (emitter->events.head) ++;
+ ;
+ yaml_event_delete(tmp_4);
+ }
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_need_more_events(yaml_emitter_t *emitter)
+{
+ int __retres;
+ yaml_event_t *event;
+ int level = 0;
+ int accumulate = 0;
+ if (emitter->events.head == emitter->events.tail) {
+ __retres = 1;
+ goto return_label;
+ }
+ switch ((emitter->events.head)->type) {
+ case (yaml_event_type_t)YAML_DOCUMENT_START_EVENT: accumulate = 1;
+ break;
+ case (yaml_event_type_t)YAML_SEQUENCE_START_EVENT: accumulate = 2;
+ break;
+ case (yaml_event_type_t)YAML_MAPPING_START_EVENT: accumulate = 3;
+ break;
+ default: __retres = 0;
+ goto return_label;
+ }
+ if (emitter->events.tail - emitter->events.head > (long)accumulate) {
+ __retres = 0;
+ goto return_label;
+ }
+ event = emitter->events.head;
+ while (event != emitter->events.tail) {
+ switch (event->type) {
+ case (yaml_event_type_t)YAML_STREAM_START_EVENT:
+ case (yaml_event_type_t)YAML_DOCUMENT_START_EVENT:
+ case (yaml_event_type_t)YAML_SEQUENCE_START_EVENT:
+ case (yaml_event_type_t)YAML_MAPPING_START_EVENT:
+ level ++;
+ break;
+ case (yaml_event_type_t)YAML_STREAM_END_EVENT:
+ case (yaml_event_type_t)YAML_DOCUMENT_END_EVENT:
+ case (yaml_event_type_t)YAML_SEQUENCE_END_EVENT:
+ case (yaml_event_type_t)YAML_MAPPING_END_EVENT:
+ level --;
+ break;
+ default: break;
+ }
+ if (! level) {
+ __retres = 0;
+ goto return_label;
+ }
+ event ++;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_append_tag_directive(yaml_emitter_t *emitter,
+ yaml_tag_directive_t value,
+ int allow_duplicates)
+{
+ int __retres;
+ yaml_tag_directive_t *tag_directive;
+ int tmp_3;
+ yaml_tag_directive_t copy =
+ {.handle = (yaml_char_t *)0, .prefix = (yaml_char_t *)0};
+ tag_directive = emitter->tag_directives.start;
+ while (tag_directive != emitter->tag_directives.top) {
+ {
+ int tmp_0;
+ tmp_0 = strcmp((char const *)value.handle,
+ (char const *)tag_directive->handle);
+ if (tmp_0 == 0) {
+ int tmp;
+ if (allow_duplicates) {
+ __retres = 1;
+ goto return_label;
+ }
+ tmp = yaml_emitter_set_emitter_error(emitter,
+ "duplicate %TAG directive");
+ __retres = tmp;
+ goto return_label;
+ }
+ }
+ tag_directive ++;
+ }
+ copy.handle = yaml_strdup((yaml_char_t const *)value.handle);
+ copy.prefix = yaml_strdup((yaml_char_t const *)value.prefix);
+ if (! copy.handle) goto _LOR;
+ else
+ if (! copy.prefix) {
+ _LOR: {
+ emitter->error = YAML_MEMORY_ERROR;
+ goto error;
+ }
+ }
+ if (emitter->tag_directives.top != emitter->tag_directives.end) goto _LOR_0;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_stack_extend((void **)(& emitter->tag_directives.start),
+ (void **)(& emitter->tag_directives.top),
+ (void **)(& emitter->tag_directives.end));
+ if (tmp_1) {
+ yaml_tag_directive_t *tmp_2;
+ _LOR_0: tmp_2 = emitter->tag_directives.top;
+ (emitter->tag_directives.top) ++;
+ *tmp_2 = copy;
+ tmp_3 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) goto error;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)copy.handle);
+ yaml_free((void *)copy.prefix);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_increase_indent(yaml_emitter_t *emitter, int flow,
+ int indentless)
+{
+ int __retres;
+ int tmp_1;
+ if (emitter->indents.top != emitter->indents.end) goto _LOR;
+ else {
+ int tmp;
+ tmp = yaml_stack_extend((void **)(& emitter->indents.start),
+ (void **)(& emitter->indents.top),
+ (void **)(& emitter->indents.end));
+ if (tmp) {
+ int *tmp_0;
+ _LOR: tmp_0 = emitter->indents.top;
+ (emitter->indents.top) ++;
+ *tmp_0 = emitter->indent;
+ tmp_1 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_1 = 0;
+ }
+ }
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (emitter->indent < 0)
+ if (flow) emitter->indent = emitter->best_indent;
+ else emitter->indent = 0;
+ else
+ if (! indentless) emitter->indent += emitter->best_indent;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_state_machine(yaml_emitter_t *emitter,
+ yaml_event_t *event)
+{
+ int __retres;
+ switch (emitter->state) {
+ int tmp;
+ int tmp_0;
+ int tmp_1;
+ int tmp_2;
+ int tmp_3;
+ int tmp_4;
+ int tmp_5;
+ int tmp_6;
+ int tmp_7;
+ int tmp_8;
+ int tmp_9;
+ int tmp_10;
+ int tmp_11;
+ int tmp_12;
+ int tmp_13;
+ int tmp_14;
+ int tmp_15;
+ int tmp_16;
+ case (yaml_emitter_state_t)YAML_EMIT_STREAM_START_STATE:
+ tmp = yaml_emitter_emit_stream_start(emitter,event);
+ __retres = tmp;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_FIRST_DOCUMENT_START_STATE:
+ tmp_0 = yaml_emitter_emit_document_start(emitter,event,1);
+ __retres = tmp_0;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_DOCUMENT_START_STATE:
+ tmp_1 = yaml_emitter_emit_document_start(emitter,event,0);
+ __retres = tmp_1;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_DOCUMENT_CONTENT_STATE:
+ tmp_2 = yaml_emitter_emit_document_content(emitter,event);
+ __retres = tmp_2;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_DOCUMENT_END_STATE:
+ tmp_3 = yaml_emitter_emit_document_end(emitter,event);
+ __retres = tmp_3;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE:
+ tmp_4 = yaml_emitter_emit_flow_sequence_item(emitter,event,1);
+ __retres = tmp_4;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE:
+ tmp_5 = yaml_emitter_emit_flow_sequence_item(emitter,event,0);
+ __retres = tmp_5;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE:
+ tmp_6 = yaml_emitter_emit_flow_mapping_key(emitter,event,1);
+ __retres = tmp_6;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_FLOW_MAPPING_KEY_STATE:
+ tmp_7 = yaml_emitter_emit_flow_mapping_key(emitter,event,0);
+ __retres = tmp_7;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE:
+ tmp_8 = yaml_emitter_emit_flow_mapping_value(emitter,event,1);
+ __retres = tmp_8;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_FLOW_MAPPING_VALUE_STATE:
+ tmp_9 = yaml_emitter_emit_flow_mapping_value(emitter,event,0);
+ __retres = tmp_9;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE:
+ tmp_10 = yaml_emitter_emit_block_sequence_item(emitter,event,1);
+ __retres = tmp_10;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE:
+ tmp_11 = yaml_emitter_emit_block_sequence_item(emitter,event,0);
+ __retres = tmp_11;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE:
+ tmp_12 = yaml_emitter_emit_block_mapping_key(emitter,event,1);
+ __retres = tmp_12;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_BLOCK_MAPPING_KEY_STATE:
+ tmp_13 = yaml_emitter_emit_block_mapping_key(emitter,event,0);
+ __retres = tmp_13;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE:
+ tmp_14 = yaml_emitter_emit_block_mapping_value(emitter,event,1);
+ __retres = tmp_14;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_BLOCK_MAPPING_VALUE_STATE:
+ tmp_15 = yaml_emitter_emit_block_mapping_value(emitter,event,0);
+ __retres = tmp_15;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_END_STATE:
+ tmp_16 = yaml_emitter_set_emitter_error(emitter,
+ "expected nothing after STREAM-END");
+ __retres = tmp_16;
+ goto return_label;
+ default: __FC_assert(1 != 0,"src/emitter.c",484,"1");
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_stream_start(yaml_emitter_t *emitter,
+ yaml_event_t *event)
+{
+ int __retres;
+ int tmp_0;
+ emitter->open_ended = 0;
+ if (event->type == (unsigned int)YAML_STREAM_START_EVENT) {
+ if (! emitter->encoding) emitter->encoding = event->data.stream_start.encoding;
+ if (! emitter->encoding) emitter->encoding = YAML_UTF8_ENCODING;
+ if (emitter->best_indent < 2) goto _LOR;
+ else
+ if (emitter->best_indent > 9) _LOR: emitter->best_indent = 2;
+ if (emitter->best_width >= 0)
+ if (emitter->best_width <= emitter->best_indent * 2) emitter->best_width = 80;
+ if (emitter->best_width < 0) emitter->best_width = 2147483647;
+ if (! emitter->line_break) emitter->line_break = YAML_LN_BREAK;
+ emitter->indent = -1;
+ emitter->line = 0;
+ emitter->column = 0;
+ emitter->whitespace = 1;
+ emitter->indention = 1;
+ if (emitter->encoding != (unsigned int)YAML_UTF8_ENCODING) {
+ int tmp;
+ tmp = yaml_emitter_write_bom(emitter);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->state = YAML_EMIT_FIRST_DOCUMENT_START_STATE;
+ __retres = 1;
+ goto return_label;
+ }
+ tmp_0 = yaml_emitter_set_emitter_error(emitter,"expected STREAM-START");
+ __retres = tmp_0;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_document_start(yaml_emitter_t *emitter,
+ yaml_event_t *event, int first)
+{
+ int __retres;
+ int tmp_22;
+ if (event->type == (unsigned int)YAML_DOCUMENT_START_EVENT) {
+ yaml_tag_directive_t *tag_directive;
+ int implicit;
+ int tmp_15;
+ yaml_tag_directive_t default_tag_directives[3] =
+ {{.handle = (yaml_char_t *)"!", .prefix = (yaml_char_t *)"!"},
+ {.handle = (yaml_char_t *)"!!",
+ .prefix = (yaml_char_t *)"tag:yaml.org,2002:"},
+ {.handle = (yaml_char_t *)0, .prefix = (yaml_char_t *)0}};
+ if (event->data.document_start.version_directive) {
+ int tmp;
+ tmp = yaml_emitter_analyze_version_directive(emitter,
+ *(event->data.document_start.version_directive));
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ tag_directive = event->data.document_start.tag_directives.start;
+ while (tag_directive != event->data.document_start.tag_directives.end) {
+ {
+ int tmp_0;
+ int tmp_1;
+ tmp_0 = yaml_emitter_analyze_tag_directive(emitter,*tag_directive);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_1 = yaml_emitter_append_tag_directive(emitter,*tag_directive,0);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ tag_directive ++;
+ }
+ tag_directive = default_tag_directives;
+ while (tag_directive->handle) {
+ {
+ int tmp_2;
+ tmp_2 = yaml_emitter_append_tag_directive(emitter,*tag_directive,1);
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ tag_directive ++;
+ }
+ implicit = event->data.document_start.implicit;
+ if (! first) goto _LOR;
+ else
+ if (emitter->canonical) _LOR: implicit = 0;
+ if (event->data.document_start.version_directive) goto _LOR_0;
+ else
+ if (event->data.document_start.tag_directives.start != event->data.document_start.tag_directives.end) {
+ _LOR_0: ;
+ if (emitter->open_ended) {
+ int tmp_3;
+ int tmp_4;
+ tmp_3 = yaml_emitter_write_indicator(emitter,"...",1,0,0);
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_4 = yaml_emitter_write_indent(emitter);
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ emitter->open_ended = 0;
+ if (event->data.document_start.version_directive) {
+ int tmp_5;
+ int tmp_8;
+ implicit = 0;
+ tmp_5 = yaml_emitter_write_indicator(emitter,"%YAML",1,0,0);
+ if (! tmp_5) {
+ __retres = 0;
+ goto return_label;
+ }
+ if ((event->data.document_start.version_directive)->minor == 1) {
+ int tmp_6;
+ tmp_6 = yaml_emitter_write_indicator(emitter,"1.1",1,0,0);
+ if (! tmp_6) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ else {
+ int tmp_7;
+ tmp_7 = yaml_emitter_write_indicator(emitter,"1.2",1,0,0);
+ if (! tmp_7) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ tmp_8 = yaml_emitter_write_indent(emitter);
+ if (! tmp_8) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (event->data.document_start.tag_directives.start != event->data.document_start.tag_directives.end) {
+ implicit = 0;
+ tag_directive = event->data.document_start.tag_directives.start;
+ while (tag_directive != event->data.document_start.tag_directives.end) {
+ {
+ int tmp_9;
+ int tmp_11;
+ size_t tmp_10;
+ int tmp_13;
+ size_t tmp_12;
+ int tmp_14;
+ tmp_9 = yaml_emitter_write_indicator(emitter,"%TAG",1,0,0);
+ if (! tmp_9) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_10 = strlen((char const *)tag_directive->handle);
+ ;
+ ;
+ tmp_11 = yaml_emitter_write_tag_handle(emitter,
+ tag_directive->handle,
+ tmp_10);
+ if (! tmp_11) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_12 = strlen((char const *)tag_directive->prefix);
+ ;
+ ;
+ tmp_13 = yaml_emitter_write_tag_content(emitter,
+ tag_directive->prefix,
+ tmp_12,1);
+ if (! tmp_13) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_14 = yaml_emitter_write_indent(emitter);
+ if (! tmp_14) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ tag_directive ++;
+ }
+ }
+ tmp_15 = yaml_emitter_check_empty_document(emitter);
+ if (tmp_15) implicit = 0;
+ if (! implicit) {
+ int tmp_16;
+ int tmp_17;
+ tmp_16 = yaml_emitter_write_indent(emitter);
+ if (! tmp_16) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_17 = yaml_emitter_write_indicator(emitter,"---",1,0,0);
+ if (! tmp_17) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (emitter->canonical) {
+ int tmp_18;
+ tmp_18 = yaml_emitter_write_indent(emitter);
+ if (! tmp_18) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ emitter->state = YAML_EMIT_DOCUMENT_CONTENT_STATE;
+ emitter->open_ended = 0;
+ __retres = 1;
+ goto return_label;
+ }
+ else
+ if (event->type == (unsigned int)YAML_STREAM_END_EVENT) {
+ int tmp_21;
+ if (emitter->open_ended == 2) {
+ int tmp_19;
+ int tmp_20;
+ tmp_19 = yaml_emitter_write_indicator(emitter,"...",1,0,0);
+ if (! tmp_19) {
+ __retres = 0;
+ goto return_label;
+ }
+ emitter->open_ended = 0;
+ tmp_20 = yaml_emitter_write_indent(emitter);
+ if (! tmp_20) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ tmp_21 = yaml_emitter_flush(emitter);
+ if (! tmp_21) {
+ __retres = 0;
+ goto return_label;
+ }
+ emitter->state = YAML_EMIT_END_STATE;
+ __retres = 1;
+ goto return_label;
+ }
+ tmp_22 = yaml_emitter_set_emitter_error(emitter,
+ "expected DOCUMENT-START or STREAM-END");
+ __retres = tmp_22;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_document_content(yaml_emitter_t *emitter,
+ yaml_event_t *event)
+{
+ int __retres;
+ int tmp_1;
+ int tmp_2;
+ if (emitter->states.top != emitter->states.end) goto _LOR;
+ else {
+ int tmp;
+ tmp = yaml_stack_extend((void **)(& emitter->states.start),
+ (void **)(& emitter->states.top),
+ (void **)(& emitter->states.end));
+ if (tmp) {
+ yaml_emitter_state_t *tmp_0;
+ _LOR: tmp_0 = emitter->states.top;
+ (emitter->states.top) ++;
+ *tmp_0 = YAML_EMIT_DOCUMENT_END_STATE;
+ tmp_1 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_1 = 0;
+ }
+ }
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_2 = yaml_emitter_emit_node(emitter,event,1,0,0,0);
+ __retres = tmp_2;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_document_end(yaml_emitter_t *emitter,
+ yaml_event_t *event)
+{
+ int __retres;
+ int tmp_3;
+ if (event->type == (unsigned int)YAML_DOCUMENT_END_EVENT) {
+ int tmp;
+ int tmp_2;
+ tmp = yaml_emitter_write_indent(emitter);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (! event->data.document_end.implicit) {
+ int tmp_0;
+ int tmp_1;
+ tmp_0 = yaml_emitter_write_indicator(emitter,"...",1,0,0);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ emitter->open_ended = 0;
+ tmp_1 = yaml_emitter_write_indent(emitter);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ else
+ if (! emitter->open_ended) emitter->open_ended = 1;
+ tmp_2 = yaml_emitter_flush(emitter);
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ emitter->state = YAML_EMIT_DOCUMENT_START_STATE;
+ while (! (emitter->tag_directives.start == emitter->tag_directives.top)) {
+ (emitter->tag_directives.top) --;
+ yaml_tag_directive_t tag_directive = *(emitter->tag_directives.top);
+ yaml_free((void *)tag_directive.handle);
+ yaml_free((void *)tag_directive.prefix);
+ }
+ __retres = 1;
+ goto return_label;
+ }
+ tmp_3 = yaml_emitter_set_emitter_error(emitter,"expected DOCUMENT-END");
+ __retres = tmp_3;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_flow_sequence_item(yaml_emitter_t *emitter,
+ yaml_event_t *event,
+ int first)
+{
+ int __retres;
+ int tmp_8;
+ int tmp_9;
+ if (first) {
+ int tmp;
+ int tmp_0;
+ tmp = yaml_emitter_write_indicator(emitter,"[",1,1,0);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_0 = yaml_emitter_increase_indent(emitter,1,0);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ (emitter->flow_level) ++;
+ }
+ if (event->type == (unsigned int)YAML_SEQUENCE_END_EVENT) {
+ int tmp_3;
+ (emitter->flow_level) --;
+ (emitter->indents.top) --;
+ emitter->indent = *(emitter->indents.top);
+ if (emitter->canonical)
+ if (! first) {
+ int tmp_1;
+ int tmp_2;
+ tmp_1 = yaml_emitter_write_indicator(emitter,",",0,0,0);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_2 = yaml_emitter_write_indent(emitter);
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ tmp_3 = yaml_emitter_write_indicator(emitter,"]",0,0,0);
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ (emitter->states.top) --;
+ emitter->state = *(emitter->states.top);
+ __retres = 1;
+ goto return_label;
+ }
+ if (! first) {
+ int tmp_4;
+ tmp_4 = yaml_emitter_write_indicator(emitter,",",0,0,0);
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (emitter->canonical) goto _LOR;
+ else
+ if (emitter->column > emitter->best_width) {
+ _LOR:
+ {
+ int tmp_5;
+ tmp_5 = yaml_emitter_write_indent(emitter);
+ if (! tmp_5) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ if (emitter->states.top != emitter->states.end) goto _LOR_0;
+ else {
+ int tmp_6;
+ tmp_6 = yaml_stack_extend((void **)(& emitter->states.start),
+ (void **)(& emitter->states.top),
+ (void **)(& emitter->states.end));
+ if (tmp_6) {
+ yaml_emitter_state_t *tmp_7;
+ _LOR_0: tmp_7 = emitter->states.top;
+ (emitter->states.top) ++;
+ *tmp_7 = YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE;
+ tmp_8 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_8 = 0;
+ }
+ }
+ if (! tmp_8) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_9 = yaml_emitter_emit_node(emitter,event,0,1,0,0);
+ __retres = tmp_9;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_flow_mapping_key(yaml_emitter_t *emitter,
+ yaml_event_t *event, int first)
+{
+ int __retres;
+ if (first) {
+ int tmp;
+ int tmp_0;
+ tmp = yaml_emitter_write_indicator(emitter,"{",1,1,0);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_0 = yaml_emitter_increase_indent(emitter,1,0);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ (emitter->flow_level) ++;
+ }
+ if (event->type == (unsigned int)YAML_MAPPING_END_EVENT) {
+ int tmp_3;
+ (emitter->flow_level) --;
+ (emitter->indents.top) --;
+ emitter->indent = *(emitter->indents.top);
+ if (emitter->canonical)
+ if (! first) {
+ int tmp_1;
+ int tmp_2;
+ tmp_1 = yaml_emitter_write_indicator(emitter,",",0,0,0);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_2 = yaml_emitter_write_indent(emitter);
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ tmp_3 = yaml_emitter_write_indicator(emitter,"}",0,0,0);
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ (emitter->states.top) --;
+ emitter->state = *(emitter->states.top);
+ __retres = 1;
+ goto return_label;
+ }
+ if (! first) {
+ int tmp_4;
+ tmp_4 = yaml_emitter_write_indicator(emitter,",",0,0,0);
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (emitter->canonical) goto _LOR;
+ else
+ if (emitter->column > emitter->best_width) {
+ _LOR:
+ {
+ int tmp_5;
+ tmp_5 = yaml_emitter_write_indent(emitter);
+ if (! tmp_5) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ if (! emitter->canonical) {
+ int tmp_15;
+ tmp_15 = yaml_emitter_check_simple_key(emitter);
+ if (tmp_15) {
+ int tmp_8;
+ int tmp_9;
+ if (emitter->states.top != emitter->states.end) goto _LOR_0;
+ else {
+ int tmp_6;
+ tmp_6 = yaml_stack_extend((void **)(& emitter->states.start),
+ (void **)(& emitter->states.top),
+ (void **)(& emitter->states.end));
+ if (tmp_6) {
+ yaml_emitter_state_t *tmp_7;
+ _LOR_0: tmp_7 = emitter->states.top;
+ (emitter->states.top) ++;
+ *tmp_7 = YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE;
+ tmp_8 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_8 = 0;
+ }
+ }
+ if (! tmp_8) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_9 = yaml_emitter_emit_node(emitter,event,0,0,1,1);
+ __retres = tmp_9;
+ goto return_label;
+ }
+ else goto _LAND;
+ }
+ else {
+ _LAND:
+ {
+ int tmp_10;
+ int tmp_13;
+ int tmp_14;
+ tmp_10 = yaml_emitter_write_indicator(emitter,"?",1,0,0);
+ if (! tmp_10) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (emitter->states.top != emitter->states.end) goto _LOR_1;
+ else {
+ int tmp_11;
+ tmp_11 = yaml_stack_extend((void **)(& emitter->states.start),
+ (void **)(& emitter->states.top),
+ (void **)(& emitter->states.end));
+ if (tmp_11) {
+ yaml_emitter_state_t *tmp_12;
+ _LOR_1: tmp_12 = emitter->states.top;
+ (emitter->states.top) ++;
+ *tmp_12 = YAML_EMIT_FLOW_MAPPING_VALUE_STATE;
+ tmp_13 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_13 = 0;
+ }
+ }
+ if (! tmp_13) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_14 = yaml_emitter_emit_node(emitter,event,0,0,1,0);
+ __retres = tmp_14;
+ goto return_label;
+ }
+ }
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_flow_mapping_value(yaml_emitter_t *emitter,
+ yaml_event_t *event,
+ int simple)
+{
+ int __retres;
+ int tmp_4;
+ int tmp_5;
+ if (simple) {
+ int tmp;
+ tmp = yaml_emitter_write_indicator(emitter,":",0,0,0);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ else {
+ int tmp_1;
+ if (emitter->canonical) goto _LOR;
+ else
+ if (emitter->column > emitter->best_width) {
+ _LOR:
+ {
+ int tmp_0;
+ tmp_0 = yaml_emitter_write_indent(emitter);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ tmp_1 = yaml_emitter_write_indicator(emitter,":",1,0,0);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (emitter->states.top != emitter->states.end) goto _LOR_0;
+ else {
+ int tmp_2;
+ tmp_2 = yaml_stack_extend((void **)(& emitter->states.start),
+ (void **)(& emitter->states.top),
+ (void **)(& emitter->states.end));
+ if (tmp_2) {
+ yaml_emitter_state_t *tmp_3;
+ _LOR_0: tmp_3 = emitter->states.top;
+ (emitter->states.top) ++;
+ *tmp_3 = YAML_EMIT_FLOW_MAPPING_KEY_STATE;
+ tmp_4 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_4 = 0;
+ }
+ }
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_5 = yaml_emitter_emit_node(emitter,event,0,0,1,0);
+ __retres = tmp_5;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_block_sequence_item(yaml_emitter_t *emitter,
+ yaml_event_t *event,
+ int first)
+{
+ int __retres;
+ int tmp_1;
+ int tmp_2;
+ int tmp_5;
+ int tmp_6;
+ if (first) {
+ int tmp_0;
+ int tmp;
+ if (emitter->mapping_context)
+ if (! emitter->indention) tmp = 1; else tmp = 0;
+ else tmp = 0;
+ ;
+ tmp_0 = yaml_emitter_increase_indent(emitter,0,tmp);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (event->type == (unsigned int)YAML_SEQUENCE_END_EVENT) {
+ (emitter->indents.top) --;
+ emitter->indent = *(emitter->indents.top);
+ (emitter->states.top) --;
+ emitter->state = *(emitter->states.top);
+ __retres = 1;
+ goto return_label;
+ }
+ tmp_1 = yaml_emitter_write_indent(emitter);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_2 = yaml_emitter_write_indicator(emitter,"-",1,0,1);
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (emitter->states.top != emitter->states.end) goto _LOR;
+ else {
+ int tmp_3;
+ tmp_3 = yaml_stack_extend((void **)(& emitter->states.start),
+ (void **)(& emitter->states.top),
+ (void **)(& emitter->states.end));
+ if (tmp_3) {
+ yaml_emitter_state_t *tmp_4;
+ _LOR: tmp_4 = emitter->states.top;
+ (emitter->states.top) ++;
+ *tmp_4 = YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE;
+ tmp_5 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_5 = 0;
+ }
+ }
+ if (! tmp_5) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_6 = yaml_emitter_emit_node(emitter,event,0,1,0,0);
+ __retres = tmp_6;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_block_mapping_key(yaml_emitter_t *emitter,
+ yaml_event_t *event, int first)
+{
+ int __retres;
+ int tmp_0;
+ int tmp_10;
+ if (first) {
+ int tmp;
+ tmp = yaml_emitter_increase_indent(emitter,0,0);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (event->type == (unsigned int)YAML_MAPPING_END_EVENT) {
+ (emitter->indents.top) --;
+ emitter->indent = *(emitter->indents.top);
+ (emitter->states.top) --;
+ emitter->state = *(emitter->states.top);
+ __retres = 1;
+ goto return_label;
+ }
+ tmp_0 = yaml_emitter_write_indent(emitter);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_10 = yaml_emitter_check_simple_key(emitter);
+ if (tmp_10) {
+ int tmp_3;
+ int tmp_4;
+ if (emitter->states.top != emitter->states.end) goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_stack_extend((void **)(& emitter->states.start),
+ (void **)(& emitter->states.top),
+ (void **)(& emitter->states.end));
+ if (tmp_1) {
+ yaml_emitter_state_t *tmp_2;
+ _LOR: tmp_2 = emitter->states.top;
+ (emitter->states.top) ++;
+ *tmp_2 = YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE;
+ tmp_3 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_4 = yaml_emitter_emit_node(emitter,event,0,0,1,1);
+ __retres = tmp_4;
+ goto return_label;
+ }
+ else {
+ int tmp_5;
+ int tmp_8;
+ int tmp_9;
+ tmp_5 = yaml_emitter_write_indicator(emitter,"?",1,0,1);
+ if (! tmp_5) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (emitter->states.top != emitter->states.end) goto _LOR_0;
+ else {
+ int tmp_6;
+ tmp_6 = yaml_stack_extend((void **)(& emitter->states.start),
+ (void **)(& emitter->states.top),
+ (void **)(& emitter->states.end));
+ if (tmp_6) {
+ yaml_emitter_state_t *tmp_7;
+ _LOR_0: tmp_7 = emitter->states.top;
+ (emitter->states.top) ++;
+ *tmp_7 = YAML_EMIT_BLOCK_MAPPING_VALUE_STATE;
+ tmp_8 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_8 = 0;
+ }
+ }
+ if (! tmp_8) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_9 = yaml_emitter_emit_node(emitter,event,0,0,1,0);
+ __retres = tmp_9;
+ goto return_label;
+ }
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_block_mapping_value(yaml_emitter_t *emitter,
+ yaml_event_t *event,
+ int simple)
+{
+ int __retres;
+ int tmp_4;
+ int tmp_5;
+ if (simple) {
+ int tmp;
+ tmp = yaml_emitter_write_indicator(emitter,":",0,0,0);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ else {
+ int tmp_0;
+ int tmp_1;
+ tmp_0 = yaml_emitter_write_indent(emitter);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_1 = yaml_emitter_write_indicator(emitter,":",1,0,1);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (emitter->states.top != emitter->states.end) goto _LOR;
+ else {
+ int tmp_2;
+ tmp_2 = yaml_stack_extend((void **)(& emitter->states.start),
+ (void **)(& emitter->states.top),
+ (void **)(& emitter->states.end));
+ if (tmp_2) {
+ yaml_emitter_state_t *tmp_3;
+ _LOR: tmp_3 = emitter->states.top;
+ (emitter->states.top) ++;
+ *tmp_3 = YAML_EMIT_BLOCK_MAPPING_KEY_STATE;
+ tmp_4 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_4 = 0;
+ }
+ }
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_5 = yaml_emitter_emit_node(emitter,event,0,0,1,0);
+ __retres = tmp_5;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_node(yaml_emitter_t *emitter,
+ yaml_event_t *event, int root,
+ int sequence, int mapping, int simple_key)
+{
+ int __retres;
+ emitter->root_context = root;
+ emitter->sequence_context = sequence;
+ emitter->mapping_context = mapping;
+ emitter->simple_key_context = simple_key;
+ switch (event->type) {
+ int tmp;
+ int tmp_0;
+ int tmp_1;
+ int tmp_2;
+ int tmp_3;
+ case (yaml_event_type_t)YAML_ALIAS_EVENT:
+ tmp = yaml_emitter_emit_alias(emitter,event);
+ __retres = tmp;
+ goto return_label;
+ case (yaml_event_type_t)YAML_SCALAR_EVENT:
+ tmp_0 = yaml_emitter_emit_scalar(emitter,event);
+ __retres = tmp_0;
+ goto return_label;
+ case (yaml_event_type_t)YAML_SEQUENCE_START_EVENT:
+ tmp_1 = yaml_emitter_emit_sequence_start(emitter,event);
+ __retres = tmp_1;
+ goto return_label;
+ case (yaml_event_type_t)YAML_MAPPING_START_EVENT:
+ tmp_2 = yaml_emitter_emit_mapping_start(emitter,event);
+ __retres = tmp_2;
+ goto return_label;
+ default:
+ tmp_3 = yaml_emitter_set_emitter_error(emitter,
+ "expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS");
+ __retres = tmp_3;
+ goto return_label;
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_alias(yaml_emitter_t *emitter,
+ yaml_event_t *event __attribute__((
+ __unused__)))
+{
+ int __retres;
+ int tmp;
+ tmp = yaml_emitter_process_anchor(emitter);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (emitter->simple_key_context)
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR;
+ else {
+ int tmp_0;
+ tmp_0 = yaml_emitter_flush(emitter);
+ if (tmp_0) {
+ yaml_char_t *tmp_1;
+ _LOR:
+ { /* sequence */
+ tmp_1 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_1 = (unsigned char)' ';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ (emitter->states.top) --;
+ emitter->state = *(emitter->states.top);
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_scalar(yaml_emitter_t *emitter,
+ yaml_event_t *event)
+{
+ int __retres;
+ int tmp;
+ int tmp_0;
+ int tmp_1;
+ int tmp_2;
+ int tmp_3;
+ tmp = yaml_emitter_select_scalar_style(emitter,event);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_0 = yaml_emitter_process_anchor(emitter);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_1 = yaml_emitter_process_tag(emitter);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_2 = yaml_emitter_increase_indent(emitter,1,0);
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_3 = yaml_emitter_process_scalar(emitter);
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ (emitter->indents.top) --;
+ emitter->indent = *(emitter->indents.top);
+ (emitter->states.top) --;
+ emitter->state = *(emitter->states.top);
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_sequence_start(yaml_emitter_t *emitter,
+ yaml_event_t *event)
+{
+ int __retres;
+ int tmp;
+ int tmp_0;
+ tmp = yaml_emitter_process_anchor(emitter);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_0 = yaml_emitter_process_tag(emitter);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (emitter->flow_level) goto _LOR;
+ else
+ if (emitter->canonical) goto _LOR;
+ else
+ if (event->data.sequence_start.style == (unsigned int)YAML_FLOW_SEQUENCE_STYLE)
+ goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_emitter_check_empty_sequence(emitter);
+ if (tmp_1) _LOR:
+ emitter->state = YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE;
+ else emitter->state = YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_mapping_start(yaml_emitter_t *emitter,
+ yaml_event_t *event)
+{
+ int __retres;
+ int tmp;
+ int tmp_0;
+ tmp = yaml_emitter_process_anchor(emitter);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_0 = yaml_emitter_process_tag(emitter);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (emitter->flow_level) goto _LOR;
+ else
+ if (emitter->canonical) goto _LOR;
+ else
+ if (event->data.mapping_start.style == (unsigned int)YAML_FLOW_MAPPING_STYLE)
+ goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_emitter_check_empty_mapping(emitter);
+ if (tmp_1) _LOR:
+ emitter->state = YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE;
+ else emitter->state = YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_check_empty_document(yaml_emitter_t *emitter __attribute__((
+ __unused__)))
+{
+ int __retres;
+ __retres = 0;
+ return __retres;
+}
+
+static int yaml_emitter_check_empty_sequence(yaml_emitter_t *emitter)
+{
+ int __retres;
+ int tmp;
+ if (emitter->events.tail - emitter->events.head < (long)2) {
+ __retres = 0;
+ goto return_label;
+ }
+ if ((emitter->events.head + 0)->type == (unsigned int)YAML_SEQUENCE_START_EVENT)
+ if ((emitter->events.head + 1)->type == (unsigned int)YAML_SEQUENCE_END_EVENT)
+ tmp = 1;
+ else tmp = 0;
+ else tmp = 0;
+ __retres = tmp;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_check_empty_mapping(yaml_emitter_t *emitter)
+{
+ int __retres;
+ int tmp;
+ if (emitter->events.tail - emitter->events.head < (long)2) {
+ __retres = 0;
+ goto return_label;
+ }
+ if ((emitter->events.head + 0)->type == (unsigned int)YAML_MAPPING_START_EVENT)
+ if ((emitter->events.head + 1)->type == (unsigned int)YAML_MAPPING_END_EVENT)
+ tmp = 1;
+ else tmp = 0;
+ else tmp = 0;
+ __retres = tmp;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_check_simple_key(yaml_emitter_t *emitter)
+{
+ int __retres;
+ yaml_event_t *event = emitter->events.head;
+ size_t length = (unsigned long)0;
+ switch (event->type) {
+ int tmp;
+ int tmp_0;
+ case (yaml_event_type_t)YAML_ALIAS_EVENT:
+ length += emitter->anchor_data.anchor_length;
+ break;
+ case (yaml_event_type_t)YAML_SCALAR_EVENT: ;
+ if (emitter->scalar_data.multiline) {
+ __retres = 0;
+ goto return_label;
+ }
+ length += ((emitter->anchor_data.anchor_length + emitter->tag_data.handle_length) + emitter->tag_data.suffix_length) + emitter->scalar_data.length;
+ break;
+ case (yaml_event_type_t)YAML_SEQUENCE_START_EVENT:
+ tmp = yaml_emitter_check_empty_sequence(emitter);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ length += (emitter->anchor_data.anchor_length + emitter->tag_data.handle_length) + emitter->tag_data.suffix_length;
+ break;
+ case (yaml_event_type_t)YAML_MAPPING_START_EVENT:
+ tmp_0 = yaml_emitter_check_empty_mapping(emitter);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ length += (emitter->anchor_data.anchor_length + emitter->tag_data.handle_length) + emitter->tag_data.suffix_length;
+ break;
+ default: __retres = 0;
+ goto return_label;
+ }
+ if (length > (size_t)128) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_select_scalar_style(yaml_emitter_t *emitter,
+ yaml_event_t *event)
+{
+ int __retres;
+ int tmp;
+ yaml_scalar_style_t style = event->data.scalar.style;
+ if (! emitter->tag_data.handle)
+ if (! emitter->tag_data.suffix) tmp = 1; else tmp = 0;
+ else tmp = 0;
+ int no_tag = tmp;
+ if (no_tag)
+ if (! event->data.scalar.plain_implicit)
+ if (! event->data.scalar.quoted_implicit) {
+ int tmp_0;
+ tmp_0 = yaml_emitter_set_emitter_error(emitter,
+ "neither tag nor implicit flags are specified");
+ __retres = tmp_0;
+ goto return_label;
+ }
+ if (style == (unsigned int)YAML_ANY_SCALAR_STYLE) style = YAML_PLAIN_SCALAR_STYLE;
+ if (emitter->canonical) style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
+ if (emitter->simple_key_context)
+ if (emitter->scalar_data.multiline) style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
+ if (style == (unsigned int)YAML_PLAIN_SCALAR_STYLE) {
+ if (emitter->flow_level) {
+ if (! emitter->scalar_data.flow_plain_allowed) style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
+ else goto _LAND;
+ }
+ else
+ _LAND:
+ if (! emitter->flow_level)
+ if (! emitter->scalar_data.block_plain_allowed) style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
+ if (! emitter->scalar_data.length)
+ if (emitter->flow_level) style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
+ else
+ if (emitter->simple_key_context) style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
+ if (no_tag)
+ if (! event->data.scalar.plain_implicit) style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
+ }
+ if (style == (unsigned int)YAML_SINGLE_QUOTED_SCALAR_STYLE)
+ if (! emitter->scalar_data.single_quoted_allowed) style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
+ if (style == (unsigned int)YAML_LITERAL_SCALAR_STYLE) goto _LOR;
+ else
+ if (style == (unsigned int)YAML_FOLDED_SCALAR_STYLE)
+ _LOR:
+ if (! emitter->scalar_data.block_allowed) style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
+ else
+ if (emitter->flow_level) style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
+ else
+ if (emitter->simple_key_context) style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
+ if (no_tag)
+ if (! event->data.scalar.quoted_implicit)
+ if (style != (unsigned int)YAML_PLAIN_SCALAR_STYLE) {
+ emitter->tag_data.handle = (yaml_char_t *)"!";
+ emitter->tag_data.handle_length = (unsigned long)1;
+ }
+ emitter->scalar_data.style = style;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_process_anchor(yaml_emitter_t *emitter)
+{
+ int __retres;
+ int tmp_0;
+ char const *tmp;
+ int tmp_1;
+ if (! emitter->anchor_data.anchor) {
+ __retres = 1;
+ goto return_label;
+ }
+ if (emitter->anchor_data.alias) tmp = "*"; else tmp = "&";
+ ;
+ tmp_0 = yaml_emitter_write_indicator(emitter,tmp,1,0,0);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_1 = yaml_emitter_write_anchor(emitter,emitter->anchor_data.anchor,
+ emitter->anchor_data.anchor_length);
+ __retres = tmp_1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_process_tag(yaml_emitter_t *emitter)
+{
+ int __retres;
+ if (! emitter->tag_data.handle)
+ if (! emitter->tag_data.suffix) {
+ __retres = 1;
+ goto return_label;
+ }
+ if (emitter->tag_data.handle) {
+ int tmp;
+ tmp = yaml_emitter_write_tag_handle(emitter,emitter->tag_data.handle,
+ emitter->tag_data.handle_length);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (emitter->tag_data.suffix) {
+ int tmp_0;
+ tmp_0 = yaml_emitter_write_tag_content(emitter,
+ emitter->tag_data.suffix,
+ emitter->tag_data.suffix_length,
+ 0);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ else {
+ int tmp_1;
+ int tmp_2;
+ int tmp_3;
+ tmp_1 = yaml_emitter_write_indicator(emitter,"!<",1,0,0);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_2 = yaml_emitter_write_tag_content(emitter,emitter->tag_data.suffix,
+ emitter->tag_data.suffix_length,0);
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_3 = yaml_emitter_write_indicator(emitter,">",0,0,0);
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_process_scalar(yaml_emitter_t *emitter)
+{
+ int __retres;
+ switch (emitter->scalar_data.style) {
+ int tmp;
+ int tmp_0;
+ int tmp_1;
+ int tmp_2;
+ int tmp_3;
+ case (yaml_scalar_style_t)YAML_PLAIN_SCALAR_STYLE:
+ tmp = yaml_emitter_write_plain_scalar(emitter,emitter->scalar_data.value,
+ emitter->scalar_data.length,
+ ! emitter->simple_key_context);
+ __retres = tmp;
+ goto return_label;
+ case (yaml_scalar_style_t)YAML_SINGLE_QUOTED_SCALAR_STYLE:
+ tmp_0 = yaml_emitter_write_single_quoted_scalar(emitter,
+ emitter->scalar_data.value,
+ emitter->scalar_data.length,
+ ! emitter->simple_key_context);
+ __retres = tmp_0;
+ goto return_label;
+ case (yaml_scalar_style_t)YAML_DOUBLE_QUOTED_SCALAR_STYLE:
+ tmp_1 = yaml_emitter_write_double_quoted_scalar(emitter,
+ emitter->scalar_data.value,
+ emitter->scalar_data.length,
+ ! emitter->simple_key_context);
+ __retres = tmp_1;
+ goto return_label;
+ case (yaml_scalar_style_t)YAML_LITERAL_SCALAR_STYLE:
+ tmp_2 = yaml_emitter_write_literal_scalar(emitter,
+ emitter->scalar_data.value,
+ emitter->scalar_data.length);
+ __retres = tmp_2;
+ goto return_label;
+ case (yaml_scalar_style_t)YAML_FOLDED_SCALAR_STYLE:
+ tmp_3 = yaml_emitter_write_folded_scalar(emitter,
+ emitter->scalar_data.value,
+ emitter->scalar_data.length);
+ __retres = tmp_3;
+ goto return_label;
+ default: __FC_assert(1 != 0,"src/emitter.c",1341,"1");
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_analyze_version_directive(yaml_emitter_t *emitter,
+ yaml_version_directive_t version_directive)
+{
+ int __retres;
+ if (version_directive.major != 1) goto _LOR;
+ else
+ if (version_directive.minor != 1)
+ if (version_directive.minor != 2) {
+ _LOR:
+ {
+ int tmp;
+ tmp = yaml_emitter_set_emitter_error(emitter,
+ "incompatible %YAML directive");
+ __retres = tmp;
+ goto return_label;
+ }
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_analyze_tag_directive(yaml_emitter_t *emitter,
+ yaml_tag_directive_t tag_directive)
+{
+ int __retres;
+ yaml_string_t handle;
+ yaml_string_t prefix;
+ size_t handle_length;
+ size_t prefix_length;
+ handle_length = strlen((char const *)tag_directive.handle);
+ prefix_length = strlen((char const *)tag_directive.prefix);
+ handle.start = tag_directive.handle;
+ handle.end = tag_directive.handle + handle_length;
+ handle.pointer = tag_directive.handle;
+ prefix.start = tag_directive.prefix;
+ prefix.end = tag_directive.prefix + prefix_length;
+ prefix.pointer = tag_directive.prefix;
+ if (handle.start == handle.end) {
+ int tmp;
+ tmp = yaml_emitter_set_emitter_error(emitter,
+ "tag handle must not be empty");
+ __retres = tmp;
+ goto return_label;
+ }
+ if ((int)*(handle.start + 0) != '!') {
+ int tmp_0;
+ tmp_0 = yaml_emitter_set_emitter_error(emitter,
+ "tag handle must start with \'!\'");
+ __retres = tmp_0;
+ goto return_label;
+ }
+ if ((int)*(handle.end + -1) != '!') {
+ int tmp_1;
+ tmp_1 = yaml_emitter_set_emitter_error(emitter,
+ "tag handle must end with \'!\'");
+ __retres = tmp_1;
+ goto return_label;
+ }
+ (handle.pointer) ++;
+ while (handle.pointer < handle.end - 1) {
+ int tmp_6;
+ if ((int)*(handle.pointer + 0) >= (int)((unsigned char)'0')) {
+ if (! ((int)*(handle.pointer + 0) <= (int)((unsigned char)'9')))
+ goto _LAND_1;
+ }
+ else {
+ _LAND_1: ;
+ if ((int)*(handle.pointer + 0) >= (int)((unsigned char)'A')) {
+ if (! ((int)*(handle.pointer + 0) <= (int)((unsigned char)'Z')))
+ goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(handle.pointer + 0) >= (int)((unsigned char)'a')) {
+ if (! ((int)*(handle.pointer + 0) <= (int)((unsigned char)'z')))
+ goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (! ((int)*(handle.pointer + 0) == '_'))
+ if (! ((int)*(handle.pointer + 0) == '-')) {
+ int tmp_2;
+ tmp_2 = yaml_emitter_set_emitter_error(emitter,
+ "tag handle must contain alphanumerical characters only");
+ __retres = tmp_2;
+ goto return_label;
+ }
+ }
+ }
+ }
+ if (((int)*(handle.pointer + 0) & 0x80) == 0x00) tmp_6 = 1;
+ else {
+ int tmp_5;
+ if (((int)*(handle.pointer + 0) & 0xE0) == 0xC0) tmp_5 = 2;
+ else {
+ int tmp_4;
+ if (((int)*(handle.pointer + 0) & 0xF0) == 0xE0) tmp_4 = 3;
+ else {
+ int tmp_3;
+ if (((int)*(handle.pointer + 0) & 0xF8) == 0xF0) tmp_3 = 4;
+ else tmp_3 = 0;
+ tmp_4 = tmp_3;
+ }
+ tmp_5 = tmp_4;
+ }
+ tmp_6 = tmp_5;
+ }
+ handle.pointer += tmp_6;
+ }
+ if (prefix.start == prefix.end) {
+ int tmp_7;
+ tmp_7 = yaml_emitter_set_emitter_error(emitter,
+ "tag prefix must not be empty");
+ __retres = tmp_7;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_analyze_anchor(yaml_emitter_t *emitter,
+ yaml_char_t *anchor, int alias)
+{
+ int __retres;
+ size_t anchor_length;
+ yaml_string_t string;
+ anchor_length = strlen((char const *)anchor);
+ string.start = anchor;
+ string.end = anchor + anchor_length;
+ string.pointer = anchor;
+ if (string.start == string.end) {
+ int tmp_0;
+ char const *tmp;
+ if (alias) tmp = "alias value must not be empty";
+ else tmp = "anchor value must not be empty";
+ ;
+ tmp_0 = yaml_emitter_set_emitter_error(emitter,tmp);
+ __retres = tmp_0;
+ goto return_label;
+ }
+ while (string.pointer != string.end) {
+ int tmp_6;
+ if ((int)*(string.pointer + 0) >= (int)((unsigned char)'0')) {
+ if (! ((int)*(string.pointer + 0) <= (int)((unsigned char)'9')))
+ goto _LAND_1;
+ }
+ else {
+ _LAND_1: ;
+ if ((int)*(string.pointer + 0) >= (int)((unsigned char)'A')) {
+ if (! ((int)*(string.pointer + 0) <= (int)((unsigned char)'Z')))
+ goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(string.pointer + 0) >= (int)((unsigned char)'a')) {
+ if (! ((int)*(string.pointer + 0) <= (int)((unsigned char)'z')))
+ goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (! ((int)*(string.pointer + 0) == '_'))
+ if (! ((int)*(string.pointer + 0) == '-')) {
+ int tmp_2;
+ char const *tmp_1;
+ if (alias) tmp_1 = "alias value must contain alphanumerical characters only";
+ else tmp_1 = "anchor value must contain alphanumerical characters only";
+ ;
+ tmp_2 = yaml_emitter_set_emitter_error(emitter,tmp_1);
+ __retres = tmp_2;
+ goto return_label;
+ }
+ }
+ }
+ }
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_6 = 1;
+ else {
+ int tmp_5;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_5 = 2;
+ else {
+ int tmp_4;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_4 = 3;
+ else {
+ int tmp_3;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0) tmp_3 = 4;
+ else tmp_3 = 0;
+ tmp_4 = tmp_3;
+ }
+ tmp_5 = tmp_4;
+ }
+ tmp_6 = tmp_5;
+ }
+ string.pointer += tmp_6;
+ }
+ emitter->anchor_data.anchor = string.start;
+ emitter->anchor_data.anchor_length = (unsigned long)(string.end - string.start);
+ emitter->anchor_data.alias = alias;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_analyze_tag(yaml_emitter_t *emitter, yaml_char_t *tag)
+{
+ int __retres;
+ size_t tag_length;
+ yaml_string_t string;
+ yaml_tag_directive_t *tag_directive;
+ tag_length = strlen((char const *)tag);
+ string.start = tag;
+ string.end = tag + tag_length;
+ string.pointer = tag;
+ if (string.start == string.end) {
+ int tmp;
+ tmp = yaml_emitter_set_emitter_error(emitter,
+ "tag value must not be empty");
+ __retres = tmp;
+ goto return_label;
+ }
+ tag_directive = emitter->tag_directives.start;
+ while (tag_directive != emitter->tag_directives.top) {
+ {
+ size_t prefix_length = strlen((char const *)tag_directive->prefix);
+ if (prefix_length < (unsigned long)(string.end - string.start)) {
+ int tmp_1;
+ tmp_1 = strncmp((char const *)tag_directive->prefix,
+ (char const *)string.start,prefix_length);
+ if (tmp_1 == 0) {
+ emitter->tag_data.handle = tag_directive->handle;
+ emitter->tag_data.handle_length = strlen((char const *)tag_directive->handle);
+ emitter->tag_data.suffix = string.start + prefix_length;
+ emitter->tag_data.suffix_length = (size_t)(string.end - string.start) - prefix_length;
+ __retres = 1;
+ goto return_label;
+ }
+ }
+ }
+ tag_directive ++;
+ }
+ emitter->tag_data.suffix = string.start;
+ emitter->tag_data.suffix_length = (unsigned long)(string.end - string.start);
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_analyze_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length)
+{
+ int __retres;
+ yaml_string_t string;
+ int tmp_51;
+ int tmp_2;
+ int block_indicators = 0;
+ int flow_indicators = 0;
+ int line_breaks = 0;
+ int special_characters = 0;
+ int leading_space = 0;
+ int leading_break = 0;
+ int trailing_space = 0;
+ int trailing_break = 0;
+ int break_space = 0;
+ int space_break = 0;
+ int preceded_by_whitespace = 0;
+ int followed_by_whitespace = 0;
+ int previous_space = 0;
+ int previous_break = 0;
+ string.start = value;
+ string.end = value + length;
+ string.pointer = value;
+ emitter->scalar_data.value = value;
+ emitter->scalar_data.length = length;
+ if (string.start == string.end) {
+ emitter->scalar_data.multiline = 0;
+ emitter->scalar_data.flow_plain_allowed = 0;
+ emitter->scalar_data.block_plain_allowed = 1;
+ emitter->scalar_data.single_quoted_allowed = 1;
+ emitter->scalar_data.block_allowed = 0;
+ __retres = 1;
+ goto return_label;
+ }
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'-')) {
+ if ((int)*(string.pointer + 1) == (int)((unsigned char)'-')) {
+ if ((int)*(string.pointer + 2) == (int)((unsigned char)'-')) goto _LOR;
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'.'))
+ if ((int)*(string.pointer + 1) == (int)((unsigned char)'.'))
+ if ((int)*(string.pointer + 2) == (int)((unsigned char)'.')) {
+ _LOR: {
+ block_indicators = 1;
+ flow_indicators = 1;
+ }
+ }
+ }
+ preceded_by_whitespace = 1;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_2 = 1;
+ else {
+ int tmp_1;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_1 = 2;
+ else {
+ int tmp_0;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_0 = 3;
+ else {
+ int tmp;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0) tmp = 4;
+ else tmp = 0;
+ tmp_0 = tmp;
+ }
+ tmp_1 = tmp_0;
+ }
+ tmp_2 = tmp_1;
+ }
+ ;
+ if ((int)*(string.pointer + tmp_2) == (int)((unsigned char)' ')) tmp_51 = 1;
+ else {
+ int tmp_6;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_6 = 1;
+ else {
+ int tmp_5;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_5 = 2;
+ else {
+ int tmp_4;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_4 = 3;
+ else {
+ int tmp_3;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0) tmp_3 = 4;
+ else tmp_3 = 0;
+ tmp_4 = tmp_3;
+ }
+ tmp_5 = tmp_4;
+ }
+ tmp_6 = tmp_5;
+ }
+ ;
+ if ((int)*(string.pointer + tmp_6) == (int)((unsigned char)'\t'))
+ tmp_51 = 1;
+ else {
+ int tmp_10;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_10 = 1;
+ else {
+ int tmp_9;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_9 = 2;
+ else {
+ int tmp_8;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_8 = 3;
+ else {
+ int tmp_7;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0) tmp_7 = 4;
+ else tmp_7 = 0;
+ tmp_8 = tmp_7;
+ }
+ tmp_9 = tmp_8;
+ }
+ tmp_10 = tmp_9;
+ }
+ ;
+ if ((int)*(string.pointer + tmp_10) == (int)((unsigned char)'\r'))
+ tmp_51 = 1;
+ else {
+ int tmp_14;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_14 = 1;
+ else {
+ int tmp_13;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_13 = 2;
+ else {
+ int tmp_12;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_12 = 3;
+ else {
+ int tmp_11;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0) tmp_11 = 4;
+ else tmp_11 = 0;
+ tmp_12 = tmp_11;
+ }
+ tmp_13 = tmp_12;
+ }
+ tmp_14 = tmp_13;
+ }
+ ;
+ if ((int)*(string.pointer + tmp_14) == (int)((unsigned char)'\n'))
+ tmp_51 = 1;
+ else {
+ int tmp_18;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_18 = 1;
+ else {
+ int tmp_17;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_17 = 2;
+ else {
+ int tmp_16;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_16 = 3;
+ else {
+ int tmp_15;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0) tmp_15 = 4;
+ else tmp_15 = 0;
+ tmp_16 = tmp_15;
+ }
+ tmp_17 = tmp_16;
+ }
+ tmp_18 = tmp_17;
+ }
+ ;
+ if ((int)*(string.pointer + tmp_18) == (int)((unsigned char)'\302')) {
+ int tmp_22;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_22 = 1;
+ else {
+ int tmp_21;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_21 = 2;
+ else {
+ int tmp_20;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_20 = 3;
+ else {
+ int tmp_19;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0) tmp_19 = 4;
+ else tmp_19 = 0;
+ tmp_20 = tmp_19;
+ }
+ tmp_21 = tmp_20;
+ }
+ tmp_22 = tmp_21;
+ }
+ ;
+ if ((int)*(string.pointer + (tmp_22 + 1)) == (int)((unsigned char)'\205'))
+ tmp_51 = 1;
+ else goto _LAND_5;
+ }
+ else {
+ int tmp_26;
+ _LAND_5:
+ { /* sequence */
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_26 = 1;
+ else {
+ int tmp_25;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_25 = 2;
+ else {
+ int tmp_24;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_24 = 3;
+ else {
+ int tmp_23;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_23 = 4;
+ else tmp_23 = 0;
+ tmp_24 = tmp_23;
+ }
+ tmp_25 = tmp_24;
+ }
+ tmp_26 = tmp_25;
+ }
+ ;
+ }
+ if ((int)*(string.pointer + tmp_26) == (int)((unsigned char)'\342')) {
+ int tmp_30;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_30 = 1;
+ else {
+ int tmp_29;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_29 = 2;
+ else {
+ int tmp_28;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_28 = 3;
+ else {
+ int tmp_27;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_27 = 4;
+ else tmp_27 = 0;
+ tmp_28 = tmp_27;
+ }
+ tmp_29 = tmp_28;
+ }
+ tmp_30 = tmp_29;
+ }
+ ;
+ if ((int)*(string.pointer + (tmp_30 + 1)) == (int)((unsigned char)'\200')) {
+ int tmp_34;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_34 = 1;
+ else {
+ int tmp_33;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_33 = 2;
+ else {
+ int tmp_32;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_32 = 3;
+ else {
+ int tmp_31;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_31 = 4;
+ else tmp_31 = 0;
+ tmp_32 = tmp_31;
+ }
+ tmp_33 = tmp_32;
+ }
+ tmp_34 = tmp_33;
+ }
+ ;
+ if ((int)*(string.pointer + (tmp_34 + 2)) == (int)((unsigned char)'\250'))
+ tmp_51 = 1;
+ else goto _LAND_4;
+ }
+ else goto _LAND_4;
+ }
+ else {
+ int tmp_38;
+ _LAND_4:
+ { /* sequence */
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_38 = 1;
+ else {
+ int tmp_37;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_37 = 2;
+ else {
+ int tmp_36;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_36 = 3;
+ else {
+ int tmp_35;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_35 = 4;
+ else tmp_35 = 0;
+ tmp_36 = tmp_35;
+ }
+ tmp_37 = tmp_36;
+ }
+ tmp_38 = tmp_37;
+ }
+ ;
+ }
+ if ((int)*(string.pointer + tmp_38) == (int)((unsigned char)'\342')) {
+ int tmp_42;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_42 = 1;
+ else {
+ int tmp_41;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_41 = 2;
+ else {
+ int tmp_40;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_40 = 3;
+ else {
+ int tmp_39;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_39 = 4;
+ else tmp_39 = 0;
+ tmp_40 = tmp_39;
+ }
+ tmp_41 = tmp_40;
+ }
+ tmp_42 = tmp_41;
+ }
+ ;
+ if ((int)*(string.pointer + (tmp_42 + 1)) == (int)((unsigned char)'\200')) {
+ int tmp_46;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_46 = 1;
+ else {
+ int tmp_45;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_45 = 2;
+ else {
+ int tmp_44;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_44 = 3;
+ else {
+ int tmp_43;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_43 = 4;
+ else tmp_43 = 0;
+ tmp_44 = tmp_43;
+ }
+ tmp_45 = tmp_44;
+ }
+ tmp_46 = tmp_45;
+ }
+ ;
+ if ((int)*(string.pointer + (tmp_46 + 2)) == (int)((unsigned char)'\251'))
+ tmp_51 = 1;
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ int tmp_50;
+ _LAND_2:
+ { /* sequence */
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_50 = 1;
+ else {
+ int tmp_49;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_49 = 2;
+ else {
+ int tmp_48;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_48 = 3;
+ else {
+ int tmp_47;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_47 = 4;
+ else tmp_47 = 0;
+ tmp_48 = tmp_47;
+ }
+ tmp_49 = tmp_48;
+ }
+ tmp_50 = tmp_49;
+ }
+ ;
+ }
+ if ((int)*(string.pointer + tmp_50) == (int)((unsigned char)'\000'))
+ tmp_51 = 1;
+ else tmp_51 = 0;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ followed_by_whitespace = tmp_51;
+ while (string.pointer != string.end) {
+ int tmp_60;
+ int tmp_64;
+ if (string.start == string.pointer) {
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'#')) goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)','))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'['))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)']'))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'{'))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'}'))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'&'))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'*'))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'!'))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'|'))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'>'))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\''))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\"'))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'%'))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'@'))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'`')) {
+ _LOR_0:
+ {
+ flow_indicators = 1;
+ block_indicators = 1;
+ }
+ }
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'?')) goto _LOR_1;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)':')) {
+ _LOR_1:
+ {
+ flow_indicators = 1;
+ if (followed_by_whitespace) block_indicators = 1;
+ }
+ }
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'-'))
+ if (followed_by_whitespace) {
+ flow_indicators = 1;
+ block_indicators = 1;
+ }
+ }
+ else {
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)',')) goto _LOR_2;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'?'))
+ goto _LOR_2;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'['))
+ goto _LOR_2;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)']'))
+ goto _LOR_2;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'{'))
+ goto _LOR_2;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'}'))
+ _LOR_2:
+ flow_indicators = 1;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)':')) {
+ flow_indicators = 1;
+ if (followed_by_whitespace) block_indicators = 1;
+ }
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'#'))
+ if (preceded_by_whitespace) {
+ flow_indicators = 1;
+ block_indicators = 1;
+ }
+ }
+ if ((int)*(string.pointer + 0) == 0x0A) goto _LAND_6;
+ else
+ if ((int)*(string.pointer + 0) >= 0x20) {
+ if ((int)*(string.pointer + 0) <= 0x7E) goto _LAND_6;
+ else goto _LAND_11;
+ }
+ else {
+ _LAND_11: ;
+ if ((int)*(string.pointer + 0) == 0xC2) {
+ if ((int)*(string.pointer + (0 + 1)) >= 0xA0) goto _LAND_6;
+ else goto _LAND_10;
+ }
+ else {
+ _LAND_10: ;
+ if ((int)*(string.pointer + 0) > 0xC2) {
+ if ((int)*(string.pointer + 0) < 0xED) goto _LAND_6;
+ else goto _LAND_9;
+ }
+ else {
+ _LAND_9: ;
+ if ((int)*(string.pointer + 0) == 0xED) {
+ if ((int)*(string.pointer + (0 + 1)) < 0xA0) goto _LAND_6;
+ else goto _LAND_8;
+ }
+ else {
+ _LAND_8: ;
+ if ((int)*(string.pointer + 0) == 0xEE) goto _LAND_6;
+ else
+ if ((int)*(string.pointer + 0) == 0xEF)
+ if ((int)*(string.pointer + (0 + 1)) == 0xBB) {
+ if ((int)*(string.pointer + (0 + 2)) == 0xBF) goto _LOR_3;
+ else goto _LAND_7;
+ }
+ else {
+ _LAND_7: ;
+ if ((int)*(string.pointer + (0 + 1)) == 0xBF) {
+ if ((int)*(string.pointer + (0 + 2)) == 0xBE) goto _LOR_3;
+ else
+ if ((int)*(string.pointer + (0 + 2)) == 0xBF)
+ goto _LOR_3;
+ else goto _LAND_6;
+ }
+ else
+ _LAND_6:
+ if (! ((int)*(string.pointer + 0) <= (int)((unsigned char)'\177')))
+ if (! emitter->unicode) _LOR_3:
+ special_characters = 1;
+ }
+ else goto _LOR_3;
+ }
+ }
+ }
+ }
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\r')) goto _LOR_5;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n')) goto _LOR_5;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_5;
+ else goto _LAND_14;
+ }
+ else {
+ _LAND_14: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_5;
+ else goto _LAND_13;
+ }
+ else goto _LAND_13;
+ }
+ else {
+ _LAND_13: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200'))
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\251'))
+ _LOR_5:
+ line_breaks = 1;
+ }
+ }
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)' ')) {
+ int tmp_55;
+ if (string.start == string.pointer) leading_space = 1;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_55 = 1;
+ else {
+ int tmp_54;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_54 = 2;
+ else {
+ int tmp_53;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_53 = 3;
+ else {
+ int tmp_52;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0) tmp_52 = 4;
+ else tmp_52 = 0;
+ tmp_53 = tmp_52;
+ }
+ tmp_54 = tmp_53;
+ }
+ tmp_55 = tmp_54;
+ }
+ ;
+ if (string.pointer + tmp_55 == string.end) trailing_space = 1;
+ if (previous_break) break_space = 1;
+ previous_space = 1;
+ previous_break = 0;
+ }
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\r')) goto _LOR_6;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n'))
+ goto _LOR_6;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_6;
+ else goto _LAND_19;
+ }
+ else {
+ _LAND_19: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_6;
+ else goto _LAND_18;
+ }
+ else goto _LAND_18;
+ }
+ else {
+ _LAND_18: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\251')) {
+ _LOR_6:
+ {
+ int tmp_59;
+ if (string.start == string.pointer) leading_break = 1;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00)
+ tmp_59 = 1;
+ else {
+ int tmp_58;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_58 = 2;
+ else {
+ int tmp_57;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_57 = 3;
+ else {
+ int tmp_56;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_56 = 4;
+ else tmp_56 = 0;
+ tmp_57 = tmp_56;
+ }
+ tmp_58 = tmp_57;
+ }
+ tmp_59 = tmp_58;
+ }
+ ;
+ if (string.pointer + tmp_59 == string.end) trailing_break = 1;
+ if (previous_space) space_break = 1;
+ previous_space = 0;
+ previous_break = 1;
+ }
+ }
+ else goto _LAND_16;
+ }
+ else goto _LAND_16;
+ }
+ else {
+ _LAND_16: {
+ previous_space = 0;
+ previous_break = 0;
+ }
+ }
+ }
+ }
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)' ')) tmp_60 = 1;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\t')) tmp_60 = 1;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\r'))
+ tmp_60 = 1;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n'))
+ tmp_60 = 1;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ tmp_60 = 1;
+ else goto _LAND_24;
+ }
+ else {
+ _LAND_24: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ tmp_60 = 1;
+ else goto _LAND_23;
+ }
+ else goto _LAND_23;
+ }
+ else {
+ _LAND_23: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\251'))
+ tmp_60 = 1;
+ else goto _LAND_21;
+ }
+ else goto _LAND_21;
+ }
+ else {
+ _LAND_21: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\000'))
+ tmp_60 = 1;
+ else tmp_60 = 0;
+ }
+ }
+ }
+ preceded_by_whitespace = tmp_60;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_64 = 1;
+ else {
+ int tmp_63;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_63 = 2;
+ else {
+ int tmp_62;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_62 = 3;
+ else {
+ int tmp_61;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0) tmp_61 = 4;
+ else tmp_61 = 0;
+ tmp_62 = tmp_61;
+ }
+ tmp_63 = tmp_62;
+ }
+ tmp_64 = tmp_63;
+ }
+ string.pointer += tmp_64;
+ if (string.pointer != string.end) {
+ int tmp_117;
+ int tmp_68;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_68 = 1;
+ else {
+ int tmp_67;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_67 = 2;
+ else {
+ int tmp_66;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_66 = 3;
+ else {
+ int tmp_65;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0) tmp_65 = 4;
+ else tmp_65 = 0;
+ tmp_66 = tmp_65;
+ }
+ tmp_67 = tmp_66;
+ }
+ tmp_68 = tmp_67;
+ }
+ ;
+ if ((int)*(string.pointer + tmp_68) == (int)((unsigned char)' '))
+ tmp_117 = 1;
+ else {
+ int tmp_72;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_72 = 1;
+ else {
+ int tmp_71;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_71 = 2;
+ else {
+ int tmp_70;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_70 = 3;
+ else {
+ int tmp_69;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0) tmp_69 = 4;
+ else tmp_69 = 0;
+ tmp_70 = tmp_69;
+ }
+ tmp_71 = tmp_70;
+ }
+ tmp_72 = tmp_71;
+ }
+ ;
+ if ((int)*(string.pointer + tmp_72) == (int)((unsigned char)'\t'))
+ tmp_117 = 1;
+ else {
+ int tmp_76;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_76 = 1;
+ else {
+ int tmp_75;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_75 = 2;
+ else {
+ int tmp_74;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_74 = 3;
+ else {
+ int tmp_73;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0) tmp_73 = 4;
+ else tmp_73 = 0;
+ tmp_74 = tmp_73;
+ }
+ tmp_75 = tmp_74;
+ }
+ tmp_76 = tmp_75;
+ }
+ ;
+ if ((int)*(string.pointer + tmp_76) == (int)((unsigned char)'\r'))
+ tmp_117 = 1;
+ else {
+ int tmp_80;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_80 = 1;
+ else {
+ int tmp_79;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_79 = 2;
+ else {
+ int tmp_78;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_78 = 3;
+ else {
+ int tmp_77;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0) tmp_77 = 4;
+ else tmp_77 = 0;
+ tmp_78 = tmp_77;
+ }
+ tmp_79 = tmp_78;
+ }
+ tmp_80 = tmp_79;
+ }
+ ;
+ if ((int)*(string.pointer + tmp_80) == (int)((unsigned char)'\n'))
+ tmp_117 = 1;
+ else {
+ int tmp_84;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_84 = 1;
+ else {
+ int tmp_83;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_83 = 2;
+ else {
+ int tmp_82;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_82 = 3;
+ else {
+ int tmp_81;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_81 = 4;
+ else tmp_81 = 0;
+ tmp_82 = tmp_81;
+ }
+ tmp_83 = tmp_82;
+ }
+ tmp_84 = tmp_83;
+ }
+ ;
+ if ((int)*(string.pointer + tmp_84) == (int)((unsigned char)'\302')) {
+ int tmp_88;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_88 = 1;
+ else {
+ int tmp_87;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_87 = 2;
+ else {
+ int tmp_86;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_86 = 3;
+ else {
+ int tmp_85;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_85 = 4;
+ else tmp_85 = 0;
+ tmp_86 = tmp_85;
+ }
+ tmp_87 = tmp_86;
+ }
+ tmp_88 = tmp_87;
+ }
+ ;
+ if ((int)*(string.pointer + (tmp_88 + 1)) == (int)((unsigned char)'\205'))
+ tmp_117 = 1;
+ else goto _LAND_29;
+ }
+ else {
+ int tmp_92;
+ _LAND_29:
+ { /* sequence */
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_92 = 1;
+ else {
+ int tmp_91;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_91 = 2;
+ else {
+ int tmp_90;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_90 = 3;
+ else {
+ int tmp_89;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_89 = 4;
+ else tmp_89 = 0;
+ tmp_90 = tmp_89;
+ }
+ tmp_91 = tmp_90;
+ }
+ tmp_92 = tmp_91;
+ }
+ ;
+ }
+ if ((int)*(string.pointer + tmp_92) == (int)((unsigned char)'\342')) {
+ int tmp_96;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_96 = 1;
+ else {
+ int tmp_95;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_95 = 2;
+ else {
+ int tmp_94;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_94 = 3;
+ else {
+ int tmp_93;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_93 = 4;
+ else tmp_93 = 0;
+ tmp_94 = tmp_93;
+ }
+ tmp_95 = tmp_94;
+ }
+ tmp_96 = tmp_95;
+ }
+ ;
+ if ((int)*(string.pointer + (tmp_96 + 1)) == (int)((unsigned char)'\200')) {
+ int tmp_100;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00)
+ tmp_100 = 1;
+ else {
+ int tmp_99;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_99 = 2;
+ else {
+ int tmp_98;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_98 = 3;
+ else {
+ int tmp_97;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_97 = 4;
+ else tmp_97 = 0;
+ tmp_98 = tmp_97;
+ }
+ tmp_99 = tmp_98;
+ }
+ tmp_100 = tmp_99;
+ }
+ ;
+ if ((int)*(string.pointer + (tmp_100 + 2)) == (int)((unsigned char)'\250'))
+ tmp_117 = 1;
+ else goto _LAND_28;
+ }
+ else goto _LAND_28;
+ }
+ else {
+ int tmp_104;
+ _LAND_28:
+ { /* sequence */
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00)
+ tmp_104 = 1;
+ else {
+ int tmp_103;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_103 = 2;
+ else {
+ int tmp_102;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_102 = 3;
+ else {
+ int tmp_101;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_101 = 4;
+ else tmp_101 = 0;
+ tmp_102 = tmp_101;
+ }
+ tmp_103 = tmp_102;
+ }
+ tmp_104 = tmp_103;
+ }
+ ;
+ }
+ if ((int)*(string.pointer + tmp_104) == (int)((unsigned char)'\342')) {
+ int tmp_108;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00)
+ tmp_108 = 1;
+ else {
+ int tmp_107;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_107 = 2;
+ else {
+ int tmp_106;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_106 = 3;
+ else {
+ int tmp_105;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_105 = 4;
+ else tmp_105 = 0;
+ tmp_106 = tmp_105;
+ }
+ tmp_107 = tmp_106;
+ }
+ tmp_108 = tmp_107;
+ }
+ ;
+ if ((int)*(string.pointer + (tmp_108 + 1)) == (int)((unsigned char)'\200')) {
+ int tmp_112;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00)
+ tmp_112 = 1;
+ else {
+ int tmp_111;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_111 = 2;
+ else {
+ int tmp_110;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_110 = 3;
+ else {
+ int tmp_109;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_109 = 4;
+ else tmp_109 = 0;
+ tmp_110 = tmp_109;
+ }
+ tmp_111 = tmp_110;
+ }
+ tmp_112 = tmp_111;
+ }
+ ;
+ if ((int)*(string.pointer + (tmp_112 + 2)) == (int)((unsigned char)'\251'))
+ tmp_117 = 1;
+ else goto _LAND_26;
+ }
+ else goto _LAND_26;
+ }
+ else {
+ int tmp_116;
+ _LAND_26:
+ { /* sequence */
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00)
+ tmp_116 = 1;
+ else {
+ int tmp_115;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_115 = 2;
+ else {
+ int tmp_114;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_114 = 3;
+ else {
+ int tmp_113;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_113 = 4;
+ else tmp_113 = 0;
+ tmp_114 = tmp_113;
+ }
+ tmp_115 = tmp_114;
+ }
+ tmp_116 = tmp_115;
+ }
+ ;
+ }
+ if ((int)*(string.pointer + tmp_116) == (int)((unsigned char)'\000'))
+ tmp_117 = 1;
+ else tmp_117 = 0;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ followed_by_whitespace = tmp_117;
+ }
+ }
+ emitter->scalar_data.multiline = line_breaks;
+ emitter->scalar_data.flow_plain_allowed = 1;
+ emitter->scalar_data.block_plain_allowed = 1;
+ emitter->scalar_data.single_quoted_allowed = 1;
+ emitter->scalar_data.block_allowed = 1;
+ if (leading_space) goto _LOR_7;
+ else
+ if (leading_break) goto _LOR_7;
+ else
+ if (trailing_space) goto _LOR_7;
+ else
+ if (trailing_break) {
+ _LOR_7:
+ {
+ emitter->scalar_data.flow_plain_allowed = 0;
+ emitter->scalar_data.block_plain_allowed = 0;
+ }
+ }
+ if (trailing_space) emitter->scalar_data.block_allowed = 0;
+ if (break_space) {
+ emitter->scalar_data.flow_plain_allowed = 0;
+ emitter->scalar_data.block_plain_allowed = 0;
+ emitter->scalar_data.single_quoted_allowed = 0;
+ }
+ if (space_break) goto _LOR_8;
+ else
+ if (special_characters) {
+ _LOR_8:
+ {
+ emitter->scalar_data.flow_plain_allowed = 0;
+ emitter->scalar_data.block_plain_allowed = 0;
+ emitter->scalar_data.single_quoted_allowed = 0;
+ emitter->scalar_data.block_allowed = 0;
+ }
+ }
+ if (line_breaks) {
+ emitter->scalar_data.flow_plain_allowed = 0;
+ emitter->scalar_data.block_plain_allowed = 0;
+ }
+ if (flow_indicators) emitter->scalar_data.flow_plain_allowed = 0;
+ if (block_indicators) emitter->scalar_data.block_plain_allowed = 0;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_analyze_event(yaml_emitter_t *emitter,
+ yaml_event_t *event)
+{
+ int __retres;
+ emitter->anchor_data.anchor = (yaml_char_t *)0;
+ emitter->anchor_data.anchor_length = (unsigned long)0;
+ emitter->tag_data.handle = (yaml_char_t *)0;
+ emitter->tag_data.handle_length = (unsigned long)0;
+ emitter->tag_data.suffix = (yaml_char_t *)0;
+ emitter->tag_data.suffix_length = (unsigned long)0;
+ emitter->scalar_data.value = (yaml_char_t *)0;
+ emitter->scalar_data.length = (unsigned long)0;
+ switch (event->type) {
+ int tmp;
+ int tmp_2;
+ case (yaml_event_type_t)YAML_ALIAS_EVENT:
+ tmp = yaml_emitter_analyze_anchor(emitter,event->data.alias.anchor,1);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ goto return_label;
+ case (yaml_event_type_t)YAML_SCALAR_EVENT: ;
+ if (event->data.scalar.anchor) {
+ int tmp_0;
+ tmp_0 = yaml_emitter_analyze_anchor(emitter,event->data.scalar.anchor,
+ 0);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (event->data.scalar.tag)
+ if (emitter->canonical) goto _LOR;
+ else
+ if (! event->data.scalar.plain_implicit)
+ if (! event->data.scalar.quoted_implicit) {
+ _LOR:
+ {
+ int tmp_1;
+ tmp_1 = yaml_emitter_analyze_tag(emitter,
+ event->data.scalar.tag);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ tmp_2 = yaml_emitter_analyze_scalar(emitter,event->data.scalar.value,
+ event->data.scalar.length);
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ goto return_label;
+ case (yaml_event_type_t)YAML_SEQUENCE_START_EVENT: ;
+ if (event->data.sequence_start.anchor) {
+ int tmp_3;
+ tmp_3 = yaml_emitter_analyze_anchor(emitter,
+ event->data.sequence_start.anchor,
+ 0);
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (event->data.sequence_start.tag)
+ if (emitter->canonical) goto _LOR_0;
+ else
+ if (! event->data.sequence_start.implicit) {
+ _LOR_0:
+ {
+ int tmp_4;
+ tmp_4 = yaml_emitter_analyze_tag(emitter,
+ event->data.sequence_start.tag);
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ __retres = 1;
+ goto return_label;
+ case (yaml_event_type_t)YAML_MAPPING_START_EVENT: ;
+ if (event->data.mapping_start.anchor) {
+ int tmp_5;
+ tmp_5 = yaml_emitter_analyze_anchor(emitter,
+ event->data.mapping_start.anchor,0);
+ if (! tmp_5) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (event->data.mapping_start.tag)
+ if (emitter->canonical) goto _LOR_1;
+ else
+ if (! event->data.mapping_start.implicit) {
+ _LOR_1:
+ {
+ int tmp_6;
+ tmp_6 = yaml_emitter_analyze_tag(emitter,
+ event->data.mapping_start.tag);
+ if (! tmp_6) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ __retres = 1;
+ goto return_label;
+ default: __retres = 1;
+ goto return_label;
+ }
+ return_label: return __retres;
+}
+
+static int yaml_emitter_write_bom(yaml_emitter_t *emitter)
+{
+ int __retres;
+ yaml_char_t *tmp_0;
+ yaml_char_t *tmp_1;
+ yaml_char_t *tmp_2;
+ if (! (emitter->buffer.pointer + 5 < emitter->buffer.end)) {
+ int tmp;
+ tmp = yaml_emitter_flush(emitter);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ tmp_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_0 = (unsigned char)'\357';
+ tmp_1 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_1 = (unsigned char)'\273';
+ tmp_2 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_2 = (unsigned char)'\277';
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_write_indent(yaml_emitter_t *emitter)
+{
+ int __retres;
+ int tmp;
+ if (emitter->indent >= 0) tmp = emitter->indent; else tmp = 0;
+ int indent = tmp;
+ if (! emitter->indention) goto _LOR_0;
+ else
+ if (emitter->column > indent) goto _LOR_0;
+ else
+ if (emitter->column == indent)
+ if (! emitter->whitespace)
+ _LOR_0:
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR;
+ else {
+ int tmp_0;
+ tmp_0 = yaml_emitter_flush(emitter);
+ if (tmp_0) {
+ _LOR: ;
+ if (emitter->line_break == (unsigned int)YAML_CR_BREAK) {
+ yaml_char_t *tmp_1;
+ tmp_1 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_1 = (unsigned char)'\r';
+ yaml_char_t tmp_9 = *tmp_1;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_LN_BREAK) {
+ yaml_char_t *tmp_2;
+ tmp_2 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_2 = (unsigned char)'\n';
+ yaml_char_t tmp_7 = *tmp_2;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_CRLN_BREAK) {
+ yaml_char_t *tmp_3;
+ yaml_char_t *tmp_4;
+ tmp_3 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_3 = (unsigned char)'\r';
+ tmp_4 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_4 = (unsigned char)'\n';
+ yaml_char_t tmp_5 = *tmp_4;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ while (emitter->column < indent)
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR_1;
+ else {
+ int tmp_5_0;
+ tmp_5_0 = yaml_emitter_flush(emitter);
+ if (tmp_5_0) {
+ yaml_char_t *tmp_6;
+ _LOR_1:
+ { /* sequence */
+ tmp_6 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_6 = (unsigned char)' ';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->whitespace = 1;
+ emitter->indention = 1;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_write_indicator(yaml_emitter_t *emitter,
+ char const *indicator,
+ int need_whitespace,
+ int is_whitespace, int is_indention)
+{
+ int __retres;
+ size_t indicator_length;
+ yaml_string_t string;
+ int tmp_22_0;
+ indicator_length = strlen(indicator);
+ string.start = (yaml_char_t *)indicator;
+ string.end = (yaml_char_t *)indicator + indicator_length;
+ string.pointer = (yaml_char_t *)indicator;
+ if (need_whitespace)
+ if (! emitter->whitespace)
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR;
+ else {
+ int tmp;
+ tmp = yaml_emitter_flush(emitter);
+ if (tmp) {
+ yaml_char_t *tmp_0;
+ _LOR:
+ { /* sequence */
+ tmp_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_0 = (unsigned char)' ';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ while (string.pointer != string.end)
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR_0;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_emitter_flush(emitter);
+ if (tmp_1) {
+ _LOR_0: ;
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_2;
+ yaml_char_t *tmp_3;
+ tmp_2 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_3 = string.pointer;
+ (string.pointer) ++;
+ *tmp_2 = *tmp_3;
+ yaml_char_t tmp_28 = *tmp_2;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_4;
+ yaml_char_t *tmp_5;
+ yaml_char_t *tmp_6;
+ yaml_char_t *tmp_7;
+ tmp_4 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_5 = string.pointer;
+ (string.pointer) ++;
+ *tmp_4 = *tmp_5;
+ tmp_6 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_7 = string.pointer;
+ (string.pointer) ++;
+ *tmp_6 = *tmp_7;
+ yaml_char_t tmp_26 = *tmp_6;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_8;
+ yaml_char_t *tmp_9;
+ yaml_char_t *tmp_10;
+ yaml_char_t *tmp_11;
+ yaml_char_t *tmp_12;
+ yaml_char_t *tmp_13;
+ tmp_8 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_9 = string.pointer;
+ (string.pointer) ++;
+ *tmp_8 = *tmp_9;
+ tmp_10 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_11 = string.pointer;
+ (string.pointer) ++;
+ *tmp_10 = *tmp_11;
+ tmp_12 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_13 = string.pointer;
+ (string.pointer) ++;
+ *tmp_12 = *tmp_13;
+ yaml_char_t tmp_24 = *tmp_12;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_14;
+ yaml_char_t *tmp_15;
+ yaml_char_t *tmp_16;
+ yaml_char_t *tmp_17;
+ yaml_char_t *tmp_18;
+ yaml_char_t *tmp_19;
+ yaml_char_t *tmp_20;
+ yaml_char_t *tmp_21;
+ tmp_14 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_15 = string.pointer;
+ (string.pointer) ++;
+ *tmp_14 = *tmp_15;
+ tmp_16 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_17 = string.pointer;
+ (string.pointer) ++;
+ *tmp_16 = *tmp_17;
+ tmp_18 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_19 = string.pointer;
+ (string.pointer) ++;
+ *tmp_18 = *tmp_19;
+ tmp_20 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_21 = string.pointer;
+ (string.pointer) ++;
+ *tmp_20 = *tmp_21;
+ yaml_char_t tmp_22 = *tmp_20;
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->whitespace = is_whitespace;
+ if (emitter->indention)
+ if (is_indention) tmp_22_0 = 1; else tmp_22_0 = 0;
+ else tmp_22_0 = 0;
+ emitter->indention = tmp_22_0;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_write_anchor(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length)
+{
+ int __retres;
+ yaml_string_t string;
+ string.start = value;
+ string.end = value + length;
+ string.pointer = value;
+ while (string.pointer != string.end)
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR;
+ else {
+ int tmp;
+ tmp = yaml_emitter_flush(emitter);
+ if (tmp) {
+ _LOR: ;
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_0;
+ yaml_char_t *tmp_1;
+ tmp_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_1 = string.pointer;
+ (string.pointer) ++;
+ *tmp_0 = *tmp_1;
+ yaml_char_t tmp_26 = *tmp_0;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_2;
+ yaml_char_t *tmp_3;
+ yaml_char_t *tmp_4;
+ yaml_char_t *tmp_5;
+ tmp_2 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_3 = string.pointer;
+ (string.pointer) ++;
+ *tmp_2 = *tmp_3;
+ tmp_4 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_5 = string.pointer;
+ (string.pointer) ++;
+ *tmp_4 = *tmp_5;
+ yaml_char_t tmp_24 = *tmp_4;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_6;
+ yaml_char_t *tmp_7;
+ yaml_char_t *tmp_8;
+ yaml_char_t *tmp_9;
+ yaml_char_t *tmp_10;
+ yaml_char_t *tmp_11;
+ tmp_6 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_7 = string.pointer;
+ (string.pointer) ++;
+ *tmp_6 = *tmp_7;
+ tmp_8 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_9 = string.pointer;
+ (string.pointer) ++;
+ *tmp_8 = *tmp_9;
+ tmp_10 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_11 = string.pointer;
+ (string.pointer) ++;
+ *tmp_10 = *tmp_11;
+ yaml_char_t tmp_22 = *tmp_10;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_12;
+ yaml_char_t *tmp_13;
+ yaml_char_t *tmp_14;
+ yaml_char_t *tmp_15;
+ yaml_char_t *tmp_16;
+ yaml_char_t *tmp_17;
+ yaml_char_t *tmp_18;
+ yaml_char_t *tmp_19;
+ tmp_12 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_13 = string.pointer;
+ (string.pointer) ++;
+ *tmp_12 = *tmp_13;
+ tmp_14 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_15 = string.pointer;
+ (string.pointer) ++;
+ *tmp_14 = *tmp_15;
+ tmp_16 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_17 = string.pointer;
+ (string.pointer) ++;
+ *tmp_16 = *tmp_17;
+ tmp_18 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_19 = string.pointer;
+ (string.pointer) ++;
+ *tmp_18 = *tmp_19;
+ yaml_char_t tmp_20 = *tmp_18;
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->whitespace = 0;
+ emitter->indention = 0;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_write_tag_handle(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length)
+{
+ int __retres;
+ yaml_string_t string;
+ string.start = value;
+ string.end = value + length;
+ string.pointer = value;
+ if (! emitter->whitespace)
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR;
+ else {
+ int tmp;
+ tmp = yaml_emitter_flush(emitter);
+ if (tmp) {
+ yaml_char_t *tmp_0;
+ _LOR:
+ { /* sequence */
+ tmp_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_0 = (unsigned char)' ';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ while (string.pointer != string.end)
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR_0;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_emitter_flush(emitter);
+ if (tmp_1) {
+ _LOR_0: ;
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_2;
+ yaml_char_t *tmp_3;
+ tmp_2 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_3 = string.pointer;
+ (string.pointer) ++;
+ *tmp_2 = *tmp_3;
+ yaml_char_t tmp_28 = *tmp_2;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_4;
+ yaml_char_t *tmp_5;
+ yaml_char_t *tmp_6;
+ yaml_char_t *tmp_7;
+ tmp_4 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_5 = string.pointer;
+ (string.pointer) ++;
+ *tmp_4 = *tmp_5;
+ tmp_6 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_7 = string.pointer;
+ (string.pointer) ++;
+ *tmp_6 = *tmp_7;
+ yaml_char_t tmp_26 = *tmp_6;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_8;
+ yaml_char_t *tmp_9;
+ yaml_char_t *tmp_10;
+ yaml_char_t *tmp_11;
+ yaml_char_t *tmp_12;
+ yaml_char_t *tmp_13;
+ tmp_8 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_9 = string.pointer;
+ (string.pointer) ++;
+ *tmp_8 = *tmp_9;
+ tmp_10 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_11 = string.pointer;
+ (string.pointer) ++;
+ *tmp_10 = *tmp_11;
+ tmp_12 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_13 = string.pointer;
+ (string.pointer) ++;
+ *tmp_12 = *tmp_13;
+ yaml_char_t tmp_24 = *tmp_12;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_14;
+ yaml_char_t *tmp_15;
+ yaml_char_t *tmp_16;
+ yaml_char_t *tmp_17;
+ yaml_char_t *tmp_18;
+ yaml_char_t *tmp_19;
+ yaml_char_t *tmp_20;
+ yaml_char_t *tmp_21;
+ tmp_14 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_15 = string.pointer;
+ (string.pointer) ++;
+ *tmp_14 = *tmp_15;
+ tmp_16 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_17 = string.pointer;
+ (string.pointer) ++;
+ *tmp_16 = *tmp_17;
+ tmp_18 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_19 = string.pointer;
+ (string.pointer) ++;
+ *tmp_18 = *tmp_19;
+ tmp_20 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_21 = string.pointer;
+ (string.pointer) ++;
+ *tmp_20 = *tmp_21;
+ yaml_char_t tmp_22 = *tmp_20;
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->whitespace = 0;
+ emitter->indention = 0;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_write_tag_content(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length,
+ int need_whitespace)
+{
+ int __retres;
+ yaml_string_t string;
+ string.start = value;
+ string.end = value + length;
+ string.pointer = value;
+ if (need_whitespace)
+ if (! emitter->whitespace)
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR;
+ else {
+ int tmp;
+ tmp = yaml_emitter_flush(emitter);
+ if (tmp) {
+ yaml_char_t *tmp_0;
+ _LOR:
+ { /* sequence */
+ tmp_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_0 = (unsigned char)' ';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ while (string.pointer != string.end)
+ if ((int)*(string.pointer + 0) >= (int)((unsigned char)'0')) {
+ if ((int)*(string.pointer + 0) <= (int)((unsigned char)'9')) goto _LOR_4;
+ else goto _LAND_1;
+ }
+ else {
+ _LAND_1: ;
+ if ((int)*(string.pointer + 0) >= (int)((unsigned char)'A')) {
+ if ((int)*(string.pointer + 0) <= (int)((unsigned char)'Z'))
+ goto _LOR_4;
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(string.pointer + 0) >= (int)((unsigned char)'a')) {
+ if ((int)*(string.pointer + 0) <= (int)((unsigned char)'z'))
+ goto _LOR_4;
+ else goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if ((int)*(string.pointer + 0) == '_') goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == '-') goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)';'))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'/'))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'?'))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)':'))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'@'))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'&'))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'='))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'+'))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'$'))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)','))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'_'))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'.'))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'~'))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'*'))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\''))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'('))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)')'))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'['))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)']')) {
+ _LOR_4:
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_0;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_emitter_flush
+ (emitter);
+ if (tmp_1) {
+ _LOR_0: ;
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_2;
+ yaml_char_t *tmp_3;
+ tmp_2 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_3 = string.pointer;
+ (string.pointer) ++;
+ *tmp_2 = *tmp_3;
+ yaml_char_t tmp_28 =
+ *tmp_2;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_4;
+ yaml_char_t *tmp_5;
+ yaml_char_t *tmp_6;
+ yaml_char_t *tmp_7;
+ tmp_4 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_5 = string.pointer;
+ (string.pointer) ++;
+ *tmp_4 = *tmp_5;
+ tmp_6 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_7 = string.pointer;
+ (string.pointer) ++;
+ *tmp_6 = *tmp_7;
+ yaml_char_t tmp_26 =
+ *tmp_6;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_8;
+ yaml_char_t *tmp_9;
+ yaml_char_t *tmp_10;
+ yaml_char_t *tmp_11;
+ yaml_char_t *tmp_12;
+ yaml_char_t *tmp_13;
+ tmp_8 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_9 = string.pointer;
+ (string.pointer) ++;
+ *tmp_8 = *tmp_9;
+ tmp_10 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_11 = string.pointer;
+ (string.pointer) ++;
+ *tmp_10 = *tmp_11;
+ tmp_12 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_13 = string.pointer;
+ (string.pointer) ++;
+ *tmp_12 = *tmp_13;
+ yaml_char_t tmp_24 =
+ *tmp_12;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_14;
+ yaml_char_t *tmp_15;
+ yaml_char_t *tmp_16;
+ yaml_char_t *tmp_17;
+ yaml_char_t *tmp_18;
+ yaml_char_t *tmp_19;
+ yaml_char_t *tmp_20;
+ yaml_char_t *tmp_21;
+ tmp_14 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_15 = string.pointer;
+ (string.pointer) ++;
+ *tmp_14 = *tmp_15;
+ tmp_16 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_17 = string.pointer;
+ (string.pointer) ++;
+ *tmp_16 = *tmp_17;
+ tmp_18 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_19 = string.pointer;
+ (string.pointer) ++;
+ *tmp_18 = *tmp_19;
+ tmp_20 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_21 = string.pointer;
+ (string.pointer) ++;
+ *tmp_20 = *tmp_21;
+ yaml_char_t tmp_22 =
+ *tmp_20;
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ else {
+ int tmp_25;
+ unsigned int value_0;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00)
+ tmp_25 = 1;
+ else {
+ int tmp_24_0;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_24_0 = 2;
+ else {
+ int tmp_23;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_23 = 3;
+ else {
+ int tmp_22_1;
+ if (((int)*(
+ string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_22_1 = 4;
+ else tmp_22_1 = 0;
+ tmp_23 = tmp_22_1;
+ }
+ tmp_24_0 = tmp_23;
+ }
+ tmp_25 = tmp_24_0;
+ }
+ int width = tmp_25;
+ while (1) {
+ int tmp_35;
+ tmp_35 = width;
+ width --;
+ ;
+ if (! tmp_35) break;
+ {
+ yaml_char_t *tmp_26_0;
+ tmp_26_0 = string.pointer;
+ (string.pointer) ++;
+ value_0 = (unsigned int)*tmp_26_0;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_1;
+ else {
+ int tmp_27;
+ tmp_27 = yaml_emitter_flush
+ (emitter);
+ if (tmp_27) {
+ yaml_char_t *tmp_28_0;
+ _LOR_1:
+ { /* sequence */
+ tmp_28_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_28_0 = (unsigned char)'%';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_2;
+ else {
+ int tmp_29;
+ tmp_29 = yaml_emitter_flush
+ (emitter);
+ if (tmp_29) {
+ yaml_char_t *tmp_30;
+ int tmp_31;
+ _LOR_2:
+ { /* sequence */
+ tmp_30 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ if (value_0 >> 4 < (unsigned int)10)
+ tmp_31 = '0';
+ else tmp_31 =
+ 'A' - 10;
+ *tmp_30 = (unsigned char)(
+ (value_0 >> 4) + (unsigned int)tmp_31);
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_3;
+ else {
+ int tmp_32;
+ tmp_32 = yaml_emitter_flush
+ (emitter);
+ if (tmp_32) {
+ yaml_char_t *tmp_33;
+ int tmp_34;
+ _LOR_3:
+ { /* sequence */
+ tmp_33 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ if ((value_0 & (unsigned int)0x0F) < (unsigned int)10)
+ tmp_34 = '0';
+ else tmp_34 =
+ 'A' - 10;
+ *tmp_33 = (unsigned char)(
+ (value_0 & (unsigned int)0x0F) + (unsigned int)tmp_34);
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ emitter->whitespace = 0;
+ emitter->indention = 0;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length,
+ int allow_breaks)
+{
+ int __retres;
+ yaml_string_t string;
+ int spaces = 0;
+ int breaks = 0;
+ string.start = value;
+ string.end = value + length;
+ string.pointer = value;
+ if (! emitter->whitespace)
+ if (length) goto _LOR_0;
+ else
+ if (emitter->flow_level)
+ _LOR_0:
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR;
+ else {
+ int tmp;
+ tmp = yaml_emitter_flush(emitter);
+ if (tmp) {
+ yaml_char_t *tmp_0;
+ _LOR:
+ { /* sequence */
+ tmp_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_0 = (unsigned char)' ';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ while (string.pointer != string.end)
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)' ')) {
+ if (allow_breaks) {
+ if (! spaces) {
+ if (emitter->column > emitter->best_width) {
+ if (! ((int)*(string.pointer + 1) == (int)((unsigned char)' '))) {
+ int tmp_1;
+ int tmp_5;
+ tmp_1 = yaml_emitter_write_indent(emitter);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_5 = 1;
+ else {
+ int tmp_4;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_4 = 2;
+ else {
+ int tmp_3;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_3 = 3;
+ else {
+ int tmp_2;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_2 = 4;
+ else tmp_2 = 0;
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ tmp_5 = tmp_4;
+ }
+ string.pointer += tmp_5;
+ }
+ else goto _LAND_1;
+ }
+ else goto _LAND_1;
+ }
+ else goto _LAND_1;
+ }
+ else
+ _LAND_1:
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR_1;
+ else {
+ int tmp_6;
+ tmp_6 = yaml_emitter_flush(emitter);
+ if (tmp_6) {
+ _LOR_1: ;
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_7;
+ yaml_char_t *tmp_8;
+ tmp_7 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_8 = string.pointer;
+ (string.pointer) ++;
+ *tmp_7 = *tmp_8;
+ yaml_char_t tmp_33 = *tmp_7;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_9;
+ yaml_char_t *tmp_10;
+ yaml_char_t *tmp_11;
+ yaml_char_t *tmp_12;
+ tmp_9 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_10 = string.pointer;
+ (string.pointer) ++;
+ *tmp_9 = *tmp_10;
+ tmp_11 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_12 = string.pointer;
+ (string.pointer) ++;
+ *tmp_11 = *tmp_12;
+ yaml_char_t tmp_31 = *tmp_11;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_13;
+ yaml_char_t *tmp_14;
+ yaml_char_t *tmp_15;
+ yaml_char_t *tmp_16;
+ yaml_char_t *tmp_17;
+ yaml_char_t *tmp_18;
+ tmp_13 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_14 = string.pointer;
+ (string.pointer) ++;
+ *tmp_13 = *tmp_14;
+ tmp_15 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_16 = string.pointer;
+ (string.pointer) ++;
+ *tmp_15 = *tmp_16;
+ tmp_17 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_18 = string.pointer;
+ (string.pointer) ++;
+ *tmp_17 = *tmp_18;
+ yaml_char_t tmp_29 = *tmp_17;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_19;
+ yaml_char_t *tmp_20;
+ yaml_char_t *tmp_21;
+ yaml_char_t *tmp_22;
+ yaml_char_t *tmp_23;
+ yaml_char_t *tmp_24;
+ yaml_char_t *tmp_25;
+ yaml_char_t *tmp_26;
+ tmp_19 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_20 = string.pointer;
+ (string.pointer) ++;
+ *tmp_19 = *tmp_20;
+ tmp_21 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_22 = string.pointer;
+ (string.pointer) ++;
+ *tmp_21 = *tmp_22;
+ tmp_23 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_24 = string.pointer;
+ (string.pointer) ++;
+ *tmp_23 = *tmp_24;
+ tmp_25 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_26 = string.pointer;
+ (string.pointer) ++;
+ *tmp_25 = *tmp_26;
+ yaml_char_t tmp_27 = *tmp_25;
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ spaces = 1;
+ }
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\r')) goto _LOR_6;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n'))
+ goto _LOR_6;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_6;
+ else goto _LAND_6;
+ }
+ else {
+ _LAND_6: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_6;
+ else goto _LAND_5;
+ }
+ else goto _LAND_5;
+ }
+ else {
+ _LAND_5: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\251')) {
+ _LOR_6:
+ {
+ if (! breaks)
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n'))
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_2;
+ else {
+ int tmp_27_0;
+ tmp_27_0 = yaml_emitter_flush(emitter);
+ if (tmp_27_0) {
+ _LOR_2: ;
+ if (emitter->line_break == (unsigned int)YAML_CR_BREAK) {
+ yaml_char_t *tmp_28;
+ tmp_28 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_28 = (unsigned char)'\r';
+ yaml_char_t tmp_39 = *tmp_28;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_LN_BREAK) {
+ yaml_char_t *tmp_29_0;
+ tmp_29_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_29_0 = (unsigned char)'\n';
+ yaml_char_t tmp_37 = *tmp_29_0;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_CRLN_BREAK) {
+ yaml_char_t *tmp_30;
+ yaml_char_t *tmp_31_0;
+ tmp_30 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_30 = (unsigned char)'\r';
+ tmp_31_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_31_0 = (unsigned char)'\n';
+ yaml_char_t tmp_35 = *tmp_31_0;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_4;
+ else {
+ int tmp_32;
+ tmp_32 = yaml_emitter_flush(emitter);
+ if (tmp_32) {
+ int tmp_59_0;
+ _LOR_4: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n')) {
+ int tmp_38;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_3;
+ else {
+ int tmp_33_0;
+ tmp_33_0 = yaml_emitter_flush(emitter);
+ if (tmp_33_0) {
+ _LOR_3: ;
+ if (emitter->line_break == (unsigned int)YAML_CR_BREAK) {
+ yaml_char_t *tmp_34;
+ tmp_34 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_34 = (unsigned char)'\r';
+ yaml_char_t tmp_45 = *tmp_34;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_LN_BREAK) {
+ yaml_char_t *tmp_35_0;
+ tmp_35_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_35_0 = (unsigned char)'\n';
+ yaml_char_t tmp_43 = *tmp_35_0;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_CRLN_BREAK) {
+ yaml_char_t *tmp_36;
+ yaml_char_t *tmp_37_0;
+ tmp_36 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_36 = (unsigned char)'\r';
+ tmp_37_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_37_0 = (unsigned char)'\n';
+ yaml_char_t tmp_41 = *tmp_37_0;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ tmp_38 = 1;
+ }
+ else tmp_38 = 0;
+ }
+ (string.pointer) ++;
+ tmp_59_0 = 1;
+ }
+ else {
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_39_0;
+ yaml_char_t *tmp_40;
+ tmp_39_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_40 = string.pointer;
+ (string.pointer) ++;
+ *tmp_39_0 = *tmp_40;
+ yaml_char_t tmp_65 = *tmp_39_0;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_41_0;
+ yaml_char_t *tmp_42;
+ yaml_char_t *tmp_43_0;
+ yaml_char_t *tmp_44;
+ tmp_41_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_42 = string.pointer;
+ (string.pointer) ++;
+ *tmp_41_0 = *tmp_42;
+ tmp_43_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_44 = string.pointer;
+ (string.pointer) ++;
+ *tmp_43_0 = *tmp_44;
+ yaml_char_t tmp_63 = *tmp_43_0;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_45_0;
+ yaml_char_t *tmp_46;
+ yaml_char_t *tmp_47;
+ yaml_char_t *tmp_48;
+ yaml_char_t *tmp_49;
+ yaml_char_t *tmp_50;
+ tmp_45_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_46 = string.pointer;
+ (string.pointer) ++;
+ *tmp_45_0 = *tmp_46;
+ tmp_47 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_48 = string.pointer;
+ (string.pointer) ++;
+ *tmp_47 = *tmp_48;
+ tmp_49 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_50 = string.pointer;
+ (string.pointer) ++;
+ *tmp_49 = *tmp_50;
+ yaml_char_t tmp_61 = *tmp_49;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_51;
+ yaml_char_t *tmp_52;
+ yaml_char_t *tmp_53;
+ yaml_char_t *tmp_54;
+ yaml_char_t *tmp_55;
+ yaml_char_t *tmp_56;
+ yaml_char_t *tmp_57;
+ yaml_char_t *tmp_58;
+ tmp_51 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_52 = string.pointer;
+ (string.pointer) ++;
+ *tmp_51 = *tmp_52;
+ tmp_53 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_54 = string.pointer;
+ (string.pointer) ++;
+ *tmp_53 = *tmp_54;
+ tmp_55 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_56 = string.pointer;
+ (string.pointer) ++;
+ *tmp_55 = *tmp_56;
+ tmp_57 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_58 = string.pointer;
+ (string.pointer) ++;
+ *tmp_57 = *tmp_58;
+ yaml_char_t tmp_59 = *tmp_57;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ tmp_59_0 = 1;
+ }
+ if (! tmp_59_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->indention = 1;
+ breaks = 1;
+ }
+ }
+ else goto _LAND_3;
+ }
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3:
+ {
+ if (breaks) {
+ int tmp_60;
+ tmp_60 = yaml_emitter_write_indent(emitter);
+ if (! tmp_60) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_5;
+ else {
+ int tmp_61_0;
+ tmp_61_0 = yaml_emitter_flush(emitter);
+ if (tmp_61_0) {
+ _LOR_5: ;
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_62;
+ yaml_char_t *tmp_63_0;
+ tmp_62 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_63_0 = string.pointer;
+ (string.pointer) ++;
+ *tmp_62 = *tmp_63_0;
+ yaml_char_t tmp_88 = *tmp_62;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_64;
+ yaml_char_t *tmp_65_0;
+ yaml_char_t *tmp_66;
+ yaml_char_t *tmp_67;
+ tmp_64 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_65_0 = string.pointer;
+ (string.pointer) ++;
+ *tmp_64 = *tmp_65_0;
+ tmp_66 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_67 = string.pointer;
+ (string.pointer) ++;
+ *tmp_66 = *tmp_67;
+ yaml_char_t tmp_86 = *tmp_66;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_68;
+ yaml_char_t *tmp_69;
+ yaml_char_t *tmp_70;
+ yaml_char_t *tmp_71;
+ yaml_char_t *tmp_72;
+ yaml_char_t *tmp_73;
+ tmp_68 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_69 = string.pointer;
+ (string.pointer) ++;
+ *tmp_68 = *tmp_69;
+ tmp_70 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_71 = string.pointer;
+ (string.pointer) ++;
+ *tmp_70 = *tmp_71;
+ tmp_72 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_73 = string.pointer;
+ (string.pointer) ++;
+ *tmp_72 = *tmp_73;
+ yaml_char_t tmp_84 = *tmp_72;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_74;
+ yaml_char_t *tmp_75;
+ yaml_char_t *tmp_76;
+ yaml_char_t *tmp_77;
+ yaml_char_t *tmp_78;
+ yaml_char_t *tmp_79;
+ yaml_char_t *tmp_80;
+ yaml_char_t *tmp_81;
+ tmp_74 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_75 = string.pointer;
+ (string.pointer) ++;
+ *tmp_74 = *tmp_75;
+ tmp_76 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_77 = string.pointer;
+ (string.pointer) ++;
+ *tmp_76 = *tmp_77;
+ tmp_78 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_79 = string.pointer;
+ (string.pointer) ++;
+ *tmp_78 = *tmp_79;
+ tmp_80 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_81 = string.pointer;
+ (string.pointer) ++;
+ *tmp_80 = *tmp_81;
+ yaml_char_t tmp_82 = *tmp_80;
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->indention = 0;
+ spaces = 0;
+ breaks = 0;
+ }
+ }
+ }
+ }
+ emitter->whitespace = 0;
+ emitter->indention = 0;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value,
+ size_t length,
+ int allow_breaks)
+{
+ int __retres;
+ yaml_string_t string;
+ int tmp;
+ int tmp_84;
+ int spaces = 0;
+ int breaks = 0;
+ string.start = value;
+ string.end = value + length;
+ string.pointer = value;
+ tmp = yaml_emitter_write_indicator(emitter,"\'",1,0,0);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ while (string.pointer != string.end)
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)' ')) {
+ if (allow_breaks) {
+ if (! spaces) {
+ if (emitter->column > emitter->best_width) {
+ if (string.pointer != string.start) {
+ if (string.pointer != string.end - 1) {
+ if (! ((int)*(string.pointer + 1) == (int)((unsigned char)' '))) {
+ int tmp_0;
+ int tmp_4;
+ tmp_0 = yaml_emitter_write_indent(emitter);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_4 = 1;
+ else {
+ int tmp_3;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_3 = 2;
+ else {
+ int tmp_2;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_2 = 3;
+ else {
+ int tmp_1;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_1 = 4;
+ else tmp_1 = 0;
+ tmp_2 = tmp_1;
+ }
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ string.pointer += tmp_4;
+ }
+ else goto _LAND_3;
+ }
+ else goto _LAND_3;
+ }
+ else goto _LAND_3;
+ }
+ else goto _LAND_3;
+ }
+ else goto _LAND_3;
+ }
+ else
+ _LAND_3:
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR;
+ else {
+ int tmp_5;
+ tmp_5 = yaml_emitter_flush(emitter);
+ if (tmp_5) {
+ _LOR: ;
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_6;
+ yaml_char_t *tmp_7;
+ tmp_6 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_7 = string.pointer;
+ (string.pointer) ++;
+ *tmp_6 = *tmp_7;
+ yaml_char_t tmp_32 = *tmp_6;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_8;
+ yaml_char_t *tmp_9;
+ yaml_char_t *tmp_10;
+ yaml_char_t *tmp_11;
+ tmp_8 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_9 = string.pointer;
+ (string.pointer) ++;
+ *tmp_8 = *tmp_9;
+ tmp_10 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_11 = string.pointer;
+ (string.pointer) ++;
+ *tmp_10 = *tmp_11;
+ yaml_char_t tmp_30 = *tmp_10;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_12;
+ yaml_char_t *tmp_13;
+ yaml_char_t *tmp_14;
+ yaml_char_t *tmp_15;
+ yaml_char_t *tmp_16;
+ yaml_char_t *tmp_17;
+ tmp_12 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_13 = string.pointer;
+ (string.pointer) ++;
+ *tmp_12 = *tmp_13;
+ tmp_14 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_15 = string.pointer;
+ (string.pointer) ++;
+ *tmp_14 = *tmp_15;
+ tmp_16 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_17 = string.pointer;
+ (string.pointer) ++;
+ *tmp_16 = *tmp_17;
+ yaml_char_t tmp_28 = *tmp_16;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_18;
+ yaml_char_t *tmp_19;
+ yaml_char_t *tmp_20;
+ yaml_char_t *tmp_21;
+ yaml_char_t *tmp_22;
+ yaml_char_t *tmp_23;
+ yaml_char_t *tmp_24;
+ yaml_char_t *tmp_25;
+ tmp_18 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_19 = string.pointer;
+ (string.pointer) ++;
+ *tmp_18 = *tmp_19;
+ tmp_20 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_21 = string.pointer;
+ (string.pointer) ++;
+ *tmp_20 = *tmp_21;
+ tmp_22 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_23 = string.pointer;
+ (string.pointer) ++;
+ *tmp_22 = *tmp_23;
+ tmp_24 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_25 = string.pointer;
+ (string.pointer) ++;
+ *tmp_24 = *tmp_25;
+ yaml_char_t tmp_26 = *tmp_24;
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ spaces = 1;
+ }
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\r')) goto _LOR_5;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n'))
+ goto _LOR_5;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_5;
+ else goto _LAND_8;
+ }
+ else {
+ _LAND_8: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_5;
+ else goto _LAND_7;
+ }
+ else goto _LAND_7;
+ }
+ else {
+ _LAND_7: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\251')) {
+ _LOR_5:
+ {
+ if (! breaks)
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n'))
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_0;
+ else {
+ int tmp_26_1;
+ tmp_26_1 = yaml_emitter_flush(emitter);
+ if (tmp_26_1) {
+ _LOR_0: ;
+ if (emitter->line_break == (unsigned int)YAML_CR_BREAK) {
+ yaml_char_t *tmp_27;
+ tmp_27 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_27 = (unsigned char)'\r';
+ yaml_char_t tmp_38 = *tmp_27;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_LN_BREAK) {
+ yaml_char_t *tmp_28_1;
+ tmp_28_1 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_28_1 = (unsigned char)'\n';
+ yaml_char_t tmp_36 = *tmp_28_1;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_CRLN_BREAK) {
+ yaml_char_t *tmp_29;
+ yaml_char_t *tmp_30_0;
+ tmp_29 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_29 = (unsigned char)'\r';
+ tmp_30_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_30_0 = (unsigned char)'\n';
+ yaml_char_t tmp_34 = *tmp_30_0;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_2;
+ else {
+ int tmp_31;
+ tmp_31 = yaml_emitter_flush(emitter);
+ if (tmp_31) {
+ int tmp_58_0;
+ _LOR_2: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n')) {
+ int tmp_37;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_1;
+ else {
+ int tmp_32_0;
+ tmp_32_0 = yaml_emitter_flush(emitter);
+ if (tmp_32_0) {
+ _LOR_1: ;
+ if (emitter->line_break == (unsigned int)YAML_CR_BREAK) {
+ yaml_char_t *tmp_33;
+ tmp_33 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_33 = (unsigned char)'\r';
+ yaml_char_t tmp_44 = *tmp_33;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_LN_BREAK) {
+ yaml_char_t *tmp_34_0;
+ tmp_34_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_34_0 = (unsigned char)'\n';
+ yaml_char_t tmp_42 = *tmp_34_0;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_CRLN_BREAK) {
+ yaml_char_t *tmp_35;
+ yaml_char_t *tmp_36_0;
+ tmp_35 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_35 = (unsigned char)'\r';
+ tmp_36_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_36_0 = (unsigned char)'\n';
+ yaml_char_t tmp_40 = *tmp_36_0;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ tmp_37 = 1;
+ }
+ else tmp_37 = 0;
+ }
+ (string.pointer) ++;
+ tmp_58_0 = 1;
+ }
+ else {
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_38_0;
+ yaml_char_t *tmp_39;
+ tmp_38_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_39 = string.pointer;
+ (string.pointer) ++;
+ *tmp_38_0 = *tmp_39;
+ yaml_char_t tmp_64 = *tmp_38_0;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_40_0;
+ yaml_char_t *tmp_41;
+ yaml_char_t *tmp_42_0;
+ yaml_char_t *tmp_43;
+ tmp_40_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_41 = string.pointer;
+ (string.pointer) ++;
+ *tmp_40_0 = *tmp_41;
+ tmp_42_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_43 = string.pointer;
+ (string.pointer) ++;
+ *tmp_42_0 = *tmp_43;
+ yaml_char_t tmp_62 = *tmp_42_0;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_44_0;
+ yaml_char_t *tmp_45;
+ yaml_char_t *tmp_46;
+ yaml_char_t *tmp_47;
+ yaml_char_t *tmp_48;
+ yaml_char_t *tmp_49;
+ tmp_44_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_45 = string.pointer;
+ (string.pointer) ++;
+ *tmp_44_0 = *tmp_45;
+ tmp_46 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_47 = string.pointer;
+ (string.pointer) ++;
+ *tmp_46 = *tmp_47;
+ tmp_48 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_49 = string.pointer;
+ (string.pointer) ++;
+ *tmp_48 = *tmp_49;
+ yaml_char_t tmp_60 = *tmp_48;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_50;
+ yaml_char_t *tmp_51;
+ yaml_char_t *tmp_52;
+ yaml_char_t *tmp_53;
+ yaml_char_t *tmp_54;
+ yaml_char_t *tmp_55;
+ yaml_char_t *tmp_56;
+ yaml_char_t *tmp_57;
+ tmp_50 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_51 = string.pointer;
+ (string.pointer) ++;
+ *tmp_50 = *tmp_51;
+ tmp_52 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_53 = string.pointer;
+ (string.pointer) ++;
+ *tmp_52 = *tmp_53;
+ tmp_54 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_55 = string.pointer;
+ (string.pointer) ++;
+ *tmp_54 = *tmp_55;
+ tmp_56 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_57 = string.pointer;
+ (string.pointer) ++;
+ *tmp_56 = *tmp_57;
+ yaml_char_t tmp_58 = *tmp_56;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ tmp_58_0 = 1;
+ }
+ if (! tmp_58_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->indention = 1;
+ breaks = 1;
+ }
+ }
+ else goto _LAND_5;
+ }
+ else goto _LAND_5;
+ }
+ else {
+ _LAND_5:
+ {
+ if (breaks) {
+ int tmp_59;
+ tmp_59 = yaml_emitter_write_indent(emitter);
+ if (! tmp_59) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\''))
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_3;
+ else {
+ int tmp_60_0;
+ tmp_60_0 = yaml_emitter_flush(emitter);
+ if (tmp_60_0) {
+ yaml_char_t *tmp_61;
+ _LOR_3:
+ { /* sequence */
+ tmp_61 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_61 = (unsigned char)'\'';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_4;
+ else {
+ int tmp_62_0;
+ tmp_62_0 = yaml_emitter_flush(emitter);
+ if (tmp_62_0) {
+ _LOR_4: ;
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_63;
+ yaml_char_t *tmp_64_0;
+ tmp_63 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_64_0 = string.pointer;
+ (string.pointer) ++;
+ *tmp_63 = *tmp_64_0;
+ yaml_char_t tmp_89 = *tmp_63;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_65;
+ yaml_char_t *tmp_66;
+ yaml_char_t *tmp_67;
+ yaml_char_t *tmp_68;
+ tmp_65 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_66 = string.pointer;
+ (string.pointer) ++;
+ *tmp_65 = *tmp_66;
+ tmp_67 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_68 = string.pointer;
+ (string.pointer) ++;
+ *tmp_67 = *tmp_68;
+ yaml_char_t tmp_87 = *tmp_67;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_69;
+ yaml_char_t *tmp_70;
+ yaml_char_t *tmp_71;
+ yaml_char_t *tmp_72;
+ yaml_char_t *tmp_73;
+ yaml_char_t *tmp_74;
+ tmp_69 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_70 = string.pointer;
+ (string.pointer) ++;
+ *tmp_69 = *tmp_70;
+ tmp_71 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_72 = string.pointer;
+ (string.pointer) ++;
+ *tmp_71 = *tmp_72;
+ tmp_73 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_74 = string.pointer;
+ (string.pointer) ++;
+ *tmp_73 = *tmp_74;
+ yaml_char_t tmp_85 = *tmp_73;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_75;
+ yaml_char_t *tmp_76;
+ yaml_char_t *tmp_77;
+ yaml_char_t *tmp_78;
+ yaml_char_t *tmp_79;
+ yaml_char_t *tmp_80;
+ yaml_char_t *tmp_81;
+ yaml_char_t *tmp_82;
+ tmp_75 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_76 = string.pointer;
+ (string.pointer) ++;
+ *tmp_75 = *tmp_76;
+ tmp_77 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_78 = string.pointer;
+ (string.pointer) ++;
+ *tmp_77 = *tmp_78;
+ tmp_79 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_80 = string.pointer;
+ (string.pointer) ++;
+ *tmp_79 = *tmp_80;
+ tmp_81 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_82 = string.pointer;
+ (string.pointer) ++;
+ *tmp_81 = *tmp_82;
+ yaml_char_t tmp_83 = *tmp_81;
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->indention = 0;
+ spaces = 0;
+ breaks = 0;
+ }
+ }
+ }
+ }
+ if (breaks) {
+ int tmp_83_0;
+ tmp_83_0 = yaml_emitter_write_indent(emitter);
+ if (! tmp_83_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ tmp_84 = yaml_emitter_write_indicator(emitter,"\'",0,0,0);
+ if (! tmp_84) {
+ __retres = 0;
+ goto return_label;
+ }
+ emitter->whitespace = 0;
+ emitter->indention = 0;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_write_double_quoted_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value,
+ size_t length,
+ int allow_breaks)
+{
+ int __retres;
+ yaml_string_t string;
+ int tmp;
+ int tmp_96_0;
+ int spaces = 0;
+ string.start = value;
+ string.end = value + length;
+ string.pointer = value;
+ tmp = yaml_emitter_write_indicator(emitter,"\"",1,0,0);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ while (string.pointer != string.end)
+ if ((int)*(string.pointer + 0) == 0x0A) goto _LAND_11;
+ else
+ if ((int)*(string.pointer + 0) >= 0x20) {
+ if ((int)*(string.pointer + 0) <= 0x7E) goto _LAND_11;
+ else goto _LAND_16;
+ }
+ else {
+ _LAND_16: ;
+ if ((int)*(string.pointer + 0) == 0xC2) {
+ if ((int)*(string.pointer + (0 + 1)) >= 0xA0) goto _LAND_11;
+ else goto _LAND_15;
+ }
+ else {
+ _LAND_15: ;
+ if ((int)*(string.pointer + 0) > 0xC2) {
+ if ((int)*(string.pointer + 0) < 0xED) goto _LAND_11;
+ else goto _LAND_14;
+ }
+ else {
+ _LAND_14: ;
+ if ((int)*(string.pointer + 0) == 0xED) {
+ if ((int)*(string.pointer + (0 + 1)) < 0xA0) goto _LAND_11;
+ else goto _LAND_13;
+ }
+ else {
+ _LAND_13: ;
+ if ((int)*(string.pointer + 0) == 0xEE) goto _LAND_11;
+ else
+ if ((int)*(string.pointer + 0) == 0xEF)
+ if ((int)*(string.pointer + (0 + 1)) == 0xBB) {
+ if ((int)*(string.pointer + (0 + 2)) == 0xBF) goto _LOR_22;
+ else goto _LAND_12;
+ }
+ else {
+ _LAND_12: ;
+ if ((int)*(string.pointer + (0 + 1)) == 0xBF) {
+ if ((int)*(string.pointer + (0 + 2)) == 0xBE) goto _LOR_22;
+ else
+ if ((int)*(string.pointer + (0 + 2)) == 0xBF)
+ goto _LOR_22;
+ else goto _LAND_11;
+ }
+ else
+ _LAND_11:
+ if (! emitter->unicode) {
+ if (! ((int)*(string.pointer + 0) <= (int)((unsigned char)'\177')))
+ goto _LOR_22;
+ else goto _LAND_10;
+ }
+ else {
+ _LAND_10: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\357')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\273')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\277'))
+ goto _LOR_22;
+ else goto _LAND_9;
+ }
+ else goto _LAND_9;
+ }
+ else {
+ _LAND_9: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_22;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n'))
+ goto _LOR_22;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_22;
+ else goto _LAND_7;
+ }
+ else {
+ _LAND_7: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_22;
+ else goto _LAND_6;
+ }
+ else goto _LAND_6;
+ }
+ else {
+ _LAND_6: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\251'))
+ goto _LOR_22;
+ else goto _LAND_4;
+ }
+ else goto _LAND_4;
+ }
+ else {
+ _LAND_4: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\"'))
+ goto _LOR_22;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\\')) {
+ _LOR_22:
+ {
+ unsigned char octet;
+ unsigned int width;
+ unsigned int value_0;
+ int k;
+ octet = *(string.pointer + 0);
+ if (((int)octet & 0x80) == 0x00)
+ width = (unsigned int)1;
+ else {
+ int tmp_2;
+ if (((int)octet & 0xE0) == 0xC0)
+ tmp_2 = 2;
+ else {
+ int tmp_1;
+ if (((int)octet & 0xF0) == 0xE0)
+ tmp_1 = 3;
+ else {
+ int tmp_0;
+ if (((int)octet & 0xF8) == 0xF0)
+ tmp_0 = 4;
+ else tmp_0 = 0;
+ tmp_1 = tmp_0;
+ }
+ tmp_2 = tmp_1;
+ }
+ width = (unsigned int)tmp_2;
+ }
+ if (((int)octet & 0x80) == 0x00)
+ value_0 = (unsigned int)(
+ (int)octet & 0x7F);
+ else {
+ int tmp_5;
+ if (((int)octet & 0xE0) == 0xC0)
+ tmp_5 = (int)octet & 0x1F;
+ else {
+ int tmp_4;
+ if (((int)octet & 0xF0) == 0xE0)
+ tmp_4 = (int)octet & 0x0F;
+ else {
+ int tmp_3;
+ if (((int)octet & 0xF8) == 0xF0)
+ tmp_3 = (int)octet & 0x07;
+ else tmp_3 = 0;
+ tmp_4 = tmp_3;
+ }
+ tmp_5 = tmp_4;
+ }
+ value_0 = (unsigned int)tmp_5;
+ }
+ k = 1;
+ while (k < (int)width) {
+ octet = *(string.pointer + k);
+ value_0 = (value_0 << 6) + (unsigned int)(
+ (int)octet & 0x3F);
+ k ++;
+ }
+ string.pointer += width;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR;
+ else {
+ int tmp_6;
+ tmp_6 = yaml_emitter_flush
+ (emitter);
+ if (tmp_6) {
+ yaml_char_t *tmp_7;
+ _LOR:
+ { /* sequence */
+ tmp_7 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_7 = (unsigned char)'\\';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ switch (value_0) {
+ case (unsigned int)0x00: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_0;
+ else {
+ int tmp_8;
+ tmp_8 = yaml_emitter_flush
+ (emitter);
+ if (tmp_8) {
+ yaml_char_t *tmp_9;
+ _LOR_0:
+ { /* sequence */
+ tmp_9 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_9 = (unsigned char)'0';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0x07: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_1;
+ else {
+ int tmp_10;
+ tmp_10 = yaml_emitter_flush
+ (emitter);
+ if (tmp_10) {
+ yaml_char_t *tmp_11;
+ _LOR_1:
+ { /* sequence */
+ tmp_11 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_11 = (unsigned char)'a';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0x08: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_2;
+ else {
+ int tmp_12;
+ tmp_12 = yaml_emitter_flush
+ (emitter);
+ if (tmp_12) {
+ yaml_char_t *tmp_13;
+ _LOR_2:
+ { /* sequence */
+ tmp_13 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_13 = (unsigned char)'b';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0x09: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_3;
+ else {
+ int tmp_14;
+ tmp_14 = yaml_emitter_flush
+ (emitter);
+ if (tmp_14) {
+ yaml_char_t *tmp_15;
+ _LOR_3:
+ { /* sequence */
+ tmp_15 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_15 = (unsigned char)'t';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0x0A: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_4;
+ else {
+ int tmp_16;
+ tmp_16 = yaml_emitter_flush
+ (emitter);
+ if (tmp_16) {
+ yaml_char_t *tmp_17;
+ _LOR_4:
+ { /* sequence */
+ tmp_17 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_17 = (unsigned char)'n';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0x0B: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_5;
+ else {
+ int tmp_18;
+ tmp_18 = yaml_emitter_flush
+ (emitter);
+ if (tmp_18) {
+ yaml_char_t *tmp_19;
+ _LOR_5:
+ { /* sequence */
+ tmp_19 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_19 = (unsigned char)'v';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0x0C: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_6;
+ else {
+ int tmp_20;
+ tmp_20 = yaml_emitter_flush
+ (emitter);
+ if (tmp_20) {
+ yaml_char_t *tmp_21;
+ _LOR_6:
+ { /* sequence */
+ tmp_21 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_21 = (unsigned char)'f';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0x0D: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_7;
+ else {
+ int tmp_22;
+ tmp_22 = yaml_emitter_flush
+ (emitter);
+ if (tmp_22) {
+ yaml_char_t *tmp_23;
+ _LOR_7:
+ { /* sequence */
+ tmp_23 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_23 = (unsigned char)'r';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0x1B: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_8;
+ else {
+ int tmp_24;
+ tmp_24 = yaml_emitter_flush
+ (emitter);
+ if (tmp_24) {
+ yaml_char_t *tmp_25;
+ _LOR_8:
+ { /* sequence */
+ tmp_25 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_25 = (unsigned char)'e';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0x22: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_9;
+ else {
+ int tmp_26;
+ tmp_26 = yaml_emitter_flush
+ (emitter);
+ if (tmp_26) {
+ yaml_char_t *tmp_27;
+ _LOR_9:
+ { /* sequence */
+ tmp_27 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_27 = (unsigned char)'\"';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0x5C: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_10;
+ else {
+ int tmp_28;
+ tmp_28 = yaml_emitter_flush
+ (emitter);
+ if (tmp_28) {
+ yaml_char_t *tmp_29;
+ _LOR_10:
+ { /* sequence */
+ tmp_29 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_29 = (unsigned char)'\\';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0x85: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_11;
+ else {
+ int tmp_30;
+ tmp_30 = yaml_emitter_flush
+ (emitter);
+ if (tmp_30) {
+ yaml_char_t *tmp_31;
+ _LOR_11:
+ { /* sequence */
+ tmp_31 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_31 = (unsigned char)'N';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0xA0: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_12;
+ else {
+ int tmp_32;
+ tmp_32 = yaml_emitter_flush
+ (emitter);
+ if (tmp_32) {
+ yaml_char_t *tmp_33;
+ _LOR_12:
+ { /* sequence */
+ tmp_33 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_33 = (unsigned char)'_';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0x2028: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_13;
+ else {
+ int tmp_34;
+ tmp_34 = yaml_emitter_flush
+ (emitter);
+ if (tmp_34) {
+ yaml_char_t *tmp_35;
+ _LOR_13:
+ { /* sequence */
+ tmp_35 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_35 = (unsigned char)'L';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0x2029: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_14;
+ else {
+ int tmp_36;
+ tmp_36 = yaml_emitter_flush
+ (emitter);
+ if (tmp_36) {
+ yaml_char_t *tmp_37;
+ _LOR_14:
+ { /* sequence */
+ tmp_37 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_37 = (unsigned char)'P';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ default: ;
+ if (value_0 <= (unsigned int)0xFF) {
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_15;
+ else {
+ int tmp_38;
+ tmp_38 = yaml_emitter_flush
+ (emitter);
+ if (tmp_38) {
+ yaml_char_t *tmp_39;
+ _LOR_15:
+ { /* sequence */
+ tmp_39 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_39 = (unsigned char)'x';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ width = (unsigned int)2;
+ }
+ else
+ if (value_0 <= (unsigned int)0xFFFF) {
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_16;
+ else {
+ int tmp_40;
+ tmp_40 = yaml_emitter_flush
+ (emitter);
+ if (tmp_40) {
+ yaml_char_t *tmp_41;
+ _LOR_16:
+ { /* sequence */
+ tmp_41 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_41 = (unsigned char)'u';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ width = (unsigned int)4;
+ }
+ else {
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_17;
+ else {
+ int tmp_42;
+ tmp_42 = yaml_emitter_flush
+ (emitter);
+ if (tmp_42) {
+ yaml_char_t *tmp_43;
+ _LOR_17:
+ { /* sequence */
+ tmp_43 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_43 = (unsigned char)'U';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ width = (unsigned int)8;
+ }
+ k = (int)((width - (unsigned int)1) * (unsigned int)4);
+ while (k >= 0) {
+ {
+ int digit =
+ (int)((value_0 >> k) & (unsigned int)0x0F);
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_18;
+ else {
+ int tmp_44;
+ tmp_44 = yaml_emitter_flush
+ (emitter);
+ if (tmp_44) {
+ yaml_char_t *tmp_45;
+ int tmp_46;
+ _LOR_18:
+ { /* sequence */
+ tmp_45 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ if (digit < 10)
+ tmp_46 = '0';
+ else tmp_46 = 'A' - 10;
+ *tmp_45 = (unsigned char)(
+ digit + tmp_46);
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ k -= 4;
+ }
+ }
+ spaces = 0;
+ }
+ }
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)' ')) {
+ if (allow_breaks) {
+ if (! spaces) {
+ if (emitter->column > emitter->best_width) {
+ if (string.pointer != string.start) {
+ if (string.pointer !=
+ string.end - 1) {
+ int tmp_47;
+ int tmp_53;
+ tmp_47 = yaml_emitter_write_indent
+ (emitter);
+ if (! tmp_47) {
+ __retres = 0;
+ goto return_label;
+ }
+ if ((int)*(string.pointer + 1) == (int)((unsigned char)' '))
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_19;
+ else {
+ int tmp_48;
+ tmp_48 = yaml_emitter_flush
+ (emitter);
+ if (tmp_48) {
+ yaml_char_t *tmp_49;
+ _LOR_19:
+ { /* sequence */
+ tmp_49 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_49 = (unsigned char)'\\';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00)
+ tmp_53 = 1;
+ else {
+ int tmp_52;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_52 = 2;
+ else {
+ int tmp_51;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_51 = 3;
+ else {
+ int tmp_50;
+ if (((int)*(
+ string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_50 = 4;
+ else tmp_50 = 0;
+ tmp_51 = tmp_50;
+ }
+ tmp_52 = tmp_51;
+ }
+ tmp_53 = tmp_52;
+ }
+ string.pointer += tmp_53;
+ }
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else
+ _LAND_2:
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_20;
+ else {
+ int tmp_54;
+ tmp_54 = yaml_emitter_flush
+ (emitter);
+ if (tmp_54) {
+ _LOR_20: ;
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_55;
+ yaml_char_t *tmp_56;
+ tmp_55 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_56 = string.pointer;
+ (string.pointer) ++;
+ *tmp_55 = *tmp_56;
+ yaml_char_t tmp_81 =
+ *tmp_55;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_57;
+ yaml_char_t *tmp_58;
+ yaml_char_t *tmp_59;
+ yaml_char_t *tmp_60;
+ tmp_57 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_58 = string.pointer;
+ (string.pointer) ++;
+ *tmp_57 = *tmp_58;
+ tmp_59 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_60 = string.pointer;
+ (string.pointer) ++;
+ *tmp_59 = *tmp_60;
+ yaml_char_t tmp_79 =
+ *tmp_59;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_61;
+ yaml_char_t *tmp_62;
+ yaml_char_t *tmp_63;
+ yaml_char_t *tmp_64;
+ yaml_char_t *tmp_65;
+ yaml_char_t *tmp_66;
+ tmp_61 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_62 = string.pointer;
+ (string.pointer) ++;
+ *tmp_61 = *tmp_62;
+ tmp_63 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_64 = string.pointer;
+ (string.pointer) ++;
+ *tmp_63 = *tmp_64;
+ tmp_65 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_66 = string.pointer;
+ (string.pointer) ++;
+ *tmp_65 = *tmp_66;
+ yaml_char_t tmp_77 =
+ *tmp_65;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_67;
+ yaml_char_t *tmp_68;
+ yaml_char_t *tmp_69;
+ yaml_char_t *tmp_70;
+ yaml_char_t *tmp_71;
+ yaml_char_t *tmp_72;
+ yaml_char_t *tmp_73;
+ yaml_char_t *tmp_74;
+ tmp_67 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_68 = string.pointer;
+ (string.pointer) ++;
+ *tmp_67 = *tmp_68;
+ tmp_69 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_70 = string.pointer;
+ (string.pointer) ++;
+ *tmp_69 = *tmp_70;
+ tmp_71 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_72 = string.pointer;
+ (string.pointer) ++;
+ *tmp_71 = *tmp_72;
+ tmp_73 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_74 = string.pointer;
+ (string.pointer) ++;
+ *tmp_73 = *tmp_74;
+ yaml_char_t tmp_75 =
+ *tmp_73;
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ spaces = 1;
+ }
+ else {
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_21;
+ else {
+ int tmp_75_0;
+ tmp_75_0 = yaml_emitter_flush
+ (emitter);
+ if (tmp_75_0) {
+ _LOR_21: ;
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_76;
+ yaml_char_t *tmp_77_0;
+ tmp_76 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_77_0 = string.pointer;
+ (string.pointer) ++;
+ *tmp_76 = *tmp_77_0;
+ yaml_char_t tmp_102 =
+ *tmp_76;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_78;
+ yaml_char_t *tmp_79_0;
+ yaml_char_t *tmp_80;
+ yaml_char_t *tmp_81_0;
+ tmp_78 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_79_0 = string.pointer;
+ (string.pointer) ++;
+ *tmp_78 = *tmp_79_0;
+ tmp_80 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_81_0 = string.pointer;
+ (string.pointer) ++;
+ *tmp_80 = *tmp_81_0;
+ yaml_char_t tmp_100 =
+ *tmp_80;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_82;
+ yaml_char_t *tmp_83;
+ yaml_char_t *tmp_84;
+ yaml_char_t *tmp_85;
+ yaml_char_t *tmp_86;
+ yaml_char_t *tmp_87;
+ tmp_82 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_83 = string.pointer;
+ (string.pointer) ++;
+ *tmp_82 = *tmp_83;
+ tmp_84 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_85 = string.pointer;
+ (string.pointer) ++;
+ *tmp_84 = *tmp_85;
+ tmp_86 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_87 = string.pointer;
+ (string.pointer) ++;
+ *tmp_86 = *tmp_87;
+ yaml_char_t tmp_98 =
+ *tmp_86;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_88;
+ yaml_char_t *tmp_89;
+ yaml_char_t *tmp_90;
+ yaml_char_t *tmp_91;
+ yaml_char_t *tmp_92;
+ yaml_char_t *tmp_93;
+ yaml_char_t *tmp_94;
+ yaml_char_t *tmp_95;
+ tmp_88 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_89 = string.pointer;
+ (string.pointer) ++;
+ *tmp_88 = *tmp_89;
+ tmp_90 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_91 = string.pointer;
+ (string.pointer) ++;
+ *tmp_90 = *tmp_91;
+ tmp_92 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_93 = string.pointer;
+ (string.pointer) ++;
+ *tmp_92 = *tmp_93;
+ tmp_94 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_95 = string.pointer;
+ (string.pointer) ++;
+ *tmp_94 = *tmp_95;
+ yaml_char_t tmp_96 =
+ *tmp_94;
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ spaces = 0;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ else goto _LOR_22;
+ }
+ }
+ }
+ }
+ tmp_96_0 = yaml_emitter_write_indicator(emitter,"\"",0,0,0);
+ if (! tmp_96_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ emitter->whitespace = 0;
+ emitter->indention = 0;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_write_block_scalar_hints(yaml_emitter_t *emitter,
+ yaml_string_t string)
+{
+ int __retres;
+ char indent_hint[2];
+ char const *chomp_hint = (char const *)0;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)' ')) goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\r')) goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n')) goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_0;
+ else goto _LAND_1;
+ }
+ else {
+ _LAND_1: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_0;
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200'))
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\251')) {
+ _LOR_0:
+ {
+ int tmp;
+ indent_hint[0] = (char)('0' + (int)((char)emitter->best_indent));
+ indent_hint[1] = (char)'\000';
+ tmp = yaml_emitter_write_indicator(emitter,
+ (char const *)(indent_hint),
+ 0,0,0);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ }
+ }
+ emitter->open_ended = 0;
+ string.pointer = string.end;
+ if (string.start == string.pointer) chomp_hint = "-";
+ else {
+ while (1) {
+ (string.pointer) --;
+ if (! (((int)*(string.pointer) & 0xC0) == 0x80)) break;
+ }
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\r')) goto _LOR_2;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n')) goto _LOR_2;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_2;
+ else goto _LAND_9;
+ }
+ else {
+ _LAND_9: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_2;
+ else goto _LAND_8;
+ }
+ else goto _LAND_8;
+ }
+ else {
+ _LAND_8: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\251')) {
+ _LOR_2: ;
+ if (string.start == string.pointer) {
+ chomp_hint = "+";
+ emitter->open_ended = 2;
+ }
+ else {
+ while (1) {
+ (string.pointer) --;
+ if (! (((int)*(string.pointer) & 0xC0) == 0x80))
+ break;
+ }
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_1;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n'))
+ goto _LOR_1;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_1;
+ else goto _LAND_4;
+ }
+ else {
+ _LAND_4: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_1;
+ else goto _LAND_3;
+ }
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200'))
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\251')) {
+ _LOR_1:
+ {
+ chomp_hint = "+";
+ emitter->open_ended = 2;
+ }
+ }
+ }
+ }
+ }
+ }
+ else goto _LAND_6;
+ }
+ else goto _LAND_6;
+ }
+ else _LAND_6: chomp_hint = "-";
+ }
+ }
+ }
+ if (chomp_hint) {
+ int tmp_0;
+ tmp_0 = yaml_emitter_write_indicator(emitter,chomp_hint,0,0,0);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_write_literal_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value,
+ size_t length)
+{
+ int __retres;
+ yaml_string_t string;
+ int tmp;
+ int tmp_0;
+ int breaks = 1;
+ string.start = value;
+ string.end = value + length;
+ string.pointer = value;
+ tmp = yaml_emitter_write_indicator(emitter,"|",1,0,0);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_0 = yaml_emitter_write_block_scalar_hints(emitter,string);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_emitter_flush(emitter);
+ if (tmp_1) {
+ _LOR: ;
+ if (emitter->line_break == (unsigned int)YAML_CR_BREAK) {
+ yaml_char_t *tmp_2;
+ tmp_2 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_2 = (unsigned char)'\r';
+ yaml_char_t tmp_10 = *tmp_2;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_LN_BREAK) {
+ yaml_char_t *tmp_3;
+ tmp_3 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_3 = (unsigned char)'\n';
+ yaml_char_t tmp_8 = *tmp_3;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_CRLN_BREAK) {
+ yaml_char_t *tmp_4;
+ yaml_char_t *tmp_5;
+ tmp_4 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_4 = (unsigned char)'\r';
+ tmp_5 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_5 = (unsigned char)'\n';
+ yaml_char_t tmp_6 = *tmp_5;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->indention = 1;
+ emitter->whitespace = 1;
+ while (string.pointer != string.end)
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\r')) goto _LOR_3;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n')) goto _LOR_3;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_3;
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_3;
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ _LAND_2: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\251')) {
+ _LOR_3:
+ {
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_1;
+ else {
+ int tmp_6_0;
+ tmp_6_0 = yaml_emitter_flush(emitter);
+ if (tmp_6_0) {
+ int tmp_33_1;
+ _LOR_1: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n')) {
+ int tmp_12_0;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_0;
+ else {
+ int tmp_7;
+ tmp_7 = yaml_emitter_flush(emitter);
+ if (tmp_7) {
+ _LOR_0: ;
+ if (emitter->line_break == (unsigned int)YAML_CR_BREAK) {
+ yaml_char_t *tmp_8_0;
+ tmp_8_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_8_0 = (unsigned char)'\r';
+ yaml_char_t tmp_16 = *tmp_8_0;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_LN_BREAK) {
+ yaml_char_t *tmp_9;
+ tmp_9 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_9 = (unsigned char)'\n';
+ yaml_char_t tmp_14 = *tmp_9;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_CRLN_BREAK) {
+ yaml_char_t *tmp_10_0;
+ yaml_char_t *tmp_11;
+ tmp_10_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_10_0 = (unsigned char)'\r';
+ tmp_11 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_11 = (unsigned char)'\n';
+ yaml_char_t tmp_12 = *tmp_11;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ tmp_12_0 = 1;
+ }
+ else tmp_12_0 = 0;
+ }
+ (string.pointer) ++;
+ tmp_33_1 = 1;
+ }
+ else {
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_13;
+ yaml_char_t *tmp_14_0;
+ tmp_13 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_14_0 = string.pointer;
+ (string.pointer) ++;
+ *tmp_13 = *tmp_14_0;
+ yaml_char_t tmp_39 = *tmp_13;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_15;
+ yaml_char_t *tmp_16_0;
+ yaml_char_t *tmp_17;
+ yaml_char_t *tmp_18;
+ tmp_15 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_16_0 = string.pointer;
+ (string.pointer) ++;
+ *tmp_15 = *tmp_16_0;
+ tmp_17 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_18 = string.pointer;
+ (string.pointer) ++;
+ *tmp_17 = *tmp_18;
+ yaml_char_t tmp_37 = *tmp_17;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_19;
+ yaml_char_t *tmp_20;
+ yaml_char_t *tmp_21;
+ yaml_char_t *tmp_22;
+ yaml_char_t *tmp_23;
+ yaml_char_t *tmp_24;
+ tmp_19 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_20 = string.pointer;
+ (string.pointer) ++;
+ *tmp_19 = *tmp_20;
+ tmp_21 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_22 = string.pointer;
+ (string.pointer) ++;
+ *tmp_21 = *tmp_22;
+ tmp_23 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_24 = string.pointer;
+ (string.pointer) ++;
+ *tmp_23 = *tmp_24;
+ yaml_char_t tmp_35 = *tmp_23;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_25;
+ yaml_char_t *tmp_26;
+ yaml_char_t *tmp_27;
+ yaml_char_t *tmp_28;
+ yaml_char_t *tmp_29;
+ yaml_char_t *tmp_30;
+ yaml_char_t *tmp_31;
+ yaml_char_t *tmp_32;
+ tmp_25 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_26 = string.pointer;
+ (string.pointer) ++;
+ *tmp_25 = *tmp_26;
+ tmp_27 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_28 = string.pointer;
+ (string.pointer) ++;
+ *tmp_27 = *tmp_28;
+ tmp_29 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_30 = string.pointer;
+ (string.pointer) ++;
+ *tmp_29 = *tmp_30;
+ tmp_31 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_32 = string.pointer;
+ (string.pointer) ++;
+ *tmp_31 = *tmp_32;
+ yaml_char_t tmp_33 = *tmp_31;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ tmp_33_1 = 1;
+ }
+ if (! tmp_33_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->indention = 1;
+ breaks = 1;
+ }
+ }
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0:
+ {
+ if (breaks) {
+ int tmp_34;
+ tmp_34 = yaml_emitter_write_indent(emitter);
+ if (! tmp_34) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_2;
+ else {
+ int tmp_35_1;
+ tmp_35_1 = yaml_emitter_flush(emitter);
+ if (tmp_35_1) {
+ _LOR_2: ;
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_36;
+ yaml_char_t *tmp_37_1;
+ tmp_36 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_37_1 = string.pointer;
+ (string.pointer) ++;
+ *tmp_36 = *tmp_37_1;
+ yaml_char_t tmp_62 = *tmp_36;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_38;
+ yaml_char_t *tmp_39_1;
+ yaml_char_t *tmp_40;
+ yaml_char_t *tmp_41;
+ tmp_38 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_39_1 = string.pointer;
+ (string.pointer) ++;
+ *tmp_38 = *tmp_39_1;
+ tmp_40 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_41 = string.pointer;
+ (string.pointer) ++;
+ *tmp_40 = *tmp_41;
+ yaml_char_t tmp_60 = *tmp_40;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_42;
+ yaml_char_t *tmp_43;
+ yaml_char_t *tmp_44;
+ yaml_char_t *tmp_45;
+ yaml_char_t *tmp_46;
+ yaml_char_t *tmp_47;
+ tmp_42 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_43 = string.pointer;
+ (string.pointer) ++;
+ *tmp_42 = *tmp_43;
+ tmp_44 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_45 = string.pointer;
+ (string.pointer) ++;
+ *tmp_44 = *tmp_45;
+ tmp_46 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_47 = string.pointer;
+ (string.pointer) ++;
+ *tmp_46 = *tmp_47;
+ yaml_char_t tmp_58 = *tmp_46;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_48;
+ yaml_char_t *tmp_49;
+ yaml_char_t *tmp_50;
+ yaml_char_t *tmp_51;
+ yaml_char_t *tmp_52;
+ yaml_char_t *tmp_53;
+ yaml_char_t *tmp_54;
+ yaml_char_t *tmp_55;
+ tmp_48 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_49 = string.pointer;
+ (string.pointer) ++;
+ *tmp_48 = *tmp_49;
+ tmp_50 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_51 = string.pointer;
+ (string.pointer) ++;
+ *tmp_50 = *tmp_51;
+ tmp_52 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_53 = string.pointer;
+ (string.pointer) ++;
+ *tmp_52 = *tmp_53;
+ tmp_54 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_55 = string.pointer;
+ (string.pointer) ++;
+ *tmp_54 = *tmp_55;
+ yaml_char_t tmp_56 = *tmp_54;
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->indention = 0;
+ breaks = 0;
+ }
+ }
+ }
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length)
+{
+ int __retres;
+ yaml_string_t string;
+ int tmp;
+ int tmp_0;
+ int breaks = 1;
+ int leading_spaces = 1;
+ string.start = value;
+ string.end = value + length;
+ string.pointer = value;
+ tmp = yaml_emitter_write_indicator(emitter,">",1,0,0);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_0 = yaml_emitter_write_block_scalar_hints(emitter,string);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_emitter_flush(emitter);
+ if (tmp_1) {
+ _LOR: ;
+ if (emitter->line_break == (unsigned int)YAML_CR_BREAK) {
+ yaml_char_t *tmp_2;
+ tmp_2 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_2 = (unsigned char)'\r';
+ yaml_char_t tmp_10 = *tmp_2;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_LN_BREAK) {
+ yaml_char_t *tmp_3;
+ tmp_3 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_3 = (unsigned char)'\n';
+ yaml_char_t tmp_8 = *tmp_3;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_CRLN_BREAK) {
+ yaml_char_t *tmp_4;
+ yaml_char_t *tmp_5;
+ tmp_4 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_4 = (unsigned char)'\r';
+ tmp_5 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_5 = (unsigned char)'\n';
+ yaml_char_t tmp_6 = *tmp_5;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->indention = 1;
+ emitter->whitespace = 1;
+ while (string.pointer != string.end)
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\r')) goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n')) goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_4;
+ else goto _LAND_14;
+ }
+ else {
+ _LAND_14: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_4;
+ else goto _LAND_13;
+ }
+ else goto _LAND_13;
+ }
+ else {
+ _LAND_13: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\251')) {
+ _LOR_4:
+ {
+ if (! breaks)
+ if (! leading_spaces)
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n')) {
+ int k = 0;
+ while (1) {
+ if (! ((int)*(string.pointer + k) == (int)((unsigned char)'\r')))
+ if (! ((int)*(string.pointer + k) == (int)((unsigned char)'\n')))
+ if ((int)*(string.pointer + k) == (int)((unsigned char)'\302')) {
+ if (! ((int)*(string.pointer + (k + 1)) == (int)((unsigned char)'\205')))
+ goto _LAND_1;
+ }
+ else {
+ _LAND_1: ;
+ if ((int)*(string.pointer + k) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (k + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(string.pointer + (k + 2)) == (int)((unsigned char)'\250')))
+ goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(string.pointer + k) == (int)((unsigned char)'\342'))
+ if ((int)*(string.pointer + (k + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(string.pointer + (
+ k + 2)) == (int)((unsigned char)'\251')))
+ break;
+ }
+ else break;
+ else break;
+ }
+ }
+ {
+ int tmp_9;
+ if (((int)*(string.pointer + k) & 0x80) == 0x00)
+ tmp_9 = 1;
+ else {
+ int tmp_8_1;
+ if (((int)*(string.pointer + k) & 0xE0) == 0xC0)
+ tmp_8_1 = 2;
+ else {
+ int tmp_7;
+ if (((int)*(string.pointer + k) & 0xF0) == 0xE0)
+ tmp_7 = 3;
+ else {
+ int tmp_6_1;
+ if (((int)*(string.pointer + k) & 0xF8) == 0xF0)
+ tmp_6_1 = 4;
+ else tmp_6_1 = 0;
+ tmp_7 = tmp_6_1;
+ }
+ tmp_8_1 = tmp_7;
+ }
+ tmp_9 = tmp_8_1;
+ }
+ k += tmp_9;
+ }
+ }
+ if (! ((int)*(string.pointer + k) == (int)((unsigned char)' ')))
+ if (! ((int)*(string.pointer + k) == (int)((unsigned char)'\t')))
+ if (! ((int)*(string.pointer + k) == (int)((unsigned char)'\r')))
+ if (! ((int)*(string.pointer + k) == (int)((unsigned char)'\n')))
+ if ((int)*(string.pointer + k) == (int)((unsigned char)'\302')) {
+ if (! ((int)*(string.pointer + (k + 1)) == (int)((unsigned char)'\205')))
+ goto _LAND_6;
+ }
+ else {
+ _LAND_6: ;
+ if ((int)*(string.pointer + k) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (k + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(string.pointer + (
+ k + 2)) == (int)((unsigned char)'\250')))
+ goto _LAND_5;
+ }
+ else goto _LAND_5;
+ }
+ else {
+ _LAND_5: ;
+ if ((int)*(string.pointer + k) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (k + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(string.pointer + (
+ k + 2)) == (int)((unsigned char)'\251')))
+ goto _LAND_3;
+ }
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if (! ((int)*(string.pointer + k) == (int)((unsigned char)'\000')))
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_0;
+ else {
+ int tmp_10_1;
+ tmp_10_1 = yaml_emitter_flush
+ (emitter);
+ if (tmp_10_1) {
+ _LOR_0: ;
+ if (emitter->line_break == (unsigned int)YAML_CR_BREAK) {
+ yaml_char_t *tmp_11;
+ tmp_11 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_11 = (unsigned char)'\r';
+ yaml_char_t tmp_19 = *tmp_11;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_LN_BREAK) {
+ yaml_char_t *tmp_12;
+ tmp_12 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_12 = (unsigned char)'\n';
+ yaml_char_t tmp_17 =
+ *tmp_12;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_CRLN_BREAK) {
+ yaml_char_t *tmp_13;
+ yaml_char_t *tmp_14;
+ tmp_13 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_13 = (unsigned char)'\r';
+ tmp_14 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_14 = (unsigned char)'\n';
+ yaml_char_t tmp_15 =
+ *tmp_14;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ }
+ }
+ }
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_2;
+ else {
+ int tmp_15_0;
+ tmp_15_0 = yaml_emitter_flush(emitter);
+ if (tmp_15_0) {
+ int tmp_42_1;
+ _LOR_2: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n')) {
+ int tmp_21_0;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_1;
+ else {
+ int tmp_16;
+ tmp_16 = yaml_emitter_flush(emitter);
+ if (tmp_16) {
+ _LOR_1: ;
+ if (emitter->line_break == (unsigned int)YAML_CR_BREAK) {
+ yaml_char_t *tmp_17_0;
+ tmp_17_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_17_0 = (unsigned char)'\r';
+ yaml_char_t tmp_25 = *tmp_17_0;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_LN_BREAK) {
+ yaml_char_t *tmp_18;
+ tmp_18 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_18 = (unsigned char)'\n';
+ yaml_char_t tmp_23 = *tmp_18;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_CRLN_BREAK) {
+ yaml_char_t *tmp_19_0;
+ yaml_char_t *tmp_20;
+ tmp_19_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_19_0 = (unsigned char)'\r';
+ tmp_20 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_20 = (unsigned char)'\n';
+ yaml_char_t tmp_21 = *tmp_20;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ tmp_21_0 = 1;
+ }
+ else tmp_21_0 = 0;
+ }
+ (string.pointer) ++;
+ tmp_42_1 = 1;
+ }
+ else {
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_22;
+ yaml_char_t *tmp_23_0;
+ tmp_22 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_23_0 = string.pointer;
+ (string.pointer) ++;
+ *tmp_22 = *tmp_23_0;
+ yaml_char_t tmp_48 = *tmp_22;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_24;
+ yaml_char_t *tmp_25_0;
+ yaml_char_t *tmp_26;
+ yaml_char_t *tmp_27;
+ tmp_24 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_25_0 = string.pointer;
+ (string.pointer) ++;
+ *tmp_24 = *tmp_25_0;
+ tmp_26 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_27 = string.pointer;
+ (string.pointer) ++;
+ *tmp_26 = *tmp_27;
+ yaml_char_t tmp_46 = *tmp_26;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_28;
+ yaml_char_t *tmp_29;
+ yaml_char_t *tmp_30;
+ yaml_char_t *tmp_31;
+ yaml_char_t *tmp_32;
+ yaml_char_t *tmp_33;
+ tmp_28 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_29 = string.pointer;
+ (string.pointer) ++;
+ *tmp_28 = *tmp_29;
+ tmp_30 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_31 = string.pointer;
+ (string.pointer) ++;
+ *tmp_30 = *tmp_31;
+ tmp_32 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_33 = string.pointer;
+ (string.pointer) ++;
+ *tmp_32 = *tmp_33;
+ yaml_char_t tmp_44 = *tmp_32;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_34;
+ yaml_char_t *tmp_35;
+ yaml_char_t *tmp_36;
+ yaml_char_t *tmp_37;
+ yaml_char_t *tmp_38;
+ yaml_char_t *tmp_39;
+ yaml_char_t *tmp_40;
+ yaml_char_t *tmp_41;
+ tmp_34 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_35 = string.pointer;
+ (string.pointer) ++;
+ *tmp_34 = *tmp_35;
+ tmp_36 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_37 = string.pointer;
+ (string.pointer) ++;
+ *tmp_36 = *tmp_37;
+ tmp_38 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_39 = string.pointer;
+ (string.pointer) ++;
+ *tmp_38 = *tmp_39;
+ tmp_40 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_41 = string.pointer;
+ (string.pointer) ++;
+ *tmp_40 = *tmp_41;
+ yaml_char_t tmp_42 = *tmp_40;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ tmp_42_1 = 1;
+ }
+ if (! tmp_42_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->indention = 1;
+ breaks = 1;
+ }
+ }
+ else goto _LAND_11;
+ }
+ else goto _LAND_11;
+ }
+ else {
+ _LAND_11:
+ {
+ if (breaks) {
+ int tmp_43;
+ int tmp_44_1;
+ tmp_43 = yaml_emitter_write_indent(emitter);
+ if (! tmp_43) {
+ __retres = 0;
+ goto return_label;
+ }
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)' '))
+ tmp_44_1 = 1;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\t'))
+ tmp_44_1 = 1;
+ else tmp_44_1 = 0;
+ leading_spaces = tmp_44_1;
+ }
+ if (! breaks) {
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)' ')) {
+ if (! ((int)*(string.pointer + 1) == (int)((unsigned char)' '))) {
+ if (emitter->column > emitter->best_width) {
+ int tmp_45;
+ int tmp_49;
+ tmp_45 = yaml_emitter_write_indent(emitter);
+ if (! tmp_45) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00)
+ tmp_49 = 1;
+ else {
+ int tmp_48_0;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_48_0 = 2;
+ else {
+ int tmp_47;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_47 = 3;
+ else {
+ int tmp_46_0;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_46_0 = 4;
+ else tmp_46_0 = 0;
+ tmp_47 = tmp_46_0;
+ }
+ tmp_48_0 = tmp_47;
+ }
+ tmp_49 = tmp_48_0;
+ }
+ string.pointer += tmp_49;
+ }
+ else goto _LAND_9;
+ }
+ else goto _LAND_9;
+ }
+ else goto _LAND_9;
+ }
+ else
+ _LAND_9:
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_3;
+ else {
+ int tmp_50;
+ tmp_50 = yaml_emitter_flush(emitter);
+ if (tmp_50) {
+ _LOR_3: ;
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_51;
+ yaml_char_t *tmp_52;
+ tmp_51 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_52 = string.pointer;
+ (string.pointer) ++;
+ *tmp_51 = *tmp_52;
+ yaml_char_t tmp_77 = *tmp_51;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_53;
+ yaml_char_t *tmp_54;
+ yaml_char_t *tmp_55;
+ yaml_char_t *tmp_56;
+ tmp_53 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_54 = string.pointer;
+ (string.pointer) ++;
+ *tmp_53 = *tmp_54;
+ tmp_55 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_56 = string.pointer;
+ (string.pointer) ++;
+ *tmp_55 = *tmp_56;
+ yaml_char_t tmp_75 = *tmp_55;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_57;
+ yaml_char_t *tmp_58;
+ yaml_char_t *tmp_59;
+ yaml_char_t *tmp_60;
+ yaml_char_t *tmp_61;
+ yaml_char_t *tmp_62;
+ tmp_57 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_58 = string.pointer;
+ (string.pointer) ++;
+ *tmp_57 = *tmp_58;
+ tmp_59 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_60 = string.pointer;
+ (string.pointer) ++;
+ *tmp_59 = *tmp_60;
+ tmp_61 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_62 = string.pointer;
+ (string.pointer) ++;
+ *tmp_61 = *tmp_62;
+ yaml_char_t tmp_73 = *tmp_61;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_63;
+ yaml_char_t *tmp_64;
+ yaml_char_t *tmp_65;
+ yaml_char_t *tmp_66;
+ yaml_char_t *tmp_67;
+ yaml_char_t *tmp_68;
+ yaml_char_t *tmp_69;
+ yaml_char_t *tmp_70;
+ tmp_63 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_64 = string.pointer;
+ (string.pointer) ++;
+ *tmp_63 = *tmp_64;
+ tmp_65 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_66 = string.pointer;
+ (string.pointer) ++;
+ *tmp_65 = *tmp_66;
+ tmp_67 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_68 = string.pointer;
+ (string.pointer) ++;
+ *tmp_67 = *tmp_68;
+ tmp_69 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_70 = string.pointer;
+ (string.pointer) ++;
+ *tmp_69 = *tmp_70;
+ yaml_char_t tmp_71 = *tmp_69;
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->indention = 0;
+ breaks = 0;
+ }
+ }
+ }
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_set_composer_error(yaml_parser_t *parser,
+ char const *problem,
+ yaml_mark_t problem_mark);
+
+static int yaml_parser_set_composer_error_context(yaml_parser_t *parser,
+ char const *context,
+ yaml_mark_t context_mark,
+ char const *problem,
+ yaml_mark_t problem_mark);
+
+static int yaml_parser_register_anchor(yaml_parser_t *parser, int index_0,
+ yaml_char_t *anchor);
+
+static void yaml_parser_delete_aliases(yaml_parser_t *parser);
+
+static int yaml_parser_load_nodes(yaml_parser_t *parser,
+ struct loader_ctx *ctx);
+
+static int yaml_parser_load_document(yaml_parser_t *parser,
+ yaml_event_t *event);
+
+static int yaml_parser_load_alias(yaml_parser_t *parser, yaml_event_t *event,
+ struct loader_ctx *ctx);
+
+static int yaml_parser_load_scalar(yaml_parser_t *parser,
+ yaml_event_t *event,
+ struct loader_ctx *ctx);
+
+static int yaml_parser_load_sequence(yaml_parser_t *parser,
+ yaml_event_t *event,
+ struct loader_ctx *ctx);
+
+static int yaml_parser_load_mapping(yaml_parser_t *parser,
+ yaml_event_t *event,
+ struct loader_ctx *ctx);
+
+static int yaml_parser_load_sequence_end(yaml_parser_t *parser,
+ yaml_event_t *event,
+ struct loader_ctx *ctx);
+
+static int yaml_parser_load_mapping_end(yaml_parser_t *parser,
+ yaml_event_t *event,
+ struct loader_ctx *ctx);
+
+int yaml_parser_load(yaml_parser_t *parser, yaml_document_t *document)
+{
+ int __retres;
+ yaml_event_t event;
+ int tmp_1;
+ yaml_node_t *tmp;
+ int tmp_3;
+ int tmp_6;
+ yaml_alias_data_t *tmp_4;
+ int tmp_7;
+ __FC_assert(parser != (yaml_parser_t *)0,"src/loader.c",91,"parser");
+ __FC_assert(document != (yaml_document_t *)0,"src/loader.c",92,"document");
+ memset((void *)document,0,sizeof(yaml_document_t));
+ tmp = (yaml_node_t *)yaml_malloc((unsigned long)16 * sizeof(*(document->nodes.start)));
+ document->nodes.start = tmp;
+ if (tmp) {
+ document->nodes.top = document->nodes.start;
+ document->nodes.end = document->nodes.start + 16;
+ tmp_1 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_1 = 0;
+ }
+ if (! tmp_1) goto error;
+ if (! parser->stream_start_produced) {
+ int tmp_2;
+ tmp_2 = yaml_parser_parse(parser,& event);
+ if (! tmp_2) goto error;
+ __FC_assert((event.type == (unsigned int)YAML_STREAM_START_EVENT) != 0,
+ "src/loader.c",100,"event.type == YAML_STREAM_START_EVENT");
+ }
+ if (parser->stream_end_produced) {
+ __retres = 1;
+ goto return_label;
+ }
+ tmp_3 = yaml_parser_parse(parser,& event);
+ if (! tmp_3) goto error;
+ if (event.type == (unsigned int)YAML_STREAM_END_EVENT) {
+ __retres = 1;
+ goto return_label;
+ }
+ tmp_4 = (yaml_alias_data_t *)yaml_malloc((unsigned long)16 * sizeof(*(parser->aliases.start)));
+ parser->aliases.start = tmp_4;
+ if (tmp_4) {
+ parser->aliases.top = parser->aliases.start;
+ parser->aliases.end = parser->aliases.start + 16;
+ tmp_6 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_6 = 0;
+ }
+ if (! tmp_6) goto error;
+ parser->document = document;
+ tmp_7 = yaml_parser_load_document(parser,& event);
+ if (! tmp_7) goto error;
+ yaml_parser_delete_aliases(parser);
+ parser->document = (yaml_document_t *)0;
+ __retres = 1;
+ goto return_label;
+ error: yaml_parser_delete_aliases(parser);
+ yaml_document_delete(document);
+ parser->document = (yaml_document_t *)0;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_set_composer_error(yaml_parser_t *parser,
+ char const *problem,
+ yaml_mark_t problem_mark)
+{
+ int __retres;
+ parser->error = YAML_COMPOSER_ERROR;
+ parser->problem = problem;
+ parser->problem_mark = problem_mark;
+ __retres = 0;
+ return __retres;
+}
+
+static int yaml_parser_set_composer_error_context(yaml_parser_t *parser,
+ char const *context,
+ yaml_mark_t context_mark,
+ char const *problem,
+ yaml_mark_t problem_mark)
+{
+ int __retres;
+ parser->error = YAML_COMPOSER_ERROR;
+ parser->context = context;
+ parser->context_mark = context_mark;
+ parser->problem = problem;
+ parser->problem_mark = problem_mark;
+ __retres = 0;
+ return __retres;
+}
+
+static void yaml_parser_delete_aliases(yaml_parser_t *parser)
+{
+ yaml_alias_data_t *tmp_0;
+ yaml_alias_data_t *tmp;
+ while (! (parser->aliases.start == parser->aliases.top)) {
+ (parser->aliases.top) --;
+ ;
+ yaml_free((void *)(parser->aliases.top)->anchor);
+ }
+ yaml_free((void *)parser->aliases.start);
+ tmp_0 = (yaml_alias_data_t *)0;
+ parser->aliases.end = tmp_0;
+ tmp = tmp_0;
+ parser->aliases.top = tmp;
+ parser->aliases.start = tmp;
+ return;
+}
+
+static int yaml_parser_load_document(yaml_parser_t *parser,
+ yaml_event_t *event)
+{
+ int __retres;
+ int tmp_0;
+ int tmp_1;
+ struct loader_ctx ctx =
+ {.start = (int *)0, .end = (int *)0, .top = (int *)0};
+ __FC_assert((event->type == (unsigned int)YAML_DOCUMENT_START_EVENT) != 0,
+ "src/loader.c",189,"event->type == YAML_DOCUMENT_START_EVENT");
+ (parser->document)->version_directive = event->data.document_start.version_directive;
+ (parser->document)->tag_directives.start = event->data.document_start.tag_directives.start;
+ (parser->document)->tag_directives.end = event->data.document_start.tag_directives.end;
+ (parser->document)->start_implicit = event->data.document_start.implicit;
+ (parser->document)->start_mark = event->start_mark;
+ ctx.start = (int *)yaml_malloc((unsigned long)16 * sizeof(*(ctx.start)));
+ if (ctx.start) {
+ ctx.top = ctx.start;
+ ctx.end = ctx.start + 16;
+ tmp_0 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_0 = 0;
+ }
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_1 = yaml_parser_load_nodes(parser,& ctx);
+ if (! tmp_1) {
+ yaml_free((void *)ctx.start);
+ ctx.end = (int *)0;
+ ctx.top = ctx.end;
+ ctx.start = ctx.top;
+ __retres = 0;
+ goto return_label;
+ }
+ yaml_free((void *)ctx.start);
+ ctx.end = (int *)0;
+ ctx.top = ctx.end;
+ ctx.start = ctx.top;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_load_nodes(yaml_parser_t *parser,
+ struct loader_ctx *ctx)
+{
+ int __retres;
+ yaml_event_t event;
+ while (1) {
+ {
+ int tmp;
+ tmp = yaml_parser_parse(parser,& event);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ switch (event.type) {
+ int tmp_0;
+ int tmp_1;
+ int tmp_2;
+ int tmp_3;
+ int tmp_4;
+ int tmp_5;
+ case (yaml_event_type_t)YAML_ALIAS_EVENT:
+ tmp_0 = yaml_parser_load_alias(parser,& event,ctx);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ break;
+ case (yaml_event_type_t)YAML_SCALAR_EVENT:
+ tmp_1 = yaml_parser_load_scalar(parser,& event,ctx);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ break;
+ case (yaml_event_type_t)YAML_SEQUENCE_START_EVENT:
+ tmp_2 = yaml_parser_load_sequence(parser,& event,ctx);
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ break;
+ case (yaml_event_type_t)YAML_SEQUENCE_END_EVENT:
+ tmp_3 = yaml_parser_load_sequence_end(parser,& event,ctx);
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ break;
+ case (yaml_event_type_t)YAML_MAPPING_START_EVENT:
+ tmp_4 = yaml_parser_load_mapping(parser,& event,ctx);
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ break;
+ case (yaml_event_type_t)YAML_MAPPING_END_EVENT:
+ tmp_5 = yaml_parser_load_mapping_end(parser,& event,ctx);
+ if (! tmp_5) {
+ __retres = 0;
+ goto return_label;
+ }
+ break;
+ default: __FC_assert(0 != 0,"src/loader.c",246,"0");
+ __retres = 0;
+ goto return_label;
+ case (yaml_event_type_t)YAML_DOCUMENT_END_EVENT: break;
+ }
+ }
+ if (! (event.type != (unsigned int)YAML_DOCUMENT_END_EVENT)) break;
+ }
+ (parser->document)->end_implicit = event.data.document_end.implicit;
+ (parser->document)->end_mark = event.end_mark;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_register_anchor(yaml_parser_t *parser, int index_0,
+ yaml_char_t *anchor)
+{
+ int __retres;
+ yaml_alias_data_t data;
+ yaml_alias_data_t *alias_data;
+ int tmp_3;
+ if (! anchor) {
+ __retres = 1;
+ goto return_label;
+ }
+ data.anchor = anchor;
+ data.index = index_0;
+ data.mark = ((parser->document)->nodes.start + (index_0 - 1))->start_mark;
+ alias_data = parser->aliases.start;
+ while (alias_data != parser->aliases.top) {
+ {
+ int tmp_0;
+ tmp_0 = strcmp((char const *)alias_data->anchor,(char const *)anchor);
+ if (tmp_0 == 0) {
+ int tmp;
+ yaml_free((void *)anchor);
+ tmp = yaml_parser_set_composer_error_context(parser,
+ "found duplicate anchor; first occurrence",
+ alias_data->mark,
+ "second occurrence",
+ data.mark);
+ __retres = tmp;
+ goto return_label;
+ }
+ }
+ alias_data ++;
+ }
+ if (parser->aliases.top != parser->aliases.end) goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_stack_extend((void **)(& parser->aliases.start),
+ (void **)(& parser->aliases.top),
+ (void **)(& parser->aliases.end));
+ if (tmp_1) {
+ yaml_alias_data_t *tmp_2;
+ _LOR: tmp_2 = parser->aliases.top;
+ (parser->aliases.top) ++;
+ *tmp_2 = data;
+ tmp_3 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) {
+ yaml_free((void *)anchor);
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_load_node_add(yaml_parser_t *parser,
+ struct loader_ctx *ctx, int index_0)
+{
+ int __retres;
+ struct yaml_node_s *parent;
+ int parent_index;
+ if (ctx->start == ctx->top) {
+ __retres = 1;
+ goto return_label;
+ }
+ parent_index = *(ctx->top - 1);
+ parent = (parser->document)->nodes.start + (parent_index - 1);
+ switch (parent->type) {
+ int tmp;
+ int tmp_2;
+ case (yaml_node_type_t)YAML_SEQUENCE_NODE: ;
+ if (parent->data.sequence.items.top - parent->data.sequence.items.start < (long)(
+ 2147483647 - 1)) tmp = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp = 0;
+ }
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (parent->data.sequence.items.top != parent->data.sequence.items.end)
+ goto _LOR;
+ else {
+ int tmp_0;
+ tmp_0 = yaml_stack_extend((void **)(& parent->data.sequence.items.start),
+ (void **)(& parent->data.sequence.items.top),
+ (void **)(& parent->data.sequence.items.end));
+ if (tmp_0) {
+ yaml_node_item_t *tmp_1;
+ _LOR: tmp_1 = parent->data.sequence.items.top;
+ (parent->data.sequence.items.top) ++;
+ *tmp_1 = index_0;
+ tmp_2 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ }
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ break;
+ case (yaml_node_type_t)YAML_MAPPING_NODE:
+ {
+ yaml_node_pair_t pair;
+ int tmp_3;
+ int tmp_6;
+ if (! (parent->data.mapping.pairs.start == parent->data.mapping.pairs.top)) {
+ yaml_node_pair_t *p = parent->data.mapping.pairs.top - 1;
+ if (p->key != 0)
+ if (p->value == 0) {
+ p->value = index_0;
+ break;
+ }
+ }
+ pair.key = index_0;
+ pair.value = 0;
+ if (parent->data.mapping.pairs.top - parent->data.mapping.pairs.start < (long)(
+ 2147483647 - 1)) tmp_3 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (parent->data.mapping.pairs.top != parent->data.mapping.pairs.end)
+ goto _LOR_0;
+ else {
+ int tmp_4;
+ tmp_4 = yaml_stack_extend((void **)(& parent->data.mapping.pairs.start),
+ (void **)(& parent->data.mapping.pairs.top),
+ (void **)(& parent->data.mapping.pairs.end));
+ if (tmp_4) {
+ yaml_node_pair_t *tmp_5;
+ _LOR_0: tmp_5 = parent->data.mapping.pairs.top;
+ (parent->data.mapping.pairs.top) ++;
+ *tmp_5 = pair;
+ tmp_6 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_6 = 0;
+ }
+ }
+ if (! tmp_6) {
+ __retres = 0;
+ goto return_label;
+ }
+ break;
+ }
+ default: __FC_assert(0 != 0,"src/loader.c",340,"0");
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_load_alias(yaml_parser_t *parser, yaml_event_t *event,
+ struct loader_ctx *ctx)
+{
+ int __retres;
+ yaml_alias_data_t *alias_data;
+ int tmp_1;
+ yaml_char_t *anchor = event->data.alias.anchor;
+ alias_data = parser->aliases.start;
+ while (alias_data != parser->aliases.top) {
+ {
+ int tmp_0;
+ tmp_0 = strcmp((char const *)alias_data->anchor,(char const *)anchor);
+ if (tmp_0 == 0) {
+ int tmp;
+ yaml_free((void *)anchor);
+ tmp = yaml_parser_load_node_add(parser,ctx,alias_data->index);
+ __retres = tmp;
+ goto return_label;
+ }
+ }
+ alias_data ++;
+ }
+ yaml_free((void *)anchor);
+ tmp_1 = yaml_parser_set_composer_error(parser,"found undefined alias",
+ event->start_mark);
+ __retres = tmp_1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_load_scalar(yaml_parser_t *parser,
+ yaml_event_t *event,
+ struct loader_ctx *ctx)
+{
+ int __retres;
+ yaml_node_t node;
+ int index_0;
+ int tmp;
+ int tmp_3;
+ int tmp_4;
+ int tmp_5;
+ yaml_char_t *tag = event->data.scalar.tag;
+ if ((parser->document)->nodes.top - (parser->document)->nodes.start < (long)(
+ 2147483647 - 1)) tmp = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp = 0;
+ }
+ if (! tmp) goto error;
+ if (! tag) goto _LOR;
+ else {
+ int tmp_0;
+ tmp_0 = strcmp((char const *)tag,"!");
+ if (tmp_0 == 0) {
+ _LOR:
+ {
+ yaml_free((void *)tag);
+ tag = yaml_strdup((yaml_char_t const *)"tag:yaml.org,2002:str");
+ if (! tag) goto error;
+ }
+ }
+ }
+ memset((void *)(& node),0,sizeof(yaml_node_t));
+ node.type = YAML_SCALAR_NODE;
+ node.tag = tag;
+ node.start_mark = event->start_mark;
+ node.end_mark = event->end_mark;
+ node.data.scalar.value = event->data.scalar.value;
+ node.data.scalar.length = event->data.scalar.length;
+ node.data.scalar.style = event->data.scalar.style;
+ if ((parser->document)->nodes.top != (parser->document)->nodes.end)
+ goto _LOR_0;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_stack_extend((void **)(& (parser->document)->nodes.start),
+ (void **)(& (parser->document)->nodes.top),
+ (void **)(& (parser->document)->nodes.end));
+ if (tmp_1) {
+ yaml_node_t *tmp_2;
+ _LOR_0: tmp_2 = (parser->document)->nodes.top;
+ ((parser->document)->nodes.top) ++;
+ *tmp_2 = node;
+ tmp_3 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) goto error;
+ index_0 = (int)((parser->document)->nodes.top - (parser->document)->nodes.start);
+ tmp_4 = yaml_parser_register_anchor(parser,index_0,
+ event->data.scalar.anchor);
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_5 = yaml_parser_load_node_add(parser,ctx,index_0);
+ __retres = tmp_5;
+ goto return_label;
+ error: yaml_free((void *)tag);
+ yaml_free((void *)event->data.scalar.anchor);
+ yaml_free((void *)event->data.scalar.value);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_load_sequence(yaml_parser_t *parser,
+ yaml_event_t *event,
+ struct loader_ctx *ctx)
+{
+ int __retres;
+ yaml_node_t node;
+ int index_0;
+ int tmp;
+ int tmp_2;
+ int tmp_5;
+ int tmp_6;
+ int tmp_7;
+ int tmp_8;
+ int tmp_11;
+ struct __anonstruct_items_49 items =
+ {.start = (yaml_node_item_t *)0,
+ .end = (yaml_node_item_t *)0,
+ .top = (yaml_node_item_t *)0};
+ yaml_char_t *tag = event->data.sequence_start.tag;
+ if ((parser->document)->nodes.top - (parser->document)->nodes.start < (long)(
+ 2147483647 - 1)) tmp = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp = 0;
+ }
+ if (! tmp) goto error;
+ if (! tag) goto _LOR;
+ else {
+ int tmp_0;
+ tmp_0 = strcmp((char const *)tag,"!");
+ if (tmp_0 == 0) {
+ _LOR:
+ {
+ yaml_free((void *)tag);
+ tag = yaml_strdup((yaml_char_t const *)"tag:yaml.org,2002:seq");
+ if (! tag) goto error;
+ }
+ }
+ }
+ items.start = (yaml_node_item_t *)yaml_malloc((unsigned long)16 * sizeof(*(items.start)));
+ if (items.start) {
+ items.top = items.start;
+ items.end = items.start + 16;
+ tmp_2 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ if (! tmp_2) goto error;
+ memset((void *)(& node),0,sizeof(yaml_node_t));
+ node.type = YAML_SEQUENCE_NODE;
+ node.tag = tag;
+ node.start_mark = event->start_mark;
+ node.end_mark = event->end_mark;
+ node.data.sequence.items.start = items.start;
+ node.data.sequence.items.end = items.end;
+ node.data.sequence.items.top = items.start;
+ node.data.sequence.style = event->data.sequence_start.style;
+ if ((parser->document)->nodes.top != (parser->document)->nodes.end)
+ goto _LOR_0;
+ else {
+ int tmp_3;
+ tmp_3 = yaml_stack_extend((void **)(& (parser->document)->nodes.start),
+ (void **)(& (parser->document)->nodes.top),
+ (void **)(& (parser->document)->nodes.end));
+ if (tmp_3) {
+ yaml_node_t *tmp_4;
+ _LOR_0: tmp_4 = (parser->document)->nodes.top;
+ ((parser->document)->nodes.top) ++;
+ *tmp_4 = node;
+ tmp_5 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_5 = 0;
+ }
+ }
+ if (! tmp_5) goto error;
+ index_0 = (int)((parser->document)->nodes.top - (parser->document)->nodes.start);
+ tmp_6 = yaml_parser_register_anchor(parser,index_0,
+ event->data.sequence_start.anchor);
+ if (! tmp_6) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_7 = yaml_parser_load_node_add(parser,ctx,index_0);
+ if (! tmp_7) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (ctx->top - ctx->start < (long)(2147483647 - 1)) tmp_8 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_8 = 0;
+ }
+ if (! tmp_8) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (ctx->top != ctx->end) goto _LOR_1;
+ else {
+ int tmp_9;
+ tmp_9 = yaml_stack_extend((void **)(& ctx->start),(void **)(& ctx->top),
+ (void **)(& ctx->end));
+ if (tmp_9) {
+ int *tmp_10;
+ _LOR_1: tmp_10 = ctx->top;
+ (ctx->top) ++;
+ *tmp_10 = index_0;
+ tmp_11 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_11 = 0;
+ }
+ }
+ if (! tmp_11) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)tag);
+ yaml_free((void *)event->data.sequence_start.anchor);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_load_sequence_end(yaml_parser_t *parser,
+ yaml_event_t *event,
+ struct loader_ctx *ctx)
+{
+ int __retres;
+ int index_0;
+ __FC_assert((ctx->top - ctx->start > (long)0) != 0,"src/loader.c",467,
+ "((*ctx).top - (*ctx).start) > 0");
+ index_0 = *(ctx->top - 1);
+ __FC_assert((((parser->document)->nodes.start + (index_0 - 1))->type == (unsigned int)YAML_SEQUENCE_NODE) != 0,
+ "src/loader.c",470,
+ "parser->document->nodes.start[index-1].type == YAML_SEQUENCE_NODE");
+ ((parser->document)->nodes.start + (index_0 - 1))->end_mark = event->end_mark;
+ (ctx->top) --;
+ ;
+ __retres = 1;
+ return __retres;
+}
+
+static int yaml_parser_load_mapping(yaml_parser_t *parser,
+ yaml_event_t *event,
+ struct loader_ctx *ctx)
+{
+ int __retres;
+ yaml_node_t node;
+ int index_0;
+ int tmp;
+ int tmp_2;
+ int tmp_5;
+ int tmp_6;
+ int tmp_7;
+ int tmp_8;
+ int tmp_11;
+ struct __anonstruct_pairs_50 pairs =
+ {.start = (yaml_node_pair_t *)0,
+ .end = (yaml_node_pair_t *)0,
+ .top = (yaml_node_pair_t *)0};
+ yaml_char_t *tag = event->data.mapping_start.tag;
+ if ((parser->document)->nodes.top - (parser->document)->nodes.start < (long)(
+ 2147483647 - 1)) tmp = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp = 0;
+ }
+ if (! tmp) goto error;
+ if (! tag) goto _LOR;
+ else {
+ int tmp_0;
+ tmp_0 = strcmp((char const *)tag,"!");
+ if (tmp_0 == 0) {
+ _LOR:
+ {
+ yaml_free((void *)tag);
+ tag = yaml_strdup((yaml_char_t const *)"tag:yaml.org,2002:map");
+ if (! tag) goto error;
+ }
+ }
+ }
+ pairs.start = (yaml_node_pair_t *)yaml_malloc((unsigned long)16 * sizeof(*(pairs.start)));
+ if (pairs.start) {
+ pairs.top = pairs.start;
+ pairs.end = pairs.start + 16;
+ tmp_2 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ if (! tmp_2) goto error;
+ memset((void *)(& node),0,sizeof(yaml_node_t));
+ node.type = YAML_MAPPING_NODE;
+ node.tag = tag;
+ node.start_mark = event->start_mark;
+ node.end_mark = event->end_mark;
+ node.data.mapping.pairs.start = pairs.start;
+ node.data.mapping.pairs.end = pairs.end;
+ node.data.mapping.pairs.top = pairs.start;
+ node.data.mapping.style = event->data.mapping_start.style;
+ if ((parser->document)->nodes.top != (parser->document)->nodes.end)
+ goto _LOR_0;
+ else {
+ int tmp_3;
+ tmp_3 = yaml_stack_extend((void **)(& (parser->document)->nodes.start),
+ (void **)(& (parser->document)->nodes.top),
+ (void **)(& (parser->document)->nodes.end));
+ if (tmp_3) {
+ yaml_node_t *tmp_4;
+ _LOR_0: tmp_4 = (parser->document)->nodes.top;
+ ((parser->document)->nodes.top) ++;
+ *tmp_4 = node;
+ tmp_5 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_5 = 0;
+ }
+ }
+ if (! tmp_5) goto error;
+ index_0 = (int)((parser->document)->nodes.top - (parser->document)->nodes.start);
+ tmp_6 = yaml_parser_register_anchor(parser,index_0,
+ event->data.mapping_start.anchor);
+ if (! tmp_6) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_7 = yaml_parser_load_node_add(parser,ctx,index_0);
+ if (! tmp_7) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (ctx->top - ctx->start < (long)(2147483647 - 1)) tmp_8 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_8 = 0;
+ }
+ if (! tmp_8) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (ctx->top != ctx->end) goto _LOR_1;
+ else {
+ int tmp_9;
+ tmp_9 = yaml_stack_extend((void **)(& ctx->start),(void **)(& ctx->top),
+ (void **)(& ctx->end));
+ if (tmp_9) {
+ int *tmp_10;
+ _LOR_1: tmp_10 = ctx->top;
+ (ctx->top) ++;
+ *tmp_10 = index_0;
+ tmp_11 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_11 = 0;
+ }
+ }
+ if (! tmp_11) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)tag);
+ yaml_free((void *)event->data.mapping_start.anchor);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_load_mapping_end(yaml_parser_t *parser,
+ yaml_event_t *event,
+ struct loader_ctx *ctx)
+{
+ int __retres;
+ int index_0;
+ __FC_assert((ctx->top - ctx->start > (long)0) != 0,"src/loader.c",535,
+ "((*ctx).top - (*ctx).start) > 0");
+ index_0 = *(ctx->top - 1);
+ __FC_assert((((parser->document)->nodes.start + (index_0 - 1))->type == (unsigned int)YAML_MAPPING_NODE) != 0,
+ "src/loader.c",538,
+ "parser->document->nodes.start[index-1].type == YAML_MAPPING_NODE");
+ ((parser->document)->nodes.start + (index_0 - 1))->end_mark = event->end_mark;
+ (ctx->top) --;
+ ;
+ __retres = 1;
+ return __retres;
+}
+
+static int yaml_parser_set_parser_error(yaml_parser_t *parser,
+ char const *problem,
+ yaml_mark_t problem_mark);
+
+static int yaml_parser_set_parser_error_context(yaml_parser_t *parser,
+ char const *context,
+ yaml_mark_t context_mark,
+ char const *problem,
+ yaml_mark_t problem_mark);
+
+static int yaml_parser_state_machine(yaml_parser_t *parser,
+ yaml_event_t *event);
+
+static int yaml_parser_parse_stream_start(yaml_parser_t *parser,
+ yaml_event_t *event);
+
+static int yaml_parser_parse_document_start(yaml_parser_t *parser,
+ yaml_event_t *event, int implicit);
+
+static int yaml_parser_parse_document_content(yaml_parser_t *parser,
+ yaml_event_t *event);
+
+static int yaml_parser_parse_document_end(yaml_parser_t *parser,
+ yaml_event_t *event);
+
+static int yaml_parser_parse_node(yaml_parser_t *parser, yaml_event_t *event,
+ int block, int indentless_sequence);
+
+static int yaml_parser_parse_block_sequence_entry(yaml_parser_t *parser,
+ yaml_event_t *event,
+ int first);
+
+static int yaml_parser_parse_indentless_sequence_entry(yaml_parser_t *parser,
+ yaml_event_t *event);
+
+static int yaml_parser_parse_block_mapping_key(yaml_parser_t *parser,
+ yaml_event_t *event, int first);
+
+static int yaml_parser_parse_block_mapping_value(yaml_parser_t *parser,
+ yaml_event_t *event);
+
+static int yaml_parser_parse_flow_sequence_entry(yaml_parser_t *parser,
+ yaml_event_t *event,
+ int first);
+
+static int yaml_parser_parse_flow_sequence_entry_mapping_key(yaml_parser_t *parser,
+ yaml_event_t *event);
+
+static int yaml_parser_parse_flow_sequence_entry_mapping_value(yaml_parser_t *parser,
+ yaml_event_t *event);
+
+static int yaml_parser_parse_flow_sequence_entry_mapping_end(yaml_parser_t *parser,
+ yaml_event_t *event);
+
+static int yaml_parser_parse_flow_mapping_key(yaml_parser_t *parser,
+ yaml_event_t *event, int first);
+
+static int yaml_parser_parse_flow_mapping_value(yaml_parser_t *parser,
+ yaml_event_t *event,
+ int empty);
+
+static int yaml_parser_process_empty_scalar(yaml_parser_t *parser,
+ yaml_event_t *event,
+ yaml_mark_t mark);
+
+static int yaml_parser_process_directives(yaml_parser_t *parser,
+ yaml_version_directive_t **version_directive_ref,
+ yaml_tag_directive_t **tag_directives_start_ref,
+ yaml_tag_directive_t **tag_directives_end_ref);
+
+static int yaml_parser_append_tag_directive(yaml_parser_t *parser,
+ yaml_tag_directive_t value,
+ int allow_duplicates,
+ yaml_mark_t mark);
+
+int yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event)
+{
+ int __retres;
+ int tmp;
+ __FC_assert(parser != (yaml_parser_t *)0,"src/parser.c",172,"parser");
+ __FC_assert(event != (yaml_event_t *)0,"src/parser.c",173,"event");
+ memset((void *)event,0,sizeof(yaml_event_t));
+ if (parser->stream_end_produced) goto _LOR;
+ else
+ if (parser->error) goto _LOR;
+ else
+ if (parser->state == (unsigned int)YAML_PARSE_END_STATE) {
+ _LOR: {
+ __retres = 1;
+ goto return_label;
+ }
+ }
+ tmp = yaml_parser_state_machine(parser,event);
+ __retres = tmp;
+ return_label: return __retres;
+}
+
+static int yaml_parser_set_parser_error(yaml_parser_t *parser,
+ char const *problem,
+ yaml_mark_t problem_mark)
+{
+ int __retres;
+ parser->error = YAML_PARSER_ERROR;
+ parser->problem = problem;
+ parser->problem_mark = problem_mark;
+ __retres = 0;
+ return __retres;
+}
+
+static int yaml_parser_set_parser_error_context(yaml_parser_t *parser,
+ char const *context,
+ yaml_mark_t context_mark,
+ char const *problem,
+ yaml_mark_t problem_mark)
+{
+ int __retres;
+ parser->error = YAML_PARSER_ERROR;
+ parser->context = context;
+ parser->context_mark = context_mark;
+ parser->problem = problem;
+ parser->problem_mark = problem_mark;
+ __retres = 0;
+ return __retres;
+}
+
+static int yaml_parser_state_machine(yaml_parser_t *parser,
+ yaml_event_t *event)
+{
+ int __retres;
+ switch (parser->state) {
+ int tmp;
+ int tmp_0;
+ int tmp_1;
+ int tmp_2;
+ int tmp_3;
+ int tmp_4;
+ int tmp_5;
+ int tmp_6;
+ int tmp_7;
+ int tmp_8;
+ int tmp_9;
+ int tmp_10;
+ int tmp_11;
+ int tmp_12;
+ int tmp_13;
+ int tmp_14;
+ int tmp_15;
+ int tmp_16;
+ int tmp_17;
+ int tmp_18;
+ int tmp_19;
+ int tmp_20;
+ int tmp_21;
+ case (yaml_parser_state_t)YAML_PARSE_STREAM_START_STATE:
+ tmp = yaml_parser_parse_stream_start(parser,event);
+ __retres = tmp;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE:
+ tmp_0 = yaml_parser_parse_document_start(parser,event,1);
+ __retres = tmp_0;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_DOCUMENT_START_STATE:
+ tmp_1 = yaml_parser_parse_document_start(parser,event,0);
+ __retres = tmp_1;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_DOCUMENT_CONTENT_STATE:
+ tmp_2 = yaml_parser_parse_document_content(parser,event);
+ __retres = tmp_2;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_DOCUMENT_END_STATE:
+ tmp_3 = yaml_parser_parse_document_end(parser,event);
+ __retres = tmp_3;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_BLOCK_NODE_STATE:
+ tmp_4 = yaml_parser_parse_node(parser,event,1,0);
+ __retres = tmp_4;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE:
+ tmp_5 = yaml_parser_parse_node(parser,event,1,1);
+ __retres = tmp_5;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_FLOW_NODE_STATE:
+ tmp_6 = yaml_parser_parse_node(parser,event,0,0);
+ __retres = tmp_6;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE:
+ tmp_7 = yaml_parser_parse_block_sequence_entry(parser,event,1);
+ __retres = tmp_7;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE:
+ tmp_8 = yaml_parser_parse_block_sequence_entry(parser,event,0);
+ __retres = tmp_8;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE:
+ tmp_9 = yaml_parser_parse_indentless_sequence_entry(parser,event);
+ __retres = tmp_9;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE:
+ tmp_10 = yaml_parser_parse_block_mapping_key(parser,event,1);
+ __retres = tmp_10;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_BLOCK_MAPPING_KEY_STATE:
+ tmp_11 = yaml_parser_parse_block_mapping_key(parser,event,0);
+ __retres = tmp_11;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_BLOCK_MAPPING_VALUE_STATE:
+ tmp_12 = yaml_parser_parse_block_mapping_value(parser,event);
+ __retres = tmp_12;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE:
+ tmp_13 = yaml_parser_parse_flow_sequence_entry(parser,event,1);
+ __retres = tmp_13;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE:
+ tmp_14 = yaml_parser_parse_flow_sequence_entry(parser,event,0);
+ __retres = tmp_14;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE:
+ tmp_15 = yaml_parser_parse_flow_sequence_entry_mapping_key(parser,event);
+ __retres = tmp_15;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE:
+ tmp_16 = yaml_parser_parse_flow_sequence_entry_mapping_value(parser,
+ event);
+ __retres = tmp_16;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE:
+ tmp_17 = yaml_parser_parse_flow_sequence_entry_mapping_end(parser,event);
+ __retres = tmp_17;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE:
+ tmp_18 = yaml_parser_parse_flow_mapping_key(parser,event,1);
+ __retres = tmp_18;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_FLOW_MAPPING_KEY_STATE:
+ tmp_19 = yaml_parser_parse_flow_mapping_key(parser,event,0);
+ __retres = tmp_19;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_FLOW_MAPPING_VALUE_STATE:
+ tmp_20 = yaml_parser_parse_flow_mapping_value(parser,event,0);
+ __retres = tmp_20;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE:
+ tmp_21 = yaml_parser_parse_flow_mapping_value(parser,event,1);
+ __retres = tmp_21;
+ goto return_label;
+ default: __FC_assert(1 != 0,"src/parser.c",300,"1");
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_stream_start(yaml_parser_t *parser,
+ yaml_event_t *event)
+{
+ int __retres;
+ yaml_token_t *token;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type != (unsigned int)YAML_STREAM_START_TOKEN) {
+ int tmp_0;
+ tmp_0 = yaml_parser_set_parser_error(parser,
+ "did not find expected <stream-start>",
+ token->start_mark);
+ __retres = tmp_0;
+ goto return_label;
+ }
+ parser->state = YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_STREAM_START_EVENT;
+ event->start_mark = token->start_mark;
+ event->end_mark = token->start_mark;
+ event->data.stream_start.encoding = token->data.stream_start.encoding;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_document_start(yaml_parser_t *parser,
+ yaml_event_t *event, int implicit)
+{
+ int __retres;
+ yaml_token_t *token;
+ yaml_version_directive_t *version_directive =
+ (yaml_version_directive_t *)0;
+ struct __anonstruct_tag_directives_49 tag_directives =
+ {.start = (yaml_tag_directive_t *)0, .end = (yaml_tag_directive_t *)0};
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (! implicit)
+ while (token->type == (unsigned int)YAML_DOCUMENT_END_TOKEN) {
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_0;
+ tmp_0 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_0) token = parser->tokens.head;
+ else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (implicit) {
+ if (token->type != (unsigned int)YAML_VERSION_DIRECTIVE_TOKEN) {
+ if (token->type != (unsigned int)YAML_TAG_DIRECTIVE_TOKEN) {
+ if (token->type != (unsigned int)YAML_DOCUMENT_START_TOKEN) {
+ if (token->type != (unsigned int)YAML_STREAM_END_TOKEN) {
+ int tmp_1;
+ int tmp_4;
+ tmp_1 = yaml_parser_process_directives(parser,
+ (yaml_version_directive_t **)0,
+ (yaml_tag_directive_t **)0,
+ (yaml_tag_directive_t **)0);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (parser->states.top != parser->states.end) goto _LOR;
+ else {
+ int tmp_2;
+ tmp_2 = yaml_stack_extend((void **)(& parser->states.start),
+ (void **)(& parser->states.top),
+ (void **)(& parser->states.end));
+ if (tmp_2) {
+ yaml_parser_state_t *tmp_3;
+ _LOR: tmp_3 = parser->states.top;
+ (parser->states.top) ++;
+ *tmp_3 = YAML_PARSE_DOCUMENT_END_STATE;
+ tmp_4 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_4 = 0;
+ }
+ }
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->state = YAML_PARSE_BLOCK_NODE_STATE;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_DOCUMENT_START_EVENT;
+ event->start_mark = token->start_mark;
+ event->end_mark = token->start_mark;
+ event->data.document_start.version_directive = (yaml_version_directive_t *)0;
+ event->data.document_start.tag_directives.start = (yaml_tag_directive_t *)0;
+ event->data.document_start.tag_directives.end = (yaml_tag_directive_t *)0;
+ event->data.document_start.implicit = 1;
+ __retres = 1;
+ goto return_label;
+ }
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ _LAND_2: ;
+ if (token->type != (unsigned int)YAML_STREAM_END_TOKEN) {
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ int tmp_5;
+ int tmp_9;
+ start_mark = token->start_mark;
+ tmp_5 = yaml_parser_process_directives(parser,& version_directive,
+ & tag_directives.start,
+ & tag_directives.end);
+ if (! tmp_5) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_6;
+ tmp_6 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_6) token = parser->tokens.head;
+ else token = (yaml_token_t *)0;
+ }
+ if (! token) goto error;
+ if (token->type != (unsigned int)YAML_DOCUMENT_START_TOKEN) {
+ yaml_parser_set_parser_error(parser,
+ "did not find expected <document start>",
+ token->start_mark);
+ goto error;
+ }
+ if (parser->states.top != parser->states.end) goto _LOR_0;
+ else {
+ int tmp_7;
+ tmp_7 = yaml_stack_extend((void **)(& parser->states.start),
+ (void **)(& parser->states.top),
+ (void **)(& parser->states.end));
+ if (tmp_7) {
+ yaml_parser_state_t *tmp_8;
+ _LOR_0: tmp_8 = parser->states.top;
+ (parser->states.top) ++;
+ *tmp_8 = YAML_PARSE_DOCUMENT_END_STATE;
+ tmp_9 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_9 = 0;
+ }
+ }
+ if (! tmp_9) goto error;
+ parser->state = YAML_PARSE_DOCUMENT_CONTENT_STATE;
+ end_mark = token->end_mark;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_DOCUMENT_START_EVENT;
+ event->start_mark = start_mark;
+ event->end_mark = end_mark;
+ event->data.document_start.version_directive = version_directive;
+ event->data.document_start.tag_directives.start = tag_directives.start;
+ event->data.document_start.tag_directives.end = tag_directives.end;
+ event->data.document_start.implicit = 0;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ version_directive = (yaml_version_directive_t *)0;
+ tag_directives.end = (yaml_tag_directive_t *)0;
+ tag_directives.start = tag_directives.end;
+ __retres = 1;
+ goto return_label;
+ }
+ else {
+ parser->state = YAML_PARSE_END_STATE;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_STREAM_END_EVENT;
+ event->start_mark = token->start_mark;
+ event->end_mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ __retres = 1;
+ goto return_label;
+ }
+ }
+ error: yaml_free((void *)version_directive);
+ while (tag_directives.start != tag_directives.end) {
+ yaml_free((void *)(tag_directives.end + -1)->handle);
+ yaml_free((void *)(tag_directives.end + -1)->prefix);
+ (tag_directives.end) --;
+ }
+ yaml_free((void *)tag_directives.start);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_document_content(yaml_parser_t *parser,
+ yaml_event_t *event)
+{
+ int __retres;
+ yaml_token_t *token;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type == (unsigned int)YAML_VERSION_DIRECTIVE_TOKEN) goto _LOR;
+ else
+ if (token->type == (unsigned int)YAML_TAG_DIRECTIVE_TOKEN) goto _LOR;
+ else
+ if (token->type == (unsigned int)YAML_DOCUMENT_START_TOKEN) goto _LOR;
+ else
+ if (token->type == (unsigned int)YAML_DOCUMENT_END_TOKEN) goto _LOR;
+ else
+ if (token->type == (unsigned int)YAML_STREAM_END_TOKEN) {
+ _LOR:
+ {
+ int tmp_0;
+ (parser->states.top) --;
+ parser->state = *(parser->states.top);
+ tmp_0 = yaml_parser_process_empty_scalar(parser,event,
+ token->start_mark);
+ __retres = tmp_0;
+ goto return_label;
+ }
+ }
+ else {
+ int tmp_1;
+ tmp_1 = yaml_parser_parse_node(parser,event,1,0);
+ __retres = tmp_1;
+ goto return_label;
+ }
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_document_end(yaml_parser_t *parser,
+ yaml_event_t *event)
+{
+ int __retres;
+ yaml_token_t *token;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ int implicit = 1;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ end_mark = token->start_mark;
+ start_mark = end_mark;
+ if (token->type == (unsigned int)YAML_DOCUMENT_END_TOKEN) {
+ end_mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ implicit = 0;
+ }
+ while (! (parser->tag_directives.start == parser->tag_directives.top)) {
+ (parser->tag_directives.top) --;
+ yaml_tag_directive_t tag_directive = *(parser->tag_directives.top);
+ yaml_free((void *)tag_directive.handle);
+ yaml_free((void *)tag_directive.prefix);
+ }
+ parser->state = YAML_PARSE_DOCUMENT_START_STATE;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_DOCUMENT_END_EVENT;
+ event->start_mark = start_mark;
+ event->end_mark = end_mark;
+ event->data.document_end.implicit = implicit;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_node(yaml_parser_t *parser, yaml_event_t *event,
+ int block, int indentless_sequence)
+{
+ int __retres;
+ yaml_token_t *token;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ yaml_mark_t tag_mark;
+ int implicit;
+ yaml_char_t *anchor = (yaml_char_t *)0;
+ yaml_char_t *tag_handle = (yaml_char_t *)0;
+ yaml_char_t *tag_suffix = (yaml_char_t *)0;
+ yaml_char_t *tag = (yaml_char_t *)0;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type == (unsigned int)YAML_ALIAS_TOKEN) {
+ (parser->states.top) --;
+ parser->state = *(parser->states.top);
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_ALIAS_EVENT;
+ event->start_mark = token->start_mark;
+ event->end_mark = token->end_mark;
+ event->data.alias.anchor = token->data.alias.value;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ __retres = 1;
+ goto return_label;
+ }
+ else {
+ int tmp_8;
+ end_mark = token->start_mark;
+ start_mark = end_mark;
+ if (token->type == (unsigned int)YAML_ANCHOR_TOKEN) {
+ anchor = token->data.anchor.value;
+ start_mark = token->start_mark;
+ end_mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_0;
+ tmp_0 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_0) token = parser->tokens.head;
+ else token = (yaml_token_t *)0;
+ }
+ if (! token) goto error;
+ if (token->type == (unsigned int)YAML_TAG_TOKEN) {
+ tag_handle = token->data.tag.handle;
+ tag_suffix = token->data.tag.suffix;
+ tag_mark = token->start_mark;
+ end_mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_1) token = parser->tokens.head;
+ else token = (yaml_token_t *)0;
+ }
+ if (! token) goto error;
+ }
+ }
+ else
+ if (token->type == (unsigned int)YAML_TAG_TOKEN) {
+ tag_handle = token->data.tag.handle;
+ tag_suffix = token->data.tag.suffix;
+ tag_mark = token->start_mark;
+ start_mark = tag_mark;
+ end_mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_2;
+ tmp_2 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_2) token = parser->tokens.head;
+ else token = (yaml_token_t *)0;
+ }
+ if (! token) goto error;
+ if (token->type == (unsigned int)YAML_ANCHOR_TOKEN) {
+ anchor = token->data.anchor.value;
+ end_mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_3;
+ tmp_3 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_3) token = parser->tokens.head;
+ else token = (yaml_token_t *)0;
+ }
+ if (! token) goto error;
+ }
+ }
+ if (tag_handle)
+ if (! *tag_handle) {
+ tag = tag_suffix;
+ yaml_free((void *)tag_handle);
+ tag_suffix = (yaml_char_t *)0;
+ tag_handle = tag_suffix;
+ }
+ else {
+ yaml_tag_directive_t *tag_directive;
+ tag_directive = parser->tag_directives.start;
+ while (tag_directive != parser->tag_directives.top) {
+ {
+ int tmp_7;
+ tmp_7 = strcmp((char const *)tag_directive->handle,
+ (char const *)tag_handle);
+ if (tmp_7 == 0) {
+ size_t prefix_len =
+ strlen((char const *)tag_directive->prefix);
+ size_t suffix_len = strlen((char const *)tag_suffix);
+ tag = (yaml_char_t *)yaml_malloc((prefix_len + suffix_len) + (size_t)1);
+ if (! tag) {
+ parser->error = YAML_MEMORY_ERROR;
+ goto error;
+ }
+ memcpy((void *)tag,(void const *)tag_directive->prefix,
+ prefix_len);
+ memcpy((void *)(tag + prefix_len),(void const *)tag_suffix,
+ suffix_len);
+ *(tag + (prefix_len + suffix_len)) = (unsigned char)'\000';
+ yaml_free((void *)tag_handle);
+ yaml_free((void *)tag_suffix);
+ tag_suffix = (yaml_char_t *)0;
+ tag_handle = tag_suffix;
+ break;
+ }
+ }
+ tag_directive ++;
+ }
+ if (! tag) {
+ yaml_parser_set_parser_error_context(parser,"while parsing a node",
+ start_mark,
+ "found undefined tag handle",
+ tag_mark);
+ goto error;
+ }
+ }
+ if (! tag) tmp_8 = 1;
+ else
+ if (! *tag) tmp_8 = 1; else tmp_8 = 0;
+ implicit = tmp_8;
+ if (indentless_sequence) {
+ if (token->type == (unsigned int)YAML_BLOCK_ENTRY_TOKEN) {
+ end_mark = token->end_mark;
+ parser->state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_SEQUENCE_START_EVENT;
+ event->start_mark = start_mark;
+ event->end_mark = end_mark;
+ event->data.sequence_start.anchor = anchor;
+ event->data.sequence_start.tag = tag;
+ event->data.sequence_start.implicit = implicit;
+ event->data.sequence_start.style = YAML_BLOCK_SEQUENCE_STYLE;
+ __retres = 1;
+ goto return_label;
+ }
+ else goto _LAND_3;
+ }
+ else
+ _LAND_3:
+ if (token->type == (unsigned int)YAML_SCALAR_TOKEN) {
+ int plain_implicit = 0;
+ int quoted_implicit = 0;
+ end_mark = token->end_mark;
+ if (token->data.scalar.style == (unsigned int)YAML_PLAIN_SCALAR_STYLE) {
+ if (! tag) goto _LOR; else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if (tag) {
+ int tmp_9;
+ tmp_9 = strcmp((char const *)tag,"!");
+ if (tmp_9 == 0) _LOR: plain_implicit = 1; else goto _LAND;
+ }
+ else
+ _LAND: if (! tag) quoted_implicit = 1;
+ }
+ (parser->states.top) --;
+ parser->state = *(parser->states.top);
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_SCALAR_EVENT;
+ event->start_mark = start_mark;
+ event->end_mark = end_mark;
+ event->data.scalar.anchor = anchor;
+ event->data.scalar.tag = tag;
+ event->data.scalar.value = token->data.scalar.value;
+ event->data.scalar.length = token->data.scalar.length;
+ event->data.scalar.plain_implicit = plain_implicit;
+ event->data.scalar.quoted_implicit = quoted_implicit;
+ event->data.scalar.style = token->data.scalar.style;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ __retres = 1;
+ goto return_label;
+ }
+ else
+ if (token->type == (unsigned int)YAML_FLOW_SEQUENCE_START_TOKEN) {
+ end_mark = token->end_mark;
+ parser->state = YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_SEQUENCE_START_EVENT;
+ event->start_mark = start_mark;
+ event->end_mark = end_mark;
+ event->data.sequence_start.anchor = anchor;
+ event->data.sequence_start.tag = tag;
+ event->data.sequence_start.implicit = implicit;
+ event->data.sequence_start.style = YAML_FLOW_SEQUENCE_STYLE;
+ __retres = 1;
+ goto return_label;
+ }
+ else
+ if (token->type == (unsigned int)YAML_FLOW_MAPPING_START_TOKEN) {
+ end_mark = token->end_mark;
+ parser->state = YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_MAPPING_START_EVENT;
+ event->start_mark = start_mark;
+ event->end_mark = end_mark;
+ event->data.mapping_start.anchor = anchor;
+ event->data.mapping_start.tag = tag;
+ event->data.mapping_start.implicit = implicit;
+ event->data.mapping_start.style = YAML_FLOW_MAPPING_STYLE;
+ __retres = 1;
+ goto return_label;
+ }
+ else
+ if (block) {
+ if (token->type == (unsigned int)YAML_BLOCK_SEQUENCE_START_TOKEN) {
+ end_mark = token->end_mark;
+ parser->state = YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_SEQUENCE_START_EVENT;
+ event->start_mark = start_mark;
+ event->end_mark = end_mark;
+ event->data.sequence_start.anchor = anchor;
+ event->data.sequence_start.tag = tag;
+ event->data.sequence_start.implicit = implicit;
+ event->data.sequence_start.style = YAML_BLOCK_SEQUENCE_STYLE;
+ __retres = 1;
+ goto return_label;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ _LAND_2: ;
+ if (block) {
+ if (token->type == (unsigned int)YAML_BLOCK_MAPPING_START_TOKEN) {
+ end_mark = token->end_mark;
+ parser->state = YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_MAPPING_START_EVENT;
+ event->start_mark = start_mark;
+ event->end_mark = end_mark;
+ event->data.mapping_start.anchor = anchor;
+ event->data.mapping_start.tag = tag;
+ event->data.mapping_start.implicit = implicit;
+ event->data.mapping_start.style = YAML_BLOCK_MAPPING_STYLE;
+ __retres = 1;
+ goto return_label;
+ }
+ else goto _LAND_1;
+ }
+ else {
+ _LAND_1: ;
+ if (anchor) goto _LOR_0;
+ else
+ if (tag) {
+ _LOR_0:
+ {
+ yaml_char_t *value = yaml_malloc((unsigned long)1);
+ if (! value) {
+ parser->error = YAML_MEMORY_ERROR;
+ goto error;
+ }
+ *(value + 0) = (unsigned char)'\000';
+ (parser->states.top) --;
+ parser->state = *(parser->states.top);
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_SCALAR_EVENT;
+ event->start_mark = start_mark;
+ event->end_mark = end_mark;
+ event->data.scalar.anchor = anchor;
+ event->data.scalar.tag = tag;
+ event->data.scalar.value = value;
+ event->data.scalar.length = (unsigned long)0;
+ event->data.scalar.plain_implicit = implicit;
+ event->data.scalar.quoted_implicit = 0;
+ event->data.scalar.style = YAML_PLAIN_SCALAR_STYLE;
+ __retres = 1;
+ goto return_label;
+ }
+ }
+ else {
+ char const *tmp_11;
+ ;
+ ;
+ if (block) tmp_11 = "while parsing a block node";
+ else tmp_11 = "while parsing a flow node";
+ ;
+ yaml_parser_set_parser_error_context(parser,tmp_11,
+ start_mark,
+ "did not find expected node content",
+ token->start_mark);
+ goto error;
+ }
+ }
+ }
+ }
+ error: yaml_free((void *)anchor);
+ yaml_free((void *)tag_handle);
+ yaml_free((void *)tag_suffix);
+ yaml_free((void *)tag);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_block_sequence_entry(yaml_parser_t *parser,
+ yaml_event_t *event,
+ int first)
+{
+ int __retres;
+ yaml_token_t *token;
+ if (first) {
+ int tmp_2;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (parser->marks.top != parser->marks.end) goto _LOR;
+ else {
+ int tmp_0;
+ tmp_0 = yaml_stack_extend((void **)(& parser->marks.start),
+ (void **)(& parser->marks.top),
+ (void **)(& parser->marks.end));
+ if (tmp_0) {
+ yaml_mark_t *tmp_1;
+ _LOR: tmp_1 = parser->marks.top;
+ (parser->marks.top) ++;
+ *tmp_1 = token->start_mark;
+ tmp_2 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ }
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ }
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_3;
+ tmp_3 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_3) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type == (unsigned int)YAML_BLOCK_ENTRY_TOKEN) {
+ yaml_mark_t mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_4;
+ tmp_4 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_4) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type != (unsigned int)YAML_BLOCK_ENTRY_TOKEN) {
+ if (token->type != (unsigned int)YAML_BLOCK_END_TOKEN) {
+ int tmp_7;
+ int tmp_8;
+ if (parser->states.top != parser->states.end) goto _LOR_0;
+ else {
+ int tmp_5;
+ tmp_5 = yaml_stack_extend((void **)(& parser->states.start),
+ (void **)(& parser->states.top),
+ (void **)(& parser->states.end));
+ if (tmp_5) {
+ yaml_parser_state_t *tmp_6;
+ _LOR_0: tmp_6 = parser->states.top;
+ (parser->states.top) ++;
+ *tmp_6 = YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE;
+ tmp_7 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_7 = 0;
+ }
+ }
+ if (! tmp_7) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_8 = yaml_parser_parse_node(parser,event,1,0);
+ __retres = tmp_8;
+ goto return_label;
+ }
+ else goto _LAND;
+ }
+ else {
+ _LAND:
+ {
+ int tmp_9;
+ parser->state = YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE;
+ tmp_9 = yaml_parser_process_empty_scalar(parser,event,mark);
+ __retres = tmp_9;
+ goto return_label;
+ }
+ }
+ }
+ else
+ if (token->type == (unsigned int)YAML_BLOCK_END_TOKEN) {
+ (parser->states.top) --;
+ parser->state = *(parser->states.top);
+ (parser->marks.top) --;
+ ;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_SEQUENCE_END_EVENT;
+ event->start_mark = token->start_mark;
+ event->end_mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ __retres = 1;
+ goto return_label;
+ }
+ else {
+ int tmp_10;
+ ;
+ (parser->marks.top) --;
+ ;
+ ;
+ tmp_10 = yaml_parser_set_parser_error_context(parser,
+ "while parsing a block collection",
+ *(parser->marks.top),
+ "did not find expected \'-\' indicator",
+ token->start_mark);
+ __retres = tmp_10;
+ goto return_label;
+ }
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_indentless_sequence_entry(yaml_parser_t *parser,
+ yaml_event_t *event)
+{
+ int __retres;
+ yaml_token_t *token;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type == (unsigned int)YAML_BLOCK_ENTRY_TOKEN) {
+ yaml_mark_t mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_0;
+ tmp_0 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_0) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type != (unsigned int)YAML_BLOCK_ENTRY_TOKEN) {
+ if (token->type != (unsigned int)YAML_KEY_TOKEN) {
+ if (token->type != (unsigned int)YAML_VALUE_TOKEN) {
+ if (token->type != (unsigned int)YAML_BLOCK_END_TOKEN) {
+ int tmp_3;
+ int tmp_4;
+ if (parser->states.top != parser->states.end) goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_stack_extend((void **)(& parser->states.start),
+ (void **)(& parser->states.top),
+ (void **)(& parser->states.end));
+ if (tmp_1) {
+ yaml_parser_state_t *tmp_2;
+ _LOR: tmp_2 = parser->states.top;
+ (parser->states.top) ++;
+ *tmp_2 = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE;
+ tmp_3 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_4 = yaml_parser_parse_node(parser,event,1,0);
+ __retres = tmp_4;
+ goto return_label;
+ }
+ else goto _LAND_1;
+ }
+ else goto _LAND_1;
+ }
+ else goto _LAND_1;
+ }
+ else {
+ _LAND_1:
+ {
+ int tmp_5;
+ parser->state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE;
+ tmp_5 = yaml_parser_process_empty_scalar(parser,event,mark);
+ __retres = tmp_5;
+ goto return_label;
+ }
+ }
+ }
+ else {
+ (parser->states.top) --;
+ parser->state = *(parser->states.top);
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_SEQUENCE_END_EVENT;
+ event->start_mark = token->start_mark;
+ event->end_mark = token->start_mark;
+ __retres = 1;
+ goto return_label;
+ }
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_block_mapping_key(yaml_parser_t *parser,
+ yaml_event_t *event, int first)
+{
+ int __retres;
+ yaml_token_t *token;
+ if (first) {
+ int tmp_2;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (parser->marks.top != parser->marks.end) goto _LOR;
+ else {
+ int tmp_0;
+ tmp_0 = yaml_stack_extend((void **)(& parser->marks.start),
+ (void **)(& parser->marks.top),
+ (void **)(& parser->marks.end));
+ if (tmp_0) {
+ yaml_mark_t *tmp_1;
+ _LOR: tmp_1 = parser->marks.top;
+ (parser->marks.top) ++;
+ *tmp_1 = token->start_mark;
+ tmp_2 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ }
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ }
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_3;
+ tmp_3 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_3) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type == (unsigned int)YAML_KEY_TOKEN) {
+ yaml_mark_t mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_4;
+ tmp_4 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_4) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type != (unsigned int)YAML_KEY_TOKEN) {
+ if (token->type != (unsigned int)YAML_VALUE_TOKEN) {
+ if (token->type != (unsigned int)YAML_BLOCK_END_TOKEN) {
+ int tmp_7;
+ int tmp_8;
+ if (parser->states.top != parser->states.end) goto _LOR_0;
+ else {
+ int tmp_5;
+ tmp_5 = yaml_stack_extend((void **)(& parser->states.start),
+ (void **)(& parser->states.top),
+ (void **)(& parser->states.end));
+ if (tmp_5) {
+ yaml_parser_state_t *tmp_6;
+ _LOR_0: tmp_6 = parser->states.top;
+ (parser->states.top) ++;
+ *tmp_6 = YAML_PARSE_BLOCK_MAPPING_VALUE_STATE;
+ tmp_7 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_7 = 0;
+ }
+ }
+ if (! tmp_7) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_8 = yaml_parser_parse_node(parser,event,1,1);
+ __retres = tmp_8;
+ goto return_label;
+ }
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0:
+ {
+ int tmp_9;
+ parser->state = YAML_PARSE_BLOCK_MAPPING_VALUE_STATE;
+ tmp_9 = yaml_parser_process_empty_scalar(parser,event,mark);
+ __retres = tmp_9;
+ goto return_label;
+ }
+ }
+ }
+ else
+ if (token->type == (unsigned int)YAML_BLOCK_END_TOKEN) {
+ (parser->states.top) --;
+ parser->state = *(parser->states.top);
+ (parser->marks.top) --;
+ ;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_MAPPING_END_EVENT;
+ event->start_mark = token->start_mark;
+ event->end_mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ __retres = 1;
+ goto return_label;
+ }
+ else {
+ int tmp_10;
+ ;
+ (parser->marks.top) --;
+ ;
+ ;
+ tmp_10 = yaml_parser_set_parser_error_context(parser,
+ "while parsing a block mapping",
+ *(parser->marks.top),
+ "did not find expected key",
+ token->start_mark);
+ __retres = tmp_10;
+ goto return_label;
+ }
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_block_mapping_value(yaml_parser_t *parser,
+ yaml_event_t *event)
+{
+ int __retres;
+ yaml_token_t *token;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type == (unsigned int)YAML_VALUE_TOKEN) {
+ yaml_mark_t mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_0;
+ tmp_0 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_0) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type != (unsigned int)YAML_KEY_TOKEN) {
+ if (token->type != (unsigned int)YAML_VALUE_TOKEN) {
+ if (token->type != (unsigned int)YAML_BLOCK_END_TOKEN) {
+ int tmp_3;
+ int tmp_4;
+ if (parser->states.top != parser->states.end) goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_stack_extend((void **)(& parser->states.start),
+ (void **)(& parser->states.top),
+ (void **)(& parser->states.end));
+ if (tmp_1) {
+ yaml_parser_state_t *tmp_2;
+ _LOR: tmp_2 = parser->states.top;
+ (parser->states.top) ++;
+ *tmp_2 = YAML_PARSE_BLOCK_MAPPING_KEY_STATE;
+ tmp_3 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_4 = yaml_parser_parse_node(parser,event,1,1);
+ __retres = tmp_4;
+ goto return_label;
+ }
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0:
+ {
+ int tmp_5;
+ parser->state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE;
+ tmp_5 = yaml_parser_process_empty_scalar(parser,event,mark);
+ __retres = tmp_5;
+ goto return_label;
+ }
+ }
+ }
+ else {
+ int tmp_6;
+ parser->state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE;
+ tmp_6 = yaml_parser_process_empty_scalar(parser,event,token->start_mark);
+ __retres = tmp_6;
+ goto return_label;
+ }
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_flow_sequence_entry(yaml_parser_t *parser,
+ yaml_event_t *event,
+ int first)
+{
+ int __retres;
+ yaml_token_t *token;
+ if (first) {
+ int tmp_2;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (parser->marks.top != parser->marks.end) goto _LOR;
+ else {
+ int tmp_0;
+ tmp_0 = yaml_stack_extend((void **)(& parser->marks.start),
+ (void **)(& parser->marks.top),
+ (void **)(& parser->marks.end));
+ if (tmp_0) {
+ yaml_mark_t *tmp_1;
+ _LOR: tmp_1 = parser->marks.top;
+ (parser->marks.top) ++;
+ *tmp_1 = token->start_mark;
+ tmp_2 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ }
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ }
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_3;
+ tmp_3 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_3) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type != (unsigned int)YAML_FLOW_SEQUENCE_END_TOKEN) {
+ if (! first)
+ if (token->type == (unsigned int)YAML_FLOW_ENTRY_TOKEN) {
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_4;
+ tmp_4 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_4) token = parser->tokens.head;
+ else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ else {
+ int tmp_5;
+ ;
+ (parser->marks.top) --;
+ ;
+ ;
+ tmp_5 = yaml_parser_set_parser_error_context(parser,
+ "while parsing a flow sequence",
+ *(parser->marks.top),
+ "did not find expected \',\' or \']\'",
+ token->start_mark);
+ __retres = tmp_5;
+ goto return_label;
+ }
+ if (token->type == (unsigned int)YAML_KEY_TOKEN) {
+ parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_MAPPING_START_EVENT;
+ event->start_mark = token->start_mark;
+ event->end_mark = token->end_mark;
+ event->data.mapping_start.anchor = (yaml_char_t *)0;
+ event->data.mapping_start.tag = (yaml_char_t *)0;
+ event->data.mapping_start.implicit = 1;
+ event->data.mapping_start.style = YAML_FLOW_MAPPING_STYLE;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ __retres = 1;
+ goto return_label;
+ }
+ else
+ if (token->type != (unsigned int)YAML_FLOW_SEQUENCE_END_TOKEN) {
+ int tmp_8;
+ int tmp_9;
+ if (parser->states.top != parser->states.end) goto _LOR_0;
+ else {
+ int tmp_6;
+ tmp_6 = yaml_stack_extend((void **)(& parser->states.start),
+ (void **)(& parser->states.top),
+ (void **)(& parser->states.end));
+ if (tmp_6) {
+ yaml_parser_state_t *tmp_7;
+ _LOR_0: tmp_7 = parser->states.top;
+ (parser->states.top) ++;
+ *tmp_7 = YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE;
+ tmp_8 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_8 = 0;
+ }
+ }
+ if (! tmp_8) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_9 = yaml_parser_parse_node(parser,event,0,0);
+ __retres = tmp_9;
+ goto return_label;
+ }
+ }
+ (parser->states.top) --;
+ parser->state = *(parser->states.top);
+ (parser->marks.top) --;
+ ;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_SEQUENCE_END_EVENT;
+ event->start_mark = token->start_mark;
+ event->end_mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_flow_sequence_entry_mapping_key(yaml_parser_t *parser,
+ yaml_event_t *event)
+{
+ int __retres;
+ yaml_token_t *token;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type != (unsigned int)YAML_VALUE_TOKEN) {
+ if (token->type != (unsigned int)YAML_FLOW_ENTRY_TOKEN) {
+ if (token->type != (unsigned int)YAML_FLOW_SEQUENCE_END_TOKEN) {
+ int tmp_2;
+ int tmp_3;
+ if (parser->states.top != parser->states.end) goto _LOR;
+ else {
+ int tmp_0;
+ tmp_0 = yaml_stack_extend((void **)(& parser->states.start),
+ (void **)(& parser->states.top),
+ (void **)(& parser->states.end));
+ if (tmp_0) {
+ yaml_parser_state_t *tmp_1;
+ _LOR: tmp_1 = parser->states.top;
+ (parser->states.top) ++;
+ *tmp_1 = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE;
+ tmp_2 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ }
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_3 = yaml_parser_parse_node(parser,event,0,0);
+ __retres = tmp_3;
+ goto return_label;
+ }
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0:
+ {
+ int tmp_4;
+ yaml_mark_t mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE;
+ tmp_4 = yaml_parser_process_empty_scalar(parser,event,mark);
+ __retres = tmp_4;
+ goto return_label;
+ }
+ }
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_flow_sequence_entry_mapping_value(yaml_parser_t *parser,
+ yaml_event_t *event)
+{
+ int __retres;
+ yaml_token_t *token;
+ int tmp_5;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type == (unsigned int)YAML_VALUE_TOKEN) {
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_0;
+ tmp_0 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_0) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type != (unsigned int)YAML_FLOW_ENTRY_TOKEN)
+ if (token->type != (unsigned int)YAML_FLOW_SEQUENCE_END_TOKEN) {
+ int tmp_3;
+ int tmp_4;
+ if (parser->states.top != parser->states.end) goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_stack_extend((void **)(& parser->states.start),
+ (void **)(& parser->states.top),
+ (void **)(& parser->states.end));
+ if (tmp_1) {
+ yaml_parser_state_t *tmp_2;
+ _LOR: tmp_2 = parser->states.top;
+ (parser->states.top) ++;
+ *tmp_2 = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE;
+ tmp_3 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_4 = yaml_parser_parse_node(parser,event,0,0);
+ __retres = tmp_4;
+ goto return_label;
+ }
+ }
+ parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE;
+ tmp_5 = yaml_parser_process_empty_scalar(parser,event,token->start_mark);
+ __retres = tmp_5;
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_flow_sequence_entry_mapping_end(yaml_parser_t *parser,
+ yaml_event_t *event)
+{
+ int __retres;
+ yaml_token_t *token;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_MAPPING_END_EVENT;
+ event->start_mark = token->start_mark;
+ event->end_mark = token->start_mark;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_flow_mapping_key(yaml_parser_t *parser,
+ yaml_event_t *event, int first)
+{
+ int __retres;
+ yaml_token_t *token;
+ if (first) {
+ int tmp_2;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (parser->marks.top != parser->marks.end) goto _LOR;
+ else {
+ int tmp_0;
+ tmp_0 = yaml_stack_extend((void **)(& parser->marks.start),
+ (void **)(& parser->marks.top),
+ (void **)(& parser->marks.end));
+ if (tmp_0) {
+ yaml_mark_t *tmp_1;
+ _LOR: tmp_1 = parser->marks.top;
+ (parser->marks.top) ++;
+ *tmp_1 = token->start_mark;
+ tmp_2 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ }
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ }
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_3;
+ tmp_3 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_3) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type != (unsigned int)YAML_FLOW_MAPPING_END_TOKEN) {
+ if (! first)
+ if (token->type == (unsigned int)YAML_FLOW_ENTRY_TOKEN) {
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_4;
+ tmp_4 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_4) token = parser->tokens.head;
+ else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ else {
+ int tmp_5;
+ ;
+ (parser->marks.top) --;
+ ;
+ ;
+ tmp_5 = yaml_parser_set_parser_error_context(parser,
+ "while parsing a flow mapping",
+ *(parser->marks.top),
+ "did not find expected \',\' or \'}\'",
+ token->start_mark);
+ __retres = tmp_5;
+ goto return_label;
+ }
+ if (token->type == (unsigned int)YAML_KEY_TOKEN) {
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_6;
+ tmp_6 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_6) token = parser->tokens.head;
+ else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type != (unsigned int)YAML_VALUE_TOKEN) {
+ if (token->type != (unsigned int)YAML_FLOW_ENTRY_TOKEN) {
+ if (token->type != (unsigned int)YAML_FLOW_MAPPING_END_TOKEN) {
+ int tmp_9;
+ int tmp_10;
+ if (parser->states.top != parser->states.end) goto _LOR_0;
+ else {
+ int tmp_7;
+ tmp_7 = yaml_stack_extend((void **)(& parser->states.start),
+ (void **)(& parser->states.top),
+ (void **)(& parser->states.end));
+ if (tmp_7) {
+ yaml_parser_state_t *tmp_8;
+ _LOR_0: tmp_8 = parser->states.top;
+ (parser->states.top) ++;
+ *tmp_8 = YAML_PARSE_FLOW_MAPPING_VALUE_STATE;
+ tmp_9 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_9 = 0;
+ }
+ }
+ if (! tmp_9) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_10 = yaml_parser_parse_node(parser,event,0,0);
+ __retres = tmp_10;
+ goto return_label;
+ }
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0:
+ {
+ int tmp_11;
+ parser->state = YAML_PARSE_FLOW_MAPPING_VALUE_STATE;
+ tmp_11 = yaml_parser_process_empty_scalar(parser,event,
+ token->start_mark);
+ __retres = tmp_11;
+ goto return_label;
+ }
+ }
+ }
+ else
+ if (token->type != (unsigned int)YAML_FLOW_MAPPING_END_TOKEN) {
+ int tmp_14;
+ int tmp_15;
+ if (parser->states.top != parser->states.end) goto _LOR_1;
+ else {
+ int tmp_12;
+ tmp_12 = yaml_stack_extend((void **)(& parser->states.start),
+ (void **)(& parser->states.top),
+ (void **)(& parser->states.end));
+ if (tmp_12) {
+ yaml_parser_state_t *tmp_13;
+ _LOR_1: tmp_13 = parser->states.top;
+ (parser->states.top) ++;
+ *tmp_13 = YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE;
+ tmp_14 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_14 = 0;
+ }
+ }
+ if (! tmp_14) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_15 = yaml_parser_parse_node(parser,event,0,0);
+ __retres = tmp_15;
+ goto return_label;
+ }
+ }
+ (parser->states.top) --;
+ parser->state = *(parser->states.top);
+ (parser->marks.top) --;
+ ;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_MAPPING_END_EVENT;
+ event->start_mark = token->start_mark;
+ event->end_mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_flow_mapping_value(yaml_parser_t *parser,
+ yaml_event_t *event,
+ int empty)
+{
+ int __retres;
+ yaml_token_t *token;
+ int tmp_6;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (empty) {
+ int tmp_0;
+ parser->state = YAML_PARSE_FLOW_MAPPING_KEY_STATE;
+ tmp_0 = yaml_parser_process_empty_scalar(parser,event,token->start_mark);
+ __retres = tmp_0;
+ goto return_label;
+ }
+ if (token->type == (unsigned int)YAML_VALUE_TOKEN) {
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_1) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type != (unsigned int)YAML_FLOW_ENTRY_TOKEN)
+ if (token->type != (unsigned int)YAML_FLOW_MAPPING_END_TOKEN) {
+ int tmp_4;
+ int tmp_5;
+ if (parser->states.top != parser->states.end) goto _LOR;
+ else {
+ int tmp_2;
+ tmp_2 = yaml_stack_extend((void **)(& parser->states.start),
+ (void **)(& parser->states.top),
+ (void **)(& parser->states.end));
+ if (tmp_2) {
+ yaml_parser_state_t *tmp_3;
+ _LOR: tmp_3 = parser->states.top;
+ (parser->states.top) ++;
+ *tmp_3 = YAML_PARSE_FLOW_MAPPING_KEY_STATE;
+ tmp_4 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_4 = 0;
+ }
+ }
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_5 = yaml_parser_parse_node(parser,event,0,0);
+ __retres = tmp_5;
+ goto return_label;
+ }
+ }
+ parser->state = YAML_PARSE_FLOW_MAPPING_KEY_STATE;
+ tmp_6 = yaml_parser_process_empty_scalar(parser,event,token->start_mark);
+ __retres = tmp_6;
+ return_label: return __retres;
+}
+
+static int yaml_parser_process_empty_scalar(yaml_parser_t *parser,
+ yaml_event_t *event,
+ yaml_mark_t mark)
+{
+ int __retres;
+ yaml_char_t *value;
+ value = (yaml_char_t *)yaml_malloc((unsigned long)1);
+ if (! value) {
+ parser->error = YAML_MEMORY_ERROR;
+ __retres = 0;
+ goto return_label;
+ }
+ *(value + 0) = (unsigned char)'\000';
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_SCALAR_EVENT;
+ event->start_mark = mark;
+ event->end_mark = mark;
+ event->data.scalar.anchor = (yaml_char_t *)0;
+ event->data.scalar.tag = (yaml_char_t *)0;
+ event->data.scalar.value = value;
+ event->data.scalar.length = (unsigned long)0;
+ event->data.scalar.plain_implicit = 1;
+ event->data.scalar.quoted_implicit = 0;
+ event->data.scalar.style = YAML_PLAIN_SCALAR_STYLE;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_process_directives(yaml_parser_t *parser,
+ yaml_version_directive_t **version_directive_ref,
+ yaml_tag_directive_t **tag_directives_start_ref,
+ yaml_tag_directive_t **tag_directives_end_ref)
+{
+ int __retres;
+ yaml_tag_directive_t *default_tag_directive;
+ yaml_token_t *token;
+ int tmp_0;
+ yaml_tag_directive_t default_tag_directives[3] =
+ {{.handle = (yaml_char_t *)"!", .prefix = (yaml_char_t *)"!"},
+ {.handle = (yaml_char_t *)"!!",
+ .prefix = (yaml_char_t *)"tag:yaml.org,2002:"},
+ {.handle = (yaml_char_t *)0, .prefix = (yaml_char_t *)0}};
+ yaml_version_directive_t *version_directive =
+ (yaml_version_directive_t *)0;
+ struct __anonstruct_tag_directives_50 tag_directives =
+ {.start = (yaml_tag_directive_t *)0,
+ .end = (yaml_tag_directive_t *)0,
+ .top = (yaml_tag_directive_t *)0};
+ tag_directives.start = (yaml_tag_directive_t *)yaml_malloc((unsigned long)16 * sizeof(*(tag_directives.start)));
+ if (tag_directives.start) {
+ tag_directives.top = tag_directives.start;
+ tag_directives.end = tag_directives.start + 16;
+ tmp_0 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_0 = 0;
+ }
+ if (! tmp_0) goto error;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_1) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) goto error;
+ while (1) {
+ if (! (token->type == (unsigned int)YAML_VERSION_DIRECTIVE_TOKEN))
+ if (! (token->type == (unsigned int)YAML_TAG_DIRECTIVE_TOKEN))
+ break;
+ if (token->type == (unsigned int)YAML_VERSION_DIRECTIVE_TOKEN) {
+ if (version_directive) {
+ yaml_parser_set_parser_error(parser,
+ "found duplicate %YAML directive",
+ token->start_mark);
+ goto error;
+ }
+ if (token->data.version_directive.major != 1) goto _LOR;
+ else
+ if (token->data.version_directive.minor != 1)
+ if (token->data.version_directive.minor != 2) {
+ _LOR:
+ {
+ yaml_parser_set_parser_error(parser,
+ "found incompatible YAML document",
+ token->start_mark);
+ goto error;
+ }
+ }
+ version_directive = (yaml_version_directive_t *)yaml_malloc(sizeof(yaml_version_directive_t));
+ if (! version_directive) {
+ parser->error = YAML_MEMORY_ERROR;
+ goto error;
+ }
+ version_directive->major = token->data.version_directive.major;
+ version_directive->minor = token->data.version_directive.minor;
+ }
+ else
+ if (token->type == (unsigned int)YAML_TAG_DIRECTIVE_TOKEN) {
+ yaml_tag_directive_t value;
+ int tmp_3;
+ int tmp_6;
+ value.handle = token->data.tag_directive.handle;
+ value.prefix = token->data.tag_directive.prefix;
+ tmp_3 = yaml_parser_append_tag_directive(parser,value,0,
+ token->start_mark);
+ if (! tmp_3) goto error;
+ if (tag_directives.top != tag_directives.end) goto _LOR_0;
+ else {
+ int tmp_4;
+ tmp_4 = yaml_stack_extend((void **)(& tag_directives.start),
+ (void **)(& tag_directives.top),
+ (void **)(& tag_directives.end));
+ if (tmp_4) {
+ yaml_tag_directive_t *tmp_5;
+ _LOR_0: tmp_5 = tag_directives.top;
+ (tag_directives.top) ++;
+ *tmp_5 = value;
+ tmp_6 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_6 = 0;
+ }
+ }
+ if (! tmp_6) goto error;
+ }
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_7;
+ tmp_7 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_7) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) goto error;
+ }
+ default_tag_directive = default_tag_directives;
+ while (default_tag_directive->handle) {
+ {
+ int tmp_8;
+ tmp_8 = yaml_parser_append_tag_directive(parser,*default_tag_directive,
+ 1,token->start_mark);
+ if (! tmp_8) goto error;
+ }
+ default_tag_directive ++;
+ }
+ if (version_directive_ref) *version_directive_ref = version_directive;
+ if (tag_directives_start_ref)
+ if (tag_directives.start == tag_directives.top) {
+ yaml_tag_directive_t *tmp_9;
+ tmp_9 = (yaml_tag_directive_t *)0;
+ *tag_directives_end_ref = tmp_9;
+ *tag_directives_start_ref = tmp_9;
+ yaml_free((void *)tag_directives.start);
+ tag_directives.end = (yaml_tag_directive_t *)0;
+ tag_directives.top = tag_directives.end;
+ tag_directives.start = tag_directives.top;
+ }
+ else {
+ *tag_directives_start_ref = tag_directives.start;
+ *tag_directives_end_ref = tag_directives.top;
+ }
+ else {
+ yaml_free((void *)tag_directives.start);
+ tag_directives.end = (yaml_tag_directive_t *)0;
+ tag_directives.top = tag_directives.end;
+ tag_directives.start = tag_directives.top;
+ }
+ if (! version_directive_ref) yaml_free((void *)version_directive);
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)version_directive);
+ while (! (tag_directives.start == tag_directives.top)) {
+ (tag_directives.top) --;
+ yaml_tag_directive_t tag_directive = *(tag_directives.top);
+ yaml_free((void *)tag_directive.handle);
+ yaml_free((void *)tag_directive.prefix);
+ }
+ yaml_free((void *)tag_directives.start);
+ tag_directives.end = (yaml_tag_directive_t *)0;
+ tag_directives.top = tag_directives.end;
+ tag_directives.start = tag_directives.top;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_append_tag_directive(yaml_parser_t *parser,
+ yaml_tag_directive_t value,
+ int allow_duplicates,
+ yaml_mark_t mark)
+{
+ int __retres;
+ yaml_tag_directive_t *tag_directive;
+ int tmp_3;
+ yaml_tag_directive_t copy =
+ {.handle = (yaml_char_t *)0, .prefix = (yaml_char_t *)0};
+ tag_directive = parser->tag_directives.start;
+ while (tag_directive != parser->tag_directives.top) {
+ {
+ int tmp_0;
+ tmp_0 = strcmp((char const *)value.handle,
+ (char const *)tag_directive->handle);
+ if (tmp_0 == 0) {
+ int tmp;
+ if (allow_duplicates) {
+ __retres = 1;
+ goto return_label;
+ }
+ tmp = yaml_parser_set_parser_error(parser,
+ "found duplicate %TAG directive",
+ mark);
+ __retres = tmp;
+ goto return_label;
+ }
+ }
+ tag_directive ++;
+ }
+ copy.handle = yaml_strdup((yaml_char_t const *)value.handle);
+ copy.prefix = yaml_strdup((yaml_char_t const *)value.prefix);
+ if (! copy.handle) goto _LOR;
+ else
+ if (! copy.prefix) {
+ _LOR: {
+ parser->error = YAML_MEMORY_ERROR;
+ goto error;
+ }
+ }
+ if (parser->tag_directives.top != parser->tag_directives.end) goto _LOR_0;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_stack_extend((void **)(& parser->tag_directives.start),
+ (void **)(& parser->tag_directives.top),
+ (void **)(& parser->tag_directives.end));
+ if (tmp_1) {
+ yaml_tag_directive_t *tmp_2;
+ _LOR_0: tmp_2 = parser->tag_directives.top;
+ (parser->tag_directives.top) ++;
+ *tmp_2 = copy;
+ tmp_3 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) goto error;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)copy.handle);
+ yaml_free((void *)copy.prefix);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_set_reader_error(yaml_parser_t *parser,
+ char const *problem, size_t offset,
+ int value);
+
+static int yaml_parser_update_raw_buffer(yaml_parser_t *parser);
+
+static int yaml_parser_determine_encoding(yaml_parser_t *parser);
+
+static int yaml_parser_set_reader_error(yaml_parser_t *parser,
+ char const *problem, size_t offset,
+ int value)
+{
+ int __retres;
+ parser->error = YAML_READER_ERROR;
+ parser->problem = problem;
+ parser->problem_offset = offset;
+ parser->problem_value = value;
+ __retres = 0;
+ return __retres;
+}
+
+static int yaml_parser_determine_encoding(yaml_parser_t *parser)
+{
+ int __retres;
+ while (1) {
+ if (! parser->eof) {
+ if (! (parser->raw_buffer.last - parser->raw_buffer.pointer < (long)3))
+ break;
+ }
+ else break;
+ {
+ int tmp;
+ tmp = yaml_parser_update_raw_buffer(parser);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ if (parser->raw_buffer.last - parser->raw_buffer.pointer >= (long)2) {
+ int tmp_2;
+ tmp_2 = memcmp((void const *)parser->raw_buffer.pointer,
+ (void const *)"\377\376",(unsigned long)2);
+ if (tmp_2) goto _LAND_1;
+ else {
+ parser->encoding = YAML_UTF16LE_ENCODING;
+ parser->raw_buffer.pointer += 2;
+ parser->offset += (size_t)2;
+ }
+ }
+ else {
+ _LAND_1: ;
+ if (parser->raw_buffer.last - parser->raw_buffer.pointer >= (long)2) {
+ int tmp_1;
+ tmp_1 = memcmp((void const *)parser->raw_buffer.pointer,
+ (void const *)"\376\377",(unsigned long)2);
+ if (tmp_1) goto _LAND_0;
+ else {
+ parser->encoding = YAML_UTF16BE_ENCODING;
+ parser->raw_buffer.pointer += 2;
+ parser->offset += (size_t)2;
+ }
+ }
+ else {
+ _LAND_0: ;
+ if (parser->raw_buffer.last - parser->raw_buffer.pointer >= (long)3) {
+ int tmp_0;
+ tmp_0 = memcmp((void const *)parser->raw_buffer.pointer,
+ (void const *)"\357\273\277",(unsigned long)3);
+ if (tmp_0) goto _LAND;
+ else {
+ parser->encoding = YAML_UTF8_ENCODING;
+ parser->raw_buffer.pointer += 3;
+ parser->offset += (size_t)3;
+ }
+ }
+ else _LAND: parser->encoding = YAML_UTF8_ENCODING;
+ }
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_update_raw_buffer(yaml_parser_t *parser)
+{
+ int __retres;
+ int tmp_0;
+ size_t size_read = (unsigned long)0;
+ if (parser->raw_buffer.start == parser->raw_buffer.pointer)
+ if (parser->raw_buffer.last == parser->raw_buffer.end) {
+ __retres = 1;
+ goto return_label;
+ }
+ if (parser->eof) {
+ __retres = 1;
+ goto return_label;
+ }
+ if (parser->raw_buffer.start < parser->raw_buffer.pointer)
+ if (parser->raw_buffer.pointer < parser->raw_buffer.last) memmove
+ ((void *)parser->raw_buffer.start,
+ (void const *)parser->raw_buffer.pointer,
+ (unsigned long)(
+ parser->raw_buffer.last - parser->raw_buffer.pointer));
+ parser->raw_buffer.last -= parser->raw_buffer.pointer - parser->raw_buffer.start;
+ parser->raw_buffer.pointer = parser->raw_buffer.start;
+ tmp_0 = (*(parser->read_handler))(parser->read_handler_data,
+ parser->raw_buffer.last,
+ (unsigned long)(parser->raw_buffer.end - parser->raw_buffer.last),
+ & size_read);
+ if (! tmp_0) {
+ int tmp;
+ tmp = yaml_parser_set_reader_error(parser,"input error",parser->offset,
+ -1);
+ __retres = tmp;
+ goto return_label;
+ }
+ parser->raw_buffer.last += size_read;
+ if (! size_read) parser->eof = 1;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+int yaml_parser_update_buffer(yaml_parser_t *parser, size_t length)
+{
+ int __retres;
+ int first = 1;
+ __FC_assert(parser->read_handler != (yaml_read_handler_t *)0,
+ "src/reader.c",146,"parser->read_handler");
+ if (parser->eof)
+ if (parser->raw_buffer.pointer == parser->raw_buffer.last) {
+ __retres = 1;
+ goto return_label;
+ }
+ if (parser->unread >= length) {
+ __retres = 1;
+ goto return_label;
+ }
+ if (! parser->encoding) {
+ int tmp;
+ tmp = yaml_parser_determine_encoding(parser);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (parser->buffer.start < parser->buffer.pointer) {
+ if (parser->buffer.pointer < parser->buffer.last) {
+ size_t size =
+ (unsigned long)(parser->buffer.last - parser->buffer.pointer);
+ memmove((void *)parser->buffer.start,
+ (void const *)parser->buffer.pointer,size);
+ parser->buffer.pointer = parser->buffer.start;
+ parser->buffer.last = parser->buffer.start + size;
+ }
+ else goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (parser->buffer.pointer == parser->buffer.last) {
+ parser->buffer.pointer = parser->buffer.start;
+ parser->buffer.last = parser->buffer.start;
+ }
+ }
+ while (parser->unread < length) {
+ if (! first) goto _LOR;
+ else
+ if (parser->raw_buffer.pointer == parser->raw_buffer.last) {
+ _LOR:
+ {
+ int tmp_0;
+ tmp_0 = yaml_parser_update_raw_buffer(parser);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ first = 0;
+ while (parser->raw_buffer.pointer != parser->raw_buffer.last) {
+ unsigned char octet;
+ int low;
+ int high;
+ size_t k;
+ unsigned int value = (unsigned int)0;
+ unsigned int value2 = (unsigned int)0;
+ int incomplete = 0;
+ unsigned int width = (unsigned int)0;
+ size_t raw_unread =
+ (unsigned long)(parser->raw_buffer.last - parser->raw_buffer.pointer);
+ switch (parser->encoding) {
+ case (yaml_encoding_t)YAML_UTF8_ENCODING:
+ octet = *(parser->raw_buffer.pointer + 0);
+ if (((int)octet & 0x80) == 0x00) width = (unsigned int)1;
+ else {
+ int tmp_3;
+ if (((int)octet & 0xE0) == 0xC0) tmp_3 = 2;
+ else {
+ int tmp_2;
+ if (((int)octet & 0xF0) == 0xE0) tmp_2 = 3;
+ else {
+ int tmp_1;
+ if (((int)octet & 0xF8) == 0xF0) tmp_1 = 4; else tmp_1 = 0;
+ tmp_2 = tmp_1;
+ }
+ tmp_3 = tmp_2;
+ }
+ width = (unsigned int)tmp_3;
+ }
+ if (! width) {
+ int tmp_4;
+ tmp_4 = yaml_parser_set_reader_error(parser,
+ "invalid leading UTF-8 octet",
+ parser->offset,(int)octet);
+ __retres = tmp_4;
+ goto return_label;
+ }
+ if ((size_t)width > raw_unread) {
+ if (parser->eof) {
+ int tmp_5;
+ tmp_5 = yaml_parser_set_reader_error(parser,
+ "incomplete UTF-8 octet sequence",
+ parser->offset,-1);
+ __retres = tmp_5;
+ goto return_label;
+ }
+ incomplete = 1;
+ break;
+ }
+ if (((int)octet & 0x80) == 0x00) value = (unsigned int)((int)octet & 0x7F);
+ else {
+ int tmp_8;
+ if (((int)octet & 0xE0) == 0xC0) tmp_8 = (int)octet & 0x1F;
+ else {
+ int tmp_7;
+ if (((int)octet & 0xF0) == 0xE0) tmp_7 = (int)octet & 0x0F;
+ else {
+ int tmp_6;
+ if (((int)octet & 0xF8) == 0xF0) tmp_6 = (int)octet & 0x07;
+ else tmp_6 = 0;
+ tmp_7 = tmp_6;
+ }
+ tmp_8 = tmp_7;
+ }
+ value = (unsigned int)tmp_8;
+ }
+ k = (unsigned long)1;
+ while (k < (size_t)width) {
+ octet = *(parser->raw_buffer.pointer + k);
+ if (((int)octet & 0xC0) != 0x80) {
+ int tmp_9;
+ tmp_9 = yaml_parser_set_reader_error(parser,
+ "invalid trailing UTF-8 octet",
+ parser->offset + k,
+ (int)octet);
+ __retres = tmp_9;
+ goto return_label;
+ }
+ value = (value << 6) + (unsigned int)((int)octet & 0x3F);
+ k += (size_t)1;
+ }
+ if (! (width == (unsigned int)1))
+ if (width == (unsigned int)2) {
+ if (! (value >= (unsigned int)0x80)) goto _LAND_2;
+ }
+ else {
+ _LAND_2: ;
+ if (width == (unsigned int)3) {
+ if (! (value >= (unsigned int)0x800)) goto _LAND_1;
+ }
+ else {
+ _LAND_1: ;
+ if (width == (unsigned int)4) {
+ if (! (value >= (unsigned int)0x10000)) goto _LAND_0;
+ }
+ else {
+ int tmp_10;
+ _LAND_0:
+ tmp_10 = yaml_parser_set_reader_error(parser,
+ "invalid length of a UTF-8 sequence",
+ parser->offset,-1);
+ __retres = tmp_10;
+ goto return_label;
+ }
+ }
+ }
+ if (value >= (unsigned int)0xD800) {
+ if (value <= (unsigned int)0xDFFF) goto _LOR_0; else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if (value > (unsigned int)0x10FFFF) {
+ int tmp_11;
+ _LOR_0:
+ tmp_11 = yaml_parser_set_reader_error(parser,
+ "invalid Unicode character",
+ parser->offset,(int)value);
+ __retres = tmp_11;
+ goto return_label;
+ }
+ }
+ break;
+ case (yaml_encoding_t)YAML_UTF16LE_ENCODING:
+ case (yaml_encoding_t)YAML_UTF16BE_ENCODING:
+ if (parser->encoding == (unsigned int)YAML_UTF16LE_ENCODING)
+ low = 0;
+ else low = 1;
+ if (parser->encoding == (unsigned int)YAML_UTF16LE_ENCODING)
+ high = 1;
+ else high = 0;
+ if (raw_unread < (size_t)2) {
+ if (parser->eof) {
+ int tmp_12;
+ tmp_12 = yaml_parser_set_reader_error(parser,
+ "incomplete UTF-16 character",
+ parser->offset,-1);
+ __retres = tmp_12;
+ goto return_label;
+ }
+ incomplete = 1;
+ break;
+ }
+ value = (unsigned int)((int)*(parser->raw_buffer.pointer + low) + (
+ (int)*(parser->raw_buffer.pointer + high) << 8));
+ if ((value & (unsigned int)0xFC00) == (unsigned int)0xDC00) {
+ int tmp_13;
+ tmp_13 = yaml_parser_set_reader_error(parser,
+ "unexpected low surrogate area",
+ parser->offset,(int)value);
+ __retres = tmp_13;
+ goto return_label;
+ }
+ if ((value & (unsigned int)0xFC00) == (unsigned int)0xD800) {
+ width = (unsigned int)4;
+ if (raw_unread < (size_t)4) {
+ if (parser->eof) {
+ int tmp_14;
+ tmp_14 = yaml_parser_set_reader_error(parser,
+ "incomplete UTF-16 surrogate pair",
+ parser->offset,-1);
+ __retres = tmp_14;
+ goto return_label;
+ }
+ incomplete = 1;
+ break;
+ }
+ value2 = (unsigned int)((int)*(parser->raw_buffer.pointer + (
+ low + 2)) + ((int)*(parser->raw_buffer.pointer + (
+ high + 2)) << 8));
+ if ((value2 & (unsigned int)0xFC00) != (unsigned int)0xDC00) {
+ int tmp_15;
+ tmp_15 = yaml_parser_set_reader_error(parser,
+ "expected low surrogate area",
+ parser->offset + (size_t)2,
+ (int)value2);
+ __retres = tmp_15;
+ goto return_label;
+ }
+ value = ((unsigned int)0x10000 + ((value & (unsigned int)0x3FF) << 10)) + (
+ value2 & (unsigned int)0x3FF);
+ }
+ else width = (unsigned int)2;
+ break;
+ default: __FC_assert(1 != 0,"src/reader.c",397,"1");
+ }
+ if (incomplete) break;
+ if (! (value == (unsigned int)0x09))
+ if (! (value == (unsigned int)0x0A))
+ if (! (value == (unsigned int)0x0D))
+ if (value >= (unsigned int)0x20) {
+ if (! (value <= (unsigned int)0x7E)) goto _LAND_7;
+ }
+ else {
+ _LAND_7: ;
+ if (! (value == (unsigned int)0x85))
+ if (value >= (unsigned int)0xA0) {
+ if (! (value <= (unsigned int)0xD7FF)) goto _LAND_6;
+ }
+ else {
+ _LAND_6: ;
+ if (value >= (unsigned int)0xE000) {
+ if (! (value <= (unsigned int)0xFFFD)) goto _LAND_5;
+ }
+ else {
+ _LAND_5: ;
+ if (value >= (unsigned int)0x10000) {
+ if (! (value <= (unsigned int)0x10FFFF)) goto _LAND_4;
+ }
+ else {
+ int tmp_16;
+ _LAND_4:
+ tmp_16 = yaml_parser_set_reader_error(parser,
+ "control characters are not allowed",
+ parser->offset,
+ (int)value);
+ __retres = tmp_16;
+ goto return_label;
+ }
+ }
+ }
+ }
+ parser->raw_buffer.pointer += width;
+ parser->offset += (size_t)width;
+ if (value <= (unsigned int)0x7F) {
+ yaml_char_t *tmp_17;
+ tmp_17 = parser->buffer.last;
+ (parser->buffer.last) ++;
+ *tmp_17 = (unsigned char)value;
+ }
+ else
+ if (value <= (unsigned int)0x7FF) {
+ yaml_char_t *tmp_18;
+ yaml_char_t *tmp_19;
+ tmp_18 = parser->buffer.last;
+ (parser->buffer.last) ++;
+ *tmp_18 = (unsigned char)((unsigned int)0xC0 + (value >> 6));
+ tmp_19 = parser->buffer.last;
+ (parser->buffer.last) ++;
+ *tmp_19 = (unsigned char)((unsigned int)0x80 + (value & (unsigned int)0x3F));
+ }
+ else
+ if (value <= (unsigned int)0xFFFF) {
+ yaml_char_t *tmp_20;
+ yaml_char_t *tmp_21;
+ yaml_char_t *tmp_22;
+ tmp_20 = parser->buffer.last;
+ (parser->buffer.last) ++;
+ *tmp_20 = (unsigned char)((unsigned int)0xE0 + (value >> 12));
+ tmp_21 = parser->buffer.last;
+ (parser->buffer.last) ++;
+ *tmp_21 = (unsigned char)((unsigned int)0x80 + ((value >> 6) & (unsigned int)0x3F));
+ tmp_22 = parser->buffer.last;
+ (parser->buffer.last) ++;
+ *tmp_22 = (unsigned char)((unsigned int)0x80 + (value & (unsigned int)0x3F));
+ }
+ else {
+ yaml_char_t *tmp_23;
+ yaml_char_t *tmp_24;
+ yaml_char_t *tmp_25;
+ yaml_char_t *tmp_26;
+ tmp_23 = parser->buffer.last;
+ (parser->buffer.last) ++;
+ *tmp_23 = (unsigned char)((unsigned int)0xF0 + (value >> 18));
+ tmp_24 = parser->buffer.last;
+ (parser->buffer.last) ++;
+ *tmp_24 = (unsigned char)((unsigned int)0x80 + ((value >> 12) & (unsigned int)0x3F));
+ tmp_25 = parser->buffer.last;
+ (parser->buffer.last) ++;
+ *tmp_25 = (unsigned char)((unsigned int)0x80 + ((value >> 6) & (unsigned int)0x3F));
+ tmp_26 = parser->buffer.last;
+ (parser->buffer.last) ++;
+ *tmp_26 = (unsigned char)((unsigned int)0x80 + (value & (unsigned int)0x3F));
+ }
+ parser->unread += (size_t)1;
+ }
+ if (parser->eof) {
+ yaml_char_t *tmp_27;
+ tmp_27 = parser->buffer.last;
+ (parser->buffer.last) ++;
+ *tmp_27 = (unsigned char)'\000';
+ parser->unread += (size_t)1;
+ __retres = 1;
+ goto return_label;
+ }
+ }
+ if (parser->offset >= ~ ((unsigned long)0) / (unsigned long)2) {
+ int tmp_28;
+ tmp_28 = yaml_parser_set_reader_error(parser,"input is too long",
+ parser->offset,-1);
+ __retres = tmp_28;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_set_scanner_error(yaml_parser_t *parser,
+ char const *context,
+ yaml_mark_t context_mark,
+ char const *problem);
+
+static int yaml_parser_fetch_next_token(yaml_parser_t *parser);
+
+static int yaml_parser_stale_simple_keys(yaml_parser_t *parser);
+
+static int yaml_parser_save_simple_key(yaml_parser_t *parser);
+
+static int yaml_parser_remove_simple_key(yaml_parser_t *parser);
+
+static int yaml_parser_increase_flow_level(yaml_parser_t *parser);
+
+static int yaml_parser_decrease_flow_level(yaml_parser_t *parser);
+
+static int yaml_parser_roll_indent(yaml_parser_t *parser, ptrdiff_t column,
+ ptrdiff_t number, yaml_token_type_t type,
+ yaml_mark_t mark);
+
+static int yaml_parser_unroll_indent(yaml_parser_t *parser, ptrdiff_t column);
+
+static int yaml_parser_fetch_stream_start(yaml_parser_t *parser);
+
+static int yaml_parser_fetch_stream_end(yaml_parser_t *parser);
+
+static int yaml_parser_fetch_directive(yaml_parser_t *parser);
+
+static int yaml_parser_fetch_document_indicator(yaml_parser_t *parser,
+ yaml_token_type_t type);
+
+static int yaml_parser_fetch_flow_collection_start(yaml_parser_t *parser,
+ yaml_token_type_t type);
+
+static int yaml_parser_fetch_flow_collection_end(yaml_parser_t *parser,
+ yaml_token_type_t type);
+
+static int yaml_parser_fetch_flow_entry(yaml_parser_t *parser);
+
+static int yaml_parser_fetch_block_entry(yaml_parser_t *parser);
+
+static int yaml_parser_fetch_key(yaml_parser_t *parser);
+
+static int yaml_parser_fetch_value(yaml_parser_t *parser);
+
+static int yaml_parser_fetch_anchor(yaml_parser_t *parser,
+ yaml_token_type_t type);
+
+static int yaml_parser_fetch_tag(yaml_parser_t *parser);
+
+static int yaml_parser_fetch_block_scalar(yaml_parser_t *parser, int literal);
+
+static int yaml_parser_fetch_flow_scalar(yaml_parser_t *parser, int single);
+
+static int yaml_parser_fetch_plain_scalar(yaml_parser_t *parser);
+
+static int yaml_parser_scan_to_next_token(yaml_parser_t *parser);
+
+static int yaml_parser_scan_directive(yaml_parser_t *parser,
+ yaml_token_t *token);
+
+static int yaml_parser_scan_directive_name(yaml_parser_t *parser,
+ yaml_mark_t start_mark,
+ yaml_char_t **name);
+
+static int yaml_parser_scan_version_directive_value(yaml_parser_t *parser,
+ yaml_mark_t start_mark,
+ int *major, int *minor);
+
+static int yaml_parser_scan_version_directive_number(yaml_parser_t *parser,
+ yaml_mark_t start_mark,
+ int *number);
+
+static int yaml_parser_scan_tag_directive_value(yaml_parser_t *parser,
+ yaml_mark_t start_mark,
+ yaml_char_t **handle,
+ yaml_char_t **prefix);
+
+static int yaml_parser_scan_anchor(yaml_parser_t *parser,
+ yaml_token_t *token,
+ yaml_token_type_t type);
+
+static int yaml_parser_scan_tag(yaml_parser_t *parser, yaml_token_t *token);
+
+static int yaml_parser_scan_tag_handle(yaml_parser_t *parser, int directive,
+ yaml_mark_t start_mark,
+ yaml_char_t **handle);
+
+static int yaml_parser_scan_tag_uri(yaml_parser_t *parser, int uri_char,
+ int directive, yaml_char_t *head,
+ yaml_mark_t start_mark, yaml_char_t **uri);
+
+static int yaml_parser_scan_uri_escapes(yaml_parser_t *parser, int directive,
+ yaml_mark_t start_mark,
+ yaml_string_t *string);
+
+static int yaml_parser_scan_block_scalar(yaml_parser_t *parser,
+ yaml_token_t *token, int literal);
+
+static int yaml_parser_scan_block_scalar_breaks(yaml_parser_t *parser,
+ int *indent,
+ yaml_string_t *breaks,
+ yaml_mark_t start_mark,
+ yaml_mark_t *end_mark);
+
+static int yaml_parser_scan_flow_scalar(yaml_parser_t *parser,
+ yaml_token_t *token, int single);
+
+static int yaml_parser_scan_plain_scalar(yaml_parser_t *parser,
+ yaml_token_t *token);
+
+int yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token)
+{
+ int __retres;
+ yaml_token_t *tmp_0;
+ __FC_assert(parser != (yaml_parser_t *)0,"src/scanner.c",745,"parser");
+ __FC_assert(token != (yaml_token_t *)0,"src/scanner.c",746,"token");
+ memset((void *)token,0,sizeof(yaml_token_t));
+ if (parser->stream_end_produced) goto _LOR;
+ else
+ if (parser->error) {
+ _LOR: {
+ __retres = 1;
+ goto return_label;
+ }
+ }
+ if (! parser->token_available) {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ tmp_0 = parser->tokens.head;
+ (parser->tokens.head) ++;
+ *token = *tmp_0;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ if (token->type == (unsigned int)YAML_STREAM_END_TOKEN) parser->stream_end_produced = 1;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_set_scanner_error(yaml_parser_t *parser,
+ char const *context,
+ yaml_mark_t context_mark,
+ char const *problem)
+{
+ int __retres;
+ parser->error = YAML_SCANNER_ERROR;
+ parser->context = context;
+ parser->context_mark = context_mark;
+ parser->problem = problem;
+ parser->problem_mark = parser->mark;
+ __retres = 0;
+ return __retres;
+}
+
+int yaml_parser_fetch_more_tokens(yaml_parser_t *parser)
+{
+ int __retres;
+ int need_more_tokens;
+ while (1) {
+ {
+ int tmp_0;
+ need_more_tokens = 0;
+ if (parser->tokens.head == parser->tokens.tail) need_more_tokens = 1;
+ else {
+ yaml_simple_key_t *simple_key;
+ int tmp;
+ tmp = yaml_parser_stale_simple_keys(parser);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ simple_key = parser->simple_keys.start;
+ while (simple_key != parser->simple_keys.top) {
+ if (simple_key->possible)
+ if (simple_key->token_number == parser->tokens_parsed) {
+ need_more_tokens = 1;
+ break;
+ }
+ simple_key ++;
+ }
+ }
+ if (! need_more_tokens) break;
+ tmp_0 = yaml_parser_fetch_next_token(parser);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ parser->token_available = 1;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_next_token(yaml_parser_t *parser)
+{
+ int __retres;
+ int tmp_0;
+ int tmp_2;
+ int tmp_3;
+ int tmp_4;
+ int tmp_6;
+ int tmp_27;
+ if (parser->unread >= (size_t)1) tmp_0 = 1;
+ else tmp_0 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (! parser->stream_start_produced) {
+ int tmp_1;
+ tmp_1 = yaml_parser_fetch_stream_start(parser);
+ __retres = tmp_1;
+ goto return_label;
+ }
+ tmp_2 = yaml_parser_scan_to_next_token(parser);
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_3 = yaml_parser_stale_simple_keys(parser);
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_4 = yaml_parser_unroll_indent(parser,(long)parser->mark.column);
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (parser->unread >= (size_t)4) tmp_6 = 1;
+ else tmp_6 = yaml_parser_update_buffer(parser,(unsigned long)4);
+ if (! tmp_6) {
+ __retres = 0;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000')) {
+ int tmp_7;
+ tmp_7 = yaml_parser_fetch_stream_end(parser);
+ __retres = tmp_7;
+ goto return_label;
+ }
+ if (parser->mark.column == (size_t)0)
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'%')) {
+ int tmp_8;
+ tmp_8 = yaml_parser_fetch_directive(parser);
+ __retres = tmp_8;
+ goto return_label;
+ }
+ if (parser->mark.column == (size_t)0)
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'-'))
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'-'))
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'-'))
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)' '))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\t'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\r'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\n'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (3 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_0;
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (3 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (3 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_0;
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ _LAND_2: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (3 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (3 + 2)) == (int)((unsigned char)'\251'))
+ goto _LOR_0;
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\000')) {
+ int tmp_9;
+ _LOR_0:
+ tmp_9 = yaml_parser_fetch_document_indicator
+ (parser,YAML_DOCUMENT_START_TOKEN);
+ __retres = tmp_9;
+ goto return_label;
+ }
+ }
+ }
+ }
+ if (parser->mark.column == (size_t)0)
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'.'))
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'.'))
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'.'))
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)' '))
+ goto _LOR_2;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\t'))
+ goto _LOR_2;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\r'))
+ goto _LOR_2;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\n'))
+ goto _LOR_2;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (3 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_2;
+ else goto _LAND_8;
+ }
+ else {
+ _LAND_8: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (3 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (3 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_2;
+ else goto _LAND_7;
+ }
+ else goto _LAND_7;
+ }
+ else {
+ _LAND_7: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (3 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (3 + 2)) == (int)((unsigned char)'\251'))
+ goto _LOR_2;
+ else goto _LAND_5;
+ }
+ else goto _LAND_5;
+ }
+ else {
+ _LAND_5: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\000')) {
+ int tmp_10;
+ _LOR_2:
+ tmp_10 = yaml_parser_fetch_document_indicator
+ (parser,YAML_DOCUMENT_END_TOKEN);
+ __retres = tmp_10;
+ goto return_label;
+ }
+ }
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'[')) {
+ int tmp_11;
+ tmp_11 = yaml_parser_fetch_flow_collection_start(parser,
+ YAML_FLOW_SEQUENCE_START_TOKEN);
+ __retres = tmp_11;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'{')) {
+ int tmp_12;
+ tmp_12 = yaml_parser_fetch_flow_collection_start(parser,
+ YAML_FLOW_MAPPING_START_TOKEN);
+ __retres = tmp_12;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)']')) {
+ int tmp_13;
+ tmp_13 = yaml_parser_fetch_flow_collection_end(parser,
+ YAML_FLOW_SEQUENCE_END_TOKEN);
+ __retres = tmp_13;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'}')) {
+ int tmp_14;
+ tmp_14 = yaml_parser_fetch_flow_collection_end(parser,
+ YAML_FLOW_MAPPING_END_TOKEN);
+ __retres = tmp_14;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)',')) {
+ int tmp_15;
+ tmp_15 = yaml_parser_fetch_flow_entry(parser);
+ __retres = tmp_15;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'-'))
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)' '))
+ goto _LOR_4;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\t'))
+ goto _LOR_4;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\r'))
+ goto _LOR_4;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\n'))
+ goto _LOR_4;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_4;
+ else goto _LAND_13;
+ }
+ else {
+ _LAND_13: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (1 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_4;
+ else goto _LAND_12;
+ }
+ else goto _LAND_12;
+ }
+ else {
+ _LAND_12: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (1 + 2)) == (int)((unsigned char)'\251'))
+ goto _LOR_4;
+ else goto _LAND_10;
+ }
+ else goto _LAND_10;
+ }
+ else {
+ _LAND_10: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\000')) {
+ int tmp_16;
+ _LOR_4: tmp_16 = yaml_parser_fetch_block_entry(parser);
+ __retres = tmp_16;
+ goto return_label;
+ }
+ }
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'?'))
+ if (parser->flow_level) goto _LOR_7;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)' '))
+ goto _LOR_7;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\t'))
+ goto _LOR_7;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\r'))
+ goto _LOR_7;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\n'))
+ goto _LOR_7;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_7;
+ else goto _LAND_18;
+ }
+ else {
+ _LAND_18: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (1 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_7;
+ else goto _LAND_17;
+ }
+ else goto _LAND_17;
+ }
+ else {
+ _LAND_17: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (1 + 2)) == (int)((unsigned char)'\251'))
+ goto _LOR_7;
+ else goto _LAND_15;
+ }
+ else goto _LAND_15;
+ }
+ else {
+ _LAND_15: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\000')) {
+ int tmp_17;
+ _LOR_7: tmp_17 = yaml_parser_fetch_key(parser);
+ __retres = tmp_17;
+ goto return_label;
+ }
+ }
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)':'))
+ if (parser->flow_level) goto _LOR_10;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)' '))
+ goto _LOR_10;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\t'))
+ goto _LOR_10;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\r'))
+ goto _LOR_10;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\n'))
+ goto _LOR_10;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_10;
+ else goto _LAND_23;
+ }
+ else {
+ _LAND_23: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (1 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_10;
+ else goto _LAND_22;
+ }
+ else goto _LAND_22;
+ }
+ else {
+ _LAND_22: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (1 + 2)) == (int)((unsigned char)'\251'))
+ goto _LOR_10;
+ else goto _LAND_20;
+ }
+ else goto _LAND_20;
+ }
+ else {
+ _LAND_20: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\000')) {
+ int tmp_18;
+ _LOR_10: tmp_18 = yaml_parser_fetch_value(parser);
+ __retres = tmp_18;
+ goto return_label;
+ }
+ }
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'*')) {
+ int tmp_19;
+ tmp_19 = yaml_parser_fetch_anchor(parser,YAML_ALIAS_TOKEN);
+ __retres = tmp_19;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'&')) {
+ int tmp_20;
+ tmp_20 = yaml_parser_fetch_anchor(parser,YAML_ANCHOR_TOKEN);
+ __retres = tmp_20;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'!')) {
+ int tmp_21;
+ tmp_21 = yaml_parser_fetch_tag(parser);
+ __retres = tmp_21;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'|'))
+ if (! parser->flow_level) {
+ int tmp_22;
+ tmp_22 = yaml_parser_fetch_block_scalar(parser,1);
+ __retres = tmp_22;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'>'))
+ if (! parser->flow_level) {
+ int tmp_23;
+ tmp_23 = yaml_parser_fetch_block_scalar(parser,0);
+ __retres = tmp_23;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\'')) {
+ int tmp_24;
+ tmp_24 = yaml_parser_fetch_flow_scalar(parser,1);
+ __retres = tmp_24;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\"')) {
+ int tmp_25;
+ tmp_25 = yaml_parser_fetch_flow_scalar(parser,0);
+ __retres = tmp_25;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' '))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_13;
+ else goto _LAND_34;
+ }
+ else {
+ _LAND_34: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_13;
+ else goto _LAND_33;
+ }
+ else goto _LAND_33;
+ }
+ else {
+ _LAND_33: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251'))
+ goto _LOR_13;
+ else goto _LAND_31;
+ }
+ else goto _LAND_31;
+ }
+ else {
+ _LAND_31: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'-'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'?'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)':'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)','))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'['))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)']'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'{'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'}'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'#'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'&'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'*'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'!'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'|'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'>'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\''))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\"'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'%'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'@'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'`')) {
+ _LOR_13: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'-')) {
+ if ((int)*(
+ parser->buffer.pointer + 1) == (int)((unsigned char)' '))
+ goto _LAND_29;
+ else
+ if ((int)*(
+ parser->buffer.pointer + 1) == (int)((unsigned char)'\t'))
+ goto _LAND_29;
+ else goto _LOR_11;
+ }
+ else
+ _LAND_29:
+ if (! parser->flow_level)
+ if ((int)*(
+ parser->buffer.pointer + 0) == (int)((unsigned char)'?'))
+ goto _LOR_12;
+ else
+ if ((int)*(
+ parser->buffer.pointer + 0) == (int)((unsigned char)':')) {
+ _LOR_12: ;
+ if (! (
+ (int)*(
+ parser->buffer.pointer + 1) == (int)((unsigned char)' ')))
+ if (! (
+ (int)*(
+ parser->buffer.pointer + 1) == (int)((unsigned char)'\t')))
+ if (! (
+ (int)*(
+ parser->buffer.pointer + 1) == (int)((unsigned char)'\r')))
+ if (! (
+ (int)*(
+ parser->buffer.pointer + 1) == (int)((unsigned char)'\n')))
+ if (
+ (int)*(
+ parser->buffer.pointer + 1) == (int)((unsigned char)'\302')) {
+ if (! (
+ (int)*(
+ parser->buffer.pointer + (
+ 1 + 1)) == (int)((unsigned char)'\205')))
+ goto _LAND_28;
+ }
+ else {
+ _LAND_28:
+ ;
+ if (
+ (int)*(
+ parser->buffer.pointer + 1) == (int)((unsigned char)'\342')) {
+ if (
+ (int)*(
+ parser->buffer.pointer + (
+ 1 + 1)) == (int)((unsigned char)'\200')) {
+ if (! (
+ (int)*(
+ parser->buffer.pointer + (
+ 1 + 2)) == (int)((unsigned char)'\250')))
+ goto _LAND_27;
+ }
+ else
+ goto _LAND_27;
+ }
+ else {
+ _LAND_27:
+ ;
+ if (
+ (int)*(
+ parser->buffer.pointer + 1) == (int)((unsigned char)'\342')) {
+ if (
+ (int)*(
+ parser->buffer.pointer + (
+ 1 + 1)) == (int)((unsigned char)'\200')) {
+ if (! (
+ (int)*(
+ parser->buffer.pointer + (
+ 1 + 2)) == (int)((unsigned char)'\251')))
+ goto _LAND_25;
+ }
+ else
+ goto _LAND_25;
+ }
+ else {
+ _LAND_25:
+ ;
+ if (! (
+ (int)*(
+ parser->buffer.pointer + 1) == (int)((unsigned char)'\000'))) {
+ int tmp_26;
+ _LOR_11:
+ tmp_26 = yaml_parser_fetch_plain_scalar
+ (parser);
+ __retres = tmp_26;
+ goto return_label;
+ }
+ }
+ }
+ }
+ }
+ }
+ else goto _LOR_11;
+ }
+ }
+ }
+ tmp_27 = yaml_parser_set_scanner_error(parser,
+ "while scanning for the next token",
+ parser->mark,
+ "found character that cannot start any token");
+ __retres = tmp_27;
+ return_label: return __retres;
+}
+
+static int yaml_parser_stale_simple_keys(yaml_parser_t *parser)
+{
+ int __retres;
+ yaml_simple_key_t *simple_key;
+ simple_key = parser->simple_keys.start;
+ while (simple_key != parser->simple_keys.top) {
+ if (simple_key->possible)
+ if (simple_key->mark.line < parser->mark.line) goto _LOR;
+ else
+ if (simple_key->mark.index + (size_t)1024 < parser->mark.index) {
+ _LOR:
+ {
+ if (simple_key->required) {
+ int tmp;
+ tmp = yaml_parser_set_scanner_error(parser,
+ "while scanning a simple key",
+ simple_key->mark,
+ "could not find expected \':\'");
+ __retres = tmp;
+ goto return_label;
+ }
+ simple_key->possible = 0;
+ }
+ }
+ simple_key ++;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_save_simple_key(yaml_parser_t *parser)
+{
+ int __retres;
+ int tmp;
+ if (! parser->flow_level)
+ if ((long)parser->indent == (long)parser->mark.column) tmp = 1;
+ else tmp = 0;
+ else tmp = 0;
+ int required = tmp;
+ if (parser->simple_key_allowed) {
+ yaml_simple_key_t simple_key;
+ int tmp_0;
+ simple_key.possible = 1;
+ simple_key.required = required;
+ simple_key.token_number = parser->tokens_parsed + (size_t)(parser->tokens.tail - parser->tokens.head);
+ simple_key.mark = parser->mark;
+ tmp_0 = yaml_parser_remove_simple_key(parser);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ *(parser->simple_keys.top - 1) = simple_key;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_remove_simple_key(yaml_parser_t *parser)
+{
+ int __retres;
+ yaml_simple_key_t *simple_key = parser->simple_keys.top - 1;
+ if (simple_key->possible)
+ if (simple_key->required) {
+ int tmp;
+ tmp = yaml_parser_set_scanner_error(parser,
+ "while scanning a simple key",
+ simple_key->mark,
+ "could not find expected \':\'");
+ __retres = tmp;
+ goto return_label;
+ }
+ simple_key->possible = 0;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_increase_flow_level(yaml_parser_t *parser)
+{
+ int __retres;
+ int tmp_1;
+ yaml_simple_key_t empty_simple_key =
+ {.possible = 0,
+ .required = 0,
+ .token_number = (unsigned long)0,
+ .mark = {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0}};
+ if (parser->simple_keys.top != parser->simple_keys.end) goto _LOR;
+ else {
+ int tmp;
+ tmp = yaml_stack_extend((void **)(& parser->simple_keys.start),
+ (void **)(& parser->simple_keys.top),
+ (void **)(& parser->simple_keys.end));
+ if (tmp) {
+ yaml_simple_key_t *tmp_0;
+ _LOR: tmp_0 = parser->simple_keys.top;
+ (parser->simple_keys.top) ++;
+ *tmp_0 = empty_simple_key;
+ tmp_1 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_1 = 0;
+ }
+ }
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (parser->flow_level == 2147483647) {
+ parser->error = YAML_MEMORY_ERROR;
+ __retres = 0;
+ goto return_label;
+ }
+ (parser->flow_level) ++;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_decrease_flow_level(yaml_parser_t *parser)
+{
+ int __retres;
+ if (parser->flow_level) {
+ (parser->flow_level) --;
+ (parser->simple_keys.top) --;
+ ;
+ }
+ __retres = 1;
+ return __retres;
+}
+
+static int yaml_parser_roll_indent(yaml_parser_t *parser, ptrdiff_t column,
+ ptrdiff_t number, yaml_token_type_t type,
+ yaml_mark_t mark)
+{
+ int __retres;
+ yaml_token_t token;
+ if (parser->flow_level) {
+ __retres = 1;
+ goto return_label;
+ }
+ if ((ptrdiff_t)parser->indent < column) {
+ int tmp_1;
+ if (parser->indents.top != parser->indents.end) goto _LOR;
+ else {
+ int tmp;
+ tmp = yaml_stack_extend((void **)(& parser->indents.start),
+ (void **)(& parser->indents.top),
+ (void **)(& parser->indents.end));
+ if (tmp) {
+ int *tmp_0;
+ _LOR: tmp_0 = parser->indents.top;
+ (parser->indents.top) ++;
+ *tmp_0 = parser->indent;
+ tmp_1 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_1 = 0;
+ }
+ }
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (column > (ptrdiff_t)2147483647) {
+ parser->error = YAML_MEMORY_ERROR;
+ __retres = 0;
+ goto return_label;
+ }
+ parser->indent = (int)column;
+ memset((void *)(& token),0,sizeof(yaml_token_t));
+ token.type = type;
+ token.start_mark = mark;
+ token.end_mark = mark;
+ if (number == (ptrdiff_t)(-1)) {
+ int tmp_4;
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR_0;
+ else {
+ int tmp_2;
+ tmp_2 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_2) {
+ yaml_token_t *tmp_3;
+ _LOR_0: tmp_3 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_3 = token;
+ tmp_4 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_4 = 0;
+ }
+ }
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ else {
+ int tmp_6;
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR_1;
+ else {
+ int tmp_5;
+ tmp_5 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_5) {
+ _LOR_1:
+ {
+ memmove((void *)((parser->tokens.head + ((size_t)number - parser->tokens_parsed)) + 1),
+ (void const *)(parser->tokens.head + ((size_t)number - parser->tokens_parsed)),
+ ((size_t)(parser->tokens.tail - parser->tokens.head) - (
+ (size_t)number - parser->tokens_parsed)) * sizeof(*(parser->tokens.start)));
+ *(parser->tokens.head + ((size_t)number - parser->tokens_parsed)) = token;
+ (parser->tokens.tail) ++;
+ }
+ tmp_6 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_6 = 0;
+ }
+ }
+ if (! tmp_6) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_unroll_indent(yaml_parser_t *parser, ptrdiff_t column)
+{
+ int __retres;
+ yaml_token_t token;
+ if (parser->flow_level) {
+ __retres = 1;
+ goto return_label;
+ }
+ while ((ptrdiff_t)parser->indent > column) {
+ int tmp_1;
+ memset((void *)(& token),0,sizeof(yaml_token_t));
+ token.type = YAML_BLOCK_END_TOKEN;
+ token.start_mark = parser->mark;
+ token.end_mark = parser->mark;
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp;
+ tmp = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp) {
+ yaml_token_t *tmp_0;
+ _LOR: tmp_0 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_0 = token;
+ tmp_1 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_1 = 0;
+ }
+ }
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ (parser->indents.top) --;
+ parser->indent = *(parser->indents.top);
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_stream_start(yaml_parser_t *parser)
+{
+ int __retres;
+ yaml_token_t token;
+ int tmp_1;
+ int tmp_4;
+ yaml_simple_key_t simple_key =
+ {.possible = 0,
+ .required = 0,
+ .token_number = (unsigned long)0,
+ .mark = {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0}};
+ parser->indent = -1;
+ if (parser->simple_keys.top != parser->simple_keys.end) goto _LOR;
+ else {
+ int tmp;
+ tmp = yaml_stack_extend((void **)(& parser->simple_keys.start),
+ (void **)(& parser->simple_keys.top),
+ (void **)(& parser->simple_keys.end));
+ if (tmp) {
+ yaml_simple_key_t *tmp_0;
+ _LOR: tmp_0 = parser->simple_keys.top;
+ (parser->simple_keys.top) ++;
+ *tmp_0 = simple_key;
+ tmp_1 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_1 = 0;
+ }
+ }
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = 1;
+ parser->stream_start_produced = 1;
+ memset((void *)(& token),0,sizeof(yaml_token_t));
+ token.type = YAML_STREAM_START_TOKEN;
+ token.start_mark = parser->mark;
+ token.end_mark = parser->mark;
+ token.data.stream_start.encoding = parser->encoding;
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR_0;
+ else {
+ int tmp_2;
+ tmp_2 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_2) {
+ yaml_token_t *tmp_3;
+ _LOR_0: tmp_3 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_3 = token;
+ tmp_4 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_4 = 0;
+ }
+ }
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_stream_end(yaml_parser_t *parser)
+{
+ int __retres;
+ yaml_token_t token;
+ int tmp;
+ int tmp_0;
+ int tmp_3;
+ if (parser->mark.column != (size_t)0) {
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ }
+ tmp = yaml_parser_unroll_indent(parser,(long)(-1));
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_0 = yaml_parser_remove_simple_key(parser);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = 0;
+ memset((void *)(& token),0,sizeof(yaml_token_t));
+ token.type = YAML_STREAM_END_TOKEN;
+ token.start_mark = parser->mark;
+ token.end_mark = parser->mark;
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_1) {
+ yaml_token_t *tmp_2;
+ _LOR: tmp_2 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_2 = token;
+ tmp_3 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_directive(yaml_parser_t *parser)
+{
+ int __retres;
+ yaml_token_t token;
+ int tmp;
+ int tmp_0;
+ int tmp_1;
+ int tmp_4;
+ tmp = yaml_parser_unroll_indent(parser,(long)(-1));
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_0 = yaml_parser_remove_simple_key(parser);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = 0;
+ tmp_1 = yaml_parser_scan_directive(parser,& token);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp_2;
+ tmp_2 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_2) {
+ yaml_token_t *tmp_3;
+ _LOR: tmp_3 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_3 = token;
+ tmp_4 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_4 = 0;
+ }
+ }
+ if (! tmp_4) {
+ yaml_token_delete(& token);
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_document_indicator(yaml_parser_t *parser,
+ yaml_token_type_t type)
+{
+ int __retres;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ yaml_token_t token;
+ int tmp;
+ int tmp_0;
+ int tmp_4;
+ int tmp_8;
+ int tmp_12;
+ int tmp_15;
+ tmp = yaml_parser_unroll_indent(parser,(long)(-1));
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_0 = yaml_parser_remove_simple_key(parser);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = 0;
+ start_mark = parser->mark;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_4 = 1;
+ else {
+ int tmp_3;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_3 = 2;
+ else {
+ int tmp_2;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_2 = 3;
+ else {
+ int tmp_1;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_1 = 4;
+ else tmp_1 = 0;
+ tmp_2 = tmp_1;
+ }
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ parser->buffer.pointer += tmp_4;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_8 = 1;
+ else {
+ int tmp_7;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_7 = 2;
+ else {
+ int tmp_6;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_6 = 3;
+ else {
+ int tmp_5;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_5 = 4;
+ else tmp_5 = 0;
+ tmp_6 = tmp_5;
+ }
+ tmp_7 = tmp_6;
+ }
+ tmp_8 = tmp_7;
+ }
+ parser->buffer.pointer += tmp_8;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_12 = 1;
+ else {
+ int tmp_11;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_11 = 2;
+ else {
+ int tmp_10;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_10 = 3;
+ else {
+ int tmp_9;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_9 = 4;
+ else tmp_9 = 0;
+ tmp_10 = tmp_9;
+ }
+ tmp_11 = tmp_10;
+ }
+ tmp_12 = tmp_11;
+ }
+ parser->buffer.pointer += tmp_12;
+ end_mark = parser->mark;
+ memset((void *)(& token),0,sizeof(yaml_token_t));
+ token.type = type;
+ token.start_mark = start_mark;
+ token.end_mark = end_mark;
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp_13;
+ tmp_13 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_13) {
+ yaml_token_t *tmp_14;
+ _LOR: tmp_14 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_14 = token;
+ tmp_15 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_15 = 0;
+ }
+ }
+ if (! tmp_15) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_flow_collection_start(yaml_parser_t *parser,
+ yaml_token_type_t type)
+{
+ int __retres;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ yaml_token_t token;
+ int tmp;
+ int tmp_0;
+ int tmp_4;
+ int tmp_7;
+ tmp = yaml_parser_save_simple_key(parser);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_0 = yaml_parser_increase_flow_level(parser);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = 1;
+ start_mark = parser->mark;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_4 = 1;
+ else {
+ int tmp_3;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_3 = 2;
+ else {
+ int tmp_2;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_2 = 3;
+ else {
+ int tmp_1;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_1 = 4;
+ else tmp_1 = 0;
+ tmp_2 = tmp_1;
+ }
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ parser->buffer.pointer += tmp_4;
+ end_mark = parser->mark;
+ memset((void *)(& token),0,sizeof(yaml_token_t));
+ token.type = type;
+ token.start_mark = start_mark;
+ token.end_mark = end_mark;
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp_5;
+ tmp_5 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_5) {
+ yaml_token_t *tmp_6;
+ _LOR: tmp_6 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_6 = token;
+ tmp_7 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_7 = 0;
+ }
+ }
+ if (! tmp_7) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_flow_collection_end(yaml_parser_t *parser,
+ yaml_token_type_t type)
+{
+ int __retres;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ yaml_token_t token;
+ int tmp;
+ int tmp_0;
+ int tmp_4;
+ int tmp_7;
+ tmp = yaml_parser_remove_simple_key(parser);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_0 = yaml_parser_decrease_flow_level(parser);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = 0;
+ start_mark = parser->mark;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_4 = 1;
+ else {
+ int tmp_3;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_3 = 2;
+ else {
+ int tmp_2;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_2 = 3;
+ else {
+ int tmp_1;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_1 = 4;
+ else tmp_1 = 0;
+ tmp_2 = tmp_1;
+ }
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ parser->buffer.pointer += tmp_4;
+ end_mark = parser->mark;
+ memset((void *)(& token),0,sizeof(yaml_token_t));
+ token.type = type;
+ token.start_mark = start_mark;
+ token.end_mark = end_mark;
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp_5;
+ tmp_5 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_5) {
+ yaml_token_t *tmp_6;
+ _LOR: tmp_6 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_6 = token;
+ tmp_7 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_7 = 0;
+ }
+ }
+ if (! tmp_7) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_flow_entry(yaml_parser_t *parser)
+{
+ int __retres;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ yaml_token_t token;
+ int tmp;
+ int tmp_3;
+ int tmp_6;
+ tmp = yaml_parser_remove_simple_key(parser);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = 1;
+ start_mark = parser->mark;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_3 = 1;
+ else {
+ int tmp_2;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_2 = 2;
+ else {
+ int tmp_1;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_1 = 3;
+ else {
+ int tmp_0;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_0 = 4;
+ else tmp_0 = 0;
+ tmp_1 = tmp_0;
+ }
+ tmp_2 = tmp_1;
+ }
+ tmp_3 = tmp_2;
+ }
+ parser->buffer.pointer += tmp_3;
+ end_mark = parser->mark;
+ memset((void *)(& token),0,sizeof(yaml_token_t));
+ token.type = YAML_FLOW_ENTRY_TOKEN;
+ token.start_mark = start_mark;
+ token.end_mark = end_mark;
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp_4;
+ tmp_4 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_4) {
+ yaml_token_t *tmp_5;
+ _LOR: tmp_5 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_5 = token;
+ tmp_6 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_6 = 0;
+ }
+ }
+ if (! tmp_6) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_block_entry(yaml_parser_t *parser)
+{
+ int __retres;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ yaml_token_t token;
+ int tmp_1;
+ int tmp_5;
+ int tmp_8;
+ if (! parser->flow_level) {
+ int tmp_0;
+ if (! parser->simple_key_allowed) {
+ int tmp;
+ tmp = yaml_parser_set_scanner_error(parser,(char const *)0,
+ parser->mark,
+ "block sequence entries are not allowed in this context");
+ __retres = tmp;
+ goto return_label;
+ }
+ tmp_0 = yaml_parser_roll_indent(parser,(long)parser->mark.column,
+ (long)(-1),
+ YAML_BLOCK_SEQUENCE_START_TOKEN,
+ parser->mark);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ tmp_1 = yaml_parser_remove_simple_key(parser);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = 1;
+ start_mark = parser->mark;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_5 = 1;
+ else {
+ int tmp_4;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_4 = 2;
+ else {
+ int tmp_3;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_3 = 3;
+ else {
+ int tmp_2;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_2 = 4;
+ else tmp_2 = 0;
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ tmp_5 = tmp_4;
+ }
+ parser->buffer.pointer += tmp_5;
+ end_mark = parser->mark;
+ memset((void *)(& token),0,sizeof(yaml_token_t));
+ token.type = YAML_BLOCK_ENTRY_TOKEN;
+ token.start_mark = start_mark;
+ token.end_mark = end_mark;
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp_6;
+ tmp_6 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_6) {
+ yaml_token_t *tmp_7;
+ _LOR: tmp_7 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_7 = token;
+ tmp_8 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_8 = 0;
+ }
+ }
+ if (! tmp_8) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_key(yaml_parser_t *parser)
+{
+ int __retres;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ yaml_token_t token;
+ int tmp_1;
+ int tmp_5;
+ int tmp_8;
+ if (! parser->flow_level) {
+ int tmp_0;
+ if (! parser->simple_key_allowed) {
+ int tmp;
+ tmp = yaml_parser_set_scanner_error(parser,(char const *)0,
+ parser->mark,
+ "mapping keys are not allowed in this context");
+ __retres = tmp;
+ goto return_label;
+ }
+ tmp_0 = yaml_parser_roll_indent(parser,(long)parser->mark.column,
+ (long)(-1),
+ YAML_BLOCK_MAPPING_START_TOKEN,
+ parser->mark);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ tmp_1 = yaml_parser_remove_simple_key(parser);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = ! parser->flow_level;
+ start_mark = parser->mark;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_5 = 1;
+ else {
+ int tmp_4;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_4 = 2;
+ else {
+ int tmp_3;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_3 = 3;
+ else {
+ int tmp_2;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_2 = 4;
+ else tmp_2 = 0;
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ tmp_5 = tmp_4;
+ }
+ parser->buffer.pointer += tmp_5;
+ end_mark = parser->mark;
+ memset((void *)(& token),0,sizeof(yaml_token_t));
+ token.type = YAML_KEY_TOKEN;
+ token.start_mark = start_mark;
+ token.end_mark = end_mark;
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp_6;
+ tmp_6 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_6) {
+ yaml_token_t *tmp_7;
+ _LOR: tmp_7 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_7 = token;
+ tmp_8 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_8 = 0;
+ }
+ }
+ if (! tmp_8) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_value(yaml_parser_t *parser)
+{
+ int __retres;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ yaml_token_t token;
+ int tmp_7;
+ int tmp_10;
+ yaml_simple_key_t *simple_key = parser->simple_keys.top - 1;
+ if (simple_key->possible) {
+ int tmp_0;
+ int tmp_1;
+ memset((void *)(& token),0,sizeof(yaml_token_t));
+ token.type = YAML_KEY_TOKEN;
+ token.start_mark = simple_key->mark;
+ token.end_mark = simple_key->mark;
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp;
+ tmp = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp) {
+ _LOR:
+ {
+ memmove((void *)((parser->tokens.head + (simple_key->token_number - parser->tokens_parsed)) + 1),
+ (void const *)(parser->tokens.head + (simple_key->token_number - parser->tokens_parsed)),
+ ((size_t)(parser->tokens.tail - parser->tokens.head) - (
+ simple_key->token_number - parser->tokens_parsed)) * sizeof(*(parser->tokens.start)));
+ *(parser->tokens.head + (simple_key->token_number - parser->tokens_parsed)) = token;
+ (parser->tokens.tail) ++;
+ }
+ tmp_0 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_0 = 0;
+ }
+ }
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_1 = yaml_parser_roll_indent(parser,(long)simple_key->mark.column,
+ (long)simple_key->token_number,
+ YAML_BLOCK_MAPPING_START_TOKEN,
+ simple_key->mark);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ simple_key->possible = 0;
+ parser->simple_key_allowed = 0;
+ }
+ else {
+ if (! parser->flow_level) {
+ int tmp_3;
+ if (! parser->simple_key_allowed) {
+ int tmp_2;
+ tmp_2 = yaml_parser_set_scanner_error(parser,(char const *)0,
+ parser->mark,
+ "mapping values are not allowed in this context");
+ __retres = tmp_2;
+ goto return_label;
+ }
+ tmp_3 = yaml_parser_roll_indent(parser,(long)parser->mark.column,
+ (long)(-1),
+ YAML_BLOCK_MAPPING_START_TOKEN,
+ parser->mark);
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ parser->simple_key_allowed = ! parser->flow_level;
+ }
+ start_mark = parser->mark;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_7 = 1;
+ else {
+ int tmp_6;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_6 = 2;
+ else {
+ int tmp_5;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_5 = 3;
+ else {
+ int tmp_4;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_4 = 4;
+ else tmp_4 = 0;
+ tmp_5 = tmp_4;
+ }
+ tmp_6 = tmp_5;
+ }
+ tmp_7 = tmp_6;
+ }
+ parser->buffer.pointer += tmp_7;
+ end_mark = parser->mark;
+ memset((void *)(& token),0,sizeof(yaml_token_t));
+ token.type = YAML_VALUE_TOKEN;
+ token.start_mark = start_mark;
+ token.end_mark = end_mark;
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR_0;
+ else {
+ int tmp_8;
+ tmp_8 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_8) {
+ yaml_token_t *tmp_9;
+ _LOR_0: tmp_9 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_9 = token;
+ tmp_10 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_10 = 0;
+ }
+ }
+ if (! tmp_10) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_anchor(yaml_parser_t *parser,
+ yaml_token_type_t type)
+{
+ int __retres;
+ yaml_token_t token;
+ int tmp;
+ int tmp_0;
+ int tmp_3;
+ tmp = yaml_parser_save_simple_key(parser);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = 0;
+ tmp_0 = yaml_parser_scan_anchor(parser,& token,type);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_1) {
+ yaml_token_t *tmp_2;
+ _LOR: tmp_2 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_2 = token;
+ tmp_3 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) {
+ yaml_token_delete(& token);
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_tag(yaml_parser_t *parser)
+{
+ int __retres;
+ yaml_token_t token;
+ int tmp;
+ int tmp_0;
+ int tmp_3;
+ tmp = yaml_parser_save_simple_key(parser);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = 0;
+ tmp_0 = yaml_parser_scan_tag(parser,& token);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_1) {
+ yaml_token_t *tmp_2;
+ _LOR: tmp_2 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_2 = token;
+ tmp_3 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) {
+ yaml_token_delete(& token);
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_block_scalar(yaml_parser_t *parser, int literal)
+{
+ int __retres;
+ yaml_token_t token;
+ int tmp;
+ int tmp_0;
+ int tmp_3;
+ tmp = yaml_parser_remove_simple_key(parser);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = 1;
+ tmp_0 = yaml_parser_scan_block_scalar(parser,& token,literal);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_1) {
+ yaml_token_t *tmp_2;
+ _LOR: tmp_2 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_2 = token;
+ tmp_3 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) {
+ yaml_token_delete(& token);
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_flow_scalar(yaml_parser_t *parser, int single)
+{
+ int __retres;
+ yaml_token_t token;
+ int tmp;
+ int tmp_0;
+ int tmp_3;
+ tmp = yaml_parser_save_simple_key(parser);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = 0;
+ tmp_0 = yaml_parser_scan_flow_scalar(parser,& token,single);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_1) {
+ yaml_token_t *tmp_2;
+ _LOR: tmp_2 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_2 = token;
+ tmp_3 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) {
+ yaml_token_delete(& token);
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_plain_scalar(yaml_parser_t *parser)
+{
+ int __retres;
+ yaml_token_t token;
+ int tmp;
+ int tmp_0;
+ int tmp_3;
+ tmp = yaml_parser_save_simple_key(parser);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = 0;
+ tmp_0 = yaml_parser_scan_plain_scalar(parser,& token);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_1) {
+ yaml_token_t *tmp_2;
+ _LOR: tmp_2 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_2 = token;
+ tmp_3 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) {
+ yaml_token_delete(& token);
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_to_next_token(yaml_parser_t *parser)
+{
+ int __retres;
+ while (1) {
+ {
+ int tmp_0;
+ int tmp_6;
+ if (parser->unread >= (size_t)1) tmp_0 = 1;
+ else tmp_0 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (parser->mark.column == (size_t)0)
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\357'))
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\273'))
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\277')) {
+ int tmp_4;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_4 = 1;
+ else {
+ int tmp_3;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_3 = 2;
+ else {
+ int tmp_2;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_2 = 3;
+ else {
+ int tmp_1;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_1 = 4;
+ else tmp_1 = 0;
+ tmp_2 = tmp_1;
+ }
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ parser->buffer.pointer += tmp_4;
+ }
+ if (parser->unread >= (size_t)1) tmp_6 = 1;
+ else tmp_6 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_6) {
+ __retres = 0;
+ goto return_label;
+ }
+ while (1) {
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (parser->flow_level) goto _LOR;
+ else
+ if (! parser->simple_key_allowed) {
+ _LOR: ;
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')))
+ break;
+ }
+ else break;
+ {
+ int tmp_10;
+ int tmp_12;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_10 = 1;
+ else {
+ int tmp_9;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_9 = 2;
+ else {
+ int tmp_8;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_8 = 3;
+ else {
+ int tmp_7;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_7 = 4;
+ else tmp_7 = 0;
+ tmp_8 = tmp_7;
+ }
+ tmp_9 = tmp_8;
+ }
+ tmp_10 = tmp_9;
+ }
+ parser->buffer.pointer += tmp_10;
+ if (parser->unread >= (size_t)1) tmp_12 = 1;
+ else tmp_12 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_12) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'#'))
+ while (1) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ break;
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ break;
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ _LAND_2: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251'))
+ break;
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000'))
+ break;
+ }
+ }
+ }
+ {
+ int tmp_16;
+ int tmp_18;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_16 = 1;
+ else {
+ int tmp_15;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_15 = 2;
+ else {
+ int tmp_14;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_14 = 3;
+ else {
+ int tmp_13;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_13 = 4;
+ else tmp_13 = 0;
+ tmp_14 = tmp_13;
+ }
+ tmp_15 = tmp_14;
+ }
+ tmp_16 = tmp_15;
+ }
+ parser->buffer.pointer += tmp_16;
+ if (parser->unread >= (size_t)1) tmp_18 = 1;
+ else tmp_18 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_18) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_1;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ goto _LOR_1;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_1;
+ else goto _LAND_12;
+ }
+ else {
+ _LAND_12: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_1;
+ else goto _LAND_11;
+ }
+ else goto _LAND_11;
+ }
+ else {
+ _LAND_11: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')) {
+ _LOR_1:
+ {
+ int tmp_20;
+ if (parser->unread >= (size_t)2) tmp_20 = 1;
+ else tmp_20 = yaml_parser_update_buffer(parser,
+ (unsigned long)2);
+ if (! tmp_20) {
+ __retres = 0;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\n')) {
+ parser->mark.index += (size_t)2;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)2;
+ parser->buffer.pointer += 2;
+ yaml_char_t *tmp_27 = parser->buffer.pointer;
+ }
+ else goto _LAND_7;
+ }
+ else {
+ _LAND_7: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_0;
+ else goto _LAND_6;
+ }
+ else {
+ _LAND_6: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_0;
+ else goto _LAND_5;
+ }
+ else goto _LAND_5;
+ }
+ else {
+ _LAND_5: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200'))
+ if ((int)*(parser->buffer.pointer + (
+ 0 + 2)) == (int)((unsigned char)'\251')) {
+ int tmp_24;
+ _LOR_0:
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_24 = 1;
+ else {
+ int tmp_23;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_23 = 2;
+ else {
+ int tmp_22;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_22 = 3;
+ else {
+ int tmp_21;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_21 = 4;
+ else tmp_21 = 0;
+ tmp_22 = tmp_21;
+ }
+ tmp_23 = tmp_22;
+ }
+ tmp_24 = tmp_23;
+ }
+ parser->buffer.pointer += tmp_24;
+ yaml_char_t *tmp_25 =
+ parser->buffer.pointer;
+ }
+ }
+ }
+ }
+ if (! parser->flow_level) parser->simple_key_allowed = 1;
+ }
+ }
+ else goto _LAND_9;
+ }
+ else goto _LAND_9;
+ }
+ else _LAND_9: break;
+ }
+ }
+ }
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_directive(yaml_parser_t *parser,
+ yaml_token_t *token)
+{
+ int __retres;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ int major;
+ int minor;
+ int tmp_2;
+ int tmp_3;
+ int tmp_7;
+ int tmp_9;
+ yaml_char_t *name = (yaml_char_t *)0;
+ yaml_char_t *handle = (yaml_char_t *)0;
+ yaml_char_t *prefix = (yaml_char_t *)0;
+ start_mark = parser->mark;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_2 = 1;
+ else {
+ int tmp_1;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_1 = 2;
+ else {
+ int tmp_0;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_0 = 3;
+ else {
+ int tmp;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp = 4;
+ else tmp = 0;
+ tmp_0 = tmp;
+ }
+ tmp_1 = tmp_0;
+ }
+ tmp_2 = tmp_1;
+ }
+ parser->buffer.pointer += tmp_2;
+ tmp_3 = yaml_parser_scan_directive_name(parser,start_mark,& name);
+ if (! tmp_3) goto error;
+ tmp_7 = strcmp((char const *)name,"YAML");
+ if (tmp_7 == 0) {
+ int tmp_4;
+ tmp_4 = yaml_parser_scan_version_directive_value(parser,start_mark,
+ & major,& minor);
+ if (! tmp_4) goto error;
+ end_mark = parser->mark;
+ memset((void *)token,0,sizeof(yaml_token_t));
+ token->type = YAML_VERSION_DIRECTIVE_TOKEN;
+ token->start_mark = start_mark;
+ token->end_mark = end_mark;
+ token->data.version_directive.major = major;
+ token->data.version_directive.minor = minor;
+ }
+ else {
+ int tmp_6;
+ tmp_6 = strcmp((char const *)name,"TAG");
+ if (tmp_6 == 0) {
+ int tmp_5;
+ tmp_5 = yaml_parser_scan_tag_directive_value(parser,start_mark,
+ & handle,& prefix);
+ if (! tmp_5) goto error;
+ end_mark = parser->mark;
+ memset((void *)token,0,sizeof(yaml_token_t));
+ token->type = YAML_TAG_DIRECTIVE_TOKEN;
+ token->start_mark = start_mark;
+ token->end_mark = end_mark;
+ token->data.tag_directive.handle = handle;
+ token->data.tag_directive.prefix = prefix;
+ }
+ else {
+ yaml_parser_set_scanner_error(parser,"while scanning a directive",
+ start_mark,
+ "found unknown directive name");
+ goto error;
+ }
+ }
+ if (parser->unread >= (size_t)1) tmp_9 = 1;
+ else tmp_9 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_9) goto error;
+ while (1) {
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')))
+ break;
+ {
+ int tmp_13;
+ int tmp_15;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_13 = 1;
+ else {
+ int tmp_12;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_12 = 2;
+ else {
+ int tmp_11;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_11 = 3;
+ else {
+ int tmp_10;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_10 = 4;
+ else tmp_10 = 0;
+ tmp_11 = tmp_10;
+ }
+ tmp_12 = tmp_11;
+ }
+ tmp_13 = tmp_12;
+ }
+ parser->buffer.pointer += tmp_13;
+ if (parser->unread >= (size_t)1) tmp_15 = 1;
+ else tmp_15 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_15) goto error;
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'#'))
+ while (1) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ break;
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ break;
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ _LAND_2: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251'))
+ break;
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000'))
+ break;
+ }
+ }
+ }
+ {
+ int tmp_19;
+ int tmp_21;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_19 = 1;
+ else {
+ int tmp_18;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_18 = 2;
+ else {
+ int tmp_17;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_17 = 3;
+ else {
+ int tmp_16;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_16 = 4;
+ else tmp_16 = 0;
+ tmp_17 = tmp_16;
+ }
+ tmp_18 = tmp_17;
+ }
+ tmp_19 = tmp_18;
+ }
+ parser->buffer.pointer += tmp_19;
+ if (parser->unread >= (size_t)1) tmp_21 = 1;
+ else tmp_21 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_21) goto error;
+ }
+ }
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')))
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205')))
+ goto _LAND_8;
+ }
+ else {
+ _LAND_8: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250')))
+ goto _LAND_7;
+ }
+ else goto _LAND_7;
+ }
+ else {
+ _LAND_7: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')))
+ goto _LAND_5;
+ }
+ else goto _LAND_5;
+ }
+ else {
+ _LAND_5: ;
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000'))) {
+ yaml_parser_set_scanner_error(parser,
+ "while scanning a directive",
+ start_mark,
+ "did not find expected comment or line break");
+ goto error;
+ }
+ }
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_0;
+ else goto _LAND_15;
+ }
+ else {
+ _LAND_15: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_0;
+ else goto _LAND_14;
+ }
+ else goto _LAND_14;
+ }
+ else {
+ _LAND_14: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200'))
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')) {
+ _LOR_0:
+ {
+ int tmp_23;
+ if (parser->unread >= (size_t)2) tmp_23 = 1;
+ else tmp_23 = yaml_parser_update_buffer(parser,
+ (unsigned long)2);
+ if (! tmp_23) goto error;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\n')) {
+ parser->mark.index += (size_t)2;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)2;
+ parser->buffer.pointer += 2;
+ yaml_char_t *tmp_30 = parser->buffer.pointer;
+ }
+ else goto _LAND_12;
+ }
+ else {
+ _LAND_12: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ goto _LOR;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR;
+ else goto _LAND_11;
+ }
+ else {
+ _LAND_11: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR;
+ else goto _LAND_10;
+ }
+ else goto _LAND_10;
+ }
+ else {
+ _LAND_10: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200'))
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')) {
+ int tmp_27;
+ _LOR: parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_27 = 1;
+ else {
+ int tmp_26;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_26 = 2;
+ else {
+ int tmp_25;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_25 = 3;
+ else {
+ int tmp_24;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_24 = 4;
+ else tmp_24 = 0;
+ tmp_25 = tmp_24;
+ }
+ tmp_26 = tmp_25;
+ }
+ tmp_27 = tmp_26;
+ }
+ parser->buffer.pointer += tmp_27;
+ yaml_char_t *tmp_28 =
+ parser->buffer.pointer;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ yaml_free((void *)name);
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)prefix);
+ yaml_free((void *)handle);
+ yaml_free((void *)name);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_directive_name(yaml_parser_t *parser,
+ yaml_mark_t start_mark,
+ yaml_char_t **name)
+{
+ int __retres;
+ int tmp_0;
+ int tmp_2;
+ yaml_string_t string =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ string.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (string.start) {
+ string.pointer = string.start;
+ string.end = string.start + 16;
+ memset((void *)string.start,0,(unsigned long)16);
+ tmp_0 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_0 = 0;
+ }
+ if (! tmp_0) goto error;
+ if (parser->unread >= (size_t)1) tmp_2 = 1;
+ else tmp_2 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_2) goto error;
+ while (1) {
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'0')) {
+ if (! ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'9')))
+ goto _LAND_1;
+ }
+ else {
+ _LAND_1: ;
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'A')) {
+ if (! ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'Z')))
+ goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'a')) {
+ if (! ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'z')))
+ goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (! ((int)*(parser->buffer.pointer + 0) == '_'))
+ if (! ((int)*(parser->buffer.pointer + 0) == '-')) break;
+ }
+ }
+ }
+ {
+ int tmp_25_1;
+ int tmp_4;
+ int tmp_27_1;
+ if (string.pointer + 5 < string.end) tmp_4 = 1;
+ else {
+ int tmp_3;
+ tmp_3 = yaml_string_extend(& string.start,& string.pointer,
+ & string.end);
+ if (tmp_3) tmp_4 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_4 = 0;
+ }
+ }
+ if (tmp_4) {
+ if (((int)*(parser->buffer.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_5;
+ yaml_char_t *tmp_6;
+ tmp_5 = string.pointer;
+ (string.pointer) ++;
+ tmp_6 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_5 = *tmp_6;
+ yaml_char_t tmp_31 = *tmp_5;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_7;
+ yaml_char_t *tmp_8;
+ yaml_char_t *tmp_9;
+ yaml_char_t *tmp_10;
+ tmp_7 = string.pointer;
+ (string.pointer) ++;
+ tmp_8 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_7 = *tmp_8;
+ tmp_9 = string.pointer;
+ (string.pointer) ++;
+ tmp_10 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_9 = *tmp_10;
+ yaml_char_t tmp_29 = *tmp_9;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_11;
+ yaml_char_t *tmp_12;
+ yaml_char_t *tmp_13;
+ yaml_char_t *tmp_14;
+ yaml_char_t *tmp_15;
+ yaml_char_t *tmp_16;
+ tmp_11 = string.pointer;
+ (string.pointer) ++;
+ tmp_12 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_11 = *tmp_12;
+ tmp_13 = string.pointer;
+ (string.pointer) ++;
+ tmp_14 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_13 = *tmp_14;
+ tmp_15 = string.pointer;
+ (string.pointer) ++;
+ tmp_16 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_15 = *tmp_16;
+ yaml_char_t tmp_27 = *tmp_15;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_17;
+ yaml_char_t *tmp_18;
+ yaml_char_t *tmp_19;
+ yaml_char_t *tmp_20;
+ yaml_char_t *tmp_21;
+ yaml_char_t *tmp_22;
+ yaml_char_t *tmp_23;
+ yaml_char_t *tmp_24;
+ tmp_17 = string.pointer;
+ (string.pointer) ++;
+ tmp_18 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_17 = *tmp_18;
+ tmp_19 = string.pointer;
+ (string.pointer) ++;
+ tmp_20 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_19 = *tmp_20;
+ tmp_21 = string.pointer;
+ (string.pointer) ++;
+ tmp_22 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_21 = *tmp_22;
+ tmp_23 = string.pointer;
+ (string.pointer) ++;
+ tmp_24 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_23 = *tmp_24;
+ yaml_char_t tmp_25 = *tmp_23;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ tmp_25_1 = 1;
+ }
+ else tmp_25_1 = 0;
+ if (! tmp_25_1) goto error;
+ if (parser->unread >= (size_t)1) tmp_27_1 = 1;
+ else tmp_27_1 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_27_1) goto error;
+ }
+ }
+ if (string.start == string.pointer) {
+ yaml_parser_set_scanner_error(parser,"while scanning a directive",
+ start_mark,
+ "could not find expected directive name");
+ goto error;
+ }
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')))
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205')))
+ goto _LAND_6;
+ }
+ else {
+ _LAND_6: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250')))
+ goto _LAND_5;
+ }
+ else goto _LAND_5;
+ }
+ else {
+ _LAND_5: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')))
+ goto _LAND_3;
+ }
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000'))) {
+ yaml_parser_set_scanner_error(parser,
+ "while scanning a directive",
+ start_mark,
+ "found unexpected non-alphabetical character");
+ goto error;
+ }
+ }
+ }
+ }
+ *name = string.start;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)string.start);
+ string.end = (yaml_char_t *)0;
+ string.pointer = string.end;
+ string.start = string.pointer;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_version_directive_value(yaml_parser_t *parser,
+ yaml_mark_t start_mark,
+ int *major, int *minor)
+{
+ int __retres;
+ int tmp_0;
+ int tmp_7;
+ int tmp_12;
+ int tmp_13;
+ if (parser->unread >= (size_t)1) tmp_0 = 1;
+ else tmp_0 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ while (1) {
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')))
+ break;
+ {
+ int tmp_4;
+ int tmp_6;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_4 = 1;
+ else {
+ int tmp_3;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_3 = 2;
+ else {
+ int tmp_2;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_2 = 3;
+ else {
+ int tmp_1;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_1 = 4;
+ else tmp_1 = 0;
+ tmp_2 = tmp_1;
+ }
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ parser->buffer.pointer += tmp_4;
+ if (parser->unread >= (size_t)1) tmp_6 = 1;
+ else tmp_6 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_6) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ tmp_7 = yaml_parser_scan_version_directive_number(parser,start_mark,major);
+ if (! tmp_7) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'.'))) {
+ int tmp_8;
+ tmp_8 = yaml_parser_set_scanner_error(parser,
+ "while scanning a %YAML directive",
+ start_mark,
+ "did not find expected digit or \'.\' character");
+ __retres = tmp_8;
+ goto return_label;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_12 = 1;
+ else {
+ int tmp_11;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_11 = 2;
+ else {
+ int tmp_10;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_10 = 3;
+ else {
+ int tmp_9;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_9 = 4;
+ else tmp_9 = 0;
+ tmp_10 = tmp_9;
+ }
+ tmp_11 = tmp_10;
+ }
+ tmp_12 = tmp_11;
+ }
+ parser->buffer.pointer += tmp_12;
+ tmp_13 = yaml_parser_scan_version_directive_number(parser,start_mark,minor);
+ if (! tmp_13) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_version_directive_number(yaml_parser_t *parser,
+ yaml_mark_t start_mark,
+ int *number)
+{
+ int __retres;
+ int tmp_0;
+ int value = 0;
+ size_t length = (unsigned long)0;
+ if (parser->unread >= (size_t)1) tmp_0 = 1;
+ else tmp_0 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ while (1) {
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'0')) {
+ if (! ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'9')))
+ break;
+ }
+ else break;
+ {
+ int tmp_5;
+ int tmp_7;
+ length += (size_t)1;
+ if (length > (size_t)9) {
+ int tmp_1;
+ tmp_1 = yaml_parser_set_scanner_error(parser,
+ "while scanning a %YAML directive",
+ start_mark,
+ "found extremely long version number");
+ __retres = tmp_1;
+ goto return_label;
+ }
+ value = value * 10 + ((int)*(parser->buffer.pointer + 0) - (int)((unsigned char)'0'));
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_5 = 1;
+ else {
+ int tmp_4;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_4 = 2;
+ else {
+ int tmp_3;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_3 = 3;
+ else {
+ int tmp_2;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_2 = 4;
+ else tmp_2 = 0;
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ tmp_5 = tmp_4;
+ }
+ parser->buffer.pointer += tmp_5;
+ if (parser->unread >= (size_t)1) tmp_7 = 1;
+ else tmp_7 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_7) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ if (! length) {
+ int tmp_8;
+ tmp_8 = yaml_parser_set_scanner_error(parser,
+ "while scanning a %YAML directive",
+ start_mark,
+ "did not find expected version number");
+ __retres = tmp_8;
+ goto return_label;
+ }
+ *number = value;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_tag_directive_value(yaml_parser_t *parser,
+ yaml_mark_t start_mark,
+ yaml_char_t **handle,
+ yaml_char_t **prefix)
+{
+ int __retres;
+ int tmp_0;
+ int tmp_7;
+ int tmp_9;
+ int tmp_16;
+ int tmp_18;
+ yaml_char_t *handle_value = (yaml_char_t *)0;
+ yaml_char_t *prefix_value = (yaml_char_t *)0;
+ if (parser->unread >= (size_t)1) tmp_0 = 1;
+ else tmp_0 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_0) goto error;
+ while (1) {
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')))
+ break;
+ {
+ int tmp_4;
+ int tmp_6;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_4 = 1;
+ else {
+ int tmp_3;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_3 = 2;
+ else {
+ int tmp_2;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_2 = 3;
+ else {
+ int tmp_1;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_1 = 4;
+ else tmp_1 = 0;
+ tmp_2 = tmp_1;
+ }
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ parser->buffer.pointer += tmp_4;
+ if (parser->unread >= (size_t)1) tmp_6 = 1;
+ else tmp_6 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_6) goto error;
+ }
+ }
+ tmp_7 = yaml_parser_scan_tag_handle(parser,1,start_mark,& handle_value);
+ if (! tmp_7) goto error;
+ if (parser->unread >= (size_t)1) tmp_9 = 1;
+ else tmp_9 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_9) goto error;
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t'))) {
+ yaml_parser_set_scanner_error(parser,"while scanning a %TAG directive",
+ start_mark,
+ "did not find expected whitespace");
+ goto error;
+ }
+ while (1) {
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')))
+ break;
+ {
+ int tmp_13;
+ int tmp_15;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_13 = 1;
+ else {
+ int tmp_12;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_12 = 2;
+ else {
+ int tmp_11;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_11 = 3;
+ else {
+ int tmp_10;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_10 = 4;
+ else tmp_10 = 0;
+ tmp_11 = tmp_10;
+ }
+ tmp_12 = tmp_11;
+ }
+ tmp_13 = tmp_12;
+ }
+ parser->buffer.pointer += tmp_13;
+ if (parser->unread >= (size_t)1) tmp_15 = 1;
+ else tmp_15 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_15) goto error;
+ }
+ }
+ tmp_16 = yaml_parser_scan_tag_uri(parser,1,1,(yaml_char_t *)0,start_mark,
+ & prefix_value);
+ if (! tmp_16) goto error;
+ if (parser->unread >= (size_t)1) tmp_18 = 1;
+ else tmp_18 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_18) goto error;
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')))
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205')))
+ goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250')))
+ goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ _LAND_2: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')))
+ goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000'))) {
+ yaml_parser_set_scanner_error(parser,
+ "while scanning a %TAG directive",
+ start_mark,
+ "did not find expected whitespace or line break");
+ goto error;
+ }
+ }
+ }
+ }
+ *handle = handle_value;
+ *prefix = prefix_value;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)handle_value);
+ yaml_free((void *)prefix_value);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_anchor(yaml_parser_t *parser,
+ yaml_token_t *token,
+ yaml_token_type_t type)
+{
+ int __retres;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ int tmp_0;
+ int tmp_4;
+ int tmp_6;
+ int length = 0;
+ yaml_string_t string =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ string.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (string.start) {
+ string.pointer = string.start;
+ string.end = string.start + 16;
+ memset((void *)string.start,0,(unsigned long)16);
+ tmp_0 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_0 = 0;
+ }
+ if (! tmp_0) goto error;
+ start_mark = parser->mark;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_4 = 1;
+ else {
+ int tmp_3;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_3 = 2;
+ else {
+ int tmp_2;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_2 = 3;
+ else {
+ int tmp_1;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_1 = 4;
+ else tmp_1 = 0;
+ tmp_2 = tmp_1;
+ }
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ parser->buffer.pointer += tmp_4;
+ if (parser->unread >= (size_t)1) tmp_6 = 1;
+ else tmp_6 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_6) goto error;
+ while (1) {
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'0')) {
+ if (! ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'9')))
+ goto _LAND_1;
+ }
+ else {
+ _LAND_1: ;
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'A')) {
+ if (! ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'Z')))
+ goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'a')) {
+ if (! ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'z')))
+ goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (! ((int)*(parser->buffer.pointer + 0) == '_'))
+ if (! ((int)*(parser->buffer.pointer + 0) == '-')) break;
+ }
+ }
+ }
+ {
+ int tmp_29_1;
+ int tmp_8;
+ int tmp_31_1;
+ if (string.pointer + 5 < string.end) tmp_8 = 1;
+ else {
+ int tmp_7;
+ tmp_7 = yaml_string_extend(& string.start,& string.pointer,
+ & string.end);
+ if (tmp_7) tmp_8 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_8 = 0;
+ }
+ }
+ if (tmp_8) {
+ if (((int)*(parser->buffer.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_9;
+ yaml_char_t *tmp_10;
+ tmp_9 = string.pointer;
+ (string.pointer) ++;
+ tmp_10 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_9 = *tmp_10;
+ yaml_char_t tmp_35 = *tmp_9;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_11;
+ yaml_char_t *tmp_12;
+ yaml_char_t *tmp_13;
+ yaml_char_t *tmp_14;
+ tmp_11 = string.pointer;
+ (string.pointer) ++;
+ tmp_12 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_11 = *tmp_12;
+ tmp_13 = string.pointer;
+ (string.pointer) ++;
+ tmp_14 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_13 = *tmp_14;
+ yaml_char_t tmp_33 = *tmp_13;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_15;
+ yaml_char_t *tmp_16;
+ yaml_char_t *tmp_17;
+ yaml_char_t *tmp_18;
+ yaml_char_t *tmp_19;
+ yaml_char_t *tmp_20;
+ tmp_15 = string.pointer;
+ (string.pointer) ++;
+ tmp_16 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_15 = *tmp_16;
+ tmp_17 = string.pointer;
+ (string.pointer) ++;
+ tmp_18 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_17 = *tmp_18;
+ tmp_19 = string.pointer;
+ (string.pointer) ++;
+ tmp_20 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_19 = *tmp_20;
+ yaml_char_t tmp_31 = *tmp_19;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_21;
+ yaml_char_t *tmp_22;
+ yaml_char_t *tmp_23;
+ yaml_char_t *tmp_24;
+ yaml_char_t *tmp_25;
+ yaml_char_t *tmp_26;
+ yaml_char_t *tmp_27;
+ yaml_char_t *tmp_28;
+ tmp_21 = string.pointer;
+ (string.pointer) ++;
+ tmp_22 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_21 = *tmp_22;
+ tmp_23 = string.pointer;
+ (string.pointer) ++;
+ tmp_24 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_23 = *tmp_24;
+ tmp_25 = string.pointer;
+ (string.pointer) ++;
+ tmp_26 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_25 = *tmp_26;
+ tmp_27 = string.pointer;
+ (string.pointer) ++;
+ tmp_28 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_27 = *tmp_28;
+ yaml_char_t tmp_29 = *tmp_27;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ tmp_29_1 = 1;
+ }
+ else tmp_29_1 = 0;
+ if (! tmp_29_1) goto error;
+ if (parser->unread >= (size_t)1) tmp_31_1 = 1;
+ else tmp_31_1 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_31_1) goto error;
+ length ++;
+ }
+ }
+ end_mark = parser->mark;
+ if (! length) goto _LOR;
+ else
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')))
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205')))
+ goto _LAND_6;
+ }
+ else {
+ _LAND_6: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250')))
+ goto _LAND_5;
+ }
+ else goto _LAND_5;
+ }
+ else {
+ _LAND_5: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')))
+ goto _LAND_3;
+ }
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'?')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)':')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)',')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)']')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'}')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'%')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'@')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'`'))) {
+ _LOR:
+ {
+ char const *tmp_32;
+ ;
+ if (type == (unsigned int)YAML_ANCHOR_TOKEN)
+ tmp_32 = "while scanning an anchor";
+ else tmp_32 = "while scanning an alias";
+ ;
+ yaml_parser_set_scanner_error(parser,
+ tmp_32,
+ start_mark,
+ "did not find expected alphabetic or numeric character");
+ goto error;
+ }
+ }
+ }
+ }
+ }
+ if (type == (unsigned int)YAML_ANCHOR_TOKEN) {
+ memset((void *)token,0,sizeof(yaml_token_t));
+ token->type = YAML_ANCHOR_TOKEN;
+ token->start_mark = start_mark;
+ token->end_mark = end_mark;
+ token->data.anchor.value = string.start;
+ }
+ else {
+ memset((void *)token,0,sizeof(yaml_token_t));
+ token->type = YAML_ALIAS_TOKEN;
+ token->start_mark = start_mark;
+ token->end_mark = end_mark;
+ token->data.alias.value = string.start;
+ }
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)string.start);
+ string.end = (yaml_char_t *)0;
+ string.pointer = string.end;
+ string.start = string.pointer;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_tag(yaml_parser_t *parser, yaml_token_t *token)
+{
+ int __retres;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ int tmp_0;
+ int tmp_22;
+ yaml_char_t *handle = (yaml_char_t *)0;
+ yaml_char_t *suffix = (yaml_char_t *)0;
+ start_mark = parser->mark;
+ if (parser->unread >= (size_t)2) tmp_0 = 1;
+ else tmp_0 = yaml_parser_update_buffer(parser,(unsigned long)2);
+ if (! tmp_0) goto error;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'<')) {
+ int tmp_5;
+ int tmp_9;
+ int tmp_10;
+ int tmp_14;
+ handle = (yaml_char_t *)yaml_malloc((unsigned long)1);
+ if (! handle) goto error;
+ *(handle + 0) = (unsigned char)'\000';
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_5 = 1;
+ else {
+ int tmp_4;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_4 = 2;
+ else {
+ int tmp_3;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_3 = 3;
+ else {
+ int tmp_2;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_2 = 4;
+ else tmp_2 = 0;
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ tmp_5 = tmp_4;
+ }
+ parser->buffer.pointer += tmp_5;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_9 = 1;
+ else {
+ int tmp_8;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_8 = 2;
+ else {
+ int tmp_7;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_7 = 3;
+ else {
+ int tmp_6;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_6 = 4;
+ else tmp_6 = 0;
+ tmp_7 = tmp_6;
+ }
+ tmp_8 = tmp_7;
+ }
+ tmp_9 = tmp_8;
+ }
+ parser->buffer.pointer += tmp_9;
+ tmp_10 = yaml_parser_scan_tag_uri(parser,1,0,(yaml_char_t *)0,start_mark,
+ & suffix);
+ if (! tmp_10) goto error;
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'>'))) {
+ yaml_parser_set_scanner_error(parser,"while scanning a tag",start_mark,
+ "did not find the expected \'>\'");
+ goto error;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_14 = 1;
+ else {
+ int tmp_13;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_13 = 2;
+ else {
+ int tmp_12;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_12 = 3;
+ else {
+ int tmp_11;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_11 = 4;
+ else tmp_11 = 0;
+ tmp_12 = tmp_11;
+ }
+ tmp_13 = tmp_12;
+ }
+ tmp_14 = tmp_13;
+ }
+ parser->buffer.pointer += tmp_14;
+ }
+ else {
+ int tmp_15;
+ tmp_15 = yaml_parser_scan_tag_handle(parser,0,start_mark,& handle);
+ if (! tmp_15) goto error;
+ if ((int)*(handle + 0) == '!') {
+ if ((int)*(handle + 1) != '\000') {
+ size_t tmp_20;
+ tmp_20 = strlen((char const *)handle);
+ ;
+ if ((int)*(handle + (tmp_20 - (size_t)1)) == '!') {
+ int tmp_16;
+ tmp_16 = yaml_parser_scan_tag_uri(parser,0,0,(yaml_char_t *)0,
+ start_mark,& suffix);
+ if (! tmp_16) goto error;
+ }
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0:
+ {
+ int tmp_17;
+ tmp_17 = yaml_parser_scan_tag_uri(parser,0,0,handle,start_mark,
+ & suffix);
+ if (! tmp_17) goto error;
+ yaml_free((void *)handle);
+ handle = (yaml_char_t *)yaml_malloc((unsigned long)2);
+ if (! handle) goto error;
+ *(handle + 0) = (unsigned char)'!';
+ *(handle + 1) = (unsigned char)'\000';
+ if ((int)*(suffix + 0) == '\000') {
+ yaml_char_t *tmp_19 = handle;
+ handle = suffix;
+ suffix = tmp_19;
+ }
+ }
+ }
+ }
+ if (parser->unread >= (size_t)1) tmp_22 = 1;
+ else tmp_22 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_22) goto error;
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')))
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205')))
+ goto _LAND_5;
+ }
+ else {
+ _LAND_5: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250')))
+ goto _LAND_4;
+ }
+ else goto _LAND_4;
+ }
+ else {
+ _LAND_4: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')))
+ goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ _LAND_2: ;
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000')))
+ if (! parser->flow_level) goto _LOR;
+ else
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)','))) {
+ _LOR:
+ {
+ yaml_parser_set_scanner_error(parser,
+ "while scanning a tag",
+ start_mark,
+ "did not find expected whitespace or line break");
+ goto error;
+ }
+ }
+ }
+ }
+ }
+ end_mark = parser->mark;
+ memset((void *)token,0,sizeof(yaml_token_t));
+ token->type = YAML_TAG_TOKEN;
+ token->start_mark = start_mark;
+ token->end_mark = end_mark;
+ token->data.tag.handle = handle;
+ token->data.tag.suffix = suffix;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)handle);
+ yaml_free((void *)suffix);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_tag_handle(yaml_parser_t *parser, int directive,
+ yaml_mark_t start_mark,
+ yaml_char_t **handle)
+{
+ int __retres;
+ int tmp_0;
+ int tmp_2;
+ int tmp_26_2;
+ int tmp_5;
+ int tmp_28_2;
+ yaml_string_t string =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ string.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (string.start) {
+ string.pointer = string.start;
+ string.end = string.start + 16;
+ memset((void *)string.start,0,(unsigned long)16);
+ tmp_0 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_0 = 0;
+ }
+ if (! tmp_0) goto error;
+ if (parser->unread >= (size_t)1) tmp_2 = 1;
+ else tmp_2 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_2) goto error;
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'!'))) {
+ char const *tmp_3;
+ ;
+ if (directive) tmp_3 = "while scanning a tag directive";
+ else tmp_3 = "while scanning a tag";
+ ;
+ yaml_parser_set_scanner_error(parser,tmp_3,start_mark,
+ "did not find expected \'!\'");
+ goto error;
+ }
+ if (string.pointer + 5 < string.end) tmp_5 = 1;
+ else {
+ int tmp_4;
+ tmp_4 = yaml_string_extend(& string.start,& string.pointer,& string.end);
+ if (tmp_4) tmp_5 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_5 = 0;
+ }
+ }
+ if (tmp_5) {
+ if (((int)*(parser->buffer.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_6;
+ yaml_char_t *tmp_7;
+ tmp_6 = string.pointer;
+ (string.pointer) ++;
+ tmp_7 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_6 = *tmp_7;
+ yaml_char_t tmp_32 = *tmp_6;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_8;
+ yaml_char_t *tmp_9;
+ yaml_char_t *tmp_10;
+ yaml_char_t *tmp_11;
+ tmp_8 = string.pointer;
+ (string.pointer) ++;
+ tmp_9 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_8 = *tmp_9;
+ tmp_10 = string.pointer;
+ (string.pointer) ++;
+ tmp_11 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_10 = *tmp_11;
+ yaml_char_t tmp_30 = *tmp_10;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_12;
+ yaml_char_t *tmp_13;
+ yaml_char_t *tmp_14;
+ yaml_char_t *tmp_15;
+ yaml_char_t *tmp_16;
+ yaml_char_t *tmp_17;
+ tmp_12 = string.pointer;
+ (string.pointer) ++;
+ tmp_13 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_12 = *tmp_13;
+ tmp_14 = string.pointer;
+ (string.pointer) ++;
+ tmp_15 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_14 = *tmp_15;
+ tmp_16 = string.pointer;
+ (string.pointer) ++;
+ tmp_17 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_16 = *tmp_17;
+ yaml_char_t tmp_28 = *tmp_16;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_18;
+ yaml_char_t *tmp_19;
+ yaml_char_t *tmp_20;
+ yaml_char_t *tmp_21;
+ yaml_char_t *tmp_22;
+ yaml_char_t *tmp_23;
+ yaml_char_t *tmp_24;
+ yaml_char_t *tmp_25;
+ tmp_18 = string.pointer;
+ (string.pointer) ++;
+ tmp_19 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_18 = *tmp_19;
+ tmp_20 = string.pointer;
+ (string.pointer) ++;
+ tmp_21 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_20 = *tmp_21;
+ tmp_22 = string.pointer;
+ (string.pointer) ++;
+ tmp_23 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_22 = *tmp_23;
+ tmp_24 = string.pointer;
+ (string.pointer) ++;
+ tmp_25 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_24 = *tmp_25;
+ yaml_char_t tmp_26 = *tmp_24;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ tmp_26_2 = 1;
+ }
+ else tmp_26_2 = 0;
+ if (! tmp_26_2) goto error;
+ if (parser->unread >= (size_t)1) tmp_28_2 = 1;
+ else tmp_28_2 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_28_2) goto error;
+ while (1) {
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'0')) {
+ if (! ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'9')))
+ goto _LAND_1;
+ }
+ else {
+ _LAND_1: ;
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'A')) {
+ if (! ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'Z')))
+ goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'a')) {
+ if (! ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'z')))
+ goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (! ((int)*(parser->buffer.pointer + 0) == '_'))
+ if (! ((int)*(parser->buffer.pointer + 0) == '-')) break;
+ }
+ }
+ }
+ {
+ int tmp_51_0;
+ int tmp_30_1;
+ int tmp_53_0;
+ if (string.pointer + 5 < string.end) tmp_30_1 = 1;
+ else {
+ int tmp_29;
+ tmp_29 = yaml_string_extend(& string.start,& string.pointer,
+ & string.end);
+ if (tmp_29) tmp_30_1 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_30_1 = 0;
+ }
+ }
+ if (tmp_30_1) {
+ if (((int)*(parser->buffer.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_31;
+ yaml_char_t *tmp_32_1;
+ tmp_31 = string.pointer;
+ (string.pointer) ++;
+ tmp_32_1 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_31 = *tmp_32_1;
+ yaml_char_t tmp_57 = *tmp_31;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_33;
+ yaml_char_t *tmp_34;
+ yaml_char_t *tmp_35;
+ yaml_char_t *tmp_36;
+ tmp_33 = string.pointer;
+ (string.pointer) ++;
+ tmp_34 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_33 = *tmp_34;
+ tmp_35 = string.pointer;
+ (string.pointer) ++;
+ tmp_36 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_35 = *tmp_36;
+ yaml_char_t tmp_55 = *tmp_35;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_37;
+ yaml_char_t *tmp_38;
+ yaml_char_t *tmp_39;
+ yaml_char_t *tmp_40;
+ yaml_char_t *tmp_41;
+ yaml_char_t *tmp_42;
+ tmp_37 = string.pointer;
+ (string.pointer) ++;
+ tmp_38 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_37 = *tmp_38;
+ tmp_39 = string.pointer;
+ (string.pointer) ++;
+ tmp_40 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_39 = *tmp_40;
+ tmp_41 = string.pointer;
+ (string.pointer) ++;
+ tmp_42 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_41 = *tmp_42;
+ yaml_char_t tmp_53 = *tmp_41;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_43;
+ yaml_char_t *tmp_44;
+ yaml_char_t *tmp_45;
+ yaml_char_t *tmp_46;
+ yaml_char_t *tmp_47;
+ yaml_char_t *tmp_48;
+ yaml_char_t *tmp_49;
+ yaml_char_t *tmp_50;
+ tmp_43 = string.pointer;
+ (string.pointer) ++;
+ tmp_44 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_43 = *tmp_44;
+ tmp_45 = string.pointer;
+ (string.pointer) ++;
+ tmp_46 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_45 = *tmp_46;
+ tmp_47 = string.pointer;
+ (string.pointer) ++;
+ tmp_48 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_47 = *tmp_48;
+ tmp_49 = string.pointer;
+ (string.pointer) ++;
+ tmp_50 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_49 = *tmp_50;
+ yaml_char_t tmp_51 = *tmp_49;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ tmp_51_0 = 1;
+ }
+ else tmp_51_0 = 0;
+ if (! tmp_51_0) goto error;
+ if (parser->unread >= (size_t)1) tmp_53_0 = 1;
+ else tmp_53_0 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_53_0) goto error;
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'!')) {
+ int tmp_76_0;
+ int tmp_55_0;
+ if (string.pointer + 5 < string.end) tmp_55_0 = 1;
+ else {
+ int tmp_54;
+ tmp_54 = yaml_string_extend(& string.start,& string.pointer,
+ & string.end);
+ if (tmp_54) tmp_55_0 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_55_0 = 0;
+ }
+ }
+ if (tmp_55_0) {
+ if (((int)*(parser->buffer.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_56;
+ yaml_char_t *tmp_57_0;
+ tmp_56 = string.pointer;
+ (string.pointer) ++;
+ tmp_57_0 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_56 = *tmp_57_0;
+ yaml_char_t tmp_82 = *tmp_56;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_58;
+ yaml_char_t *tmp_59;
+ yaml_char_t *tmp_60;
+ yaml_char_t *tmp_61;
+ tmp_58 = string.pointer;
+ (string.pointer) ++;
+ tmp_59 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_58 = *tmp_59;
+ tmp_60 = string.pointer;
+ (string.pointer) ++;
+ tmp_61 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_60 = *tmp_61;
+ yaml_char_t tmp_80 = *tmp_60;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_62;
+ yaml_char_t *tmp_63;
+ yaml_char_t *tmp_64;
+ yaml_char_t *tmp_65;
+ yaml_char_t *tmp_66;
+ yaml_char_t *tmp_67;
+ tmp_62 = string.pointer;
+ (string.pointer) ++;
+ tmp_63 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_62 = *tmp_63;
+ tmp_64 = string.pointer;
+ (string.pointer) ++;
+ tmp_65 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_64 = *tmp_65;
+ tmp_66 = string.pointer;
+ (string.pointer) ++;
+ tmp_67 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_66 = *tmp_67;
+ yaml_char_t tmp_78 = *tmp_66;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_68;
+ yaml_char_t *tmp_69;
+ yaml_char_t *tmp_70;
+ yaml_char_t *tmp_71;
+ yaml_char_t *tmp_72;
+ yaml_char_t *tmp_73;
+ yaml_char_t *tmp_74;
+ yaml_char_t *tmp_75;
+ tmp_68 = string.pointer;
+ (string.pointer) ++;
+ tmp_69 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_68 = *tmp_69;
+ tmp_70 = string.pointer;
+ (string.pointer) ++;
+ tmp_71 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_70 = *tmp_71;
+ tmp_72 = string.pointer;
+ (string.pointer) ++;
+ tmp_73 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_72 = *tmp_73;
+ tmp_74 = string.pointer;
+ (string.pointer) ++;
+ tmp_75 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_74 = *tmp_75;
+ yaml_char_t tmp_76 = *tmp_74;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ tmp_76_0 = 1;
+ }
+ else tmp_76_0 = 0;
+ if (! tmp_76_0) goto error;
+ }
+ else
+ if (directive)
+ if ((int)*(string.start + 0) == '!') {
+ if (! ((int)*(string.start + 1) == '\000')) goto _LAND_2;
+ }
+ else {
+ _LAND_2:
+ {
+ yaml_parser_set_scanner_error(parser,
+ "while parsing a tag directive",
+ start_mark,
+ "did not find expected \'!\'");
+ goto error;
+ }
+ }
+ *handle = string.start;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)string.start);
+ string.end = (yaml_char_t *)0;
+ string.pointer = string.end;
+ string.start = string.pointer;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_tag_uri(yaml_parser_t *parser, int uri_char,
+ int directive, yaml_char_t *head,
+ yaml_mark_t start_mark, yaml_char_t **uri)
+{
+ int __retres;
+ size_t tmp_0;
+ int tmp_2;
+ int tmp_5;
+ if (head) tmp_0 = strlen((char const *)head);
+ else tmp_0 = (unsigned long)0;
+ size_t length = tmp_0;
+ yaml_string_t string =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ string.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (string.start) {
+ string.pointer = string.start;
+ string.end = string.start + 16;
+ memset((void *)string.start,0,(unsigned long)16);
+ tmp_2 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ if (! tmp_2) goto error;
+ while ((unsigned long)(string.end - string.start) <= length) {
+ int tmp_3;
+ tmp_3 = yaml_string_extend(& string.start,& string.pointer,& string.end);
+ if (! tmp_3) {
+ parser->error = YAML_MEMORY_ERROR;
+ goto error;
+ }
+ }
+ if (length > (size_t)1) {
+ memcpy((void *)string.start,(void const *)(head + 1),length - (size_t)1);
+ string.pointer += length - (size_t)1;
+ }
+ if (parser->unread >= (size_t)1) tmp_5 = 1;
+ else tmp_5 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_5) goto error;
+ while (1) {
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'0')) {
+ if (! ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'9')))
+ goto _LAND_1;
+ }
+ else {
+ _LAND_1: ;
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'A')) {
+ if (! ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'Z')))
+ goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'a')) {
+ if (! ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'z')))
+ goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (! ((int)*(parser->buffer.pointer + 0) == '_'))
+ if (! ((int)*(parser->buffer.pointer + 0) == '-'))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)';')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'/')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'?')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)':')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'@')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'&')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'=')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'+')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'$')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'.')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'%')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'!')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'~')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'*')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\'')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'(')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)')')))
+ if (uri_char) {
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)',')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'[')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)']')))
+ break;
+ }
+ else break;
+ }
+ }
+ }
+ {
+ int tmp_33_2;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'%')) {
+ int tmp_7;
+ int tmp_8;
+ if (string.pointer + 5 < string.end) tmp_7 = 1;
+ else {
+ int tmp_6;
+ tmp_6 = yaml_string_extend(& string.start,& string.pointer,
+ & string.end);
+ if (tmp_6) tmp_7 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_7 = 0;
+ }
+ }
+ if (! tmp_7) goto error;
+ tmp_8 = yaml_parser_scan_uri_escapes(parser,directive,start_mark,
+ & string);
+ if (! tmp_8) goto error;
+ }
+ else {
+ int tmp_31_2;
+ int tmp_10;
+ if (string.pointer + 5 < string.end) tmp_10 = 1;
+ else {
+ int tmp_9;
+ tmp_9 = yaml_string_extend(& string.start,& string.pointer,
+ & string.end);
+ if (tmp_9) tmp_10 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_10 = 0;
+ }
+ }
+ if (tmp_10) {
+ if (((int)*(parser->buffer.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_11;
+ yaml_char_t *tmp_12;
+ tmp_11 = string.pointer;
+ (string.pointer) ++;
+ tmp_12 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_11 = *tmp_12;
+ yaml_char_t tmp_37 = *tmp_11;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_13;
+ yaml_char_t *tmp_14;
+ yaml_char_t *tmp_15;
+ yaml_char_t *tmp_16;
+ tmp_13 = string.pointer;
+ (string.pointer) ++;
+ tmp_14 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_13 = *tmp_14;
+ tmp_15 = string.pointer;
+ (string.pointer) ++;
+ tmp_16 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_15 = *tmp_16;
+ yaml_char_t tmp_35 = *tmp_15;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_17;
+ yaml_char_t *tmp_18;
+ yaml_char_t *tmp_19;
+ yaml_char_t *tmp_20;
+ yaml_char_t *tmp_21;
+ yaml_char_t *tmp_22;
+ tmp_17 = string.pointer;
+ (string.pointer) ++;
+ tmp_18 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_17 = *tmp_18;
+ tmp_19 = string.pointer;
+ (string.pointer) ++;
+ tmp_20 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_19 = *tmp_20;
+ tmp_21 = string.pointer;
+ (string.pointer) ++;
+ tmp_22 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_21 = *tmp_22;
+ yaml_char_t tmp_33 = *tmp_21;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_23;
+ yaml_char_t *tmp_24;
+ yaml_char_t *tmp_25;
+ yaml_char_t *tmp_26;
+ yaml_char_t *tmp_27;
+ yaml_char_t *tmp_28;
+ yaml_char_t *tmp_29;
+ yaml_char_t *tmp_30;
+ tmp_23 = string.pointer;
+ (string.pointer) ++;
+ tmp_24 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_23 = *tmp_24;
+ tmp_25 = string.pointer;
+ (string.pointer) ++;
+ tmp_26 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_25 = *tmp_26;
+ tmp_27 = string.pointer;
+ (string.pointer) ++;
+ tmp_28 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_27 = *tmp_28;
+ tmp_29 = string.pointer;
+ (string.pointer) ++;
+ tmp_30 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_29 = *tmp_30;
+ yaml_char_t tmp_31 = *tmp_29;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ tmp_31_2 = 1;
+ }
+ else tmp_31_2 = 0;
+ if (! tmp_31_2) goto error;
+ }
+ length += (size_t)1;
+ if (parser->unread >= (size_t)1) tmp_33_2 = 1;
+ else tmp_33_2 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_33_2) goto error;
+ }
+ }
+ if (! length) {
+ int tmp_35_2;
+ char const *tmp_36;
+ if (string.pointer + 5 < string.end) tmp_35_2 = 1;
+ else {
+ int tmp_34;
+ tmp_34 = yaml_string_extend(& string.start,& string.pointer,
+ & string.end);
+ if (tmp_34) tmp_35_2 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_35_2 = 0;
+ }
+ }
+ if (! tmp_35_2) goto error;
+ ;
+ if (directive) tmp_36 = "while parsing a %TAG directive";
+ else tmp_36 = "while parsing a tag";
+ ;
+ yaml_parser_set_scanner_error(parser,tmp_36,start_mark,
+ "did not find expected tag URI");
+ goto error;
+ }
+ *uri = string.start;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)string.start);
+ string.end = (yaml_char_t *)0;
+ string.pointer = string.end;
+ string.start = string.pointer;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_uri_escapes(yaml_parser_t *parser, int directive,
+ yaml_mark_t start_mark,
+ yaml_string_t *string)
+{
+ int __retres;
+ int width = 0;
+ while (1) {
+ {
+ int tmp_0;
+ int tmp_4;
+ int tmp_6;
+ yaml_char_t *tmp_14;
+ int tmp_18;
+ int tmp_22;
+ int tmp_26;
+ unsigned char octet = (unsigned char)0;
+ if (parser->unread >= (size_t)3) tmp_0 = 1;
+ else tmp_0 = yaml_parser_update_buffer(parser,(unsigned long)3);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'%'))
+ if ((int)*(parser->buffer.pointer + 1) >= (int)((unsigned char)'0')) {
+ if ((int)*(parser->buffer.pointer + 1) <= (int)((unsigned char)'9'))
+ goto _LOR;
+ else goto _LAND_4;
+ }
+ else {
+ _LAND_4: ;
+ if ((int)*(parser->buffer.pointer + 1) >= (int)((unsigned char)'A')) {
+ if ((int)*(parser->buffer.pointer + 1) <= (int)((unsigned char)'F'))
+ goto _LOR;
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if ((int)*(parser->buffer.pointer + 1) >= (int)((unsigned char)'a')) {
+ if ((int)*(parser->buffer.pointer + 1) <= (int)((unsigned char)'f')) {
+ _LOR: ;
+ if ((int)*(parser->buffer.pointer + 2) >= (int)((unsigned char)'0')) {
+ if (! ((int)*(parser->buffer.pointer + 2) <= (int)((unsigned char)'9')))
+ goto _LAND_1;
+ }
+ else {
+ _LAND_1: ;
+ if ((int)*(parser->buffer.pointer + 2) >= (int)((unsigned char)'A')) {
+ if (! ((int)*(parser->buffer.pointer + 2) <= (int)((unsigned char)'F')))
+ goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(parser->buffer.pointer + 2) >= (int)((unsigned char)'a')) {
+ if (! ((int)*(parser->buffer.pointer + 2) <= (int)((unsigned char)'f')))
+ goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ }
+ }
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ }
+ else {
+ _LAND_2:
+ {
+ int tmp_2;
+ char const *tmp_1;
+ ;
+ if (directive) tmp_1 = "while parsing a %TAG directive";
+ else tmp_1 = "while parsing a tag";
+ ;
+ tmp_2 = yaml_parser_set_scanner_error(parser,tmp_1,start_mark,
+ "did not find URI escaped octet");
+ __retres = tmp_2;
+ goto return_label;
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 1) >= (int)((unsigned char)'A')) {
+ if ((int)*(parser->buffer.pointer + 1) <= (int)((unsigned char)'F'))
+ tmp_4 = ((int)*(parser->buffer.pointer + 1) - (int)((unsigned char)'A')) + 10;
+ else goto _LAND_5;
+ }
+ else {
+ int tmp_3;
+ _LAND_5:
+ if ((int)*(parser->buffer.pointer + 1) >= (int)((unsigned char)'a'))
+ if ((int)*(parser->buffer.pointer + 1) <= (int)((unsigned char)'f'))
+ tmp_3 = ((int)*(parser->buffer.pointer + 1) - (int)((unsigned char)'a')) + 10;
+ else tmp_3 = (int)*(parser->buffer.pointer + 1) - (int)((unsigned char)'0');
+ else tmp_3 = (int)*(parser->buffer.pointer + 1) - (int)((unsigned char)'0');
+ tmp_4 = tmp_3;
+ }
+ if ((int)*(parser->buffer.pointer + 2) >= (int)((unsigned char)'A')) {
+ if ((int)*(parser->buffer.pointer + 2) <= (int)((unsigned char)'F'))
+ tmp_6 = ((int)*(parser->buffer.pointer + 2) - (int)((unsigned char)'A')) + 10;
+ else goto _LAND_6;
+ }
+ else {
+ int tmp_5;
+ _LAND_6:
+ if ((int)*(parser->buffer.pointer + 2) >= (int)((unsigned char)'a'))
+ if ((int)*(parser->buffer.pointer + 2) <= (int)((unsigned char)'f'))
+ tmp_5 = ((int)*(parser->buffer.pointer + 2) - (int)((unsigned char)'a')) + 10;
+ else tmp_5 = (int)*(parser->buffer.pointer + 2) - (int)((unsigned char)'0');
+ else tmp_5 = (int)*(parser->buffer.pointer + 2) - (int)((unsigned char)'0');
+ tmp_6 = tmp_5;
+ }
+ octet = (unsigned char)((tmp_4 << 4) + tmp_6);
+ if (! width) {
+ if (((int)octet & 0x80) == 0x00) width = 1;
+ else {
+ int tmp_9;
+ if (((int)octet & 0xE0) == 0xC0) tmp_9 = 2;
+ else {
+ int tmp_8;
+ if (((int)octet & 0xF0) == 0xE0) tmp_8 = 3;
+ else {
+ int tmp_7;
+ if (((int)octet & 0xF8) == 0xF0) tmp_7 = 4; else tmp_7 = 0;
+ tmp_8 = tmp_7;
+ }
+ tmp_9 = tmp_8;
+ }
+ width = tmp_9;
+ }
+ if (! width) {
+ int tmp_11;
+ char const *tmp_10;
+ ;
+ if (directive) tmp_10 = "while parsing a %TAG directive";
+ else tmp_10 = "while parsing a tag";
+ ;
+ tmp_11 = yaml_parser_set_scanner_error(parser,tmp_10,start_mark,
+ "found an incorrect leading UTF-8 octet");
+ __retres = tmp_11;
+ goto return_label;
+ }
+ }
+ else
+ if (((int)octet & 0xC0) != 0x80) {
+ int tmp_13;
+ char const *tmp_12;
+ ;
+ if (directive) tmp_12 = "while parsing a %TAG directive";
+ else tmp_12 = "while parsing a tag";
+ ;
+ tmp_13 = yaml_parser_set_scanner_error(parser,tmp_12,start_mark,
+ "found an incorrect trailing UTF-8 octet");
+ __retres = tmp_13;
+ goto return_label;
+ }
+ tmp_14 = string->pointer;
+ (string->pointer) ++;
+ *tmp_14 = octet;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_18 = 1;
+ else {
+ int tmp_17;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_17 = 2;
+ else {
+ int tmp_16;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_16 = 3;
+ else {
+ int tmp_15;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_15 = 4;
+ else tmp_15 = 0;
+ tmp_16 = tmp_15;
+ }
+ tmp_17 = tmp_16;
+ }
+ tmp_18 = tmp_17;
+ }
+ parser->buffer.pointer += tmp_18;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_22 = 1;
+ else {
+ int tmp_21;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_21 = 2;
+ else {
+ int tmp_20;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_20 = 3;
+ else {
+ int tmp_19;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_19 = 4;
+ else tmp_19 = 0;
+ tmp_20 = tmp_19;
+ }
+ tmp_21 = tmp_20;
+ }
+ tmp_22 = tmp_21;
+ }
+ parser->buffer.pointer += tmp_22;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_26 = 1;
+ else {
+ int tmp_25;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_25 = 2;
+ else {
+ int tmp_24;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_24 = 3;
+ else {
+ int tmp_23;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_23 = 4;
+ else tmp_23 = 0;
+ tmp_24 = tmp_23;
+ }
+ tmp_25 = tmp_24;
+ }
+ tmp_26 = tmp_25;
+ }
+ parser->buffer.pointer += tmp_26;
+ }
+ width --;
+ if (! width) break;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_block_scalar(yaml_parser_t *parser,
+ yaml_token_t *token, int literal)
+{
+ int __retres;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ int tmp_0;
+ int tmp_2;
+ int tmp_4;
+ int tmp_8;
+ int tmp_10;
+ int tmp_32;
+ int tmp_51_1;
+ int tmp_53_1;
+ yaml_string_t string =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ yaml_string_t leading_break =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ yaml_string_t trailing_breaks =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ int chomping = 0;
+ int increment = 0;
+ int indent = 0;
+ int leading_blank = 0;
+ int trailing_blank = 0;
+ string.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (string.start) {
+ string.pointer = string.start;
+ string.end = string.start + 16;
+ memset((void *)string.start,0,(unsigned long)16);
+ tmp_0 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_0 = 0;
+ }
+ if (! tmp_0) goto error;
+ leading_break.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (leading_break.start) {
+ leading_break.pointer = leading_break.start;
+ leading_break.end = leading_break.start + 16;
+ memset((void *)leading_break.start,0,(unsigned long)16);
+ tmp_2 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ if (! tmp_2) goto error;
+ trailing_breaks.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (trailing_breaks.start) {
+ trailing_breaks.pointer = trailing_breaks.start;
+ trailing_breaks.end = trailing_breaks.start + 16;
+ memset((void *)trailing_breaks.start,0,(unsigned long)16);
+ tmp_4 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_4 = 0;
+ }
+ if (! tmp_4) goto error;
+ start_mark = parser->mark;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_8 = 1;
+ else {
+ int tmp_7;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_7 = 2;
+ else {
+ int tmp_6;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_6 = 3;
+ else {
+ int tmp_5;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_5 = 4;
+ else tmp_5 = 0;
+ tmp_6 = tmp_5;
+ }
+ tmp_7 = tmp_6;
+ }
+ tmp_8 = tmp_7;
+ }
+ parser->buffer.pointer += tmp_8;
+ if (parser->unread >= (size_t)1) tmp_10 = 1;
+ else tmp_10 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_10) goto error;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'+'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'-')) {
+ _LOR_0:
+ {
+ int tmp_14;
+ int tmp_16;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'+'))
+ chomping = 1;
+ else chomping = -1;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_14 = 1;
+ else {
+ int tmp_13;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_13 = 2;
+ else {
+ int tmp_12;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_12 = 3;
+ else {
+ int tmp_11;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_11 = 4;
+ else tmp_11 = 0;
+ tmp_12 = tmp_11;
+ }
+ tmp_13 = tmp_12;
+ }
+ tmp_14 = tmp_13;
+ }
+ parser->buffer.pointer += tmp_14;
+ if (parser->unread >= (size_t)1) tmp_16 = 1;
+ else tmp_16 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_16) goto error;
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'0'))
+ if ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'9')) {
+ int tmp_20;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'0')) {
+ yaml_parser_set_scanner_error(parser,
+ "while scanning a block scalar",
+ start_mark,
+ "found an indentation indicator equal to 0");
+ goto error;
+ }
+ increment = (int)*(parser->buffer.pointer + 0) - (int)((unsigned char)'0');
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_20 = 1;
+ else {
+ int tmp_19;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_19 = 2;
+ else {
+ int tmp_18;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_18 = 3;
+ else {
+ int tmp_17;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_17 = 4;
+ else tmp_17 = 0;
+ tmp_18 = tmp_17;
+ }
+ tmp_19 = tmp_18;
+ }
+ tmp_20 = tmp_19;
+ }
+ parser->buffer.pointer += tmp_20;
+ }
+ }
+ }
+ else
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'0'))
+ if ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'9')) {
+ int tmp_24;
+ int tmp_26;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'0')) {
+ yaml_parser_set_scanner_error(parser,
+ "while scanning a block scalar",
+ start_mark,
+ "found an indentation indicator equal to 0");
+ goto error;
+ }
+ increment = (int)*(parser->buffer.pointer + 0) - (int)((unsigned char)'0');
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_24 = 1;
+ else {
+ int tmp_23;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_23 = 2;
+ else {
+ int tmp_22;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_22 = 3;
+ else {
+ int tmp_21;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_21 = 4;
+ else tmp_21 = 0;
+ tmp_22 = tmp_21;
+ }
+ tmp_23 = tmp_22;
+ }
+ tmp_24 = tmp_23;
+ }
+ parser->buffer.pointer += tmp_24;
+ if (parser->unread >= (size_t)1) tmp_26 = 1;
+ else tmp_26 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_26) goto error;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'+'))
+ goto _LOR;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'-')) {
+ _LOR:
+ {
+ int tmp_30;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'+'))
+ chomping = 1;
+ else chomping = -1;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_30 = 1;
+ else {
+ int tmp_29;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_29 = 2;
+ else {
+ int tmp_28;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_28 = 3;
+ else {
+ int tmp_27;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_27 = 4;
+ else tmp_27 = 0;
+ tmp_28 = tmp_27;
+ }
+ tmp_29 = tmp_28;
+ }
+ tmp_30 = tmp_29;
+ }
+ parser->buffer.pointer += tmp_30;
+ }
+ }
+ }
+ if (parser->unread >= (size_t)1) tmp_32 = 1;
+ else tmp_32 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_32) goto error;
+ while (1) {
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')))
+ break;
+ {
+ int tmp_36;
+ int tmp_38;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_36 = 1;
+ else {
+ int tmp_35;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_35 = 2;
+ else {
+ int tmp_34;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_34 = 3;
+ else {
+ int tmp_33;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_33 = 4;
+ else tmp_33 = 0;
+ tmp_34 = tmp_33;
+ }
+ tmp_35 = tmp_34;
+ }
+ tmp_36 = tmp_35;
+ }
+ parser->buffer.pointer += tmp_36;
+ if (parser->unread >= (size_t)1) tmp_38 = 1;
+ else tmp_38 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_38) goto error;
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'#'))
+ while (1) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ break;
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ break;
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ _LAND_2: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251'))
+ break;
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000'))
+ break;
+ }
+ }
+ }
+ {
+ int tmp_42;
+ int tmp_44;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_42 = 1;
+ else {
+ int tmp_41;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_41 = 2;
+ else {
+ int tmp_40;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_40 = 3;
+ else {
+ int tmp_39;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_39 = 4;
+ else tmp_39 = 0;
+ tmp_40 = tmp_39;
+ }
+ tmp_41 = tmp_40;
+ }
+ tmp_42 = tmp_41;
+ }
+ parser->buffer.pointer += tmp_42;
+ if (parser->unread >= (size_t)1) tmp_44 = 1;
+ else tmp_44 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_44) goto error;
+ }
+ }
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')))
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205')))
+ goto _LAND_8;
+ }
+ else {
+ _LAND_8: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250')))
+ goto _LAND_7;
+ }
+ else goto _LAND_7;
+ }
+ else {
+ _LAND_7: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')))
+ goto _LAND_5;
+ }
+ else goto _LAND_5;
+ }
+ else {
+ _LAND_5: ;
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000'))) {
+ yaml_parser_set_scanner_error(parser,
+ "while scanning a block scalar",
+ start_mark,
+ "did not find expected comment or line break");
+ goto error;
+ }
+ }
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_2;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ goto _LOR_2;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_2;
+ else goto _LAND_15;
+ }
+ else {
+ _LAND_15: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_2;
+ else goto _LAND_14;
+ }
+ else goto _LAND_14;
+ }
+ else {
+ _LAND_14: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200'))
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')) {
+ _LOR_2:
+ {
+ int tmp_46;
+ if (parser->unread >= (size_t)2) tmp_46 = 1;
+ else tmp_46 = yaml_parser_update_buffer(parser,
+ (unsigned long)2);
+ if (! tmp_46) goto error;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\n')) {
+ parser->mark.index += (size_t)2;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)2;
+ parser->buffer.pointer += 2;
+ yaml_char_t *tmp_53 = parser->buffer.pointer;
+ }
+ else goto _LAND_12;
+ }
+ else {
+ _LAND_12: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_1;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ goto _LOR_1;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_1;
+ else goto _LAND_11;
+ }
+ else {
+ _LAND_11: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_1;
+ else goto _LAND_10;
+ }
+ else goto _LAND_10;
+ }
+ else {
+ _LAND_10: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200'))
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')) {
+ int tmp_50;
+ _LOR_1: parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_50 = 1;
+ else {
+ int tmp_49;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_49 = 2;
+ else {
+ int tmp_48;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_48 = 3;
+ else {
+ int tmp_47;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_47 = 4;
+ else tmp_47 = 0;
+ tmp_48 = tmp_47;
+ }
+ tmp_49 = tmp_48;
+ }
+ tmp_50 = tmp_49;
+ }
+ parser->buffer.pointer += tmp_50;
+ yaml_char_t *tmp_51 =
+ parser->buffer.pointer;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ end_mark = parser->mark;
+ if (increment)
+ if (parser->indent >= 0) indent = parser->indent + increment;
+ else indent = increment;
+ tmp_51_1 = yaml_parser_scan_block_scalar_breaks(parser,& indent,
+ & trailing_breaks,
+ start_mark,& end_mark);
+ if (! tmp_51_1) goto error;
+ if (parser->unread >= (size_t)1) tmp_53_1 = 1;
+ else tmp_53_1 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_53_1) goto error;
+ while (1) {
+ if ((int)parser->mark.column == indent) {
+ if (! (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000'))))
+ break;
+ }
+ else break;
+ {
+ int tmp_54;
+ int tmp_61;
+ int tmp_60;
+ int tmp_62;
+ int tmp_89_0;
+ int tmp_101_0;
+ int tmp_91_0;
+ int tmp_102;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' '))
+ tmp_54 = 1;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t'))
+ tmp_54 = 1;
+ else tmp_54 = 0;
+ trailing_blank = tmp_54;
+ if (! literal) {
+ if ((int)*(leading_break.start) == '\n') {
+ if (! leading_blank) {
+ if (! trailing_blank) {
+ if ((int)*(trailing_breaks.start) == '\000') {
+ int tmp_56;
+ yaml_char_t *tmp_57;
+ if (string.pointer + 5 < string.end) tmp_56 = 1;
+ else {
+ int tmp_55;
+ tmp_55 = yaml_string_extend(& string.start,
+ & string.pointer,& string.end);
+ if (tmp_55) tmp_56 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_56 = 0;
+ }
+ }
+ if (! tmp_56) goto error;
+ tmp_57 = string.pointer;
+ (string.pointer) ++;
+ *tmp_57 = (unsigned char)' ';
+ }
+ leading_break.pointer = leading_break.start;
+ memset((void *)leading_break.start,0,
+ (unsigned long)(leading_break.end - leading_break.start));
+ }
+ else goto _LAND_18;
+ }
+ else goto _LAND_18;
+ }
+ else goto _LAND_18;
+ }
+ else {
+ _LAND_18:
+ {
+ int tmp_59;
+ int tmp_58;
+ tmp_58 = yaml_string_join(& string.start,& string.pointer,
+ & string.end,& leading_break.start,
+ & leading_break.pointer,
+ & leading_break.end);
+ if (tmp_58) {
+ leading_break.pointer = leading_break.start;
+ tmp_59 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_59 = 0;
+ }
+ if (! tmp_59) goto error;
+ leading_break.pointer = leading_break.start;
+ memset((void *)leading_break.start,0,
+ (unsigned long)(leading_break.end - leading_break.start));
+ }
+ }
+ tmp_60 = yaml_string_join(& string.start,& string.pointer,& string.end,
+ & trailing_breaks.start,
+ & trailing_breaks.pointer,
+ & trailing_breaks.end);
+ if (tmp_60) {
+ trailing_breaks.pointer = trailing_breaks.start;
+ tmp_61 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_61 = 0;
+ }
+ if (! tmp_61) goto error;
+ trailing_breaks.pointer = trailing_breaks.start;
+ memset((void *)trailing_breaks.start,0,
+ (unsigned long)(trailing_breaks.end - trailing_breaks.start));
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' '))
+ tmp_62 = 1;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t'))
+ tmp_62 = 1;
+ else tmp_62 = 0;
+ leading_blank = tmp_62;
+ while (1) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ break;
+ else goto _LAND_23;
+ }
+ else {
+ _LAND_23: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ break;
+ else goto _LAND_22;
+ }
+ else goto _LAND_22;
+ }
+ else {
+ _LAND_22: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251'))
+ break;
+ else goto _LAND_20;
+ }
+ else goto _LAND_20;
+ }
+ else {
+ _LAND_20: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000'))
+ break;
+ }
+ }
+ }
+ {
+ int tmp_85_0;
+ int tmp_64;
+ int tmp_87_0;
+ if (string.pointer + 5 < string.end) tmp_64 = 1;
+ else {
+ int tmp_63;
+ tmp_63 = yaml_string_extend(& string.start,& string.pointer,
+ & string.end);
+ if (tmp_63) tmp_64 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_64 = 0;
+ }
+ }
+ if (tmp_64) {
+ if (((int)*(parser->buffer.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_65;
+ yaml_char_t *tmp_66;
+ tmp_65 = string.pointer;
+ (string.pointer) ++;
+ tmp_66 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_65 = *tmp_66;
+ yaml_char_t tmp_91 = *tmp_65;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_67;
+ yaml_char_t *tmp_68;
+ yaml_char_t *tmp_69;
+ yaml_char_t *tmp_70;
+ tmp_67 = string.pointer;
+ (string.pointer) ++;
+ tmp_68 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_67 = *tmp_68;
+ tmp_69 = string.pointer;
+ (string.pointer) ++;
+ tmp_70 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_69 = *tmp_70;
+ yaml_char_t tmp_89 = *tmp_69;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_71;
+ yaml_char_t *tmp_72;
+ yaml_char_t *tmp_73;
+ yaml_char_t *tmp_74;
+ yaml_char_t *tmp_75;
+ yaml_char_t *tmp_76;
+ tmp_71 = string.pointer;
+ (string.pointer) ++;
+ tmp_72 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_71 = *tmp_72;
+ tmp_73 = string.pointer;
+ (string.pointer) ++;
+ tmp_74 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_73 = *tmp_74;
+ tmp_75 = string.pointer;
+ (string.pointer) ++;
+ tmp_76 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_75 = *tmp_76;
+ yaml_char_t tmp_87 = *tmp_75;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_77;
+ yaml_char_t *tmp_78;
+ yaml_char_t *tmp_79;
+ yaml_char_t *tmp_80;
+ yaml_char_t *tmp_81;
+ yaml_char_t *tmp_82;
+ yaml_char_t *tmp_83;
+ yaml_char_t *tmp_84;
+ tmp_77 = string.pointer;
+ (string.pointer) ++;
+ tmp_78 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_77 = *tmp_78;
+ tmp_79 = string.pointer;
+ (string.pointer) ++;
+ tmp_80 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_79 = *tmp_80;
+ tmp_81 = string.pointer;
+ (string.pointer) ++;
+ tmp_82 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_81 = *tmp_82;
+ tmp_83 = string.pointer;
+ (string.pointer) ++;
+ tmp_84 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_83 = *tmp_84;
+ yaml_char_t tmp_85 = *tmp_83;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ tmp_85_0 = 1;
+ }
+ else tmp_85_0 = 0;
+ if (! tmp_85_0) goto error;
+ if (parser->unread >= (size_t)1) tmp_87_0 = 1;
+ else tmp_87_0 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_87_0) goto error;
+ }
+ }
+ if (parser->unread >= (size_t)2) tmp_89_0 = 1;
+ else tmp_89_0 = yaml_parser_update_buffer(parser,(unsigned long)2);
+ if (! tmp_89_0) goto error;
+ if (leading_break.pointer + 5 < leading_break.end) tmp_91_0 = 1;
+ else {
+ int tmp_90;
+ tmp_90 = yaml_string_extend(& leading_break.start,
+ & leading_break.pointer,
+ & leading_break.end);
+ if (tmp_90) tmp_91_0 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_91_0 = 0;
+ }
+ }
+ if (tmp_91_0) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\n')) {
+ yaml_char_t *tmp_92;
+ tmp_92 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ *tmp_92 = (unsigned char)'\n';
+ parser->buffer.pointer += 2;
+ parser->mark.index += (size_t)2;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)2;
+ size_t tmp_107 = parser->unread;
+ }
+ else goto _LAND_25;
+ }
+ else {
+ _LAND_25: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_4;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')) {
+ yaml_char_t *tmp_93;
+ _LOR_4:
+ { /* sequence */
+ tmp_93 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ *tmp_93 = (unsigned char)'\n';
+ }
+ (parser->buffer.pointer) ++;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_105 = parser->unread;
+ }
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\205')) {
+ yaml_char_t *tmp_94;
+ tmp_94 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ *tmp_94 = (unsigned char)'\n';
+ parser->buffer.pointer += 2;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_103 = parser->unread;
+ }
+ else goto _LAND_24;
+ }
+ else {
+ _LAND_24: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\200'))
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'\250'))
+ goto _LOR_3;
+ else
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'\251')) {
+ yaml_char_t *tmp_95;
+ yaml_char_t *tmp_96;
+ yaml_char_t *tmp_97;
+ yaml_char_t *tmp_98;
+ yaml_char_t *tmp_99;
+ yaml_char_t *tmp_100;
+ _LOR_3:
+ { /* sequence */
+ tmp_95 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ tmp_96 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_95 = *tmp_96;
+ }
+ tmp_97 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ tmp_98 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_97 = *tmp_98;
+ tmp_99 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ tmp_100 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_99 = *tmp_100;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_101 = parser->unread;
+ }
+ }
+ }
+ tmp_101_0 = 1;
+ }
+ else tmp_101_0 = 0;
+ if (! tmp_101_0) goto error;
+ tmp_102 = yaml_parser_scan_block_scalar_breaks(parser,& indent,
+ & trailing_breaks,
+ start_mark,& end_mark);
+ if (! tmp_102) goto error;
+ }
+ }
+ if (chomping != -1) {
+ int tmp_104;
+ int tmp_103_0;
+ tmp_103_0 = yaml_string_join(& string.start,& string.pointer,
+ & string.end,& leading_break.start,
+ & leading_break.pointer,& leading_break.end);
+ if (tmp_103_0) {
+ leading_break.pointer = leading_break.start;
+ tmp_104 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_104 = 0;
+ }
+ if (! tmp_104) goto error;
+ }
+ if (chomping == 1) {
+ int tmp_106;
+ int tmp_105_0;
+ tmp_105_0 = yaml_string_join(& string.start,& string.pointer,
+ & string.end,& trailing_breaks.start,
+ & trailing_breaks.pointer,
+ & trailing_breaks.end);
+ if (tmp_105_0) {
+ trailing_breaks.pointer = trailing_breaks.start;
+ tmp_106 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_106 = 0;
+ }
+ if (! tmp_106) goto error;
+ }
+ memset((void *)token,0,sizeof(yaml_token_t));
+ token->type = YAML_SCALAR_TOKEN;
+ token->start_mark = start_mark;
+ token->end_mark = end_mark;
+ token->data.scalar.value = string.start;
+ token->data.scalar.length = (unsigned long)(string.pointer - string.start);
+ if (literal) token->data.scalar.style = YAML_LITERAL_SCALAR_STYLE;
+ else token->data.scalar.style = YAML_FOLDED_SCALAR_STYLE;
+ yaml_free((void *)leading_break.start);
+ leading_break.end = (yaml_char_t *)0;
+ leading_break.pointer = leading_break.end;
+ leading_break.start = leading_break.pointer;
+ yaml_free((void *)trailing_breaks.start);
+ trailing_breaks.end = (yaml_char_t *)0;
+ trailing_breaks.pointer = trailing_breaks.end;
+ trailing_breaks.start = trailing_breaks.pointer;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)string.start);
+ string.end = (yaml_char_t *)0;
+ string.pointer = string.end;
+ string.start = string.pointer;
+ yaml_free((void *)leading_break.start);
+ leading_break.end = (yaml_char_t *)0;
+ leading_break.pointer = leading_break.end;
+ leading_break.start = leading_break.pointer;
+ yaml_free((void *)trailing_breaks.start);
+ trailing_breaks.end = (yaml_char_t *)0;
+ trailing_breaks.pointer = trailing_breaks.end;
+ trailing_breaks.start = trailing_breaks.pointer;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_block_scalar_breaks(yaml_parser_t *parser,
+ int *indent,
+ yaml_string_t *breaks,
+ yaml_mark_t start_mark,
+ yaml_mark_t *end_mark)
+{
+ int __retres;
+ int max_indent = 0;
+ *end_mark = parser->mark;
+ while (1) {
+ {
+ int tmp_0;
+ int tmp_9;
+ int tmp_21_1;
+ int tmp_11;
+ if (parser->unread >= (size_t)1) tmp_0 = 1;
+ else tmp_0 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ while (1) {
+ if (! *indent) goto _LOR;
+ else
+ if ((int)parser->mark.column < *indent) {
+ _LOR: ;
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ break;
+ }
+ else break;
+ {
+ int tmp_4;
+ int tmp_6;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_4 = 1;
+ else {
+ int tmp_3;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_3 = 2;
+ else {
+ int tmp_2;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_2 = 3;
+ else {
+ int tmp_1;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_1 = 4;
+ else tmp_1 = 0;
+ tmp_2 = tmp_1;
+ }
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ parser->buffer.pointer += tmp_4;
+ if (parser->unread >= (size_t)1) tmp_6 = 1;
+ else tmp_6 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_6) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ if ((int)parser->mark.column > max_indent) max_indent = (int)parser->mark.column;
+ if (! *indent) goto _LOR_0;
+ else
+ if ((int)parser->mark.column < *indent) {
+ _LOR_0: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')) {
+ int tmp_7;
+ tmp_7 = yaml_parser_set_scanner_error(parser,
+ "while scanning a block scalar",
+ start_mark,
+ "found a tab character where an indentation space is expected");
+ __retres = tmp_7;
+ goto return_label;
+ }
+ }
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')))
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205')))
+ goto _LAND_1;
+ }
+ else {
+ _LAND_1: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250')))
+ goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')))
+ break;
+ }
+ else break;
+ else break;
+ }
+ }
+ if (parser->unread >= (size_t)2) tmp_9 = 1;
+ else tmp_9 = yaml_parser_update_buffer(parser,(unsigned long)2);
+ if (! tmp_9) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (breaks->pointer + 5 < breaks->end) tmp_11 = 1;
+ else {
+ int tmp_10;
+ tmp_10 = yaml_string_extend(& breaks->start,& breaks->pointer,
+ & breaks->end);
+ if (tmp_10) tmp_11 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_11 = 0;
+ }
+ }
+ if (tmp_11) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\n')) {
+ yaml_char_t *tmp_12;
+ tmp_12 = breaks->pointer;
+ (breaks->pointer) ++;
+ *tmp_12 = (unsigned char)'\n';
+ parser->buffer.pointer += 2;
+ parser->mark.index += (size_t)2;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)2;
+ size_t tmp_27 = parser->unread;
+ }
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_2;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')) {
+ yaml_char_t *tmp_13;
+ _LOR_2:
+ { /* sequence */
+ tmp_13 = breaks->pointer;
+ (breaks->pointer) ++;
+ *tmp_13 = (unsigned char)'\n';
+ }
+ (parser->buffer.pointer) ++;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_25 = parser->unread;
+ }
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\205')) {
+ yaml_char_t *tmp_14;
+ tmp_14 = breaks->pointer;
+ (breaks->pointer) ++;
+ *tmp_14 = (unsigned char)'\n';
+ parser->buffer.pointer += 2;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_23 = parser->unread;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ _LAND_2: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\200'))
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'\250'))
+ goto _LOR_1;
+ else
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'\251')) {
+ yaml_char_t *tmp_15;
+ yaml_char_t *tmp_16;
+ yaml_char_t *tmp_17;
+ yaml_char_t *tmp_18;
+ yaml_char_t *tmp_19;
+ yaml_char_t *tmp_20;
+ _LOR_1:
+ { /* sequence */
+ tmp_15 = breaks->pointer;
+ (breaks->pointer) ++;
+ tmp_16 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_15 = *tmp_16;
+ }
+ tmp_17 = breaks->pointer;
+ (breaks->pointer) ++;
+ tmp_18 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_17 = *tmp_18;
+ tmp_19 = breaks->pointer;
+ (breaks->pointer) ++;
+ tmp_20 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_19 = *tmp_20;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_21 = parser->unread;
+ }
+ }
+ }
+ tmp_21_1 = 1;
+ }
+ else tmp_21_1 = 0;
+ if (! tmp_21_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ *end_mark = parser->mark;
+ }
+ }
+ if (! *indent) {
+ *indent = max_indent;
+ if (*indent < parser->indent + 1) *indent = parser->indent + 1;
+ if (*indent < 1) *indent = 1;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_flow_scalar(yaml_parser_t *parser,
+ yaml_token_t *token, int single)
+{
+ int __retres;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ int leading_blanks;
+ int tmp_0;
+ int tmp_2;
+ int tmp_4;
+ int tmp_6;
+ int tmp_10;
+ int tmp_187;
+ yaml_string_t string =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ yaml_string_t leading_break =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ yaml_string_t trailing_breaks =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ yaml_string_t whitespaces =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ string.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (string.start) {
+ string.pointer = string.start;
+ string.end = string.start + 16;
+ memset((void *)string.start,0,(unsigned long)16);
+ tmp_0 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_0 = 0;
+ }
+ if (! tmp_0) goto error;
+ leading_break.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (leading_break.start) {
+ leading_break.pointer = leading_break.start;
+ leading_break.end = leading_break.start + 16;
+ memset((void *)leading_break.start,0,(unsigned long)16);
+ tmp_2 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ if (! tmp_2) goto error;
+ trailing_breaks.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (trailing_breaks.start) {
+ trailing_breaks.pointer = trailing_breaks.start;
+ trailing_breaks.end = trailing_breaks.start + 16;
+ memset((void *)trailing_breaks.start,0,(unsigned long)16);
+ tmp_4 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_4 = 0;
+ }
+ if (! tmp_4) goto error;
+ whitespaces.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (whitespaces.start) {
+ whitespaces.pointer = whitespaces.start;
+ whitespaces.end = whitespaces.start + 16;
+ memset((void *)whitespaces.start,0,(unsigned long)16);
+ tmp_6 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_6 = 0;
+ }
+ if (! tmp_6) goto error;
+ start_mark = parser->mark;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_10 = 1;
+ else {
+ int tmp_9;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_9 = 2;
+ else {
+ int tmp_8;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_8 = 3;
+ else {
+ int tmp_7;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_7 = 4;
+ else tmp_7 = 0;
+ tmp_8 = tmp_7;
+ }
+ tmp_9 = tmp_8;
+ }
+ tmp_10 = tmp_9;
+ }
+ parser->buffer.pointer += tmp_10;
+ while (1) {
+ {
+ int tmp_12;
+ int tmp_14;
+ int tmp_114;
+ int tmp_115_0;
+ int tmp_117;
+ if (parser->unread >= (size_t)4) tmp_12 = 1;
+ else tmp_12 = yaml_parser_update_buffer(parser,(unsigned long)4);
+ if (! tmp_12) goto error;
+ if (parser->mark.column == (size_t)0)
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'-')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'-')) {
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'-'))
+ goto _LOR_1;
+ else goto _LAND_5;
+ }
+ else goto _LAND_5;
+ }
+ else {
+ _LAND_5: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'.'))
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'.'))
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'.')) {
+ _LOR_1: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)' '))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\t'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\r'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\n'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (3 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_0;
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (3 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (3 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_0;
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ _LAND_2: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (3 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (3 + 2)) == (int)((unsigned char)'\251'))
+ goto _LOR_0;
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\000')) {
+ _LOR_0:
+ {
+ yaml_parser_set_scanner_error(parser,
+ "while scanning a quoted scalar",
+ start_mark,
+ "found unexpected document indicator");
+ goto error;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000')) {
+ yaml_parser_set_scanner_error(parser,
+ "while scanning a quoted scalar",
+ start_mark,
+ "found unexpected end of stream");
+ goto error;
+ }
+ if (parser->unread >= (size_t)2) tmp_14 = 1;
+ else tmp_14 = yaml_parser_update_buffer(parser,(unsigned long)2);
+ if (! tmp_14) goto error;
+ leading_blanks = 0;
+ while (1) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' '))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ break;
+ else goto _LAND_27;
+ }
+ else {
+ _LAND_27: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ break;
+ else goto _LAND_26;
+ }
+ else goto _LAND_26;
+ }
+ else {
+ _LAND_26: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251'))
+ break;
+ else goto _LAND_24;
+ }
+ else goto _LAND_24;
+ }
+ else {
+ _LAND_24: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000'))
+ break;
+ }
+ }
+ }
+ {
+ int tmp_112;
+ if (single) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\'')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\'')) {
+ int tmp_16;
+ yaml_char_t *tmp_17;
+ int tmp_21;
+ int tmp_25;
+ if (string.pointer + 5 < string.end) tmp_16 = 1;
+ else {
+ int tmp_15;
+ tmp_15 = yaml_string_extend(& string.start,
+ & string.pointer,& string.end);
+ if (tmp_15) tmp_16 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_16 = 0;
+ }
+ }
+ if (! tmp_16) goto error;
+ tmp_17 = string.pointer;
+ (string.pointer) ++;
+ *tmp_17 = (unsigned char)'\'';
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_21 = 1;
+ else {
+ int tmp_20;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_20 = 2;
+ else {
+ int tmp_19;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_19 = 3;
+ else {
+ int tmp_18;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_18 = 4;
+ else tmp_18 = 0;
+ tmp_19 = tmp_18;
+ }
+ tmp_20 = tmp_19;
+ }
+ tmp_21 = tmp_20;
+ }
+ parser->buffer.pointer += tmp_21;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_25 = 1;
+ else {
+ int tmp_24;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_24 = 2;
+ else {
+ int tmp_23;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_23 = 3;
+ else {
+ int tmp_22;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_22 = 4;
+ else tmp_22 = 0;
+ tmp_23 = tmp_22;
+ }
+ tmp_24 = tmp_23;
+ }
+ tmp_25 = tmp_24;
+ }
+ parser->buffer.pointer += tmp_25;
+ }
+ else goto _LAND_22;
+ }
+ else goto _LAND_22;
+ }
+ else {
+ int tmp_110;
+ _LAND_22:
+ { /* sequence */
+ if (single) tmp_110 = '\''; else tmp_110 = '\"';
+ ;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)tmp_110))
+ break;
+ else
+ if (! single) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\\')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\r'))
+ goto _LOR_4;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\n'))
+ goto _LOR_4;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_4;
+ else goto _LAND_19;
+ }
+ else {
+ _LAND_19: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (1 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_4;
+ else goto _LAND_18;
+ }
+ else goto _LAND_18;
+ }
+ else {
+ _LAND_18: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (1 + 2)) == (int)((unsigned char)'\251')) {
+ _LOR_4:
+ {
+ int tmp_27;
+ int tmp_31;
+ if (parser->unread >= (size_t)3) tmp_27 = 1;
+ else tmp_27 = yaml_parser_update_buffer
+ (parser,(unsigned long)3);
+ if (! tmp_27) goto error;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_31 = 1;
+ else {
+ int tmp_30;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_30 = 2;
+ else {
+ int tmp_29;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_29 = 3;
+ else {
+ int tmp_28;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_28 = 4;
+ else tmp_28 = 0;
+ tmp_29 = tmp_28;
+ }
+ tmp_30 = tmp_29;
+ }
+ tmp_31 = tmp_30;
+ }
+ parser->buffer.pointer += tmp_31;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')) {
+ if ((int)*(parser->buffer.pointer + (
+ 0 + 1)) == (int)((unsigned char)'\n')) {
+ parser->mark.index += (size_t)2;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)2;
+ parser->buffer.pointer += 2;
+ yaml_char_t *tmp_38 =
+ parser->buffer.pointer;
+ }
+ else goto _LAND_9;
+ }
+ else {
+ _LAND_9: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_2;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ goto _LOR_2;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (
+ 0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_2;
+ else goto _LAND_8;
+ }
+ else {
+ _LAND_8: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (
+ 0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (
+ 0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_2;
+ else goto _LAND_7;
+ }
+ else goto _LAND_7;
+ }
+ else {
+ _LAND_7: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + (
+ 0 + 1)) == (int)((unsigned char)'\200'))
+ if ((int)*(parser->buffer.pointer + (
+ 0 + 2)) == (int)((unsigned char)'\251')) {
+ int tmp_35;
+ _LOR_2:
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_35 = 1;
+ else {
+ int tmp_34;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_34 = 2;
+ else {
+ int tmp_33;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_33 = 3;
+ else {
+ int tmp_32;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_32 = 4;
+ else tmp_32 = 0;
+ tmp_33 = tmp_32;
+ }
+ tmp_34 = tmp_33;
+ }
+ tmp_35 = tmp_34;
+ }
+ parser->buffer.pointer += tmp_35;
+ yaml_char_t *tmp_36 =
+ parser->buffer.pointer;
+ }
+ }
+ }
+ }
+ leading_blanks = 1;
+ break;
+ }
+ }
+ else goto _LAND_20;
+ }
+ else goto _LAND_20;
+ }
+ else goto _LAND_20;
+ }
+ }
+ }
+ else goto _LAND_20;
+ }
+ else
+ _LAND_20:
+ if (! single) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\\')) {
+ int tmp_37;
+ int tmp_64;
+ int tmp_68;
+ size_t code_length = (unsigned long)0;
+ if (string.pointer + 5 < string.end) tmp_37 = 1;
+ else {
+ int tmp_36_1;
+ tmp_36_1 = yaml_string_extend(& string.start,
+ & string.pointer,
+ & string.end);
+ if (tmp_36_1) tmp_37 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_37 = 0;
+ }
+ }
+ if (! tmp_37) goto error;
+ switch ((int)*(parser->buffer.pointer + 1)) {
+ yaml_char_t *tmp_38_1;
+ yaml_char_t *tmp_39;
+ yaml_char_t *tmp_40;
+ yaml_char_t *tmp_41;
+ yaml_char_t *tmp_42;
+ yaml_char_t *tmp_43;
+ yaml_char_t *tmp_44;
+ yaml_char_t *tmp_45;
+ yaml_char_t *tmp_46;
+ yaml_char_t *tmp_47;
+ yaml_char_t *tmp_48;
+ yaml_char_t *tmp_49;
+ yaml_char_t *tmp_50;
+ yaml_char_t *tmp_51;
+ yaml_char_t *tmp_52;
+ yaml_char_t *tmp_53;
+ yaml_char_t *tmp_54;
+ yaml_char_t *tmp_55;
+ yaml_char_t *tmp_56;
+ yaml_char_t *tmp_57;
+ yaml_char_t *tmp_58;
+ yaml_char_t *tmp_59;
+ yaml_char_t *tmp_60;
+ case '0':
+ { /* sequence */
+ tmp_38_1 = string.pointer;
+ (string.pointer) ++;
+ *tmp_38_1 = (unsigned char)'\000';
+ }
+ break;
+ case 'a':
+ { /* sequence */
+ tmp_39 = string.pointer;
+ (string.pointer) ++;
+ *tmp_39 = (unsigned char)'\a';
+ }
+ break;
+ case 'b':
+ { /* sequence */
+ tmp_40 = string.pointer;
+ (string.pointer) ++;
+ *tmp_40 = (unsigned char)'\b';
+ }
+ break;
+ case 't': case '\t':
+ { /* sequence */
+ tmp_41 = string.pointer;
+ (string.pointer) ++;
+ *tmp_41 = (unsigned char)'\t';
+ }
+ break;
+ case 'n':
+ { /* sequence */
+ tmp_42 = string.pointer;
+ (string.pointer) ++;
+ *tmp_42 = (unsigned char)'\n';
+ }
+ break;
+ case 'v':
+ { /* sequence */
+ tmp_43 = string.pointer;
+ (string.pointer) ++;
+ *tmp_43 = (unsigned char)'\v';
+ }
+ break;
+ case 'f':
+ { /* sequence */
+ tmp_44 = string.pointer;
+ (string.pointer) ++;
+ *tmp_44 = (unsigned char)'\f';
+ }
+ break;
+ case 'r':
+ { /* sequence */
+ tmp_45 = string.pointer;
+ (string.pointer) ++;
+ *tmp_45 = (unsigned char)'\r';
+ }
+ break;
+ case 'e':
+ { /* sequence */
+ tmp_46 = string.pointer;
+ (string.pointer) ++;
+ *tmp_46 = (unsigned char)'\033';
+ }
+ break;
+ case ' ':
+ { /* sequence */
+ tmp_47 = string.pointer;
+ (string.pointer) ++;
+ *tmp_47 = (unsigned char)' ';
+ }
+ break;
+ case '\"':
+ { /* sequence */
+ tmp_48 = string.pointer;
+ (string.pointer) ++;
+ *tmp_48 = (unsigned char)'\"';
+ }
+ break;
+ case '/':
+ { /* sequence */
+ tmp_49 = string.pointer;
+ (string.pointer) ++;
+ *tmp_49 = (unsigned char)'/';
+ }
+ break;
+ case '\\':
+ { /* sequence */
+ tmp_50 = string.pointer;
+ (string.pointer) ++;
+ *tmp_50 = (unsigned char)'\\';
+ }
+ break;
+ case 'N':
+ { /* sequence */
+ tmp_51 = string.pointer;
+ (string.pointer) ++;
+ *tmp_51 = (unsigned char)'\302';
+ }
+ tmp_52 = string.pointer;
+ (string.pointer) ++;
+ *tmp_52 = (unsigned char)'\205';
+ break;
+ case '_':
+ { /* sequence */
+ tmp_53 = string.pointer;
+ (string.pointer) ++;
+ *tmp_53 = (unsigned char)'\302';
+ }
+ tmp_54 = string.pointer;
+ (string.pointer) ++;
+ *tmp_54 = (unsigned char)'\240';
+ break;
+ case 'L':
+ { /* sequence */
+ tmp_55 = string.pointer;
+ (string.pointer) ++;
+ *tmp_55 = (unsigned char)'\342';
+ }
+ tmp_56 = string.pointer;
+ (string.pointer) ++;
+ *tmp_56 = (unsigned char)'\200';
+ tmp_57 = string.pointer;
+ (string.pointer) ++;
+ *tmp_57 = (unsigned char)'\250';
+ break;
+ case 'P':
+ { /* sequence */
+ tmp_58 = string.pointer;
+ (string.pointer) ++;
+ *tmp_58 = (unsigned char)'\342';
+ }
+ tmp_59 = string.pointer;
+ (string.pointer) ++;
+ *tmp_59 = (unsigned char)'\200';
+ tmp_60 = string.pointer;
+ (string.pointer) ++;
+ *tmp_60 = (unsigned char)'\251';
+ break;
+ case 'x': code_length = (unsigned long)2;
+ break;
+ case 'u': code_length = (unsigned long)4;
+ break;
+ case 'U': code_length = (unsigned long)8;
+ break;
+ default:
+ yaml_parser_set_scanner_error(parser,
+ "while parsing a quoted scalar",
+ start_mark,
+ "found unknown escape character");
+ goto error;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_64 = 1;
+ else {
+ int tmp_63;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_63 = 2;
+ else {
+ int tmp_62;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_62 = 3;
+ else {
+ int tmp_61;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_61 = 4;
+ else tmp_61 = 0;
+ tmp_62 = tmp_61;
+ }
+ tmp_63 = tmp_62;
+ }
+ tmp_64 = tmp_63;
+ }
+ parser->buffer.pointer += tmp_64;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_68 = 1;
+ else {
+ int tmp_67;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_67 = 2;
+ else {
+ int tmp_66;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_66 = 3;
+ else {
+ int tmp_65;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_65 = 4;
+ else tmp_65 = 0;
+ tmp_66 = tmp_65;
+ }
+ tmp_67 = tmp_66;
+ }
+ tmp_68 = tmp_67;
+ }
+ parser->buffer.pointer += tmp_68;
+ if (code_length) {
+ size_t k;
+ int tmp_70;
+ unsigned int value = (unsigned int)0;
+ if (parser->unread >= code_length) tmp_70 = 1;
+ else tmp_70 = yaml_parser_update_buffer(parser,
+ code_length);
+ if (! tmp_70) goto error;
+ k = (unsigned long)0;
+ while (k < code_length) {
+ {
+ int tmp_72;
+ if ((int)*(parser->buffer.pointer + k) >= (int)((unsigned char)'0')) {
+ if (! ((int)*(parser->buffer.pointer + k) <= (int)((unsigned char)'9')))
+ goto _LAND_12;
+ }
+ else {
+ _LAND_12: ;
+ if ((int)*(parser->buffer.pointer + k) >= (int)((unsigned char)'A')) {
+ if (! ((int)*(parser->buffer.pointer + k) <= (int)((unsigned char)'F')))
+ goto _LAND_11;
+ }
+ else {
+ _LAND_11: ;
+ if ((int)*(parser->buffer.pointer + k) >= (int)((unsigned char)'a')) {
+ if (! ((int)*(parser->buffer.pointer + k) <= (int)((unsigned char)'f')))
+ goto _LAND_10;
+ }
+ else {
+ _LAND_10:
+ {
+ yaml_parser_set_scanner_error(parser,
+ "while parsing a quoted scalar",
+ start_mark,
+ "did not find expected hexdecimal number");
+ goto error;
+ }
+ }
+ }
+ }
+ if ((int)*(parser->buffer.pointer + k) >= (int)((unsigned char)'A')) {
+ if ((int)*(parser->buffer.pointer + k) <= (int)((unsigned char)'F'))
+ tmp_72 = ((int)*(parser->buffer.pointer + k) - (int)((unsigned char)'A')) + 10;
+ else goto _LAND_13;
+ }
+ else {
+ int tmp_71;
+ _LAND_13:
+ if ((int)*(parser->buffer.pointer + k) >= (int)((unsigned char)'a'))
+ if ((int)*(parser->buffer.pointer + k) <= (int)((unsigned char)'f'))
+ tmp_71 = ((int)*(parser->buffer.pointer + k) - (int)((unsigned char)'a')) + 10;
+ else tmp_71 = (int)*(parser->buffer.pointer + k) - (int)((unsigned char)'0');
+ else tmp_71 = (int)*(parser->buffer.pointer + k) - (int)((unsigned char)'0');
+ tmp_72 = tmp_71;
+ }
+ value = (value << 4) + (unsigned int)tmp_72;
+ }
+ k += (size_t)1;
+ }
+ if (value >= (unsigned int)0xD800) {
+ if (value <= (unsigned int)0xDFFF) goto _LOR_3;
+ else goto _LAND_14;
+ }
+ else {
+ _LAND_14: ;
+ if (value > (unsigned int)0x10FFFF) {
+ _LOR_3:
+ {
+ yaml_parser_set_scanner_error(parser,
+ "while parsing a quoted scalar",
+ start_mark,
+ "found invalid Unicode character escape code");
+ goto error;
+ }
+ }
+ }
+ if (value <= (unsigned int)0x7F) {
+ yaml_char_t *tmp_73;
+ tmp_73 = string.pointer;
+ (string.pointer) ++;
+ *tmp_73 = (unsigned char)value;
+ }
+ else
+ if (value <= (unsigned int)0x7FF) {
+ yaml_char_t *tmp_74;
+ yaml_char_t *tmp_75;
+ tmp_74 = string.pointer;
+ (string.pointer) ++;
+ *tmp_74 = (unsigned char)((unsigned int)0xC0 + (
+ value >> 6));
+ tmp_75 = string.pointer;
+ (string.pointer) ++;
+ *tmp_75 = (unsigned char)((unsigned int)0x80 + (
+ value & (unsigned int)0x3F));
+ }
+ else
+ if (value <= (unsigned int)0xFFFF) {
+ yaml_char_t *tmp_76;
+ yaml_char_t *tmp_77;
+ yaml_char_t *tmp_78;
+ tmp_76 = string.pointer;
+ (string.pointer) ++;
+ *tmp_76 = (unsigned char)((unsigned int)0xE0 + (
+ value >> 12));
+ tmp_77 = string.pointer;
+ (string.pointer) ++;
+ *tmp_77 = (unsigned char)((unsigned int)0x80 + (
+ (value >> 6) & (unsigned int)0x3F));
+ tmp_78 = string.pointer;
+ (string.pointer) ++;
+ *tmp_78 = (unsigned char)((unsigned int)0x80 + (
+ value & (unsigned int)0x3F));
+ }
+ else {
+ yaml_char_t *tmp_79;
+ yaml_char_t *tmp_80;
+ yaml_char_t *tmp_81;
+ yaml_char_t *tmp_82;
+ tmp_79 = string.pointer;
+ (string.pointer) ++;
+ *tmp_79 = (unsigned char)((unsigned int)0xF0 + (
+ value >> 18));
+ tmp_80 = string.pointer;
+ (string.pointer) ++;
+ *tmp_80 = (unsigned char)((unsigned int)0x80 + (
+ (value >> 12) & (unsigned int)0x3F));
+ tmp_81 = string.pointer;
+ (string.pointer) ++;
+ *tmp_81 = (unsigned char)((unsigned int)0x80 + (
+ (value >> 6) & (unsigned int)0x3F));
+ tmp_82 = string.pointer;
+ (string.pointer) ++;
+ *tmp_82 = (unsigned char)((unsigned int)0x80 + (
+ value & (unsigned int)0x3F));
+ }
+ k = (unsigned long)0;
+ while (k < code_length) {
+ {
+ int tmp_86;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_86 = 1;
+ else {
+ int tmp_85;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_85 = 2;
+ else {
+ int tmp_84;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_84 = 3;
+ else {
+ int tmp_83;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_83 = 4;
+ else tmp_83 = 0;
+ tmp_84 = tmp_83;
+ }
+ tmp_85 = tmp_84;
+ }
+ tmp_86 = tmp_85;
+ }
+ parser->buffer.pointer += tmp_86;
+ }
+ k += (size_t)1;
+ }
+ }
+ }
+ else goto _LAND_15;
+ }
+ else {
+ _LAND_15:
+ {
+ int tmp_109_0;
+ int tmp_88;
+ if (string.pointer + 5 < string.end) tmp_88 = 1;
+ else {
+ int tmp_87;
+ tmp_87 = yaml_string_extend(& string.start,
+ & string.pointer,
+ & string.end);
+ if (tmp_87) tmp_88 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_88 = 0;
+ }
+ }
+ if (tmp_88) {
+ if (((int)*(parser->buffer.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_89;
+ yaml_char_t *tmp_90;
+ tmp_89 = string.pointer;
+ (string.pointer) ++;
+ tmp_90 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_89 = *tmp_90;
+ yaml_char_t tmp_115 = *tmp_89;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_91;
+ yaml_char_t *tmp_92;
+ yaml_char_t *tmp_93;
+ yaml_char_t *tmp_94;
+ tmp_91 = string.pointer;
+ (string.pointer) ++;
+ tmp_92 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_91 = *tmp_92;
+ tmp_93 = string.pointer;
+ (string.pointer) ++;
+ tmp_94 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_93 = *tmp_94;
+ yaml_char_t tmp_113 = *tmp_93;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_95;
+ yaml_char_t *tmp_96;
+ yaml_char_t *tmp_97;
+ yaml_char_t *tmp_98;
+ yaml_char_t *tmp_99;
+ yaml_char_t *tmp_100;
+ tmp_95 = string.pointer;
+ (string.pointer) ++;
+ tmp_96 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_95 = *tmp_96;
+ tmp_97 = string.pointer;
+ (string.pointer) ++;
+ tmp_98 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_97 = *tmp_98;
+ tmp_99 = string.pointer;
+ (string.pointer) ++;
+ tmp_100 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_99 = *tmp_100;
+ yaml_char_t tmp_111 = *tmp_99;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_101;
+ yaml_char_t *tmp_102;
+ yaml_char_t *tmp_103;
+ yaml_char_t *tmp_104;
+ yaml_char_t *tmp_105;
+ yaml_char_t *tmp_106;
+ yaml_char_t *tmp_107;
+ yaml_char_t *tmp_108;
+ tmp_101 = string.pointer;
+ (string.pointer) ++;
+ tmp_102 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_101 = *tmp_102;
+ tmp_103 = string.pointer;
+ (string.pointer) ++;
+ tmp_104 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_103 = *tmp_104;
+ tmp_105 = string.pointer;
+ (string.pointer) ++;
+ tmp_106 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_105 = *tmp_106;
+ tmp_107 = string.pointer;
+ (string.pointer) ++;
+ tmp_108 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_107 = *tmp_108;
+ yaml_char_t tmp_109 = *tmp_107;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ tmp_109_0 = 1;
+ }
+ else tmp_109_0 = 0;
+ if (! tmp_109_0) goto error;
+ }
+ }
+ }
+ if (parser->unread >= (size_t)2) tmp_112 = 1;
+ else tmp_112 = yaml_parser_update_buffer(parser,(unsigned long)2);
+ if (! tmp_112) goto error;
+ }
+ }
+ if (parser->unread >= (size_t)1) tmp_114 = 1;
+ else tmp_114 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_114) goto error;
+ if (single) tmp_115_0 = '\''; else tmp_115_0 = '\"';
+ ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)tmp_115_0))
+ break;
+ if (parser->unread >= (size_t)1) tmp_117 = 1;
+ else tmp_117 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_117) goto error;
+ while (1) {
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')))
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205')))
+ goto _LAND_34;
+ }
+ else {
+ _LAND_34: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250')))
+ goto _LAND_33;
+ }
+ else goto _LAND_33;
+ }
+ else {
+ _LAND_33: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')))
+ break;
+ }
+ else break;
+ else break;
+ }
+ }
+ {
+ int tmp_172_0;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' '))
+ goto _LOR_9;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t'))
+ _LOR_9:
+ if (! leading_blanks) {
+ int tmp_140_0;
+ int tmp_119;
+ if (whitespaces.pointer + 5 < whitespaces.end) tmp_119 = 1;
+ else {
+ int tmp_118;
+ tmp_118 = yaml_string_extend(& whitespaces.start,
+ & whitespaces.pointer,
+ & whitespaces.end);
+ if (tmp_118) tmp_119 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_119 = 0;
+ }
+ }
+ if (tmp_119) {
+ if (((int)*(parser->buffer.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_120;
+ yaml_char_t *tmp_121;
+ tmp_120 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_121 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_120 = *tmp_121;
+ yaml_char_t tmp_146 = *tmp_120;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_122;
+ yaml_char_t *tmp_123;
+ yaml_char_t *tmp_124;
+ yaml_char_t *tmp_125;
+ tmp_122 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_123 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_122 = *tmp_123;
+ tmp_124 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_125 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_124 = *tmp_125;
+ yaml_char_t tmp_144 = *tmp_124;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_126;
+ yaml_char_t *tmp_127;
+ yaml_char_t *tmp_128;
+ yaml_char_t *tmp_129;
+ yaml_char_t *tmp_130;
+ yaml_char_t *tmp_131;
+ tmp_126 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_127 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_126 = *tmp_127;
+ tmp_128 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_129 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_128 = *tmp_129;
+ tmp_130 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_131 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_130 = *tmp_131;
+ yaml_char_t tmp_142 = *tmp_130;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_132;
+ yaml_char_t *tmp_133;
+ yaml_char_t *tmp_134;
+ yaml_char_t *tmp_135;
+ yaml_char_t *tmp_136;
+ yaml_char_t *tmp_137;
+ yaml_char_t *tmp_138;
+ yaml_char_t *tmp_139;
+ tmp_132 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_133 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_132 = *tmp_133;
+ tmp_134 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_135 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_134 = *tmp_135;
+ tmp_136 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_137 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_136 = *tmp_137;
+ tmp_138 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_139 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_138 = *tmp_139;
+ yaml_char_t tmp_140 = *tmp_138;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ tmp_140_0 = 1;
+ }
+ else tmp_140_0 = 0;
+ if (! tmp_140_0) goto error;
+ }
+ else {
+ int tmp_144_0;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_144_0 = 1;
+ else {
+ int tmp_143;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_143 = 2;
+ else {
+ int tmp_142_0;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_142_0 = 3;
+ else {
+ int tmp_141;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_141 = 4;
+ else tmp_141 = 0;
+ tmp_142_0 = tmp_141;
+ }
+ tmp_143 = tmp_142_0;
+ }
+ tmp_144_0 = tmp_143;
+ }
+ parser->buffer.pointer += tmp_144_0;
+ }
+ else {
+ int tmp_146_0;
+ if (parser->unread >= (size_t)2) tmp_146_0 = 1;
+ else tmp_146_0 = yaml_parser_update_buffer(parser,
+ (unsigned long)2);
+ if (! tmp_146_0) goto error;
+ if (! leading_blanks) {
+ int tmp_158_0;
+ int tmp_148;
+ whitespaces.pointer = whitespaces.start;
+ memset((void *)whitespaces.start,0,
+ (unsigned long)(whitespaces.end - whitespaces.start));
+ if (leading_break.pointer + 5 < leading_break.end) tmp_148 = 1;
+ else {
+ int tmp_147;
+ tmp_147 = yaml_string_extend(& leading_break.start,
+ & leading_break.pointer,
+ & leading_break.end);
+ if (tmp_147) tmp_148 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_148 = 0;
+ }
+ }
+ if (tmp_148) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\n')) {
+ yaml_char_t *tmp_149;
+ tmp_149 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ *tmp_149 = (unsigned char)'\n';
+ parser->buffer.pointer += 2;
+ parser->mark.index += (size_t)2;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)2;
+ size_t tmp_164 = parser->unread;
+ }
+ else goto _LAND_29;
+ }
+ else {
+ _LAND_29: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_6;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')) {
+ yaml_char_t *tmp_150;
+ _LOR_6:
+ { /* sequence */
+ tmp_150 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ *tmp_150 = (unsigned char)'\n';
+ }
+ (parser->buffer.pointer) ++;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_162 = parser->unread;
+ }
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\205')) {
+ yaml_char_t *tmp_151;
+ tmp_151 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ *tmp_151 = (unsigned char)'\n';
+ parser->buffer.pointer += 2;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_160 = parser->unread;
+ }
+ else goto _LAND_28;
+ }
+ else {
+ _LAND_28: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\200'))
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'\250'))
+ goto _LOR_5;
+ else
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'\251')) {
+ yaml_char_t *tmp_152;
+ yaml_char_t *tmp_153;
+ yaml_char_t *tmp_154;
+ yaml_char_t *tmp_155;
+ yaml_char_t *tmp_156;
+ yaml_char_t *tmp_157;
+ _LOR_5:
+ { /* sequence */
+ tmp_152 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ tmp_153 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_152 = *tmp_153;
+ }
+ tmp_154 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ tmp_155 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_154 = *tmp_155;
+ tmp_156 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ tmp_157 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_156 = *tmp_157;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_158 = parser->unread;
+ }
+ }
+ }
+ tmp_158_0 = 1;
+ }
+ else tmp_158_0 = 0;
+ if (! tmp_158_0) goto error;
+ leading_blanks = 1;
+ }
+ else {
+ int tmp_170_0;
+ int tmp_160_0;
+ if (trailing_breaks.pointer + 5 < trailing_breaks.end)
+ tmp_160_0 = 1;
+ else {
+ int tmp_159;
+ tmp_159 = yaml_string_extend(& trailing_breaks.start,
+ & trailing_breaks.pointer,
+ & trailing_breaks.end);
+ if (tmp_159) tmp_160_0 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_160_0 = 0;
+ }
+ }
+ if (tmp_160_0) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\n')) {
+ yaml_char_t *tmp_161;
+ tmp_161 = trailing_breaks.pointer;
+ (trailing_breaks.pointer) ++;
+ *tmp_161 = (unsigned char)'\n';
+ parser->buffer.pointer += 2;
+ parser->mark.index += (size_t)2;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)2;
+ size_t tmp_176 = parser->unread;
+ }
+ else goto _LAND_31;
+ }
+ else {
+ _LAND_31: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_8;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')) {
+ yaml_char_t *tmp_162_0;
+ _LOR_8:
+ { /* sequence */
+ tmp_162_0 = trailing_breaks.pointer;
+ (trailing_breaks.pointer) ++;
+ *tmp_162_0 = (unsigned char)'\n';
+ }
+ (parser->buffer.pointer) ++;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_174 = parser->unread;
+ }
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\205')) {
+ yaml_char_t *tmp_163;
+ tmp_163 = trailing_breaks.pointer;
+ (trailing_breaks.pointer) ++;
+ *tmp_163 = (unsigned char)'\n';
+ parser->buffer.pointer += 2;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_172 = parser->unread;
+ }
+ else goto _LAND_30;
+ }
+ else {
+ _LAND_30: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\200'))
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'\250'))
+ goto _LOR_7;
+ else
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'\251')) {
+ yaml_char_t *tmp_164_0;
+ yaml_char_t *tmp_165;
+ yaml_char_t *tmp_166;
+ yaml_char_t *tmp_167;
+ yaml_char_t *tmp_168;
+ yaml_char_t *tmp_169;
+ _LOR_7:
+ { /* sequence */
+ tmp_164_0 = trailing_breaks.pointer;
+ (trailing_breaks.pointer) ++;
+ tmp_165 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_164_0 = *tmp_165;
+ }
+ tmp_166 = trailing_breaks.pointer;
+ (trailing_breaks.pointer) ++;
+ tmp_167 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_166 = *tmp_167;
+ tmp_168 = trailing_breaks.pointer;
+ (trailing_breaks.pointer) ++;
+ tmp_169 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_168 = *tmp_169;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_170 = parser->unread;
+ }
+ }
+ }
+ tmp_170_0 = 1;
+ }
+ else tmp_170_0 = 0;
+ if (! tmp_170_0) goto error;
+ }
+ }
+ if (parser->unread >= (size_t)1) tmp_172_0 = 1;
+ else tmp_172_0 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_172_0) goto error;
+ }
+ }
+ if (leading_blanks)
+ if ((int)*(leading_break.start + 0) == '\n') {
+ if ((int)*(trailing_breaks.start + 0) == '\000') {
+ int tmp_174_0;
+ yaml_char_t *tmp_175;
+ if (string.pointer + 5 < string.end) tmp_174_0 = 1;
+ else {
+ int tmp_173;
+ tmp_173 = yaml_string_extend(& string.start,& string.pointer,
+ & string.end);
+ if (tmp_173) tmp_174_0 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_174_0 = 0;
+ }
+ }
+ if (! tmp_174_0) goto error;
+ tmp_175 = string.pointer;
+ (string.pointer) ++;
+ *tmp_175 = (unsigned char)' ';
+ }
+ else {
+ int tmp_177;
+ int tmp_176_0;
+ tmp_176_0 = yaml_string_join(& string.start,& string.pointer,
+ & string.end,
+ & trailing_breaks.start,
+ & trailing_breaks.pointer,
+ & trailing_breaks.end);
+ if (tmp_176_0) {
+ trailing_breaks.pointer = trailing_breaks.start;
+ tmp_177 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_177 = 0;
+ }
+ if (! tmp_177) goto error;
+ trailing_breaks.pointer = trailing_breaks.start;
+ memset((void *)trailing_breaks.start,0,
+ (unsigned long)(trailing_breaks.end - trailing_breaks.start));
+ }
+ leading_break.pointer = leading_break.start;
+ memset((void *)leading_break.start,0,
+ (unsigned long)(leading_break.end - leading_break.start));
+ }
+ else {
+ int tmp_179;
+ int tmp_178;
+ int tmp_181;
+ int tmp_180;
+ tmp_178 = yaml_string_join(& string.start,& string.pointer,
+ & string.end,& leading_break.start,
+ & leading_break.pointer,
+ & leading_break.end);
+ if (tmp_178) {
+ leading_break.pointer = leading_break.start;
+ tmp_179 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_179 = 0;
+ }
+ if (! tmp_179) goto error;
+ tmp_180 = yaml_string_join(& string.start,& string.pointer,
+ & string.end,& trailing_breaks.start,
+ & trailing_breaks.pointer,
+ & trailing_breaks.end);
+ if (tmp_180) {
+ trailing_breaks.pointer = trailing_breaks.start;
+ tmp_181 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_181 = 0;
+ }
+ if (! tmp_181) goto error;
+ leading_break.pointer = leading_break.start;
+ memset((void *)leading_break.start,0,
+ (unsigned long)(leading_break.end - leading_break.start));
+ trailing_breaks.pointer = trailing_breaks.start;
+ memset((void *)trailing_breaks.start,0,
+ (unsigned long)(trailing_breaks.end - trailing_breaks.start));
+ }
+ else {
+ int tmp_183;
+ int tmp_182;
+ tmp_182 = yaml_string_join(& string.start,& string.pointer,
+ & string.end,& whitespaces.start,
+ & whitespaces.pointer,& whitespaces.end);
+ if (tmp_182) {
+ whitespaces.pointer = whitespaces.start;
+ tmp_183 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_183 = 0;
+ }
+ if (! tmp_183) goto error;
+ whitespaces.pointer = whitespaces.start;
+ memset((void *)whitespaces.start,0,
+ (unsigned long)(whitespaces.end - whitespaces.start));
+ }
+ }
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_187 = 1;
+ else {
+ int tmp_186;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_186 = 2;
+ else {
+ int tmp_185;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_185 = 3;
+ else {
+ int tmp_184;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_184 = 4;
+ else tmp_184 = 0;
+ tmp_185 = tmp_184;
+ }
+ tmp_186 = tmp_185;
+ }
+ tmp_187 = tmp_186;
+ }
+ parser->buffer.pointer += tmp_187;
+ end_mark = parser->mark;
+ memset((void *)token,0,sizeof(yaml_token_t));
+ token->type = YAML_SCALAR_TOKEN;
+ token->start_mark = start_mark;
+ token->end_mark = end_mark;
+ token->data.scalar.value = string.start;
+ token->data.scalar.length = (unsigned long)(string.pointer - string.start);
+ if (single) token->data.scalar.style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
+ else token->data.scalar.style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
+ yaml_free((void *)leading_break.start);
+ leading_break.end = (yaml_char_t *)0;
+ leading_break.pointer = leading_break.end;
+ leading_break.start = leading_break.pointer;
+ yaml_free((void *)trailing_breaks.start);
+ trailing_breaks.end = (yaml_char_t *)0;
+ trailing_breaks.pointer = trailing_breaks.end;
+ trailing_breaks.start = trailing_breaks.pointer;
+ yaml_free((void *)whitespaces.start);
+ whitespaces.end = (yaml_char_t *)0;
+ whitespaces.pointer = whitespaces.end;
+ whitespaces.start = whitespaces.pointer;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)string.start);
+ string.end = (yaml_char_t *)0;
+ string.pointer = string.end;
+ string.start = string.pointer;
+ yaml_free((void *)leading_break.start);
+ leading_break.end = (yaml_char_t *)0;
+ leading_break.pointer = leading_break.end;
+ leading_break.start = leading_break.pointer;
+ yaml_free((void *)trailing_breaks.start);
+ trailing_breaks.end = (yaml_char_t *)0;
+ trailing_breaks.pointer = trailing_breaks.end;
+ trailing_breaks.start = trailing_breaks.pointer;
+ yaml_free((void *)whitespaces.start);
+ whitespaces.end = (yaml_char_t *)0;
+ whitespaces.pointer = whitespaces.end;
+ whitespaces.start = whitespaces.pointer;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_plain_scalar(yaml_parser_t *parser,
+ yaml_token_t *token)
+{
+ int __retres;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ int tmp_0;
+ int tmp_2;
+ int tmp_4;
+ int tmp_6;
+ yaml_string_t string =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ yaml_string_t leading_break =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ yaml_string_t trailing_breaks =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ yaml_string_t whitespaces =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ int leading_blanks = 0;
+ int indent = parser->indent + 1;
+ string.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (string.start) {
+ string.pointer = string.start;
+ string.end = string.start + 16;
+ memset((void *)string.start,0,(unsigned long)16);
+ tmp_0 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_0 = 0;
+ }
+ if (! tmp_0) goto error;
+ leading_break.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (leading_break.start) {
+ leading_break.pointer = leading_break.start;
+ leading_break.end = leading_break.start + 16;
+ memset((void *)leading_break.start,0,(unsigned long)16);
+ tmp_2 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ if (! tmp_2) goto error;
+ trailing_breaks.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (trailing_breaks.start) {
+ trailing_breaks.pointer = trailing_breaks.start;
+ trailing_breaks.end = trailing_breaks.start + 16;
+ memset((void *)trailing_breaks.start,0,(unsigned long)16);
+ tmp_4 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_4 = 0;
+ }
+ if (! tmp_4) goto error;
+ whitespaces.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (whitespaces.start) {
+ whitespaces.pointer = whitespaces.start;
+ whitespaces.end = whitespaces.start + 16;
+ memset((void *)whitespaces.start,0,(unsigned long)16);
+ tmp_6 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_6 = 0;
+ }
+ if (! tmp_6) goto error;
+ end_mark = parser->mark;
+ start_mark = end_mark;
+ while (1) {
+ {
+ int tmp_8;
+ int tmp_46_1;
+ if (parser->unread >= (size_t)4) tmp_8 = 1;
+ else tmp_8 = yaml_parser_update_buffer(parser,(unsigned long)4);
+ if (! tmp_8) goto error;
+ if (parser->mark.column == (size_t)0)
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'-')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'-')) {
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'-'))
+ goto _LOR;
+ else goto _LAND_5;
+ }
+ else goto _LAND_5;
+ }
+ else {
+ _LAND_5: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'.'))
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'.'))
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'.')) {
+ _LOR: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)' '))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\t'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\r'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\n'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (3 + 1)) == (int)((unsigned char)'\205'))
+ break;
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (3 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (3 + 2)) == (int)((unsigned char)'\250'))
+ break;
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ _LAND_2: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (3 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (3 + 2)) == (int)((unsigned char)'\251'))
+ break;
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\000'))
+ break;
+ }
+ }
+ }
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'#'))
+ break;
+ while (1) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' '))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ break;
+ else goto _LAND_16;
+ }
+ else {
+ _LAND_16: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ break;
+ else goto _LAND_15;
+ }
+ else goto _LAND_15;
+ }
+ else {
+ _LAND_15: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251'))
+ break;
+ else goto _LAND_13;
+ }
+ else goto _LAND_13;
+ }
+ else {
+ _LAND_13: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000'))
+ break;
+ }
+ }
+ }
+ {
+ int tmp_42_2;
+ int tmp_21;
+ int tmp_44_2;
+ if (parser->flow_level)
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)':'))
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)','))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'?'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'['))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)']'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'{'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'}')) {
+ _LOR_0:
+ {
+ yaml_parser_set_scanner_error(parser,
+ "while scanning a plain scalar",
+ start_mark,
+ "found unexpected \':\'");
+ goto error;
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)':'))
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)' '))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\t'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\r'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\n'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\205'))
+ break;
+ else goto _LAND_11;
+ }
+ else {
+ _LAND_11: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (1 + 2)) == (int)((unsigned char)'\250'))
+ break;
+ else goto _LAND_10;
+ }
+ else goto _LAND_10;
+ }
+ else {
+ _LAND_10: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (1 + 2)) == (int)((unsigned char)'\251'))
+ break;
+ else goto _LAND_8;
+ }
+ else goto _LAND_8;
+ }
+ else {
+ _LAND_8: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\000'))
+ break;
+ else goto _LAND_6;
+ }
+ }
+ }
+ else {
+ _LAND_6: ;
+ if (parser->flow_level)
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)','))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'['))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)']'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'{'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'}'))
+ break;
+ }
+ if (leading_blanks) goto _LOR_1;
+ else
+ if (whitespaces.start != whitespaces.pointer)
+ _LOR_1:
+ if (leading_blanks) {
+ if ((int)*(leading_break.start + 0) == '\n') {
+ if ((int)*(trailing_breaks.start + 0) == '\000') {
+ int tmp_10;
+ yaml_char_t *tmp_11;
+ if (string.pointer + 5 < string.end) tmp_10 = 1;
+ else {
+ int tmp_9;
+ tmp_9 = yaml_string_extend(& string.start,
+ & string.pointer,
+ & string.end);
+ if (tmp_9) tmp_10 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_10 = 0;
+ }
+ }
+ if (! tmp_10) goto error;
+ tmp_11 = string.pointer;
+ (string.pointer) ++;
+ *tmp_11 = (unsigned char)' ';
+ }
+ else {
+ int tmp_13;
+ int tmp_12;
+ tmp_12 = yaml_string_join(& string.start,
+ & string.pointer,& string.end,
+ & trailing_breaks.start,
+ & trailing_breaks.pointer,
+ & trailing_breaks.end);
+ if (tmp_12) {
+ trailing_breaks.pointer = trailing_breaks.start;
+ tmp_13 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_13 = 0;
+ }
+ if (! tmp_13) goto error;
+ trailing_breaks.pointer = trailing_breaks.start;
+ memset((void *)trailing_breaks.start,0,
+ (unsigned long)(trailing_breaks.end - trailing_breaks.start));
+ }
+ leading_break.pointer = leading_break.start;
+ memset((void *)leading_break.start,0,
+ (unsigned long)(leading_break.end - leading_break.start));
+ }
+ else {
+ int tmp_15;
+ int tmp_14;
+ int tmp_17;
+ int tmp_16;
+ tmp_14 = yaml_string_join(& string.start,& string.pointer,
+ & string.end,
+ & leading_break.start,
+ & leading_break.pointer,
+ & leading_break.end);
+ if (tmp_14) {
+ leading_break.pointer = leading_break.start;
+ tmp_15 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_15 = 0;
+ }
+ if (! tmp_15) goto error;
+ tmp_16 = yaml_string_join(& string.start,& string.pointer,
+ & string.end,
+ & trailing_breaks.start,
+ & trailing_breaks.pointer,
+ & trailing_breaks.end);
+ if (tmp_16) {
+ trailing_breaks.pointer = trailing_breaks.start;
+ tmp_17 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_17 = 0;
+ }
+ if (! tmp_17) goto error;
+ leading_break.pointer = leading_break.start;
+ memset((void *)leading_break.start,0,
+ (unsigned long)(leading_break.end - leading_break.start));
+ trailing_breaks.pointer = trailing_breaks.start;
+ memset((void *)trailing_breaks.start,0,
+ (unsigned long)(trailing_breaks.end - trailing_breaks.start));
+ }
+ leading_blanks = 0;
+ }
+ else {
+ int tmp_19;
+ int tmp_18;
+ tmp_18 = yaml_string_join(& string.start,& string.pointer,
+ & string.end,& whitespaces.start,
+ & whitespaces.pointer,
+ & whitespaces.end);
+ if (tmp_18) {
+ whitespaces.pointer = whitespaces.start;
+ tmp_19 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_19 = 0;
+ }
+ if (! tmp_19) goto error;
+ whitespaces.pointer = whitespaces.start;
+ memset((void *)whitespaces.start,0,
+ (unsigned long)(whitespaces.end - whitespaces.start));
+ }
+ if (string.pointer + 5 < string.end) tmp_21 = 1;
+ else {
+ int tmp_20;
+ tmp_20 = yaml_string_extend(& string.start,& string.pointer,
+ & string.end);
+ if (tmp_20) tmp_21 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_21 = 0;
+ }
+ }
+ if (tmp_21) {
+ if (((int)*(parser->buffer.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_22;
+ yaml_char_t *tmp_23;
+ tmp_22 = string.pointer;
+ (string.pointer) ++;
+ tmp_23 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_22 = *tmp_23;
+ yaml_char_t tmp_48 = *tmp_22;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_24;
+ yaml_char_t *tmp_25;
+ yaml_char_t *tmp_26;
+ yaml_char_t *tmp_27;
+ tmp_24 = string.pointer;
+ (string.pointer) ++;
+ tmp_25 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_24 = *tmp_25;
+ tmp_26 = string.pointer;
+ (string.pointer) ++;
+ tmp_27 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_26 = *tmp_27;
+ yaml_char_t tmp_46 = *tmp_26;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_28;
+ yaml_char_t *tmp_29;
+ yaml_char_t *tmp_30;
+ yaml_char_t *tmp_31;
+ yaml_char_t *tmp_32;
+ yaml_char_t *tmp_33;
+ tmp_28 = string.pointer;
+ (string.pointer) ++;
+ tmp_29 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_28 = *tmp_29;
+ tmp_30 = string.pointer;
+ (string.pointer) ++;
+ tmp_31 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_30 = *tmp_31;
+ tmp_32 = string.pointer;
+ (string.pointer) ++;
+ tmp_33 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_32 = *tmp_33;
+ yaml_char_t tmp_44 = *tmp_32;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_34;
+ yaml_char_t *tmp_35;
+ yaml_char_t *tmp_36;
+ yaml_char_t *tmp_37;
+ yaml_char_t *tmp_38;
+ yaml_char_t *tmp_39;
+ yaml_char_t *tmp_40;
+ yaml_char_t *tmp_41;
+ tmp_34 = string.pointer;
+ (string.pointer) ++;
+ tmp_35 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_34 = *tmp_35;
+ tmp_36 = string.pointer;
+ (string.pointer) ++;
+ tmp_37 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_36 = *tmp_37;
+ tmp_38 = string.pointer;
+ (string.pointer) ++;
+ tmp_39 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_38 = *tmp_39;
+ tmp_40 = string.pointer;
+ (string.pointer) ++;
+ tmp_41 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_40 = *tmp_41;
+ yaml_char_t tmp_42 = *tmp_40;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ tmp_42_2 = 1;
+ }
+ else tmp_42_2 = 0;
+ if (! tmp_42_2) goto error;
+ end_mark = parser->mark;
+ if (parser->unread >= (size_t)2) tmp_44_2 = 1;
+ else tmp_44_2 = yaml_parser_update_buffer(parser,(unsigned long)2);
+ if (! tmp_44_2) goto error;
+ }
+ }
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')))
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205')))
+ goto _LAND_19;
+ }
+ else {
+ _LAND_19: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250')))
+ goto _LAND_18;
+ }
+ else goto _LAND_18;
+ }
+ else {
+ _LAND_18: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')))
+ break;
+ }
+ else break;
+ else break;
+ }
+ }
+ if (parser->unread >= (size_t)1) tmp_46_1 = 1;
+ else tmp_46_1 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_46_1) goto error;
+ while (1) {
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')))
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205')))
+ goto _LAND_26;
+ }
+ else {
+ _LAND_26: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250')))
+ goto _LAND_25;
+ }
+ else goto _LAND_25;
+ }
+ else {
+ _LAND_25: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')))
+ break;
+ }
+ else break;
+ else break;
+ }
+ }
+ {
+ int tmp_101_1;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' '))
+ goto _LOR_6;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')) {
+ _LOR_6:
+ {
+ if (leading_blanks)
+ if ((int)parser->mark.column < indent)
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')) {
+ yaml_parser_set_scanner_error(parser,
+ "while scanning a plain scalar",
+ start_mark,
+ "found a tab character that violates indentation");
+ goto error;
+ }
+ if (! leading_blanks) {
+ int tmp_69_0;
+ int tmp_48_1;
+ if (whitespaces.pointer + 5 < whitespaces.end) tmp_48_1 = 1;
+ else {
+ int tmp_47;
+ tmp_47 = yaml_string_extend(& whitespaces.start,
+ & whitespaces.pointer,
+ & whitespaces.end);
+ if (tmp_47) tmp_48_1 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_48_1 = 0;
+ }
+ }
+ if (tmp_48_1) {
+ if (((int)*(parser->buffer.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_49;
+ yaml_char_t *tmp_50;
+ tmp_49 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_50 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_49 = *tmp_50;
+ yaml_char_t tmp_75 = *tmp_49;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_51;
+ yaml_char_t *tmp_52;
+ yaml_char_t *tmp_53;
+ yaml_char_t *tmp_54;
+ tmp_51 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_52 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_51 = *tmp_52;
+ tmp_53 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_54 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_53 = *tmp_54;
+ yaml_char_t tmp_73 = *tmp_53;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_55;
+ yaml_char_t *tmp_56;
+ yaml_char_t *tmp_57;
+ yaml_char_t *tmp_58;
+ yaml_char_t *tmp_59;
+ yaml_char_t *tmp_60;
+ tmp_55 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_56 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_55 = *tmp_56;
+ tmp_57 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_58 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_57 = *tmp_58;
+ tmp_59 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_60 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_59 = *tmp_60;
+ yaml_char_t tmp_71 = *tmp_59;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_61;
+ yaml_char_t *tmp_62;
+ yaml_char_t *tmp_63;
+ yaml_char_t *tmp_64;
+ yaml_char_t *tmp_65;
+ yaml_char_t *tmp_66;
+ yaml_char_t *tmp_67;
+ yaml_char_t *tmp_68;
+ tmp_61 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_62 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_61 = *tmp_62;
+ tmp_63 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_64 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_63 = *tmp_64;
+ tmp_65 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_66 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_65 = *tmp_66;
+ tmp_67 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_68 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_67 = *tmp_68;
+ yaml_char_t tmp_69 = *tmp_67;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ tmp_69_0 = 1;
+ }
+ else tmp_69_0 = 0;
+ if (! tmp_69_0) goto error;
+ }
+ else {
+ int tmp_73_0;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_73_0 = 1;
+ else {
+ int tmp_72;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_72 = 2;
+ else {
+ int tmp_71_0;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_71_0 = 3;
+ else {
+ int tmp_70;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_70 = 4;
+ else tmp_70 = 0;
+ tmp_71_0 = tmp_70;
+ }
+ tmp_72 = tmp_71_0;
+ }
+ tmp_73_0 = tmp_72;
+ }
+ parser->buffer.pointer += tmp_73_0;
+ }
+ }
+ }
+ else {
+ int tmp_75_1;
+ if (parser->unread >= (size_t)2) tmp_75_1 = 1;
+ else tmp_75_1 = yaml_parser_update_buffer(parser,
+ (unsigned long)2);
+ if (! tmp_75_1) goto error;
+ if (! leading_blanks) {
+ int tmp_87_1;
+ int tmp_77;
+ whitespaces.pointer = whitespaces.start;
+ memset((void *)whitespaces.start,0,
+ (unsigned long)(whitespaces.end - whitespaces.start));
+ if (leading_break.pointer + 5 < leading_break.end) tmp_77 = 1;
+ else {
+ int tmp_76;
+ tmp_76 = yaml_string_extend(& leading_break.start,
+ & leading_break.pointer,
+ & leading_break.end);
+ if (tmp_76) tmp_77 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_77 = 0;
+ }
+ }
+ if (tmp_77) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\n')) {
+ yaml_char_t *tmp_78;
+ tmp_78 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ *tmp_78 = (unsigned char)'\n';
+ parser->buffer.pointer += 2;
+ parser->mark.index += (size_t)2;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)2;
+ size_t tmp_93 = parser->unread;
+ }
+ else goto _LAND_21;
+ }
+ else {
+ _LAND_21: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_3;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')) {
+ yaml_char_t *tmp_79;
+ _LOR_3:
+ { /* sequence */
+ tmp_79 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ *tmp_79 = (unsigned char)'\n';
+ }
+ (parser->buffer.pointer) ++;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_91 = parser->unread;
+ }
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\205')) {
+ yaml_char_t *tmp_80;
+ tmp_80 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ *tmp_80 = (unsigned char)'\n';
+ parser->buffer.pointer += 2;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_89 = parser->unread;
+ }
+ else goto _LAND_20;
+ }
+ else {
+ _LAND_20: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\200'))
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'\250'))
+ goto _LOR_2;
+ else
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'\251')) {
+ yaml_char_t *tmp_81;
+ yaml_char_t *tmp_82;
+ yaml_char_t *tmp_83;
+ yaml_char_t *tmp_84;
+ yaml_char_t *tmp_85;
+ yaml_char_t *tmp_86;
+ _LOR_2:
+ { /* sequence */
+ tmp_81 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ tmp_82 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_81 = *tmp_82;
+ }
+ tmp_83 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ tmp_84 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_83 = *tmp_84;
+ tmp_85 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ tmp_86 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_85 = *tmp_86;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_87 = parser->unread;
+ }
+ }
+ }
+ tmp_87_1 = 1;
+ }
+ else tmp_87_1 = 0;
+ if (! tmp_87_1) goto error;
+ leading_blanks = 1;
+ }
+ else {
+ int tmp_99_0;
+ int tmp_89_1;
+ if (trailing_breaks.pointer + 5 < trailing_breaks.end)
+ tmp_89_1 = 1;
+ else {
+ int tmp_88;
+ tmp_88 = yaml_string_extend(& trailing_breaks.start,
+ & trailing_breaks.pointer,
+ & trailing_breaks.end);
+ if (tmp_88) tmp_89_1 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_89_1 = 0;
+ }
+ }
+ if (tmp_89_1) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\n')) {
+ yaml_char_t *tmp_90;
+ tmp_90 = trailing_breaks.pointer;
+ (trailing_breaks.pointer) ++;
+ *tmp_90 = (unsigned char)'\n';
+ parser->buffer.pointer += 2;
+ parser->mark.index += (size_t)2;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)2;
+ size_t tmp_105 = parser->unread;
+ }
+ else goto _LAND_23;
+ }
+ else {
+ _LAND_23: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_5;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')) {
+ yaml_char_t *tmp_91_1;
+ _LOR_5:
+ { /* sequence */
+ tmp_91_1 = trailing_breaks.pointer;
+ (trailing_breaks.pointer) ++;
+ *tmp_91_1 = (unsigned char)'\n';
+ }
+ (parser->buffer.pointer) ++;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_103 = parser->unread;
+ }
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\205')) {
+ yaml_char_t *tmp_92;
+ tmp_92 = trailing_breaks.pointer;
+ (trailing_breaks.pointer) ++;
+ *tmp_92 = (unsigned char)'\n';
+ parser->buffer.pointer += 2;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_101 = parser->unread;
+ }
+ else goto _LAND_22;
+ }
+ else {
+ _LAND_22: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\200'))
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'\250'))
+ goto _LOR_4;
+ else
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'\251')) {
+ yaml_char_t *tmp_93_0;
+ yaml_char_t *tmp_94;
+ yaml_char_t *tmp_95;
+ yaml_char_t *tmp_96;
+ yaml_char_t *tmp_97;
+ yaml_char_t *tmp_98;
+ _LOR_4:
+ { /* sequence */
+ tmp_93_0 = trailing_breaks.pointer;
+ (trailing_breaks.pointer) ++;
+ tmp_94 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_93_0 = *tmp_94;
+ }
+ tmp_95 = trailing_breaks.pointer;
+ (trailing_breaks.pointer) ++;
+ tmp_96 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_95 = *tmp_96;
+ tmp_97 = trailing_breaks.pointer;
+ (trailing_breaks.pointer) ++;
+ tmp_98 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_97 = *tmp_98;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_99 = parser->unread;
+ }
+ }
+ }
+ tmp_99_0 = 1;
+ }
+ else tmp_99_0 = 0;
+ if (! tmp_99_0) goto error;
+ }
+ }
+ if (parser->unread >= (size_t)1) tmp_101_1 = 1;
+ else tmp_101_1 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_101_1) goto error;
+ }
+ }
+ if (! parser->flow_level)
+ if ((int)parser->mark.column < indent) break;
+ }
+ }
+ memset((void *)token,0,sizeof(yaml_token_t));
+ token->type = YAML_SCALAR_TOKEN;
+ token->start_mark = start_mark;
+ token->end_mark = end_mark;
+ token->data.scalar.value = string.start;
+ token->data.scalar.length = (unsigned long)(string.pointer - string.start);
+ token->data.scalar.style = YAML_PLAIN_SCALAR_STYLE;
+ if (leading_blanks) parser->simple_key_allowed = 1;
+ yaml_free((void *)leading_break.start);
+ leading_break.end = (yaml_char_t *)0;
+ leading_break.pointer = leading_break.end;
+ leading_break.start = leading_break.pointer;
+ yaml_free((void *)trailing_breaks.start);
+ trailing_breaks.end = (yaml_char_t *)0;
+ trailing_breaks.pointer = trailing_breaks.end;
+ trailing_breaks.start = trailing_breaks.pointer;
+ yaml_free((void *)whitespaces.start);
+ whitespaces.end = (yaml_char_t *)0;
+ whitespaces.pointer = whitespaces.end;
+ whitespaces.start = whitespaces.pointer;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)string.start);
+ string.end = (yaml_char_t *)0;
+ string.pointer = string.end;
+ string.start = string.pointer;
+ yaml_free((void *)leading_break.start);
+ leading_break.end = (yaml_char_t *)0;
+ leading_break.pointer = leading_break.end;
+ leading_break.start = leading_break.pointer;
+ yaml_free((void *)trailing_breaks.start);
+ trailing_breaks.end = (yaml_char_t *)0;
+ trailing_breaks.pointer = trailing_breaks.end;
+ trailing_breaks.start = trailing_breaks.pointer;
+ yaml_free((void *)whitespaces.start);
+ whitespaces.end = (yaml_char_t *)0;
+ whitespaces.pointer = whitespaces.end;
+ whitespaces.start = whitespaces.pointer;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_set_writer_error(yaml_emitter_t *emitter,
+ char const *problem);
+
+static int yaml_emitter_set_writer_error(yaml_emitter_t *emitter,
+ char const *problem)
+{
+ int __retres;
+ emitter->error = YAML_WRITER_ERROR;
+ emitter->problem = problem;
+ __retres = 0;
+ return __retres;
+}
+
+int yaml_emitter_flush(yaml_emitter_t *emitter)
+{
+ int __retres;
+ int low;
+ int high;
+ int tmp_8;
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/writer.c",36,"emitter");
+ __FC_assert(emitter->write_handler != (yaml_write_handler_t *)0,
+ "src/writer.c",37,"emitter->write_handler");
+ __FC_assert(emitter->encoding != (unsigned int)0,"src/writer.c",38,
+ "emitter->encoding");
+ emitter->buffer.last = emitter->buffer.pointer;
+ emitter->buffer.pointer = emitter->buffer.start;
+ if (emitter->buffer.start == emitter->buffer.last) {
+ __retres = 1;
+ goto return_label;
+ }
+ if (emitter->encoding == (unsigned int)YAML_UTF8_ENCODING) {
+ int tmp_0;
+ tmp_0 = (*(emitter->write_handler))(emitter->write_handler_data,
+ emitter->buffer.start,
+ (unsigned long)(emitter->buffer.last - emitter->buffer.start));
+ if (tmp_0) {
+ emitter->buffer.last = emitter->buffer.start;
+ emitter->buffer.pointer = emitter->buffer.start;
+ __retres = 1;
+ goto return_label;
+ }
+ else {
+ int tmp;
+ tmp = yaml_emitter_set_writer_error(emitter,"write error");
+ __retres = tmp;
+ goto return_label;
+ }
+ }
+ if (emitter->encoding == (unsigned int)YAML_UTF16LE_ENCODING) low = 0;
+ else low = 1;
+ if (emitter->encoding == (unsigned int)YAML_UTF16LE_ENCODING) high = 1;
+ else high = 0;
+ while (emitter->buffer.pointer != emitter->buffer.last) {
+ unsigned char octet;
+ unsigned int width;
+ unsigned int value;
+ size_t k;
+ octet = *(emitter->buffer.pointer + 0);
+ if (((int)octet & 0x80) == 0x00) width = (unsigned int)1;
+ else {
+ int tmp_3;
+ if (((int)octet & 0xE0) == 0xC0) tmp_3 = 2;
+ else {
+ int tmp_2;
+ if (((int)octet & 0xF0) == 0xE0) tmp_2 = 3;
+ else {
+ int tmp_1;
+ if (((int)octet & 0xF8) == 0xF0) tmp_1 = 4; else tmp_1 = 0;
+ tmp_2 = tmp_1;
+ }
+ tmp_3 = tmp_2;
+ }
+ width = (unsigned int)tmp_3;
+ }
+ if (((int)octet & 0x80) == 0x00) value = (unsigned int)((int)octet & 0x7F);
+ else {
+ int tmp_6;
+ if (((int)octet & 0xE0) == 0xC0) tmp_6 = (int)octet & 0x1F;
+ else {
+ int tmp_5;
+ if (((int)octet & 0xF0) == 0xE0) tmp_5 = (int)octet & 0x0F;
+ else {
+ int tmp_4;
+ if (((int)octet & 0xF8) == 0xF0) tmp_4 = (int)octet & 0x07;
+ else tmp_4 = 0;
+ tmp_5 = tmp_4;
+ }
+ tmp_6 = tmp_5;
+ }
+ value = (unsigned int)tmp_6;
+ }
+ k = (unsigned long)1;
+ while (k < (size_t)width) {
+ octet = *(emitter->buffer.pointer + k);
+ value = (value << 6) + (unsigned int)((int)octet & 0x3F);
+ k += (size_t)1;
+ }
+ emitter->buffer.pointer += width;
+ if (value < (unsigned int)0x10000) {
+ *(emitter->raw_buffer.last + high) = (unsigned char)(value >> 8);
+ *(emitter->raw_buffer.last + low) = (unsigned char)(value & (unsigned int)0xFF);
+ emitter->raw_buffer.last += 2;
+ }
+ else {
+ value -= (unsigned int)0x10000;
+ *(emitter->raw_buffer.last + high) = (unsigned char)((unsigned int)0xD8 + (
+ value >> 18));
+ *(emitter->raw_buffer.last + low) = (unsigned char)((value >> 10) & (unsigned int)0xFF);
+ *(emitter->raw_buffer.last + (high + 2)) = (unsigned char)((unsigned int)0xDC + (
+ (value >> 8) & (unsigned int)0xFF));
+ *(emitter->raw_buffer.last + (low + 2)) = (unsigned char)(value & (unsigned int)0xFF);
+ emitter->raw_buffer.last += 4;
+ }
+ }
+ tmp_8 = (*(emitter->write_handler))(emitter->write_handler_data,
+ emitter->raw_buffer.start,
+ (unsigned long)(emitter->raw_buffer.last - emitter->raw_buffer.start));
+ if (tmp_8) {
+ emitter->buffer.last = emitter->buffer.start;
+ emitter->buffer.pointer = emitter->buffer.start;
+ emitter->raw_buffer.last = emitter->raw_buffer.start;
+ emitter->raw_buffer.pointer = emitter->raw_buffer.start;
+ __retres = 1;
+ goto return_label;
+ }
+ else {
+ int tmp_7;
+ tmp_7 = yaml_emitter_set_writer_error(emitter,"write error");
+ __retres = tmp_7;
+ goto return_label;
+ }
+ return_label: return __retres;
+}
+
+test_case utf8_sequences[43] =
+ {{.title = (char *)"a simple test",
+ .test = (char *)"\'test\' is \'\320\277\321\200\320\276\320\262\320\265\321\200\320\272\320\260\' in Russian!",
+ .result = 1},
+ {.title = (char *)"an empty line", .test = (char *)"!", .result = 1},
+ {.title = (char *)"u-0 is a control character",
+ .test = (char *)"\000!",
+ .result = 0},
+ {.title = (char *)"u-80 is a control character",
+ .test = (char *)"\302\200!",
+ .result = 0},
+ {.title = (char *)"u-800 is valid",
+ .test = (char *)"\340\240\200!",
+ .result = 1},
+ {.title = (char *)"u-10000 is valid",
+ .test = (char *)"\360\220\200\200!",
+ .result = 1},
+ {.title = (char *)"5 bytes sequences are not allowed",
+ .test = (char *)"\370\210\200\200\200!",
+ .result = 0},
+ {.title = (char *)"6 bytes sequences are not allowed",
+ .test = (char *)"\374\204\200\200\200\200!",
+ .result = 0},
+ {.title = (char *)"u-7f is a control character",
+ .test = (char *)"\177!",
+ .result = 0},
+ {.title = (char *)"u-7FF is valid",
+ .test = (char *)"\337\277!",
+ .result = 1},
+ {.title = (char *)"u-FFFF is a control character",
+ .test = (char *)"\357\277\277!",
+ .result = 0},
+ {.title = (char *)"u-1FFFFF is too large",
+ .test = (char *)"\367\277\277\277!",
+ .result = 0},
+ {.title = (char *)"u-3FFFFFF is 5 bytes",
+ .test = (char *)"\373\277\277\277\277!",
+ .result = 0},
+ {.title = (char *)"u-7FFFFFFF is 6 bytes",
+ .test = (char *)"\375\277\277\277\277\277!",
+ .result = 0},
+ {.title = (char *)"u-D7FF", .test = (char *)"\355\237\277!", .result = 1},
+ {.title = (char *)"u-E000", .test = (char *)"\356\200\200!", .result = 1},
+ {.title = (char *)"u-FFFD", .test = (char *)"\357\277\275!", .result = 1},
+ {.title = (char *)"u-10FFFF",
+ .test = (char *)"\364\217\277\277!",
+ .result = 1},
+ {.title = (char *)"u-110000",
+ .test = (char *)"\364\220\200\200!",
+ .result = 0},
+ {.title = (char *)"first continuation byte",
+ .test = (char *)"\200!",
+ .result = 0},
+ {.title = (char *)"last continuation byte",
+ .test = (char *)"\277!",
+ .result = 0},
+ {.title = (char *)"2 continuation bytes",
+ .test = (char *)"\200\277!",
+ .result = 0},
+ {.title = (char *)"3 continuation bytes",
+ .test = (char *)"\200\277\200!",
+ .result = 0},
+ {.title = (char *)"4 continuation bytes",
+ .test = (char *)"\200\277\200\277!",
+ .result = 0},
+ {.title = (char *)"5 continuation bytes",
+ .test = (char *)"\200\277\200\277\200!",
+ .result = 0},
+ {.title = (char *)"6 continuation bytes",
+ .test = (char *)"\200\277\200\277\200\277!",
+ .result = 0},
+ {.title = (char *)"7 continuation bytes",
+ .test = (char *)"\200\277\200\277\200\277\200!",
+ .result = 0},
+ {.title = (char *)"sequence of all 64 possible continuation bytes",
+ .test = (char *)"\200|\201|\202|\203|\204|\205|\206|\207|\210|\211|\212|\213|\214|\215|\216|\217|\220|\221|\222|\223|\224|\225|\226|\227|\230|\231|\232|\233|\234|\235|\236|\237|\240|\241|\242|\243|\244|\245|\246|\247|\250|\251|\252|\253|\254|\255|\256|\257|\260|\261|\262|\263|\264|\265|\266|\267|\270|\271|\272|\273|\274|\275|\276|\277!",
+ .result = 0},
+ {.title = (char *)"32 first bytes of 2-byte sequences {0xc0-0xdf}",
+ .test = (char *)"\300 |\301 |\302 |\303 |\304 |\305 |\306 |\307 |\310 |\311 |\312 |\313 |\314 |\315 |\316 |\317 |\320 |\321 |\322 |\323 |\324 |\325 |\326 |\327 |\330 |\331 |\332 |\333 |\334 |\335 |\336 |\337 !",
+ .result = 0},
+ {.title = (char *)"16 first bytes of 3-byte sequences {0xe0-0xef}",
+ .test = (char *)"\340 |\341 |\342 |\343 |\344 |\345 |\346 |\347 |\350 |\351 |\352 |\353 |\354 |\355 |\356 |\357 !",
+ .result = 0},
+ {.title = (char *)"8 first bytes of 4-byte sequences {0xf0-0xf7}",
+ .test = (char *)"\360 |\361 |\362 |\363 |\364 |\365 |\366 |\367 !",
+ .result = 0},
+ {.title = (char *)"4 first bytes of 5-byte sequences {0xf8-0xfb}",
+ .test = (char *)"\370 |\371 |\372 |\373 !",
+ .result = 0},
+ {.title = (char *)"2 first bytes of 6-byte sequences {0xfc-0xfd}",
+ .test = (char *)"\374 |\375 !",
+ .result = 0},
+ {.title = (char *)"sequences with last byte missing {u-0}",
+ .test = (char *)"\300|\340\200|\360\200\200|\370\200\200\200|\374\200\200\200\200!",
+ .result = 0},
+ {.title = (char *)"sequences with last byte missing {u-...FF}",
+ .test = (char *)"\337|\357\277|\367\277\277|\373\277\277\277|\375\277\277\277\277!",
+ .result = 0},
+ {.title = (char *)"impossible bytes",
+ .test = (char *)"\376|\377|\376\376\377\377!",
+ .result = 0},
+ {.title = (char *)"overlong sequences {u-2f}",
+ .test = (char *)"\300\257|\340\200\257|\360\200\200\257|\370\200\200\200\257|\374\200\200\200\200\257!",
+ .result = 0},
+ {.title = (char *)"maximum overlong sequences",
+ .test = (char *)"\301\277|\340\237\277|\360\217\277\277|\370\207\277\277\277|\374\203\277\277\277\277!",
+ .result = 0},
+ {.title = (char *)"overlong representation of the NUL character",
+ .test = (char *)"\300\200|\340\200\200|\360\200\200\200|\370\200\200\200\200|\374\200\200\200\200\200!",
+ .result = 0},
+ {.title = (char *)"single UTF-16 surrogates",
+ .test = (char *)"\355\240\200|\355\255\277|\355\256\200|\355\257\277|\355\260\200|\355\276\200|\355\277\277!",
+ .result = 0},
+ {.title = (char *)"paired UTF-16 surrogates",
+ .test = (char *)"\355\240\200\355\260\200|\355\240\200\355\277\277|\355\255\277\355\260\200|\355\255\277\355\277\277|\355\256\200\355\260\200|\355\256\200\355\277\277|\355\257\277\355\260\200|\355\257\277\355\277\277!",
+ .result = 0},
+ {.title = (char *)"other illegal code positions",
+ .test = (char *)"\357\277\276|\357\277\277!",
+ .result = 0},
+ {.title = (char *)0, .test = (char *)0, .result = 0}};
+test_case boms[5] =
+ {{.title = (char *)"no bom (utf-8)",
+ .test = (char *)"Hi is \320\237\321\200\320\270\320\262\320\265\321\202!",
+ .result = 13},
+ {.title = (char *)"bom (utf-8)",
+ .test = (char *)"\357\273\277Hi is \320\237\321\200\320\270\320\262\320\265\321\202!",
+ .result = 13},
+ {.title = (char *)"bom (utf-16-le)",
+ .test = (char *)"\377\376H\000i\000 \000i\000s\000 \000\037\004@\0048\0042\0045\004B\004!",
+ .result = 13},
+ {.title = (char *)"bom (utf-16-be)",
+ .test = (char *)"\376\377\000H\000i\000 \000i\000s\000 \004\037\004@\0048\0042\0045\004B!",
+ .result = 13},
+ {.title = (char *)0, .test = (char *)0, .result = 0}};
+char *bom_original =
+ (char *)"Hi is \320\237\321\200\320\270\320\262\320\265\321\202";
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..)));
+ */
+int printf_va_1(char const * __restrict format);
+
+/*@ requires valid_read_string(format);
+ requires valid_read_string(param0);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: *(param0 + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ *(param0 + (0 ..));
+ */
+int printf_va_2(char const * __restrict format, char *param0);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..)));
+ */
+int printf_va_3(char const * __restrict format);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..)));
+ */
+int printf_va_4(char const * __restrict format);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..)));
+ */
+int printf_va_5(char const * __restrict format);
+
+/*@ requires valid_read_string(format);
+ requires valid_read_string(param0);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param2),
+ (indirect: param1), (indirect: *(param0 + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ param2, param1, *(param0 + (0 ..));
+ */
+int printf_va_6(char const * __restrict format, char *param0,
+ unsigned int param1, long param2);
+
+/*@ requires valid_read_string(format);
+ requires valid_read_string(param0);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ param1, *(param0 + (0 ..));
+ */
+int printf_va_7(char const * __restrict format, char *param0, long param1);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..)));
+ */
+int printf_va_8(char const * __restrict format);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param0);
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ param0;
+ */
+int printf_va_9(char const * __restrict format, int param0);
+
+int check_utf8_sequences(void)
+{
+ yaml_parser_t parser;
+ int k;
+ int failed = 0;
+ printf("checking utf-8 sequences...\n"); /* printf_va_1 */
+ k = 0;
+ while (utf8_sequences[k].test) {
+ {
+ int result;
+ char *title = utf8_sequences[k].title;
+ int check = utf8_sequences[k].result;
+ char *start = utf8_sequences[k].test;
+ char *end = start;
+ printf("\t%s:\n",title); /* printf_va_2 */
+ while (1) {
+ while (1) {
+ if ((int)*end != '|') {
+ if (! ((int)*end != '!')) break;
+ }
+ else break;
+ end ++;
+ }
+ yaml_parser_initialize(& parser);
+ yaml_parser_set_input_string(& parser,(unsigned char const *)start,
+ (unsigned long)(end - start));
+ result = yaml_parser_update_buffer(& parser,
+ (unsigned long)(end - start));
+ if (result != check) {
+ printf("\t\t- "); /* printf_va_3 */
+ failed ++;
+ }
+ else printf("\t\t+ "); /* printf_va_4 */
+ if (! parser.error) printf("(no error)\n"); /* printf_va_5 */
+ else
+ if (parser.error == (unsigned int)YAML_READER_ERROR)
+ if (parser.problem_value != -1) printf("(reader error: %s: #%X at %ld)\n",
+ (char *)parser.problem,
+ (unsigned int)parser.problem_value,
+ (long)parser.problem_offset); /* printf_va_6 */
+ else printf("(reader error: %s at %ld)\n",(char *)parser.problem,
+ (long)parser.problem_offset); /* printf_va_7 */
+ if ((int)*end == '!') break;
+ end ++;
+ start = end;
+ yaml_parser_delete(& parser);
+ }
+ printf("\n"); /* printf_va_8 */
+ }
+ k ++;
+ }
+ printf("checking utf-8 sequences: %d fail(s)\n",failed); /* printf_va_9 */
+ return failed;
+}
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..)));
+ */
+int printf_va_10(char const * __restrict format);
+
+/*@ requires valid_read_string(format);
+ requires valid_read_string(param0);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: *(param0 + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ *(param0 + (0 ..));
+ */
+int printf_va_11(char const * __restrict format, char *param0);
+
+/*@ requires valid_read_string(format);
+ requires valid_read_string(param0);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ param1, *(param0 + (0 ..));
+ */
+int printf_va_12(char const * __restrict format, char *param0, long param1);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: param0);
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ param1, param0;
+ */
+int printf_va_13(char const * __restrict format, long param0, int param1);
+
+/*@ requires valid_read_string(format);
+ requires valid_read_string(param1);
+ requires valid_read_string(param0);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: *(param1 + (0 ..))),
+ (indirect: *(param0 + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ *(param1 + (0 ..)), *(param0 + (0 ..));
+ */
+int printf_va_14(char const * __restrict format, char *param0, char *param1);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..)));
+ */
+int printf_va_15(char const * __restrict format);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param0);
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ param0;
+ */
+int printf_va_16(char const * __restrict format, int param0);
+
+int check_boms(void)
+{
+ yaml_parser_t parser;
+ int k;
+ int failed = 0;
+ printf("checking boms...\n"); /* printf_va_10 */
+ k = 0;
+ while (boms[k].test) {
+ {
+ int result;
+ char *title = boms[k].title;
+ int check = boms[k].result;
+ char *start = boms[k].test;
+ char *end = start;
+ while ((int)*end != '!') end ++;
+ printf("\t%s: ",title); /* printf_va_11 */
+ yaml_parser_initialize(& parser);
+ yaml_parser_set_input_string(& parser,(unsigned char const *)start,
+ (unsigned long)(end - start));
+ result = yaml_parser_update_buffer(& parser,
+ (unsigned long)(end - start));
+ if (! result) {
+ printf("- (reader error: %s at %ld)\n",(char *)parser.problem,
+ (long)parser.problem_offset); /* printf_va_12 */
+ failed ++;
+ }
+ else
+ if (parser.unread != (size_t)check) {
+ printf("- (length=%ld while expected length=%d)\n",
+ (long)parser.unread,check); /* printf_va_13 */
+ failed ++;
+ }
+ else {
+ int tmp;
+ tmp = memcmp((void const *)parser.buffer.start,
+ (void const *)bom_original,(unsigned long)check);
+ if (tmp != 0) {
+ printf("- (value \'%s\' does not equal to the original value \'%s\')\n",
+ (char *)parser.buffer.start,bom_original); /* printf_va_14 */
+ failed ++;
+ }
+ else printf("+\n"); /* printf_va_15 */
+ }
+ yaml_parser_delete(& parser);
+ }
+ k ++;
+ }
+ printf("checking boms: %d fail(s)\n",failed); /* printf_va_16 */
+ return failed;
+}
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..)));
+ */
+int printf_va_17(char const * __restrict format);
+
+/*@ requires valid_read_string(format);
+ requires valid_read_string(param0);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ param1, *(param0 + (0 ..));
+ */
+int printf_va_18(char const * __restrict format, char *param0, long param1);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param0);
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ param0;
+ */
+int printf_va_19(char const * __restrict format, int param0);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param3),
+ (indirect: param2), (indirect: param1), (indirect: param0);
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ param3, param2, param1, param0;
+ */
+int printf_va_20(char const * __restrict format, unsigned int param0,
+ unsigned int param1, unsigned int param2,
+ unsigned int param3);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param2),
+ (indirect: param1), (indirect: param0);
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ param2, param1, param0;
+ */
+int printf_va_21(char const * __restrict format, unsigned int param0,
+ int param1, long param2);
+
+/*@ requires valid_read_string(format);
+ requires valid_read_string(param0);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ param1, *(param0 + (0 ..));
+ */
+int printf_va_22(char const * __restrict format, char *param0, long param1);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param0);
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ param0;
+ */
+int printf_va_23(char const * __restrict format, int param0);
+
+int check_long_utf8(void)
+{
+ yaml_parser_t parser;
+ int j;
+ unsigned char ch0;
+ unsigned char ch1;
+ int tmp_0;
+ int tmp_1;
+ int tmp_2;
+ int k = 0;
+ int failed = 0;
+ unsigned char *buffer = malloc((unsigned long)(3 + 100000 * 2));
+ __FC_assert(buffer != (unsigned char *)0,"tests/test-reader.c",215,
+ "buffer");
+ printf("checking a long utf8 sequence...\n"); /* printf_va_17 */
+ tmp_0 = k;
+ k ++;
+ *(buffer + tmp_0) = (unsigned char)'\357';
+ tmp_1 = k;
+ k ++;
+ *(buffer + tmp_1) = (unsigned char)'\273';
+ tmp_2 = k;
+ k ++;
+ *(buffer + tmp_2) = (unsigned char)'\277';
+ j = 0;
+ while (j < 100000) {
+ if (j % 2) {
+ int tmp_3;
+ int tmp_4;
+ tmp_3 = k;
+ k ++;
+ *(buffer + tmp_3) = (unsigned char)'\320';
+ tmp_4 = k;
+ k ++;
+ *(buffer + tmp_4) = (unsigned char)'\220';
+ }
+ else {
+ int tmp_5;
+ int tmp_6;
+ tmp_5 = k;
+ k ++;
+ *(buffer + tmp_5) = (unsigned char)'\320';
+ tmp_6 = k;
+ k ++;
+ *(buffer + tmp_6) = (unsigned char)'\257';
+ }
+ j ++;
+ }
+ yaml_parser_initialize(& parser);
+ yaml_parser_set_input_string(& parser,(unsigned char const *)buffer,
+ (unsigned long)(3 + 100000 * 2));
+ k = 0;
+ while (k < 100000) {
+ if (! parser.unread) {
+ int tmp_7;
+ tmp_7 = yaml_parser_update_buffer(& parser,(unsigned long)1);
+ if (! tmp_7) {
+ printf("\treader error: %s at %ld\n",(char *)parser.problem,
+ (long)parser.problem_offset); /* printf_va_18 */
+ failed = 1;
+ break;
+ }
+ }
+ if (! parser.unread) {
+ printf("\tnot enough characters at %d\n",k); /* printf_va_19 */
+ failed = 1;
+ break;
+ }
+ if (k % 2) {
+ ch0 = (unsigned char)'\320';
+ ch1 = (unsigned char)'\220';
+ }
+ else {
+ ch0 = (unsigned char)'\320';
+ ch1 = (unsigned char)'\257';
+ }
+ if ((int)*(parser.buffer.pointer + 0) != (int)ch0) goto _LOR;
+ else
+ if ((int)*(parser.buffer.pointer + 1) != (int)ch1) {
+ _LOR:
+ {
+ printf("\tincorrect UTF-8 sequence: %X %X instead of %X %X\n",
+ (unsigned int)((int)*(parser.buffer.pointer + 0)),
+ (unsigned int)((int)*(parser.buffer.pointer + 1)),
+ (unsigned int)((int)ch0),(unsigned int)((int)ch1)); /* printf_va_20 */
+ failed = 1;
+ break;
+ }
+ }
+ parser.buffer.pointer += 2;
+ parser.unread -= (size_t)1;
+ k ++;
+ }
+ if (! failed) {
+ int tmp_8;
+ tmp_8 = yaml_parser_update_buffer(& parser,(unsigned long)1);
+ if (tmp_8) {
+ if ((int)*(parser.buffer.pointer + 0) != '\000') {
+ printf("\texpected NUL, found %X (eof=%d, unread=%ld)\n",
+ (unsigned int)((int)*(parser.buffer.pointer + 0)),parser.eof,
+ (long)parser.unread); /* printf_va_21 */
+ failed = 1;
+ }
+ }
+ else {
+ printf("\treader error: %s at %ld\n",(char *)parser.problem,
+ (long)parser.problem_offset); /* printf_va_22 */
+ failed = 1;
+ }
+ }
+ yaml_parser_delete(& parser);
+ free((void *)buffer);
+ printf("checking a long utf8 sequence: %d fail(s)\n",failed); /* printf_va_23 */
+ return failed;
+}
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..)));
+ */
+int printf_va_24(char const * __restrict format);
+
+/*@ requires valid_read_string(format);
+ requires valid_read_string(param0);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ param1, *(param0 + (0 ..));
+ */
+int printf_va_25(char const * __restrict format, char *param0, long param1);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param0);
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ param0;
+ */
+int printf_va_26(char const * __restrict format, int param0);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param3),
+ (indirect: param2), (indirect: param1), (indirect: param0);
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ param3, param2, param1, param0;
+ */
+int printf_va_27(char const * __restrict format, unsigned int param0,
+ unsigned int param1, unsigned int param2,
+ unsigned int param3);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param2),
+ (indirect: param1), (indirect: param0);
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ param2, param1, param0;
+ */
+int printf_va_28(char const * __restrict format, unsigned int param0,
+ int param1, long param2);
+
+/*@ requires valid_read_string(format);
+ requires valid_read_string(param0);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ param1, *(param0 + (0 ..));
+ */
+int printf_va_29(char const * __restrict format, char *param0, long param1);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param0);
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ param0;
+ */
+int printf_va_30(char const * __restrict format, int param0);
+
+int check_long_utf16(void)
+{
+ yaml_parser_t parser;
+ int j;
+ unsigned char ch0;
+ unsigned char ch1;
+ int tmp_0;
+ int tmp_1;
+ int k = 0;
+ int failed = 0;
+ unsigned char *buffer = malloc((unsigned long)(2 + 100000 * 2));
+ __FC_assert(buffer != (unsigned char *)0,"tests/test-reader.c",287,
+ "buffer");
+ printf("checking a long utf16 sequence...\n"); /* printf_va_24 */
+ tmp_0 = k;
+ k ++;
+ *(buffer + tmp_0) = (unsigned char)'\377';
+ tmp_1 = k;
+ k ++;
+ *(buffer + tmp_1) = (unsigned char)'\376';
+ j = 0;
+ while (j < 100000) {
+ if (j % 2) {
+ int tmp_2;
+ int tmp_3;
+ tmp_2 = k;
+ k ++;
+ *(buffer + tmp_2) = (unsigned char)'\020';
+ tmp_3 = k;
+ k ++;
+ *(buffer + tmp_3) = (unsigned char)'\004';
+ }
+ else {
+ int tmp_4;
+ int tmp_5;
+ tmp_4 = k;
+ k ++;
+ *(buffer + tmp_4) = (unsigned char)'/';
+ tmp_5 = k;
+ k ++;
+ *(buffer + tmp_5) = (unsigned char)'\004';
+ }
+ j ++;
+ }
+ yaml_parser_initialize(& parser);
+ yaml_parser_set_input_string(& parser,(unsigned char const *)buffer,
+ (unsigned long)(2 + 100000 * 2));
+ k = 0;
+ while (k < 100000) {
+ if (! parser.unread) {
+ int tmp_6;
+ tmp_6 = yaml_parser_update_buffer(& parser,(unsigned long)1);
+ if (! tmp_6) {
+ printf("\treader error: %s at %ld\n",(char *)parser.problem,
+ (long)parser.problem_offset); /* printf_va_25 */
+ failed = 1;
+ break;
+ }
+ }
+ if (! parser.unread) {
+ printf("\tnot enough characters at %d\n",k); /* printf_va_26 */
+ failed = 1;
+ break;
+ }
+ if (k % 2) {
+ ch0 = (unsigned char)'\320';
+ ch1 = (unsigned char)'\220';
+ }
+ else {
+ ch0 = (unsigned char)'\320';
+ ch1 = (unsigned char)'\257';
+ }
+ if ((int)*(parser.buffer.pointer + 0) != (int)ch0) goto _LOR;
+ else
+ if ((int)*(parser.buffer.pointer + 1) != (int)ch1) {
+ _LOR:
+ {
+ printf("\tincorrect UTF-8 sequence: %X %X instead of %X %X\n",
+ (unsigned int)((int)*(parser.buffer.pointer + 0)),
+ (unsigned int)((int)*(parser.buffer.pointer + 1)),
+ (unsigned int)((int)ch0),(unsigned int)((int)ch1)); /* printf_va_27 */
+ failed = 1;
+ break;
+ }
+ }
+ parser.buffer.pointer += 2;
+ parser.unread -= (size_t)1;
+ k ++;
+ }
+ if (! failed) {
+ int tmp_7;
+ tmp_7 = yaml_parser_update_buffer(& parser,(unsigned long)1);
+ if (tmp_7) {
+ if ((int)*(parser.buffer.pointer + 0) != '\000') {
+ printf("\texpected NUL, found %X (eof=%d, unread=%ld)\n",
+ (unsigned int)((int)*(parser.buffer.pointer + 0)),parser.eof,
+ (long)parser.unread); /* printf_va_28 */
+ failed = 1;
+ }
+ }
+ else {
+ printf("\treader error: %s at %ld\n",(char *)parser.problem,
+ (long)parser.problem_offset); /* printf_va_29 */
+ failed = 1;
+ }
+ }
+ yaml_parser_delete(& parser);
+ free((void *)buffer);
+ printf("checking a long utf16 sequence: %d fail(s)\n",failed); /* printf_va_30 */
+ return failed;
+}
+
+int main(void)
+{
+ int __retres;
+ int tmp;
+ int tmp_0;
+ int tmp_1;
+ int tmp_2;
+ tmp = check_utf8_sequences();
+ tmp_0 = check_boms();
+ tmp_1 = check_long_utf8();
+ tmp_2 = check_long_utf16();
+ __retres = ((tmp + tmp_0) + tmp_1) + tmp_2;
+ return __retres;
+}
+
+
diff --git a/libyaml/.frama-c/test-reader.parse/metrics.log b/libyaml/.frama-c/test-reader.parse/metrics.log
new file mode 100644
index 0000000000000000000000000000000000000000..f46220bbde167225fb1adf9b8277899af275884a
--- /dev/null
+++ b/libyaml/.frama-c/test-reader.parse/metrics.log
@@ -0,0 +1,193 @@
+[metrics] Defined functions (199)
+=======================
+ check_boms (1 call); check_long_utf16 (1 call); check_long_utf8 (1 call);
+ check_utf8_sequences (1 call); main (0 call);
+ yaml_alias_event_initialize (0 call); yaml_check_utf8 (16 calls);
+ yaml_document_add_mapping (0 call); yaml_document_add_scalar (0 call);
+ yaml_document_add_sequence (0 call);
+ yaml_document_append_mapping_pair (0 call);
+ yaml_document_append_sequence_item (0 call); yaml_document_delete (2 calls);
+ yaml_document_end_event_initialize (0 call);
+ yaml_document_get_node (0 call); yaml_document_get_root_node (0 call);
+ yaml_document_initialize (0 call);
+ yaml_document_start_event_initialize (0 call);
+ yaml_emitter_analyze_anchor (4 calls); yaml_emitter_analyze_event (1 call);
+ yaml_emitter_analyze_scalar (1 call); yaml_emitter_analyze_tag (3 calls);
+ yaml_emitter_analyze_tag_directive (1 call);
+ yaml_emitter_analyze_version_directive (1 call);
+ yaml_emitter_anchor_node (4 calls);
+ yaml_emitter_append_tag_directive (2 calls);
+ yaml_emitter_check_empty_document (1 call);
+ yaml_emitter_check_empty_mapping (2 calls);
+ yaml_emitter_check_empty_sequence (2 calls);
+ yaml_emitter_check_simple_key (2 calls); yaml_emitter_close (1 call);
+ yaml_emitter_delete (0 call);
+ yaml_emitter_delete_document_and_anchors (3 calls);
+ yaml_emitter_dump (0 call); yaml_emitter_dump_alias (1 call);
+ yaml_emitter_dump_mapping (1 call); yaml_emitter_dump_node (4 calls);
+ yaml_emitter_dump_scalar (1 call); yaml_emitter_dump_sequence (1 call);
+ yaml_emitter_emit (10 calls); yaml_emitter_emit_alias (1 call);
+ yaml_emitter_emit_block_mapping_key (2 calls);
+ yaml_emitter_emit_block_mapping_value (2 calls);
+ yaml_emitter_emit_block_sequence_item (2 calls);
+ yaml_emitter_emit_document_content (1 call);
+ yaml_emitter_emit_document_end (1 call);
+ yaml_emitter_emit_document_start (2 calls);
+ yaml_emitter_emit_flow_mapping_key (2 calls);
+ yaml_emitter_emit_flow_mapping_value (2 calls);
+ yaml_emitter_emit_flow_sequence_item (2 calls);
+ yaml_emitter_emit_mapping_start (1 call); yaml_emitter_emit_node (9 calls);
+ yaml_emitter_emit_scalar (1 call);
+ yaml_emitter_emit_sequence_start (1 call);
+ yaml_emitter_emit_stream_start (1 call); yaml_emitter_flush (60 calls);
+ yaml_emitter_generate_anchor (1 call);
+ yaml_emitter_increase_indent (5 calls); yaml_emitter_initialize (0 call);
+ yaml_emitter_need_more_events (1 call); yaml_emitter_open (1 call);
+ yaml_emitter_process_anchor (4 calls); yaml_emitter_process_scalar (1 call);
+ yaml_emitter_process_tag (3 calls);
+ yaml_emitter_select_scalar_style (1 call); yaml_emitter_set_break (0 call);
+ yaml_emitter_set_canonical (0 call);
+ yaml_emitter_set_emitter_error (16 calls);
+ yaml_emitter_set_encoding (0 call); yaml_emitter_set_indent (0 call);
+ yaml_emitter_set_output (0 call); yaml_emitter_set_output_file (0 call);
+ yaml_emitter_set_output_string (0 call); yaml_emitter_set_unicode (0 call);
+ yaml_emitter_set_width (0 call); yaml_emitter_set_writer_error (2 calls);
+ yaml_emitter_state_machine (1 call); yaml_emitter_write_anchor (1 call);
+ yaml_emitter_write_block_scalar_hints (2 calls);
+ yaml_emitter_write_bom (1 call);
+ yaml_emitter_write_double_quoted_scalar (1 call);
+ yaml_emitter_write_folded_scalar (1 call);
+ yaml_emitter_write_indent (25 calls);
+ yaml_emitter_write_indicator (34 calls);
+ yaml_emitter_write_literal_scalar (1 call);
+ yaml_emitter_write_plain_scalar (1 call);
+ yaml_emitter_write_single_quoted_scalar (1 call);
+ yaml_emitter_write_tag_content (3 calls);
+ yaml_emitter_write_tag_handle (2 calls); yaml_event_delete (3 calls);
+ yaml_file_read_handler (address taken) (0 call);
+ yaml_file_write_handler (address taken) (0 call); yaml_free (169 calls);
+ yaml_get_version (0 call); yaml_get_version_string (0 call);
+ yaml_malloc (52 calls); yaml_mapping_end_event_initialize (0 call);
+ yaml_mapping_start_event_initialize (0 call);
+ yaml_parser_append_tag_directive (2 calls);
+ yaml_parser_decrease_flow_level (1 call); yaml_parser_delete (4 calls);
+ yaml_parser_delete_aliases (2 calls);
+ yaml_parser_determine_encoding (1 call); yaml_parser_fetch_anchor (2 calls);
+ yaml_parser_fetch_block_entry (1 call);
+ yaml_parser_fetch_block_scalar (2 calls);
+ yaml_parser_fetch_directive (1 call);
+ yaml_parser_fetch_document_indicator (2 calls);
+ yaml_parser_fetch_flow_collection_end (2 calls);
+ yaml_parser_fetch_flow_collection_start (2 calls);
+ yaml_parser_fetch_flow_entry (1 call);
+ yaml_parser_fetch_flow_scalar (2 calls); yaml_parser_fetch_key (1 call);
+ yaml_parser_fetch_more_tokens (37 calls);
+ yaml_parser_fetch_next_token (1 call);
+ yaml_parser_fetch_plain_scalar (1 call);
+ yaml_parser_fetch_stream_end (1 call);
+ yaml_parser_fetch_stream_start (1 call); yaml_parser_fetch_tag (1 call);
+ yaml_parser_fetch_value (1 call); yaml_parser_increase_flow_level (1 call);
+ yaml_parser_initialize (4 calls); yaml_parser_load (0 call);
+ yaml_parser_load_alias (1 call); yaml_parser_load_document (1 call);
+ yaml_parser_load_mapping (1 call); yaml_parser_load_mapping_end (1 call);
+ yaml_parser_load_node_add (4 calls); yaml_parser_load_nodes (1 call);
+ yaml_parser_load_scalar (1 call); yaml_parser_load_sequence (1 call);
+ yaml_parser_load_sequence_end (1 call); yaml_parser_parse (3 calls);
+ yaml_parser_parse_block_mapping_key (2 calls);
+ yaml_parser_parse_block_mapping_value (1 call);
+ yaml_parser_parse_block_sequence_entry (2 calls);
+ yaml_parser_parse_document_content (1 call);
+ yaml_parser_parse_document_end (1 call);
+ yaml_parser_parse_document_start (2 calls);
+ yaml_parser_parse_flow_mapping_key (2 calls);
+ yaml_parser_parse_flow_mapping_value (2 calls);
+ yaml_parser_parse_flow_sequence_entry (2 calls);
+ yaml_parser_parse_flow_sequence_entry_mapping_end (1 call);
+ yaml_parser_parse_flow_sequence_entry_mapping_key (1 call);
+ yaml_parser_parse_flow_sequence_entry_mapping_value (1 call);
+ yaml_parser_parse_indentless_sequence_entry (1 call);
+ yaml_parser_parse_node (14 calls); yaml_parser_parse_stream_start (1 call);
+ yaml_parser_process_directives (2 calls);
+ yaml_parser_process_empty_scalar (11 calls);
+ yaml_parser_register_anchor (3 calls);
+ yaml_parser_remove_simple_key (9 calls); yaml_parser_roll_indent (4 calls);
+ yaml_parser_save_simple_key (5 calls); yaml_parser_scan (0 call);
+ yaml_parser_scan_anchor (1 call); yaml_parser_scan_block_scalar (1 call);
+ yaml_parser_scan_block_scalar_breaks (2 calls);
+ yaml_parser_scan_directive (1 call);
+ yaml_parser_scan_directive_name (1 call);
+ yaml_parser_scan_flow_scalar (1 call);
+ yaml_parser_scan_plain_scalar (1 call); yaml_parser_scan_tag (1 call);
+ yaml_parser_scan_tag_directive_value (1 call);
+ yaml_parser_scan_tag_handle (2 calls); yaml_parser_scan_tag_uri (4 calls);
+ yaml_parser_scan_to_next_token (1 call);
+ yaml_parser_scan_uri_escapes (1 call);
+ yaml_parser_scan_version_directive_number (2 calls);
+ yaml_parser_scan_version_directive_value (1 call);
+ yaml_parser_set_composer_error (1 call);
+ yaml_parser_set_composer_error_context (1 call);
+ yaml_parser_set_encoding (0 call); yaml_parser_set_input (0 call);
+ yaml_parser_set_input_file (0 call); yaml_parser_set_input_string (4 calls);
+ yaml_parser_set_parser_error (5 calls);
+ yaml_parser_set_parser_error_context (6 calls);
+ yaml_parser_set_reader_error (12 calls);
+ yaml_parser_set_scanner_error (35 calls);
+ yaml_parser_stale_simple_keys (2 calls); yaml_parser_state_machine (1 call);
+ yaml_parser_unroll_indent (4 calls); yaml_parser_update_buffer (65 calls);
+ yaml_parser_update_raw_buffer (2 calls); yaml_queue_extend (20 calls);
+ yaml_realloc (3 calls); yaml_scalar_event_initialize (0 call);
+ yaml_sequence_end_event_initialize (0 call);
+ yaml_sequence_start_event_initialize (0 call); yaml_stack_extend (47 calls);
+ yaml_strdup (21 calls); yaml_stream_end_event_initialize (0 call);
+ yaml_stream_start_event_initialize (0 call); yaml_string_extend (26 calls);
+ yaml_string_join (12 calls);
+ yaml_string_read_handler (address taken) (0 call);
+ yaml_string_write_handler (address taken) (0 call);
+ yaml_token_delete (7 calls);
+
+Specified-only functions (0)
+============================
+
+
+Undefined and unspecified functions (0)
+=======================================
+
+
+'Extern' global variables (0)
+=============================
+
+
+Potential entry points (38)
+===========================
+ main; yaml_alias_event_initialize; yaml_document_add_mapping;
+ yaml_document_add_scalar; yaml_document_add_sequence;
+ yaml_document_append_mapping_pair; yaml_document_append_sequence_item;
+ yaml_document_end_event_initialize; yaml_document_get_node;
+ yaml_document_get_root_node; yaml_document_initialize;
+ yaml_document_start_event_initialize; yaml_emitter_delete;
+ yaml_emitter_dump; yaml_emitter_initialize; yaml_emitter_set_break;
+ yaml_emitter_set_canonical; yaml_emitter_set_encoding;
+ yaml_emitter_set_indent; yaml_emitter_set_output;
+ yaml_emitter_set_output_file; yaml_emitter_set_output_string;
+ yaml_emitter_set_unicode; yaml_emitter_set_width; yaml_get_version;
+ yaml_get_version_string; yaml_mapping_end_event_initialize;
+ yaml_mapping_start_event_initialize; yaml_parser_load; yaml_parser_scan;
+ yaml_parser_set_encoding; yaml_parser_set_input;
+ yaml_parser_set_input_file; yaml_scalar_event_initialize;
+ yaml_sequence_end_event_initialize; yaml_sequence_start_event_initialize;
+ yaml_stream_end_event_initialize; yaml_stream_start_event_initialize;
+
+Global metrics
+==============
+Sloc = 16578
+Decision point = 3337
+Global variables = 3
+If = 3210
+Loop = 106
+Goto = 1588
+Assignment = 7722
+Exit point = 199
+Function = 199
+Function call = 1263
+Pointer dereferencing = 8750
+Cyclomatic complexity = 3536
diff --git a/libyaml/.frama-c/test-reader.parse/warnings.log b/libyaml/.frama-c/test-reader.parse/warnings.log
new file mode 100644
index 0000000000000000000000000000000000000000..8f38f7570b2e07d1426df9beee5221f290ed9292
--- /dev/null
+++ b/libyaml/.frama-c/test-reader.parse/warnings.log
@@ -0,0 +1,11 @@
+tests/test-reader.c:147:[variadic] warning: Incorrect type for argument 3. The argument will be cast from int to unsigned int.
+tests/test-reader.c:254:[variadic] warning: Incorrect type for argument 2. The argument will be cast from int to unsigned int.
+tests/test-reader.c:254:[variadic] warning: Incorrect type for argument 3. The argument will be cast from int to unsigned int.
+tests/test-reader.c:254:[variadic] warning: Incorrect type for argument 4. The argument will be cast from int to unsigned int.
+tests/test-reader.c:254:[variadic] warning: Incorrect type for argument 5. The argument will be cast from int to unsigned int.
+tests/test-reader.c:269:[variadic] warning: Incorrect type for argument 2. The argument will be cast from int to unsigned int.
+tests/test-reader.c:325:[variadic] warning: Incorrect type for argument 2. The argument will be cast from int to unsigned int.
+tests/test-reader.c:325:[variadic] warning: Incorrect type for argument 3. The argument will be cast from int to unsigned int.
+tests/test-reader.c:325:[variadic] warning: Incorrect type for argument 4. The argument will be cast from int to unsigned int.
+tests/test-reader.c:325:[variadic] warning: Incorrect type for argument 5. The argument will be cast from int to unsigned int.
+tests/test-reader.c:340:[variadic] warning: Incorrect type for argument 2. The argument will be cast from int to unsigned int.
diff --git a/libyaml/.frama-c/test-version.eva/alarms.csv b/libyaml/.frama-c/test-version.eva/alarms.csv
new file mode 100644
index 0000000000000000000000000000000000000000..8f697f2be8fef9adc76bcec921ec10a1270136bf
--- /dev/null
+++ b/libyaml/.frama-c/test-version.eva/alarms.csv
@@ -0,0 +1,5 @@
+directory file line function property kind status property
+FRAMAC_SHARE/libc assert.h 31 __FC_assert precondition Unknown nonnull_c: c ≢ 0
+FRAMAC_SHARE/libc string.h 137 strcmp precondition Unknown valid_string_s1: valid_read_string(s1)
+tests test-version.c 21 main precondition of __FC_assert Unknown nonnull_c: c ≢ 0
+tests test-version.c 21 main precondition of strcmp Unknown valid_string_s1: valid_read_string(s1)
diff --git a/libyaml/.frama-c/test-version.eva/metrics.log b/libyaml/.frama-c/test-version.eva/metrics.log
new file mode 100644
index 0000000000000000000000000000000000000000..90cbb73a64be239d8e2298c8b6fdd9d058515e8c
--- /dev/null
+++ b/libyaml/.frama-c/test-version.eva/metrics.log
@@ -0,0 +1,11 @@
+[metrics] Eva coverage statistics
+=======================
+Syntactically reachable functions = 3 (out of 195)
+Semantically reached functions = 3
+Coverage estimation = 100.0%
+[metrics] Statements analyzed by Eva
+--------------------------
+19 stmts in analyzed functions, 19 stmts analyzed (100.0%)
+main: 13 stmts out of 13 (100.0%)
+yaml_get_version: 4 stmts out of 4 (100.0%)
+yaml_get_version_string: 2 stmts out of 2 (100.0%)
diff --git a/libyaml/.frama-c/test-version.eva/nonterm.log b/libyaml/.frama-c/test-version.eva/nonterm.log
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/libyaml/.frama-c/test-version.eva/warnings.log b/libyaml/.frama-c/test-version.eva/warnings.log
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/libyaml/.frama-c/test-version.parse/framac.ast b/libyaml/.frama-c/test-version.parse/framac.ast
new file mode 100644
index 0000000000000000000000000000000000000000..50c648ac7b45b59c8928a903082cd2e6035aee56
--- /dev/null
+++ b/libyaml/.frama-c/test-version.parse/framac.ast
@@ -0,0 +1,22649 @@
+/* Generated by Frama-C */
+#include "assert.h"
+#include "errno.h"
+#include "stdarg.h"
+#include "stddef.h"
+#include "stdio.h"
+#include "stdlib.h"
+#include "string.h"
+#include "strings.h"
+typedef unsigned char yaml_char_t;
+struct yaml_version_directive_s {
+ int major ;
+ int minor ;
+};
+typedef struct yaml_version_directive_s yaml_version_directive_t;
+struct yaml_tag_directive_s {
+ yaml_char_t *handle ;
+ yaml_char_t *prefix ;
+};
+typedef struct yaml_tag_directive_s yaml_tag_directive_t;
+enum yaml_encoding_e {
+ YAML_ANY_ENCODING = 0,
+ YAML_UTF8_ENCODING = 1,
+ YAML_UTF16LE_ENCODING = 2,
+ YAML_UTF16BE_ENCODING = 3
+};
+typedef enum yaml_encoding_e yaml_encoding_t;
+enum yaml_break_e {
+ YAML_ANY_BREAK = 0,
+ YAML_CR_BREAK = 1,
+ YAML_LN_BREAK = 2,
+ YAML_CRLN_BREAK = 3
+};
+typedef enum yaml_break_e yaml_break_t;
+enum yaml_error_type_e {
+ YAML_NO_ERROR = 0,
+ YAML_MEMORY_ERROR = 1,
+ YAML_READER_ERROR = 2,
+ YAML_SCANNER_ERROR = 3,
+ YAML_PARSER_ERROR = 4,
+ YAML_COMPOSER_ERROR = 5,
+ YAML_WRITER_ERROR = 6,
+ YAML_EMITTER_ERROR = 7
+};
+typedef enum yaml_error_type_e yaml_error_type_t;
+struct yaml_mark_s {
+ size_t index ;
+ size_t line ;
+ size_t column ;
+};
+typedef struct yaml_mark_s yaml_mark_t;
+enum yaml_scalar_style_e {
+ YAML_ANY_SCALAR_STYLE = 0,
+ YAML_PLAIN_SCALAR_STYLE = 1,
+ YAML_SINGLE_QUOTED_SCALAR_STYLE = 2,
+ YAML_DOUBLE_QUOTED_SCALAR_STYLE = 3,
+ YAML_LITERAL_SCALAR_STYLE = 4,
+ YAML_FOLDED_SCALAR_STYLE = 5
+};
+typedef enum yaml_scalar_style_e yaml_scalar_style_t;
+enum yaml_sequence_style_e {
+ YAML_ANY_SEQUENCE_STYLE = 0,
+ YAML_BLOCK_SEQUENCE_STYLE = 1,
+ YAML_FLOW_SEQUENCE_STYLE = 2
+};
+typedef enum yaml_sequence_style_e yaml_sequence_style_t;
+enum yaml_mapping_style_e {
+ YAML_ANY_MAPPING_STYLE = 0,
+ YAML_BLOCK_MAPPING_STYLE = 1,
+ YAML_FLOW_MAPPING_STYLE = 2
+};
+typedef enum yaml_mapping_style_e yaml_mapping_style_t;
+enum yaml_token_type_e {
+ YAML_NO_TOKEN = 0,
+ YAML_STREAM_START_TOKEN = 1,
+ YAML_STREAM_END_TOKEN = 2,
+ YAML_VERSION_DIRECTIVE_TOKEN = 3,
+ YAML_TAG_DIRECTIVE_TOKEN = 4,
+ YAML_DOCUMENT_START_TOKEN = 5,
+ YAML_DOCUMENT_END_TOKEN = 6,
+ YAML_BLOCK_SEQUENCE_START_TOKEN = 7,
+ YAML_BLOCK_MAPPING_START_TOKEN = 8,
+ YAML_BLOCK_END_TOKEN = 9,
+ YAML_FLOW_SEQUENCE_START_TOKEN = 10,
+ YAML_FLOW_SEQUENCE_END_TOKEN = 11,
+ YAML_FLOW_MAPPING_START_TOKEN = 12,
+ YAML_FLOW_MAPPING_END_TOKEN = 13,
+ YAML_BLOCK_ENTRY_TOKEN = 14,
+ YAML_FLOW_ENTRY_TOKEN = 15,
+ YAML_KEY_TOKEN = 16,
+ YAML_VALUE_TOKEN = 17,
+ YAML_ALIAS_TOKEN = 18,
+ YAML_ANCHOR_TOKEN = 19,
+ YAML_TAG_TOKEN = 20,
+ YAML_SCALAR_TOKEN = 21
+};
+typedef enum yaml_token_type_e yaml_token_type_t;
+struct __anonstruct_stream_start_2 {
+ yaml_encoding_t encoding ;
+};
+struct __anonstruct_alias_3 {
+ yaml_char_t *value ;
+};
+struct __anonstruct_anchor_4 {
+ yaml_char_t *value ;
+};
+struct __anonstruct_tag_5 {
+ yaml_char_t *handle ;
+ yaml_char_t *suffix ;
+};
+struct __anonstruct_scalar_6 {
+ yaml_char_t *value ;
+ size_t length ;
+ yaml_scalar_style_t style ;
+};
+struct __anonstruct_version_directive_7 {
+ int major ;
+ int minor ;
+};
+struct __anonstruct_tag_directive_8 {
+ yaml_char_t *handle ;
+ yaml_char_t *prefix ;
+};
+union __anonunion_data_1 {
+ struct __anonstruct_stream_start_2 stream_start ;
+ struct __anonstruct_alias_3 alias ;
+ struct __anonstruct_anchor_4 anchor ;
+ struct __anonstruct_tag_5 tag ;
+ struct __anonstruct_scalar_6 scalar ;
+ struct __anonstruct_version_directive_7 version_directive ;
+ struct __anonstruct_tag_directive_8 tag_directive ;
+};
+struct yaml_token_s {
+ yaml_token_type_t type ;
+ union __anonunion_data_1 data ;
+ yaml_mark_t start_mark ;
+ yaml_mark_t end_mark ;
+};
+typedef struct yaml_token_s yaml_token_t;
+enum yaml_event_type_e {
+ YAML_NO_EVENT = 0,
+ YAML_STREAM_START_EVENT = 1,
+ YAML_STREAM_END_EVENT = 2,
+ YAML_DOCUMENT_START_EVENT = 3,
+ YAML_DOCUMENT_END_EVENT = 4,
+ YAML_ALIAS_EVENT = 5,
+ YAML_SCALAR_EVENT = 6,
+ YAML_SEQUENCE_START_EVENT = 7,
+ YAML_SEQUENCE_END_EVENT = 8,
+ YAML_MAPPING_START_EVENT = 9,
+ YAML_MAPPING_END_EVENT = 10
+};
+typedef enum yaml_event_type_e yaml_event_type_t;
+struct __anonstruct_stream_start_10 {
+ yaml_encoding_t encoding ;
+};
+struct __anonstruct_tag_directives_12 {
+ yaml_tag_directive_t *start ;
+ yaml_tag_directive_t *end ;
+};
+struct __anonstruct_document_start_11 {
+ yaml_version_directive_t *version_directive ;
+ struct __anonstruct_tag_directives_12 tag_directives ;
+ int implicit ;
+};
+struct __anonstruct_document_end_13 {
+ int implicit ;
+};
+struct __anonstruct_alias_14 {
+ yaml_char_t *anchor ;
+};
+struct __anonstruct_scalar_15 {
+ yaml_char_t *anchor ;
+ yaml_char_t *tag ;
+ yaml_char_t *value ;
+ size_t length ;
+ int plain_implicit ;
+ int quoted_implicit ;
+ yaml_scalar_style_t style ;
+};
+struct __anonstruct_sequence_start_16 {
+ yaml_char_t *anchor ;
+ yaml_char_t *tag ;
+ int implicit ;
+ yaml_sequence_style_t style ;
+};
+struct __anonstruct_mapping_start_17 {
+ yaml_char_t *anchor ;
+ yaml_char_t *tag ;
+ int implicit ;
+ yaml_mapping_style_t style ;
+};
+union __anonunion_data_9 {
+ struct __anonstruct_stream_start_10 stream_start ;
+ struct __anonstruct_document_start_11 document_start ;
+ struct __anonstruct_document_end_13 document_end ;
+ struct __anonstruct_alias_14 alias ;
+ struct __anonstruct_scalar_15 scalar ;
+ struct __anonstruct_sequence_start_16 sequence_start ;
+ struct __anonstruct_mapping_start_17 mapping_start ;
+};
+struct yaml_event_s {
+ yaml_event_type_t type ;
+ union __anonunion_data_9 data ;
+ yaml_mark_t start_mark ;
+ yaml_mark_t end_mark ;
+};
+typedef struct yaml_event_s yaml_event_t;
+enum yaml_node_type_e {
+ YAML_NO_NODE = 0,
+ YAML_SCALAR_NODE = 1,
+ YAML_SEQUENCE_NODE = 2,
+ YAML_MAPPING_NODE = 3
+};
+typedef enum yaml_node_type_e yaml_node_type_t;
+struct yaml_node_s;
+typedef struct yaml_node_s yaml_node_t;
+typedef int yaml_node_item_t;
+struct yaml_node_pair_s {
+ int key ;
+ int value ;
+};
+typedef struct yaml_node_pair_s yaml_node_pair_t;
+struct __anonstruct_scalar_19 {
+ yaml_char_t *value ;
+ size_t length ;
+ yaml_scalar_style_t style ;
+};
+struct __anonstruct_items_21 {
+ yaml_node_item_t *start ;
+ yaml_node_item_t *end ;
+ yaml_node_item_t *top ;
+};
+struct __anonstruct_sequence_20 {
+ struct __anonstruct_items_21 items ;
+ yaml_sequence_style_t style ;
+};
+struct __anonstruct_pairs_23 {
+ yaml_node_pair_t *start ;
+ yaml_node_pair_t *end ;
+ yaml_node_pair_t *top ;
+};
+struct __anonstruct_mapping_22 {
+ struct __anonstruct_pairs_23 pairs ;
+ yaml_mapping_style_t style ;
+};
+union __anonunion_data_18 {
+ struct __anonstruct_scalar_19 scalar ;
+ struct __anonstruct_sequence_20 sequence ;
+ struct __anonstruct_mapping_22 mapping ;
+};
+struct yaml_node_s {
+ yaml_node_type_t type ;
+ yaml_char_t *tag ;
+ union __anonunion_data_18 data ;
+ yaml_mark_t start_mark ;
+ yaml_mark_t end_mark ;
+};
+struct __anonstruct_nodes_24 {
+ yaml_node_t *start ;
+ yaml_node_t *end ;
+ yaml_node_t *top ;
+};
+struct __anonstruct_tag_directives_25 {
+ yaml_tag_directive_t *start ;
+ yaml_tag_directive_t *end ;
+};
+struct yaml_document_s {
+ struct __anonstruct_nodes_24 nodes ;
+ yaml_version_directive_t *version_directive ;
+ struct __anonstruct_tag_directives_25 tag_directives ;
+ int start_implicit ;
+ int end_implicit ;
+ yaml_mark_t start_mark ;
+ yaml_mark_t end_mark ;
+};
+typedef struct yaml_document_s yaml_document_t;
+typedef int yaml_read_handler_t(void *data, unsigned char *buffer,
+ size_t size, size_t *size_read);
+struct yaml_simple_key_s {
+ int possible ;
+ int required ;
+ size_t token_number ;
+ yaml_mark_t mark ;
+};
+typedef struct yaml_simple_key_s yaml_simple_key_t;
+enum yaml_parser_state_e {
+ YAML_PARSE_STREAM_START_STATE = 0,
+ YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE = 1,
+ YAML_PARSE_DOCUMENT_START_STATE = 2,
+ YAML_PARSE_DOCUMENT_CONTENT_STATE = 3,
+ YAML_PARSE_DOCUMENT_END_STATE = 4,
+ YAML_PARSE_BLOCK_NODE_STATE = 5,
+ YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE = 6,
+ YAML_PARSE_FLOW_NODE_STATE = 7,
+ YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE = 8,
+ YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE = 9,
+ YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE = 10,
+ YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE = 11,
+ YAML_PARSE_BLOCK_MAPPING_KEY_STATE = 12,
+ YAML_PARSE_BLOCK_MAPPING_VALUE_STATE = 13,
+ YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE = 14,
+ YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE = 15,
+ YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE = 16,
+ YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE = 17,
+ YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE = 18,
+ YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE = 19,
+ YAML_PARSE_FLOW_MAPPING_KEY_STATE = 20,
+ YAML_PARSE_FLOW_MAPPING_VALUE_STATE = 21,
+ YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE = 22,
+ YAML_PARSE_END_STATE = 23
+};
+typedef enum yaml_parser_state_e yaml_parser_state_t;
+struct yaml_alias_data_s {
+ yaml_char_t *anchor ;
+ int index ;
+ yaml_mark_t mark ;
+};
+typedef struct yaml_alias_data_s yaml_alias_data_t;
+struct __anonstruct_string_27 {
+ unsigned char const *start ;
+ unsigned char const *end ;
+ unsigned char const *current ;
+};
+union __anonunion_input_26 {
+ struct __anonstruct_string_27 string ;
+ FILE *file ;
+};
+struct __anonstruct_buffer_28 {
+ yaml_char_t *start ;
+ yaml_char_t *end ;
+ yaml_char_t *pointer ;
+ yaml_char_t *last ;
+};
+struct __anonstruct_raw_buffer_29 {
+ unsigned char *start ;
+ unsigned char *end ;
+ unsigned char *pointer ;
+ unsigned char *last ;
+};
+struct __anonstruct_tokens_30 {
+ yaml_token_t *start ;
+ yaml_token_t *end ;
+ yaml_token_t *head ;
+ yaml_token_t *tail ;
+};
+struct __anonstruct_indents_31 {
+ int *start ;
+ int *end ;
+ int *top ;
+};
+struct __anonstruct_simple_keys_32 {
+ yaml_simple_key_t *start ;
+ yaml_simple_key_t *end ;
+ yaml_simple_key_t *top ;
+};
+struct __anonstruct_states_33 {
+ yaml_parser_state_t *start ;
+ yaml_parser_state_t *end ;
+ yaml_parser_state_t *top ;
+};
+struct __anonstruct_marks_34 {
+ yaml_mark_t *start ;
+ yaml_mark_t *end ;
+ yaml_mark_t *top ;
+};
+struct __anonstruct_tag_directives_35 {
+ yaml_tag_directive_t *start ;
+ yaml_tag_directive_t *end ;
+ yaml_tag_directive_t *top ;
+};
+struct __anonstruct_aliases_36 {
+ yaml_alias_data_t *start ;
+ yaml_alias_data_t *end ;
+ yaml_alias_data_t *top ;
+};
+struct yaml_parser_s {
+ yaml_error_type_t error ;
+ char const *problem ;
+ size_t problem_offset ;
+ int problem_value ;
+ yaml_mark_t problem_mark ;
+ char const *context ;
+ yaml_mark_t context_mark ;
+ yaml_read_handler_t *read_handler ;
+ void *read_handler_data ;
+ union __anonunion_input_26 input ;
+ int eof ;
+ struct __anonstruct_buffer_28 buffer ;
+ size_t unread ;
+ struct __anonstruct_raw_buffer_29 raw_buffer ;
+ yaml_encoding_t encoding ;
+ size_t offset ;
+ yaml_mark_t mark ;
+ int stream_start_produced ;
+ int stream_end_produced ;
+ int flow_level ;
+ struct __anonstruct_tokens_30 tokens ;
+ size_t tokens_parsed ;
+ int token_available ;
+ struct __anonstruct_indents_31 indents ;
+ int indent ;
+ int simple_key_allowed ;
+ struct __anonstruct_simple_keys_32 simple_keys ;
+ struct __anonstruct_states_33 states ;
+ yaml_parser_state_t state ;
+ struct __anonstruct_marks_34 marks ;
+ struct __anonstruct_tag_directives_35 tag_directives ;
+ struct __anonstruct_aliases_36 aliases ;
+ yaml_document_t *document ;
+};
+typedef struct yaml_parser_s yaml_parser_t;
+typedef int yaml_write_handler_t(void *data, unsigned char *buffer,
+ size_t size);
+enum yaml_emitter_state_e {
+ YAML_EMIT_STREAM_START_STATE = 0,
+ YAML_EMIT_FIRST_DOCUMENT_START_STATE = 1,
+ YAML_EMIT_DOCUMENT_START_STATE = 2,
+ YAML_EMIT_DOCUMENT_CONTENT_STATE = 3,
+ YAML_EMIT_DOCUMENT_END_STATE = 4,
+ YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE = 5,
+ YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE = 6,
+ YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE = 7,
+ YAML_EMIT_FLOW_MAPPING_KEY_STATE = 8,
+ YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE = 9,
+ YAML_EMIT_FLOW_MAPPING_VALUE_STATE = 10,
+ YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE = 11,
+ YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE = 12,
+ YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE = 13,
+ YAML_EMIT_BLOCK_MAPPING_KEY_STATE = 14,
+ YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE = 15,
+ YAML_EMIT_BLOCK_MAPPING_VALUE_STATE = 16,
+ YAML_EMIT_END_STATE = 17
+};
+typedef enum yaml_emitter_state_e yaml_emitter_state_t;
+struct yaml_anchors_s {
+ int references ;
+ int anchor ;
+ int serialized ;
+};
+typedef struct yaml_anchors_s yaml_anchors_t;
+struct __anonstruct_string_38 {
+ unsigned char *buffer ;
+ size_t size ;
+ size_t *size_written ;
+};
+union __anonunion_output_37 {
+ struct __anonstruct_string_38 string ;
+ FILE *file ;
+};
+struct __anonstruct_buffer_39 {
+ yaml_char_t *start ;
+ yaml_char_t *end ;
+ yaml_char_t *pointer ;
+ yaml_char_t *last ;
+};
+struct __anonstruct_raw_buffer_40 {
+ unsigned char *start ;
+ unsigned char *end ;
+ unsigned char *pointer ;
+ unsigned char *last ;
+};
+struct __anonstruct_states_41 {
+ yaml_emitter_state_t *start ;
+ yaml_emitter_state_t *end ;
+ yaml_emitter_state_t *top ;
+};
+struct __anonstruct_events_42 {
+ yaml_event_t *start ;
+ yaml_event_t *end ;
+ yaml_event_t *head ;
+ yaml_event_t *tail ;
+};
+struct __anonstruct_indents_43 {
+ int *start ;
+ int *end ;
+ int *top ;
+};
+struct __anonstruct_tag_directives_44 {
+ yaml_tag_directive_t *start ;
+ yaml_tag_directive_t *end ;
+ yaml_tag_directive_t *top ;
+};
+struct __anonstruct_anchor_data_45 {
+ yaml_char_t *anchor ;
+ size_t anchor_length ;
+ int alias ;
+};
+struct __anonstruct_tag_data_46 {
+ yaml_char_t *handle ;
+ size_t handle_length ;
+ yaml_char_t *suffix ;
+ size_t suffix_length ;
+};
+struct __anonstruct_scalar_data_47 {
+ yaml_char_t *value ;
+ size_t length ;
+ int multiline ;
+ int flow_plain_allowed ;
+ int block_plain_allowed ;
+ int single_quoted_allowed ;
+ int block_allowed ;
+ yaml_scalar_style_t style ;
+};
+struct yaml_emitter_s {
+ yaml_error_type_t error ;
+ char const *problem ;
+ yaml_write_handler_t *write_handler ;
+ void *write_handler_data ;
+ union __anonunion_output_37 output ;
+ struct __anonstruct_buffer_39 buffer ;
+ struct __anonstruct_raw_buffer_40 raw_buffer ;
+ yaml_encoding_t encoding ;
+ int canonical ;
+ int best_indent ;
+ int best_width ;
+ int unicode ;
+ yaml_break_t line_break ;
+ struct __anonstruct_states_41 states ;
+ yaml_emitter_state_t state ;
+ struct __anonstruct_events_42 events ;
+ struct __anonstruct_indents_43 indents ;
+ struct __anonstruct_tag_directives_44 tag_directives ;
+ int indent ;
+ int flow_level ;
+ int root_context ;
+ int sequence_context ;
+ int mapping_context ;
+ int simple_key_context ;
+ int line ;
+ int column ;
+ int whitespace ;
+ int indention ;
+ int open_ended ;
+ struct __anonstruct_anchor_data_45 anchor_data ;
+ struct __anonstruct_tag_data_46 tag_data ;
+ struct __anonstruct_scalar_data_47 scalar_data ;
+ int opened ;
+ int closed ;
+ yaml_anchors_t *anchors ;
+ int last_anchor_id ;
+ yaml_document_t *document ;
+};
+typedef struct yaml_emitter_s yaml_emitter_t;
+struct __anonstruct_yaml_string_t_48 {
+ yaml_char_t *start ;
+ yaml_char_t *end ;
+ yaml_char_t *pointer ;
+};
+typedef struct __anonstruct_yaml_string_t_48 yaml_string_t;
+struct __anonstruct_context_49 {
+ yaml_error_type_t error ;
+};
+struct __anonstruct_tag_directives_copy_50 {
+ yaml_tag_directive_t *start ;
+ yaml_tag_directive_t *end ;
+ yaml_tag_directive_t *top ;
+};
+struct __anonstruct_context_51 {
+ yaml_error_type_t error ;
+};
+struct __anonstruct_nodes_52 {
+ yaml_node_t *start ;
+ yaml_node_t *end ;
+ yaml_node_t *top ;
+};
+struct __anonstruct_tag_directives_copy_53 {
+ yaml_tag_directive_t *start ;
+ yaml_tag_directive_t *end ;
+ yaml_tag_directive_t *top ;
+};
+struct __anonstruct_context_54 {
+ yaml_error_type_t error ;
+};
+struct __anonstruct_context_55 {
+ yaml_error_type_t error ;
+};
+struct __anonstruct_items_56 {
+ yaml_node_item_t *start ;
+ yaml_node_item_t *end ;
+ yaml_node_item_t *top ;
+};
+struct __anonstruct_context_57 {
+ yaml_error_type_t error ;
+};
+struct __anonstruct_pairs_58 {
+ yaml_node_pair_t *start ;
+ yaml_node_pair_t *end ;
+ yaml_node_pair_t *top ;
+};
+struct __anonstruct_context_59 {
+ yaml_error_type_t error ;
+};
+struct __anonstruct_context_60 {
+ yaml_error_type_t error ;
+};
+struct loader_ctx {
+ int *start ;
+ int *end ;
+ int *top ;
+};
+struct __anonstruct_items_49 {
+ yaml_node_item_t *start ;
+ yaml_node_item_t *end ;
+ yaml_node_item_t *top ;
+};
+struct __anonstruct_pairs_50 {
+ yaml_node_pair_t *start ;
+ yaml_node_pair_t *end ;
+ yaml_node_pair_t *top ;
+};
+struct __anonstruct_tag_directives_49 {
+ yaml_tag_directive_t *start ;
+ yaml_tag_directive_t *end ;
+};
+struct __anonstruct_tag_directives_50 {
+ yaml_tag_directive_t *start ;
+ yaml_tag_directive_t *end ;
+ yaml_tag_directive_t *top ;
+};
+char const *yaml_get_version_string(void);
+
+void yaml_get_version(int *major, int *minor, int *patch);
+
+void yaml_token_delete(yaml_token_t *token);
+
+int yaml_stream_start_event_initialize(yaml_event_t *event,
+ yaml_encoding_t encoding);
+
+int yaml_stream_end_event_initialize(yaml_event_t *event);
+
+int yaml_document_start_event_initialize(yaml_event_t *event,
+ yaml_version_directive_t *version_directive,
+ yaml_tag_directive_t *tag_directives_start,
+ yaml_tag_directive_t *tag_directives_end,
+ int implicit);
+
+int yaml_document_end_event_initialize(yaml_event_t *event, int implicit);
+
+int yaml_alias_event_initialize(yaml_event_t *event,
+ yaml_char_t const *anchor);
+
+int yaml_scalar_event_initialize(yaml_event_t *event,
+ yaml_char_t const *anchor,
+ yaml_char_t const *tag,
+ yaml_char_t const *value, int length,
+ int plain_implicit, int quoted_implicit,
+ yaml_scalar_style_t style);
+
+int yaml_sequence_start_event_initialize(yaml_event_t *event,
+ yaml_char_t const *anchor,
+ yaml_char_t const *tag,
+ int implicit,
+ yaml_sequence_style_t style);
+
+int yaml_sequence_end_event_initialize(yaml_event_t *event);
+
+int yaml_mapping_start_event_initialize(yaml_event_t *event,
+ yaml_char_t const *anchor,
+ yaml_char_t const *tag, int implicit,
+ yaml_mapping_style_t style);
+
+int yaml_mapping_end_event_initialize(yaml_event_t *event);
+
+void yaml_event_delete(yaml_event_t *event);
+
+int yaml_document_initialize(yaml_document_t *document,
+ yaml_version_directive_t *version_directive,
+ yaml_tag_directive_t *tag_directives_start,
+ yaml_tag_directive_t *tag_directives_end,
+ int start_implicit, int end_implicit);
+
+void yaml_document_delete(yaml_document_t *document);
+
+yaml_node_t *yaml_document_get_node(yaml_document_t *document, int index_0);
+
+yaml_node_t *yaml_document_get_root_node(yaml_document_t *document);
+
+int yaml_document_add_scalar(yaml_document_t *document,
+ yaml_char_t const *tag,
+ yaml_char_t const *value, int length,
+ yaml_scalar_style_t style);
+
+int yaml_document_add_sequence(yaml_document_t *document,
+ yaml_char_t const *tag,
+ yaml_sequence_style_t style);
+
+int yaml_document_add_mapping(yaml_document_t *document,
+ yaml_char_t const *tag,
+ yaml_mapping_style_t style);
+
+int yaml_document_append_sequence_item(yaml_document_t *document,
+ int sequence, int item);
+
+int yaml_document_append_mapping_pair(yaml_document_t *document, int mapping,
+ int key, int value);
+
+int yaml_parser_initialize(yaml_parser_t *parser);
+
+void yaml_parser_delete(yaml_parser_t *parser);
+
+void yaml_parser_set_input_string(yaml_parser_t *parser,
+ unsigned char const *input, size_t size);
+
+void yaml_parser_set_input_file(yaml_parser_t *parser, FILE *file);
+
+void yaml_parser_set_input(yaml_parser_t *parser,
+ yaml_read_handler_t *handler, void *data);
+
+void yaml_parser_set_encoding(yaml_parser_t *parser, yaml_encoding_t encoding);
+
+int yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token);
+
+int yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event);
+
+int yaml_parser_load(yaml_parser_t *parser, yaml_document_t *document);
+
+int yaml_emitter_initialize(yaml_emitter_t *emitter);
+
+void yaml_emitter_delete(yaml_emitter_t *emitter);
+
+void yaml_emitter_set_output_string(yaml_emitter_t *emitter,
+ unsigned char *output, size_t size,
+ size_t *size_written);
+
+void yaml_emitter_set_output_file(yaml_emitter_t *emitter, FILE *file);
+
+void yaml_emitter_set_output(yaml_emitter_t *emitter,
+ yaml_write_handler_t *handler, void *data);
+
+void yaml_emitter_set_encoding(yaml_emitter_t *emitter,
+ yaml_encoding_t encoding);
+
+void yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical);
+
+void yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent);
+
+void yaml_emitter_set_width(yaml_emitter_t *emitter, int width);
+
+void yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode);
+
+void yaml_emitter_set_break(yaml_emitter_t *emitter, yaml_break_t line_break);
+
+int yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event);
+
+int yaml_emitter_open(yaml_emitter_t *emitter);
+
+int yaml_emitter_close(yaml_emitter_t *emitter);
+
+int yaml_emitter_dump(yaml_emitter_t *emitter, yaml_document_t *document);
+
+int yaml_emitter_flush(yaml_emitter_t *emitter);
+
+void *yaml_malloc(size_t size);
+
+void *yaml_realloc(void *ptr, size_t size);
+
+void yaml_free(void *ptr);
+
+yaml_char_t *yaml_strdup(yaml_char_t const *str);
+
+int yaml_parser_update_buffer(yaml_parser_t *parser, size_t length);
+
+int yaml_parser_fetch_more_tokens(yaml_parser_t *parser);
+
+int yaml_string_extend(yaml_char_t **start, yaml_char_t **pointer,
+ yaml_char_t **end);
+
+int yaml_string_join(yaml_char_t **a_start, yaml_char_t **a_pointer,
+ yaml_char_t **a_end, yaml_char_t **b_start,
+ yaml_char_t **b_pointer,
+ yaml_char_t **b_end __attribute__((__unused__)));
+
+int yaml_stack_extend(void **start, void **top, void **end);
+
+int yaml_queue_extend(void **start, void **head, void **tail, void **end);
+
+char const *yaml_get_version_string(void)
+{
+ char const *__retres;
+ __retres = "0.2.5";
+ return __retres;
+}
+
+void yaml_get_version(int *major, int *minor, int *patch)
+{
+ *major = 0;
+ *minor = 2;
+ *patch = 5;
+ return;
+}
+
+void *yaml_malloc(size_t size)
+{
+ void *tmp_0;
+ size_t tmp;
+ if (size) tmp = size; else tmp = (unsigned long)1;
+ tmp_0 = malloc(tmp);
+ return tmp_0;
+}
+
+void *yaml_realloc(void *ptr, size_t size)
+{
+ void *tmp_3;
+ if (ptr) {
+ void *tmp_0;
+ size_t tmp;
+ if (size) tmp = size; else tmp = (unsigned long)1;
+ ;
+ tmp_0 = realloc(ptr,tmp);
+ tmp_3 = tmp_0;
+ }
+ else {
+ void *tmp_2;
+ size_t tmp_1;
+ if (size) tmp_1 = size; else tmp_1 = (unsigned long)1;
+ tmp_2 = malloc(tmp_1);
+ tmp_3 = tmp_2;
+ }
+ return tmp_3;
+}
+
+void yaml_free(void *ptr)
+{
+ if (ptr) free(ptr);
+ return;
+}
+
+yaml_char_t *yaml_strdup(yaml_char_t const *str)
+{
+ yaml_char_t *__retres;
+ yaml_char_t *tmp;
+ if (! str) {
+ __retres = (yaml_char_t *)0;
+ goto return_label;
+ }
+ tmp = (yaml_char_t *)strdup((char const *)str);
+ __retres = tmp;
+ return_label: return __retres;
+}
+
+int yaml_string_extend(yaml_char_t **start, yaml_char_t **pointer,
+ yaml_char_t **end)
+{
+ int __retres;
+ yaml_char_t *new_start =
+ yaml_realloc((void *)*start,(unsigned long)((*end - *start) * (long)2));
+ if (! new_start) {
+ __retres = 0;
+ goto return_label;
+ }
+ memset((void *)(new_start + (*end - *start)),0,
+ (unsigned long)(*end - *start));
+ *pointer = new_start + (*pointer - *start);
+ *end = new_start + (*end - *start) * (long)2;
+ *start = new_start;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+int yaml_string_join(yaml_char_t **a_start, yaml_char_t **a_pointer,
+ yaml_char_t **a_end, yaml_char_t **b_start,
+ yaml_char_t **b_pointer,
+ yaml_char_t **b_end __attribute__((__unused__)))
+{
+ int __retres;
+ if (*b_start == *b_pointer) {
+ __retres = 1;
+ goto return_label;
+ }
+ while (*a_end - *a_pointer <= *b_pointer - *b_start) {
+ int tmp;
+ tmp = yaml_string_extend(a_start,a_pointer,a_end);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ memcpy((void *)*a_pointer,(void const *)*b_start,
+ (unsigned long)(*b_pointer - *b_start));
+ *a_pointer += *b_pointer - *b_start;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+int yaml_stack_extend(void **start, void **top, void **end)
+{
+ int __retres;
+ void *new_start;
+ if ((char *)*end - (char *)*start >= (long)(2147483647 / 2)) {
+ __retres = 0;
+ goto return_label;
+ }
+ new_start = yaml_realloc(*start,
+ (unsigned long)(((char *)*end - (char *)*start) * (long)2));
+ if (! new_start) {
+ __retres = 0;
+ goto return_label;
+ }
+ *top = (void *)((char *)new_start + ((char *)*top - (char *)*start));
+ *end = (void *)((char *)new_start + ((char *)*end - (char *)*start) * (long)2);
+ *start = new_start;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+int yaml_queue_extend(void **start, void **head, void **tail, void **end)
+{
+ int __retres;
+ if (*start == *head)
+ if (*tail == *end) {
+ void *new_start =
+ yaml_realloc(*start,
+ (unsigned long)(((char *)*end - (char *)*start) * (long)2));
+ if (! new_start) {
+ __retres = 0;
+ goto return_label;
+ }
+ *head = (void *)((char *)new_start + ((char *)*head - (char *)*start));
+ *tail = (void *)((char *)new_start + ((char *)*tail - (char *)*start));
+ *end = (void *)((char *)new_start + ((char *)*end - (char *)*start) * (long)2);
+ *start = new_start;
+ }
+ if (*tail == *end) {
+ if (*head != *tail) memmove(*start,(void const *)*head,
+ (unsigned long)((char *)*tail - (char *)*head));
+ *tail = (void *)((char *)*start + ((char *)*tail - (char *)*head));
+ *head = *start;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+int yaml_parser_initialize(yaml_parser_t *parser)
+{
+ int __retres;
+ int tmp_2;
+ unsigned char *tmp;
+ int tmp_6;
+ yaml_char_t *tmp_3;
+ int tmp_10;
+ yaml_token_t *tmp_7;
+ int tmp_13;
+ int *tmp_11;
+ int tmp_16;
+ yaml_simple_key_t *tmp_14;
+ int tmp_19;
+ yaml_parser_state_t *tmp_17;
+ int tmp_22;
+ yaml_mark_t *tmp_20;
+ int tmp_25;
+ yaml_tag_directive_t *tmp_23;
+ unsigned char *tmp_27;
+ unsigned char *tmp_26;
+ yaml_char_t *tmp_29;
+ yaml_char_t *tmp_28;
+ yaml_token_t *tmp_32;
+ yaml_token_t *tmp_31;
+ yaml_token_t *tmp_30;
+ int *tmp_34;
+ int *tmp_33;
+ yaml_simple_key_t *tmp_36;
+ yaml_simple_key_t *tmp_35;
+ yaml_parser_state_t *tmp_38;
+ yaml_parser_state_t *tmp_37;
+ yaml_mark_t *tmp_40;
+ yaml_mark_t *tmp_39;
+ yaml_tag_directive_t *tmp_42;
+ yaml_tag_directive_t *tmp_41;
+ __FC_assert(parser != (yaml_parser_t *)0,"src/api.c",179,"parser");
+ memset((void *)parser,0,sizeof(yaml_parser_t));
+ tmp = (unsigned char *)yaml_malloc((unsigned long)16384);
+ parser->raw_buffer.start = tmp;
+ if (tmp) {
+ unsigned char *tmp_1;
+ tmp_1 = parser->raw_buffer.start;
+ parser->raw_buffer.pointer = tmp_1;
+ parser->raw_buffer.last = tmp_1;
+ parser->raw_buffer.end = parser->raw_buffer.start + 16384;
+ tmp_2 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ if (! tmp_2) goto error;
+ tmp_3 = (yaml_char_t *)yaml_malloc((unsigned long)(16384 * 3));
+ parser->buffer.start = tmp_3;
+ if (tmp_3) {
+ yaml_char_t *tmp_5;
+ tmp_5 = parser->buffer.start;
+ parser->buffer.pointer = tmp_5;
+ parser->buffer.last = tmp_5;
+ parser->buffer.end = parser->buffer.start + 16384 * 3;
+ tmp_6 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_6 = 0;
+ }
+ if (! tmp_6) goto error;
+ tmp_7 = (yaml_token_t *)yaml_malloc((unsigned long)16 * sizeof(*(parser->tokens.start)));
+ parser->tokens.start = tmp_7;
+ if (tmp_7) {
+ yaml_token_t *tmp_9;
+ tmp_9 = parser->tokens.start;
+ parser->tokens.tail = tmp_9;
+ parser->tokens.head = tmp_9;
+ parser->tokens.end = parser->tokens.start + 16;
+ tmp_10 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_10 = 0;
+ }
+ if (! tmp_10) goto error;
+ tmp_11 = (int *)yaml_malloc((unsigned long)16 * sizeof(*(parser->indents.start)));
+ parser->indents.start = tmp_11;
+ if (tmp_11) {
+ parser->indents.top = parser->indents.start;
+ parser->indents.end = parser->indents.start + 16;
+ tmp_13 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_13 = 0;
+ }
+ if (! tmp_13) goto error;
+ tmp_14 = (yaml_simple_key_t *)yaml_malloc((unsigned long)16 * sizeof(*(parser->simple_keys.start)));
+ parser->simple_keys.start = tmp_14;
+ if (tmp_14) {
+ parser->simple_keys.top = parser->simple_keys.start;
+ parser->simple_keys.end = parser->simple_keys.start + 16;
+ tmp_16 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_16 = 0;
+ }
+ if (! tmp_16) goto error;
+ tmp_17 = (yaml_parser_state_t *)yaml_malloc((unsigned long)16 * sizeof(*(parser->states.start)));
+ parser->states.start = tmp_17;
+ if (tmp_17) {
+ parser->states.top = parser->states.start;
+ parser->states.end = parser->states.start + 16;
+ tmp_19 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_19 = 0;
+ }
+ if (! tmp_19) goto error;
+ tmp_20 = (yaml_mark_t *)yaml_malloc((unsigned long)16 * sizeof(*(parser->marks.start)));
+ parser->marks.start = tmp_20;
+ if (tmp_20) {
+ parser->marks.top = parser->marks.start;
+ parser->marks.end = parser->marks.start + 16;
+ tmp_22 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_22 = 0;
+ }
+ if (! tmp_22) goto error;
+ tmp_23 = (yaml_tag_directive_t *)yaml_malloc((unsigned long)16 * sizeof(*(parser->tag_directives.start)));
+ parser->tag_directives.start = tmp_23;
+ if (tmp_23) {
+ parser->tag_directives.top = parser->tag_directives.start;
+ parser->tag_directives.end = parser->tag_directives.start + 16;
+ tmp_25 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_25 = 0;
+ }
+ if (! tmp_25) goto error;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)parser->raw_buffer.start);
+ tmp_27 = (unsigned char *)0;
+ parser->raw_buffer.end = tmp_27;
+ tmp_26 = tmp_27;
+ parser->raw_buffer.pointer = tmp_26;
+ parser->raw_buffer.start = tmp_26;
+ yaml_free((void *)parser->buffer.start);
+ tmp_29 = (yaml_char_t *)0;
+ parser->buffer.end = tmp_29;
+ tmp_28 = tmp_29;
+ parser->buffer.pointer = tmp_28;
+ parser->buffer.start = tmp_28;
+ yaml_free((void *)parser->tokens.start);
+ tmp_32 = (yaml_token_t *)0;
+ parser->tokens.end = tmp_32;
+ tmp_31 = tmp_32;
+ parser->tokens.tail = tmp_31;
+ tmp_30 = tmp_31;
+ parser->tokens.head = tmp_30;
+ parser->tokens.start = tmp_30;
+ yaml_free((void *)parser->indents.start);
+ tmp_34 = (int *)0;
+ parser->indents.end = tmp_34;
+ tmp_33 = tmp_34;
+ parser->indents.top = tmp_33;
+ parser->indents.start = tmp_33;
+ yaml_free((void *)parser->simple_keys.start);
+ tmp_36 = (yaml_simple_key_t *)0;
+ parser->simple_keys.end = tmp_36;
+ tmp_35 = tmp_36;
+ parser->simple_keys.top = tmp_35;
+ parser->simple_keys.start = tmp_35;
+ yaml_free((void *)parser->states.start);
+ tmp_38 = (yaml_parser_state_t *)0;
+ parser->states.end = tmp_38;
+ tmp_37 = tmp_38;
+ parser->states.top = tmp_37;
+ parser->states.start = tmp_37;
+ yaml_free((void *)parser->marks.start);
+ tmp_40 = (yaml_mark_t *)0;
+ parser->marks.end = tmp_40;
+ tmp_39 = tmp_40;
+ parser->marks.top = tmp_39;
+ parser->marks.start = tmp_39;
+ yaml_free((void *)parser->tag_directives.start);
+ tmp_42 = (yaml_tag_directive_t *)0;
+ parser->tag_directives.end = tmp_42;
+ tmp_41 = tmp_42;
+ parser->tag_directives.top = tmp_41;
+ parser->tag_directives.start = tmp_41;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+void yaml_parser_delete(yaml_parser_t *parser)
+{
+ unsigned char *tmp_0;
+ unsigned char *tmp;
+ yaml_char_t *tmp_2;
+ yaml_char_t *tmp_1;
+ yaml_token_t *tmp_6;
+ yaml_token_t *tmp_5;
+ yaml_token_t *tmp_4;
+ int *tmp_8;
+ int *tmp_7;
+ yaml_simple_key_t *tmp_10;
+ yaml_simple_key_t *tmp_9;
+ yaml_parser_state_t *tmp_12;
+ yaml_parser_state_t *tmp_11;
+ yaml_mark_t *tmp_14;
+ yaml_mark_t *tmp_13;
+ yaml_tag_directive_t *tmp_16;
+ yaml_tag_directive_t *tmp_15;
+ __FC_assert(parser != (yaml_parser_t *)0,"src/api.c",222,"parser");
+ yaml_free((void *)parser->raw_buffer.start);
+ tmp_0 = (unsigned char *)0;
+ parser->raw_buffer.end = tmp_0;
+ tmp = tmp_0;
+ parser->raw_buffer.pointer = tmp;
+ parser->raw_buffer.start = tmp;
+ yaml_free((void *)parser->buffer.start);
+ tmp_2 = (yaml_char_t *)0;
+ parser->buffer.end = tmp_2;
+ tmp_1 = tmp_2;
+ parser->buffer.pointer = tmp_1;
+ parser->buffer.start = tmp_1;
+ while (! (parser->tokens.head == parser->tokens.tail)) {
+ yaml_token_t *tmp_3;
+ tmp_3 = parser->tokens.head;
+ (parser->tokens.head) ++;
+ ;
+ yaml_token_delete(tmp_3);
+ }
+ yaml_free((void *)parser->tokens.start);
+ tmp_6 = (yaml_token_t *)0;
+ parser->tokens.end = tmp_6;
+ tmp_5 = tmp_6;
+ parser->tokens.tail = tmp_5;
+ tmp_4 = tmp_5;
+ parser->tokens.head = tmp_4;
+ parser->tokens.start = tmp_4;
+ yaml_free((void *)parser->indents.start);
+ tmp_8 = (int *)0;
+ parser->indents.end = tmp_8;
+ tmp_7 = tmp_8;
+ parser->indents.top = tmp_7;
+ parser->indents.start = tmp_7;
+ yaml_free((void *)parser->simple_keys.start);
+ tmp_10 = (yaml_simple_key_t *)0;
+ parser->simple_keys.end = tmp_10;
+ tmp_9 = tmp_10;
+ parser->simple_keys.top = tmp_9;
+ parser->simple_keys.start = tmp_9;
+ yaml_free((void *)parser->states.start);
+ tmp_12 = (yaml_parser_state_t *)0;
+ parser->states.end = tmp_12;
+ tmp_11 = tmp_12;
+ parser->states.top = tmp_11;
+ parser->states.start = tmp_11;
+ yaml_free((void *)parser->marks.start);
+ tmp_14 = (yaml_mark_t *)0;
+ parser->marks.end = tmp_14;
+ tmp_13 = tmp_14;
+ parser->marks.top = tmp_13;
+ parser->marks.start = tmp_13;
+ while (! (parser->tag_directives.start == parser->tag_directives.top)) {
+ (parser->tag_directives.top) --;
+ yaml_tag_directive_t tag_directive = *(parser->tag_directives.top);
+ yaml_free((void *)tag_directive.handle);
+ yaml_free((void *)tag_directive.prefix);
+ }
+ yaml_free((void *)parser->tag_directives.start);
+ tmp_16 = (yaml_tag_directive_t *)0;
+ parser->tag_directives.end = tmp_16;
+ tmp_15 = tmp_16;
+ parser->tag_directives.top = tmp_15;
+ parser->tag_directives.start = tmp_15;
+ memset((void *)parser,0,sizeof(yaml_parser_t));
+ return;
+}
+
+static int yaml_string_read_handler(void *data, unsigned char *buffer,
+ size_t size, size_t *size_read)
+{
+ int __retres;
+ yaml_parser_t *parser = (yaml_parser_t *)data;
+ if (parser->input.string.current == parser->input.string.end) {
+ *size_read = (unsigned long)0;
+ __retres = 1;
+ goto return_label;
+ }
+ if (size > (unsigned long)(parser->input.string.end - parser->input.string.current))
+ size = (unsigned long)(parser->input.string.end - parser->input.string.current);
+ memcpy((void *)buffer,(void const *)parser->input.string.current,size);
+ parser->input.string.current += size;
+ *size_read = size;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_file_read_handler(void *data, unsigned char *buffer,
+ size_t size, size_t *size_read)
+{
+ int tmp_0;
+ int tmp;
+ yaml_parser_t *parser = (yaml_parser_t *)data;
+ *size_read = fread((void *)buffer,(unsigned long)1,size,parser->input.file);
+ tmp = ferror(parser->input.file);
+ if (tmp) tmp_0 = 0; else tmp_0 = 1;
+ return tmp_0;
+}
+
+void yaml_parser_set_input_string(yaml_parser_t *parser,
+ unsigned char const *input, size_t size)
+{
+ __FC_assert(parser != (yaml_parser_t *)0,"src/api.c",292,"parser");
+ __FC_assert(! parser->read_handler != 0,"src/api.c",293,
+ "!parser->read_handler");
+ __FC_assert(input != (unsigned char const *)0,"src/api.c",294,"input");
+ parser->read_handler = & yaml_string_read_handler;
+ parser->read_handler_data = (void *)parser;
+ parser->input.string.start = input;
+ parser->input.string.current = input;
+ parser->input.string.end = input + size;
+ return;
+}
+
+void yaml_parser_set_input_file(yaml_parser_t *parser, FILE *file)
+{
+ __FC_assert(parser != (yaml_parser_t *)0,"src/api.c",311,"parser");
+ __FC_assert(! parser->read_handler != 0,"src/api.c",312,
+ "!parser->read_handler");
+ __FC_assert(file != (FILE *)0,"src/api.c",313,"file");
+ parser->read_handler = & yaml_file_read_handler;
+ parser->read_handler_data = (void *)parser;
+ parser->input.file = file;
+ return;
+}
+
+void yaml_parser_set_input(yaml_parser_t *parser,
+ yaml_read_handler_t *handler, void *data)
+{
+ __FC_assert(parser != (yaml_parser_t *)0,"src/api.c",329,"parser");
+ __FC_assert(! parser->read_handler != 0,"src/api.c",330,
+ "!parser->read_handler");
+ __FC_assert(handler != (yaml_read_handler_t *)0,"src/api.c",331,"handler");
+ parser->read_handler = handler;
+ parser->read_handler_data = data;
+ return;
+}
+
+void yaml_parser_set_encoding(yaml_parser_t *parser, yaml_encoding_t encoding)
+{
+ __FC_assert(parser != (yaml_parser_t *)0,"src/api.c",344,"parser");
+ __FC_assert(! parser->encoding != 0,"src/api.c",345,"!parser->encoding");
+ parser->encoding = encoding;
+ return;
+}
+
+int yaml_emitter_initialize(yaml_emitter_t *emitter)
+{
+ int __retres;
+ int tmp_2;
+ yaml_char_t *tmp;
+ int tmp_6;
+ unsigned char *tmp_3;
+ int tmp_9;
+ yaml_emitter_state_t *tmp_7;
+ int tmp_13;
+ yaml_event_t *tmp_10;
+ int tmp_16;
+ int *tmp_14;
+ int tmp_19;
+ yaml_tag_directive_t *tmp_17;
+ yaml_char_t *tmp_21;
+ yaml_char_t *tmp_20;
+ unsigned char *tmp_23;
+ unsigned char *tmp_22;
+ yaml_emitter_state_t *tmp_25;
+ yaml_emitter_state_t *tmp_24;
+ yaml_event_t *tmp_28;
+ yaml_event_t *tmp_27;
+ yaml_event_t *tmp_26;
+ int *tmp_30;
+ int *tmp_29;
+ yaml_tag_directive_t *tmp_32;
+ yaml_tag_directive_t *tmp_31;
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/api.c",357,"emitter");
+ memset((void *)emitter,0,sizeof(yaml_emitter_t));
+ tmp = (yaml_char_t *)yaml_malloc((unsigned long)16384);
+ emitter->buffer.start = tmp;
+ if (tmp) {
+ yaml_char_t *tmp_1;
+ tmp_1 = emitter->buffer.start;
+ emitter->buffer.pointer = tmp_1;
+ emitter->buffer.last = tmp_1;
+ emitter->buffer.end = emitter->buffer.start + 16384;
+ tmp_2 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ if (! tmp_2) goto error;
+ tmp_3 = (unsigned char *)yaml_malloc((unsigned long)(16384 * 2 + 2));
+ emitter->raw_buffer.start = tmp_3;
+ if (tmp_3) {
+ unsigned char *tmp_5;
+ tmp_5 = emitter->raw_buffer.start;
+ emitter->raw_buffer.pointer = tmp_5;
+ emitter->raw_buffer.last = tmp_5;
+ emitter->raw_buffer.end = emitter->raw_buffer.start + (16384 * 2 + 2);
+ tmp_6 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_6 = 0;
+ }
+ if (! tmp_6) goto error;
+ tmp_7 = (yaml_emitter_state_t *)yaml_malloc((unsigned long)16 * sizeof(*(emitter->states.start)));
+ emitter->states.start = tmp_7;
+ if (tmp_7) {
+ emitter->states.top = emitter->states.start;
+ emitter->states.end = emitter->states.start + 16;
+ tmp_9 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_9 = 0;
+ }
+ if (! tmp_9) goto error;
+ tmp_10 = (yaml_event_t *)yaml_malloc((unsigned long)16 * sizeof(*(emitter->events.start)));
+ emitter->events.start = tmp_10;
+ if (tmp_10) {
+ yaml_event_t *tmp_12;
+ tmp_12 = emitter->events.start;
+ emitter->events.tail = tmp_12;
+ emitter->events.head = tmp_12;
+ emitter->events.end = emitter->events.start + 16;
+ tmp_13 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_13 = 0;
+ }
+ if (! tmp_13) goto error;
+ tmp_14 = (int *)yaml_malloc((unsigned long)16 * sizeof(*(emitter->indents.start)));
+ emitter->indents.start = tmp_14;
+ if (tmp_14) {
+ emitter->indents.top = emitter->indents.start;
+ emitter->indents.end = emitter->indents.start + 16;
+ tmp_16 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_16 = 0;
+ }
+ if (! tmp_16) goto error;
+ tmp_17 = (yaml_tag_directive_t *)yaml_malloc((unsigned long)16 * sizeof(*(emitter->tag_directives.start)));
+ emitter->tag_directives.start = tmp_17;
+ if (tmp_17) {
+ emitter->tag_directives.top = emitter->tag_directives.start;
+ emitter->tag_directives.end = emitter->tag_directives.start + 16;
+ tmp_19 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_19 = 0;
+ }
+ if (! tmp_19) goto error;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)emitter->buffer.start);
+ tmp_21 = (yaml_char_t *)0;
+ emitter->buffer.end = tmp_21;
+ tmp_20 = tmp_21;
+ emitter->buffer.pointer = tmp_20;
+ emitter->buffer.start = tmp_20;
+ yaml_free((void *)emitter->raw_buffer.start);
+ tmp_23 = (unsigned char *)0;
+ emitter->raw_buffer.end = tmp_23;
+ tmp_22 = tmp_23;
+ emitter->raw_buffer.pointer = tmp_22;
+ emitter->raw_buffer.start = tmp_22;
+ yaml_free((void *)emitter->states.start);
+ tmp_25 = (yaml_emitter_state_t *)0;
+ emitter->states.end = tmp_25;
+ tmp_24 = tmp_25;
+ emitter->states.top = tmp_24;
+ emitter->states.start = tmp_24;
+ yaml_free((void *)emitter->events.start);
+ tmp_28 = (yaml_event_t *)0;
+ emitter->events.end = tmp_28;
+ tmp_27 = tmp_28;
+ emitter->events.tail = tmp_27;
+ tmp_26 = tmp_27;
+ emitter->events.head = tmp_26;
+ emitter->events.start = tmp_26;
+ yaml_free((void *)emitter->indents.start);
+ tmp_30 = (int *)0;
+ emitter->indents.end = tmp_30;
+ tmp_29 = tmp_30;
+ emitter->indents.top = tmp_29;
+ emitter->indents.start = tmp_29;
+ yaml_free((void *)emitter->tag_directives.start);
+ tmp_32 = (yaml_tag_directive_t *)0;
+ emitter->tag_directives.end = tmp_32;
+ tmp_31 = tmp_32;
+ emitter->tag_directives.top = tmp_31;
+ emitter->tag_directives.start = tmp_31;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+void yaml_emitter_delete(yaml_emitter_t *emitter)
+{
+ yaml_char_t *tmp_0;
+ yaml_char_t *tmp;
+ unsigned char *tmp_2;
+ unsigned char *tmp_1;
+ yaml_emitter_state_t *tmp_4;
+ yaml_emitter_state_t *tmp_3;
+ yaml_event_t *tmp_8;
+ yaml_event_t *tmp_7;
+ yaml_event_t *tmp_6;
+ int *tmp_10;
+ int *tmp_9;
+ yaml_tag_directive_t *tmp_12;
+ yaml_tag_directive_t *tmp_11;
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/api.c",394,"emitter");
+ yaml_free((void *)emitter->buffer.start);
+ tmp_0 = (yaml_char_t *)0;
+ emitter->buffer.end = tmp_0;
+ tmp = tmp_0;
+ emitter->buffer.pointer = tmp;
+ emitter->buffer.start = tmp;
+ yaml_free((void *)emitter->raw_buffer.start);
+ tmp_2 = (unsigned char *)0;
+ emitter->raw_buffer.end = tmp_2;
+ tmp_1 = tmp_2;
+ emitter->raw_buffer.pointer = tmp_1;
+ emitter->raw_buffer.start = tmp_1;
+ yaml_free((void *)emitter->states.start);
+ tmp_4 = (yaml_emitter_state_t *)0;
+ emitter->states.end = tmp_4;
+ tmp_3 = tmp_4;
+ emitter->states.top = tmp_3;
+ emitter->states.start = tmp_3;
+ while (! (emitter->events.head == emitter->events.tail)) {
+ yaml_event_t *tmp_5;
+ tmp_5 = emitter->events.head;
+ (emitter->events.head) ++;
+ ;
+ yaml_event_delete(tmp_5);
+ }
+ yaml_free((void *)emitter->events.start);
+ tmp_8 = (yaml_event_t *)0;
+ emitter->events.end = tmp_8;
+ tmp_7 = tmp_8;
+ emitter->events.tail = tmp_7;
+ tmp_6 = tmp_7;
+ emitter->events.head = tmp_6;
+ emitter->events.start = tmp_6;
+ yaml_free((void *)emitter->indents.start);
+ tmp_10 = (int *)0;
+ emitter->indents.end = tmp_10;
+ tmp_9 = tmp_10;
+ emitter->indents.top = tmp_9;
+ emitter->indents.start = tmp_9;
+ while (! (emitter->tag_directives.start == emitter->tag_directives.top)) {
+ (emitter->tag_directives.top) --;
+ yaml_tag_directive_t tag_directive = *(emitter->tag_directives.top);
+ yaml_free((void *)tag_directive.handle);
+ yaml_free((void *)tag_directive.prefix);
+ }
+ yaml_free((void *)emitter->tag_directives.start);
+ tmp_12 = (yaml_tag_directive_t *)0;
+ emitter->tag_directives.end = tmp_12;
+ tmp_11 = tmp_12;
+ emitter->tag_directives.top = tmp_11;
+ emitter->tag_directives.start = tmp_11;
+ yaml_free((void *)emitter->anchors);
+ memset((void *)emitter,0,sizeof(yaml_emitter_t));
+ return;
+}
+
+static int yaml_string_write_handler(void *data, unsigned char *buffer,
+ size_t size)
+{
+ int __retres;
+ yaml_emitter_t *emitter = (yaml_emitter_t *)data;
+ if (emitter->output.string.size - *(emitter->output.string.size_written) < size) {
+ memcpy((void *)(emitter->output.string.buffer + *(emitter->output.string.size_written)),
+ (void const *)buffer,
+ emitter->output.string.size - *(emitter->output.string.size_written));
+ *(emitter->output.string.size_written) = emitter->output.string.size;
+ __retres = 0;
+ goto return_label;
+ }
+ memcpy((void *)(emitter->output.string.buffer + *(emitter->output.string.size_written)),
+ (void const *)buffer,size);
+ *(emitter->output.string.size_written) += size;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_file_write_handler(void *data, unsigned char *buffer,
+ size_t size)
+{
+ int __retres;
+ size_t tmp;
+ yaml_emitter_t *emitter = (yaml_emitter_t *)data;
+ tmp = fwrite((void const *)buffer,(unsigned long)1,size,
+ emitter->output.file);
+ ;
+ __retres = tmp == size;
+ return __retres;
+}
+
+void yaml_emitter_set_output_string(yaml_emitter_t *emitter,
+ unsigned char *output, size_t size,
+ size_t *size_written)
+{
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/api.c",460,"emitter");
+ __FC_assert(! emitter->write_handler != 0,"src/api.c",461,
+ "!emitter->write_handler");
+ __FC_assert(output != (unsigned char *)0,"src/api.c",462,"output");
+ emitter->write_handler = & yaml_string_write_handler;
+ emitter->write_handler_data = (void *)emitter;
+ emitter->output.string.buffer = output;
+ emitter->output.string.size = size;
+ emitter->output.string.size_written = size_written;
+ *size_written = (unsigned long)0;
+ return;
+}
+
+void yaml_emitter_set_output_file(yaml_emitter_t *emitter, FILE *file)
+{
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/api.c",480,"emitter");
+ __FC_assert(! emitter->write_handler != 0,"src/api.c",481,
+ "!emitter->write_handler");
+ __FC_assert(file != (FILE *)0,"src/api.c",482,"file");
+ emitter->write_handler = & yaml_file_write_handler;
+ emitter->write_handler_data = (void *)emitter;
+ emitter->output.file = file;
+ return;
+}
+
+void yaml_emitter_set_output(yaml_emitter_t *emitter,
+ yaml_write_handler_t *handler, void *data)
+{
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/api.c",498,"emitter");
+ __FC_assert(! emitter->write_handler != 0,"src/api.c",499,
+ "!emitter->write_handler");
+ __FC_assert(handler != (yaml_write_handler_t *)0,"src/api.c",500,"handler");
+ emitter->write_handler = handler;
+ emitter->write_handler_data = data;
+ return;
+}
+
+void yaml_emitter_set_encoding(yaml_emitter_t *emitter,
+ yaml_encoding_t encoding)
+{
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/api.c",513,"emitter");
+ __FC_assert(! emitter->encoding != 0,"src/api.c",514,"!emitter->encoding");
+ emitter->encoding = encoding;
+ return;
+}
+
+void yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical)
+{
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/api.c",526,"emitter");
+ emitter->canonical = canonical != 0;
+ return;
+}
+
+void yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent)
+{
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/api.c",538,"emitter");
+ if (1 < indent)
+ if (indent < 10) emitter->best_indent = indent;
+ else emitter->best_indent = 2;
+ else emitter->best_indent = 2;
+ return;
+}
+
+void yaml_emitter_set_width(yaml_emitter_t *emitter, int width)
+{
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/api.c",550,"emitter");
+ if (width >= 0) emitter->best_width = width; else emitter->best_width = -1;
+ return;
+}
+
+void yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode)
+{
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/api.c",562,"emitter");
+ emitter->unicode = unicode != 0;
+ return;
+}
+
+void yaml_emitter_set_break(yaml_emitter_t *emitter, yaml_break_t line_break)
+{
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/api.c",574,"emitter");
+ emitter->line_break = line_break;
+ return;
+}
+
+void yaml_token_delete(yaml_token_t *token)
+{
+ __FC_assert(token != (yaml_token_t *)0,"src/api.c",586,"token");
+ switch (token->type) {
+ case (yaml_token_type_t)YAML_TAG_DIRECTIVE_TOKEN:
+ yaml_free((void *)token->data.tag_directive.handle);
+ yaml_free((void *)token->data.tag_directive.prefix);
+ break;
+ case (yaml_token_type_t)YAML_ALIAS_TOKEN:
+ yaml_free((void *)token->data.alias.value);
+ break;
+ case (yaml_token_type_t)YAML_ANCHOR_TOKEN:
+ yaml_free((void *)token->data.anchor.value);
+ break;
+ case (yaml_token_type_t)YAML_TAG_TOKEN:
+ yaml_free((void *)token->data.tag.handle);
+ yaml_free((void *)token->data.tag.suffix);
+ break;
+ case (yaml_token_type_t)YAML_SCALAR_TOKEN:
+ yaml_free((void *)token->data.scalar.value);
+ break;
+ default: break;
+ }
+ memset((void *)token,0,sizeof(yaml_token_t));
+ return;
+}
+
+static int yaml_check_utf8(yaml_char_t const *start, size_t length)
+{
+ int __retres;
+ yaml_char_t const *end = start + length;
+ yaml_char_t const *pointer = start;
+ while (pointer < end) {
+ unsigned char octet;
+ unsigned int width;
+ unsigned int value;
+ size_t k;
+ octet = *(pointer + 0);
+ if (((int)octet & 0x80) == 0x00) width = (unsigned int)1;
+ else {
+ int tmp_1;
+ if (((int)octet & 0xE0) == 0xC0) tmp_1 = 2;
+ else {
+ int tmp_0;
+ if (((int)octet & 0xF0) == 0xE0) tmp_0 = 3;
+ else {
+ int tmp;
+ if (((int)octet & 0xF8) == 0xF0) tmp = 4; else tmp = 0;
+ tmp_0 = tmp;
+ }
+ tmp_1 = tmp_0;
+ }
+ width = (unsigned int)tmp_1;
+ }
+ if (((int)octet & 0x80) == 0x00) value = (unsigned int)((int)octet & 0x7F);
+ else {
+ int tmp_4;
+ if (((int)octet & 0xE0) == 0xC0) tmp_4 = (int)octet & 0x1F;
+ else {
+ int tmp_3;
+ if (((int)octet & 0xF0) == 0xE0) tmp_3 = (int)octet & 0x0F;
+ else {
+ int tmp_2;
+ if (((int)octet & 0xF8) == 0xF0) tmp_2 = (int)octet & 0x07;
+ else tmp_2 = 0;
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ value = (unsigned int)tmp_4;
+ }
+ if (! width) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (pointer + width > end) {
+ __retres = 0;
+ goto return_label;
+ }
+ k = (unsigned long)1;
+ while (k < (size_t)width) {
+ octet = *(pointer + k);
+ if (((int)octet & 0xC0) != 0x80) {
+ __retres = 0;
+ goto return_label;
+ }
+ value = (value << 6) + (unsigned int)((int)octet & 0x3F);
+ k += (size_t)1;
+ }
+ if (! (width == (unsigned int)1))
+ if (width == (unsigned int)2) {
+ if (! (value >= (unsigned int)0x80)) goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if (width == (unsigned int)3) {
+ if (! (value >= (unsigned int)0x800)) goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (width == (unsigned int)4) {
+ if (! (value >= (unsigned int)0x10000)) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ pointer += width;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+int yaml_stream_start_event_initialize(yaml_event_t *event,
+ yaml_encoding_t encoding)
+{
+ int __retres;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ __FC_assert(event != (yaml_event_t *)0,"src/api.c",674,"event");
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_STREAM_START_EVENT;
+ event->start_mark = mark;
+ event->end_mark = mark;
+ event->data.stream_start.encoding = encoding;
+ __retres = 1;
+ return __retres;
+}
+
+int yaml_stream_end_event_initialize(yaml_event_t *event)
+{
+ int __retres;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ __FC_assert(event != (yaml_event_t *)0,"src/api.c",690,"event");
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_STREAM_END_EVENT;
+ event->start_mark = mark;
+ event->end_mark = mark;
+ __retres = 1;
+ return __retres;
+}
+
+int yaml_document_start_event_initialize(yaml_event_t *event,
+ yaml_version_directive_t *version_directive,
+ yaml_tag_directive_t *tag_directives_start,
+ yaml_tag_directive_t *tag_directives_end,
+ int implicit)
+{
+ int __retres;
+ struct __anonstruct_context_49 context;
+ int tmp;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ yaml_version_directive_t *version_directive_copy =
+ (yaml_version_directive_t *)0;
+ struct __anonstruct_tag_directives_copy_50 tag_directives_copy =
+ {.start = (yaml_tag_directive_t *)0,
+ .end = (yaml_tag_directive_t *)0,
+ .top = (yaml_tag_directive_t *)0};
+ yaml_tag_directive_t value =
+ {.handle = (yaml_char_t *)0, .prefix = (yaml_char_t *)0};
+ __FC_assert(event != (yaml_event_t *)0,"src/api.c",720,"event");
+ if (tag_directives_start) {
+ if (tag_directives_end) tmp = 1; else goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (tag_directives_start == tag_directives_end) tmp = 1; else tmp = 0;
+ }
+ __FC_assert(tmp != 0,"src/api.c",721,
+ "(tag_directives_start && tag_directives_end) || (tag_directives_start == tag_directives_end)");
+ if (version_directive) {
+ version_directive_copy = (yaml_version_directive_t *)yaml_malloc(sizeof(yaml_version_directive_t));
+ if (! version_directive_copy) goto error;
+ version_directive_copy->major = version_directive->major;
+ version_directive_copy->minor = version_directive->minor;
+ }
+ if (tag_directives_start != tag_directives_end) {
+ yaml_tag_directive_t *tag_directive;
+ int tmp_2;
+ tag_directives_copy.start = (yaml_tag_directive_t *)yaml_malloc((unsigned long)16 * sizeof(*(tag_directives_copy.start)));
+ if (tag_directives_copy.start) {
+ tag_directives_copy.top = tag_directives_copy.start;
+ tag_directives_copy.end = tag_directives_copy.start + 16;
+ tmp_2 = 1;
+ }
+ else {
+ context.error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ if (! tmp_2) goto error;
+ tag_directive = tag_directives_start;
+ while (tag_directive != tag_directives_end) {
+ {
+ int tmp_4;
+ size_t tmp_3;
+ int tmp_6;
+ size_t tmp_5;
+ int tmp_9;
+ __FC_assert(tag_directive->handle != (yaml_char_t *)0,"src/api.c",
+ 738,"tag_directive->handle");
+ __FC_assert(tag_directive->prefix != (yaml_char_t *)0,"src/api.c",
+ 739,"tag_directive->prefix");
+ tmp_3 = strlen((char const *)tag_directive->handle);
+ ;
+ tmp_4 = yaml_check_utf8((yaml_char_t const *)tag_directive->handle,
+ tmp_3);
+ if (! tmp_4) goto error;
+ tmp_5 = strlen((char const *)tag_directive->prefix);
+ ;
+ tmp_6 = yaml_check_utf8((yaml_char_t const *)tag_directive->prefix,
+ tmp_5);
+ if (! tmp_6) goto error;
+ value.handle = yaml_strdup((yaml_char_t const *)tag_directive->handle);
+ value.prefix = yaml_strdup((yaml_char_t const *)tag_directive->prefix);
+ if (! value.handle) goto error;
+ else
+ if (! value.prefix) goto error;
+ if (tag_directives_copy.top != tag_directives_copy.end) goto _LOR;
+ else {
+ int tmp_7;
+ tmp_7 = yaml_stack_extend((void **)(& tag_directives_copy.start),
+ (void **)(& tag_directives_copy.top),
+ (void **)(& tag_directives_copy.end));
+ if (tmp_7) {
+ yaml_tag_directive_t *tmp_8;
+ _LOR: tmp_8 = tag_directives_copy.top;
+ (tag_directives_copy.top) ++;
+ *tmp_8 = value;
+ tmp_9 = 1;
+ }
+ else {
+ context.error = YAML_MEMORY_ERROR;
+ tmp_9 = 0;
+ }
+ }
+ if (! tmp_9) goto error;
+ value.handle = (yaml_char_t *)0;
+ value.prefix = (yaml_char_t *)0;
+ }
+ tag_directive ++;
+ }
+ }
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_DOCUMENT_START_EVENT;
+ event->start_mark = mark;
+ event->end_mark = mark;
+ event->data.document_start.version_directive = version_directive_copy;
+ event->data.document_start.tag_directives.start = tag_directives_copy.start;
+ event->data.document_start.tag_directives.end = tag_directives_copy.top;
+ event->data.document_start.implicit = implicit;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)version_directive_copy);
+ while (! (tag_directives_copy.start == tag_directives_copy.top)) {
+ (tag_directives_copy.top) --;
+ yaml_tag_directive_t value_0 = *(tag_directives_copy.top);
+ yaml_free((void *)value_0.handle);
+ yaml_free((void *)value_0.prefix);
+ }
+ yaml_free((void *)tag_directives_copy.start);
+ tag_directives_copy.end = (yaml_tag_directive_t *)0;
+ tag_directives_copy.top = tag_directives_copy.end;
+ tag_directives_copy.start = tag_directives_copy.top;
+ yaml_free((void *)value.handle);
+ yaml_free((void *)value.prefix);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int yaml_document_end_event_initialize(yaml_event_t *event, int implicit)
+{
+ int __retres;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ __FC_assert(event != (yaml_event_t *)0,"src/api.c",785,"event");
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_DOCUMENT_END_EVENT;
+ event->start_mark = mark;
+ event->end_mark = mark;
+ event->data.document_end.implicit = implicit;
+ __retres = 1;
+ return __retres;
+}
+
+int yaml_alias_event_initialize(yaml_event_t *event,
+ yaml_char_t const *anchor)
+{
+ int __retres;
+ int tmp_0;
+ size_t tmp;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ yaml_char_t *anchor_copy = (yaml_char_t *)0;
+ __FC_assert(event != (yaml_event_t *)0,"src/api.c",802,"event");
+ __FC_assert(anchor != (yaml_char_t const *)0,"src/api.c",803,"anchor");
+ tmp = strlen((char const *)anchor);
+ ;
+ tmp_0 = yaml_check_utf8(anchor,tmp);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ anchor_copy = yaml_strdup(anchor);
+ if (! anchor_copy) {
+ __retres = 0;
+ goto return_label;
+ }
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_ALIAS_EVENT;
+ event->start_mark = mark;
+ event->end_mark = mark;
+ event->data.alias.anchor = anchor_copy;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+int yaml_scalar_event_initialize(yaml_event_t *event,
+ yaml_char_t const *anchor,
+ yaml_char_t const *tag,
+ yaml_char_t const *value, int length,
+ int plain_implicit, int quoted_implicit,
+ yaml_scalar_style_t style)
+{
+ int __retres;
+ int tmp_4;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ yaml_char_t *anchor_copy = (yaml_char_t *)0;
+ yaml_char_t *tag_copy = (yaml_char_t *)0;
+ yaml_char_t *value_copy = (yaml_char_t *)0;
+ __FC_assert(event != (yaml_event_t *)0,"src/api.c",832,"event");
+ __FC_assert(value != (yaml_char_t const *)0,"src/api.c",833,"value");
+ if (anchor) {
+ int tmp_0;
+ size_t tmp;
+ tmp = strlen((char const *)anchor);
+ ;
+ tmp_0 = yaml_check_utf8(anchor,tmp);
+ if (! tmp_0) goto error;
+ anchor_copy = yaml_strdup(anchor);
+ if (! anchor_copy) goto error;
+ }
+ if (tag) {
+ int tmp_2;
+ size_t tmp_1;
+ tmp_1 = strlen((char const *)tag);
+ ;
+ tmp_2 = yaml_check_utf8(tag,tmp_1);
+ if (! tmp_2) goto error;
+ tag_copy = yaml_strdup(tag);
+ if (! tag_copy) goto error;
+ }
+ if (length < 0) {
+ size_t tmp_3;
+ tmp_3 = strlen((char const *)value);
+ length = (int)tmp_3;
+ }
+ tmp_4 = yaml_check_utf8(value,(unsigned long)length);
+ if (! tmp_4) goto error;
+ value_copy = (yaml_char_t *)yaml_malloc((unsigned long)(length + 1));
+ if (! value_copy) goto error;
+ memcpy((void *)value_copy,(void const *)value,(unsigned long)length);
+ *(value_copy + length) = (unsigned char)'\000';
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_SCALAR_EVENT;
+ event->start_mark = mark;
+ event->end_mark = mark;
+ event->data.scalar.anchor = anchor_copy;
+ event->data.scalar.tag = tag_copy;
+ event->data.scalar.value = value_copy;
+ event->data.scalar.length = (unsigned long)length;
+ event->data.scalar.plain_implicit = plain_implicit;
+ event->data.scalar.quoted_implicit = quoted_implicit;
+ event->data.scalar.style = style;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)anchor_copy);
+ yaml_free((void *)tag_copy);
+ yaml_free((void *)value_copy);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int yaml_sequence_start_event_initialize(yaml_event_t *event,
+ yaml_char_t const *anchor,
+ yaml_char_t const *tag,
+ int implicit,
+ yaml_sequence_style_t style)
+{
+ int __retres;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ yaml_char_t *anchor_copy = (yaml_char_t *)0;
+ yaml_char_t *tag_copy = (yaml_char_t *)0;
+ __FC_assert(event != (yaml_event_t *)0,"src/api.c",883,"event");
+ if (anchor) {
+ int tmp_0;
+ size_t tmp;
+ tmp = strlen((char const *)anchor);
+ ;
+ tmp_0 = yaml_check_utf8(anchor,tmp);
+ if (! tmp_0) goto error;
+ anchor_copy = yaml_strdup(anchor);
+ if (! anchor_copy) goto error;
+ }
+ if (tag) {
+ int tmp_2;
+ size_t tmp_1;
+ tmp_1 = strlen((char const *)tag);
+ ;
+ tmp_2 = yaml_check_utf8(tag,tmp_1);
+ if (! tmp_2) goto error;
+ tag_copy = yaml_strdup(tag);
+ if (! tag_copy) goto error;
+ }
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_SEQUENCE_START_EVENT;
+ event->start_mark = mark;
+ event->end_mark = mark;
+ event->data.sequence_start.anchor = anchor_copy;
+ event->data.sequence_start.tag = tag_copy;
+ event->data.sequence_start.implicit = implicit;
+ event->data.sequence_start.style = style;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)anchor_copy);
+ yaml_free((void *)tag_copy);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int yaml_sequence_end_event_initialize(yaml_event_t *event)
+{
+ int __retres;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ __FC_assert(event != (yaml_event_t *)0,"src/api.c",918,"event");
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_SEQUENCE_END_EVENT;
+ event->start_mark = mark;
+ event->end_mark = mark;
+ __retres = 1;
+ return __retres;
+}
+
+int yaml_mapping_start_event_initialize(yaml_event_t *event,
+ yaml_char_t const *anchor,
+ yaml_char_t const *tag, int implicit,
+ yaml_mapping_style_t style)
+{
+ int __retres;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ yaml_char_t *anchor_copy = (yaml_char_t *)0;
+ yaml_char_t *tag_copy = (yaml_char_t *)0;
+ __FC_assert(event != (yaml_event_t *)0,"src/api.c",938,"event");
+ if (anchor) {
+ int tmp_0;
+ size_t tmp;
+ tmp = strlen((char const *)anchor);
+ ;
+ tmp_0 = yaml_check_utf8(anchor,tmp);
+ if (! tmp_0) goto error;
+ anchor_copy = yaml_strdup(anchor);
+ if (! anchor_copy) goto error;
+ }
+ if (tag) {
+ int tmp_2;
+ size_t tmp_1;
+ tmp_1 = strlen((char const *)tag);
+ ;
+ tmp_2 = yaml_check_utf8(tag,tmp_1);
+ if (! tmp_2) goto error;
+ tag_copy = yaml_strdup(tag);
+ if (! tag_copy) goto error;
+ }
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_MAPPING_START_EVENT;
+ event->start_mark = mark;
+ event->end_mark = mark;
+ event->data.mapping_start.anchor = anchor_copy;
+ event->data.mapping_start.tag = tag_copy;
+ event->data.mapping_start.implicit = implicit;
+ event->data.mapping_start.style = style;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)anchor_copy);
+ yaml_free((void *)tag_copy);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int yaml_mapping_end_event_initialize(yaml_event_t *event)
+{
+ int __retres;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ __FC_assert(event != (yaml_event_t *)0,"src/api.c",973,"event");
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_MAPPING_END_EVENT;
+ event->start_mark = mark;
+ event->end_mark = mark;
+ __retres = 1;
+ return __retres;
+}
+
+void yaml_event_delete(yaml_event_t *event)
+{
+ yaml_tag_directive_t *tag_directive;
+ __FC_assert(event != (yaml_event_t *)0,"src/api.c",989,"event");
+ switch (event->type) {
+ case (yaml_event_type_t)YAML_DOCUMENT_START_EVENT:
+ yaml_free((void *)event->data.document_start.version_directive);
+ tag_directive = event->data.document_start.tag_directives.start;
+ while (tag_directive != event->data.document_start.tag_directives.end) {
+ yaml_free((void *)tag_directive->handle);
+ yaml_free((void *)tag_directive->prefix);
+ tag_directive ++;
+ }
+ yaml_free((void *)event->data.document_start.tag_directives.start);
+ break;
+ case (yaml_event_type_t)YAML_ALIAS_EVENT:
+ yaml_free((void *)event->data.alias.anchor);
+ break;
+ case (yaml_event_type_t)YAML_SCALAR_EVENT:
+ yaml_free((void *)event->data.scalar.anchor);
+ yaml_free((void *)event->data.scalar.tag);
+ yaml_free((void *)event->data.scalar.value);
+ break;
+ case (yaml_event_type_t)YAML_SEQUENCE_START_EVENT:
+ yaml_free((void *)event->data.sequence_start.anchor);
+ yaml_free((void *)event->data.sequence_start.tag);
+ break;
+ case (yaml_event_type_t)YAML_MAPPING_START_EVENT:
+ yaml_free((void *)event->data.mapping_start.anchor);
+ yaml_free((void *)event->data.mapping_start.tag);
+ break;
+ default: break;
+ }
+ memset((void *)event,0,sizeof(yaml_event_t));
+ return;
+}
+
+int yaml_document_initialize(yaml_document_t *document,
+ yaml_version_directive_t *version_directive,
+ yaml_tag_directive_t *tag_directives_start,
+ yaml_tag_directive_t *tag_directives_end,
+ int start_implicit, int end_implicit)
+{
+ int __retres;
+ struct __anonstruct_context_51 context;
+ int tmp;
+ int tmp_1;
+ struct __anonstruct_nodes_52 nodes =
+ {.start = (yaml_node_t *)0,
+ .end = (yaml_node_t *)0,
+ .top = (yaml_node_t *)0};
+ yaml_version_directive_t *version_directive_copy =
+ (yaml_version_directive_t *)0;
+ struct __anonstruct_tag_directives_copy_53 tag_directives_copy =
+ {.start = (yaml_tag_directive_t *)0,
+ .end = (yaml_tag_directive_t *)0,
+ .top = (yaml_tag_directive_t *)0};
+ yaml_tag_directive_t value =
+ {.handle = (yaml_char_t *)0, .prefix = (yaml_char_t *)0};
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ __FC_assert(document != (yaml_document_t *)0,"src/api.c",1059,"document");
+ if (tag_directives_start) {
+ if (tag_directives_end) tmp = 1; else goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (tag_directives_start == tag_directives_end) tmp = 1; else tmp = 0;
+ }
+ __FC_assert(tmp != 0,"src/api.c",1060,
+ "(tag_directives_start && tag_directives_end) || (tag_directives_start == tag_directives_end)");
+ nodes.start = (yaml_node_t *)yaml_malloc((unsigned long)16 * sizeof(*(nodes.start)));
+ if (nodes.start) {
+ nodes.top = nodes.start;
+ nodes.end = nodes.start + 16;
+ tmp_1 = 1;
+ }
+ else {
+ context.error = YAML_MEMORY_ERROR;
+ tmp_1 = 0;
+ }
+ if (! tmp_1) goto error;
+ if (version_directive) {
+ version_directive_copy = (yaml_version_directive_t *)yaml_malloc(sizeof(yaml_version_directive_t));
+ if (! version_directive_copy) goto error;
+ version_directive_copy->major = version_directive->major;
+ version_directive_copy->minor = version_directive->minor;
+ }
+ if (tag_directives_start != tag_directives_end) {
+ yaml_tag_directive_t *tag_directive;
+ int tmp_4;
+ tag_directives_copy.start = (yaml_tag_directive_t *)yaml_malloc((unsigned long)16 * sizeof(*(tag_directives_copy.start)));
+ if (tag_directives_copy.start) {
+ tag_directives_copy.top = tag_directives_copy.start;
+ tag_directives_copy.end = tag_directives_copy.start + 16;
+ tmp_4 = 1;
+ }
+ else {
+ context.error = YAML_MEMORY_ERROR;
+ tmp_4 = 0;
+ }
+ if (! tmp_4) goto error;
+ tag_directive = tag_directives_start;
+ while (tag_directive != tag_directives_end) {
+ {
+ int tmp_6;
+ size_t tmp_5;
+ int tmp_8;
+ size_t tmp_7;
+ int tmp_11;
+ __FC_assert(tag_directive->handle != (yaml_char_t *)0,"src/api.c",
+ 1079,"tag_directive->handle");
+ __FC_assert(tag_directive->prefix != (yaml_char_t *)0,"src/api.c",
+ 1080,"tag_directive->prefix");
+ tmp_5 = strlen((char const *)tag_directive->handle);
+ ;
+ tmp_6 = yaml_check_utf8((yaml_char_t const *)tag_directive->handle,
+ tmp_5);
+ if (! tmp_6) goto error;
+ tmp_7 = strlen((char const *)tag_directive->prefix);
+ ;
+ tmp_8 = yaml_check_utf8((yaml_char_t const *)tag_directive->prefix,
+ tmp_7);
+ if (! tmp_8) goto error;
+ value.handle = yaml_strdup((yaml_char_t const *)tag_directive->handle);
+ value.prefix = yaml_strdup((yaml_char_t const *)tag_directive->prefix);
+ if (! value.handle) goto error;
+ else
+ if (! value.prefix) goto error;
+ if (tag_directives_copy.top != tag_directives_copy.end) goto _LOR;
+ else {
+ int tmp_9;
+ tmp_9 = yaml_stack_extend((void **)(& tag_directives_copy.start),
+ (void **)(& tag_directives_copy.top),
+ (void **)(& tag_directives_copy.end));
+ if (tmp_9) {
+ yaml_tag_directive_t *tmp_10;
+ _LOR: tmp_10 = tag_directives_copy.top;
+ (tag_directives_copy.top) ++;
+ *tmp_10 = value;
+ tmp_11 = 1;
+ }
+ else {
+ context.error = YAML_MEMORY_ERROR;
+ tmp_11 = 0;
+ }
+ }
+ if (! tmp_11) goto error;
+ value.handle = (yaml_char_t *)0;
+ value.prefix = (yaml_char_t *)0;
+ }
+ tag_directive ++;
+ }
+ }
+ memset((void *)document,0,sizeof(yaml_document_t));
+ document->nodes.start = nodes.start;
+ document->nodes.end = nodes.end;
+ document->nodes.top = nodes.start;
+ document->version_directive = version_directive_copy;
+ document->tag_directives.start = tag_directives_copy.start;
+ document->tag_directives.end = tag_directives_copy.top;
+ document->start_implicit = start_implicit;
+ document->end_implicit = end_implicit;
+ document->start_mark = mark;
+ document->end_mark = mark;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)nodes.start);
+ nodes.end = (yaml_node_t *)0;
+ nodes.top = nodes.end;
+ nodes.start = nodes.top;
+ yaml_free((void *)version_directive_copy);
+ while (! (tag_directives_copy.start == tag_directives_copy.top)) {
+ (tag_directives_copy.top) --;
+ yaml_tag_directive_t value_0 = *(tag_directives_copy.top);
+ yaml_free((void *)value_0.handle);
+ yaml_free((void *)value_0.prefix);
+ }
+ yaml_free((void *)tag_directives_copy.start);
+ tag_directives_copy.end = (yaml_tag_directive_t *)0;
+ tag_directives_copy.top = tag_directives_copy.end;
+ tag_directives_copy.start = tag_directives_copy.top;
+ yaml_free((void *)value.handle);
+ yaml_free((void *)value.prefix);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+void yaml_document_delete(yaml_document_t *document)
+{
+ yaml_tag_directive_t *tag_directive;
+ yaml_node_t *tmp_0;
+ yaml_node_t *tmp;
+ __FC_assert(document != (yaml_document_t *)0,"src/api.c",1127,"document");
+ while (! (document->nodes.start == document->nodes.top)) {
+ (document->nodes.top) --;
+ yaml_node_t node = *(document->nodes.top);
+ yaml_free((void *)node.tag);
+ switch (node.type) {
+ case (yaml_node_type_t)YAML_SCALAR_NODE:
+ yaml_free((void *)node.data.scalar.value);
+ break;
+ case (yaml_node_type_t)YAML_SEQUENCE_NODE:
+ yaml_free((void *)node.data.sequence.items.start);
+ node.data.sequence.items.end = (yaml_node_item_t *)0;
+ node.data.sequence.items.top = node.data.sequence.items.end;
+ node.data.sequence.items.start = node.data.sequence.items.top;
+ break;
+ case (yaml_node_type_t)YAML_MAPPING_NODE:
+ yaml_free((void *)node.data.mapping.pairs.start);
+ node.data.mapping.pairs.end = (yaml_node_pair_t *)0;
+ node.data.mapping.pairs.top = node.data.mapping.pairs.end;
+ node.data.mapping.pairs.start = node.data.mapping.pairs.top;
+ break;
+ default: __FC_assert(0 != 0,"src/api.c",1143,"0");
+ }
+ }
+ yaml_free((void *)document->nodes.start);
+ tmp_0 = (yaml_node_t *)0;
+ document->nodes.end = tmp_0;
+ tmp = tmp_0;
+ document->nodes.top = tmp;
+ document->nodes.start = tmp;
+ yaml_free((void *)document->version_directive);
+ tag_directive = document->tag_directives.start;
+ while (tag_directive != document->tag_directives.end) {
+ yaml_free((void *)tag_directive->handle);
+ yaml_free((void *)tag_directive->prefix);
+ tag_directive ++;
+ }
+ yaml_free((void *)document->tag_directives.start);
+ memset((void *)document,0,sizeof(yaml_document_t));
+ return;
+}
+
+yaml_node_t *yaml_document_get_node(yaml_document_t *document, int index_0)
+{
+ yaml_node_t *__retres;
+ __FC_assert(document != (yaml_document_t *)0,"src/api.c",1167,"document");
+ if (index_0 > 0)
+ if (document->nodes.start + index_0 <= document->nodes.top) {
+ __retres = (document->nodes.start + index_0) - 1;
+ goto return_label;
+ }
+ __retres = (yaml_node_t *)0;
+ return_label: return __retres;
+}
+
+yaml_node_t *yaml_document_get_root_node(yaml_document_t *document)
+{
+ yaml_node_t *__retres;
+ __FC_assert(document != (yaml_document_t *)0,"src/api.c",1182,"document");
+ if (document->nodes.top != document->nodes.start) {
+ __retres = document->nodes.start;
+ goto return_label;
+ }
+ __retres = (yaml_node_t *)0;
+ return_label: return __retres;
+}
+
+int yaml_document_add_scalar(yaml_document_t *document,
+ yaml_char_t const *tag,
+ yaml_char_t const *value, int length,
+ yaml_scalar_style_t style)
+{
+ int __retres;
+ struct __anonstruct_context_54 context;
+ yaml_node_t node;
+ int tmp_0;
+ size_t tmp;
+ int tmp_2;
+ int tmp_6;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ yaml_char_t *tag_copy = (yaml_char_t *)0;
+ yaml_char_t *value_copy = (yaml_char_t *)0;
+ __FC_assert(document != (yaml_document_t *)0,"src/api.c",1207,"document");
+ __FC_assert(value != (yaml_char_t const *)0,"src/api.c",1208,"value");
+ if (! tag) tag = (yaml_char_t const *)"tag:yaml.org,2002:str";
+ tmp = strlen((char const *)tag);
+ ;
+ tmp_0 = yaml_check_utf8(tag,tmp);
+ if (! tmp_0) goto error;
+ tag_copy = yaml_strdup(tag);
+ if (! tag_copy) goto error;
+ if (length < 0) {
+ size_t tmp_1;
+ tmp_1 = strlen((char const *)value);
+ length = (int)tmp_1;
+ }
+ tmp_2 = yaml_check_utf8(value,(unsigned long)length);
+ if (! tmp_2) goto error;
+ value_copy = (yaml_char_t *)yaml_malloc((unsigned long)(length + 1));
+ if (! value_copy) goto error;
+ memcpy((void *)value_copy,(void const *)value,(unsigned long)length);
+ *(value_copy + length) = (unsigned char)'\000';
+ memset((void *)(& node),0,sizeof(yaml_node_t));
+ node.type = YAML_SCALAR_NODE;
+ node.tag = tag_copy;
+ node.start_mark = mark;
+ node.end_mark = mark;
+ node.data.scalar.value = value_copy;
+ node.data.scalar.length = (unsigned long)length;
+ node.data.scalar.style = style;
+ if (document->nodes.top != document->nodes.end) goto _LOR;
+ else {
+ int tmp_4;
+ tmp_4 = yaml_stack_extend((void **)(& document->nodes.start),
+ (void **)(& document->nodes.top),
+ (void **)(& document->nodes.end));
+ if (tmp_4) {
+ yaml_node_t *tmp_5;
+ _LOR: tmp_5 = document->nodes.top;
+ (document->nodes.top) ++;
+ *tmp_5 = node;
+ tmp_6 = 1;
+ }
+ else {
+ context.error = YAML_MEMORY_ERROR;
+ tmp_6 = 0;
+ }
+ }
+ if (! tmp_6) goto error;
+ __retres = (int)(document->nodes.top - document->nodes.start);
+ goto return_label;
+ error: yaml_free((void *)tag_copy);
+ yaml_free((void *)value_copy);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int yaml_document_add_sequence(yaml_document_t *document,
+ yaml_char_t const *tag,
+ yaml_sequence_style_t style)
+{
+ int __retres;
+ struct __anonstruct_context_55 context;
+ yaml_node_t node;
+ int tmp_0;
+ size_t tmp;
+ int tmp_2;
+ int tmp_5;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ yaml_char_t *tag_copy = (yaml_char_t *)0;
+ struct __anonstruct_items_56 items =
+ {.start = (yaml_node_item_t *)0,
+ .end = (yaml_node_item_t *)0,
+ .top = (yaml_node_item_t *)0};
+ __FC_assert(document != (yaml_document_t *)0,"src/api.c",1260,"document");
+ if (! tag) tag = (yaml_char_t const *)"tag:yaml.org,2002:seq";
+ tmp = strlen((char const *)tag);
+ ;
+ tmp_0 = yaml_check_utf8(tag,tmp);
+ if (! tmp_0) goto error;
+ tag_copy = yaml_strdup(tag);
+ if (! tag_copy) goto error;
+ items.start = (yaml_node_item_t *)yaml_malloc((unsigned long)16 * sizeof(*(items.start)));
+ if (items.start) {
+ items.top = items.start;
+ items.end = items.start + 16;
+ tmp_2 = 1;
+ }
+ else {
+ context.error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ if (! tmp_2) goto error;
+ memset((void *)(& node),0,sizeof(yaml_node_t));
+ node.type = YAML_SEQUENCE_NODE;
+ node.tag = tag_copy;
+ node.start_mark = mark;
+ node.end_mark = mark;
+ node.data.sequence.items.start = items.start;
+ node.data.sequence.items.end = items.end;
+ node.data.sequence.items.top = items.start;
+ node.data.sequence.style = style;
+ if (document->nodes.top != document->nodes.end) goto _LOR;
+ else {
+ int tmp_3;
+ tmp_3 = yaml_stack_extend((void **)(& document->nodes.start),
+ (void **)(& document->nodes.top),
+ (void **)(& document->nodes.end));
+ if (tmp_3) {
+ yaml_node_t *tmp_4;
+ _LOR: tmp_4 = document->nodes.top;
+ (document->nodes.top) ++;
+ *tmp_4 = node;
+ tmp_5 = 1;
+ }
+ else {
+ context.error = YAML_MEMORY_ERROR;
+ tmp_5 = 0;
+ }
+ }
+ if (! tmp_5) goto error;
+ __retres = (int)(document->nodes.top - document->nodes.start);
+ goto return_label;
+ error: yaml_free((void *)items.start);
+ items.end = (yaml_node_item_t *)0;
+ items.top = items.end;
+ items.start = items.top;
+ yaml_free((void *)tag_copy);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int yaml_document_add_mapping(yaml_document_t *document,
+ yaml_char_t const *tag,
+ yaml_mapping_style_t style)
+{
+ int __retres;
+ struct __anonstruct_context_57 context;
+ yaml_node_t node;
+ int tmp_0;
+ size_t tmp;
+ int tmp_2;
+ int tmp_5;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ yaml_char_t *tag_copy = (yaml_char_t *)0;
+ struct __anonstruct_pairs_58 pairs =
+ {.start = (yaml_node_pair_t *)0,
+ .end = (yaml_node_pair_t *)0,
+ .top = (yaml_node_pair_t *)0};
+ __FC_assert(document != (yaml_document_t *)0,"src/api.c",1305,"document");
+ if (! tag) tag = (yaml_char_t const *)"tag:yaml.org,2002:map";
+ tmp = strlen((char const *)tag);
+ ;
+ tmp_0 = yaml_check_utf8(tag,tmp);
+ if (! tmp_0) goto error;
+ tag_copy = yaml_strdup(tag);
+ if (! tag_copy) goto error;
+ pairs.start = (yaml_node_pair_t *)yaml_malloc((unsigned long)16 * sizeof(*(pairs.start)));
+ if (pairs.start) {
+ pairs.top = pairs.start;
+ pairs.end = pairs.start + 16;
+ tmp_2 = 1;
+ }
+ else {
+ context.error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ if (! tmp_2) goto error;
+ memset((void *)(& node),0,sizeof(yaml_node_t));
+ node.type = YAML_MAPPING_NODE;
+ node.tag = tag_copy;
+ node.start_mark = mark;
+ node.end_mark = mark;
+ node.data.mapping.pairs.start = pairs.start;
+ node.data.mapping.pairs.end = pairs.end;
+ node.data.mapping.pairs.top = pairs.start;
+ node.data.mapping.style = style;
+ if (document->nodes.top != document->nodes.end) goto _LOR;
+ else {
+ int tmp_3;
+ tmp_3 = yaml_stack_extend((void **)(& document->nodes.start),
+ (void **)(& document->nodes.top),
+ (void **)(& document->nodes.end));
+ if (tmp_3) {
+ yaml_node_t *tmp_4;
+ _LOR: tmp_4 = document->nodes.top;
+ (document->nodes.top) ++;
+ *tmp_4 = node;
+ tmp_5 = 1;
+ }
+ else {
+ context.error = YAML_MEMORY_ERROR;
+ tmp_5 = 0;
+ }
+ }
+ if (! tmp_5) goto error;
+ __retres = (int)(document->nodes.top - document->nodes.start);
+ goto return_label;
+ error: yaml_free((void *)pairs.start);
+ pairs.end = (yaml_node_pair_t *)0;
+ pairs.top = pairs.end;
+ pairs.start = pairs.top;
+ yaml_free((void *)tag_copy);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int yaml_document_append_sequence_item(yaml_document_t *document,
+ int sequence, int item)
+{
+ int __retres;
+ struct __anonstruct_context_59 context;
+ int tmp;
+ int tmp_0;
+ int tmp_3;
+ __FC_assert(document != (yaml_document_t *)0,"src/api.c",1342,"document");
+ if (sequence > 0)
+ if (document->nodes.start + sequence <= document->nodes.top) tmp = 1;
+ else tmp = 0;
+ else tmp = 0;
+ __FC_assert(tmp != 0,"src/api.c",1343,
+ "sequence > 0 && document->nodes.start + sequence <= document->nodes.top");
+ __FC_assert(((document->nodes.start + (sequence - 1))->type == (unsigned int)YAML_SEQUENCE_NODE) != 0,
+ "src/api.c",1346,
+ "document->nodes.start[sequence-1].type == YAML_SEQUENCE_NODE");
+ if (item > 0)
+ if (document->nodes.start + item <= document->nodes.top) tmp_0 = 1;
+ else tmp_0 = 0;
+ else tmp_0 = 0;
+ __FC_assert(tmp_0 != 0,"src/api.c",1348,
+ "item > 0 && document->nodes.start + item <= document->nodes.top");
+ if ((document->nodes.start + (sequence - 1))->data.sequence.items.top != (
+ document->nodes.start + (sequence - 1))->data.sequence.items.end)
+ goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_stack_extend((void **)(& (document->nodes.start + (sequence - 1))->data.sequence.items.start),
+ (void **)(& (document->nodes.start + (sequence - 1))->data.sequence.items.top),
+ (void **)(& (document->nodes.start + (sequence - 1))->data.sequence.items.end));
+ if (tmp_1) {
+ yaml_node_item_t *tmp_2;
+ _LOR:
+ tmp_2 = (document->nodes.start + (sequence - 1))->data.sequence.items.top;
+ ((document->nodes.start + (sequence - 1))->data.sequence.items.top) ++;
+ *tmp_2 = item;
+ tmp_3 = 1;
+ }
+ else {
+ context.error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+int yaml_document_append_mapping_pair(yaml_document_t *document, int mapping,
+ int key, int value)
+{
+ int __retres;
+ struct __anonstruct_context_60 context;
+ yaml_node_pair_t pair;
+ int tmp;
+ int tmp_0;
+ int tmp_1;
+ int tmp_4;
+ __FC_assert(document != (yaml_document_t *)0,"src/api.c",1372,"document");
+ if (mapping > 0)
+ if (document->nodes.start + mapping <= document->nodes.top) tmp = 1;
+ else tmp = 0;
+ else tmp = 0;
+ __FC_assert(tmp != 0,"src/api.c",1373,
+ "mapping > 0 && document->nodes.start + mapping <= document->nodes.top");
+ __FC_assert(((document->nodes.start + (mapping - 1))->type == (unsigned int)YAML_MAPPING_NODE) != 0,
+ "src/api.c",1376,
+ "document->nodes.start[mapping-1].type == YAML_MAPPING_NODE");
+ if (key > 0)
+ if (document->nodes.start + key <= document->nodes.top) tmp_0 = 1;
+ else tmp_0 = 0;
+ else tmp_0 = 0;
+ __FC_assert(tmp_0 != 0,"src/api.c",1378,
+ "key > 0 && document->nodes.start + key <= document->nodes.top");
+ if (value > 0)
+ if (document->nodes.start + value <= document->nodes.top) tmp_1 = 1;
+ else tmp_1 = 0;
+ else tmp_1 = 0;
+ __FC_assert(tmp_1 != 0,"src/api.c",1380,
+ "value > 0 && document->nodes.start + value <= document->nodes.top");
+ pair.key = key;
+ pair.value = value;
+ if ((document->nodes.start + (mapping - 1))->data.mapping.pairs.top != (
+ document->nodes.start + (mapping - 1))->data.mapping.pairs.end)
+ goto _LOR;
+ else {
+ int tmp_2;
+ tmp_2 = yaml_stack_extend((void **)(& (document->nodes.start + (mapping - 1))->data.mapping.pairs.start),
+ (void **)(& (document->nodes.start + (mapping - 1))->data.mapping.pairs.top),
+ (void **)(& (document->nodes.start + (mapping - 1))->data.mapping.pairs.end));
+ if (tmp_2) {
+ yaml_node_pair_t *tmp_3;
+ _LOR:
+ tmp_3 = (document->nodes.start + (mapping - 1))->data.mapping.pairs.top;
+ ((document->nodes.start + (mapping - 1))->data.mapping.pairs.top) ++;
+ *tmp_3 = pair;
+ tmp_4 = 1;
+ }
+ else {
+ context.error = YAML_MEMORY_ERROR;
+ tmp_4 = 0;
+ }
+ }
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static void yaml_emitter_delete_document_and_anchors(yaml_emitter_t *emitter);
+
+static void yaml_emitter_anchor_node(yaml_emitter_t *emitter, int index_0);
+
+static yaml_char_t *yaml_emitter_generate_anchor(yaml_emitter_t *emitter __attribute__((
+ __unused__)), int anchor_id);
+
+static int yaml_emitter_dump_node(yaml_emitter_t *emitter, int index_0);
+
+static int yaml_emitter_dump_alias(yaml_emitter_t *emitter,
+ yaml_char_t *anchor);
+
+static int yaml_emitter_dump_scalar(yaml_emitter_t *emitter,
+ yaml_node_t *node, yaml_char_t *anchor);
+
+static int yaml_emitter_dump_sequence(yaml_emitter_t *emitter,
+ yaml_node_t *node, yaml_char_t *anchor);
+
+static int yaml_emitter_dump_mapping(yaml_emitter_t *emitter,
+ yaml_node_t *node, yaml_char_t *anchor);
+
+int yaml_emitter_open(yaml_emitter_t *emitter)
+{
+ int __retres;
+ yaml_event_t event;
+ int tmp;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/dumper.c",67,"emitter");
+ __FC_assert(! emitter->opened != 0,"src/dumper.c",68,"!emitter->opened");
+ memset((void *)(& event),0,sizeof(yaml_event_t));
+ event.type = YAML_STREAM_START_EVENT;
+ event.start_mark = mark;
+ event.end_mark = mark;
+ event.data.stream_start.encoding = YAML_ANY_ENCODING;
+ tmp = yaml_emitter_emit(emitter,& event);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ emitter->opened = 1;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+int yaml_emitter_close(yaml_emitter_t *emitter)
+{
+ int __retres;
+ yaml_event_t event;
+ int tmp;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/dumper.c",91,"emitter");
+ __FC_assert(emitter->opened != 0,"src/dumper.c",92,"emitter->opened");
+ if (emitter->closed) {
+ __retres = 1;
+ goto return_label;
+ }
+ memset((void *)(& event),0,sizeof(yaml_event_t));
+ event.type = YAML_STREAM_END_EVENT;
+ event.start_mark = mark;
+ event.end_mark = mark;
+ tmp = yaml_emitter_emit(emitter,& event);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ emitter->closed = 1;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+int yaml_emitter_dump(yaml_emitter_t *emitter, yaml_document_t *document)
+{
+ int __retres;
+ yaml_event_t event;
+ int tmp_2;
+ int tmp_3;
+ int tmp_4;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/dumper.c",117,"emitter");
+ __FC_assert(document != (yaml_document_t *)0,"src/dumper.c",118,"document");
+ emitter->document = document;
+ if (! emitter->opened) {
+ int tmp;
+ tmp = yaml_emitter_open(emitter);
+ if (! tmp) goto error;
+ }
+ if (document->nodes.start == document->nodes.top) {
+ int tmp_0;
+ tmp_0 = yaml_emitter_close(emitter);
+ if (! tmp_0) goto error;
+ yaml_emitter_delete_document_and_anchors(emitter);
+ __retres = 1;
+ goto return_label;
+ }
+ __FC_assert(emitter->opened != 0,"src/dumper.c",132,"emitter->opened");
+ emitter->anchors = (yaml_anchors_t *)yaml_malloc(sizeof(*(emitter->anchors)) * (unsigned long)(
+ document->nodes.top - document->nodes.start));
+ if (! emitter->anchors) goto error;
+ memset((void *)emitter->anchors,0,
+ sizeof(*(emitter->anchors)) * (unsigned long)(document->nodes.top - document->nodes.start));
+ memset((void *)(& event),0,sizeof(yaml_event_t));
+ event.type = YAML_DOCUMENT_START_EVENT;
+ event.start_mark = mark;
+ event.end_mark = mark;
+ event.data.document_start.version_directive = document->version_directive;
+ event.data.document_start.tag_directives.start = document->tag_directives.start;
+ event.data.document_start.tag_directives.end = document->tag_directives.end;
+ event.data.document_start.implicit = document->start_implicit;
+ tmp_2 = yaml_emitter_emit(emitter,& event);
+ if (! tmp_2) goto error;
+ yaml_emitter_anchor_node(emitter,1);
+ tmp_3 = yaml_emitter_dump_node(emitter,1);
+ if (! tmp_3) goto error;
+ memset((void *)(& event),0,sizeof(yaml_event_t));
+ event.type = YAML_DOCUMENT_END_EVENT;
+ event.start_mark = mark;
+ event.end_mark = mark;
+ event.data.document_end.implicit = document->end_implicit;
+ tmp_4 = yaml_emitter_emit(emitter,& event);
+ if (! tmp_4) goto error;
+ yaml_emitter_delete_document_and_anchors(emitter);
+ __retres = 1;
+ goto return_label;
+ error: yaml_emitter_delete_document_and_anchors(emitter);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static void yaml_emitter_delete_document_and_anchors(yaml_emitter_t *emitter)
+{
+ int index_0;
+ yaml_node_t *tmp_0;
+ yaml_node_t *tmp;
+ if (! emitter->anchors) {
+ yaml_document_delete(emitter->document);
+ emitter->document = (yaml_document_t *)0;
+ goto return_label;
+ }
+ index_0 = 0;
+ while ((emitter->document)->nodes.start + index_0 < (emitter->document)->nodes.top) {
+ {
+ yaml_node_t node = *((emitter->document)->nodes.start + index_0);
+ if (! (emitter->anchors + index_0)->serialized) {
+ yaml_free((void *)node.tag);
+ if (node.type == (unsigned int)YAML_SCALAR_NODE) yaml_free((void *)node.data.scalar.value);
+ }
+ if (node.type == (unsigned int)YAML_SEQUENCE_NODE) {
+ yaml_free((void *)node.data.sequence.items.start);
+ node.data.sequence.items.end = (yaml_node_item_t *)0;
+ node.data.sequence.items.top = node.data.sequence.items.end;
+ node.data.sequence.items.start = node.data.sequence.items.top;
+ }
+ if (node.type == (unsigned int)YAML_MAPPING_NODE) {
+ yaml_free((void *)node.data.mapping.pairs.start);
+ node.data.mapping.pairs.end = (yaml_node_pair_t *)0;
+ node.data.mapping.pairs.top = node.data.mapping.pairs.end;
+ node.data.mapping.pairs.start = node.data.mapping.pairs.top;
+ }
+ }
+ index_0 ++;
+ }
+ yaml_free((void *)(emitter->document)->nodes.start);
+ tmp_0 = (yaml_node_t *)0;
+ (emitter->document)->nodes.end = tmp_0;
+ tmp = tmp_0;
+ (emitter->document)->nodes.top = tmp;
+ (emitter->document)->nodes.start = tmp;
+ yaml_free((void *)emitter->anchors);
+ emitter->anchors = (yaml_anchors_t *)0;
+ emitter->last_anchor_id = 0;
+ emitter->document = (yaml_document_t *)0;
+ return_label: return;
+}
+
+static void yaml_emitter_anchor_node(yaml_emitter_t *emitter, int index_0)
+{
+ yaml_node_item_t *item;
+ yaml_node_pair_t *pair;
+ yaml_node_t *node = ((emitter->document)->nodes.start + index_0) - 1;
+ ((emitter->anchors + (index_0 - 1))->references) ++;
+ if ((emitter->anchors + (index_0 - 1))->references == 1)
+ switch (node->type) {
+ case (yaml_node_type_t)YAML_SEQUENCE_NODE:
+ item = node->data.sequence.items.start;
+ while (item < node->data.sequence.items.top) {
+ yaml_emitter_anchor_node(emitter,*item);
+ item ++;
+ }
+ break;
+ case (yaml_node_type_t)YAML_MAPPING_NODE:
+ pair = node->data.mapping.pairs.start;
+ while (pair < node->data.mapping.pairs.top) {
+ yaml_emitter_anchor_node(emitter,pair->key);
+ yaml_emitter_anchor_node(emitter,pair->value);
+ pair ++;
+ }
+ break;
+ default: break;
+ }
+ else
+ if ((emitter->anchors + (index_0 - 1))->references == 2) {
+ (emitter->last_anchor_id) ++;
+ (emitter->anchors + (index_0 - 1))->anchor = emitter->last_anchor_id;
+ }
+ return;
+}
+
+/*@ requires valid_read_string(format);
+ assigns \result, *(s + (0 ..));
+ assigns \result \from (indirect: *(format + (0 ..))), (indirect: param0);
+ assigns *(s + (0 ..)) \from (indirect: *(format + (0 ..))), param0;
+ */
+int sprintf_va_1(char * __restrict s, char const * __restrict format,
+ int param0);
+
+static yaml_char_t *yaml_emitter_generate_anchor(yaml_emitter_t *emitter __attribute__((
+ __unused__)), int anchor_id)
+{
+ yaml_char_t *__retres;
+ yaml_char_t *anchor = yaml_malloc((unsigned long)16);
+ if (! anchor) {
+ __retres = (yaml_char_t *)0;
+ goto return_label;
+ }
+ sprintf((char *)anchor,"id%03d",anchor_id); /* sprintf_va_1 */
+ __retres = anchor;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_dump_node(yaml_emitter_t *emitter, int index_0)
+{
+ int __retres;
+ yaml_node_t *node = ((emitter->document)->nodes.start + index_0) - 1;
+ int anchor_id = (emitter->anchors + (index_0 - 1))->anchor;
+ yaml_char_t *anchor = (yaml_char_t *)0;
+ if (anchor_id) {
+ anchor = yaml_emitter_generate_anchor(emitter,anchor_id);
+ if (! anchor) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if ((emitter->anchors + (index_0 - 1))->serialized) {
+ int tmp;
+ tmp = yaml_emitter_dump_alias(emitter,anchor);
+ __retres = tmp;
+ goto return_label;
+ }
+ (emitter->anchors + (index_0 - 1))->serialized = 1;
+ switch (node->type) {
+ int tmp_0;
+ int tmp_1;
+ int tmp_2;
+ case (yaml_node_type_t)YAML_SCALAR_NODE:
+ tmp_0 = yaml_emitter_dump_scalar(emitter,node,anchor);
+ __retres = tmp_0;
+ goto return_label;
+ case (yaml_node_type_t)YAML_SEQUENCE_NODE:
+ tmp_1 = yaml_emitter_dump_sequence(emitter,node,anchor);
+ __retres = tmp_1;
+ goto return_label;
+ case (yaml_node_type_t)YAML_MAPPING_NODE:
+ tmp_2 = yaml_emitter_dump_mapping(emitter,node,anchor);
+ __retres = tmp_2;
+ goto return_label;
+ default: __FC_assert(0 != 0,"src/dumper.c",289,"0");
+ break;
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_dump_alias(yaml_emitter_t *emitter,
+ yaml_char_t *anchor)
+{
+ yaml_event_t event;
+ int tmp;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ memset((void *)(& event),0,sizeof(yaml_event_t));
+ event.type = YAML_ALIAS_EVENT;
+ event.start_mark = mark;
+ event.end_mark = mark;
+ event.data.alias.anchor = anchor;
+ tmp = yaml_emitter_emit(emitter,& event);
+ return tmp;
+}
+
+static int yaml_emitter_dump_scalar(yaml_emitter_t *emitter,
+ yaml_node_t *node, yaml_char_t *anchor)
+{
+ yaml_event_t event;
+ int tmp;
+ int tmp_0;
+ int tmp_1;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ tmp = strcmp((char const *)node->tag,"tag:yaml.org,2002:str");
+ int plain_implicit = tmp == 0;
+ tmp_0 = strcmp((char const *)node->tag,"tag:yaml.org,2002:str");
+ int quoted_implicit = tmp_0 == 0;
+ memset((void *)(& event),0,sizeof(yaml_event_t));
+ event.type = YAML_SCALAR_EVENT;
+ event.start_mark = mark;
+ event.end_mark = mark;
+ event.data.scalar.anchor = anchor;
+ event.data.scalar.tag = node->tag;
+ event.data.scalar.value = node->data.scalar.value;
+ event.data.scalar.length = node->data.scalar.length;
+ event.data.scalar.plain_implicit = plain_implicit;
+ event.data.scalar.quoted_implicit = quoted_implicit;
+ event.data.scalar.style = node->data.scalar.style;
+ tmp_1 = yaml_emitter_emit(emitter,& event);
+ return tmp_1;
+}
+
+static int yaml_emitter_dump_sequence(yaml_emitter_t *emitter,
+ yaml_node_t *node, yaml_char_t *anchor)
+{
+ int __retres;
+ yaml_event_t event;
+ int tmp;
+ yaml_node_item_t *item;
+ int tmp_0;
+ int tmp_2;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ tmp = strcmp((char const *)node->tag,"tag:yaml.org,2002:seq");
+ int implicit = tmp == 0;
+ memset((void *)(& event),0,sizeof(yaml_event_t));
+ event.type = YAML_SEQUENCE_START_EVENT;
+ event.start_mark = mark;
+ event.end_mark = mark;
+ event.data.sequence_start.anchor = anchor;
+ event.data.sequence_start.tag = node->tag;
+ event.data.sequence_start.implicit = implicit;
+ event.data.sequence_start.style = node->data.sequence.style;
+ tmp_0 = yaml_emitter_emit(emitter,& event);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ item = node->data.sequence.items.start;
+ while (item < node->data.sequence.items.top) {
+ {
+ int tmp_1;
+ tmp_1 = yaml_emitter_dump_node(emitter,*item);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ item ++;
+ }
+ memset((void *)(& event),0,sizeof(yaml_event_t));
+ event.type = YAML_SEQUENCE_END_EVENT;
+ event.start_mark = mark;
+ event.end_mark = mark;
+ tmp_2 = yaml_emitter_emit(emitter,& event);
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_dump_mapping(yaml_emitter_t *emitter,
+ yaml_node_t *node, yaml_char_t *anchor)
+{
+ int __retres;
+ yaml_event_t event;
+ int tmp;
+ yaml_node_pair_t *pair;
+ int tmp_0;
+ int tmp_3;
+ yaml_mark_t mark =
+ {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0};
+ tmp = strcmp((char const *)node->tag,"tag:yaml.org,2002:map");
+ int implicit = tmp == 0;
+ memset((void *)(& event),0,sizeof(yaml_event_t));
+ event.type = YAML_MAPPING_START_EVENT;
+ event.start_mark = mark;
+ event.end_mark = mark;
+ event.data.mapping_start.anchor = anchor;
+ event.data.mapping_start.tag = node->tag;
+ event.data.mapping_start.implicit = implicit;
+ event.data.mapping_start.style = node->data.mapping.style;
+ tmp_0 = yaml_emitter_emit(emitter,& event);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ pair = node->data.mapping.pairs.start;
+ while (pair < node->data.mapping.pairs.top) {
+ {
+ int tmp_1;
+ int tmp_2;
+ tmp_1 = yaml_emitter_dump_node(emitter,pair->key);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_2 = yaml_emitter_dump_node(emitter,pair->value);
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ pair ++;
+ }
+ memset((void *)(& event),0,sizeof(yaml_event_t));
+ event.type = YAML_MAPPING_END_EVENT;
+ event.start_mark = mark;
+ event.end_mark = mark;
+ tmp_3 = yaml_emitter_emit(emitter,& event);
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_set_emitter_error(yaml_emitter_t *emitter,
+ char const *problem);
+
+static int yaml_emitter_need_more_events(yaml_emitter_t *emitter);
+
+static int yaml_emitter_append_tag_directive(yaml_emitter_t *emitter,
+ yaml_tag_directive_t value,
+ int allow_duplicates);
+
+static int yaml_emitter_increase_indent(yaml_emitter_t *emitter, int flow,
+ int indentless);
+
+static int yaml_emitter_state_machine(yaml_emitter_t *emitter,
+ yaml_event_t *event);
+
+static int yaml_emitter_emit_stream_start(yaml_emitter_t *emitter,
+ yaml_event_t *event);
+
+static int yaml_emitter_emit_document_start(yaml_emitter_t *emitter,
+ yaml_event_t *event, int first);
+
+static int yaml_emitter_emit_document_content(yaml_emitter_t *emitter,
+ yaml_event_t *event);
+
+static int yaml_emitter_emit_document_end(yaml_emitter_t *emitter,
+ yaml_event_t *event);
+
+static int yaml_emitter_emit_flow_sequence_item(yaml_emitter_t *emitter,
+ yaml_event_t *event,
+ int first);
+
+static int yaml_emitter_emit_flow_mapping_key(yaml_emitter_t *emitter,
+ yaml_event_t *event, int first);
+
+static int yaml_emitter_emit_flow_mapping_value(yaml_emitter_t *emitter,
+ yaml_event_t *event,
+ int simple);
+
+static int yaml_emitter_emit_block_sequence_item(yaml_emitter_t *emitter,
+ yaml_event_t *event,
+ int first);
+
+static int yaml_emitter_emit_block_mapping_key(yaml_emitter_t *emitter,
+ yaml_event_t *event, int first);
+
+static int yaml_emitter_emit_block_mapping_value(yaml_emitter_t *emitter,
+ yaml_event_t *event,
+ int simple);
+
+static int yaml_emitter_emit_node(yaml_emitter_t *emitter,
+ yaml_event_t *event, int root,
+ int sequence, int mapping, int simple_key);
+
+static int yaml_emitter_emit_alias(yaml_emitter_t *emitter,
+ yaml_event_t *event __attribute__((
+ __unused__)));
+
+static int yaml_emitter_emit_scalar(yaml_emitter_t *emitter,
+ yaml_event_t *event);
+
+static int yaml_emitter_emit_sequence_start(yaml_emitter_t *emitter,
+ yaml_event_t *event);
+
+static int yaml_emitter_emit_mapping_start(yaml_emitter_t *emitter,
+ yaml_event_t *event);
+
+static int yaml_emitter_check_empty_document(yaml_emitter_t *emitter __attribute__((
+ __unused__)));
+
+static int yaml_emitter_check_empty_sequence(yaml_emitter_t *emitter);
+
+static int yaml_emitter_check_empty_mapping(yaml_emitter_t *emitter);
+
+static int yaml_emitter_check_simple_key(yaml_emitter_t *emitter);
+
+static int yaml_emitter_select_scalar_style(yaml_emitter_t *emitter,
+ yaml_event_t *event);
+
+static int yaml_emitter_process_anchor(yaml_emitter_t *emitter);
+
+static int yaml_emitter_process_tag(yaml_emitter_t *emitter);
+
+static int yaml_emitter_process_scalar(yaml_emitter_t *emitter);
+
+static int yaml_emitter_analyze_version_directive(yaml_emitter_t *emitter,
+ yaml_version_directive_t version_directive);
+
+static int yaml_emitter_analyze_tag_directive(yaml_emitter_t *emitter,
+ yaml_tag_directive_t tag_directive);
+
+static int yaml_emitter_analyze_anchor(yaml_emitter_t *emitter,
+ yaml_char_t *anchor, int alias);
+
+static int yaml_emitter_analyze_tag(yaml_emitter_t *emitter, yaml_char_t *tag);
+
+static int yaml_emitter_analyze_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length);
+
+static int yaml_emitter_analyze_event(yaml_emitter_t *emitter,
+ yaml_event_t *event);
+
+static int yaml_emitter_write_bom(yaml_emitter_t *emitter);
+
+static int yaml_emitter_write_indent(yaml_emitter_t *emitter);
+
+static int yaml_emitter_write_indicator(yaml_emitter_t *emitter,
+ char const *indicator,
+ int need_whitespace,
+ int is_whitespace, int is_indention);
+
+static int yaml_emitter_write_anchor(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length);
+
+static int yaml_emitter_write_tag_handle(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length);
+
+static int yaml_emitter_write_tag_content(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length,
+ int need_whitespace);
+
+static int yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length,
+ int allow_breaks);
+
+static int yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value,
+ size_t length,
+ int allow_breaks);
+
+static int yaml_emitter_write_double_quoted_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value,
+ size_t length,
+ int allow_breaks);
+
+static int yaml_emitter_write_block_scalar_hints(yaml_emitter_t *emitter,
+ yaml_string_t string);
+
+static int yaml_emitter_write_literal_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value,
+ size_t length);
+
+static int yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length);
+
+static int yaml_emitter_set_emitter_error(yaml_emitter_t *emitter,
+ char const *problem)
+{
+ int __retres;
+ emitter->error = YAML_EMITTER_ERROR;
+ emitter->problem = problem;
+ __retres = 0;
+ return __retres;
+}
+
+int yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event)
+{
+ int __retres;
+ int tmp_1;
+ if (emitter->events.tail != emitter->events.end) goto _LOR;
+ else {
+ int tmp;
+ tmp = yaml_queue_extend((void **)(& emitter->events.start),
+ (void **)(& emitter->events.head),
+ (void **)(& emitter->events.tail),
+ (void **)(& emitter->events.end));
+ if (tmp) {
+ yaml_event_t *tmp_0;
+ _LOR: tmp_0 = emitter->events.tail;
+ (emitter->events.tail) ++;
+ *tmp_0 = *event;
+ tmp_1 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_1 = 0;
+ }
+ }
+ if (! tmp_1) {
+ yaml_event_delete(event);
+ __retres = 0;
+ goto return_label;
+ }
+ while (1) {
+ int tmp_5;
+ tmp_5 = yaml_emitter_need_more_events(emitter);
+ if (tmp_5) break;
+ {
+ int tmp_2;
+ int tmp_3;
+ yaml_event_t *tmp_4;
+ tmp_2 = yaml_emitter_analyze_event(emitter,emitter->events.head);
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_3 = yaml_emitter_state_machine(emitter,emitter->events.head);
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_4 = emitter->events.head;
+ (emitter->events.head) ++;
+ ;
+ yaml_event_delete(tmp_4);
+ }
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_need_more_events(yaml_emitter_t *emitter)
+{
+ int __retres;
+ yaml_event_t *event;
+ int level = 0;
+ int accumulate = 0;
+ if (emitter->events.head == emitter->events.tail) {
+ __retres = 1;
+ goto return_label;
+ }
+ switch ((emitter->events.head)->type) {
+ case (yaml_event_type_t)YAML_DOCUMENT_START_EVENT: accumulate = 1;
+ break;
+ case (yaml_event_type_t)YAML_SEQUENCE_START_EVENT: accumulate = 2;
+ break;
+ case (yaml_event_type_t)YAML_MAPPING_START_EVENT: accumulate = 3;
+ break;
+ default: __retres = 0;
+ goto return_label;
+ }
+ if (emitter->events.tail - emitter->events.head > (long)accumulate) {
+ __retres = 0;
+ goto return_label;
+ }
+ event = emitter->events.head;
+ while (event != emitter->events.tail) {
+ switch (event->type) {
+ case (yaml_event_type_t)YAML_STREAM_START_EVENT:
+ case (yaml_event_type_t)YAML_DOCUMENT_START_EVENT:
+ case (yaml_event_type_t)YAML_SEQUENCE_START_EVENT:
+ case (yaml_event_type_t)YAML_MAPPING_START_EVENT:
+ level ++;
+ break;
+ case (yaml_event_type_t)YAML_STREAM_END_EVENT:
+ case (yaml_event_type_t)YAML_DOCUMENT_END_EVENT:
+ case (yaml_event_type_t)YAML_SEQUENCE_END_EVENT:
+ case (yaml_event_type_t)YAML_MAPPING_END_EVENT:
+ level --;
+ break;
+ default: break;
+ }
+ if (! level) {
+ __retres = 0;
+ goto return_label;
+ }
+ event ++;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_append_tag_directive(yaml_emitter_t *emitter,
+ yaml_tag_directive_t value,
+ int allow_duplicates)
+{
+ int __retres;
+ yaml_tag_directive_t *tag_directive;
+ int tmp_3;
+ yaml_tag_directive_t copy =
+ {.handle = (yaml_char_t *)0, .prefix = (yaml_char_t *)0};
+ tag_directive = emitter->tag_directives.start;
+ while (tag_directive != emitter->tag_directives.top) {
+ {
+ int tmp_0;
+ tmp_0 = strcmp((char const *)value.handle,
+ (char const *)tag_directive->handle);
+ if (tmp_0 == 0) {
+ int tmp;
+ if (allow_duplicates) {
+ __retres = 1;
+ goto return_label;
+ }
+ tmp = yaml_emitter_set_emitter_error(emitter,
+ "duplicate %TAG directive");
+ __retres = tmp;
+ goto return_label;
+ }
+ }
+ tag_directive ++;
+ }
+ copy.handle = yaml_strdup((yaml_char_t const *)value.handle);
+ copy.prefix = yaml_strdup((yaml_char_t const *)value.prefix);
+ if (! copy.handle) goto _LOR;
+ else
+ if (! copy.prefix) {
+ _LOR: {
+ emitter->error = YAML_MEMORY_ERROR;
+ goto error;
+ }
+ }
+ if (emitter->tag_directives.top != emitter->tag_directives.end) goto _LOR_0;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_stack_extend((void **)(& emitter->tag_directives.start),
+ (void **)(& emitter->tag_directives.top),
+ (void **)(& emitter->tag_directives.end));
+ if (tmp_1) {
+ yaml_tag_directive_t *tmp_2;
+ _LOR_0: tmp_2 = emitter->tag_directives.top;
+ (emitter->tag_directives.top) ++;
+ *tmp_2 = copy;
+ tmp_3 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) goto error;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)copy.handle);
+ yaml_free((void *)copy.prefix);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_increase_indent(yaml_emitter_t *emitter, int flow,
+ int indentless)
+{
+ int __retres;
+ int tmp_1;
+ if (emitter->indents.top != emitter->indents.end) goto _LOR;
+ else {
+ int tmp;
+ tmp = yaml_stack_extend((void **)(& emitter->indents.start),
+ (void **)(& emitter->indents.top),
+ (void **)(& emitter->indents.end));
+ if (tmp) {
+ int *tmp_0;
+ _LOR: tmp_0 = emitter->indents.top;
+ (emitter->indents.top) ++;
+ *tmp_0 = emitter->indent;
+ tmp_1 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_1 = 0;
+ }
+ }
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (emitter->indent < 0)
+ if (flow) emitter->indent = emitter->best_indent;
+ else emitter->indent = 0;
+ else
+ if (! indentless) emitter->indent += emitter->best_indent;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_state_machine(yaml_emitter_t *emitter,
+ yaml_event_t *event)
+{
+ int __retres;
+ switch (emitter->state) {
+ int tmp;
+ int tmp_0;
+ int tmp_1;
+ int tmp_2;
+ int tmp_3;
+ int tmp_4;
+ int tmp_5;
+ int tmp_6;
+ int tmp_7;
+ int tmp_8;
+ int tmp_9;
+ int tmp_10;
+ int tmp_11;
+ int tmp_12;
+ int tmp_13;
+ int tmp_14;
+ int tmp_15;
+ int tmp_16;
+ case (yaml_emitter_state_t)YAML_EMIT_STREAM_START_STATE:
+ tmp = yaml_emitter_emit_stream_start(emitter,event);
+ __retres = tmp;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_FIRST_DOCUMENT_START_STATE:
+ tmp_0 = yaml_emitter_emit_document_start(emitter,event,1);
+ __retres = tmp_0;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_DOCUMENT_START_STATE:
+ tmp_1 = yaml_emitter_emit_document_start(emitter,event,0);
+ __retres = tmp_1;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_DOCUMENT_CONTENT_STATE:
+ tmp_2 = yaml_emitter_emit_document_content(emitter,event);
+ __retres = tmp_2;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_DOCUMENT_END_STATE:
+ tmp_3 = yaml_emitter_emit_document_end(emitter,event);
+ __retres = tmp_3;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE:
+ tmp_4 = yaml_emitter_emit_flow_sequence_item(emitter,event,1);
+ __retres = tmp_4;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE:
+ tmp_5 = yaml_emitter_emit_flow_sequence_item(emitter,event,0);
+ __retres = tmp_5;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE:
+ tmp_6 = yaml_emitter_emit_flow_mapping_key(emitter,event,1);
+ __retres = tmp_6;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_FLOW_MAPPING_KEY_STATE:
+ tmp_7 = yaml_emitter_emit_flow_mapping_key(emitter,event,0);
+ __retres = tmp_7;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE:
+ tmp_8 = yaml_emitter_emit_flow_mapping_value(emitter,event,1);
+ __retres = tmp_8;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_FLOW_MAPPING_VALUE_STATE:
+ tmp_9 = yaml_emitter_emit_flow_mapping_value(emitter,event,0);
+ __retres = tmp_9;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE:
+ tmp_10 = yaml_emitter_emit_block_sequence_item(emitter,event,1);
+ __retres = tmp_10;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE:
+ tmp_11 = yaml_emitter_emit_block_sequence_item(emitter,event,0);
+ __retres = tmp_11;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE:
+ tmp_12 = yaml_emitter_emit_block_mapping_key(emitter,event,1);
+ __retres = tmp_12;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_BLOCK_MAPPING_KEY_STATE:
+ tmp_13 = yaml_emitter_emit_block_mapping_key(emitter,event,0);
+ __retres = tmp_13;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE:
+ tmp_14 = yaml_emitter_emit_block_mapping_value(emitter,event,1);
+ __retres = tmp_14;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_BLOCK_MAPPING_VALUE_STATE:
+ tmp_15 = yaml_emitter_emit_block_mapping_value(emitter,event,0);
+ __retres = tmp_15;
+ goto return_label;
+ case (yaml_emitter_state_t)YAML_EMIT_END_STATE:
+ tmp_16 = yaml_emitter_set_emitter_error(emitter,
+ "expected nothing after STREAM-END");
+ __retres = tmp_16;
+ goto return_label;
+ default: __FC_assert(1 != 0,"src/emitter.c",484,"1");
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_stream_start(yaml_emitter_t *emitter,
+ yaml_event_t *event)
+{
+ int __retres;
+ int tmp_0;
+ emitter->open_ended = 0;
+ if (event->type == (unsigned int)YAML_STREAM_START_EVENT) {
+ if (! emitter->encoding) emitter->encoding = event->data.stream_start.encoding;
+ if (! emitter->encoding) emitter->encoding = YAML_UTF8_ENCODING;
+ if (emitter->best_indent < 2) goto _LOR;
+ else
+ if (emitter->best_indent > 9) _LOR: emitter->best_indent = 2;
+ if (emitter->best_width >= 0)
+ if (emitter->best_width <= emitter->best_indent * 2) emitter->best_width = 80;
+ if (emitter->best_width < 0) emitter->best_width = 2147483647;
+ if (! emitter->line_break) emitter->line_break = YAML_LN_BREAK;
+ emitter->indent = -1;
+ emitter->line = 0;
+ emitter->column = 0;
+ emitter->whitespace = 1;
+ emitter->indention = 1;
+ if (emitter->encoding != (unsigned int)YAML_UTF8_ENCODING) {
+ int tmp;
+ tmp = yaml_emitter_write_bom(emitter);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->state = YAML_EMIT_FIRST_DOCUMENT_START_STATE;
+ __retres = 1;
+ goto return_label;
+ }
+ tmp_0 = yaml_emitter_set_emitter_error(emitter,"expected STREAM-START");
+ __retres = tmp_0;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_document_start(yaml_emitter_t *emitter,
+ yaml_event_t *event, int first)
+{
+ int __retres;
+ int tmp_22;
+ if (event->type == (unsigned int)YAML_DOCUMENT_START_EVENT) {
+ yaml_tag_directive_t *tag_directive;
+ int implicit;
+ int tmp_15;
+ yaml_tag_directive_t default_tag_directives[3] =
+ {{.handle = (yaml_char_t *)"!", .prefix = (yaml_char_t *)"!"},
+ {.handle = (yaml_char_t *)"!!",
+ .prefix = (yaml_char_t *)"tag:yaml.org,2002:"},
+ {.handle = (yaml_char_t *)0, .prefix = (yaml_char_t *)0}};
+ if (event->data.document_start.version_directive) {
+ int tmp;
+ tmp = yaml_emitter_analyze_version_directive(emitter,
+ *(event->data.document_start.version_directive));
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ tag_directive = event->data.document_start.tag_directives.start;
+ while (tag_directive != event->data.document_start.tag_directives.end) {
+ {
+ int tmp_0;
+ int tmp_1;
+ tmp_0 = yaml_emitter_analyze_tag_directive(emitter,*tag_directive);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_1 = yaml_emitter_append_tag_directive(emitter,*tag_directive,0);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ tag_directive ++;
+ }
+ tag_directive = default_tag_directives;
+ while (tag_directive->handle) {
+ {
+ int tmp_2;
+ tmp_2 = yaml_emitter_append_tag_directive(emitter,*tag_directive,1);
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ tag_directive ++;
+ }
+ implicit = event->data.document_start.implicit;
+ if (! first) goto _LOR;
+ else
+ if (emitter->canonical) _LOR: implicit = 0;
+ if (event->data.document_start.version_directive) goto _LOR_0;
+ else
+ if (event->data.document_start.tag_directives.start != event->data.document_start.tag_directives.end) {
+ _LOR_0: ;
+ if (emitter->open_ended) {
+ int tmp_3;
+ int tmp_4;
+ tmp_3 = yaml_emitter_write_indicator(emitter,"...",1,0,0);
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_4 = yaml_emitter_write_indent(emitter);
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ emitter->open_ended = 0;
+ if (event->data.document_start.version_directive) {
+ int tmp_5;
+ int tmp_8;
+ implicit = 0;
+ tmp_5 = yaml_emitter_write_indicator(emitter,"%YAML",1,0,0);
+ if (! tmp_5) {
+ __retres = 0;
+ goto return_label;
+ }
+ if ((event->data.document_start.version_directive)->minor == 1) {
+ int tmp_6;
+ tmp_6 = yaml_emitter_write_indicator(emitter,"1.1",1,0,0);
+ if (! tmp_6) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ else {
+ int tmp_7;
+ tmp_7 = yaml_emitter_write_indicator(emitter,"1.2",1,0,0);
+ if (! tmp_7) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ tmp_8 = yaml_emitter_write_indent(emitter);
+ if (! tmp_8) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (event->data.document_start.tag_directives.start != event->data.document_start.tag_directives.end) {
+ implicit = 0;
+ tag_directive = event->data.document_start.tag_directives.start;
+ while (tag_directive != event->data.document_start.tag_directives.end) {
+ {
+ int tmp_9;
+ int tmp_11;
+ size_t tmp_10;
+ int tmp_13;
+ size_t tmp_12;
+ int tmp_14;
+ tmp_9 = yaml_emitter_write_indicator(emitter,"%TAG",1,0,0);
+ if (! tmp_9) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_10 = strlen((char const *)tag_directive->handle);
+ ;
+ ;
+ tmp_11 = yaml_emitter_write_tag_handle(emitter,
+ tag_directive->handle,
+ tmp_10);
+ if (! tmp_11) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_12 = strlen((char const *)tag_directive->prefix);
+ ;
+ ;
+ tmp_13 = yaml_emitter_write_tag_content(emitter,
+ tag_directive->prefix,
+ tmp_12,1);
+ if (! tmp_13) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_14 = yaml_emitter_write_indent(emitter);
+ if (! tmp_14) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ tag_directive ++;
+ }
+ }
+ tmp_15 = yaml_emitter_check_empty_document(emitter);
+ if (tmp_15) implicit = 0;
+ if (! implicit) {
+ int tmp_16;
+ int tmp_17;
+ tmp_16 = yaml_emitter_write_indent(emitter);
+ if (! tmp_16) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_17 = yaml_emitter_write_indicator(emitter,"---",1,0,0);
+ if (! tmp_17) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (emitter->canonical) {
+ int tmp_18;
+ tmp_18 = yaml_emitter_write_indent(emitter);
+ if (! tmp_18) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ emitter->state = YAML_EMIT_DOCUMENT_CONTENT_STATE;
+ emitter->open_ended = 0;
+ __retres = 1;
+ goto return_label;
+ }
+ else
+ if (event->type == (unsigned int)YAML_STREAM_END_EVENT) {
+ int tmp_21;
+ if (emitter->open_ended == 2) {
+ int tmp_19;
+ int tmp_20;
+ tmp_19 = yaml_emitter_write_indicator(emitter,"...",1,0,0);
+ if (! tmp_19) {
+ __retres = 0;
+ goto return_label;
+ }
+ emitter->open_ended = 0;
+ tmp_20 = yaml_emitter_write_indent(emitter);
+ if (! tmp_20) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ tmp_21 = yaml_emitter_flush(emitter);
+ if (! tmp_21) {
+ __retres = 0;
+ goto return_label;
+ }
+ emitter->state = YAML_EMIT_END_STATE;
+ __retres = 1;
+ goto return_label;
+ }
+ tmp_22 = yaml_emitter_set_emitter_error(emitter,
+ "expected DOCUMENT-START or STREAM-END");
+ __retres = tmp_22;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_document_content(yaml_emitter_t *emitter,
+ yaml_event_t *event)
+{
+ int __retres;
+ int tmp_1;
+ int tmp_2;
+ if (emitter->states.top != emitter->states.end) goto _LOR;
+ else {
+ int tmp;
+ tmp = yaml_stack_extend((void **)(& emitter->states.start),
+ (void **)(& emitter->states.top),
+ (void **)(& emitter->states.end));
+ if (tmp) {
+ yaml_emitter_state_t *tmp_0;
+ _LOR: tmp_0 = emitter->states.top;
+ (emitter->states.top) ++;
+ *tmp_0 = YAML_EMIT_DOCUMENT_END_STATE;
+ tmp_1 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_1 = 0;
+ }
+ }
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_2 = yaml_emitter_emit_node(emitter,event,1,0,0,0);
+ __retres = tmp_2;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_document_end(yaml_emitter_t *emitter,
+ yaml_event_t *event)
+{
+ int __retres;
+ int tmp_3;
+ if (event->type == (unsigned int)YAML_DOCUMENT_END_EVENT) {
+ int tmp;
+ int tmp_2;
+ tmp = yaml_emitter_write_indent(emitter);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (! event->data.document_end.implicit) {
+ int tmp_0;
+ int tmp_1;
+ tmp_0 = yaml_emitter_write_indicator(emitter,"...",1,0,0);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ emitter->open_ended = 0;
+ tmp_1 = yaml_emitter_write_indent(emitter);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ else
+ if (! emitter->open_ended) emitter->open_ended = 1;
+ tmp_2 = yaml_emitter_flush(emitter);
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ emitter->state = YAML_EMIT_DOCUMENT_START_STATE;
+ while (! (emitter->tag_directives.start == emitter->tag_directives.top)) {
+ (emitter->tag_directives.top) --;
+ yaml_tag_directive_t tag_directive = *(emitter->tag_directives.top);
+ yaml_free((void *)tag_directive.handle);
+ yaml_free((void *)tag_directive.prefix);
+ }
+ __retres = 1;
+ goto return_label;
+ }
+ tmp_3 = yaml_emitter_set_emitter_error(emitter,"expected DOCUMENT-END");
+ __retres = tmp_3;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_flow_sequence_item(yaml_emitter_t *emitter,
+ yaml_event_t *event,
+ int first)
+{
+ int __retres;
+ int tmp_8;
+ int tmp_9;
+ if (first) {
+ int tmp;
+ int tmp_0;
+ tmp = yaml_emitter_write_indicator(emitter,"[",1,1,0);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_0 = yaml_emitter_increase_indent(emitter,1,0);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ (emitter->flow_level) ++;
+ }
+ if (event->type == (unsigned int)YAML_SEQUENCE_END_EVENT) {
+ int tmp_3;
+ (emitter->flow_level) --;
+ (emitter->indents.top) --;
+ emitter->indent = *(emitter->indents.top);
+ if (emitter->canonical)
+ if (! first) {
+ int tmp_1;
+ int tmp_2;
+ tmp_1 = yaml_emitter_write_indicator(emitter,",",0,0,0);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_2 = yaml_emitter_write_indent(emitter);
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ tmp_3 = yaml_emitter_write_indicator(emitter,"]",0,0,0);
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ (emitter->states.top) --;
+ emitter->state = *(emitter->states.top);
+ __retres = 1;
+ goto return_label;
+ }
+ if (! first) {
+ int tmp_4;
+ tmp_4 = yaml_emitter_write_indicator(emitter,",",0,0,0);
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (emitter->canonical) goto _LOR;
+ else
+ if (emitter->column > emitter->best_width) {
+ _LOR:
+ {
+ int tmp_5;
+ tmp_5 = yaml_emitter_write_indent(emitter);
+ if (! tmp_5) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ if (emitter->states.top != emitter->states.end) goto _LOR_0;
+ else {
+ int tmp_6;
+ tmp_6 = yaml_stack_extend((void **)(& emitter->states.start),
+ (void **)(& emitter->states.top),
+ (void **)(& emitter->states.end));
+ if (tmp_6) {
+ yaml_emitter_state_t *tmp_7;
+ _LOR_0: tmp_7 = emitter->states.top;
+ (emitter->states.top) ++;
+ *tmp_7 = YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE;
+ tmp_8 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_8 = 0;
+ }
+ }
+ if (! tmp_8) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_9 = yaml_emitter_emit_node(emitter,event,0,1,0,0);
+ __retres = tmp_9;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_flow_mapping_key(yaml_emitter_t *emitter,
+ yaml_event_t *event, int first)
+{
+ int __retres;
+ if (first) {
+ int tmp;
+ int tmp_0;
+ tmp = yaml_emitter_write_indicator(emitter,"{",1,1,0);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_0 = yaml_emitter_increase_indent(emitter,1,0);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ (emitter->flow_level) ++;
+ }
+ if (event->type == (unsigned int)YAML_MAPPING_END_EVENT) {
+ int tmp_3;
+ (emitter->flow_level) --;
+ (emitter->indents.top) --;
+ emitter->indent = *(emitter->indents.top);
+ if (emitter->canonical)
+ if (! first) {
+ int tmp_1;
+ int tmp_2;
+ tmp_1 = yaml_emitter_write_indicator(emitter,",",0,0,0);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_2 = yaml_emitter_write_indent(emitter);
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ tmp_3 = yaml_emitter_write_indicator(emitter,"}",0,0,0);
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ (emitter->states.top) --;
+ emitter->state = *(emitter->states.top);
+ __retres = 1;
+ goto return_label;
+ }
+ if (! first) {
+ int tmp_4;
+ tmp_4 = yaml_emitter_write_indicator(emitter,",",0,0,0);
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (emitter->canonical) goto _LOR;
+ else
+ if (emitter->column > emitter->best_width) {
+ _LOR:
+ {
+ int tmp_5;
+ tmp_5 = yaml_emitter_write_indent(emitter);
+ if (! tmp_5) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ if (! emitter->canonical) {
+ int tmp_15;
+ tmp_15 = yaml_emitter_check_simple_key(emitter);
+ if (tmp_15) {
+ int tmp_8;
+ int tmp_9;
+ if (emitter->states.top != emitter->states.end) goto _LOR_0;
+ else {
+ int tmp_6;
+ tmp_6 = yaml_stack_extend((void **)(& emitter->states.start),
+ (void **)(& emitter->states.top),
+ (void **)(& emitter->states.end));
+ if (tmp_6) {
+ yaml_emitter_state_t *tmp_7;
+ _LOR_0: tmp_7 = emitter->states.top;
+ (emitter->states.top) ++;
+ *tmp_7 = YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE;
+ tmp_8 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_8 = 0;
+ }
+ }
+ if (! tmp_8) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_9 = yaml_emitter_emit_node(emitter,event,0,0,1,1);
+ __retres = tmp_9;
+ goto return_label;
+ }
+ else goto _LAND;
+ }
+ else {
+ _LAND:
+ {
+ int tmp_10;
+ int tmp_13;
+ int tmp_14;
+ tmp_10 = yaml_emitter_write_indicator(emitter,"?",1,0,0);
+ if (! tmp_10) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (emitter->states.top != emitter->states.end) goto _LOR_1;
+ else {
+ int tmp_11;
+ tmp_11 = yaml_stack_extend((void **)(& emitter->states.start),
+ (void **)(& emitter->states.top),
+ (void **)(& emitter->states.end));
+ if (tmp_11) {
+ yaml_emitter_state_t *tmp_12;
+ _LOR_1: tmp_12 = emitter->states.top;
+ (emitter->states.top) ++;
+ *tmp_12 = YAML_EMIT_FLOW_MAPPING_VALUE_STATE;
+ tmp_13 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_13 = 0;
+ }
+ }
+ if (! tmp_13) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_14 = yaml_emitter_emit_node(emitter,event,0,0,1,0);
+ __retres = tmp_14;
+ goto return_label;
+ }
+ }
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_flow_mapping_value(yaml_emitter_t *emitter,
+ yaml_event_t *event,
+ int simple)
+{
+ int __retres;
+ int tmp_4;
+ int tmp_5;
+ if (simple) {
+ int tmp;
+ tmp = yaml_emitter_write_indicator(emitter,":",0,0,0);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ else {
+ int tmp_1;
+ if (emitter->canonical) goto _LOR;
+ else
+ if (emitter->column > emitter->best_width) {
+ _LOR:
+ {
+ int tmp_0;
+ tmp_0 = yaml_emitter_write_indent(emitter);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ tmp_1 = yaml_emitter_write_indicator(emitter,":",1,0,0);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (emitter->states.top != emitter->states.end) goto _LOR_0;
+ else {
+ int tmp_2;
+ tmp_2 = yaml_stack_extend((void **)(& emitter->states.start),
+ (void **)(& emitter->states.top),
+ (void **)(& emitter->states.end));
+ if (tmp_2) {
+ yaml_emitter_state_t *tmp_3;
+ _LOR_0: tmp_3 = emitter->states.top;
+ (emitter->states.top) ++;
+ *tmp_3 = YAML_EMIT_FLOW_MAPPING_KEY_STATE;
+ tmp_4 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_4 = 0;
+ }
+ }
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_5 = yaml_emitter_emit_node(emitter,event,0,0,1,0);
+ __retres = tmp_5;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_block_sequence_item(yaml_emitter_t *emitter,
+ yaml_event_t *event,
+ int first)
+{
+ int __retres;
+ int tmp_1;
+ int tmp_2;
+ int tmp_5;
+ int tmp_6;
+ if (first) {
+ int tmp_0;
+ int tmp;
+ if (emitter->mapping_context)
+ if (! emitter->indention) tmp = 1; else tmp = 0;
+ else tmp = 0;
+ ;
+ tmp_0 = yaml_emitter_increase_indent(emitter,0,tmp);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (event->type == (unsigned int)YAML_SEQUENCE_END_EVENT) {
+ (emitter->indents.top) --;
+ emitter->indent = *(emitter->indents.top);
+ (emitter->states.top) --;
+ emitter->state = *(emitter->states.top);
+ __retres = 1;
+ goto return_label;
+ }
+ tmp_1 = yaml_emitter_write_indent(emitter);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_2 = yaml_emitter_write_indicator(emitter,"-",1,0,1);
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (emitter->states.top != emitter->states.end) goto _LOR;
+ else {
+ int tmp_3;
+ tmp_3 = yaml_stack_extend((void **)(& emitter->states.start),
+ (void **)(& emitter->states.top),
+ (void **)(& emitter->states.end));
+ if (tmp_3) {
+ yaml_emitter_state_t *tmp_4;
+ _LOR: tmp_4 = emitter->states.top;
+ (emitter->states.top) ++;
+ *tmp_4 = YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE;
+ tmp_5 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_5 = 0;
+ }
+ }
+ if (! tmp_5) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_6 = yaml_emitter_emit_node(emitter,event,0,1,0,0);
+ __retres = tmp_6;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_block_mapping_key(yaml_emitter_t *emitter,
+ yaml_event_t *event, int first)
+{
+ int __retres;
+ int tmp_0;
+ int tmp_10;
+ if (first) {
+ int tmp;
+ tmp = yaml_emitter_increase_indent(emitter,0,0);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (event->type == (unsigned int)YAML_MAPPING_END_EVENT) {
+ (emitter->indents.top) --;
+ emitter->indent = *(emitter->indents.top);
+ (emitter->states.top) --;
+ emitter->state = *(emitter->states.top);
+ __retres = 1;
+ goto return_label;
+ }
+ tmp_0 = yaml_emitter_write_indent(emitter);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_10 = yaml_emitter_check_simple_key(emitter);
+ if (tmp_10) {
+ int tmp_3;
+ int tmp_4;
+ if (emitter->states.top != emitter->states.end) goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_stack_extend((void **)(& emitter->states.start),
+ (void **)(& emitter->states.top),
+ (void **)(& emitter->states.end));
+ if (tmp_1) {
+ yaml_emitter_state_t *tmp_2;
+ _LOR: tmp_2 = emitter->states.top;
+ (emitter->states.top) ++;
+ *tmp_2 = YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE;
+ tmp_3 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_4 = yaml_emitter_emit_node(emitter,event,0,0,1,1);
+ __retres = tmp_4;
+ goto return_label;
+ }
+ else {
+ int tmp_5;
+ int tmp_8;
+ int tmp_9;
+ tmp_5 = yaml_emitter_write_indicator(emitter,"?",1,0,1);
+ if (! tmp_5) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (emitter->states.top != emitter->states.end) goto _LOR_0;
+ else {
+ int tmp_6;
+ tmp_6 = yaml_stack_extend((void **)(& emitter->states.start),
+ (void **)(& emitter->states.top),
+ (void **)(& emitter->states.end));
+ if (tmp_6) {
+ yaml_emitter_state_t *tmp_7;
+ _LOR_0: tmp_7 = emitter->states.top;
+ (emitter->states.top) ++;
+ *tmp_7 = YAML_EMIT_BLOCK_MAPPING_VALUE_STATE;
+ tmp_8 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_8 = 0;
+ }
+ }
+ if (! tmp_8) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_9 = yaml_emitter_emit_node(emitter,event,0,0,1,0);
+ __retres = tmp_9;
+ goto return_label;
+ }
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_block_mapping_value(yaml_emitter_t *emitter,
+ yaml_event_t *event,
+ int simple)
+{
+ int __retres;
+ int tmp_4;
+ int tmp_5;
+ if (simple) {
+ int tmp;
+ tmp = yaml_emitter_write_indicator(emitter,":",0,0,0);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ else {
+ int tmp_0;
+ int tmp_1;
+ tmp_0 = yaml_emitter_write_indent(emitter);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_1 = yaml_emitter_write_indicator(emitter,":",1,0,1);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (emitter->states.top != emitter->states.end) goto _LOR;
+ else {
+ int tmp_2;
+ tmp_2 = yaml_stack_extend((void **)(& emitter->states.start),
+ (void **)(& emitter->states.top),
+ (void **)(& emitter->states.end));
+ if (tmp_2) {
+ yaml_emitter_state_t *tmp_3;
+ _LOR: tmp_3 = emitter->states.top;
+ (emitter->states.top) ++;
+ *tmp_3 = YAML_EMIT_BLOCK_MAPPING_KEY_STATE;
+ tmp_4 = 1;
+ }
+ else {
+ emitter->error = YAML_MEMORY_ERROR;
+ tmp_4 = 0;
+ }
+ }
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_5 = yaml_emitter_emit_node(emitter,event,0,0,1,0);
+ __retres = tmp_5;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_node(yaml_emitter_t *emitter,
+ yaml_event_t *event, int root,
+ int sequence, int mapping, int simple_key)
+{
+ int __retres;
+ emitter->root_context = root;
+ emitter->sequence_context = sequence;
+ emitter->mapping_context = mapping;
+ emitter->simple_key_context = simple_key;
+ switch (event->type) {
+ int tmp;
+ int tmp_0;
+ int tmp_1;
+ int tmp_2;
+ int tmp_3;
+ case (yaml_event_type_t)YAML_ALIAS_EVENT:
+ tmp = yaml_emitter_emit_alias(emitter,event);
+ __retres = tmp;
+ goto return_label;
+ case (yaml_event_type_t)YAML_SCALAR_EVENT:
+ tmp_0 = yaml_emitter_emit_scalar(emitter,event);
+ __retres = tmp_0;
+ goto return_label;
+ case (yaml_event_type_t)YAML_SEQUENCE_START_EVENT:
+ tmp_1 = yaml_emitter_emit_sequence_start(emitter,event);
+ __retres = tmp_1;
+ goto return_label;
+ case (yaml_event_type_t)YAML_MAPPING_START_EVENT:
+ tmp_2 = yaml_emitter_emit_mapping_start(emitter,event);
+ __retres = tmp_2;
+ goto return_label;
+ default:
+ tmp_3 = yaml_emitter_set_emitter_error(emitter,
+ "expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS");
+ __retres = tmp_3;
+ goto return_label;
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_alias(yaml_emitter_t *emitter,
+ yaml_event_t *event __attribute__((
+ __unused__)))
+{
+ int __retres;
+ int tmp;
+ tmp = yaml_emitter_process_anchor(emitter);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (emitter->simple_key_context)
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR;
+ else {
+ int tmp_0;
+ tmp_0 = yaml_emitter_flush(emitter);
+ if (tmp_0) {
+ yaml_char_t *tmp_1;
+ _LOR:
+ { /* sequence */
+ tmp_1 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_1 = (unsigned char)' ';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ (emitter->states.top) --;
+ emitter->state = *(emitter->states.top);
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_scalar(yaml_emitter_t *emitter,
+ yaml_event_t *event)
+{
+ int __retres;
+ int tmp;
+ int tmp_0;
+ int tmp_1;
+ int tmp_2;
+ int tmp_3;
+ tmp = yaml_emitter_select_scalar_style(emitter,event);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_0 = yaml_emitter_process_anchor(emitter);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_1 = yaml_emitter_process_tag(emitter);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_2 = yaml_emitter_increase_indent(emitter,1,0);
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_3 = yaml_emitter_process_scalar(emitter);
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ (emitter->indents.top) --;
+ emitter->indent = *(emitter->indents.top);
+ (emitter->states.top) --;
+ emitter->state = *(emitter->states.top);
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_sequence_start(yaml_emitter_t *emitter,
+ yaml_event_t *event)
+{
+ int __retres;
+ int tmp;
+ int tmp_0;
+ tmp = yaml_emitter_process_anchor(emitter);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_0 = yaml_emitter_process_tag(emitter);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (emitter->flow_level) goto _LOR;
+ else
+ if (emitter->canonical) goto _LOR;
+ else
+ if (event->data.sequence_start.style == (unsigned int)YAML_FLOW_SEQUENCE_STYLE)
+ goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_emitter_check_empty_sequence(emitter);
+ if (tmp_1) _LOR:
+ emitter->state = YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE;
+ else emitter->state = YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_emit_mapping_start(yaml_emitter_t *emitter,
+ yaml_event_t *event)
+{
+ int __retres;
+ int tmp;
+ int tmp_0;
+ tmp = yaml_emitter_process_anchor(emitter);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_0 = yaml_emitter_process_tag(emitter);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (emitter->flow_level) goto _LOR;
+ else
+ if (emitter->canonical) goto _LOR;
+ else
+ if (event->data.mapping_start.style == (unsigned int)YAML_FLOW_MAPPING_STYLE)
+ goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_emitter_check_empty_mapping(emitter);
+ if (tmp_1) _LOR:
+ emitter->state = YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE;
+ else emitter->state = YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_check_empty_document(yaml_emitter_t *emitter __attribute__((
+ __unused__)))
+{
+ int __retres;
+ __retres = 0;
+ return __retres;
+}
+
+static int yaml_emitter_check_empty_sequence(yaml_emitter_t *emitter)
+{
+ int __retres;
+ int tmp;
+ if (emitter->events.tail - emitter->events.head < (long)2) {
+ __retres = 0;
+ goto return_label;
+ }
+ if ((emitter->events.head + 0)->type == (unsigned int)YAML_SEQUENCE_START_EVENT)
+ if ((emitter->events.head + 1)->type == (unsigned int)YAML_SEQUENCE_END_EVENT)
+ tmp = 1;
+ else tmp = 0;
+ else tmp = 0;
+ __retres = tmp;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_check_empty_mapping(yaml_emitter_t *emitter)
+{
+ int __retres;
+ int tmp;
+ if (emitter->events.tail - emitter->events.head < (long)2) {
+ __retres = 0;
+ goto return_label;
+ }
+ if ((emitter->events.head + 0)->type == (unsigned int)YAML_MAPPING_START_EVENT)
+ if ((emitter->events.head + 1)->type == (unsigned int)YAML_MAPPING_END_EVENT)
+ tmp = 1;
+ else tmp = 0;
+ else tmp = 0;
+ __retres = tmp;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_check_simple_key(yaml_emitter_t *emitter)
+{
+ int __retres;
+ yaml_event_t *event = emitter->events.head;
+ size_t length = (unsigned long)0;
+ switch (event->type) {
+ int tmp;
+ int tmp_0;
+ case (yaml_event_type_t)YAML_ALIAS_EVENT:
+ length += emitter->anchor_data.anchor_length;
+ break;
+ case (yaml_event_type_t)YAML_SCALAR_EVENT: ;
+ if (emitter->scalar_data.multiline) {
+ __retres = 0;
+ goto return_label;
+ }
+ length += ((emitter->anchor_data.anchor_length + emitter->tag_data.handle_length) + emitter->tag_data.suffix_length) + emitter->scalar_data.length;
+ break;
+ case (yaml_event_type_t)YAML_SEQUENCE_START_EVENT:
+ tmp = yaml_emitter_check_empty_sequence(emitter);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ length += (emitter->anchor_data.anchor_length + emitter->tag_data.handle_length) + emitter->tag_data.suffix_length;
+ break;
+ case (yaml_event_type_t)YAML_MAPPING_START_EVENT:
+ tmp_0 = yaml_emitter_check_empty_mapping(emitter);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ length += (emitter->anchor_data.anchor_length + emitter->tag_data.handle_length) + emitter->tag_data.suffix_length;
+ break;
+ default: __retres = 0;
+ goto return_label;
+ }
+ if (length > (size_t)128) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_select_scalar_style(yaml_emitter_t *emitter,
+ yaml_event_t *event)
+{
+ int __retres;
+ int tmp;
+ yaml_scalar_style_t style = event->data.scalar.style;
+ if (! emitter->tag_data.handle)
+ if (! emitter->tag_data.suffix) tmp = 1; else tmp = 0;
+ else tmp = 0;
+ int no_tag = tmp;
+ if (no_tag)
+ if (! event->data.scalar.plain_implicit)
+ if (! event->data.scalar.quoted_implicit) {
+ int tmp_0;
+ tmp_0 = yaml_emitter_set_emitter_error(emitter,
+ "neither tag nor implicit flags are specified");
+ __retres = tmp_0;
+ goto return_label;
+ }
+ if (style == (unsigned int)YAML_ANY_SCALAR_STYLE) style = YAML_PLAIN_SCALAR_STYLE;
+ if (emitter->canonical) style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
+ if (emitter->simple_key_context)
+ if (emitter->scalar_data.multiline) style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
+ if (style == (unsigned int)YAML_PLAIN_SCALAR_STYLE) {
+ if (emitter->flow_level) {
+ if (! emitter->scalar_data.flow_plain_allowed) style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
+ else goto _LAND;
+ }
+ else
+ _LAND:
+ if (! emitter->flow_level)
+ if (! emitter->scalar_data.block_plain_allowed) style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
+ if (! emitter->scalar_data.length)
+ if (emitter->flow_level) style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
+ else
+ if (emitter->simple_key_context) style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
+ if (no_tag)
+ if (! event->data.scalar.plain_implicit) style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
+ }
+ if (style == (unsigned int)YAML_SINGLE_QUOTED_SCALAR_STYLE)
+ if (! emitter->scalar_data.single_quoted_allowed) style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
+ if (style == (unsigned int)YAML_LITERAL_SCALAR_STYLE) goto _LOR;
+ else
+ if (style == (unsigned int)YAML_FOLDED_SCALAR_STYLE)
+ _LOR:
+ if (! emitter->scalar_data.block_allowed) style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
+ else
+ if (emitter->flow_level) style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
+ else
+ if (emitter->simple_key_context) style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
+ if (no_tag)
+ if (! event->data.scalar.quoted_implicit)
+ if (style != (unsigned int)YAML_PLAIN_SCALAR_STYLE) {
+ emitter->tag_data.handle = (yaml_char_t *)"!";
+ emitter->tag_data.handle_length = (unsigned long)1;
+ }
+ emitter->scalar_data.style = style;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_process_anchor(yaml_emitter_t *emitter)
+{
+ int __retres;
+ int tmp_0;
+ char const *tmp;
+ int tmp_1;
+ if (! emitter->anchor_data.anchor) {
+ __retres = 1;
+ goto return_label;
+ }
+ if (emitter->anchor_data.alias) tmp = "*"; else tmp = "&";
+ ;
+ tmp_0 = yaml_emitter_write_indicator(emitter,tmp,1,0,0);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_1 = yaml_emitter_write_anchor(emitter,emitter->anchor_data.anchor,
+ emitter->anchor_data.anchor_length);
+ __retres = tmp_1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_process_tag(yaml_emitter_t *emitter)
+{
+ int __retres;
+ if (! emitter->tag_data.handle)
+ if (! emitter->tag_data.suffix) {
+ __retres = 1;
+ goto return_label;
+ }
+ if (emitter->tag_data.handle) {
+ int tmp;
+ tmp = yaml_emitter_write_tag_handle(emitter,emitter->tag_data.handle,
+ emitter->tag_data.handle_length);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (emitter->tag_data.suffix) {
+ int tmp_0;
+ tmp_0 = yaml_emitter_write_tag_content(emitter,
+ emitter->tag_data.suffix,
+ emitter->tag_data.suffix_length,
+ 0);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ else {
+ int tmp_1;
+ int tmp_2;
+ int tmp_3;
+ tmp_1 = yaml_emitter_write_indicator(emitter,"!<",1,0,0);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_2 = yaml_emitter_write_tag_content(emitter,emitter->tag_data.suffix,
+ emitter->tag_data.suffix_length,0);
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_3 = yaml_emitter_write_indicator(emitter,">",0,0,0);
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_process_scalar(yaml_emitter_t *emitter)
+{
+ int __retres;
+ switch (emitter->scalar_data.style) {
+ int tmp;
+ int tmp_0;
+ int tmp_1;
+ int tmp_2;
+ int tmp_3;
+ case (yaml_scalar_style_t)YAML_PLAIN_SCALAR_STYLE:
+ tmp = yaml_emitter_write_plain_scalar(emitter,emitter->scalar_data.value,
+ emitter->scalar_data.length,
+ ! emitter->simple_key_context);
+ __retres = tmp;
+ goto return_label;
+ case (yaml_scalar_style_t)YAML_SINGLE_QUOTED_SCALAR_STYLE:
+ tmp_0 = yaml_emitter_write_single_quoted_scalar(emitter,
+ emitter->scalar_data.value,
+ emitter->scalar_data.length,
+ ! emitter->simple_key_context);
+ __retres = tmp_0;
+ goto return_label;
+ case (yaml_scalar_style_t)YAML_DOUBLE_QUOTED_SCALAR_STYLE:
+ tmp_1 = yaml_emitter_write_double_quoted_scalar(emitter,
+ emitter->scalar_data.value,
+ emitter->scalar_data.length,
+ ! emitter->simple_key_context);
+ __retres = tmp_1;
+ goto return_label;
+ case (yaml_scalar_style_t)YAML_LITERAL_SCALAR_STYLE:
+ tmp_2 = yaml_emitter_write_literal_scalar(emitter,
+ emitter->scalar_data.value,
+ emitter->scalar_data.length);
+ __retres = tmp_2;
+ goto return_label;
+ case (yaml_scalar_style_t)YAML_FOLDED_SCALAR_STYLE:
+ tmp_3 = yaml_emitter_write_folded_scalar(emitter,
+ emitter->scalar_data.value,
+ emitter->scalar_data.length);
+ __retres = tmp_3;
+ goto return_label;
+ default: __FC_assert(1 != 0,"src/emitter.c",1341,"1");
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_analyze_version_directive(yaml_emitter_t *emitter,
+ yaml_version_directive_t version_directive)
+{
+ int __retres;
+ if (version_directive.major != 1) goto _LOR;
+ else
+ if (version_directive.minor != 1)
+ if (version_directive.minor != 2) {
+ _LOR:
+ {
+ int tmp;
+ tmp = yaml_emitter_set_emitter_error(emitter,
+ "incompatible %YAML directive");
+ __retres = tmp;
+ goto return_label;
+ }
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_analyze_tag_directive(yaml_emitter_t *emitter,
+ yaml_tag_directive_t tag_directive)
+{
+ int __retres;
+ yaml_string_t handle;
+ yaml_string_t prefix;
+ size_t handle_length;
+ size_t prefix_length;
+ handle_length = strlen((char const *)tag_directive.handle);
+ prefix_length = strlen((char const *)tag_directive.prefix);
+ handle.start = tag_directive.handle;
+ handle.end = tag_directive.handle + handle_length;
+ handle.pointer = tag_directive.handle;
+ prefix.start = tag_directive.prefix;
+ prefix.end = tag_directive.prefix + prefix_length;
+ prefix.pointer = tag_directive.prefix;
+ if (handle.start == handle.end) {
+ int tmp;
+ tmp = yaml_emitter_set_emitter_error(emitter,
+ "tag handle must not be empty");
+ __retres = tmp;
+ goto return_label;
+ }
+ if ((int)*(handle.start + 0) != '!') {
+ int tmp_0;
+ tmp_0 = yaml_emitter_set_emitter_error(emitter,
+ "tag handle must start with \'!\'");
+ __retres = tmp_0;
+ goto return_label;
+ }
+ if ((int)*(handle.end + -1) != '!') {
+ int tmp_1;
+ tmp_1 = yaml_emitter_set_emitter_error(emitter,
+ "tag handle must end with \'!\'");
+ __retres = tmp_1;
+ goto return_label;
+ }
+ (handle.pointer) ++;
+ while (handle.pointer < handle.end - 1) {
+ int tmp_6;
+ if ((int)*(handle.pointer + 0) >= (int)((unsigned char)'0')) {
+ if (! ((int)*(handle.pointer + 0) <= (int)((unsigned char)'9')))
+ goto _LAND_1;
+ }
+ else {
+ _LAND_1: ;
+ if ((int)*(handle.pointer + 0) >= (int)((unsigned char)'A')) {
+ if (! ((int)*(handle.pointer + 0) <= (int)((unsigned char)'Z')))
+ goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(handle.pointer + 0) >= (int)((unsigned char)'a')) {
+ if (! ((int)*(handle.pointer + 0) <= (int)((unsigned char)'z')))
+ goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (! ((int)*(handle.pointer + 0) == '_'))
+ if (! ((int)*(handle.pointer + 0) == '-')) {
+ int tmp_2;
+ tmp_2 = yaml_emitter_set_emitter_error(emitter,
+ "tag handle must contain alphanumerical characters only");
+ __retres = tmp_2;
+ goto return_label;
+ }
+ }
+ }
+ }
+ if (((int)*(handle.pointer + 0) & 0x80) == 0x00) tmp_6 = 1;
+ else {
+ int tmp_5;
+ if (((int)*(handle.pointer + 0) & 0xE0) == 0xC0) tmp_5 = 2;
+ else {
+ int tmp_4;
+ if (((int)*(handle.pointer + 0) & 0xF0) == 0xE0) tmp_4 = 3;
+ else {
+ int tmp_3;
+ if (((int)*(handle.pointer + 0) & 0xF8) == 0xF0) tmp_3 = 4;
+ else tmp_3 = 0;
+ tmp_4 = tmp_3;
+ }
+ tmp_5 = tmp_4;
+ }
+ tmp_6 = tmp_5;
+ }
+ handle.pointer += tmp_6;
+ }
+ if (prefix.start == prefix.end) {
+ int tmp_7;
+ tmp_7 = yaml_emitter_set_emitter_error(emitter,
+ "tag prefix must not be empty");
+ __retres = tmp_7;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_analyze_anchor(yaml_emitter_t *emitter,
+ yaml_char_t *anchor, int alias)
+{
+ int __retres;
+ size_t anchor_length;
+ yaml_string_t string;
+ anchor_length = strlen((char const *)anchor);
+ string.start = anchor;
+ string.end = anchor + anchor_length;
+ string.pointer = anchor;
+ if (string.start == string.end) {
+ int tmp_0;
+ char const *tmp;
+ if (alias) tmp = "alias value must not be empty";
+ else tmp = "anchor value must not be empty";
+ ;
+ tmp_0 = yaml_emitter_set_emitter_error(emitter,tmp);
+ __retres = tmp_0;
+ goto return_label;
+ }
+ while (string.pointer != string.end) {
+ int tmp_6;
+ if ((int)*(string.pointer + 0) >= (int)((unsigned char)'0')) {
+ if (! ((int)*(string.pointer + 0) <= (int)((unsigned char)'9')))
+ goto _LAND_1;
+ }
+ else {
+ _LAND_1: ;
+ if ((int)*(string.pointer + 0) >= (int)((unsigned char)'A')) {
+ if (! ((int)*(string.pointer + 0) <= (int)((unsigned char)'Z')))
+ goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(string.pointer + 0) >= (int)((unsigned char)'a')) {
+ if (! ((int)*(string.pointer + 0) <= (int)((unsigned char)'z')))
+ goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (! ((int)*(string.pointer + 0) == '_'))
+ if (! ((int)*(string.pointer + 0) == '-')) {
+ int tmp_2;
+ char const *tmp_1;
+ if (alias) tmp_1 = "alias value must contain alphanumerical characters only";
+ else tmp_1 = "anchor value must contain alphanumerical characters only";
+ ;
+ tmp_2 = yaml_emitter_set_emitter_error(emitter,tmp_1);
+ __retres = tmp_2;
+ goto return_label;
+ }
+ }
+ }
+ }
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_6 = 1;
+ else {
+ int tmp_5;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_5 = 2;
+ else {
+ int tmp_4;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_4 = 3;
+ else {
+ int tmp_3;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0) tmp_3 = 4;
+ else tmp_3 = 0;
+ tmp_4 = tmp_3;
+ }
+ tmp_5 = tmp_4;
+ }
+ tmp_6 = tmp_5;
+ }
+ string.pointer += tmp_6;
+ }
+ emitter->anchor_data.anchor = string.start;
+ emitter->anchor_data.anchor_length = (unsigned long)(string.end - string.start);
+ emitter->anchor_data.alias = alias;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_analyze_tag(yaml_emitter_t *emitter, yaml_char_t *tag)
+{
+ int __retres;
+ size_t tag_length;
+ yaml_string_t string;
+ yaml_tag_directive_t *tag_directive;
+ tag_length = strlen((char const *)tag);
+ string.start = tag;
+ string.end = tag + tag_length;
+ string.pointer = tag;
+ if (string.start == string.end) {
+ int tmp;
+ tmp = yaml_emitter_set_emitter_error(emitter,
+ "tag value must not be empty");
+ __retres = tmp;
+ goto return_label;
+ }
+ tag_directive = emitter->tag_directives.start;
+ while (tag_directive != emitter->tag_directives.top) {
+ {
+ size_t prefix_length = strlen((char const *)tag_directive->prefix);
+ if (prefix_length < (unsigned long)(string.end - string.start)) {
+ int tmp_1;
+ tmp_1 = strncmp((char const *)tag_directive->prefix,
+ (char const *)string.start,prefix_length);
+ if (tmp_1 == 0) {
+ emitter->tag_data.handle = tag_directive->handle;
+ emitter->tag_data.handle_length = strlen((char const *)tag_directive->handle);
+ emitter->tag_data.suffix = string.start + prefix_length;
+ emitter->tag_data.suffix_length = (size_t)(string.end - string.start) - prefix_length;
+ __retres = 1;
+ goto return_label;
+ }
+ }
+ }
+ tag_directive ++;
+ }
+ emitter->tag_data.suffix = string.start;
+ emitter->tag_data.suffix_length = (unsigned long)(string.end - string.start);
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_analyze_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length)
+{
+ int __retres;
+ yaml_string_t string;
+ int tmp_51;
+ int tmp_2;
+ int block_indicators = 0;
+ int flow_indicators = 0;
+ int line_breaks = 0;
+ int special_characters = 0;
+ int leading_space = 0;
+ int leading_break = 0;
+ int trailing_space = 0;
+ int trailing_break = 0;
+ int break_space = 0;
+ int space_break = 0;
+ int preceded_by_whitespace = 0;
+ int followed_by_whitespace = 0;
+ int previous_space = 0;
+ int previous_break = 0;
+ string.start = value;
+ string.end = value + length;
+ string.pointer = value;
+ emitter->scalar_data.value = value;
+ emitter->scalar_data.length = length;
+ if (string.start == string.end) {
+ emitter->scalar_data.multiline = 0;
+ emitter->scalar_data.flow_plain_allowed = 0;
+ emitter->scalar_data.block_plain_allowed = 1;
+ emitter->scalar_data.single_quoted_allowed = 1;
+ emitter->scalar_data.block_allowed = 0;
+ __retres = 1;
+ goto return_label;
+ }
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'-')) {
+ if ((int)*(string.pointer + 1) == (int)((unsigned char)'-')) {
+ if ((int)*(string.pointer + 2) == (int)((unsigned char)'-')) goto _LOR;
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'.'))
+ if ((int)*(string.pointer + 1) == (int)((unsigned char)'.'))
+ if ((int)*(string.pointer + 2) == (int)((unsigned char)'.')) {
+ _LOR: {
+ block_indicators = 1;
+ flow_indicators = 1;
+ }
+ }
+ }
+ preceded_by_whitespace = 1;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_2 = 1;
+ else {
+ int tmp_1;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_1 = 2;
+ else {
+ int tmp_0;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_0 = 3;
+ else {
+ int tmp;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0) tmp = 4;
+ else tmp = 0;
+ tmp_0 = tmp;
+ }
+ tmp_1 = tmp_0;
+ }
+ tmp_2 = tmp_1;
+ }
+ ;
+ if ((int)*(string.pointer + tmp_2) == (int)((unsigned char)' ')) tmp_51 = 1;
+ else {
+ int tmp_6;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_6 = 1;
+ else {
+ int tmp_5;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_5 = 2;
+ else {
+ int tmp_4;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_4 = 3;
+ else {
+ int tmp_3;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0) tmp_3 = 4;
+ else tmp_3 = 0;
+ tmp_4 = tmp_3;
+ }
+ tmp_5 = tmp_4;
+ }
+ tmp_6 = tmp_5;
+ }
+ ;
+ if ((int)*(string.pointer + tmp_6) == (int)((unsigned char)'\t'))
+ tmp_51 = 1;
+ else {
+ int tmp_10;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_10 = 1;
+ else {
+ int tmp_9;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_9 = 2;
+ else {
+ int tmp_8;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_8 = 3;
+ else {
+ int tmp_7;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0) tmp_7 = 4;
+ else tmp_7 = 0;
+ tmp_8 = tmp_7;
+ }
+ tmp_9 = tmp_8;
+ }
+ tmp_10 = tmp_9;
+ }
+ ;
+ if ((int)*(string.pointer + tmp_10) == (int)((unsigned char)'\r'))
+ tmp_51 = 1;
+ else {
+ int tmp_14;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_14 = 1;
+ else {
+ int tmp_13;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_13 = 2;
+ else {
+ int tmp_12;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_12 = 3;
+ else {
+ int tmp_11;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0) tmp_11 = 4;
+ else tmp_11 = 0;
+ tmp_12 = tmp_11;
+ }
+ tmp_13 = tmp_12;
+ }
+ tmp_14 = tmp_13;
+ }
+ ;
+ if ((int)*(string.pointer + tmp_14) == (int)((unsigned char)'\n'))
+ tmp_51 = 1;
+ else {
+ int tmp_18;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_18 = 1;
+ else {
+ int tmp_17;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_17 = 2;
+ else {
+ int tmp_16;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_16 = 3;
+ else {
+ int tmp_15;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0) tmp_15 = 4;
+ else tmp_15 = 0;
+ tmp_16 = tmp_15;
+ }
+ tmp_17 = tmp_16;
+ }
+ tmp_18 = tmp_17;
+ }
+ ;
+ if ((int)*(string.pointer + tmp_18) == (int)((unsigned char)'\302')) {
+ int tmp_22;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_22 = 1;
+ else {
+ int tmp_21;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_21 = 2;
+ else {
+ int tmp_20;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_20 = 3;
+ else {
+ int tmp_19;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0) tmp_19 = 4;
+ else tmp_19 = 0;
+ tmp_20 = tmp_19;
+ }
+ tmp_21 = tmp_20;
+ }
+ tmp_22 = tmp_21;
+ }
+ ;
+ if ((int)*(string.pointer + (tmp_22 + 1)) == (int)((unsigned char)'\205'))
+ tmp_51 = 1;
+ else goto _LAND_5;
+ }
+ else {
+ int tmp_26;
+ _LAND_5:
+ { /* sequence */
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_26 = 1;
+ else {
+ int tmp_25;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_25 = 2;
+ else {
+ int tmp_24;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_24 = 3;
+ else {
+ int tmp_23;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_23 = 4;
+ else tmp_23 = 0;
+ tmp_24 = tmp_23;
+ }
+ tmp_25 = tmp_24;
+ }
+ tmp_26 = tmp_25;
+ }
+ ;
+ }
+ if ((int)*(string.pointer + tmp_26) == (int)((unsigned char)'\342')) {
+ int tmp_30;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_30 = 1;
+ else {
+ int tmp_29;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_29 = 2;
+ else {
+ int tmp_28;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_28 = 3;
+ else {
+ int tmp_27;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_27 = 4;
+ else tmp_27 = 0;
+ tmp_28 = tmp_27;
+ }
+ tmp_29 = tmp_28;
+ }
+ tmp_30 = tmp_29;
+ }
+ ;
+ if ((int)*(string.pointer + (tmp_30 + 1)) == (int)((unsigned char)'\200')) {
+ int tmp_34;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_34 = 1;
+ else {
+ int tmp_33;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_33 = 2;
+ else {
+ int tmp_32;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_32 = 3;
+ else {
+ int tmp_31;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_31 = 4;
+ else tmp_31 = 0;
+ tmp_32 = tmp_31;
+ }
+ tmp_33 = tmp_32;
+ }
+ tmp_34 = tmp_33;
+ }
+ ;
+ if ((int)*(string.pointer + (tmp_34 + 2)) == (int)((unsigned char)'\250'))
+ tmp_51 = 1;
+ else goto _LAND_4;
+ }
+ else goto _LAND_4;
+ }
+ else {
+ int tmp_38;
+ _LAND_4:
+ { /* sequence */
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_38 = 1;
+ else {
+ int tmp_37;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_37 = 2;
+ else {
+ int tmp_36;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_36 = 3;
+ else {
+ int tmp_35;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_35 = 4;
+ else tmp_35 = 0;
+ tmp_36 = tmp_35;
+ }
+ tmp_37 = tmp_36;
+ }
+ tmp_38 = tmp_37;
+ }
+ ;
+ }
+ if ((int)*(string.pointer + tmp_38) == (int)((unsigned char)'\342')) {
+ int tmp_42;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_42 = 1;
+ else {
+ int tmp_41;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_41 = 2;
+ else {
+ int tmp_40;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_40 = 3;
+ else {
+ int tmp_39;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_39 = 4;
+ else tmp_39 = 0;
+ tmp_40 = tmp_39;
+ }
+ tmp_41 = tmp_40;
+ }
+ tmp_42 = tmp_41;
+ }
+ ;
+ if ((int)*(string.pointer + (tmp_42 + 1)) == (int)((unsigned char)'\200')) {
+ int tmp_46;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_46 = 1;
+ else {
+ int tmp_45;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_45 = 2;
+ else {
+ int tmp_44;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_44 = 3;
+ else {
+ int tmp_43;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_43 = 4;
+ else tmp_43 = 0;
+ tmp_44 = tmp_43;
+ }
+ tmp_45 = tmp_44;
+ }
+ tmp_46 = tmp_45;
+ }
+ ;
+ if ((int)*(string.pointer + (tmp_46 + 2)) == (int)((unsigned char)'\251'))
+ tmp_51 = 1;
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ int tmp_50;
+ _LAND_2:
+ { /* sequence */
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_50 = 1;
+ else {
+ int tmp_49;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_49 = 2;
+ else {
+ int tmp_48;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_48 = 3;
+ else {
+ int tmp_47;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_47 = 4;
+ else tmp_47 = 0;
+ tmp_48 = tmp_47;
+ }
+ tmp_49 = tmp_48;
+ }
+ tmp_50 = tmp_49;
+ }
+ ;
+ }
+ if ((int)*(string.pointer + tmp_50) == (int)((unsigned char)'\000'))
+ tmp_51 = 1;
+ else tmp_51 = 0;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ followed_by_whitespace = tmp_51;
+ while (string.pointer != string.end) {
+ int tmp_60;
+ int tmp_64;
+ if (string.start == string.pointer) {
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'#')) goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)','))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'['))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)']'))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'{'))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'}'))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'&'))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'*'))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'!'))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'|'))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'>'))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\''))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\"'))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'%'))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'@'))
+ goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'`')) {
+ _LOR_0:
+ {
+ flow_indicators = 1;
+ block_indicators = 1;
+ }
+ }
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'?')) goto _LOR_1;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)':')) {
+ _LOR_1:
+ {
+ flow_indicators = 1;
+ if (followed_by_whitespace) block_indicators = 1;
+ }
+ }
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'-'))
+ if (followed_by_whitespace) {
+ flow_indicators = 1;
+ block_indicators = 1;
+ }
+ }
+ else {
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)',')) goto _LOR_2;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'?'))
+ goto _LOR_2;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'['))
+ goto _LOR_2;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)']'))
+ goto _LOR_2;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'{'))
+ goto _LOR_2;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'}'))
+ _LOR_2:
+ flow_indicators = 1;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)':')) {
+ flow_indicators = 1;
+ if (followed_by_whitespace) block_indicators = 1;
+ }
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'#'))
+ if (preceded_by_whitespace) {
+ flow_indicators = 1;
+ block_indicators = 1;
+ }
+ }
+ if ((int)*(string.pointer + 0) == 0x0A) goto _LAND_6;
+ else
+ if ((int)*(string.pointer + 0) >= 0x20) {
+ if ((int)*(string.pointer + 0) <= 0x7E) goto _LAND_6;
+ else goto _LAND_11;
+ }
+ else {
+ _LAND_11: ;
+ if ((int)*(string.pointer + 0) == 0xC2) {
+ if ((int)*(string.pointer + (0 + 1)) >= 0xA0) goto _LAND_6;
+ else goto _LAND_10;
+ }
+ else {
+ _LAND_10: ;
+ if ((int)*(string.pointer + 0) > 0xC2) {
+ if ((int)*(string.pointer + 0) < 0xED) goto _LAND_6;
+ else goto _LAND_9;
+ }
+ else {
+ _LAND_9: ;
+ if ((int)*(string.pointer + 0) == 0xED) {
+ if ((int)*(string.pointer + (0 + 1)) < 0xA0) goto _LAND_6;
+ else goto _LAND_8;
+ }
+ else {
+ _LAND_8: ;
+ if ((int)*(string.pointer + 0) == 0xEE) goto _LAND_6;
+ else
+ if ((int)*(string.pointer + 0) == 0xEF)
+ if ((int)*(string.pointer + (0 + 1)) == 0xBB) {
+ if ((int)*(string.pointer + (0 + 2)) == 0xBF) goto _LOR_3;
+ else goto _LAND_7;
+ }
+ else {
+ _LAND_7: ;
+ if ((int)*(string.pointer + (0 + 1)) == 0xBF) {
+ if ((int)*(string.pointer + (0 + 2)) == 0xBE) goto _LOR_3;
+ else
+ if ((int)*(string.pointer + (0 + 2)) == 0xBF)
+ goto _LOR_3;
+ else goto _LAND_6;
+ }
+ else
+ _LAND_6:
+ if (! ((int)*(string.pointer + 0) <= (int)((unsigned char)'\177')))
+ if (! emitter->unicode) _LOR_3:
+ special_characters = 1;
+ }
+ else goto _LOR_3;
+ }
+ }
+ }
+ }
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\r')) goto _LOR_5;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n')) goto _LOR_5;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_5;
+ else goto _LAND_14;
+ }
+ else {
+ _LAND_14: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_5;
+ else goto _LAND_13;
+ }
+ else goto _LAND_13;
+ }
+ else {
+ _LAND_13: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200'))
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\251'))
+ _LOR_5:
+ line_breaks = 1;
+ }
+ }
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)' ')) {
+ int tmp_55;
+ if (string.start == string.pointer) leading_space = 1;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_55 = 1;
+ else {
+ int tmp_54;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_54 = 2;
+ else {
+ int tmp_53;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_53 = 3;
+ else {
+ int tmp_52;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0) tmp_52 = 4;
+ else tmp_52 = 0;
+ tmp_53 = tmp_52;
+ }
+ tmp_54 = tmp_53;
+ }
+ tmp_55 = tmp_54;
+ }
+ ;
+ if (string.pointer + tmp_55 == string.end) trailing_space = 1;
+ if (previous_break) break_space = 1;
+ previous_space = 1;
+ previous_break = 0;
+ }
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\r')) goto _LOR_6;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n'))
+ goto _LOR_6;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_6;
+ else goto _LAND_19;
+ }
+ else {
+ _LAND_19: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_6;
+ else goto _LAND_18;
+ }
+ else goto _LAND_18;
+ }
+ else {
+ _LAND_18: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\251')) {
+ _LOR_6:
+ {
+ int tmp_59;
+ if (string.start == string.pointer) leading_break = 1;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00)
+ tmp_59 = 1;
+ else {
+ int tmp_58;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_58 = 2;
+ else {
+ int tmp_57;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_57 = 3;
+ else {
+ int tmp_56;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_56 = 4;
+ else tmp_56 = 0;
+ tmp_57 = tmp_56;
+ }
+ tmp_58 = tmp_57;
+ }
+ tmp_59 = tmp_58;
+ }
+ ;
+ if (string.pointer + tmp_59 == string.end) trailing_break = 1;
+ if (previous_space) space_break = 1;
+ previous_space = 0;
+ previous_break = 1;
+ }
+ }
+ else goto _LAND_16;
+ }
+ else goto _LAND_16;
+ }
+ else {
+ _LAND_16: {
+ previous_space = 0;
+ previous_break = 0;
+ }
+ }
+ }
+ }
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)' ')) tmp_60 = 1;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\t')) tmp_60 = 1;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\r'))
+ tmp_60 = 1;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n'))
+ tmp_60 = 1;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ tmp_60 = 1;
+ else goto _LAND_24;
+ }
+ else {
+ _LAND_24: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ tmp_60 = 1;
+ else goto _LAND_23;
+ }
+ else goto _LAND_23;
+ }
+ else {
+ _LAND_23: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\251'))
+ tmp_60 = 1;
+ else goto _LAND_21;
+ }
+ else goto _LAND_21;
+ }
+ else {
+ _LAND_21: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\000'))
+ tmp_60 = 1;
+ else tmp_60 = 0;
+ }
+ }
+ }
+ preceded_by_whitespace = tmp_60;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_64 = 1;
+ else {
+ int tmp_63;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_63 = 2;
+ else {
+ int tmp_62;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_62 = 3;
+ else {
+ int tmp_61;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0) tmp_61 = 4;
+ else tmp_61 = 0;
+ tmp_62 = tmp_61;
+ }
+ tmp_63 = tmp_62;
+ }
+ tmp_64 = tmp_63;
+ }
+ string.pointer += tmp_64;
+ if (string.pointer != string.end) {
+ int tmp_117;
+ int tmp_68;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_68 = 1;
+ else {
+ int tmp_67;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_67 = 2;
+ else {
+ int tmp_66;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_66 = 3;
+ else {
+ int tmp_65;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0) tmp_65 = 4;
+ else tmp_65 = 0;
+ tmp_66 = tmp_65;
+ }
+ tmp_67 = tmp_66;
+ }
+ tmp_68 = tmp_67;
+ }
+ ;
+ if ((int)*(string.pointer + tmp_68) == (int)((unsigned char)' '))
+ tmp_117 = 1;
+ else {
+ int tmp_72;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_72 = 1;
+ else {
+ int tmp_71;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_71 = 2;
+ else {
+ int tmp_70;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_70 = 3;
+ else {
+ int tmp_69;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0) tmp_69 = 4;
+ else tmp_69 = 0;
+ tmp_70 = tmp_69;
+ }
+ tmp_71 = tmp_70;
+ }
+ tmp_72 = tmp_71;
+ }
+ ;
+ if ((int)*(string.pointer + tmp_72) == (int)((unsigned char)'\t'))
+ tmp_117 = 1;
+ else {
+ int tmp_76;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_76 = 1;
+ else {
+ int tmp_75;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_75 = 2;
+ else {
+ int tmp_74;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_74 = 3;
+ else {
+ int tmp_73;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0) tmp_73 = 4;
+ else tmp_73 = 0;
+ tmp_74 = tmp_73;
+ }
+ tmp_75 = tmp_74;
+ }
+ tmp_76 = tmp_75;
+ }
+ ;
+ if ((int)*(string.pointer + tmp_76) == (int)((unsigned char)'\r'))
+ tmp_117 = 1;
+ else {
+ int tmp_80;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_80 = 1;
+ else {
+ int tmp_79;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_79 = 2;
+ else {
+ int tmp_78;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_78 = 3;
+ else {
+ int tmp_77;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0) tmp_77 = 4;
+ else tmp_77 = 0;
+ tmp_78 = tmp_77;
+ }
+ tmp_79 = tmp_78;
+ }
+ tmp_80 = tmp_79;
+ }
+ ;
+ if ((int)*(string.pointer + tmp_80) == (int)((unsigned char)'\n'))
+ tmp_117 = 1;
+ else {
+ int tmp_84;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_84 = 1;
+ else {
+ int tmp_83;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_83 = 2;
+ else {
+ int tmp_82;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_82 = 3;
+ else {
+ int tmp_81;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_81 = 4;
+ else tmp_81 = 0;
+ tmp_82 = tmp_81;
+ }
+ tmp_83 = tmp_82;
+ }
+ tmp_84 = tmp_83;
+ }
+ ;
+ if ((int)*(string.pointer + tmp_84) == (int)((unsigned char)'\302')) {
+ int tmp_88;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_88 = 1;
+ else {
+ int tmp_87;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_87 = 2;
+ else {
+ int tmp_86;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_86 = 3;
+ else {
+ int tmp_85;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_85 = 4;
+ else tmp_85 = 0;
+ tmp_86 = tmp_85;
+ }
+ tmp_87 = tmp_86;
+ }
+ tmp_88 = tmp_87;
+ }
+ ;
+ if ((int)*(string.pointer + (tmp_88 + 1)) == (int)((unsigned char)'\205'))
+ tmp_117 = 1;
+ else goto _LAND_29;
+ }
+ else {
+ int tmp_92;
+ _LAND_29:
+ { /* sequence */
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_92 = 1;
+ else {
+ int tmp_91;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_91 = 2;
+ else {
+ int tmp_90;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_90 = 3;
+ else {
+ int tmp_89;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_89 = 4;
+ else tmp_89 = 0;
+ tmp_90 = tmp_89;
+ }
+ tmp_91 = tmp_90;
+ }
+ tmp_92 = tmp_91;
+ }
+ ;
+ }
+ if ((int)*(string.pointer + tmp_92) == (int)((unsigned char)'\342')) {
+ int tmp_96;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_96 = 1;
+ else {
+ int tmp_95;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_95 = 2;
+ else {
+ int tmp_94;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_94 = 3;
+ else {
+ int tmp_93;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_93 = 4;
+ else tmp_93 = 0;
+ tmp_94 = tmp_93;
+ }
+ tmp_95 = tmp_94;
+ }
+ tmp_96 = tmp_95;
+ }
+ ;
+ if ((int)*(string.pointer + (tmp_96 + 1)) == (int)((unsigned char)'\200')) {
+ int tmp_100;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00)
+ tmp_100 = 1;
+ else {
+ int tmp_99;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_99 = 2;
+ else {
+ int tmp_98;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_98 = 3;
+ else {
+ int tmp_97;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_97 = 4;
+ else tmp_97 = 0;
+ tmp_98 = tmp_97;
+ }
+ tmp_99 = tmp_98;
+ }
+ tmp_100 = tmp_99;
+ }
+ ;
+ if ((int)*(string.pointer + (tmp_100 + 2)) == (int)((unsigned char)'\250'))
+ tmp_117 = 1;
+ else goto _LAND_28;
+ }
+ else goto _LAND_28;
+ }
+ else {
+ int tmp_104;
+ _LAND_28:
+ { /* sequence */
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00)
+ tmp_104 = 1;
+ else {
+ int tmp_103;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_103 = 2;
+ else {
+ int tmp_102;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_102 = 3;
+ else {
+ int tmp_101;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_101 = 4;
+ else tmp_101 = 0;
+ tmp_102 = tmp_101;
+ }
+ tmp_103 = tmp_102;
+ }
+ tmp_104 = tmp_103;
+ }
+ ;
+ }
+ if ((int)*(string.pointer + tmp_104) == (int)((unsigned char)'\342')) {
+ int tmp_108;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00)
+ tmp_108 = 1;
+ else {
+ int tmp_107;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_107 = 2;
+ else {
+ int tmp_106;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_106 = 3;
+ else {
+ int tmp_105;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_105 = 4;
+ else tmp_105 = 0;
+ tmp_106 = tmp_105;
+ }
+ tmp_107 = tmp_106;
+ }
+ tmp_108 = tmp_107;
+ }
+ ;
+ if ((int)*(string.pointer + (tmp_108 + 1)) == (int)((unsigned char)'\200')) {
+ int tmp_112;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00)
+ tmp_112 = 1;
+ else {
+ int tmp_111;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_111 = 2;
+ else {
+ int tmp_110;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_110 = 3;
+ else {
+ int tmp_109;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_109 = 4;
+ else tmp_109 = 0;
+ tmp_110 = tmp_109;
+ }
+ tmp_111 = tmp_110;
+ }
+ tmp_112 = tmp_111;
+ }
+ ;
+ if ((int)*(string.pointer + (tmp_112 + 2)) == (int)((unsigned char)'\251'))
+ tmp_117 = 1;
+ else goto _LAND_26;
+ }
+ else goto _LAND_26;
+ }
+ else {
+ int tmp_116;
+ _LAND_26:
+ { /* sequence */
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00)
+ tmp_116 = 1;
+ else {
+ int tmp_115;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_115 = 2;
+ else {
+ int tmp_114;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_114 = 3;
+ else {
+ int tmp_113;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_113 = 4;
+ else tmp_113 = 0;
+ tmp_114 = tmp_113;
+ }
+ tmp_115 = tmp_114;
+ }
+ tmp_116 = tmp_115;
+ }
+ ;
+ }
+ if ((int)*(string.pointer + tmp_116) == (int)((unsigned char)'\000'))
+ tmp_117 = 1;
+ else tmp_117 = 0;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ followed_by_whitespace = tmp_117;
+ }
+ }
+ emitter->scalar_data.multiline = line_breaks;
+ emitter->scalar_data.flow_plain_allowed = 1;
+ emitter->scalar_data.block_plain_allowed = 1;
+ emitter->scalar_data.single_quoted_allowed = 1;
+ emitter->scalar_data.block_allowed = 1;
+ if (leading_space) goto _LOR_7;
+ else
+ if (leading_break) goto _LOR_7;
+ else
+ if (trailing_space) goto _LOR_7;
+ else
+ if (trailing_break) {
+ _LOR_7:
+ {
+ emitter->scalar_data.flow_plain_allowed = 0;
+ emitter->scalar_data.block_plain_allowed = 0;
+ }
+ }
+ if (trailing_space) emitter->scalar_data.block_allowed = 0;
+ if (break_space) {
+ emitter->scalar_data.flow_plain_allowed = 0;
+ emitter->scalar_data.block_plain_allowed = 0;
+ emitter->scalar_data.single_quoted_allowed = 0;
+ }
+ if (space_break) goto _LOR_8;
+ else
+ if (special_characters) {
+ _LOR_8:
+ {
+ emitter->scalar_data.flow_plain_allowed = 0;
+ emitter->scalar_data.block_plain_allowed = 0;
+ emitter->scalar_data.single_quoted_allowed = 0;
+ emitter->scalar_data.block_allowed = 0;
+ }
+ }
+ if (line_breaks) {
+ emitter->scalar_data.flow_plain_allowed = 0;
+ emitter->scalar_data.block_plain_allowed = 0;
+ }
+ if (flow_indicators) emitter->scalar_data.flow_plain_allowed = 0;
+ if (block_indicators) emitter->scalar_data.block_plain_allowed = 0;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_analyze_event(yaml_emitter_t *emitter,
+ yaml_event_t *event)
+{
+ int __retres;
+ emitter->anchor_data.anchor = (yaml_char_t *)0;
+ emitter->anchor_data.anchor_length = (unsigned long)0;
+ emitter->tag_data.handle = (yaml_char_t *)0;
+ emitter->tag_data.handle_length = (unsigned long)0;
+ emitter->tag_data.suffix = (yaml_char_t *)0;
+ emitter->tag_data.suffix_length = (unsigned long)0;
+ emitter->scalar_data.value = (yaml_char_t *)0;
+ emitter->scalar_data.length = (unsigned long)0;
+ switch (event->type) {
+ int tmp;
+ int tmp_2;
+ case (yaml_event_type_t)YAML_ALIAS_EVENT:
+ tmp = yaml_emitter_analyze_anchor(emitter,event->data.alias.anchor,1);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ goto return_label;
+ case (yaml_event_type_t)YAML_SCALAR_EVENT: ;
+ if (event->data.scalar.anchor) {
+ int tmp_0;
+ tmp_0 = yaml_emitter_analyze_anchor(emitter,event->data.scalar.anchor,
+ 0);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (event->data.scalar.tag)
+ if (emitter->canonical) goto _LOR;
+ else
+ if (! event->data.scalar.plain_implicit)
+ if (! event->data.scalar.quoted_implicit) {
+ _LOR:
+ {
+ int tmp_1;
+ tmp_1 = yaml_emitter_analyze_tag(emitter,
+ event->data.scalar.tag);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ tmp_2 = yaml_emitter_analyze_scalar(emitter,event->data.scalar.value,
+ event->data.scalar.length);
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ goto return_label;
+ case (yaml_event_type_t)YAML_SEQUENCE_START_EVENT: ;
+ if (event->data.sequence_start.anchor) {
+ int tmp_3;
+ tmp_3 = yaml_emitter_analyze_anchor(emitter,
+ event->data.sequence_start.anchor,
+ 0);
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (event->data.sequence_start.tag)
+ if (emitter->canonical) goto _LOR_0;
+ else
+ if (! event->data.sequence_start.implicit) {
+ _LOR_0:
+ {
+ int tmp_4;
+ tmp_4 = yaml_emitter_analyze_tag(emitter,
+ event->data.sequence_start.tag);
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ __retres = 1;
+ goto return_label;
+ case (yaml_event_type_t)YAML_MAPPING_START_EVENT: ;
+ if (event->data.mapping_start.anchor) {
+ int tmp_5;
+ tmp_5 = yaml_emitter_analyze_anchor(emitter,
+ event->data.mapping_start.anchor,0);
+ if (! tmp_5) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (event->data.mapping_start.tag)
+ if (emitter->canonical) goto _LOR_1;
+ else
+ if (! event->data.mapping_start.implicit) {
+ _LOR_1:
+ {
+ int tmp_6;
+ tmp_6 = yaml_emitter_analyze_tag(emitter,
+ event->data.mapping_start.tag);
+ if (! tmp_6) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ __retres = 1;
+ goto return_label;
+ default: __retres = 1;
+ goto return_label;
+ }
+ return_label: return __retres;
+}
+
+static int yaml_emitter_write_bom(yaml_emitter_t *emitter)
+{
+ int __retres;
+ yaml_char_t *tmp_0;
+ yaml_char_t *tmp_1;
+ yaml_char_t *tmp_2;
+ if (! (emitter->buffer.pointer + 5 < emitter->buffer.end)) {
+ int tmp;
+ tmp = yaml_emitter_flush(emitter);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ tmp_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_0 = (unsigned char)'\357';
+ tmp_1 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_1 = (unsigned char)'\273';
+ tmp_2 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_2 = (unsigned char)'\277';
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_write_indent(yaml_emitter_t *emitter)
+{
+ int __retres;
+ int tmp;
+ if (emitter->indent >= 0) tmp = emitter->indent; else tmp = 0;
+ int indent = tmp;
+ if (! emitter->indention) goto _LOR_0;
+ else
+ if (emitter->column > indent) goto _LOR_0;
+ else
+ if (emitter->column == indent)
+ if (! emitter->whitespace)
+ _LOR_0:
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR;
+ else {
+ int tmp_0;
+ tmp_0 = yaml_emitter_flush(emitter);
+ if (tmp_0) {
+ _LOR: ;
+ if (emitter->line_break == (unsigned int)YAML_CR_BREAK) {
+ yaml_char_t *tmp_1;
+ tmp_1 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_1 = (unsigned char)'\r';
+ yaml_char_t tmp_9 = *tmp_1;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_LN_BREAK) {
+ yaml_char_t *tmp_2;
+ tmp_2 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_2 = (unsigned char)'\n';
+ yaml_char_t tmp_7 = *tmp_2;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_CRLN_BREAK) {
+ yaml_char_t *tmp_3;
+ yaml_char_t *tmp_4;
+ tmp_3 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_3 = (unsigned char)'\r';
+ tmp_4 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_4 = (unsigned char)'\n';
+ yaml_char_t tmp_5 = *tmp_4;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ while (emitter->column < indent)
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR_1;
+ else {
+ int tmp_5_0;
+ tmp_5_0 = yaml_emitter_flush(emitter);
+ if (tmp_5_0) {
+ yaml_char_t *tmp_6;
+ _LOR_1:
+ { /* sequence */
+ tmp_6 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_6 = (unsigned char)' ';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->whitespace = 1;
+ emitter->indention = 1;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_write_indicator(yaml_emitter_t *emitter,
+ char const *indicator,
+ int need_whitespace,
+ int is_whitespace, int is_indention)
+{
+ int __retres;
+ size_t indicator_length;
+ yaml_string_t string;
+ int tmp_22_0;
+ indicator_length = strlen(indicator);
+ string.start = (yaml_char_t *)indicator;
+ string.end = (yaml_char_t *)indicator + indicator_length;
+ string.pointer = (yaml_char_t *)indicator;
+ if (need_whitespace)
+ if (! emitter->whitespace)
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR;
+ else {
+ int tmp;
+ tmp = yaml_emitter_flush(emitter);
+ if (tmp) {
+ yaml_char_t *tmp_0;
+ _LOR:
+ { /* sequence */
+ tmp_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_0 = (unsigned char)' ';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ while (string.pointer != string.end)
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR_0;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_emitter_flush(emitter);
+ if (tmp_1) {
+ _LOR_0: ;
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_2;
+ yaml_char_t *tmp_3;
+ tmp_2 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_3 = string.pointer;
+ (string.pointer) ++;
+ *tmp_2 = *tmp_3;
+ yaml_char_t tmp_28 = *tmp_2;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_4;
+ yaml_char_t *tmp_5;
+ yaml_char_t *tmp_6;
+ yaml_char_t *tmp_7;
+ tmp_4 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_5 = string.pointer;
+ (string.pointer) ++;
+ *tmp_4 = *tmp_5;
+ tmp_6 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_7 = string.pointer;
+ (string.pointer) ++;
+ *tmp_6 = *tmp_7;
+ yaml_char_t tmp_26 = *tmp_6;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_8;
+ yaml_char_t *tmp_9;
+ yaml_char_t *tmp_10;
+ yaml_char_t *tmp_11;
+ yaml_char_t *tmp_12;
+ yaml_char_t *tmp_13;
+ tmp_8 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_9 = string.pointer;
+ (string.pointer) ++;
+ *tmp_8 = *tmp_9;
+ tmp_10 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_11 = string.pointer;
+ (string.pointer) ++;
+ *tmp_10 = *tmp_11;
+ tmp_12 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_13 = string.pointer;
+ (string.pointer) ++;
+ *tmp_12 = *tmp_13;
+ yaml_char_t tmp_24 = *tmp_12;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_14;
+ yaml_char_t *tmp_15;
+ yaml_char_t *tmp_16;
+ yaml_char_t *tmp_17;
+ yaml_char_t *tmp_18;
+ yaml_char_t *tmp_19;
+ yaml_char_t *tmp_20;
+ yaml_char_t *tmp_21;
+ tmp_14 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_15 = string.pointer;
+ (string.pointer) ++;
+ *tmp_14 = *tmp_15;
+ tmp_16 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_17 = string.pointer;
+ (string.pointer) ++;
+ *tmp_16 = *tmp_17;
+ tmp_18 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_19 = string.pointer;
+ (string.pointer) ++;
+ *tmp_18 = *tmp_19;
+ tmp_20 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_21 = string.pointer;
+ (string.pointer) ++;
+ *tmp_20 = *tmp_21;
+ yaml_char_t tmp_22 = *tmp_20;
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->whitespace = is_whitespace;
+ if (emitter->indention)
+ if (is_indention) tmp_22_0 = 1; else tmp_22_0 = 0;
+ else tmp_22_0 = 0;
+ emitter->indention = tmp_22_0;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_write_anchor(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length)
+{
+ int __retres;
+ yaml_string_t string;
+ string.start = value;
+ string.end = value + length;
+ string.pointer = value;
+ while (string.pointer != string.end)
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR;
+ else {
+ int tmp;
+ tmp = yaml_emitter_flush(emitter);
+ if (tmp) {
+ _LOR: ;
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_0;
+ yaml_char_t *tmp_1;
+ tmp_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_1 = string.pointer;
+ (string.pointer) ++;
+ *tmp_0 = *tmp_1;
+ yaml_char_t tmp_26 = *tmp_0;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_2;
+ yaml_char_t *tmp_3;
+ yaml_char_t *tmp_4;
+ yaml_char_t *tmp_5;
+ tmp_2 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_3 = string.pointer;
+ (string.pointer) ++;
+ *tmp_2 = *tmp_3;
+ tmp_4 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_5 = string.pointer;
+ (string.pointer) ++;
+ *tmp_4 = *tmp_5;
+ yaml_char_t tmp_24 = *tmp_4;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_6;
+ yaml_char_t *tmp_7;
+ yaml_char_t *tmp_8;
+ yaml_char_t *tmp_9;
+ yaml_char_t *tmp_10;
+ yaml_char_t *tmp_11;
+ tmp_6 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_7 = string.pointer;
+ (string.pointer) ++;
+ *tmp_6 = *tmp_7;
+ tmp_8 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_9 = string.pointer;
+ (string.pointer) ++;
+ *tmp_8 = *tmp_9;
+ tmp_10 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_11 = string.pointer;
+ (string.pointer) ++;
+ *tmp_10 = *tmp_11;
+ yaml_char_t tmp_22 = *tmp_10;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_12;
+ yaml_char_t *tmp_13;
+ yaml_char_t *tmp_14;
+ yaml_char_t *tmp_15;
+ yaml_char_t *tmp_16;
+ yaml_char_t *tmp_17;
+ yaml_char_t *tmp_18;
+ yaml_char_t *tmp_19;
+ tmp_12 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_13 = string.pointer;
+ (string.pointer) ++;
+ *tmp_12 = *tmp_13;
+ tmp_14 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_15 = string.pointer;
+ (string.pointer) ++;
+ *tmp_14 = *tmp_15;
+ tmp_16 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_17 = string.pointer;
+ (string.pointer) ++;
+ *tmp_16 = *tmp_17;
+ tmp_18 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_19 = string.pointer;
+ (string.pointer) ++;
+ *tmp_18 = *tmp_19;
+ yaml_char_t tmp_20 = *tmp_18;
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->whitespace = 0;
+ emitter->indention = 0;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_write_tag_handle(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length)
+{
+ int __retres;
+ yaml_string_t string;
+ string.start = value;
+ string.end = value + length;
+ string.pointer = value;
+ if (! emitter->whitespace)
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR;
+ else {
+ int tmp;
+ tmp = yaml_emitter_flush(emitter);
+ if (tmp) {
+ yaml_char_t *tmp_0;
+ _LOR:
+ { /* sequence */
+ tmp_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_0 = (unsigned char)' ';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ while (string.pointer != string.end)
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR_0;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_emitter_flush(emitter);
+ if (tmp_1) {
+ _LOR_0: ;
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_2;
+ yaml_char_t *tmp_3;
+ tmp_2 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_3 = string.pointer;
+ (string.pointer) ++;
+ *tmp_2 = *tmp_3;
+ yaml_char_t tmp_28 = *tmp_2;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_4;
+ yaml_char_t *tmp_5;
+ yaml_char_t *tmp_6;
+ yaml_char_t *tmp_7;
+ tmp_4 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_5 = string.pointer;
+ (string.pointer) ++;
+ *tmp_4 = *tmp_5;
+ tmp_6 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_7 = string.pointer;
+ (string.pointer) ++;
+ *tmp_6 = *tmp_7;
+ yaml_char_t tmp_26 = *tmp_6;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_8;
+ yaml_char_t *tmp_9;
+ yaml_char_t *tmp_10;
+ yaml_char_t *tmp_11;
+ yaml_char_t *tmp_12;
+ yaml_char_t *tmp_13;
+ tmp_8 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_9 = string.pointer;
+ (string.pointer) ++;
+ *tmp_8 = *tmp_9;
+ tmp_10 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_11 = string.pointer;
+ (string.pointer) ++;
+ *tmp_10 = *tmp_11;
+ tmp_12 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_13 = string.pointer;
+ (string.pointer) ++;
+ *tmp_12 = *tmp_13;
+ yaml_char_t tmp_24 = *tmp_12;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_14;
+ yaml_char_t *tmp_15;
+ yaml_char_t *tmp_16;
+ yaml_char_t *tmp_17;
+ yaml_char_t *tmp_18;
+ yaml_char_t *tmp_19;
+ yaml_char_t *tmp_20;
+ yaml_char_t *tmp_21;
+ tmp_14 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_15 = string.pointer;
+ (string.pointer) ++;
+ *tmp_14 = *tmp_15;
+ tmp_16 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_17 = string.pointer;
+ (string.pointer) ++;
+ *tmp_16 = *tmp_17;
+ tmp_18 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_19 = string.pointer;
+ (string.pointer) ++;
+ *tmp_18 = *tmp_19;
+ tmp_20 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_21 = string.pointer;
+ (string.pointer) ++;
+ *tmp_20 = *tmp_21;
+ yaml_char_t tmp_22 = *tmp_20;
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->whitespace = 0;
+ emitter->indention = 0;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_write_tag_content(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length,
+ int need_whitespace)
+{
+ int __retres;
+ yaml_string_t string;
+ string.start = value;
+ string.end = value + length;
+ string.pointer = value;
+ if (need_whitespace)
+ if (! emitter->whitespace)
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR;
+ else {
+ int tmp;
+ tmp = yaml_emitter_flush(emitter);
+ if (tmp) {
+ yaml_char_t *tmp_0;
+ _LOR:
+ { /* sequence */
+ tmp_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_0 = (unsigned char)' ';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ while (string.pointer != string.end)
+ if ((int)*(string.pointer + 0) >= (int)((unsigned char)'0')) {
+ if ((int)*(string.pointer + 0) <= (int)((unsigned char)'9')) goto _LOR_4;
+ else goto _LAND_1;
+ }
+ else {
+ _LAND_1: ;
+ if ((int)*(string.pointer + 0) >= (int)((unsigned char)'A')) {
+ if ((int)*(string.pointer + 0) <= (int)((unsigned char)'Z'))
+ goto _LOR_4;
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(string.pointer + 0) >= (int)((unsigned char)'a')) {
+ if ((int)*(string.pointer + 0) <= (int)((unsigned char)'z'))
+ goto _LOR_4;
+ else goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if ((int)*(string.pointer + 0) == '_') goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == '-') goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)';'))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'/'))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'?'))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)':'))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'@'))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'&'))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'='))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'+'))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'$'))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)','))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'_'))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'.'))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'~'))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'*'))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\''))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'('))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)')'))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'['))
+ goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)']')) {
+ _LOR_4:
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_0;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_emitter_flush
+ (emitter);
+ if (tmp_1) {
+ _LOR_0: ;
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_2;
+ yaml_char_t *tmp_3;
+ tmp_2 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_3 = string.pointer;
+ (string.pointer) ++;
+ *tmp_2 = *tmp_3;
+ yaml_char_t tmp_28 =
+ *tmp_2;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_4;
+ yaml_char_t *tmp_5;
+ yaml_char_t *tmp_6;
+ yaml_char_t *tmp_7;
+ tmp_4 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_5 = string.pointer;
+ (string.pointer) ++;
+ *tmp_4 = *tmp_5;
+ tmp_6 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_7 = string.pointer;
+ (string.pointer) ++;
+ *tmp_6 = *tmp_7;
+ yaml_char_t tmp_26 =
+ *tmp_6;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_8;
+ yaml_char_t *tmp_9;
+ yaml_char_t *tmp_10;
+ yaml_char_t *tmp_11;
+ yaml_char_t *tmp_12;
+ yaml_char_t *tmp_13;
+ tmp_8 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_9 = string.pointer;
+ (string.pointer) ++;
+ *tmp_8 = *tmp_9;
+ tmp_10 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_11 = string.pointer;
+ (string.pointer) ++;
+ *tmp_10 = *tmp_11;
+ tmp_12 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_13 = string.pointer;
+ (string.pointer) ++;
+ *tmp_12 = *tmp_13;
+ yaml_char_t tmp_24 =
+ *tmp_12;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_14;
+ yaml_char_t *tmp_15;
+ yaml_char_t *tmp_16;
+ yaml_char_t *tmp_17;
+ yaml_char_t *tmp_18;
+ yaml_char_t *tmp_19;
+ yaml_char_t *tmp_20;
+ yaml_char_t *tmp_21;
+ tmp_14 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_15 = string.pointer;
+ (string.pointer) ++;
+ *tmp_14 = *tmp_15;
+ tmp_16 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_17 = string.pointer;
+ (string.pointer) ++;
+ *tmp_16 = *tmp_17;
+ tmp_18 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_19 = string.pointer;
+ (string.pointer) ++;
+ *tmp_18 = *tmp_19;
+ tmp_20 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_21 = string.pointer;
+ (string.pointer) ++;
+ *tmp_20 = *tmp_21;
+ yaml_char_t tmp_22 =
+ *tmp_20;
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ else {
+ int tmp_25;
+ unsigned int value_0;
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00)
+ tmp_25 = 1;
+ else {
+ int tmp_24_0;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_24_0 = 2;
+ else {
+ int tmp_23;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_23 = 3;
+ else {
+ int tmp_22_1;
+ if (((int)*(
+ string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_22_1 = 4;
+ else tmp_22_1 = 0;
+ tmp_23 = tmp_22_1;
+ }
+ tmp_24_0 = tmp_23;
+ }
+ tmp_25 = tmp_24_0;
+ }
+ int width = tmp_25;
+ while (1) {
+ int tmp_35;
+ tmp_35 = width;
+ width --;
+ ;
+ if (! tmp_35) break;
+ {
+ yaml_char_t *tmp_26_0;
+ tmp_26_0 = string.pointer;
+ (string.pointer) ++;
+ value_0 = (unsigned int)*tmp_26_0;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_1;
+ else {
+ int tmp_27;
+ tmp_27 = yaml_emitter_flush
+ (emitter);
+ if (tmp_27) {
+ yaml_char_t *tmp_28_0;
+ _LOR_1:
+ { /* sequence */
+ tmp_28_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_28_0 = (unsigned char)'%';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_2;
+ else {
+ int tmp_29;
+ tmp_29 = yaml_emitter_flush
+ (emitter);
+ if (tmp_29) {
+ yaml_char_t *tmp_30;
+ int tmp_31;
+ _LOR_2:
+ { /* sequence */
+ tmp_30 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ if (value_0 >> 4 < (unsigned int)10)
+ tmp_31 = '0';
+ else tmp_31 =
+ 'A' - 10;
+ *tmp_30 = (unsigned char)(
+ (value_0 >> 4) + (unsigned int)tmp_31);
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_3;
+ else {
+ int tmp_32;
+ tmp_32 = yaml_emitter_flush
+ (emitter);
+ if (tmp_32) {
+ yaml_char_t *tmp_33;
+ int tmp_34;
+ _LOR_3:
+ { /* sequence */
+ tmp_33 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ if ((value_0 & (unsigned int)0x0F) < (unsigned int)10)
+ tmp_34 = '0';
+ else tmp_34 =
+ 'A' - 10;
+ *tmp_33 = (unsigned char)(
+ (value_0 & (unsigned int)0x0F) + (unsigned int)tmp_34);
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ emitter->whitespace = 0;
+ emitter->indention = 0;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length,
+ int allow_breaks)
+{
+ int __retres;
+ yaml_string_t string;
+ int spaces = 0;
+ int breaks = 0;
+ string.start = value;
+ string.end = value + length;
+ string.pointer = value;
+ if (! emitter->whitespace)
+ if (length) goto _LOR_0;
+ else
+ if (emitter->flow_level)
+ _LOR_0:
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR;
+ else {
+ int tmp;
+ tmp = yaml_emitter_flush(emitter);
+ if (tmp) {
+ yaml_char_t *tmp_0;
+ _LOR:
+ { /* sequence */
+ tmp_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_0 = (unsigned char)' ';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ while (string.pointer != string.end)
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)' ')) {
+ if (allow_breaks) {
+ if (! spaces) {
+ if (emitter->column > emitter->best_width) {
+ if (! ((int)*(string.pointer + 1) == (int)((unsigned char)' '))) {
+ int tmp_1;
+ int tmp_5;
+ tmp_1 = yaml_emitter_write_indent(emitter);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_5 = 1;
+ else {
+ int tmp_4;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0) tmp_4 = 2;
+ else {
+ int tmp_3;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0) tmp_3 = 3;
+ else {
+ int tmp_2;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_2 = 4;
+ else tmp_2 = 0;
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ tmp_5 = tmp_4;
+ }
+ string.pointer += tmp_5;
+ }
+ else goto _LAND_1;
+ }
+ else goto _LAND_1;
+ }
+ else goto _LAND_1;
+ }
+ else
+ _LAND_1:
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR_1;
+ else {
+ int tmp_6;
+ tmp_6 = yaml_emitter_flush(emitter);
+ if (tmp_6) {
+ _LOR_1: ;
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_7;
+ yaml_char_t *tmp_8;
+ tmp_7 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_8 = string.pointer;
+ (string.pointer) ++;
+ *tmp_7 = *tmp_8;
+ yaml_char_t tmp_33 = *tmp_7;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_9;
+ yaml_char_t *tmp_10;
+ yaml_char_t *tmp_11;
+ yaml_char_t *tmp_12;
+ tmp_9 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_10 = string.pointer;
+ (string.pointer) ++;
+ *tmp_9 = *tmp_10;
+ tmp_11 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_12 = string.pointer;
+ (string.pointer) ++;
+ *tmp_11 = *tmp_12;
+ yaml_char_t tmp_31 = *tmp_11;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_13;
+ yaml_char_t *tmp_14;
+ yaml_char_t *tmp_15;
+ yaml_char_t *tmp_16;
+ yaml_char_t *tmp_17;
+ yaml_char_t *tmp_18;
+ tmp_13 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_14 = string.pointer;
+ (string.pointer) ++;
+ *tmp_13 = *tmp_14;
+ tmp_15 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_16 = string.pointer;
+ (string.pointer) ++;
+ *tmp_15 = *tmp_16;
+ tmp_17 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_18 = string.pointer;
+ (string.pointer) ++;
+ *tmp_17 = *tmp_18;
+ yaml_char_t tmp_29 = *tmp_17;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_19;
+ yaml_char_t *tmp_20;
+ yaml_char_t *tmp_21;
+ yaml_char_t *tmp_22;
+ yaml_char_t *tmp_23;
+ yaml_char_t *tmp_24;
+ yaml_char_t *tmp_25;
+ yaml_char_t *tmp_26;
+ tmp_19 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_20 = string.pointer;
+ (string.pointer) ++;
+ *tmp_19 = *tmp_20;
+ tmp_21 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_22 = string.pointer;
+ (string.pointer) ++;
+ *tmp_21 = *tmp_22;
+ tmp_23 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_24 = string.pointer;
+ (string.pointer) ++;
+ *tmp_23 = *tmp_24;
+ tmp_25 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_26 = string.pointer;
+ (string.pointer) ++;
+ *tmp_25 = *tmp_26;
+ yaml_char_t tmp_27 = *tmp_25;
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ spaces = 1;
+ }
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\r')) goto _LOR_6;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n'))
+ goto _LOR_6;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_6;
+ else goto _LAND_6;
+ }
+ else {
+ _LAND_6: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_6;
+ else goto _LAND_5;
+ }
+ else goto _LAND_5;
+ }
+ else {
+ _LAND_5: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\251')) {
+ _LOR_6:
+ {
+ if (! breaks)
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n'))
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_2;
+ else {
+ int tmp_27_0;
+ tmp_27_0 = yaml_emitter_flush(emitter);
+ if (tmp_27_0) {
+ _LOR_2: ;
+ if (emitter->line_break == (unsigned int)YAML_CR_BREAK) {
+ yaml_char_t *tmp_28;
+ tmp_28 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_28 = (unsigned char)'\r';
+ yaml_char_t tmp_39 = *tmp_28;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_LN_BREAK) {
+ yaml_char_t *tmp_29_0;
+ tmp_29_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_29_0 = (unsigned char)'\n';
+ yaml_char_t tmp_37 = *tmp_29_0;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_CRLN_BREAK) {
+ yaml_char_t *tmp_30;
+ yaml_char_t *tmp_31_0;
+ tmp_30 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_30 = (unsigned char)'\r';
+ tmp_31_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_31_0 = (unsigned char)'\n';
+ yaml_char_t tmp_35 = *tmp_31_0;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_4;
+ else {
+ int tmp_32;
+ tmp_32 = yaml_emitter_flush(emitter);
+ if (tmp_32) {
+ int tmp_59_0;
+ _LOR_4: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n')) {
+ int tmp_38;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_3;
+ else {
+ int tmp_33_0;
+ tmp_33_0 = yaml_emitter_flush(emitter);
+ if (tmp_33_0) {
+ _LOR_3: ;
+ if (emitter->line_break == (unsigned int)YAML_CR_BREAK) {
+ yaml_char_t *tmp_34;
+ tmp_34 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_34 = (unsigned char)'\r';
+ yaml_char_t tmp_45 = *tmp_34;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_LN_BREAK) {
+ yaml_char_t *tmp_35_0;
+ tmp_35_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_35_0 = (unsigned char)'\n';
+ yaml_char_t tmp_43 = *tmp_35_0;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_CRLN_BREAK) {
+ yaml_char_t *tmp_36;
+ yaml_char_t *tmp_37_0;
+ tmp_36 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_36 = (unsigned char)'\r';
+ tmp_37_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_37_0 = (unsigned char)'\n';
+ yaml_char_t tmp_41 = *tmp_37_0;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ tmp_38 = 1;
+ }
+ else tmp_38 = 0;
+ }
+ (string.pointer) ++;
+ tmp_59_0 = 1;
+ }
+ else {
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_39_0;
+ yaml_char_t *tmp_40;
+ tmp_39_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_40 = string.pointer;
+ (string.pointer) ++;
+ *tmp_39_0 = *tmp_40;
+ yaml_char_t tmp_65 = *tmp_39_0;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_41_0;
+ yaml_char_t *tmp_42;
+ yaml_char_t *tmp_43_0;
+ yaml_char_t *tmp_44;
+ tmp_41_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_42 = string.pointer;
+ (string.pointer) ++;
+ *tmp_41_0 = *tmp_42;
+ tmp_43_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_44 = string.pointer;
+ (string.pointer) ++;
+ *tmp_43_0 = *tmp_44;
+ yaml_char_t tmp_63 = *tmp_43_0;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_45_0;
+ yaml_char_t *tmp_46;
+ yaml_char_t *tmp_47;
+ yaml_char_t *tmp_48;
+ yaml_char_t *tmp_49;
+ yaml_char_t *tmp_50;
+ tmp_45_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_46 = string.pointer;
+ (string.pointer) ++;
+ *tmp_45_0 = *tmp_46;
+ tmp_47 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_48 = string.pointer;
+ (string.pointer) ++;
+ *tmp_47 = *tmp_48;
+ tmp_49 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_50 = string.pointer;
+ (string.pointer) ++;
+ *tmp_49 = *tmp_50;
+ yaml_char_t tmp_61 = *tmp_49;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_51;
+ yaml_char_t *tmp_52;
+ yaml_char_t *tmp_53;
+ yaml_char_t *tmp_54;
+ yaml_char_t *tmp_55;
+ yaml_char_t *tmp_56;
+ yaml_char_t *tmp_57;
+ yaml_char_t *tmp_58;
+ tmp_51 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_52 = string.pointer;
+ (string.pointer) ++;
+ *tmp_51 = *tmp_52;
+ tmp_53 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_54 = string.pointer;
+ (string.pointer) ++;
+ *tmp_53 = *tmp_54;
+ tmp_55 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_56 = string.pointer;
+ (string.pointer) ++;
+ *tmp_55 = *tmp_56;
+ tmp_57 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_58 = string.pointer;
+ (string.pointer) ++;
+ *tmp_57 = *tmp_58;
+ yaml_char_t tmp_59 = *tmp_57;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ tmp_59_0 = 1;
+ }
+ if (! tmp_59_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->indention = 1;
+ breaks = 1;
+ }
+ }
+ else goto _LAND_3;
+ }
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3:
+ {
+ if (breaks) {
+ int tmp_60;
+ tmp_60 = yaml_emitter_write_indent(emitter);
+ if (! tmp_60) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_5;
+ else {
+ int tmp_61_0;
+ tmp_61_0 = yaml_emitter_flush(emitter);
+ if (tmp_61_0) {
+ _LOR_5: ;
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_62;
+ yaml_char_t *tmp_63_0;
+ tmp_62 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_63_0 = string.pointer;
+ (string.pointer) ++;
+ *tmp_62 = *tmp_63_0;
+ yaml_char_t tmp_88 = *tmp_62;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_64;
+ yaml_char_t *tmp_65_0;
+ yaml_char_t *tmp_66;
+ yaml_char_t *tmp_67;
+ tmp_64 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_65_0 = string.pointer;
+ (string.pointer) ++;
+ *tmp_64 = *tmp_65_0;
+ tmp_66 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_67 = string.pointer;
+ (string.pointer) ++;
+ *tmp_66 = *tmp_67;
+ yaml_char_t tmp_86 = *tmp_66;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_68;
+ yaml_char_t *tmp_69;
+ yaml_char_t *tmp_70;
+ yaml_char_t *tmp_71;
+ yaml_char_t *tmp_72;
+ yaml_char_t *tmp_73;
+ tmp_68 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_69 = string.pointer;
+ (string.pointer) ++;
+ *tmp_68 = *tmp_69;
+ tmp_70 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_71 = string.pointer;
+ (string.pointer) ++;
+ *tmp_70 = *tmp_71;
+ tmp_72 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_73 = string.pointer;
+ (string.pointer) ++;
+ *tmp_72 = *tmp_73;
+ yaml_char_t tmp_84 = *tmp_72;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_74;
+ yaml_char_t *tmp_75;
+ yaml_char_t *tmp_76;
+ yaml_char_t *tmp_77;
+ yaml_char_t *tmp_78;
+ yaml_char_t *tmp_79;
+ yaml_char_t *tmp_80;
+ yaml_char_t *tmp_81;
+ tmp_74 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_75 = string.pointer;
+ (string.pointer) ++;
+ *tmp_74 = *tmp_75;
+ tmp_76 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_77 = string.pointer;
+ (string.pointer) ++;
+ *tmp_76 = *tmp_77;
+ tmp_78 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_79 = string.pointer;
+ (string.pointer) ++;
+ *tmp_78 = *tmp_79;
+ tmp_80 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_81 = string.pointer;
+ (string.pointer) ++;
+ *tmp_80 = *tmp_81;
+ yaml_char_t tmp_82 = *tmp_80;
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->indention = 0;
+ spaces = 0;
+ breaks = 0;
+ }
+ }
+ }
+ }
+ emitter->whitespace = 0;
+ emitter->indention = 0;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value,
+ size_t length,
+ int allow_breaks)
+{
+ int __retres;
+ yaml_string_t string;
+ int tmp;
+ int tmp_84;
+ int spaces = 0;
+ int breaks = 0;
+ string.start = value;
+ string.end = value + length;
+ string.pointer = value;
+ tmp = yaml_emitter_write_indicator(emitter,"\'",1,0,0);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ while (string.pointer != string.end)
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)' ')) {
+ if (allow_breaks) {
+ if (! spaces) {
+ if (emitter->column > emitter->best_width) {
+ if (string.pointer != string.start) {
+ if (string.pointer != string.end - 1) {
+ if (! ((int)*(string.pointer + 1) == (int)((unsigned char)' '))) {
+ int tmp_0;
+ int tmp_4;
+ tmp_0 = yaml_emitter_write_indent(emitter);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00) tmp_4 = 1;
+ else {
+ int tmp_3;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_3 = 2;
+ else {
+ int tmp_2;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_2 = 3;
+ else {
+ int tmp_1;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_1 = 4;
+ else tmp_1 = 0;
+ tmp_2 = tmp_1;
+ }
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ string.pointer += tmp_4;
+ }
+ else goto _LAND_3;
+ }
+ else goto _LAND_3;
+ }
+ else goto _LAND_3;
+ }
+ else goto _LAND_3;
+ }
+ else goto _LAND_3;
+ }
+ else
+ _LAND_3:
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR;
+ else {
+ int tmp_5;
+ tmp_5 = yaml_emitter_flush(emitter);
+ if (tmp_5) {
+ _LOR: ;
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_6;
+ yaml_char_t *tmp_7;
+ tmp_6 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_7 = string.pointer;
+ (string.pointer) ++;
+ *tmp_6 = *tmp_7;
+ yaml_char_t tmp_32 = *tmp_6;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_8;
+ yaml_char_t *tmp_9;
+ yaml_char_t *tmp_10;
+ yaml_char_t *tmp_11;
+ tmp_8 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_9 = string.pointer;
+ (string.pointer) ++;
+ *tmp_8 = *tmp_9;
+ tmp_10 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_11 = string.pointer;
+ (string.pointer) ++;
+ *tmp_10 = *tmp_11;
+ yaml_char_t tmp_30 = *tmp_10;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_12;
+ yaml_char_t *tmp_13;
+ yaml_char_t *tmp_14;
+ yaml_char_t *tmp_15;
+ yaml_char_t *tmp_16;
+ yaml_char_t *tmp_17;
+ tmp_12 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_13 = string.pointer;
+ (string.pointer) ++;
+ *tmp_12 = *tmp_13;
+ tmp_14 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_15 = string.pointer;
+ (string.pointer) ++;
+ *tmp_14 = *tmp_15;
+ tmp_16 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_17 = string.pointer;
+ (string.pointer) ++;
+ *tmp_16 = *tmp_17;
+ yaml_char_t tmp_28 = *tmp_16;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_18;
+ yaml_char_t *tmp_19;
+ yaml_char_t *tmp_20;
+ yaml_char_t *tmp_21;
+ yaml_char_t *tmp_22;
+ yaml_char_t *tmp_23;
+ yaml_char_t *tmp_24;
+ yaml_char_t *tmp_25;
+ tmp_18 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_19 = string.pointer;
+ (string.pointer) ++;
+ *tmp_18 = *tmp_19;
+ tmp_20 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_21 = string.pointer;
+ (string.pointer) ++;
+ *tmp_20 = *tmp_21;
+ tmp_22 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_23 = string.pointer;
+ (string.pointer) ++;
+ *tmp_22 = *tmp_23;
+ tmp_24 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_25 = string.pointer;
+ (string.pointer) ++;
+ *tmp_24 = *tmp_25;
+ yaml_char_t tmp_26 = *tmp_24;
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ spaces = 1;
+ }
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\r')) goto _LOR_5;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n'))
+ goto _LOR_5;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_5;
+ else goto _LAND_8;
+ }
+ else {
+ _LAND_8: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_5;
+ else goto _LAND_7;
+ }
+ else goto _LAND_7;
+ }
+ else {
+ _LAND_7: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\251')) {
+ _LOR_5:
+ {
+ if (! breaks)
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n'))
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_0;
+ else {
+ int tmp_26_1;
+ tmp_26_1 = yaml_emitter_flush(emitter);
+ if (tmp_26_1) {
+ _LOR_0: ;
+ if (emitter->line_break == (unsigned int)YAML_CR_BREAK) {
+ yaml_char_t *tmp_27;
+ tmp_27 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_27 = (unsigned char)'\r';
+ yaml_char_t tmp_38 = *tmp_27;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_LN_BREAK) {
+ yaml_char_t *tmp_28_1;
+ tmp_28_1 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_28_1 = (unsigned char)'\n';
+ yaml_char_t tmp_36 = *tmp_28_1;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_CRLN_BREAK) {
+ yaml_char_t *tmp_29;
+ yaml_char_t *tmp_30_0;
+ tmp_29 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_29 = (unsigned char)'\r';
+ tmp_30_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_30_0 = (unsigned char)'\n';
+ yaml_char_t tmp_34 = *tmp_30_0;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_2;
+ else {
+ int tmp_31;
+ tmp_31 = yaml_emitter_flush(emitter);
+ if (tmp_31) {
+ int tmp_58_0;
+ _LOR_2: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n')) {
+ int tmp_37;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_1;
+ else {
+ int tmp_32_0;
+ tmp_32_0 = yaml_emitter_flush(emitter);
+ if (tmp_32_0) {
+ _LOR_1: ;
+ if (emitter->line_break == (unsigned int)YAML_CR_BREAK) {
+ yaml_char_t *tmp_33;
+ tmp_33 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_33 = (unsigned char)'\r';
+ yaml_char_t tmp_44 = *tmp_33;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_LN_BREAK) {
+ yaml_char_t *tmp_34_0;
+ tmp_34_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_34_0 = (unsigned char)'\n';
+ yaml_char_t tmp_42 = *tmp_34_0;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_CRLN_BREAK) {
+ yaml_char_t *tmp_35;
+ yaml_char_t *tmp_36_0;
+ tmp_35 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_35 = (unsigned char)'\r';
+ tmp_36_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_36_0 = (unsigned char)'\n';
+ yaml_char_t tmp_40 = *tmp_36_0;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ tmp_37 = 1;
+ }
+ else tmp_37 = 0;
+ }
+ (string.pointer) ++;
+ tmp_58_0 = 1;
+ }
+ else {
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_38_0;
+ yaml_char_t *tmp_39;
+ tmp_38_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_39 = string.pointer;
+ (string.pointer) ++;
+ *tmp_38_0 = *tmp_39;
+ yaml_char_t tmp_64 = *tmp_38_0;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_40_0;
+ yaml_char_t *tmp_41;
+ yaml_char_t *tmp_42_0;
+ yaml_char_t *tmp_43;
+ tmp_40_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_41 = string.pointer;
+ (string.pointer) ++;
+ *tmp_40_0 = *tmp_41;
+ tmp_42_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_43 = string.pointer;
+ (string.pointer) ++;
+ *tmp_42_0 = *tmp_43;
+ yaml_char_t tmp_62 = *tmp_42_0;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_44_0;
+ yaml_char_t *tmp_45;
+ yaml_char_t *tmp_46;
+ yaml_char_t *tmp_47;
+ yaml_char_t *tmp_48;
+ yaml_char_t *tmp_49;
+ tmp_44_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_45 = string.pointer;
+ (string.pointer) ++;
+ *tmp_44_0 = *tmp_45;
+ tmp_46 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_47 = string.pointer;
+ (string.pointer) ++;
+ *tmp_46 = *tmp_47;
+ tmp_48 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_49 = string.pointer;
+ (string.pointer) ++;
+ *tmp_48 = *tmp_49;
+ yaml_char_t tmp_60 = *tmp_48;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_50;
+ yaml_char_t *tmp_51;
+ yaml_char_t *tmp_52;
+ yaml_char_t *tmp_53;
+ yaml_char_t *tmp_54;
+ yaml_char_t *tmp_55;
+ yaml_char_t *tmp_56;
+ yaml_char_t *tmp_57;
+ tmp_50 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_51 = string.pointer;
+ (string.pointer) ++;
+ *tmp_50 = *tmp_51;
+ tmp_52 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_53 = string.pointer;
+ (string.pointer) ++;
+ *tmp_52 = *tmp_53;
+ tmp_54 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_55 = string.pointer;
+ (string.pointer) ++;
+ *tmp_54 = *tmp_55;
+ tmp_56 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_57 = string.pointer;
+ (string.pointer) ++;
+ *tmp_56 = *tmp_57;
+ yaml_char_t tmp_58 = *tmp_56;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ tmp_58_0 = 1;
+ }
+ if (! tmp_58_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->indention = 1;
+ breaks = 1;
+ }
+ }
+ else goto _LAND_5;
+ }
+ else goto _LAND_5;
+ }
+ else {
+ _LAND_5:
+ {
+ if (breaks) {
+ int tmp_59;
+ tmp_59 = yaml_emitter_write_indent(emitter);
+ if (! tmp_59) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\''))
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_3;
+ else {
+ int tmp_60_0;
+ tmp_60_0 = yaml_emitter_flush(emitter);
+ if (tmp_60_0) {
+ yaml_char_t *tmp_61;
+ _LOR_3:
+ { /* sequence */
+ tmp_61 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_61 = (unsigned char)'\'';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_4;
+ else {
+ int tmp_62_0;
+ tmp_62_0 = yaml_emitter_flush(emitter);
+ if (tmp_62_0) {
+ _LOR_4: ;
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_63;
+ yaml_char_t *tmp_64_0;
+ tmp_63 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_64_0 = string.pointer;
+ (string.pointer) ++;
+ *tmp_63 = *tmp_64_0;
+ yaml_char_t tmp_89 = *tmp_63;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_65;
+ yaml_char_t *tmp_66;
+ yaml_char_t *tmp_67;
+ yaml_char_t *tmp_68;
+ tmp_65 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_66 = string.pointer;
+ (string.pointer) ++;
+ *tmp_65 = *tmp_66;
+ tmp_67 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_68 = string.pointer;
+ (string.pointer) ++;
+ *tmp_67 = *tmp_68;
+ yaml_char_t tmp_87 = *tmp_67;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_69;
+ yaml_char_t *tmp_70;
+ yaml_char_t *tmp_71;
+ yaml_char_t *tmp_72;
+ yaml_char_t *tmp_73;
+ yaml_char_t *tmp_74;
+ tmp_69 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_70 = string.pointer;
+ (string.pointer) ++;
+ *tmp_69 = *tmp_70;
+ tmp_71 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_72 = string.pointer;
+ (string.pointer) ++;
+ *tmp_71 = *tmp_72;
+ tmp_73 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_74 = string.pointer;
+ (string.pointer) ++;
+ *tmp_73 = *tmp_74;
+ yaml_char_t tmp_85 = *tmp_73;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_75;
+ yaml_char_t *tmp_76;
+ yaml_char_t *tmp_77;
+ yaml_char_t *tmp_78;
+ yaml_char_t *tmp_79;
+ yaml_char_t *tmp_80;
+ yaml_char_t *tmp_81;
+ yaml_char_t *tmp_82;
+ tmp_75 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_76 = string.pointer;
+ (string.pointer) ++;
+ *tmp_75 = *tmp_76;
+ tmp_77 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_78 = string.pointer;
+ (string.pointer) ++;
+ *tmp_77 = *tmp_78;
+ tmp_79 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_80 = string.pointer;
+ (string.pointer) ++;
+ *tmp_79 = *tmp_80;
+ tmp_81 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_82 = string.pointer;
+ (string.pointer) ++;
+ *tmp_81 = *tmp_82;
+ yaml_char_t tmp_83 = *tmp_81;
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->indention = 0;
+ spaces = 0;
+ breaks = 0;
+ }
+ }
+ }
+ }
+ if (breaks) {
+ int tmp_83_0;
+ tmp_83_0 = yaml_emitter_write_indent(emitter);
+ if (! tmp_83_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ tmp_84 = yaml_emitter_write_indicator(emitter,"\'",0,0,0);
+ if (! tmp_84) {
+ __retres = 0;
+ goto return_label;
+ }
+ emitter->whitespace = 0;
+ emitter->indention = 0;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_write_double_quoted_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value,
+ size_t length,
+ int allow_breaks)
+{
+ int __retres;
+ yaml_string_t string;
+ int tmp;
+ int tmp_96_0;
+ int spaces = 0;
+ string.start = value;
+ string.end = value + length;
+ string.pointer = value;
+ tmp = yaml_emitter_write_indicator(emitter,"\"",1,0,0);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ while (string.pointer != string.end)
+ if ((int)*(string.pointer + 0) == 0x0A) goto _LAND_11;
+ else
+ if ((int)*(string.pointer + 0) >= 0x20) {
+ if ((int)*(string.pointer + 0) <= 0x7E) goto _LAND_11;
+ else goto _LAND_16;
+ }
+ else {
+ _LAND_16: ;
+ if ((int)*(string.pointer + 0) == 0xC2) {
+ if ((int)*(string.pointer + (0 + 1)) >= 0xA0) goto _LAND_11;
+ else goto _LAND_15;
+ }
+ else {
+ _LAND_15: ;
+ if ((int)*(string.pointer + 0) > 0xC2) {
+ if ((int)*(string.pointer + 0) < 0xED) goto _LAND_11;
+ else goto _LAND_14;
+ }
+ else {
+ _LAND_14: ;
+ if ((int)*(string.pointer + 0) == 0xED) {
+ if ((int)*(string.pointer + (0 + 1)) < 0xA0) goto _LAND_11;
+ else goto _LAND_13;
+ }
+ else {
+ _LAND_13: ;
+ if ((int)*(string.pointer + 0) == 0xEE) goto _LAND_11;
+ else
+ if ((int)*(string.pointer + 0) == 0xEF)
+ if ((int)*(string.pointer + (0 + 1)) == 0xBB) {
+ if ((int)*(string.pointer + (0 + 2)) == 0xBF) goto _LOR_22;
+ else goto _LAND_12;
+ }
+ else {
+ _LAND_12: ;
+ if ((int)*(string.pointer + (0 + 1)) == 0xBF) {
+ if ((int)*(string.pointer + (0 + 2)) == 0xBE) goto _LOR_22;
+ else
+ if ((int)*(string.pointer + (0 + 2)) == 0xBF)
+ goto _LOR_22;
+ else goto _LAND_11;
+ }
+ else
+ _LAND_11:
+ if (! emitter->unicode) {
+ if (! ((int)*(string.pointer + 0) <= (int)((unsigned char)'\177')))
+ goto _LOR_22;
+ else goto _LAND_10;
+ }
+ else {
+ _LAND_10: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\357')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\273')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\277'))
+ goto _LOR_22;
+ else goto _LAND_9;
+ }
+ else goto _LAND_9;
+ }
+ else {
+ _LAND_9: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_22;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n'))
+ goto _LOR_22;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_22;
+ else goto _LAND_7;
+ }
+ else {
+ _LAND_7: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_22;
+ else goto _LAND_6;
+ }
+ else goto _LAND_6;
+ }
+ else {
+ _LAND_6: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\251'))
+ goto _LOR_22;
+ else goto _LAND_4;
+ }
+ else goto _LAND_4;
+ }
+ else {
+ _LAND_4: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\"'))
+ goto _LOR_22;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\\')) {
+ _LOR_22:
+ {
+ unsigned char octet;
+ unsigned int width;
+ unsigned int value_0;
+ int k;
+ octet = *(string.pointer + 0);
+ if (((int)octet & 0x80) == 0x00)
+ width = (unsigned int)1;
+ else {
+ int tmp_2;
+ if (((int)octet & 0xE0) == 0xC0)
+ tmp_2 = 2;
+ else {
+ int tmp_1;
+ if (((int)octet & 0xF0) == 0xE0)
+ tmp_1 = 3;
+ else {
+ int tmp_0;
+ if (((int)octet & 0xF8) == 0xF0)
+ tmp_0 = 4;
+ else tmp_0 = 0;
+ tmp_1 = tmp_0;
+ }
+ tmp_2 = tmp_1;
+ }
+ width = (unsigned int)tmp_2;
+ }
+ if (((int)octet & 0x80) == 0x00)
+ value_0 = (unsigned int)(
+ (int)octet & 0x7F);
+ else {
+ int tmp_5;
+ if (((int)octet & 0xE0) == 0xC0)
+ tmp_5 = (int)octet & 0x1F;
+ else {
+ int tmp_4;
+ if (((int)octet & 0xF0) == 0xE0)
+ tmp_4 = (int)octet & 0x0F;
+ else {
+ int tmp_3;
+ if (((int)octet & 0xF8) == 0xF0)
+ tmp_3 = (int)octet & 0x07;
+ else tmp_3 = 0;
+ tmp_4 = tmp_3;
+ }
+ tmp_5 = tmp_4;
+ }
+ value_0 = (unsigned int)tmp_5;
+ }
+ k = 1;
+ while (k < (int)width) {
+ octet = *(string.pointer + k);
+ value_0 = (value_0 << 6) + (unsigned int)(
+ (int)octet & 0x3F);
+ k ++;
+ }
+ string.pointer += width;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR;
+ else {
+ int tmp_6;
+ tmp_6 = yaml_emitter_flush
+ (emitter);
+ if (tmp_6) {
+ yaml_char_t *tmp_7;
+ _LOR:
+ { /* sequence */
+ tmp_7 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_7 = (unsigned char)'\\';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ switch (value_0) {
+ case (unsigned int)0x00: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_0;
+ else {
+ int tmp_8;
+ tmp_8 = yaml_emitter_flush
+ (emitter);
+ if (tmp_8) {
+ yaml_char_t *tmp_9;
+ _LOR_0:
+ { /* sequence */
+ tmp_9 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_9 = (unsigned char)'0';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0x07: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_1;
+ else {
+ int tmp_10;
+ tmp_10 = yaml_emitter_flush
+ (emitter);
+ if (tmp_10) {
+ yaml_char_t *tmp_11;
+ _LOR_1:
+ { /* sequence */
+ tmp_11 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_11 = (unsigned char)'a';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0x08: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_2;
+ else {
+ int tmp_12;
+ tmp_12 = yaml_emitter_flush
+ (emitter);
+ if (tmp_12) {
+ yaml_char_t *tmp_13;
+ _LOR_2:
+ { /* sequence */
+ tmp_13 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_13 = (unsigned char)'b';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0x09: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_3;
+ else {
+ int tmp_14;
+ tmp_14 = yaml_emitter_flush
+ (emitter);
+ if (tmp_14) {
+ yaml_char_t *tmp_15;
+ _LOR_3:
+ { /* sequence */
+ tmp_15 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_15 = (unsigned char)'t';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0x0A: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_4;
+ else {
+ int tmp_16;
+ tmp_16 = yaml_emitter_flush
+ (emitter);
+ if (tmp_16) {
+ yaml_char_t *tmp_17;
+ _LOR_4:
+ { /* sequence */
+ tmp_17 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_17 = (unsigned char)'n';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0x0B: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_5;
+ else {
+ int tmp_18;
+ tmp_18 = yaml_emitter_flush
+ (emitter);
+ if (tmp_18) {
+ yaml_char_t *tmp_19;
+ _LOR_5:
+ { /* sequence */
+ tmp_19 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_19 = (unsigned char)'v';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0x0C: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_6;
+ else {
+ int tmp_20;
+ tmp_20 = yaml_emitter_flush
+ (emitter);
+ if (tmp_20) {
+ yaml_char_t *tmp_21;
+ _LOR_6:
+ { /* sequence */
+ tmp_21 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_21 = (unsigned char)'f';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0x0D: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_7;
+ else {
+ int tmp_22;
+ tmp_22 = yaml_emitter_flush
+ (emitter);
+ if (tmp_22) {
+ yaml_char_t *tmp_23;
+ _LOR_7:
+ { /* sequence */
+ tmp_23 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_23 = (unsigned char)'r';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0x1B: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_8;
+ else {
+ int tmp_24;
+ tmp_24 = yaml_emitter_flush
+ (emitter);
+ if (tmp_24) {
+ yaml_char_t *tmp_25;
+ _LOR_8:
+ { /* sequence */
+ tmp_25 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_25 = (unsigned char)'e';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0x22: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_9;
+ else {
+ int tmp_26;
+ tmp_26 = yaml_emitter_flush
+ (emitter);
+ if (tmp_26) {
+ yaml_char_t *tmp_27;
+ _LOR_9:
+ { /* sequence */
+ tmp_27 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_27 = (unsigned char)'\"';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0x5C: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_10;
+ else {
+ int tmp_28;
+ tmp_28 = yaml_emitter_flush
+ (emitter);
+ if (tmp_28) {
+ yaml_char_t *tmp_29;
+ _LOR_10:
+ { /* sequence */
+ tmp_29 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_29 = (unsigned char)'\\';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0x85: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_11;
+ else {
+ int tmp_30;
+ tmp_30 = yaml_emitter_flush
+ (emitter);
+ if (tmp_30) {
+ yaml_char_t *tmp_31;
+ _LOR_11:
+ { /* sequence */
+ tmp_31 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_31 = (unsigned char)'N';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0xA0: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_12;
+ else {
+ int tmp_32;
+ tmp_32 = yaml_emitter_flush
+ (emitter);
+ if (tmp_32) {
+ yaml_char_t *tmp_33;
+ _LOR_12:
+ { /* sequence */
+ tmp_33 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_33 = (unsigned char)'_';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0x2028: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_13;
+ else {
+ int tmp_34;
+ tmp_34 = yaml_emitter_flush
+ (emitter);
+ if (tmp_34) {
+ yaml_char_t *tmp_35;
+ _LOR_13:
+ { /* sequence */
+ tmp_35 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_35 = (unsigned char)'L';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ case (unsigned int)0x2029: ;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_14;
+ else {
+ int tmp_36;
+ tmp_36 = yaml_emitter_flush
+ (emitter);
+ if (tmp_36) {
+ yaml_char_t *tmp_37;
+ _LOR_14:
+ { /* sequence */
+ tmp_37 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_37 = (unsigned char)'P';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ break;
+ default: ;
+ if (value_0 <= (unsigned int)0xFF) {
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_15;
+ else {
+ int tmp_38;
+ tmp_38 = yaml_emitter_flush
+ (emitter);
+ if (tmp_38) {
+ yaml_char_t *tmp_39;
+ _LOR_15:
+ { /* sequence */
+ tmp_39 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_39 = (unsigned char)'x';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ width = (unsigned int)2;
+ }
+ else
+ if (value_0 <= (unsigned int)0xFFFF) {
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_16;
+ else {
+ int tmp_40;
+ tmp_40 = yaml_emitter_flush
+ (emitter);
+ if (tmp_40) {
+ yaml_char_t *tmp_41;
+ _LOR_16:
+ { /* sequence */
+ tmp_41 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_41 = (unsigned char)'u';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ width = (unsigned int)4;
+ }
+ else {
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_17;
+ else {
+ int tmp_42;
+ tmp_42 = yaml_emitter_flush
+ (emitter);
+ if (tmp_42) {
+ yaml_char_t *tmp_43;
+ _LOR_17:
+ { /* sequence */
+ tmp_43 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_43 = (unsigned char)'U';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ width = (unsigned int)8;
+ }
+ k = (int)((width - (unsigned int)1) * (unsigned int)4);
+ while (k >= 0) {
+ {
+ int digit =
+ (int)((value_0 >> k) & (unsigned int)0x0F);
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_18;
+ else {
+ int tmp_44;
+ tmp_44 = yaml_emitter_flush
+ (emitter);
+ if (tmp_44) {
+ yaml_char_t *tmp_45;
+ int tmp_46;
+ _LOR_18:
+ { /* sequence */
+ tmp_45 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ if (digit < 10)
+ tmp_46 = '0';
+ else tmp_46 = 'A' - 10;
+ *tmp_45 = (unsigned char)(
+ digit + tmp_46);
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ k -= 4;
+ }
+ }
+ spaces = 0;
+ }
+ }
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)' ')) {
+ if (allow_breaks) {
+ if (! spaces) {
+ if (emitter->column > emitter->best_width) {
+ if (string.pointer != string.start) {
+ if (string.pointer !=
+ string.end - 1) {
+ int tmp_47;
+ int tmp_53;
+ tmp_47 = yaml_emitter_write_indent
+ (emitter);
+ if (! tmp_47) {
+ __retres = 0;
+ goto return_label;
+ }
+ if ((int)*(string.pointer + 1) == (int)((unsigned char)' '))
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_19;
+ else {
+ int tmp_48;
+ tmp_48 = yaml_emitter_flush
+ (emitter);
+ if (tmp_48) {
+ yaml_char_t *tmp_49;
+ _LOR_19:
+ { /* sequence */
+ tmp_49 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_49 = (unsigned char)'\\';
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00)
+ tmp_53 = 1;
+ else {
+ int tmp_52;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_52 = 2;
+ else {
+ int tmp_51;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_51 = 3;
+ else {
+ int tmp_50;
+ if (((int)*(
+ string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_50 = 4;
+ else tmp_50 = 0;
+ tmp_51 = tmp_50;
+ }
+ tmp_52 = tmp_51;
+ }
+ tmp_53 = tmp_52;
+ }
+ string.pointer += tmp_53;
+ }
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else
+ _LAND_2:
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_20;
+ else {
+ int tmp_54;
+ tmp_54 = yaml_emitter_flush
+ (emitter);
+ if (tmp_54) {
+ _LOR_20: ;
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_55;
+ yaml_char_t *tmp_56;
+ tmp_55 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_56 = string.pointer;
+ (string.pointer) ++;
+ *tmp_55 = *tmp_56;
+ yaml_char_t tmp_81 =
+ *tmp_55;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_57;
+ yaml_char_t *tmp_58;
+ yaml_char_t *tmp_59;
+ yaml_char_t *tmp_60;
+ tmp_57 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_58 = string.pointer;
+ (string.pointer) ++;
+ *tmp_57 = *tmp_58;
+ tmp_59 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_60 = string.pointer;
+ (string.pointer) ++;
+ *tmp_59 = *tmp_60;
+ yaml_char_t tmp_79 =
+ *tmp_59;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_61;
+ yaml_char_t *tmp_62;
+ yaml_char_t *tmp_63;
+ yaml_char_t *tmp_64;
+ yaml_char_t *tmp_65;
+ yaml_char_t *tmp_66;
+ tmp_61 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_62 = string.pointer;
+ (string.pointer) ++;
+ *tmp_61 = *tmp_62;
+ tmp_63 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_64 = string.pointer;
+ (string.pointer) ++;
+ *tmp_63 = *tmp_64;
+ tmp_65 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_66 = string.pointer;
+ (string.pointer) ++;
+ *tmp_65 = *tmp_66;
+ yaml_char_t tmp_77 =
+ *tmp_65;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_67;
+ yaml_char_t *tmp_68;
+ yaml_char_t *tmp_69;
+ yaml_char_t *tmp_70;
+ yaml_char_t *tmp_71;
+ yaml_char_t *tmp_72;
+ yaml_char_t *tmp_73;
+ yaml_char_t *tmp_74;
+ tmp_67 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_68 = string.pointer;
+ (string.pointer) ++;
+ *tmp_67 = *tmp_68;
+ tmp_69 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_70 = string.pointer;
+ (string.pointer) ++;
+ *tmp_69 = *tmp_70;
+ tmp_71 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_72 = string.pointer;
+ (string.pointer) ++;
+ *tmp_71 = *tmp_72;
+ tmp_73 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_74 = string.pointer;
+ (string.pointer) ++;
+ *tmp_73 = *tmp_74;
+ yaml_char_t tmp_75 =
+ *tmp_73;
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ spaces = 1;
+ }
+ else {
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_21;
+ else {
+ int tmp_75_0;
+ tmp_75_0 = yaml_emitter_flush
+ (emitter);
+ if (tmp_75_0) {
+ _LOR_21: ;
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_76;
+ yaml_char_t *tmp_77_0;
+ tmp_76 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_77_0 = string.pointer;
+ (string.pointer) ++;
+ *tmp_76 = *tmp_77_0;
+ yaml_char_t tmp_102 =
+ *tmp_76;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_78;
+ yaml_char_t *tmp_79_0;
+ yaml_char_t *tmp_80;
+ yaml_char_t *tmp_81_0;
+ tmp_78 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_79_0 = string.pointer;
+ (string.pointer) ++;
+ *tmp_78 = *tmp_79_0;
+ tmp_80 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_81_0 = string.pointer;
+ (string.pointer) ++;
+ *tmp_80 = *tmp_81_0;
+ yaml_char_t tmp_100 =
+ *tmp_80;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_82;
+ yaml_char_t *tmp_83;
+ yaml_char_t *tmp_84;
+ yaml_char_t *tmp_85;
+ yaml_char_t *tmp_86;
+ yaml_char_t *tmp_87;
+ tmp_82 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_83 = string.pointer;
+ (string.pointer) ++;
+ *tmp_82 = *tmp_83;
+ tmp_84 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_85 = string.pointer;
+ (string.pointer) ++;
+ *tmp_84 = *tmp_85;
+ tmp_86 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_87 = string.pointer;
+ (string.pointer) ++;
+ *tmp_86 = *tmp_87;
+ yaml_char_t tmp_98 =
+ *tmp_86;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_88;
+ yaml_char_t *tmp_89;
+ yaml_char_t *tmp_90;
+ yaml_char_t *tmp_91;
+ yaml_char_t *tmp_92;
+ yaml_char_t *tmp_93;
+ yaml_char_t *tmp_94;
+ yaml_char_t *tmp_95;
+ tmp_88 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_89 = string.pointer;
+ (string.pointer) ++;
+ *tmp_88 = *tmp_89;
+ tmp_90 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_91 = string.pointer;
+ (string.pointer) ++;
+ *tmp_90 = *tmp_91;
+ tmp_92 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_93 = string.pointer;
+ (string.pointer) ++;
+ *tmp_92 = *tmp_93;
+ tmp_94 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_95 = string.pointer;
+ (string.pointer) ++;
+ *tmp_94 = *tmp_95;
+ yaml_char_t tmp_96 =
+ *tmp_94;
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ spaces = 0;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ else goto _LOR_22;
+ }
+ }
+ }
+ }
+ tmp_96_0 = yaml_emitter_write_indicator(emitter,"\"",0,0,0);
+ if (! tmp_96_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ emitter->whitespace = 0;
+ emitter->indention = 0;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_write_block_scalar_hints(yaml_emitter_t *emitter,
+ yaml_string_t string)
+{
+ int __retres;
+ char indent_hint[2];
+ char const *chomp_hint = (char const *)0;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)' ')) goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\r')) goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n')) goto _LOR_0;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_0;
+ else goto _LAND_1;
+ }
+ else {
+ _LAND_1: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_0;
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200'))
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\251')) {
+ _LOR_0:
+ {
+ int tmp;
+ indent_hint[0] = (char)('0' + (int)((char)emitter->best_indent));
+ indent_hint[1] = (char)'\000';
+ tmp = yaml_emitter_write_indicator(emitter,
+ (char const *)(indent_hint),
+ 0,0,0);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ }
+ }
+ emitter->open_ended = 0;
+ string.pointer = string.end;
+ if (string.start == string.pointer) chomp_hint = "-";
+ else {
+ while (1) {
+ (string.pointer) --;
+ if (! (((int)*(string.pointer) & 0xC0) == 0x80)) break;
+ }
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\r')) goto _LOR_2;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n')) goto _LOR_2;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_2;
+ else goto _LAND_9;
+ }
+ else {
+ _LAND_9: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_2;
+ else goto _LAND_8;
+ }
+ else goto _LAND_8;
+ }
+ else {
+ _LAND_8: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\251')) {
+ _LOR_2: ;
+ if (string.start == string.pointer) {
+ chomp_hint = "+";
+ emitter->open_ended = 2;
+ }
+ else {
+ while (1) {
+ (string.pointer) --;
+ if (! (((int)*(string.pointer) & 0xC0) == 0x80))
+ break;
+ }
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_1;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n'))
+ goto _LOR_1;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_1;
+ else goto _LAND_4;
+ }
+ else {
+ _LAND_4: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_1;
+ else goto _LAND_3;
+ }
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200'))
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\251')) {
+ _LOR_1:
+ {
+ chomp_hint = "+";
+ emitter->open_ended = 2;
+ }
+ }
+ }
+ }
+ }
+ }
+ else goto _LAND_6;
+ }
+ else goto _LAND_6;
+ }
+ else _LAND_6: chomp_hint = "-";
+ }
+ }
+ }
+ if (chomp_hint) {
+ int tmp_0;
+ tmp_0 = yaml_emitter_write_indicator(emitter,chomp_hint,0,0,0);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_write_literal_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value,
+ size_t length)
+{
+ int __retres;
+ yaml_string_t string;
+ int tmp;
+ int tmp_0;
+ int breaks = 1;
+ string.start = value;
+ string.end = value + length;
+ string.pointer = value;
+ tmp = yaml_emitter_write_indicator(emitter,"|",1,0,0);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_0 = yaml_emitter_write_block_scalar_hints(emitter,string);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_emitter_flush(emitter);
+ if (tmp_1) {
+ _LOR: ;
+ if (emitter->line_break == (unsigned int)YAML_CR_BREAK) {
+ yaml_char_t *tmp_2;
+ tmp_2 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_2 = (unsigned char)'\r';
+ yaml_char_t tmp_10 = *tmp_2;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_LN_BREAK) {
+ yaml_char_t *tmp_3;
+ tmp_3 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_3 = (unsigned char)'\n';
+ yaml_char_t tmp_8 = *tmp_3;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_CRLN_BREAK) {
+ yaml_char_t *tmp_4;
+ yaml_char_t *tmp_5;
+ tmp_4 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_4 = (unsigned char)'\r';
+ tmp_5 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_5 = (unsigned char)'\n';
+ yaml_char_t tmp_6 = *tmp_5;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->indention = 1;
+ emitter->whitespace = 1;
+ while (string.pointer != string.end)
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\r')) goto _LOR_3;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n')) goto _LOR_3;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_3;
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_3;
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ _LAND_2: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\251')) {
+ _LOR_3:
+ {
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_1;
+ else {
+ int tmp_6_0;
+ tmp_6_0 = yaml_emitter_flush(emitter);
+ if (tmp_6_0) {
+ int tmp_33_1;
+ _LOR_1: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n')) {
+ int tmp_12_0;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_0;
+ else {
+ int tmp_7;
+ tmp_7 = yaml_emitter_flush(emitter);
+ if (tmp_7) {
+ _LOR_0: ;
+ if (emitter->line_break == (unsigned int)YAML_CR_BREAK) {
+ yaml_char_t *tmp_8_0;
+ tmp_8_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_8_0 = (unsigned char)'\r';
+ yaml_char_t tmp_16 = *tmp_8_0;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_LN_BREAK) {
+ yaml_char_t *tmp_9;
+ tmp_9 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_9 = (unsigned char)'\n';
+ yaml_char_t tmp_14 = *tmp_9;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_CRLN_BREAK) {
+ yaml_char_t *tmp_10_0;
+ yaml_char_t *tmp_11;
+ tmp_10_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_10_0 = (unsigned char)'\r';
+ tmp_11 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_11 = (unsigned char)'\n';
+ yaml_char_t tmp_12 = *tmp_11;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ tmp_12_0 = 1;
+ }
+ else tmp_12_0 = 0;
+ }
+ (string.pointer) ++;
+ tmp_33_1 = 1;
+ }
+ else {
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_13;
+ yaml_char_t *tmp_14_0;
+ tmp_13 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_14_0 = string.pointer;
+ (string.pointer) ++;
+ *tmp_13 = *tmp_14_0;
+ yaml_char_t tmp_39 = *tmp_13;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_15;
+ yaml_char_t *tmp_16_0;
+ yaml_char_t *tmp_17;
+ yaml_char_t *tmp_18;
+ tmp_15 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_16_0 = string.pointer;
+ (string.pointer) ++;
+ *tmp_15 = *tmp_16_0;
+ tmp_17 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_18 = string.pointer;
+ (string.pointer) ++;
+ *tmp_17 = *tmp_18;
+ yaml_char_t tmp_37 = *tmp_17;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_19;
+ yaml_char_t *tmp_20;
+ yaml_char_t *tmp_21;
+ yaml_char_t *tmp_22;
+ yaml_char_t *tmp_23;
+ yaml_char_t *tmp_24;
+ tmp_19 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_20 = string.pointer;
+ (string.pointer) ++;
+ *tmp_19 = *tmp_20;
+ tmp_21 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_22 = string.pointer;
+ (string.pointer) ++;
+ *tmp_21 = *tmp_22;
+ tmp_23 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_24 = string.pointer;
+ (string.pointer) ++;
+ *tmp_23 = *tmp_24;
+ yaml_char_t tmp_35 = *tmp_23;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_25;
+ yaml_char_t *tmp_26;
+ yaml_char_t *tmp_27;
+ yaml_char_t *tmp_28;
+ yaml_char_t *tmp_29;
+ yaml_char_t *tmp_30;
+ yaml_char_t *tmp_31;
+ yaml_char_t *tmp_32;
+ tmp_25 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_26 = string.pointer;
+ (string.pointer) ++;
+ *tmp_25 = *tmp_26;
+ tmp_27 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_28 = string.pointer;
+ (string.pointer) ++;
+ *tmp_27 = *tmp_28;
+ tmp_29 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_30 = string.pointer;
+ (string.pointer) ++;
+ *tmp_29 = *tmp_30;
+ tmp_31 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_32 = string.pointer;
+ (string.pointer) ++;
+ *tmp_31 = *tmp_32;
+ yaml_char_t tmp_33 = *tmp_31;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ tmp_33_1 = 1;
+ }
+ if (! tmp_33_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->indention = 1;
+ breaks = 1;
+ }
+ }
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0:
+ {
+ if (breaks) {
+ int tmp_34;
+ tmp_34 = yaml_emitter_write_indent(emitter);
+ if (! tmp_34) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_2;
+ else {
+ int tmp_35_1;
+ tmp_35_1 = yaml_emitter_flush(emitter);
+ if (tmp_35_1) {
+ _LOR_2: ;
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_36;
+ yaml_char_t *tmp_37_1;
+ tmp_36 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_37_1 = string.pointer;
+ (string.pointer) ++;
+ *tmp_36 = *tmp_37_1;
+ yaml_char_t tmp_62 = *tmp_36;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_38;
+ yaml_char_t *tmp_39_1;
+ yaml_char_t *tmp_40;
+ yaml_char_t *tmp_41;
+ tmp_38 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_39_1 = string.pointer;
+ (string.pointer) ++;
+ *tmp_38 = *tmp_39_1;
+ tmp_40 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_41 = string.pointer;
+ (string.pointer) ++;
+ *tmp_40 = *tmp_41;
+ yaml_char_t tmp_60 = *tmp_40;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_42;
+ yaml_char_t *tmp_43;
+ yaml_char_t *tmp_44;
+ yaml_char_t *tmp_45;
+ yaml_char_t *tmp_46;
+ yaml_char_t *tmp_47;
+ tmp_42 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_43 = string.pointer;
+ (string.pointer) ++;
+ *tmp_42 = *tmp_43;
+ tmp_44 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_45 = string.pointer;
+ (string.pointer) ++;
+ *tmp_44 = *tmp_45;
+ tmp_46 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_47 = string.pointer;
+ (string.pointer) ++;
+ *tmp_46 = *tmp_47;
+ yaml_char_t tmp_58 = *tmp_46;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_48;
+ yaml_char_t *tmp_49;
+ yaml_char_t *tmp_50;
+ yaml_char_t *tmp_51;
+ yaml_char_t *tmp_52;
+ yaml_char_t *tmp_53;
+ yaml_char_t *tmp_54;
+ yaml_char_t *tmp_55;
+ tmp_48 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_49 = string.pointer;
+ (string.pointer) ++;
+ *tmp_48 = *tmp_49;
+ tmp_50 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_51 = string.pointer;
+ (string.pointer) ++;
+ *tmp_50 = *tmp_51;
+ tmp_52 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_53 = string.pointer;
+ (string.pointer) ++;
+ *tmp_52 = *tmp_53;
+ tmp_54 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_55 = string.pointer;
+ (string.pointer) ++;
+ *tmp_54 = *tmp_55;
+ yaml_char_t tmp_56 = *tmp_54;
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->indention = 0;
+ breaks = 0;
+ }
+ }
+ }
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length)
+{
+ int __retres;
+ yaml_string_t string;
+ int tmp;
+ int tmp_0;
+ int breaks = 1;
+ int leading_spaces = 1;
+ string.start = value;
+ string.end = value + length;
+ string.pointer = value;
+ tmp = yaml_emitter_write_indicator(emitter,">",1,0,0);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_0 = yaml_emitter_write_block_scalar_hints(emitter,string);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end) goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_emitter_flush(emitter);
+ if (tmp_1) {
+ _LOR: ;
+ if (emitter->line_break == (unsigned int)YAML_CR_BREAK) {
+ yaml_char_t *tmp_2;
+ tmp_2 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_2 = (unsigned char)'\r';
+ yaml_char_t tmp_10 = *tmp_2;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_LN_BREAK) {
+ yaml_char_t *tmp_3;
+ tmp_3 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_3 = (unsigned char)'\n';
+ yaml_char_t tmp_8 = *tmp_3;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_CRLN_BREAK) {
+ yaml_char_t *tmp_4;
+ yaml_char_t *tmp_5;
+ tmp_4 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_4 = (unsigned char)'\r';
+ tmp_5 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_5 = (unsigned char)'\n';
+ yaml_char_t tmp_6 = *tmp_5;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->indention = 1;
+ emitter->whitespace = 1;
+ while (string.pointer != string.end)
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\r')) goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n')) goto _LOR_4;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_4;
+ else goto _LAND_14;
+ }
+ else {
+ _LAND_14: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_4;
+ else goto _LAND_13;
+ }
+ else goto _LAND_13;
+ }
+ else {
+ _LAND_13: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(string.pointer + (0 + 2)) == (int)((unsigned char)'\251')) {
+ _LOR_4:
+ {
+ if (! breaks)
+ if (! leading_spaces)
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n')) {
+ int k = 0;
+ while (1) {
+ if (! ((int)*(string.pointer + k) == (int)((unsigned char)'\r')))
+ if (! ((int)*(string.pointer + k) == (int)((unsigned char)'\n')))
+ if ((int)*(string.pointer + k) == (int)((unsigned char)'\302')) {
+ if (! ((int)*(string.pointer + (k + 1)) == (int)((unsigned char)'\205')))
+ goto _LAND_1;
+ }
+ else {
+ _LAND_1: ;
+ if ((int)*(string.pointer + k) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (k + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(string.pointer + (k + 2)) == (int)((unsigned char)'\250')))
+ goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(string.pointer + k) == (int)((unsigned char)'\342'))
+ if ((int)*(string.pointer + (k + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(string.pointer + (
+ k + 2)) == (int)((unsigned char)'\251')))
+ break;
+ }
+ else break;
+ else break;
+ }
+ }
+ {
+ int tmp_9;
+ if (((int)*(string.pointer + k) & 0x80) == 0x00)
+ tmp_9 = 1;
+ else {
+ int tmp_8_1;
+ if (((int)*(string.pointer + k) & 0xE0) == 0xC0)
+ tmp_8_1 = 2;
+ else {
+ int tmp_7;
+ if (((int)*(string.pointer + k) & 0xF0) == 0xE0)
+ tmp_7 = 3;
+ else {
+ int tmp_6_1;
+ if (((int)*(string.pointer + k) & 0xF8) == 0xF0)
+ tmp_6_1 = 4;
+ else tmp_6_1 = 0;
+ tmp_7 = tmp_6_1;
+ }
+ tmp_8_1 = tmp_7;
+ }
+ tmp_9 = tmp_8_1;
+ }
+ k += tmp_9;
+ }
+ }
+ if (! ((int)*(string.pointer + k) == (int)((unsigned char)' ')))
+ if (! ((int)*(string.pointer + k) == (int)((unsigned char)'\t')))
+ if (! ((int)*(string.pointer + k) == (int)((unsigned char)'\r')))
+ if (! ((int)*(string.pointer + k) == (int)((unsigned char)'\n')))
+ if ((int)*(string.pointer + k) == (int)((unsigned char)'\302')) {
+ if (! ((int)*(string.pointer + (k + 1)) == (int)((unsigned char)'\205')))
+ goto _LAND_6;
+ }
+ else {
+ _LAND_6: ;
+ if ((int)*(string.pointer + k) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (k + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(string.pointer + (
+ k + 2)) == (int)((unsigned char)'\250')))
+ goto _LAND_5;
+ }
+ else goto _LAND_5;
+ }
+ else {
+ _LAND_5: ;
+ if ((int)*(string.pointer + k) == (int)((unsigned char)'\342')) {
+ if ((int)*(string.pointer + (k + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(string.pointer + (
+ k + 2)) == (int)((unsigned char)'\251')))
+ goto _LAND_3;
+ }
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if (! ((int)*(string.pointer + k) == (int)((unsigned char)'\000')))
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_0;
+ else {
+ int tmp_10_1;
+ tmp_10_1 = yaml_emitter_flush
+ (emitter);
+ if (tmp_10_1) {
+ _LOR_0: ;
+ if (emitter->line_break == (unsigned int)YAML_CR_BREAK) {
+ yaml_char_t *tmp_11;
+ tmp_11 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_11 = (unsigned char)'\r';
+ yaml_char_t tmp_19 = *tmp_11;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_LN_BREAK) {
+ yaml_char_t *tmp_12;
+ tmp_12 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_12 = (unsigned char)'\n';
+ yaml_char_t tmp_17 =
+ *tmp_12;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_CRLN_BREAK) {
+ yaml_char_t *tmp_13;
+ yaml_char_t *tmp_14;
+ tmp_13 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_13 = (unsigned char)'\r';
+ tmp_14 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_14 = (unsigned char)'\n';
+ yaml_char_t tmp_15 =
+ *tmp_14;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ }
+ }
+ }
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_2;
+ else {
+ int tmp_15_0;
+ tmp_15_0 = yaml_emitter_flush(emitter);
+ if (tmp_15_0) {
+ int tmp_42_1;
+ _LOR_2: ;
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\n')) {
+ int tmp_21_0;
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_1;
+ else {
+ int tmp_16;
+ tmp_16 = yaml_emitter_flush(emitter);
+ if (tmp_16) {
+ _LOR_1: ;
+ if (emitter->line_break == (unsigned int)YAML_CR_BREAK) {
+ yaml_char_t *tmp_17_0;
+ tmp_17_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_17_0 = (unsigned char)'\r';
+ yaml_char_t tmp_25 = *tmp_17_0;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_LN_BREAK) {
+ yaml_char_t *tmp_18;
+ tmp_18 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_18 = (unsigned char)'\n';
+ yaml_char_t tmp_23 = *tmp_18;
+ }
+ else
+ if (emitter->line_break == (unsigned int)YAML_CRLN_BREAK) {
+ yaml_char_t *tmp_19_0;
+ yaml_char_t *tmp_20;
+ tmp_19_0 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_19_0 = (unsigned char)'\r';
+ tmp_20 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ *tmp_20 = (unsigned char)'\n';
+ yaml_char_t tmp_21 = *tmp_20;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ tmp_21_0 = 1;
+ }
+ else tmp_21_0 = 0;
+ }
+ (string.pointer) ++;
+ tmp_42_1 = 1;
+ }
+ else {
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_22;
+ yaml_char_t *tmp_23_0;
+ tmp_22 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_23_0 = string.pointer;
+ (string.pointer) ++;
+ *tmp_22 = *tmp_23_0;
+ yaml_char_t tmp_48 = *tmp_22;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_24;
+ yaml_char_t *tmp_25_0;
+ yaml_char_t *tmp_26;
+ yaml_char_t *tmp_27;
+ tmp_24 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_25_0 = string.pointer;
+ (string.pointer) ++;
+ *tmp_24 = *tmp_25_0;
+ tmp_26 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_27 = string.pointer;
+ (string.pointer) ++;
+ *tmp_26 = *tmp_27;
+ yaml_char_t tmp_46 = *tmp_26;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_28;
+ yaml_char_t *tmp_29;
+ yaml_char_t *tmp_30;
+ yaml_char_t *tmp_31;
+ yaml_char_t *tmp_32;
+ yaml_char_t *tmp_33;
+ tmp_28 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_29 = string.pointer;
+ (string.pointer) ++;
+ *tmp_28 = *tmp_29;
+ tmp_30 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_31 = string.pointer;
+ (string.pointer) ++;
+ *tmp_30 = *tmp_31;
+ tmp_32 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_33 = string.pointer;
+ (string.pointer) ++;
+ *tmp_32 = *tmp_33;
+ yaml_char_t tmp_44 = *tmp_32;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_34;
+ yaml_char_t *tmp_35;
+ yaml_char_t *tmp_36;
+ yaml_char_t *tmp_37;
+ yaml_char_t *tmp_38;
+ yaml_char_t *tmp_39;
+ yaml_char_t *tmp_40;
+ yaml_char_t *tmp_41;
+ tmp_34 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_35 = string.pointer;
+ (string.pointer) ++;
+ *tmp_34 = *tmp_35;
+ tmp_36 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_37 = string.pointer;
+ (string.pointer) ++;
+ *tmp_36 = *tmp_37;
+ tmp_38 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_39 = string.pointer;
+ (string.pointer) ++;
+ *tmp_38 = *tmp_39;
+ tmp_40 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_41 = string.pointer;
+ (string.pointer) ++;
+ *tmp_40 = *tmp_41;
+ yaml_char_t tmp_42 = *tmp_40;
+ }
+ emitter->column = 0;
+ (emitter->line) ++;
+ tmp_42_1 = 1;
+ }
+ if (! tmp_42_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->indention = 1;
+ breaks = 1;
+ }
+ }
+ else goto _LAND_11;
+ }
+ else goto _LAND_11;
+ }
+ else {
+ _LAND_11:
+ {
+ if (breaks) {
+ int tmp_43;
+ int tmp_44_1;
+ tmp_43 = yaml_emitter_write_indent(emitter);
+ if (! tmp_43) {
+ __retres = 0;
+ goto return_label;
+ }
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)' '))
+ tmp_44_1 = 1;
+ else
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)'\t'))
+ tmp_44_1 = 1;
+ else tmp_44_1 = 0;
+ leading_spaces = tmp_44_1;
+ }
+ if (! breaks) {
+ if ((int)*(string.pointer + 0) == (int)((unsigned char)' ')) {
+ if (! ((int)*(string.pointer + 1) == (int)((unsigned char)' '))) {
+ if (emitter->column > emitter->best_width) {
+ int tmp_45;
+ int tmp_49;
+ tmp_45 = yaml_emitter_write_indent(emitter);
+ if (! tmp_45) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (((int)*(string.pointer + 0) & 0x80) == 0x00)
+ tmp_49 = 1;
+ else {
+ int tmp_48_0;
+ if (((int)*(string.pointer + 0) & 0xE0) == 0xC0)
+ tmp_48_0 = 2;
+ else {
+ int tmp_47;
+ if (((int)*(string.pointer + 0) & 0xF0) == 0xE0)
+ tmp_47 = 3;
+ else {
+ int tmp_46_0;
+ if (((int)*(string.pointer + 0) & 0xF8) == 0xF0)
+ tmp_46_0 = 4;
+ else tmp_46_0 = 0;
+ tmp_47 = tmp_46_0;
+ }
+ tmp_48_0 = tmp_47;
+ }
+ tmp_49 = tmp_48_0;
+ }
+ string.pointer += tmp_49;
+ }
+ else goto _LAND_9;
+ }
+ else goto _LAND_9;
+ }
+ else goto _LAND_9;
+ }
+ else
+ _LAND_9:
+ if (emitter->buffer.pointer + 5 < emitter->buffer.end)
+ goto _LOR_3;
+ else {
+ int tmp_50;
+ tmp_50 = yaml_emitter_flush(emitter);
+ if (tmp_50) {
+ _LOR_3: ;
+ if (((int)*(string.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_51;
+ yaml_char_t *tmp_52;
+ tmp_51 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_52 = string.pointer;
+ (string.pointer) ++;
+ *tmp_51 = *tmp_52;
+ yaml_char_t tmp_77 = *tmp_51;
+ }
+ else
+ if (((int)*(string.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_53;
+ yaml_char_t *tmp_54;
+ yaml_char_t *tmp_55;
+ yaml_char_t *tmp_56;
+ tmp_53 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_54 = string.pointer;
+ (string.pointer) ++;
+ *tmp_53 = *tmp_54;
+ tmp_55 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_56 = string.pointer;
+ (string.pointer) ++;
+ *tmp_55 = *tmp_56;
+ yaml_char_t tmp_75 = *tmp_55;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_57;
+ yaml_char_t *tmp_58;
+ yaml_char_t *tmp_59;
+ yaml_char_t *tmp_60;
+ yaml_char_t *tmp_61;
+ yaml_char_t *tmp_62;
+ tmp_57 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_58 = string.pointer;
+ (string.pointer) ++;
+ *tmp_57 = *tmp_58;
+ tmp_59 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_60 = string.pointer;
+ (string.pointer) ++;
+ *tmp_59 = *tmp_60;
+ tmp_61 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_62 = string.pointer;
+ (string.pointer) ++;
+ *tmp_61 = *tmp_62;
+ yaml_char_t tmp_73 = *tmp_61;
+ }
+ else
+ if (((int)*(string.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_63;
+ yaml_char_t *tmp_64;
+ yaml_char_t *tmp_65;
+ yaml_char_t *tmp_66;
+ yaml_char_t *tmp_67;
+ yaml_char_t *tmp_68;
+ yaml_char_t *tmp_69;
+ yaml_char_t *tmp_70;
+ tmp_63 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_64 = string.pointer;
+ (string.pointer) ++;
+ *tmp_63 = *tmp_64;
+ tmp_65 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_66 = string.pointer;
+ (string.pointer) ++;
+ *tmp_65 = *tmp_66;
+ tmp_67 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_68 = string.pointer;
+ (string.pointer) ++;
+ *tmp_67 = *tmp_68;
+ tmp_69 = emitter->buffer.pointer;
+ (emitter->buffer.pointer) ++;
+ tmp_70 = string.pointer;
+ (string.pointer) ++;
+ *tmp_69 = *tmp_70;
+ yaml_char_t tmp_71 = *tmp_69;
+ }
+ (emitter->column) ++;
+ }
+ else {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ emitter->indention = 0;
+ breaks = 0;
+ }
+ }
+ }
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_set_composer_error(yaml_parser_t *parser,
+ char const *problem,
+ yaml_mark_t problem_mark);
+
+static int yaml_parser_set_composer_error_context(yaml_parser_t *parser,
+ char const *context,
+ yaml_mark_t context_mark,
+ char const *problem,
+ yaml_mark_t problem_mark);
+
+static int yaml_parser_register_anchor(yaml_parser_t *parser, int index_0,
+ yaml_char_t *anchor);
+
+static void yaml_parser_delete_aliases(yaml_parser_t *parser);
+
+static int yaml_parser_load_nodes(yaml_parser_t *parser,
+ struct loader_ctx *ctx);
+
+static int yaml_parser_load_document(yaml_parser_t *parser,
+ yaml_event_t *event);
+
+static int yaml_parser_load_alias(yaml_parser_t *parser, yaml_event_t *event,
+ struct loader_ctx *ctx);
+
+static int yaml_parser_load_scalar(yaml_parser_t *parser,
+ yaml_event_t *event,
+ struct loader_ctx *ctx);
+
+static int yaml_parser_load_sequence(yaml_parser_t *parser,
+ yaml_event_t *event,
+ struct loader_ctx *ctx);
+
+static int yaml_parser_load_mapping(yaml_parser_t *parser,
+ yaml_event_t *event,
+ struct loader_ctx *ctx);
+
+static int yaml_parser_load_sequence_end(yaml_parser_t *parser,
+ yaml_event_t *event,
+ struct loader_ctx *ctx);
+
+static int yaml_parser_load_mapping_end(yaml_parser_t *parser,
+ yaml_event_t *event,
+ struct loader_ctx *ctx);
+
+int yaml_parser_load(yaml_parser_t *parser, yaml_document_t *document)
+{
+ int __retres;
+ yaml_event_t event;
+ int tmp_1;
+ yaml_node_t *tmp;
+ int tmp_3;
+ int tmp_6;
+ yaml_alias_data_t *tmp_4;
+ int tmp_7;
+ __FC_assert(parser != (yaml_parser_t *)0,"src/loader.c",91,"parser");
+ __FC_assert(document != (yaml_document_t *)0,"src/loader.c",92,"document");
+ memset((void *)document,0,sizeof(yaml_document_t));
+ tmp = (yaml_node_t *)yaml_malloc((unsigned long)16 * sizeof(*(document->nodes.start)));
+ document->nodes.start = tmp;
+ if (tmp) {
+ document->nodes.top = document->nodes.start;
+ document->nodes.end = document->nodes.start + 16;
+ tmp_1 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_1 = 0;
+ }
+ if (! tmp_1) goto error;
+ if (! parser->stream_start_produced) {
+ int tmp_2;
+ tmp_2 = yaml_parser_parse(parser,& event);
+ if (! tmp_2) goto error;
+ __FC_assert((event.type == (unsigned int)YAML_STREAM_START_EVENT) != 0,
+ "src/loader.c",100,"event.type == YAML_STREAM_START_EVENT");
+ }
+ if (parser->stream_end_produced) {
+ __retres = 1;
+ goto return_label;
+ }
+ tmp_3 = yaml_parser_parse(parser,& event);
+ if (! tmp_3) goto error;
+ if (event.type == (unsigned int)YAML_STREAM_END_EVENT) {
+ __retres = 1;
+ goto return_label;
+ }
+ tmp_4 = (yaml_alias_data_t *)yaml_malloc((unsigned long)16 * sizeof(*(parser->aliases.start)));
+ parser->aliases.start = tmp_4;
+ if (tmp_4) {
+ parser->aliases.top = parser->aliases.start;
+ parser->aliases.end = parser->aliases.start + 16;
+ tmp_6 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_6 = 0;
+ }
+ if (! tmp_6) goto error;
+ parser->document = document;
+ tmp_7 = yaml_parser_load_document(parser,& event);
+ if (! tmp_7) goto error;
+ yaml_parser_delete_aliases(parser);
+ parser->document = (yaml_document_t *)0;
+ __retres = 1;
+ goto return_label;
+ error: yaml_parser_delete_aliases(parser);
+ yaml_document_delete(document);
+ parser->document = (yaml_document_t *)0;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_set_composer_error(yaml_parser_t *parser,
+ char const *problem,
+ yaml_mark_t problem_mark)
+{
+ int __retres;
+ parser->error = YAML_COMPOSER_ERROR;
+ parser->problem = problem;
+ parser->problem_mark = problem_mark;
+ __retres = 0;
+ return __retres;
+}
+
+static int yaml_parser_set_composer_error_context(yaml_parser_t *parser,
+ char const *context,
+ yaml_mark_t context_mark,
+ char const *problem,
+ yaml_mark_t problem_mark)
+{
+ int __retres;
+ parser->error = YAML_COMPOSER_ERROR;
+ parser->context = context;
+ parser->context_mark = context_mark;
+ parser->problem = problem;
+ parser->problem_mark = problem_mark;
+ __retres = 0;
+ return __retres;
+}
+
+static void yaml_parser_delete_aliases(yaml_parser_t *parser)
+{
+ yaml_alias_data_t *tmp_0;
+ yaml_alias_data_t *tmp;
+ while (! (parser->aliases.start == parser->aliases.top)) {
+ (parser->aliases.top) --;
+ ;
+ yaml_free((void *)(parser->aliases.top)->anchor);
+ }
+ yaml_free((void *)parser->aliases.start);
+ tmp_0 = (yaml_alias_data_t *)0;
+ parser->aliases.end = tmp_0;
+ tmp = tmp_0;
+ parser->aliases.top = tmp;
+ parser->aliases.start = tmp;
+ return;
+}
+
+static int yaml_parser_load_document(yaml_parser_t *parser,
+ yaml_event_t *event)
+{
+ int __retres;
+ int tmp_0;
+ int tmp_1;
+ struct loader_ctx ctx =
+ {.start = (int *)0, .end = (int *)0, .top = (int *)0};
+ __FC_assert((event->type == (unsigned int)YAML_DOCUMENT_START_EVENT) != 0,
+ "src/loader.c",189,"event->type == YAML_DOCUMENT_START_EVENT");
+ (parser->document)->version_directive = event->data.document_start.version_directive;
+ (parser->document)->tag_directives.start = event->data.document_start.tag_directives.start;
+ (parser->document)->tag_directives.end = event->data.document_start.tag_directives.end;
+ (parser->document)->start_implicit = event->data.document_start.implicit;
+ (parser->document)->start_mark = event->start_mark;
+ ctx.start = (int *)yaml_malloc((unsigned long)16 * sizeof(*(ctx.start)));
+ if (ctx.start) {
+ ctx.top = ctx.start;
+ ctx.end = ctx.start + 16;
+ tmp_0 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_0 = 0;
+ }
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_1 = yaml_parser_load_nodes(parser,& ctx);
+ if (! tmp_1) {
+ yaml_free((void *)ctx.start);
+ ctx.end = (int *)0;
+ ctx.top = ctx.end;
+ ctx.start = ctx.top;
+ __retres = 0;
+ goto return_label;
+ }
+ yaml_free((void *)ctx.start);
+ ctx.end = (int *)0;
+ ctx.top = ctx.end;
+ ctx.start = ctx.top;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_load_nodes(yaml_parser_t *parser,
+ struct loader_ctx *ctx)
+{
+ int __retres;
+ yaml_event_t event;
+ while (1) {
+ {
+ int tmp;
+ tmp = yaml_parser_parse(parser,& event);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ switch (event.type) {
+ int tmp_0;
+ int tmp_1;
+ int tmp_2;
+ int tmp_3;
+ int tmp_4;
+ int tmp_5;
+ case (yaml_event_type_t)YAML_ALIAS_EVENT:
+ tmp_0 = yaml_parser_load_alias(parser,& event,ctx);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ break;
+ case (yaml_event_type_t)YAML_SCALAR_EVENT:
+ tmp_1 = yaml_parser_load_scalar(parser,& event,ctx);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ break;
+ case (yaml_event_type_t)YAML_SEQUENCE_START_EVENT:
+ tmp_2 = yaml_parser_load_sequence(parser,& event,ctx);
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ break;
+ case (yaml_event_type_t)YAML_SEQUENCE_END_EVENT:
+ tmp_3 = yaml_parser_load_sequence_end(parser,& event,ctx);
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ break;
+ case (yaml_event_type_t)YAML_MAPPING_START_EVENT:
+ tmp_4 = yaml_parser_load_mapping(parser,& event,ctx);
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ break;
+ case (yaml_event_type_t)YAML_MAPPING_END_EVENT:
+ tmp_5 = yaml_parser_load_mapping_end(parser,& event,ctx);
+ if (! tmp_5) {
+ __retres = 0;
+ goto return_label;
+ }
+ break;
+ default: __FC_assert(0 != 0,"src/loader.c",246,"0");
+ __retres = 0;
+ goto return_label;
+ case (yaml_event_type_t)YAML_DOCUMENT_END_EVENT: break;
+ }
+ }
+ if (! (event.type != (unsigned int)YAML_DOCUMENT_END_EVENT)) break;
+ }
+ (parser->document)->end_implicit = event.data.document_end.implicit;
+ (parser->document)->end_mark = event.end_mark;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_register_anchor(yaml_parser_t *parser, int index_0,
+ yaml_char_t *anchor)
+{
+ int __retres;
+ yaml_alias_data_t data;
+ yaml_alias_data_t *alias_data;
+ int tmp_3;
+ if (! anchor) {
+ __retres = 1;
+ goto return_label;
+ }
+ data.anchor = anchor;
+ data.index = index_0;
+ data.mark = ((parser->document)->nodes.start + (index_0 - 1))->start_mark;
+ alias_data = parser->aliases.start;
+ while (alias_data != parser->aliases.top) {
+ {
+ int tmp_0;
+ tmp_0 = strcmp((char const *)alias_data->anchor,(char const *)anchor);
+ if (tmp_0 == 0) {
+ int tmp;
+ yaml_free((void *)anchor);
+ tmp = yaml_parser_set_composer_error_context(parser,
+ "found duplicate anchor; first occurrence",
+ alias_data->mark,
+ "second occurrence",
+ data.mark);
+ __retres = tmp;
+ goto return_label;
+ }
+ }
+ alias_data ++;
+ }
+ if (parser->aliases.top != parser->aliases.end) goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_stack_extend((void **)(& parser->aliases.start),
+ (void **)(& parser->aliases.top),
+ (void **)(& parser->aliases.end));
+ if (tmp_1) {
+ yaml_alias_data_t *tmp_2;
+ _LOR: tmp_2 = parser->aliases.top;
+ (parser->aliases.top) ++;
+ *tmp_2 = data;
+ tmp_3 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) {
+ yaml_free((void *)anchor);
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_load_node_add(yaml_parser_t *parser,
+ struct loader_ctx *ctx, int index_0)
+{
+ int __retres;
+ struct yaml_node_s *parent;
+ int parent_index;
+ if (ctx->start == ctx->top) {
+ __retres = 1;
+ goto return_label;
+ }
+ parent_index = *(ctx->top - 1);
+ parent = (parser->document)->nodes.start + (parent_index - 1);
+ switch (parent->type) {
+ int tmp;
+ int tmp_2;
+ case (yaml_node_type_t)YAML_SEQUENCE_NODE: ;
+ if (parent->data.sequence.items.top - parent->data.sequence.items.start < (long)(
+ 2147483647 - 1)) tmp = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp = 0;
+ }
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (parent->data.sequence.items.top != parent->data.sequence.items.end)
+ goto _LOR;
+ else {
+ int tmp_0;
+ tmp_0 = yaml_stack_extend((void **)(& parent->data.sequence.items.start),
+ (void **)(& parent->data.sequence.items.top),
+ (void **)(& parent->data.sequence.items.end));
+ if (tmp_0) {
+ yaml_node_item_t *tmp_1;
+ _LOR: tmp_1 = parent->data.sequence.items.top;
+ (parent->data.sequence.items.top) ++;
+ *tmp_1 = index_0;
+ tmp_2 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ }
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ break;
+ case (yaml_node_type_t)YAML_MAPPING_NODE:
+ {
+ yaml_node_pair_t pair;
+ int tmp_3;
+ int tmp_6;
+ if (! (parent->data.mapping.pairs.start == parent->data.mapping.pairs.top)) {
+ yaml_node_pair_t *p = parent->data.mapping.pairs.top - 1;
+ if (p->key != 0)
+ if (p->value == 0) {
+ p->value = index_0;
+ break;
+ }
+ }
+ pair.key = index_0;
+ pair.value = 0;
+ if (parent->data.mapping.pairs.top - parent->data.mapping.pairs.start < (long)(
+ 2147483647 - 1)) tmp_3 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (parent->data.mapping.pairs.top != parent->data.mapping.pairs.end)
+ goto _LOR_0;
+ else {
+ int tmp_4;
+ tmp_4 = yaml_stack_extend((void **)(& parent->data.mapping.pairs.start),
+ (void **)(& parent->data.mapping.pairs.top),
+ (void **)(& parent->data.mapping.pairs.end));
+ if (tmp_4) {
+ yaml_node_pair_t *tmp_5;
+ _LOR_0: tmp_5 = parent->data.mapping.pairs.top;
+ (parent->data.mapping.pairs.top) ++;
+ *tmp_5 = pair;
+ tmp_6 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_6 = 0;
+ }
+ }
+ if (! tmp_6) {
+ __retres = 0;
+ goto return_label;
+ }
+ break;
+ }
+ default: __FC_assert(0 != 0,"src/loader.c",340,"0");
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_load_alias(yaml_parser_t *parser, yaml_event_t *event,
+ struct loader_ctx *ctx)
+{
+ int __retres;
+ yaml_alias_data_t *alias_data;
+ int tmp_1;
+ yaml_char_t *anchor = event->data.alias.anchor;
+ alias_data = parser->aliases.start;
+ while (alias_data != parser->aliases.top) {
+ {
+ int tmp_0;
+ tmp_0 = strcmp((char const *)alias_data->anchor,(char const *)anchor);
+ if (tmp_0 == 0) {
+ int tmp;
+ yaml_free((void *)anchor);
+ tmp = yaml_parser_load_node_add(parser,ctx,alias_data->index);
+ __retres = tmp;
+ goto return_label;
+ }
+ }
+ alias_data ++;
+ }
+ yaml_free((void *)anchor);
+ tmp_1 = yaml_parser_set_composer_error(parser,"found undefined alias",
+ event->start_mark);
+ __retres = tmp_1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_load_scalar(yaml_parser_t *parser,
+ yaml_event_t *event,
+ struct loader_ctx *ctx)
+{
+ int __retres;
+ yaml_node_t node;
+ int index_0;
+ int tmp;
+ int tmp_3;
+ int tmp_4;
+ int tmp_5;
+ yaml_char_t *tag = event->data.scalar.tag;
+ if ((parser->document)->nodes.top - (parser->document)->nodes.start < (long)(
+ 2147483647 - 1)) tmp = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp = 0;
+ }
+ if (! tmp) goto error;
+ if (! tag) goto _LOR;
+ else {
+ int tmp_0;
+ tmp_0 = strcmp((char const *)tag,"!");
+ if (tmp_0 == 0) {
+ _LOR:
+ {
+ yaml_free((void *)tag);
+ tag = yaml_strdup((yaml_char_t const *)"tag:yaml.org,2002:str");
+ if (! tag) goto error;
+ }
+ }
+ }
+ memset((void *)(& node),0,sizeof(yaml_node_t));
+ node.type = YAML_SCALAR_NODE;
+ node.tag = tag;
+ node.start_mark = event->start_mark;
+ node.end_mark = event->end_mark;
+ node.data.scalar.value = event->data.scalar.value;
+ node.data.scalar.length = event->data.scalar.length;
+ node.data.scalar.style = event->data.scalar.style;
+ if ((parser->document)->nodes.top != (parser->document)->nodes.end)
+ goto _LOR_0;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_stack_extend((void **)(& (parser->document)->nodes.start),
+ (void **)(& (parser->document)->nodes.top),
+ (void **)(& (parser->document)->nodes.end));
+ if (tmp_1) {
+ yaml_node_t *tmp_2;
+ _LOR_0: tmp_2 = (parser->document)->nodes.top;
+ ((parser->document)->nodes.top) ++;
+ *tmp_2 = node;
+ tmp_3 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) goto error;
+ index_0 = (int)((parser->document)->nodes.top - (parser->document)->nodes.start);
+ tmp_4 = yaml_parser_register_anchor(parser,index_0,
+ event->data.scalar.anchor);
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_5 = yaml_parser_load_node_add(parser,ctx,index_0);
+ __retres = tmp_5;
+ goto return_label;
+ error: yaml_free((void *)tag);
+ yaml_free((void *)event->data.scalar.anchor);
+ yaml_free((void *)event->data.scalar.value);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_load_sequence(yaml_parser_t *parser,
+ yaml_event_t *event,
+ struct loader_ctx *ctx)
+{
+ int __retres;
+ yaml_node_t node;
+ int index_0;
+ int tmp;
+ int tmp_2;
+ int tmp_5;
+ int tmp_6;
+ int tmp_7;
+ int tmp_8;
+ int tmp_11;
+ struct __anonstruct_items_49 items =
+ {.start = (yaml_node_item_t *)0,
+ .end = (yaml_node_item_t *)0,
+ .top = (yaml_node_item_t *)0};
+ yaml_char_t *tag = event->data.sequence_start.tag;
+ if ((parser->document)->nodes.top - (parser->document)->nodes.start < (long)(
+ 2147483647 - 1)) tmp = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp = 0;
+ }
+ if (! tmp) goto error;
+ if (! tag) goto _LOR;
+ else {
+ int tmp_0;
+ tmp_0 = strcmp((char const *)tag,"!");
+ if (tmp_0 == 0) {
+ _LOR:
+ {
+ yaml_free((void *)tag);
+ tag = yaml_strdup((yaml_char_t const *)"tag:yaml.org,2002:seq");
+ if (! tag) goto error;
+ }
+ }
+ }
+ items.start = (yaml_node_item_t *)yaml_malloc((unsigned long)16 * sizeof(*(items.start)));
+ if (items.start) {
+ items.top = items.start;
+ items.end = items.start + 16;
+ tmp_2 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ if (! tmp_2) goto error;
+ memset((void *)(& node),0,sizeof(yaml_node_t));
+ node.type = YAML_SEQUENCE_NODE;
+ node.tag = tag;
+ node.start_mark = event->start_mark;
+ node.end_mark = event->end_mark;
+ node.data.sequence.items.start = items.start;
+ node.data.sequence.items.end = items.end;
+ node.data.sequence.items.top = items.start;
+ node.data.sequence.style = event->data.sequence_start.style;
+ if ((parser->document)->nodes.top != (parser->document)->nodes.end)
+ goto _LOR_0;
+ else {
+ int tmp_3;
+ tmp_3 = yaml_stack_extend((void **)(& (parser->document)->nodes.start),
+ (void **)(& (parser->document)->nodes.top),
+ (void **)(& (parser->document)->nodes.end));
+ if (tmp_3) {
+ yaml_node_t *tmp_4;
+ _LOR_0: tmp_4 = (parser->document)->nodes.top;
+ ((parser->document)->nodes.top) ++;
+ *tmp_4 = node;
+ tmp_5 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_5 = 0;
+ }
+ }
+ if (! tmp_5) goto error;
+ index_0 = (int)((parser->document)->nodes.top - (parser->document)->nodes.start);
+ tmp_6 = yaml_parser_register_anchor(parser,index_0,
+ event->data.sequence_start.anchor);
+ if (! tmp_6) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_7 = yaml_parser_load_node_add(parser,ctx,index_0);
+ if (! tmp_7) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (ctx->top - ctx->start < (long)(2147483647 - 1)) tmp_8 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_8 = 0;
+ }
+ if (! tmp_8) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (ctx->top != ctx->end) goto _LOR_1;
+ else {
+ int tmp_9;
+ tmp_9 = yaml_stack_extend((void **)(& ctx->start),(void **)(& ctx->top),
+ (void **)(& ctx->end));
+ if (tmp_9) {
+ int *tmp_10;
+ _LOR_1: tmp_10 = ctx->top;
+ (ctx->top) ++;
+ *tmp_10 = index_0;
+ tmp_11 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_11 = 0;
+ }
+ }
+ if (! tmp_11) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)tag);
+ yaml_free((void *)event->data.sequence_start.anchor);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_load_sequence_end(yaml_parser_t *parser,
+ yaml_event_t *event,
+ struct loader_ctx *ctx)
+{
+ int __retres;
+ int index_0;
+ __FC_assert((ctx->top - ctx->start > (long)0) != 0,"src/loader.c",467,
+ "((*ctx).top - (*ctx).start) > 0");
+ index_0 = *(ctx->top - 1);
+ __FC_assert((((parser->document)->nodes.start + (index_0 - 1))->type == (unsigned int)YAML_SEQUENCE_NODE) != 0,
+ "src/loader.c",470,
+ "parser->document->nodes.start[index-1].type == YAML_SEQUENCE_NODE");
+ ((parser->document)->nodes.start + (index_0 - 1))->end_mark = event->end_mark;
+ (ctx->top) --;
+ ;
+ __retres = 1;
+ return __retres;
+}
+
+static int yaml_parser_load_mapping(yaml_parser_t *parser,
+ yaml_event_t *event,
+ struct loader_ctx *ctx)
+{
+ int __retres;
+ yaml_node_t node;
+ int index_0;
+ int tmp;
+ int tmp_2;
+ int tmp_5;
+ int tmp_6;
+ int tmp_7;
+ int tmp_8;
+ int tmp_11;
+ struct __anonstruct_pairs_50 pairs =
+ {.start = (yaml_node_pair_t *)0,
+ .end = (yaml_node_pair_t *)0,
+ .top = (yaml_node_pair_t *)0};
+ yaml_char_t *tag = event->data.mapping_start.tag;
+ if ((parser->document)->nodes.top - (parser->document)->nodes.start < (long)(
+ 2147483647 - 1)) tmp = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp = 0;
+ }
+ if (! tmp) goto error;
+ if (! tag) goto _LOR;
+ else {
+ int tmp_0;
+ tmp_0 = strcmp((char const *)tag,"!");
+ if (tmp_0 == 0) {
+ _LOR:
+ {
+ yaml_free((void *)tag);
+ tag = yaml_strdup((yaml_char_t const *)"tag:yaml.org,2002:map");
+ if (! tag) goto error;
+ }
+ }
+ }
+ pairs.start = (yaml_node_pair_t *)yaml_malloc((unsigned long)16 * sizeof(*(pairs.start)));
+ if (pairs.start) {
+ pairs.top = pairs.start;
+ pairs.end = pairs.start + 16;
+ tmp_2 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ if (! tmp_2) goto error;
+ memset((void *)(& node),0,sizeof(yaml_node_t));
+ node.type = YAML_MAPPING_NODE;
+ node.tag = tag;
+ node.start_mark = event->start_mark;
+ node.end_mark = event->end_mark;
+ node.data.mapping.pairs.start = pairs.start;
+ node.data.mapping.pairs.end = pairs.end;
+ node.data.mapping.pairs.top = pairs.start;
+ node.data.mapping.style = event->data.mapping_start.style;
+ if ((parser->document)->nodes.top != (parser->document)->nodes.end)
+ goto _LOR_0;
+ else {
+ int tmp_3;
+ tmp_3 = yaml_stack_extend((void **)(& (parser->document)->nodes.start),
+ (void **)(& (parser->document)->nodes.top),
+ (void **)(& (parser->document)->nodes.end));
+ if (tmp_3) {
+ yaml_node_t *tmp_4;
+ _LOR_0: tmp_4 = (parser->document)->nodes.top;
+ ((parser->document)->nodes.top) ++;
+ *tmp_4 = node;
+ tmp_5 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_5 = 0;
+ }
+ }
+ if (! tmp_5) goto error;
+ index_0 = (int)((parser->document)->nodes.top - (parser->document)->nodes.start);
+ tmp_6 = yaml_parser_register_anchor(parser,index_0,
+ event->data.mapping_start.anchor);
+ if (! tmp_6) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_7 = yaml_parser_load_node_add(parser,ctx,index_0);
+ if (! tmp_7) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (ctx->top - ctx->start < (long)(2147483647 - 1)) tmp_8 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_8 = 0;
+ }
+ if (! tmp_8) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (ctx->top != ctx->end) goto _LOR_1;
+ else {
+ int tmp_9;
+ tmp_9 = yaml_stack_extend((void **)(& ctx->start),(void **)(& ctx->top),
+ (void **)(& ctx->end));
+ if (tmp_9) {
+ int *tmp_10;
+ _LOR_1: tmp_10 = ctx->top;
+ (ctx->top) ++;
+ *tmp_10 = index_0;
+ tmp_11 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_11 = 0;
+ }
+ }
+ if (! tmp_11) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)tag);
+ yaml_free((void *)event->data.mapping_start.anchor);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_load_mapping_end(yaml_parser_t *parser,
+ yaml_event_t *event,
+ struct loader_ctx *ctx)
+{
+ int __retres;
+ int index_0;
+ __FC_assert((ctx->top - ctx->start > (long)0) != 0,"src/loader.c",535,
+ "((*ctx).top - (*ctx).start) > 0");
+ index_0 = *(ctx->top - 1);
+ __FC_assert((((parser->document)->nodes.start + (index_0 - 1))->type == (unsigned int)YAML_MAPPING_NODE) != 0,
+ "src/loader.c",538,
+ "parser->document->nodes.start[index-1].type == YAML_MAPPING_NODE");
+ ((parser->document)->nodes.start + (index_0 - 1))->end_mark = event->end_mark;
+ (ctx->top) --;
+ ;
+ __retres = 1;
+ return __retres;
+}
+
+static int yaml_parser_set_parser_error(yaml_parser_t *parser,
+ char const *problem,
+ yaml_mark_t problem_mark);
+
+static int yaml_parser_set_parser_error_context(yaml_parser_t *parser,
+ char const *context,
+ yaml_mark_t context_mark,
+ char const *problem,
+ yaml_mark_t problem_mark);
+
+static int yaml_parser_state_machine(yaml_parser_t *parser,
+ yaml_event_t *event);
+
+static int yaml_parser_parse_stream_start(yaml_parser_t *parser,
+ yaml_event_t *event);
+
+static int yaml_parser_parse_document_start(yaml_parser_t *parser,
+ yaml_event_t *event, int implicit);
+
+static int yaml_parser_parse_document_content(yaml_parser_t *parser,
+ yaml_event_t *event);
+
+static int yaml_parser_parse_document_end(yaml_parser_t *parser,
+ yaml_event_t *event);
+
+static int yaml_parser_parse_node(yaml_parser_t *parser, yaml_event_t *event,
+ int block, int indentless_sequence);
+
+static int yaml_parser_parse_block_sequence_entry(yaml_parser_t *parser,
+ yaml_event_t *event,
+ int first);
+
+static int yaml_parser_parse_indentless_sequence_entry(yaml_parser_t *parser,
+ yaml_event_t *event);
+
+static int yaml_parser_parse_block_mapping_key(yaml_parser_t *parser,
+ yaml_event_t *event, int first);
+
+static int yaml_parser_parse_block_mapping_value(yaml_parser_t *parser,
+ yaml_event_t *event);
+
+static int yaml_parser_parse_flow_sequence_entry(yaml_parser_t *parser,
+ yaml_event_t *event,
+ int first);
+
+static int yaml_parser_parse_flow_sequence_entry_mapping_key(yaml_parser_t *parser,
+ yaml_event_t *event);
+
+static int yaml_parser_parse_flow_sequence_entry_mapping_value(yaml_parser_t *parser,
+ yaml_event_t *event);
+
+static int yaml_parser_parse_flow_sequence_entry_mapping_end(yaml_parser_t *parser,
+ yaml_event_t *event);
+
+static int yaml_parser_parse_flow_mapping_key(yaml_parser_t *parser,
+ yaml_event_t *event, int first);
+
+static int yaml_parser_parse_flow_mapping_value(yaml_parser_t *parser,
+ yaml_event_t *event,
+ int empty);
+
+static int yaml_parser_process_empty_scalar(yaml_parser_t *parser,
+ yaml_event_t *event,
+ yaml_mark_t mark);
+
+static int yaml_parser_process_directives(yaml_parser_t *parser,
+ yaml_version_directive_t **version_directive_ref,
+ yaml_tag_directive_t **tag_directives_start_ref,
+ yaml_tag_directive_t **tag_directives_end_ref);
+
+static int yaml_parser_append_tag_directive(yaml_parser_t *parser,
+ yaml_tag_directive_t value,
+ int allow_duplicates,
+ yaml_mark_t mark);
+
+int yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event)
+{
+ int __retres;
+ int tmp;
+ __FC_assert(parser != (yaml_parser_t *)0,"src/parser.c",172,"parser");
+ __FC_assert(event != (yaml_event_t *)0,"src/parser.c",173,"event");
+ memset((void *)event,0,sizeof(yaml_event_t));
+ if (parser->stream_end_produced) goto _LOR;
+ else
+ if (parser->error) goto _LOR;
+ else
+ if (parser->state == (unsigned int)YAML_PARSE_END_STATE) {
+ _LOR: {
+ __retres = 1;
+ goto return_label;
+ }
+ }
+ tmp = yaml_parser_state_machine(parser,event);
+ __retres = tmp;
+ return_label: return __retres;
+}
+
+static int yaml_parser_set_parser_error(yaml_parser_t *parser,
+ char const *problem,
+ yaml_mark_t problem_mark)
+{
+ int __retres;
+ parser->error = YAML_PARSER_ERROR;
+ parser->problem = problem;
+ parser->problem_mark = problem_mark;
+ __retres = 0;
+ return __retres;
+}
+
+static int yaml_parser_set_parser_error_context(yaml_parser_t *parser,
+ char const *context,
+ yaml_mark_t context_mark,
+ char const *problem,
+ yaml_mark_t problem_mark)
+{
+ int __retres;
+ parser->error = YAML_PARSER_ERROR;
+ parser->context = context;
+ parser->context_mark = context_mark;
+ parser->problem = problem;
+ parser->problem_mark = problem_mark;
+ __retres = 0;
+ return __retres;
+}
+
+static int yaml_parser_state_machine(yaml_parser_t *parser,
+ yaml_event_t *event)
+{
+ int __retres;
+ switch (parser->state) {
+ int tmp;
+ int tmp_0;
+ int tmp_1;
+ int tmp_2;
+ int tmp_3;
+ int tmp_4;
+ int tmp_5;
+ int tmp_6;
+ int tmp_7;
+ int tmp_8;
+ int tmp_9;
+ int tmp_10;
+ int tmp_11;
+ int tmp_12;
+ int tmp_13;
+ int tmp_14;
+ int tmp_15;
+ int tmp_16;
+ int tmp_17;
+ int tmp_18;
+ int tmp_19;
+ int tmp_20;
+ int tmp_21;
+ case (yaml_parser_state_t)YAML_PARSE_STREAM_START_STATE:
+ tmp = yaml_parser_parse_stream_start(parser,event);
+ __retres = tmp;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE:
+ tmp_0 = yaml_parser_parse_document_start(parser,event,1);
+ __retres = tmp_0;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_DOCUMENT_START_STATE:
+ tmp_1 = yaml_parser_parse_document_start(parser,event,0);
+ __retres = tmp_1;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_DOCUMENT_CONTENT_STATE:
+ tmp_2 = yaml_parser_parse_document_content(parser,event);
+ __retres = tmp_2;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_DOCUMENT_END_STATE:
+ tmp_3 = yaml_parser_parse_document_end(parser,event);
+ __retres = tmp_3;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_BLOCK_NODE_STATE:
+ tmp_4 = yaml_parser_parse_node(parser,event,1,0);
+ __retres = tmp_4;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE:
+ tmp_5 = yaml_parser_parse_node(parser,event,1,1);
+ __retres = tmp_5;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_FLOW_NODE_STATE:
+ tmp_6 = yaml_parser_parse_node(parser,event,0,0);
+ __retres = tmp_6;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE:
+ tmp_7 = yaml_parser_parse_block_sequence_entry(parser,event,1);
+ __retres = tmp_7;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE:
+ tmp_8 = yaml_parser_parse_block_sequence_entry(parser,event,0);
+ __retres = tmp_8;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE:
+ tmp_9 = yaml_parser_parse_indentless_sequence_entry(parser,event);
+ __retres = tmp_9;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE:
+ tmp_10 = yaml_parser_parse_block_mapping_key(parser,event,1);
+ __retres = tmp_10;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_BLOCK_MAPPING_KEY_STATE:
+ tmp_11 = yaml_parser_parse_block_mapping_key(parser,event,0);
+ __retres = tmp_11;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_BLOCK_MAPPING_VALUE_STATE:
+ tmp_12 = yaml_parser_parse_block_mapping_value(parser,event);
+ __retres = tmp_12;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE:
+ tmp_13 = yaml_parser_parse_flow_sequence_entry(parser,event,1);
+ __retres = tmp_13;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE:
+ tmp_14 = yaml_parser_parse_flow_sequence_entry(parser,event,0);
+ __retres = tmp_14;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE:
+ tmp_15 = yaml_parser_parse_flow_sequence_entry_mapping_key(parser,event);
+ __retres = tmp_15;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE:
+ tmp_16 = yaml_parser_parse_flow_sequence_entry_mapping_value(parser,
+ event);
+ __retres = tmp_16;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE:
+ tmp_17 = yaml_parser_parse_flow_sequence_entry_mapping_end(parser,event);
+ __retres = tmp_17;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE:
+ tmp_18 = yaml_parser_parse_flow_mapping_key(parser,event,1);
+ __retres = tmp_18;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_FLOW_MAPPING_KEY_STATE:
+ tmp_19 = yaml_parser_parse_flow_mapping_key(parser,event,0);
+ __retres = tmp_19;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_FLOW_MAPPING_VALUE_STATE:
+ tmp_20 = yaml_parser_parse_flow_mapping_value(parser,event,0);
+ __retres = tmp_20;
+ goto return_label;
+ case (yaml_parser_state_t)YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE:
+ tmp_21 = yaml_parser_parse_flow_mapping_value(parser,event,1);
+ __retres = tmp_21;
+ goto return_label;
+ default: __FC_assert(1 != 0,"src/parser.c",300,"1");
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_stream_start(yaml_parser_t *parser,
+ yaml_event_t *event)
+{
+ int __retres;
+ yaml_token_t *token;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type != (unsigned int)YAML_STREAM_START_TOKEN) {
+ int tmp_0;
+ tmp_0 = yaml_parser_set_parser_error(parser,
+ "did not find expected <stream-start>",
+ token->start_mark);
+ __retres = tmp_0;
+ goto return_label;
+ }
+ parser->state = YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_STREAM_START_EVENT;
+ event->start_mark = token->start_mark;
+ event->end_mark = token->start_mark;
+ event->data.stream_start.encoding = token->data.stream_start.encoding;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_document_start(yaml_parser_t *parser,
+ yaml_event_t *event, int implicit)
+{
+ int __retres;
+ yaml_token_t *token;
+ yaml_version_directive_t *version_directive =
+ (yaml_version_directive_t *)0;
+ struct __anonstruct_tag_directives_49 tag_directives =
+ {.start = (yaml_tag_directive_t *)0, .end = (yaml_tag_directive_t *)0};
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (! implicit)
+ while (token->type == (unsigned int)YAML_DOCUMENT_END_TOKEN) {
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_0;
+ tmp_0 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_0) token = parser->tokens.head;
+ else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (implicit) {
+ if (token->type != (unsigned int)YAML_VERSION_DIRECTIVE_TOKEN) {
+ if (token->type != (unsigned int)YAML_TAG_DIRECTIVE_TOKEN) {
+ if (token->type != (unsigned int)YAML_DOCUMENT_START_TOKEN) {
+ if (token->type != (unsigned int)YAML_STREAM_END_TOKEN) {
+ int tmp_1;
+ int tmp_4;
+ tmp_1 = yaml_parser_process_directives(parser,
+ (yaml_version_directive_t **)0,
+ (yaml_tag_directive_t **)0,
+ (yaml_tag_directive_t **)0);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (parser->states.top != parser->states.end) goto _LOR;
+ else {
+ int tmp_2;
+ tmp_2 = yaml_stack_extend((void **)(& parser->states.start),
+ (void **)(& parser->states.top),
+ (void **)(& parser->states.end));
+ if (tmp_2) {
+ yaml_parser_state_t *tmp_3;
+ _LOR: tmp_3 = parser->states.top;
+ (parser->states.top) ++;
+ *tmp_3 = YAML_PARSE_DOCUMENT_END_STATE;
+ tmp_4 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_4 = 0;
+ }
+ }
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->state = YAML_PARSE_BLOCK_NODE_STATE;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_DOCUMENT_START_EVENT;
+ event->start_mark = token->start_mark;
+ event->end_mark = token->start_mark;
+ event->data.document_start.version_directive = (yaml_version_directive_t *)0;
+ event->data.document_start.tag_directives.start = (yaml_tag_directive_t *)0;
+ event->data.document_start.tag_directives.end = (yaml_tag_directive_t *)0;
+ event->data.document_start.implicit = 1;
+ __retres = 1;
+ goto return_label;
+ }
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ _LAND_2: ;
+ if (token->type != (unsigned int)YAML_STREAM_END_TOKEN) {
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ int tmp_5;
+ int tmp_9;
+ start_mark = token->start_mark;
+ tmp_5 = yaml_parser_process_directives(parser,& version_directive,
+ & tag_directives.start,
+ & tag_directives.end);
+ if (! tmp_5) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_6;
+ tmp_6 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_6) token = parser->tokens.head;
+ else token = (yaml_token_t *)0;
+ }
+ if (! token) goto error;
+ if (token->type != (unsigned int)YAML_DOCUMENT_START_TOKEN) {
+ yaml_parser_set_parser_error(parser,
+ "did not find expected <document start>",
+ token->start_mark);
+ goto error;
+ }
+ if (parser->states.top != parser->states.end) goto _LOR_0;
+ else {
+ int tmp_7;
+ tmp_7 = yaml_stack_extend((void **)(& parser->states.start),
+ (void **)(& parser->states.top),
+ (void **)(& parser->states.end));
+ if (tmp_7) {
+ yaml_parser_state_t *tmp_8;
+ _LOR_0: tmp_8 = parser->states.top;
+ (parser->states.top) ++;
+ *tmp_8 = YAML_PARSE_DOCUMENT_END_STATE;
+ tmp_9 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_9 = 0;
+ }
+ }
+ if (! tmp_9) goto error;
+ parser->state = YAML_PARSE_DOCUMENT_CONTENT_STATE;
+ end_mark = token->end_mark;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_DOCUMENT_START_EVENT;
+ event->start_mark = start_mark;
+ event->end_mark = end_mark;
+ event->data.document_start.version_directive = version_directive;
+ event->data.document_start.tag_directives.start = tag_directives.start;
+ event->data.document_start.tag_directives.end = tag_directives.end;
+ event->data.document_start.implicit = 0;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ version_directive = (yaml_version_directive_t *)0;
+ tag_directives.end = (yaml_tag_directive_t *)0;
+ tag_directives.start = tag_directives.end;
+ __retres = 1;
+ goto return_label;
+ }
+ else {
+ parser->state = YAML_PARSE_END_STATE;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_STREAM_END_EVENT;
+ event->start_mark = token->start_mark;
+ event->end_mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ __retres = 1;
+ goto return_label;
+ }
+ }
+ error: yaml_free((void *)version_directive);
+ while (tag_directives.start != tag_directives.end) {
+ yaml_free((void *)(tag_directives.end + -1)->handle);
+ yaml_free((void *)(tag_directives.end + -1)->prefix);
+ (tag_directives.end) --;
+ }
+ yaml_free((void *)tag_directives.start);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_document_content(yaml_parser_t *parser,
+ yaml_event_t *event)
+{
+ int __retres;
+ yaml_token_t *token;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type == (unsigned int)YAML_VERSION_DIRECTIVE_TOKEN) goto _LOR;
+ else
+ if (token->type == (unsigned int)YAML_TAG_DIRECTIVE_TOKEN) goto _LOR;
+ else
+ if (token->type == (unsigned int)YAML_DOCUMENT_START_TOKEN) goto _LOR;
+ else
+ if (token->type == (unsigned int)YAML_DOCUMENT_END_TOKEN) goto _LOR;
+ else
+ if (token->type == (unsigned int)YAML_STREAM_END_TOKEN) {
+ _LOR:
+ {
+ int tmp_0;
+ (parser->states.top) --;
+ parser->state = *(parser->states.top);
+ tmp_0 = yaml_parser_process_empty_scalar(parser,event,
+ token->start_mark);
+ __retres = tmp_0;
+ goto return_label;
+ }
+ }
+ else {
+ int tmp_1;
+ tmp_1 = yaml_parser_parse_node(parser,event,1,0);
+ __retres = tmp_1;
+ goto return_label;
+ }
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_document_end(yaml_parser_t *parser,
+ yaml_event_t *event)
+{
+ int __retres;
+ yaml_token_t *token;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ int implicit = 1;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ end_mark = token->start_mark;
+ start_mark = end_mark;
+ if (token->type == (unsigned int)YAML_DOCUMENT_END_TOKEN) {
+ end_mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ implicit = 0;
+ }
+ while (! (parser->tag_directives.start == parser->tag_directives.top)) {
+ (parser->tag_directives.top) --;
+ yaml_tag_directive_t tag_directive = *(parser->tag_directives.top);
+ yaml_free((void *)tag_directive.handle);
+ yaml_free((void *)tag_directive.prefix);
+ }
+ parser->state = YAML_PARSE_DOCUMENT_START_STATE;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_DOCUMENT_END_EVENT;
+ event->start_mark = start_mark;
+ event->end_mark = end_mark;
+ event->data.document_end.implicit = implicit;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_node(yaml_parser_t *parser, yaml_event_t *event,
+ int block, int indentless_sequence)
+{
+ int __retres;
+ yaml_token_t *token;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ yaml_mark_t tag_mark;
+ int implicit;
+ yaml_char_t *anchor = (yaml_char_t *)0;
+ yaml_char_t *tag_handle = (yaml_char_t *)0;
+ yaml_char_t *tag_suffix = (yaml_char_t *)0;
+ yaml_char_t *tag = (yaml_char_t *)0;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type == (unsigned int)YAML_ALIAS_TOKEN) {
+ (parser->states.top) --;
+ parser->state = *(parser->states.top);
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_ALIAS_EVENT;
+ event->start_mark = token->start_mark;
+ event->end_mark = token->end_mark;
+ event->data.alias.anchor = token->data.alias.value;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ __retres = 1;
+ goto return_label;
+ }
+ else {
+ int tmp_8;
+ end_mark = token->start_mark;
+ start_mark = end_mark;
+ if (token->type == (unsigned int)YAML_ANCHOR_TOKEN) {
+ anchor = token->data.anchor.value;
+ start_mark = token->start_mark;
+ end_mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_0;
+ tmp_0 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_0) token = parser->tokens.head;
+ else token = (yaml_token_t *)0;
+ }
+ if (! token) goto error;
+ if (token->type == (unsigned int)YAML_TAG_TOKEN) {
+ tag_handle = token->data.tag.handle;
+ tag_suffix = token->data.tag.suffix;
+ tag_mark = token->start_mark;
+ end_mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_1) token = parser->tokens.head;
+ else token = (yaml_token_t *)0;
+ }
+ if (! token) goto error;
+ }
+ }
+ else
+ if (token->type == (unsigned int)YAML_TAG_TOKEN) {
+ tag_handle = token->data.tag.handle;
+ tag_suffix = token->data.tag.suffix;
+ tag_mark = token->start_mark;
+ start_mark = tag_mark;
+ end_mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_2;
+ tmp_2 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_2) token = parser->tokens.head;
+ else token = (yaml_token_t *)0;
+ }
+ if (! token) goto error;
+ if (token->type == (unsigned int)YAML_ANCHOR_TOKEN) {
+ anchor = token->data.anchor.value;
+ end_mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_3;
+ tmp_3 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_3) token = parser->tokens.head;
+ else token = (yaml_token_t *)0;
+ }
+ if (! token) goto error;
+ }
+ }
+ if (tag_handle)
+ if (! *tag_handle) {
+ tag = tag_suffix;
+ yaml_free((void *)tag_handle);
+ tag_suffix = (yaml_char_t *)0;
+ tag_handle = tag_suffix;
+ }
+ else {
+ yaml_tag_directive_t *tag_directive;
+ tag_directive = parser->tag_directives.start;
+ while (tag_directive != parser->tag_directives.top) {
+ {
+ int tmp_7;
+ tmp_7 = strcmp((char const *)tag_directive->handle,
+ (char const *)tag_handle);
+ if (tmp_7 == 0) {
+ size_t prefix_len =
+ strlen((char const *)tag_directive->prefix);
+ size_t suffix_len = strlen((char const *)tag_suffix);
+ tag = (yaml_char_t *)yaml_malloc((prefix_len + suffix_len) + (size_t)1);
+ if (! tag) {
+ parser->error = YAML_MEMORY_ERROR;
+ goto error;
+ }
+ memcpy((void *)tag,(void const *)tag_directive->prefix,
+ prefix_len);
+ memcpy((void *)(tag + prefix_len),(void const *)tag_suffix,
+ suffix_len);
+ *(tag + (prefix_len + suffix_len)) = (unsigned char)'\000';
+ yaml_free((void *)tag_handle);
+ yaml_free((void *)tag_suffix);
+ tag_suffix = (yaml_char_t *)0;
+ tag_handle = tag_suffix;
+ break;
+ }
+ }
+ tag_directive ++;
+ }
+ if (! tag) {
+ yaml_parser_set_parser_error_context(parser,"while parsing a node",
+ start_mark,
+ "found undefined tag handle",
+ tag_mark);
+ goto error;
+ }
+ }
+ if (! tag) tmp_8 = 1;
+ else
+ if (! *tag) tmp_8 = 1; else tmp_8 = 0;
+ implicit = tmp_8;
+ if (indentless_sequence) {
+ if (token->type == (unsigned int)YAML_BLOCK_ENTRY_TOKEN) {
+ end_mark = token->end_mark;
+ parser->state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_SEQUENCE_START_EVENT;
+ event->start_mark = start_mark;
+ event->end_mark = end_mark;
+ event->data.sequence_start.anchor = anchor;
+ event->data.sequence_start.tag = tag;
+ event->data.sequence_start.implicit = implicit;
+ event->data.sequence_start.style = YAML_BLOCK_SEQUENCE_STYLE;
+ __retres = 1;
+ goto return_label;
+ }
+ else goto _LAND_3;
+ }
+ else
+ _LAND_3:
+ if (token->type == (unsigned int)YAML_SCALAR_TOKEN) {
+ int plain_implicit = 0;
+ int quoted_implicit = 0;
+ end_mark = token->end_mark;
+ if (token->data.scalar.style == (unsigned int)YAML_PLAIN_SCALAR_STYLE) {
+ if (! tag) goto _LOR; else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if (tag) {
+ int tmp_9;
+ tmp_9 = strcmp((char const *)tag,"!");
+ if (tmp_9 == 0) _LOR: plain_implicit = 1; else goto _LAND;
+ }
+ else
+ _LAND: if (! tag) quoted_implicit = 1;
+ }
+ (parser->states.top) --;
+ parser->state = *(parser->states.top);
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_SCALAR_EVENT;
+ event->start_mark = start_mark;
+ event->end_mark = end_mark;
+ event->data.scalar.anchor = anchor;
+ event->data.scalar.tag = tag;
+ event->data.scalar.value = token->data.scalar.value;
+ event->data.scalar.length = token->data.scalar.length;
+ event->data.scalar.plain_implicit = plain_implicit;
+ event->data.scalar.quoted_implicit = quoted_implicit;
+ event->data.scalar.style = token->data.scalar.style;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ __retres = 1;
+ goto return_label;
+ }
+ else
+ if (token->type == (unsigned int)YAML_FLOW_SEQUENCE_START_TOKEN) {
+ end_mark = token->end_mark;
+ parser->state = YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_SEQUENCE_START_EVENT;
+ event->start_mark = start_mark;
+ event->end_mark = end_mark;
+ event->data.sequence_start.anchor = anchor;
+ event->data.sequence_start.tag = tag;
+ event->data.sequence_start.implicit = implicit;
+ event->data.sequence_start.style = YAML_FLOW_SEQUENCE_STYLE;
+ __retres = 1;
+ goto return_label;
+ }
+ else
+ if (token->type == (unsigned int)YAML_FLOW_MAPPING_START_TOKEN) {
+ end_mark = token->end_mark;
+ parser->state = YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_MAPPING_START_EVENT;
+ event->start_mark = start_mark;
+ event->end_mark = end_mark;
+ event->data.mapping_start.anchor = anchor;
+ event->data.mapping_start.tag = tag;
+ event->data.mapping_start.implicit = implicit;
+ event->data.mapping_start.style = YAML_FLOW_MAPPING_STYLE;
+ __retres = 1;
+ goto return_label;
+ }
+ else
+ if (block) {
+ if (token->type == (unsigned int)YAML_BLOCK_SEQUENCE_START_TOKEN) {
+ end_mark = token->end_mark;
+ parser->state = YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_SEQUENCE_START_EVENT;
+ event->start_mark = start_mark;
+ event->end_mark = end_mark;
+ event->data.sequence_start.anchor = anchor;
+ event->data.sequence_start.tag = tag;
+ event->data.sequence_start.implicit = implicit;
+ event->data.sequence_start.style = YAML_BLOCK_SEQUENCE_STYLE;
+ __retres = 1;
+ goto return_label;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ _LAND_2: ;
+ if (block) {
+ if (token->type == (unsigned int)YAML_BLOCK_MAPPING_START_TOKEN) {
+ end_mark = token->end_mark;
+ parser->state = YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_MAPPING_START_EVENT;
+ event->start_mark = start_mark;
+ event->end_mark = end_mark;
+ event->data.mapping_start.anchor = anchor;
+ event->data.mapping_start.tag = tag;
+ event->data.mapping_start.implicit = implicit;
+ event->data.mapping_start.style = YAML_BLOCK_MAPPING_STYLE;
+ __retres = 1;
+ goto return_label;
+ }
+ else goto _LAND_1;
+ }
+ else {
+ _LAND_1: ;
+ if (anchor) goto _LOR_0;
+ else
+ if (tag) {
+ _LOR_0:
+ {
+ yaml_char_t *value = yaml_malloc((unsigned long)1);
+ if (! value) {
+ parser->error = YAML_MEMORY_ERROR;
+ goto error;
+ }
+ *(value + 0) = (unsigned char)'\000';
+ (parser->states.top) --;
+ parser->state = *(parser->states.top);
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_SCALAR_EVENT;
+ event->start_mark = start_mark;
+ event->end_mark = end_mark;
+ event->data.scalar.anchor = anchor;
+ event->data.scalar.tag = tag;
+ event->data.scalar.value = value;
+ event->data.scalar.length = (unsigned long)0;
+ event->data.scalar.plain_implicit = implicit;
+ event->data.scalar.quoted_implicit = 0;
+ event->data.scalar.style = YAML_PLAIN_SCALAR_STYLE;
+ __retres = 1;
+ goto return_label;
+ }
+ }
+ else {
+ char const *tmp_11;
+ ;
+ ;
+ if (block) tmp_11 = "while parsing a block node";
+ else tmp_11 = "while parsing a flow node";
+ ;
+ yaml_parser_set_parser_error_context(parser,tmp_11,
+ start_mark,
+ "did not find expected node content",
+ token->start_mark);
+ goto error;
+ }
+ }
+ }
+ }
+ error: yaml_free((void *)anchor);
+ yaml_free((void *)tag_handle);
+ yaml_free((void *)tag_suffix);
+ yaml_free((void *)tag);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_block_sequence_entry(yaml_parser_t *parser,
+ yaml_event_t *event,
+ int first)
+{
+ int __retres;
+ yaml_token_t *token;
+ if (first) {
+ int tmp_2;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (parser->marks.top != parser->marks.end) goto _LOR;
+ else {
+ int tmp_0;
+ tmp_0 = yaml_stack_extend((void **)(& parser->marks.start),
+ (void **)(& parser->marks.top),
+ (void **)(& parser->marks.end));
+ if (tmp_0) {
+ yaml_mark_t *tmp_1;
+ _LOR: tmp_1 = parser->marks.top;
+ (parser->marks.top) ++;
+ *tmp_1 = token->start_mark;
+ tmp_2 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ }
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ }
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_3;
+ tmp_3 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_3) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type == (unsigned int)YAML_BLOCK_ENTRY_TOKEN) {
+ yaml_mark_t mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_4;
+ tmp_4 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_4) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type != (unsigned int)YAML_BLOCK_ENTRY_TOKEN) {
+ if (token->type != (unsigned int)YAML_BLOCK_END_TOKEN) {
+ int tmp_7;
+ int tmp_8;
+ if (parser->states.top != parser->states.end) goto _LOR_0;
+ else {
+ int tmp_5;
+ tmp_5 = yaml_stack_extend((void **)(& parser->states.start),
+ (void **)(& parser->states.top),
+ (void **)(& parser->states.end));
+ if (tmp_5) {
+ yaml_parser_state_t *tmp_6;
+ _LOR_0: tmp_6 = parser->states.top;
+ (parser->states.top) ++;
+ *tmp_6 = YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE;
+ tmp_7 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_7 = 0;
+ }
+ }
+ if (! tmp_7) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_8 = yaml_parser_parse_node(parser,event,1,0);
+ __retres = tmp_8;
+ goto return_label;
+ }
+ else goto _LAND;
+ }
+ else {
+ _LAND:
+ {
+ int tmp_9;
+ parser->state = YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE;
+ tmp_9 = yaml_parser_process_empty_scalar(parser,event,mark);
+ __retres = tmp_9;
+ goto return_label;
+ }
+ }
+ }
+ else
+ if (token->type == (unsigned int)YAML_BLOCK_END_TOKEN) {
+ (parser->states.top) --;
+ parser->state = *(parser->states.top);
+ (parser->marks.top) --;
+ ;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_SEQUENCE_END_EVENT;
+ event->start_mark = token->start_mark;
+ event->end_mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ __retres = 1;
+ goto return_label;
+ }
+ else {
+ int tmp_10;
+ ;
+ (parser->marks.top) --;
+ ;
+ ;
+ tmp_10 = yaml_parser_set_parser_error_context(parser,
+ "while parsing a block collection",
+ *(parser->marks.top),
+ "did not find expected \'-\' indicator",
+ token->start_mark);
+ __retres = tmp_10;
+ goto return_label;
+ }
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_indentless_sequence_entry(yaml_parser_t *parser,
+ yaml_event_t *event)
+{
+ int __retres;
+ yaml_token_t *token;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type == (unsigned int)YAML_BLOCK_ENTRY_TOKEN) {
+ yaml_mark_t mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_0;
+ tmp_0 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_0) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type != (unsigned int)YAML_BLOCK_ENTRY_TOKEN) {
+ if (token->type != (unsigned int)YAML_KEY_TOKEN) {
+ if (token->type != (unsigned int)YAML_VALUE_TOKEN) {
+ if (token->type != (unsigned int)YAML_BLOCK_END_TOKEN) {
+ int tmp_3;
+ int tmp_4;
+ if (parser->states.top != parser->states.end) goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_stack_extend((void **)(& parser->states.start),
+ (void **)(& parser->states.top),
+ (void **)(& parser->states.end));
+ if (tmp_1) {
+ yaml_parser_state_t *tmp_2;
+ _LOR: tmp_2 = parser->states.top;
+ (parser->states.top) ++;
+ *tmp_2 = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE;
+ tmp_3 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_4 = yaml_parser_parse_node(parser,event,1,0);
+ __retres = tmp_4;
+ goto return_label;
+ }
+ else goto _LAND_1;
+ }
+ else goto _LAND_1;
+ }
+ else goto _LAND_1;
+ }
+ else {
+ _LAND_1:
+ {
+ int tmp_5;
+ parser->state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE;
+ tmp_5 = yaml_parser_process_empty_scalar(parser,event,mark);
+ __retres = tmp_5;
+ goto return_label;
+ }
+ }
+ }
+ else {
+ (parser->states.top) --;
+ parser->state = *(parser->states.top);
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_SEQUENCE_END_EVENT;
+ event->start_mark = token->start_mark;
+ event->end_mark = token->start_mark;
+ __retres = 1;
+ goto return_label;
+ }
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_block_mapping_key(yaml_parser_t *parser,
+ yaml_event_t *event, int first)
+{
+ int __retres;
+ yaml_token_t *token;
+ if (first) {
+ int tmp_2;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (parser->marks.top != parser->marks.end) goto _LOR;
+ else {
+ int tmp_0;
+ tmp_0 = yaml_stack_extend((void **)(& parser->marks.start),
+ (void **)(& parser->marks.top),
+ (void **)(& parser->marks.end));
+ if (tmp_0) {
+ yaml_mark_t *tmp_1;
+ _LOR: tmp_1 = parser->marks.top;
+ (parser->marks.top) ++;
+ *tmp_1 = token->start_mark;
+ tmp_2 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ }
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ }
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_3;
+ tmp_3 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_3) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type == (unsigned int)YAML_KEY_TOKEN) {
+ yaml_mark_t mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_4;
+ tmp_4 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_4) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type != (unsigned int)YAML_KEY_TOKEN) {
+ if (token->type != (unsigned int)YAML_VALUE_TOKEN) {
+ if (token->type != (unsigned int)YAML_BLOCK_END_TOKEN) {
+ int tmp_7;
+ int tmp_8;
+ if (parser->states.top != parser->states.end) goto _LOR_0;
+ else {
+ int tmp_5;
+ tmp_5 = yaml_stack_extend((void **)(& parser->states.start),
+ (void **)(& parser->states.top),
+ (void **)(& parser->states.end));
+ if (tmp_5) {
+ yaml_parser_state_t *tmp_6;
+ _LOR_0: tmp_6 = parser->states.top;
+ (parser->states.top) ++;
+ *tmp_6 = YAML_PARSE_BLOCK_MAPPING_VALUE_STATE;
+ tmp_7 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_7 = 0;
+ }
+ }
+ if (! tmp_7) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_8 = yaml_parser_parse_node(parser,event,1,1);
+ __retres = tmp_8;
+ goto return_label;
+ }
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0:
+ {
+ int tmp_9;
+ parser->state = YAML_PARSE_BLOCK_MAPPING_VALUE_STATE;
+ tmp_9 = yaml_parser_process_empty_scalar(parser,event,mark);
+ __retres = tmp_9;
+ goto return_label;
+ }
+ }
+ }
+ else
+ if (token->type == (unsigned int)YAML_BLOCK_END_TOKEN) {
+ (parser->states.top) --;
+ parser->state = *(parser->states.top);
+ (parser->marks.top) --;
+ ;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_MAPPING_END_EVENT;
+ event->start_mark = token->start_mark;
+ event->end_mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ __retres = 1;
+ goto return_label;
+ }
+ else {
+ int tmp_10;
+ ;
+ (parser->marks.top) --;
+ ;
+ ;
+ tmp_10 = yaml_parser_set_parser_error_context(parser,
+ "while parsing a block mapping",
+ *(parser->marks.top),
+ "did not find expected key",
+ token->start_mark);
+ __retres = tmp_10;
+ goto return_label;
+ }
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_block_mapping_value(yaml_parser_t *parser,
+ yaml_event_t *event)
+{
+ int __retres;
+ yaml_token_t *token;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type == (unsigned int)YAML_VALUE_TOKEN) {
+ yaml_mark_t mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_0;
+ tmp_0 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_0) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type != (unsigned int)YAML_KEY_TOKEN) {
+ if (token->type != (unsigned int)YAML_VALUE_TOKEN) {
+ if (token->type != (unsigned int)YAML_BLOCK_END_TOKEN) {
+ int tmp_3;
+ int tmp_4;
+ if (parser->states.top != parser->states.end) goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_stack_extend((void **)(& parser->states.start),
+ (void **)(& parser->states.top),
+ (void **)(& parser->states.end));
+ if (tmp_1) {
+ yaml_parser_state_t *tmp_2;
+ _LOR: tmp_2 = parser->states.top;
+ (parser->states.top) ++;
+ *tmp_2 = YAML_PARSE_BLOCK_MAPPING_KEY_STATE;
+ tmp_3 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_4 = yaml_parser_parse_node(parser,event,1,1);
+ __retres = tmp_4;
+ goto return_label;
+ }
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0:
+ {
+ int tmp_5;
+ parser->state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE;
+ tmp_5 = yaml_parser_process_empty_scalar(parser,event,mark);
+ __retres = tmp_5;
+ goto return_label;
+ }
+ }
+ }
+ else {
+ int tmp_6;
+ parser->state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE;
+ tmp_6 = yaml_parser_process_empty_scalar(parser,event,token->start_mark);
+ __retres = tmp_6;
+ goto return_label;
+ }
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_flow_sequence_entry(yaml_parser_t *parser,
+ yaml_event_t *event,
+ int first)
+{
+ int __retres;
+ yaml_token_t *token;
+ if (first) {
+ int tmp_2;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (parser->marks.top != parser->marks.end) goto _LOR;
+ else {
+ int tmp_0;
+ tmp_0 = yaml_stack_extend((void **)(& parser->marks.start),
+ (void **)(& parser->marks.top),
+ (void **)(& parser->marks.end));
+ if (tmp_0) {
+ yaml_mark_t *tmp_1;
+ _LOR: tmp_1 = parser->marks.top;
+ (parser->marks.top) ++;
+ *tmp_1 = token->start_mark;
+ tmp_2 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ }
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ }
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_3;
+ tmp_3 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_3) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type != (unsigned int)YAML_FLOW_SEQUENCE_END_TOKEN) {
+ if (! first)
+ if (token->type == (unsigned int)YAML_FLOW_ENTRY_TOKEN) {
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_4;
+ tmp_4 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_4) token = parser->tokens.head;
+ else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ else {
+ int tmp_5;
+ ;
+ (parser->marks.top) --;
+ ;
+ ;
+ tmp_5 = yaml_parser_set_parser_error_context(parser,
+ "while parsing a flow sequence",
+ *(parser->marks.top),
+ "did not find expected \',\' or \']\'",
+ token->start_mark);
+ __retres = tmp_5;
+ goto return_label;
+ }
+ if (token->type == (unsigned int)YAML_KEY_TOKEN) {
+ parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_MAPPING_START_EVENT;
+ event->start_mark = token->start_mark;
+ event->end_mark = token->end_mark;
+ event->data.mapping_start.anchor = (yaml_char_t *)0;
+ event->data.mapping_start.tag = (yaml_char_t *)0;
+ event->data.mapping_start.implicit = 1;
+ event->data.mapping_start.style = YAML_FLOW_MAPPING_STYLE;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ __retres = 1;
+ goto return_label;
+ }
+ else
+ if (token->type != (unsigned int)YAML_FLOW_SEQUENCE_END_TOKEN) {
+ int tmp_8;
+ int tmp_9;
+ if (parser->states.top != parser->states.end) goto _LOR_0;
+ else {
+ int tmp_6;
+ tmp_6 = yaml_stack_extend((void **)(& parser->states.start),
+ (void **)(& parser->states.top),
+ (void **)(& parser->states.end));
+ if (tmp_6) {
+ yaml_parser_state_t *tmp_7;
+ _LOR_0: tmp_7 = parser->states.top;
+ (parser->states.top) ++;
+ *tmp_7 = YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE;
+ tmp_8 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_8 = 0;
+ }
+ }
+ if (! tmp_8) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_9 = yaml_parser_parse_node(parser,event,0,0);
+ __retres = tmp_9;
+ goto return_label;
+ }
+ }
+ (parser->states.top) --;
+ parser->state = *(parser->states.top);
+ (parser->marks.top) --;
+ ;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_SEQUENCE_END_EVENT;
+ event->start_mark = token->start_mark;
+ event->end_mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_flow_sequence_entry_mapping_key(yaml_parser_t *parser,
+ yaml_event_t *event)
+{
+ int __retres;
+ yaml_token_t *token;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type != (unsigned int)YAML_VALUE_TOKEN) {
+ if (token->type != (unsigned int)YAML_FLOW_ENTRY_TOKEN) {
+ if (token->type != (unsigned int)YAML_FLOW_SEQUENCE_END_TOKEN) {
+ int tmp_2;
+ int tmp_3;
+ if (parser->states.top != parser->states.end) goto _LOR;
+ else {
+ int tmp_0;
+ tmp_0 = yaml_stack_extend((void **)(& parser->states.start),
+ (void **)(& parser->states.top),
+ (void **)(& parser->states.end));
+ if (tmp_0) {
+ yaml_parser_state_t *tmp_1;
+ _LOR: tmp_1 = parser->states.top;
+ (parser->states.top) ++;
+ *tmp_1 = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE;
+ tmp_2 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ }
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_3 = yaml_parser_parse_node(parser,event,0,0);
+ __retres = tmp_3;
+ goto return_label;
+ }
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0:
+ {
+ int tmp_4;
+ yaml_mark_t mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE;
+ tmp_4 = yaml_parser_process_empty_scalar(parser,event,mark);
+ __retres = tmp_4;
+ goto return_label;
+ }
+ }
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_flow_sequence_entry_mapping_value(yaml_parser_t *parser,
+ yaml_event_t *event)
+{
+ int __retres;
+ yaml_token_t *token;
+ int tmp_5;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type == (unsigned int)YAML_VALUE_TOKEN) {
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_0;
+ tmp_0 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_0) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type != (unsigned int)YAML_FLOW_ENTRY_TOKEN)
+ if (token->type != (unsigned int)YAML_FLOW_SEQUENCE_END_TOKEN) {
+ int tmp_3;
+ int tmp_4;
+ if (parser->states.top != parser->states.end) goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_stack_extend((void **)(& parser->states.start),
+ (void **)(& parser->states.top),
+ (void **)(& parser->states.end));
+ if (tmp_1) {
+ yaml_parser_state_t *tmp_2;
+ _LOR: tmp_2 = parser->states.top;
+ (parser->states.top) ++;
+ *tmp_2 = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE;
+ tmp_3 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_4 = yaml_parser_parse_node(parser,event,0,0);
+ __retres = tmp_4;
+ goto return_label;
+ }
+ }
+ parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE;
+ tmp_5 = yaml_parser_process_empty_scalar(parser,event,token->start_mark);
+ __retres = tmp_5;
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_flow_sequence_entry_mapping_end(yaml_parser_t *parser,
+ yaml_event_t *event)
+{
+ int __retres;
+ yaml_token_t *token;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_MAPPING_END_EVENT;
+ event->start_mark = token->start_mark;
+ event->end_mark = token->start_mark;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_flow_mapping_key(yaml_parser_t *parser,
+ yaml_event_t *event, int first)
+{
+ int __retres;
+ yaml_token_t *token;
+ if (first) {
+ int tmp_2;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (parser->marks.top != parser->marks.end) goto _LOR;
+ else {
+ int tmp_0;
+ tmp_0 = yaml_stack_extend((void **)(& parser->marks.start),
+ (void **)(& parser->marks.top),
+ (void **)(& parser->marks.end));
+ if (tmp_0) {
+ yaml_mark_t *tmp_1;
+ _LOR: tmp_1 = parser->marks.top;
+ (parser->marks.top) ++;
+ *tmp_1 = token->start_mark;
+ tmp_2 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ }
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ }
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_3;
+ tmp_3 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_3) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type != (unsigned int)YAML_FLOW_MAPPING_END_TOKEN) {
+ if (! first)
+ if (token->type == (unsigned int)YAML_FLOW_ENTRY_TOKEN) {
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_4;
+ tmp_4 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_4) token = parser->tokens.head;
+ else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ else {
+ int tmp_5;
+ ;
+ (parser->marks.top) --;
+ ;
+ ;
+ tmp_5 = yaml_parser_set_parser_error_context(parser,
+ "while parsing a flow mapping",
+ *(parser->marks.top),
+ "did not find expected \',\' or \'}\'",
+ token->start_mark);
+ __retres = tmp_5;
+ goto return_label;
+ }
+ if (token->type == (unsigned int)YAML_KEY_TOKEN) {
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_6;
+ tmp_6 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_6) token = parser->tokens.head;
+ else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type != (unsigned int)YAML_VALUE_TOKEN) {
+ if (token->type != (unsigned int)YAML_FLOW_ENTRY_TOKEN) {
+ if (token->type != (unsigned int)YAML_FLOW_MAPPING_END_TOKEN) {
+ int tmp_9;
+ int tmp_10;
+ if (parser->states.top != parser->states.end) goto _LOR_0;
+ else {
+ int tmp_7;
+ tmp_7 = yaml_stack_extend((void **)(& parser->states.start),
+ (void **)(& parser->states.top),
+ (void **)(& parser->states.end));
+ if (tmp_7) {
+ yaml_parser_state_t *tmp_8;
+ _LOR_0: tmp_8 = parser->states.top;
+ (parser->states.top) ++;
+ *tmp_8 = YAML_PARSE_FLOW_MAPPING_VALUE_STATE;
+ tmp_9 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_9 = 0;
+ }
+ }
+ if (! tmp_9) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_10 = yaml_parser_parse_node(parser,event,0,0);
+ __retres = tmp_10;
+ goto return_label;
+ }
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0:
+ {
+ int tmp_11;
+ parser->state = YAML_PARSE_FLOW_MAPPING_VALUE_STATE;
+ tmp_11 = yaml_parser_process_empty_scalar(parser,event,
+ token->start_mark);
+ __retres = tmp_11;
+ goto return_label;
+ }
+ }
+ }
+ else
+ if (token->type != (unsigned int)YAML_FLOW_MAPPING_END_TOKEN) {
+ int tmp_14;
+ int tmp_15;
+ if (parser->states.top != parser->states.end) goto _LOR_1;
+ else {
+ int tmp_12;
+ tmp_12 = yaml_stack_extend((void **)(& parser->states.start),
+ (void **)(& parser->states.top),
+ (void **)(& parser->states.end));
+ if (tmp_12) {
+ yaml_parser_state_t *tmp_13;
+ _LOR_1: tmp_13 = parser->states.top;
+ (parser->states.top) ++;
+ *tmp_13 = YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE;
+ tmp_14 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_14 = 0;
+ }
+ }
+ if (! tmp_14) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_15 = yaml_parser_parse_node(parser,event,0,0);
+ __retres = tmp_15;
+ goto return_label;
+ }
+ }
+ (parser->states.top) --;
+ parser->state = *(parser->states.top);
+ (parser->marks.top) --;
+ ;
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_MAPPING_END_EVENT;
+ event->start_mark = token->start_mark;
+ event->end_mark = token->end_mark;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_parse_flow_mapping_value(yaml_parser_t *parser,
+ yaml_event_t *event,
+ int empty)
+{
+ int __retres;
+ yaml_token_t *token;
+ int tmp_6;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (tmp) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (empty) {
+ int tmp_0;
+ parser->state = YAML_PARSE_FLOW_MAPPING_KEY_STATE;
+ tmp_0 = yaml_parser_process_empty_scalar(parser,event,token->start_mark);
+ __retres = tmp_0;
+ goto return_label;
+ }
+ if (token->type == (unsigned int)YAML_VALUE_TOKEN) {
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_1) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (token->type != (unsigned int)YAML_FLOW_ENTRY_TOKEN)
+ if (token->type != (unsigned int)YAML_FLOW_MAPPING_END_TOKEN) {
+ int tmp_4;
+ int tmp_5;
+ if (parser->states.top != parser->states.end) goto _LOR;
+ else {
+ int tmp_2;
+ tmp_2 = yaml_stack_extend((void **)(& parser->states.start),
+ (void **)(& parser->states.top),
+ (void **)(& parser->states.end));
+ if (tmp_2) {
+ yaml_parser_state_t *tmp_3;
+ _LOR: tmp_3 = parser->states.top;
+ (parser->states.top) ++;
+ *tmp_3 = YAML_PARSE_FLOW_MAPPING_KEY_STATE;
+ tmp_4 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_4 = 0;
+ }
+ }
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_5 = yaml_parser_parse_node(parser,event,0,0);
+ __retres = tmp_5;
+ goto return_label;
+ }
+ }
+ parser->state = YAML_PARSE_FLOW_MAPPING_KEY_STATE;
+ tmp_6 = yaml_parser_process_empty_scalar(parser,event,token->start_mark);
+ __retres = tmp_6;
+ return_label: return __retres;
+}
+
+static int yaml_parser_process_empty_scalar(yaml_parser_t *parser,
+ yaml_event_t *event,
+ yaml_mark_t mark)
+{
+ int __retres;
+ yaml_char_t *value;
+ value = (yaml_char_t *)yaml_malloc((unsigned long)1);
+ if (! value) {
+ parser->error = YAML_MEMORY_ERROR;
+ __retres = 0;
+ goto return_label;
+ }
+ *(value + 0) = (unsigned char)'\000';
+ memset((void *)event,0,sizeof(yaml_event_t));
+ event->type = YAML_SCALAR_EVENT;
+ event->start_mark = mark;
+ event->end_mark = mark;
+ event->data.scalar.anchor = (yaml_char_t *)0;
+ event->data.scalar.tag = (yaml_char_t *)0;
+ event->data.scalar.value = value;
+ event->data.scalar.length = (unsigned long)0;
+ event->data.scalar.plain_implicit = 1;
+ event->data.scalar.quoted_implicit = 0;
+ event->data.scalar.style = YAML_PLAIN_SCALAR_STYLE;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_process_directives(yaml_parser_t *parser,
+ yaml_version_directive_t **version_directive_ref,
+ yaml_tag_directive_t **tag_directives_start_ref,
+ yaml_tag_directive_t **tag_directives_end_ref)
+{
+ int __retres;
+ yaml_tag_directive_t *default_tag_directive;
+ yaml_token_t *token;
+ int tmp_0;
+ yaml_tag_directive_t default_tag_directives[3] =
+ {{.handle = (yaml_char_t *)"!", .prefix = (yaml_char_t *)"!"},
+ {.handle = (yaml_char_t *)"!!",
+ .prefix = (yaml_char_t *)"tag:yaml.org,2002:"},
+ {.handle = (yaml_char_t *)0, .prefix = (yaml_char_t *)0}};
+ yaml_version_directive_t *version_directive =
+ (yaml_version_directive_t *)0;
+ struct __anonstruct_tag_directives_50 tag_directives =
+ {.start = (yaml_tag_directive_t *)0,
+ .end = (yaml_tag_directive_t *)0,
+ .top = (yaml_tag_directive_t *)0};
+ tag_directives.start = (yaml_tag_directive_t *)yaml_malloc((unsigned long)16 * sizeof(*(tag_directives.start)));
+ if (tag_directives.start) {
+ tag_directives.top = tag_directives.start;
+ tag_directives.end = tag_directives.start + 16;
+ tmp_0 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_0 = 0;
+ }
+ if (! tmp_0) goto error;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_1) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) goto error;
+ while (1) {
+ if (! (token->type == (unsigned int)YAML_VERSION_DIRECTIVE_TOKEN))
+ if (! (token->type == (unsigned int)YAML_TAG_DIRECTIVE_TOKEN))
+ break;
+ if (token->type == (unsigned int)YAML_VERSION_DIRECTIVE_TOKEN) {
+ if (version_directive) {
+ yaml_parser_set_parser_error(parser,
+ "found duplicate %YAML directive",
+ token->start_mark);
+ goto error;
+ }
+ if (token->data.version_directive.major != 1) goto _LOR;
+ else
+ if (token->data.version_directive.minor != 1)
+ if (token->data.version_directive.minor != 2) {
+ _LOR:
+ {
+ yaml_parser_set_parser_error(parser,
+ "found incompatible YAML document",
+ token->start_mark);
+ goto error;
+ }
+ }
+ version_directive = (yaml_version_directive_t *)yaml_malloc(sizeof(yaml_version_directive_t));
+ if (! version_directive) {
+ parser->error = YAML_MEMORY_ERROR;
+ goto error;
+ }
+ version_directive->major = token->data.version_directive.major;
+ version_directive->minor = token->data.version_directive.minor;
+ }
+ else
+ if (token->type == (unsigned int)YAML_TAG_DIRECTIVE_TOKEN) {
+ yaml_tag_directive_t value;
+ int tmp_3;
+ int tmp_6;
+ value.handle = token->data.tag_directive.handle;
+ value.prefix = token->data.tag_directive.prefix;
+ tmp_3 = yaml_parser_append_tag_directive(parser,value,0,
+ token->start_mark);
+ if (! tmp_3) goto error;
+ if (tag_directives.top != tag_directives.end) goto _LOR_0;
+ else {
+ int tmp_4;
+ tmp_4 = yaml_stack_extend((void **)(& tag_directives.start),
+ (void **)(& tag_directives.top),
+ (void **)(& tag_directives.end));
+ if (tmp_4) {
+ yaml_tag_directive_t *tmp_5;
+ _LOR_0: tmp_5 = tag_directives.top;
+ (tag_directives.top) ++;
+ *tmp_5 = value;
+ tmp_6 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_6 = 0;
+ }
+ }
+ if (! tmp_6) goto error;
+ }
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ parser->stream_end_produced = (parser->tokens.head)->type == (unsigned int)YAML_STREAM_END_TOKEN;
+ (parser->tokens.head) ++;
+ if (parser->token_available) token = parser->tokens.head;
+ else {
+ int tmp_7;
+ tmp_7 = yaml_parser_fetch_more_tokens(parser);
+ if (tmp_7) token = parser->tokens.head; else token = (yaml_token_t *)0;
+ }
+ if (! token) goto error;
+ }
+ default_tag_directive = default_tag_directives;
+ while (default_tag_directive->handle) {
+ {
+ int tmp_8;
+ tmp_8 = yaml_parser_append_tag_directive(parser,*default_tag_directive,
+ 1,token->start_mark);
+ if (! tmp_8) goto error;
+ }
+ default_tag_directive ++;
+ }
+ if (version_directive_ref) *version_directive_ref = version_directive;
+ if (tag_directives_start_ref)
+ if (tag_directives.start == tag_directives.top) {
+ yaml_tag_directive_t *tmp_9;
+ tmp_9 = (yaml_tag_directive_t *)0;
+ *tag_directives_end_ref = tmp_9;
+ *tag_directives_start_ref = tmp_9;
+ yaml_free((void *)tag_directives.start);
+ tag_directives.end = (yaml_tag_directive_t *)0;
+ tag_directives.top = tag_directives.end;
+ tag_directives.start = tag_directives.top;
+ }
+ else {
+ *tag_directives_start_ref = tag_directives.start;
+ *tag_directives_end_ref = tag_directives.top;
+ }
+ else {
+ yaml_free((void *)tag_directives.start);
+ tag_directives.end = (yaml_tag_directive_t *)0;
+ tag_directives.top = tag_directives.end;
+ tag_directives.start = tag_directives.top;
+ }
+ if (! version_directive_ref) yaml_free((void *)version_directive);
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)version_directive);
+ while (! (tag_directives.start == tag_directives.top)) {
+ (tag_directives.top) --;
+ yaml_tag_directive_t tag_directive = *(tag_directives.top);
+ yaml_free((void *)tag_directive.handle);
+ yaml_free((void *)tag_directive.prefix);
+ }
+ yaml_free((void *)tag_directives.start);
+ tag_directives.end = (yaml_tag_directive_t *)0;
+ tag_directives.top = tag_directives.end;
+ tag_directives.start = tag_directives.top;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_append_tag_directive(yaml_parser_t *parser,
+ yaml_tag_directive_t value,
+ int allow_duplicates,
+ yaml_mark_t mark)
+{
+ int __retres;
+ yaml_tag_directive_t *tag_directive;
+ int tmp_3;
+ yaml_tag_directive_t copy =
+ {.handle = (yaml_char_t *)0, .prefix = (yaml_char_t *)0};
+ tag_directive = parser->tag_directives.start;
+ while (tag_directive != parser->tag_directives.top) {
+ {
+ int tmp_0;
+ tmp_0 = strcmp((char const *)value.handle,
+ (char const *)tag_directive->handle);
+ if (tmp_0 == 0) {
+ int tmp;
+ if (allow_duplicates) {
+ __retres = 1;
+ goto return_label;
+ }
+ tmp = yaml_parser_set_parser_error(parser,
+ "found duplicate %TAG directive",
+ mark);
+ __retres = tmp;
+ goto return_label;
+ }
+ }
+ tag_directive ++;
+ }
+ copy.handle = yaml_strdup((yaml_char_t const *)value.handle);
+ copy.prefix = yaml_strdup((yaml_char_t const *)value.prefix);
+ if (! copy.handle) goto _LOR;
+ else
+ if (! copy.prefix) {
+ _LOR: {
+ parser->error = YAML_MEMORY_ERROR;
+ goto error;
+ }
+ }
+ if (parser->tag_directives.top != parser->tag_directives.end) goto _LOR_0;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_stack_extend((void **)(& parser->tag_directives.start),
+ (void **)(& parser->tag_directives.top),
+ (void **)(& parser->tag_directives.end));
+ if (tmp_1) {
+ yaml_tag_directive_t *tmp_2;
+ _LOR_0: tmp_2 = parser->tag_directives.top;
+ (parser->tag_directives.top) ++;
+ *tmp_2 = copy;
+ tmp_3 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) goto error;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)copy.handle);
+ yaml_free((void *)copy.prefix);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_set_reader_error(yaml_parser_t *parser,
+ char const *problem, size_t offset,
+ int value);
+
+static int yaml_parser_update_raw_buffer(yaml_parser_t *parser);
+
+static int yaml_parser_determine_encoding(yaml_parser_t *parser);
+
+static int yaml_parser_set_reader_error(yaml_parser_t *parser,
+ char const *problem, size_t offset,
+ int value)
+{
+ int __retres;
+ parser->error = YAML_READER_ERROR;
+ parser->problem = problem;
+ parser->problem_offset = offset;
+ parser->problem_value = value;
+ __retres = 0;
+ return __retres;
+}
+
+static int yaml_parser_determine_encoding(yaml_parser_t *parser)
+{
+ int __retres;
+ while (1) {
+ if (! parser->eof) {
+ if (! (parser->raw_buffer.last - parser->raw_buffer.pointer < (long)3))
+ break;
+ }
+ else break;
+ {
+ int tmp;
+ tmp = yaml_parser_update_raw_buffer(parser);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ if (parser->raw_buffer.last - parser->raw_buffer.pointer >= (long)2) {
+ int tmp_2;
+ tmp_2 = memcmp((void const *)parser->raw_buffer.pointer,
+ (void const *)"\377\376",(unsigned long)2);
+ if (tmp_2) goto _LAND_1;
+ else {
+ parser->encoding = YAML_UTF16LE_ENCODING;
+ parser->raw_buffer.pointer += 2;
+ parser->offset += (size_t)2;
+ }
+ }
+ else {
+ _LAND_1: ;
+ if (parser->raw_buffer.last - parser->raw_buffer.pointer >= (long)2) {
+ int tmp_1;
+ tmp_1 = memcmp((void const *)parser->raw_buffer.pointer,
+ (void const *)"\376\377",(unsigned long)2);
+ if (tmp_1) goto _LAND_0;
+ else {
+ parser->encoding = YAML_UTF16BE_ENCODING;
+ parser->raw_buffer.pointer += 2;
+ parser->offset += (size_t)2;
+ }
+ }
+ else {
+ _LAND_0: ;
+ if (parser->raw_buffer.last - parser->raw_buffer.pointer >= (long)3) {
+ int tmp_0;
+ tmp_0 = memcmp((void const *)parser->raw_buffer.pointer,
+ (void const *)"\357\273\277",(unsigned long)3);
+ if (tmp_0) goto _LAND;
+ else {
+ parser->encoding = YAML_UTF8_ENCODING;
+ parser->raw_buffer.pointer += 3;
+ parser->offset += (size_t)3;
+ }
+ }
+ else _LAND: parser->encoding = YAML_UTF8_ENCODING;
+ }
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_update_raw_buffer(yaml_parser_t *parser)
+{
+ int __retres;
+ int tmp_0;
+ size_t size_read = (unsigned long)0;
+ if (parser->raw_buffer.start == parser->raw_buffer.pointer)
+ if (parser->raw_buffer.last == parser->raw_buffer.end) {
+ __retres = 1;
+ goto return_label;
+ }
+ if (parser->eof) {
+ __retres = 1;
+ goto return_label;
+ }
+ if (parser->raw_buffer.start < parser->raw_buffer.pointer)
+ if (parser->raw_buffer.pointer < parser->raw_buffer.last) memmove
+ ((void *)parser->raw_buffer.start,
+ (void const *)parser->raw_buffer.pointer,
+ (unsigned long)(
+ parser->raw_buffer.last - parser->raw_buffer.pointer));
+ parser->raw_buffer.last -= parser->raw_buffer.pointer - parser->raw_buffer.start;
+ parser->raw_buffer.pointer = parser->raw_buffer.start;
+ tmp_0 = (*(parser->read_handler))(parser->read_handler_data,
+ parser->raw_buffer.last,
+ (unsigned long)(parser->raw_buffer.end - parser->raw_buffer.last),
+ & size_read);
+ if (! tmp_0) {
+ int tmp;
+ tmp = yaml_parser_set_reader_error(parser,"input error",parser->offset,
+ -1);
+ __retres = tmp;
+ goto return_label;
+ }
+ parser->raw_buffer.last += size_read;
+ if (! size_read) parser->eof = 1;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+int yaml_parser_update_buffer(yaml_parser_t *parser, size_t length)
+{
+ int __retres;
+ int first = 1;
+ __FC_assert(parser->read_handler != (yaml_read_handler_t *)0,
+ "src/reader.c",146,"parser->read_handler");
+ if (parser->eof)
+ if (parser->raw_buffer.pointer == parser->raw_buffer.last) {
+ __retres = 1;
+ goto return_label;
+ }
+ if (parser->unread >= length) {
+ __retres = 1;
+ goto return_label;
+ }
+ if (! parser->encoding) {
+ int tmp;
+ tmp = yaml_parser_determine_encoding(parser);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (parser->buffer.start < parser->buffer.pointer) {
+ if (parser->buffer.pointer < parser->buffer.last) {
+ size_t size =
+ (unsigned long)(parser->buffer.last - parser->buffer.pointer);
+ memmove((void *)parser->buffer.start,
+ (void const *)parser->buffer.pointer,size);
+ parser->buffer.pointer = parser->buffer.start;
+ parser->buffer.last = parser->buffer.start + size;
+ }
+ else goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (parser->buffer.pointer == parser->buffer.last) {
+ parser->buffer.pointer = parser->buffer.start;
+ parser->buffer.last = parser->buffer.start;
+ }
+ }
+ while (parser->unread < length) {
+ if (! first) goto _LOR;
+ else
+ if (parser->raw_buffer.pointer == parser->raw_buffer.last) {
+ _LOR:
+ {
+ int tmp_0;
+ tmp_0 = yaml_parser_update_raw_buffer(parser);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ first = 0;
+ while (parser->raw_buffer.pointer != parser->raw_buffer.last) {
+ unsigned char octet;
+ int low;
+ int high;
+ size_t k;
+ unsigned int value = (unsigned int)0;
+ unsigned int value2 = (unsigned int)0;
+ int incomplete = 0;
+ unsigned int width = (unsigned int)0;
+ size_t raw_unread =
+ (unsigned long)(parser->raw_buffer.last - parser->raw_buffer.pointer);
+ switch (parser->encoding) {
+ case (yaml_encoding_t)YAML_UTF8_ENCODING:
+ octet = *(parser->raw_buffer.pointer + 0);
+ if (((int)octet & 0x80) == 0x00) width = (unsigned int)1;
+ else {
+ int tmp_3;
+ if (((int)octet & 0xE0) == 0xC0) tmp_3 = 2;
+ else {
+ int tmp_2;
+ if (((int)octet & 0xF0) == 0xE0) tmp_2 = 3;
+ else {
+ int tmp_1;
+ if (((int)octet & 0xF8) == 0xF0) tmp_1 = 4; else tmp_1 = 0;
+ tmp_2 = tmp_1;
+ }
+ tmp_3 = tmp_2;
+ }
+ width = (unsigned int)tmp_3;
+ }
+ if (! width) {
+ int tmp_4;
+ tmp_4 = yaml_parser_set_reader_error(parser,
+ "invalid leading UTF-8 octet",
+ parser->offset,(int)octet);
+ __retres = tmp_4;
+ goto return_label;
+ }
+ if ((size_t)width > raw_unread) {
+ if (parser->eof) {
+ int tmp_5;
+ tmp_5 = yaml_parser_set_reader_error(parser,
+ "incomplete UTF-8 octet sequence",
+ parser->offset,-1);
+ __retres = tmp_5;
+ goto return_label;
+ }
+ incomplete = 1;
+ break;
+ }
+ if (((int)octet & 0x80) == 0x00) value = (unsigned int)((int)octet & 0x7F);
+ else {
+ int tmp_8;
+ if (((int)octet & 0xE0) == 0xC0) tmp_8 = (int)octet & 0x1F;
+ else {
+ int tmp_7;
+ if (((int)octet & 0xF0) == 0xE0) tmp_7 = (int)octet & 0x0F;
+ else {
+ int tmp_6;
+ if (((int)octet & 0xF8) == 0xF0) tmp_6 = (int)octet & 0x07;
+ else tmp_6 = 0;
+ tmp_7 = tmp_6;
+ }
+ tmp_8 = tmp_7;
+ }
+ value = (unsigned int)tmp_8;
+ }
+ k = (unsigned long)1;
+ while (k < (size_t)width) {
+ octet = *(parser->raw_buffer.pointer + k);
+ if (((int)octet & 0xC0) != 0x80) {
+ int tmp_9;
+ tmp_9 = yaml_parser_set_reader_error(parser,
+ "invalid trailing UTF-8 octet",
+ parser->offset + k,
+ (int)octet);
+ __retres = tmp_9;
+ goto return_label;
+ }
+ value = (value << 6) + (unsigned int)((int)octet & 0x3F);
+ k += (size_t)1;
+ }
+ if (! (width == (unsigned int)1))
+ if (width == (unsigned int)2) {
+ if (! (value >= (unsigned int)0x80)) goto _LAND_2;
+ }
+ else {
+ _LAND_2: ;
+ if (width == (unsigned int)3) {
+ if (! (value >= (unsigned int)0x800)) goto _LAND_1;
+ }
+ else {
+ _LAND_1: ;
+ if (width == (unsigned int)4) {
+ if (! (value >= (unsigned int)0x10000)) goto _LAND_0;
+ }
+ else {
+ int tmp_10;
+ _LAND_0:
+ tmp_10 = yaml_parser_set_reader_error(parser,
+ "invalid length of a UTF-8 sequence",
+ parser->offset,-1);
+ __retres = tmp_10;
+ goto return_label;
+ }
+ }
+ }
+ if (value >= (unsigned int)0xD800) {
+ if (value <= (unsigned int)0xDFFF) goto _LOR_0; else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if (value > (unsigned int)0x10FFFF) {
+ int tmp_11;
+ _LOR_0:
+ tmp_11 = yaml_parser_set_reader_error(parser,
+ "invalid Unicode character",
+ parser->offset,(int)value);
+ __retres = tmp_11;
+ goto return_label;
+ }
+ }
+ break;
+ case (yaml_encoding_t)YAML_UTF16LE_ENCODING:
+ case (yaml_encoding_t)YAML_UTF16BE_ENCODING:
+ if (parser->encoding == (unsigned int)YAML_UTF16LE_ENCODING)
+ low = 0;
+ else low = 1;
+ if (parser->encoding == (unsigned int)YAML_UTF16LE_ENCODING)
+ high = 1;
+ else high = 0;
+ if (raw_unread < (size_t)2) {
+ if (parser->eof) {
+ int tmp_12;
+ tmp_12 = yaml_parser_set_reader_error(parser,
+ "incomplete UTF-16 character",
+ parser->offset,-1);
+ __retres = tmp_12;
+ goto return_label;
+ }
+ incomplete = 1;
+ break;
+ }
+ value = (unsigned int)((int)*(parser->raw_buffer.pointer + low) + (
+ (int)*(parser->raw_buffer.pointer + high) << 8));
+ if ((value & (unsigned int)0xFC00) == (unsigned int)0xDC00) {
+ int tmp_13;
+ tmp_13 = yaml_parser_set_reader_error(parser,
+ "unexpected low surrogate area",
+ parser->offset,(int)value);
+ __retres = tmp_13;
+ goto return_label;
+ }
+ if ((value & (unsigned int)0xFC00) == (unsigned int)0xD800) {
+ width = (unsigned int)4;
+ if (raw_unread < (size_t)4) {
+ if (parser->eof) {
+ int tmp_14;
+ tmp_14 = yaml_parser_set_reader_error(parser,
+ "incomplete UTF-16 surrogate pair",
+ parser->offset,-1);
+ __retres = tmp_14;
+ goto return_label;
+ }
+ incomplete = 1;
+ break;
+ }
+ value2 = (unsigned int)((int)*(parser->raw_buffer.pointer + (
+ low + 2)) + ((int)*(parser->raw_buffer.pointer + (
+ high + 2)) << 8));
+ if ((value2 & (unsigned int)0xFC00) != (unsigned int)0xDC00) {
+ int tmp_15;
+ tmp_15 = yaml_parser_set_reader_error(parser,
+ "expected low surrogate area",
+ parser->offset + (size_t)2,
+ (int)value2);
+ __retres = tmp_15;
+ goto return_label;
+ }
+ value = ((unsigned int)0x10000 + ((value & (unsigned int)0x3FF) << 10)) + (
+ value2 & (unsigned int)0x3FF);
+ }
+ else width = (unsigned int)2;
+ break;
+ default: __FC_assert(1 != 0,"src/reader.c",397,"1");
+ }
+ if (incomplete) break;
+ if (! (value == (unsigned int)0x09))
+ if (! (value == (unsigned int)0x0A))
+ if (! (value == (unsigned int)0x0D))
+ if (value >= (unsigned int)0x20) {
+ if (! (value <= (unsigned int)0x7E)) goto _LAND_7;
+ }
+ else {
+ _LAND_7: ;
+ if (! (value == (unsigned int)0x85))
+ if (value >= (unsigned int)0xA0) {
+ if (! (value <= (unsigned int)0xD7FF)) goto _LAND_6;
+ }
+ else {
+ _LAND_6: ;
+ if (value >= (unsigned int)0xE000) {
+ if (! (value <= (unsigned int)0xFFFD)) goto _LAND_5;
+ }
+ else {
+ _LAND_5: ;
+ if (value >= (unsigned int)0x10000) {
+ if (! (value <= (unsigned int)0x10FFFF)) goto _LAND_4;
+ }
+ else {
+ int tmp_16;
+ _LAND_4:
+ tmp_16 = yaml_parser_set_reader_error(parser,
+ "control characters are not allowed",
+ parser->offset,
+ (int)value);
+ __retres = tmp_16;
+ goto return_label;
+ }
+ }
+ }
+ }
+ parser->raw_buffer.pointer += width;
+ parser->offset += (size_t)width;
+ if (value <= (unsigned int)0x7F) {
+ yaml_char_t *tmp_17;
+ tmp_17 = parser->buffer.last;
+ (parser->buffer.last) ++;
+ *tmp_17 = (unsigned char)value;
+ }
+ else
+ if (value <= (unsigned int)0x7FF) {
+ yaml_char_t *tmp_18;
+ yaml_char_t *tmp_19;
+ tmp_18 = parser->buffer.last;
+ (parser->buffer.last) ++;
+ *tmp_18 = (unsigned char)((unsigned int)0xC0 + (value >> 6));
+ tmp_19 = parser->buffer.last;
+ (parser->buffer.last) ++;
+ *tmp_19 = (unsigned char)((unsigned int)0x80 + (value & (unsigned int)0x3F));
+ }
+ else
+ if (value <= (unsigned int)0xFFFF) {
+ yaml_char_t *tmp_20;
+ yaml_char_t *tmp_21;
+ yaml_char_t *tmp_22;
+ tmp_20 = parser->buffer.last;
+ (parser->buffer.last) ++;
+ *tmp_20 = (unsigned char)((unsigned int)0xE0 + (value >> 12));
+ tmp_21 = parser->buffer.last;
+ (parser->buffer.last) ++;
+ *tmp_21 = (unsigned char)((unsigned int)0x80 + ((value >> 6) & (unsigned int)0x3F));
+ tmp_22 = parser->buffer.last;
+ (parser->buffer.last) ++;
+ *tmp_22 = (unsigned char)((unsigned int)0x80 + (value & (unsigned int)0x3F));
+ }
+ else {
+ yaml_char_t *tmp_23;
+ yaml_char_t *tmp_24;
+ yaml_char_t *tmp_25;
+ yaml_char_t *tmp_26;
+ tmp_23 = parser->buffer.last;
+ (parser->buffer.last) ++;
+ *tmp_23 = (unsigned char)((unsigned int)0xF0 + (value >> 18));
+ tmp_24 = parser->buffer.last;
+ (parser->buffer.last) ++;
+ *tmp_24 = (unsigned char)((unsigned int)0x80 + ((value >> 12) & (unsigned int)0x3F));
+ tmp_25 = parser->buffer.last;
+ (parser->buffer.last) ++;
+ *tmp_25 = (unsigned char)((unsigned int)0x80 + ((value >> 6) & (unsigned int)0x3F));
+ tmp_26 = parser->buffer.last;
+ (parser->buffer.last) ++;
+ *tmp_26 = (unsigned char)((unsigned int)0x80 + (value & (unsigned int)0x3F));
+ }
+ parser->unread += (size_t)1;
+ }
+ if (parser->eof) {
+ yaml_char_t *tmp_27;
+ tmp_27 = parser->buffer.last;
+ (parser->buffer.last) ++;
+ *tmp_27 = (unsigned char)'\000';
+ parser->unread += (size_t)1;
+ __retres = 1;
+ goto return_label;
+ }
+ }
+ if (parser->offset >= ~ ((unsigned long)0) / (unsigned long)2) {
+ int tmp_28;
+ tmp_28 = yaml_parser_set_reader_error(parser,"input is too long",
+ parser->offset,-1);
+ __retres = tmp_28;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_set_scanner_error(yaml_parser_t *parser,
+ char const *context,
+ yaml_mark_t context_mark,
+ char const *problem);
+
+static int yaml_parser_fetch_next_token(yaml_parser_t *parser);
+
+static int yaml_parser_stale_simple_keys(yaml_parser_t *parser);
+
+static int yaml_parser_save_simple_key(yaml_parser_t *parser);
+
+static int yaml_parser_remove_simple_key(yaml_parser_t *parser);
+
+static int yaml_parser_increase_flow_level(yaml_parser_t *parser);
+
+static int yaml_parser_decrease_flow_level(yaml_parser_t *parser);
+
+static int yaml_parser_roll_indent(yaml_parser_t *parser, ptrdiff_t column,
+ ptrdiff_t number, yaml_token_type_t type,
+ yaml_mark_t mark);
+
+static int yaml_parser_unroll_indent(yaml_parser_t *parser, ptrdiff_t column);
+
+static int yaml_parser_fetch_stream_start(yaml_parser_t *parser);
+
+static int yaml_parser_fetch_stream_end(yaml_parser_t *parser);
+
+static int yaml_parser_fetch_directive(yaml_parser_t *parser);
+
+static int yaml_parser_fetch_document_indicator(yaml_parser_t *parser,
+ yaml_token_type_t type);
+
+static int yaml_parser_fetch_flow_collection_start(yaml_parser_t *parser,
+ yaml_token_type_t type);
+
+static int yaml_parser_fetch_flow_collection_end(yaml_parser_t *parser,
+ yaml_token_type_t type);
+
+static int yaml_parser_fetch_flow_entry(yaml_parser_t *parser);
+
+static int yaml_parser_fetch_block_entry(yaml_parser_t *parser);
+
+static int yaml_parser_fetch_key(yaml_parser_t *parser);
+
+static int yaml_parser_fetch_value(yaml_parser_t *parser);
+
+static int yaml_parser_fetch_anchor(yaml_parser_t *parser,
+ yaml_token_type_t type);
+
+static int yaml_parser_fetch_tag(yaml_parser_t *parser);
+
+static int yaml_parser_fetch_block_scalar(yaml_parser_t *parser, int literal);
+
+static int yaml_parser_fetch_flow_scalar(yaml_parser_t *parser, int single);
+
+static int yaml_parser_fetch_plain_scalar(yaml_parser_t *parser);
+
+static int yaml_parser_scan_to_next_token(yaml_parser_t *parser);
+
+static int yaml_parser_scan_directive(yaml_parser_t *parser,
+ yaml_token_t *token);
+
+static int yaml_parser_scan_directive_name(yaml_parser_t *parser,
+ yaml_mark_t start_mark,
+ yaml_char_t **name);
+
+static int yaml_parser_scan_version_directive_value(yaml_parser_t *parser,
+ yaml_mark_t start_mark,
+ int *major, int *minor);
+
+static int yaml_parser_scan_version_directive_number(yaml_parser_t *parser,
+ yaml_mark_t start_mark,
+ int *number);
+
+static int yaml_parser_scan_tag_directive_value(yaml_parser_t *parser,
+ yaml_mark_t start_mark,
+ yaml_char_t **handle,
+ yaml_char_t **prefix);
+
+static int yaml_parser_scan_anchor(yaml_parser_t *parser,
+ yaml_token_t *token,
+ yaml_token_type_t type);
+
+static int yaml_parser_scan_tag(yaml_parser_t *parser, yaml_token_t *token);
+
+static int yaml_parser_scan_tag_handle(yaml_parser_t *parser, int directive,
+ yaml_mark_t start_mark,
+ yaml_char_t **handle);
+
+static int yaml_parser_scan_tag_uri(yaml_parser_t *parser, int uri_char,
+ int directive, yaml_char_t *head,
+ yaml_mark_t start_mark, yaml_char_t **uri);
+
+static int yaml_parser_scan_uri_escapes(yaml_parser_t *parser, int directive,
+ yaml_mark_t start_mark,
+ yaml_string_t *string);
+
+static int yaml_parser_scan_block_scalar(yaml_parser_t *parser,
+ yaml_token_t *token, int literal);
+
+static int yaml_parser_scan_block_scalar_breaks(yaml_parser_t *parser,
+ int *indent,
+ yaml_string_t *breaks,
+ yaml_mark_t start_mark,
+ yaml_mark_t *end_mark);
+
+static int yaml_parser_scan_flow_scalar(yaml_parser_t *parser,
+ yaml_token_t *token, int single);
+
+static int yaml_parser_scan_plain_scalar(yaml_parser_t *parser,
+ yaml_token_t *token);
+
+int yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token)
+{
+ int __retres;
+ yaml_token_t *tmp_0;
+ __FC_assert(parser != (yaml_parser_t *)0,"src/scanner.c",745,"parser");
+ __FC_assert(token != (yaml_token_t *)0,"src/scanner.c",746,"token");
+ memset((void *)token,0,sizeof(yaml_token_t));
+ if (parser->stream_end_produced) goto _LOR;
+ else
+ if (parser->error) {
+ _LOR: {
+ __retres = 1;
+ goto return_label;
+ }
+ }
+ if (! parser->token_available) {
+ int tmp;
+ tmp = yaml_parser_fetch_more_tokens(parser);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ tmp_0 = parser->tokens.head;
+ (parser->tokens.head) ++;
+ *token = *tmp_0;
+ parser->token_available = 0;
+ parser->tokens_parsed += (size_t)1;
+ if (token->type == (unsigned int)YAML_STREAM_END_TOKEN) parser->stream_end_produced = 1;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_set_scanner_error(yaml_parser_t *parser,
+ char const *context,
+ yaml_mark_t context_mark,
+ char const *problem)
+{
+ int __retres;
+ parser->error = YAML_SCANNER_ERROR;
+ parser->context = context;
+ parser->context_mark = context_mark;
+ parser->problem = problem;
+ parser->problem_mark = parser->mark;
+ __retres = 0;
+ return __retres;
+}
+
+int yaml_parser_fetch_more_tokens(yaml_parser_t *parser)
+{
+ int __retres;
+ int need_more_tokens;
+ while (1) {
+ {
+ int tmp_0;
+ need_more_tokens = 0;
+ if (parser->tokens.head == parser->tokens.tail) need_more_tokens = 1;
+ else {
+ yaml_simple_key_t *simple_key;
+ int tmp;
+ tmp = yaml_parser_stale_simple_keys(parser);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ simple_key = parser->simple_keys.start;
+ while (simple_key != parser->simple_keys.top) {
+ if (simple_key->possible)
+ if (simple_key->token_number == parser->tokens_parsed) {
+ need_more_tokens = 1;
+ break;
+ }
+ simple_key ++;
+ }
+ }
+ if (! need_more_tokens) break;
+ tmp_0 = yaml_parser_fetch_next_token(parser);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ parser->token_available = 1;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_next_token(yaml_parser_t *parser)
+{
+ int __retres;
+ int tmp_0;
+ int tmp_2;
+ int tmp_3;
+ int tmp_4;
+ int tmp_6;
+ int tmp_27;
+ if (parser->unread >= (size_t)1) tmp_0 = 1;
+ else tmp_0 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (! parser->stream_start_produced) {
+ int tmp_1;
+ tmp_1 = yaml_parser_fetch_stream_start(parser);
+ __retres = tmp_1;
+ goto return_label;
+ }
+ tmp_2 = yaml_parser_scan_to_next_token(parser);
+ if (! tmp_2) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_3 = yaml_parser_stale_simple_keys(parser);
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_4 = yaml_parser_unroll_indent(parser,(long)parser->mark.column);
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (parser->unread >= (size_t)4) tmp_6 = 1;
+ else tmp_6 = yaml_parser_update_buffer(parser,(unsigned long)4);
+ if (! tmp_6) {
+ __retres = 0;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000')) {
+ int tmp_7;
+ tmp_7 = yaml_parser_fetch_stream_end(parser);
+ __retres = tmp_7;
+ goto return_label;
+ }
+ if (parser->mark.column == (size_t)0)
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'%')) {
+ int tmp_8;
+ tmp_8 = yaml_parser_fetch_directive(parser);
+ __retres = tmp_8;
+ goto return_label;
+ }
+ if (parser->mark.column == (size_t)0)
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'-'))
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'-'))
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'-'))
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)' '))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\t'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\r'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\n'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (3 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_0;
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (3 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (3 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_0;
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ _LAND_2: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (3 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (3 + 2)) == (int)((unsigned char)'\251'))
+ goto _LOR_0;
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\000')) {
+ int tmp_9;
+ _LOR_0:
+ tmp_9 = yaml_parser_fetch_document_indicator
+ (parser,YAML_DOCUMENT_START_TOKEN);
+ __retres = tmp_9;
+ goto return_label;
+ }
+ }
+ }
+ }
+ if (parser->mark.column == (size_t)0)
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'.'))
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'.'))
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'.'))
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)' '))
+ goto _LOR_2;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\t'))
+ goto _LOR_2;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\r'))
+ goto _LOR_2;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\n'))
+ goto _LOR_2;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (3 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_2;
+ else goto _LAND_8;
+ }
+ else {
+ _LAND_8: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (3 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (3 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_2;
+ else goto _LAND_7;
+ }
+ else goto _LAND_7;
+ }
+ else {
+ _LAND_7: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (3 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (3 + 2)) == (int)((unsigned char)'\251'))
+ goto _LOR_2;
+ else goto _LAND_5;
+ }
+ else goto _LAND_5;
+ }
+ else {
+ _LAND_5: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\000')) {
+ int tmp_10;
+ _LOR_2:
+ tmp_10 = yaml_parser_fetch_document_indicator
+ (parser,YAML_DOCUMENT_END_TOKEN);
+ __retres = tmp_10;
+ goto return_label;
+ }
+ }
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'[')) {
+ int tmp_11;
+ tmp_11 = yaml_parser_fetch_flow_collection_start(parser,
+ YAML_FLOW_SEQUENCE_START_TOKEN);
+ __retres = tmp_11;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'{')) {
+ int tmp_12;
+ tmp_12 = yaml_parser_fetch_flow_collection_start(parser,
+ YAML_FLOW_MAPPING_START_TOKEN);
+ __retres = tmp_12;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)']')) {
+ int tmp_13;
+ tmp_13 = yaml_parser_fetch_flow_collection_end(parser,
+ YAML_FLOW_SEQUENCE_END_TOKEN);
+ __retres = tmp_13;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'}')) {
+ int tmp_14;
+ tmp_14 = yaml_parser_fetch_flow_collection_end(parser,
+ YAML_FLOW_MAPPING_END_TOKEN);
+ __retres = tmp_14;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)',')) {
+ int tmp_15;
+ tmp_15 = yaml_parser_fetch_flow_entry(parser);
+ __retres = tmp_15;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'-'))
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)' '))
+ goto _LOR_4;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\t'))
+ goto _LOR_4;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\r'))
+ goto _LOR_4;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\n'))
+ goto _LOR_4;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_4;
+ else goto _LAND_13;
+ }
+ else {
+ _LAND_13: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (1 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_4;
+ else goto _LAND_12;
+ }
+ else goto _LAND_12;
+ }
+ else {
+ _LAND_12: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (1 + 2)) == (int)((unsigned char)'\251'))
+ goto _LOR_4;
+ else goto _LAND_10;
+ }
+ else goto _LAND_10;
+ }
+ else {
+ _LAND_10: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\000')) {
+ int tmp_16;
+ _LOR_4: tmp_16 = yaml_parser_fetch_block_entry(parser);
+ __retres = tmp_16;
+ goto return_label;
+ }
+ }
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'?'))
+ if (parser->flow_level) goto _LOR_7;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)' '))
+ goto _LOR_7;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\t'))
+ goto _LOR_7;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\r'))
+ goto _LOR_7;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\n'))
+ goto _LOR_7;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_7;
+ else goto _LAND_18;
+ }
+ else {
+ _LAND_18: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (1 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_7;
+ else goto _LAND_17;
+ }
+ else goto _LAND_17;
+ }
+ else {
+ _LAND_17: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (1 + 2)) == (int)((unsigned char)'\251'))
+ goto _LOR_7;
+ else goto _LAND_15;
+ }
+ else goto _LAND_15;
+ }
+ else {
+ _LAND_15: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\000')) {
+ int tmp_17;
+ _LOR_7: tmp_17 = yaml_parser_fetch_key(parser);
+ __retres = tmp_17;
+ goto return_label;
+ }
+ }
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)':'))
+ if (parser->flow_level) goto _LOR_10;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)' '))
+ goto _LOR_10;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\t'))
+ goto _LOR_10;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\r'))
+ goto _LOR_10;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\n'))
+ goto _LOR_10;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_10;
+ else goto _LAND_23;
+ }
+ else {
+ _LAND_23: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (1 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_10;
+ else goto _LAND_22;
+ }
+ else goto _LAND_22;
+ }
+ else {
+ _LAND_22: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (1 + 2)) == (int)((unsigned char)'\251'))
+ goto _LOR_10;
+ else goto _LAND_20;
+ }
+ else goto _LAND_20;
+ }
+ else {
+ _LAND_20: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\000')) {
+ int tmp_18;
+ _LOR_10: tmp_18 = yaml_parser_fetch_value(parser);
+ __retres = tmp_18;
+ goto return_label;
+ }
+ }
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'*')) {
+ int tmp_19;
+ tmp_19 = yaml_parser_fetch_anchor(parser,YAML_ALIAS_TOKEN);
+ __retres = tmp_19;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'&')) {
+ int tmp_20;
+ tmp_20 = yaml_parser_fetch_anchor(parser,YAML_ANCHOR_TOKEN);
+ __retres = tmp_20;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'!')) {
+ int tmp_21;
+ tmp_21 = yaml_parser_fetch_tag(parser);
+ __retres = tmp_21;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'|'))
+ if (! parser->flow_level) {
+ int tmp_22;
+ tmp_22 = yaml_parser_fetch_block_scalar(parser,1);
+ __retres = tmp_22;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'>'))
+ if (! parser->flow_level) {
+ int tmp_23;
+ tmp_23 = yaml_parser_fetch_block_scalar(parser,0);
+ __retres = tmp_23;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\'')) {
+ int tmp_24;
+ tmp_24 = yaml_parser_fetch_flow_scalar(parser,1);
+ __retres = tmp_24;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\"')) {
+ int tmp_25;
+ tmp_25 = yaml_parser_fetch_flow_scalar(parser,0);
+ __retres = tmp_25;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' '))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_13;
+ else goto _LAND_34;
+ }
+ else {
+ _LAND_34: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_13;
+ else goto _LAND_33;
+ }
+ else goto _LAND_33;
+ }
+ else {
+ _LAND_33: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251'))
+ goto _LOR_13;
+ else goto _LAND_31;
+ }
+ else goto _LAND_31;
+ }
+ else {
+ _LAND_31: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'-'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'?'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)':'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)','))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'['))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)']'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'{'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'}'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'#'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'&'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'*'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'!'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'|'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'>'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\''))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\"'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'%'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'@'))
+ goto _LOR_13;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'`')) {
+ _LOR_13: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'-')) {
+ if ((int)*(
+ parser->buffer.pointer + 1) == (int)((unsigned char)' '))
+ goto _LAND_29;
+ else
+ if ((int)*(
+ parser->buffer.pointer + 1) == (int)((unsigned char)'\t'))
+ goto _LAND_29;
+ else goto _LOR_11;
+ }
+ else
+ _LAND_29:
+ if (! parser->flow_level)
+ if ((int)*(
+ parser->buffer.pointer + 0) == (int)((unsigned char)'?'))
+ goto _LOR_12;
+ else
+ if ((int)*(
+ parser->buffer.pointer + 0) == (int)((unsigned char)':')) {
+ _LOR_12: ;
+ if (! (
+ (int)*(
+ parser->buffer.pointer + 1) == (int)((unsigned char)' ')))
+ if (! (
+ (int)*(
+ parser->buffer.pointer + 1) == (int)((unsigned char)'\t')))
+ if (! (
+ (int)*(
+ parser->buffer.pointer + 1) == (int)((unsigned char)'\r')))
+ if (! (
+ (int)*(
+ parser->buffer.pointer + 1) == (int)((unsigned char)'\n')))
+ if (
+ (int)*(
+ parser->buffer.pointer + 1) == (int)((unsigned char)'\302')) {
+ if (! (
+ (int)*(
+ parser->buffer.pointer + (
+ 1 + 1)) == (int)((unsigned char)'\205')))
+ goto _LAND_28;
+ }
+ else {
+ _LAND_28:
+ ;
+ if (
+ (int)*(
+ parser->buffer.pointer + 1) == (int)((unsigned char)'\342')) {
+ if (
+ (int)*(
+ parser->buffer.pointer + (
+ 1 + 1)) == (int)((unsigned char)'\200')) {
+ if (! (
+ (int)*(
+ parser->buffer.pointer + (
+ 1 + 2)) == (int)((unsigned char)'\250')))
+ goto _LAND_27;
+ }
+ else
+ goto _LAND_27;
+ }
+ else {
+ _LAND_27:
+ ;
+ if (
+ (int)*(
+ parser->buffer.pointer + 1) == (int)((unsigned char)'\342')) {
+ if (
+ (int)*(
+ parser->buffer.pointer + (
+ 1 + 1)) == (int)((unsigned char)'\200')) {
+ if (! (
+ (int)*(
+ parser->buffer.pointer + (
+ 1 + 2)) == (int)((unsigned char)'\251')))
+ goto _LAND_25;
+ }
+ else
+ goto _LAND_25;
+ }
+ else {
+ _LAND_25:
+ ;
+ if (! (
+ (int)*(
+ parser->buffer.pointer + 1) == (int)((unsigned char)'\000'))) {
+ int tmp_26;
+ _LOR_11:
+ tmp_26 = yaml_parser_fetch_plain_scalar
+ (parser);
+ __retres = tmp_26;
+ goto return_label;
+ }
+ }
+ }
+ }
+ }
+ }
+ else goto _LOR_11;
+ }
+ }
+ }
+ tmp_27 = yaml_parser_set_scanner_error(parser,
+ "while scanning for the next token",
+ parser->mark,
+ "found character that cannot start any token");
+ __retres = tmp_27;
+ return_label: return __retres;
+}
+
+static int yaml_parser_stale_simple_keys(yaml_parser_t *parser)
+{
+ int __retres;
+ yaml_simple_key_t *simple_key;
+ simple_key = parser->simple_keys.start;
+ while (simple_key != parser->simple_keys.top) {
+ if (simple_key->possible)
+ if (simple_key->mark.line < parser->mark.line) goto _LOR;
+ else
+ if (simple_key->mark.index + (size_t)1024 < parser->mark.index) {
+ _LOR:
+ {
+ if (simple_key->required) {
+ int tmp;
+ tmp = yaml_parser_set_scanner_error(parser,
+ "while scanning a simple key",
+ simple_key->mark,
+ "could not find expected \':\'");
+ __retres = tmp;
+ goto return_label;
+ }
+ simple_key->possible = 0;
+ }
+ }
+ simple_key ++;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_save_simple_key(yaml_parser_t *parser)
+{
+ int __retres;
+ int tmp;
+ if (! parser->flow_level)
+ if ((long)parser->indent == (long)parser->mark.column) tmp = 1;
+ else tmp = 0;
+ else tmp = 0;
+ int required = tmp;
+ if (parser->simple_key_allowed) {
+ yaml_simple_key_t simple_key;
+ int tmp_0;
+ simple_key.possible = 1;
+ simple_key.required = required;
+ simple_key.token_number = parser->tokens_parsed + (size_t)(parser->tokens.tail - parser->tokens.head);
+ simple_key.mark = parser->mark;
+ tmp_0 = yaml_parser_remove_simple_key(parser);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ *(parser->simple_keys.top - 1) = simple_key;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_remove_simple_key(yaml_parser_t *parser)
+{
+ int __retres;
+ yaml_simple_key_t *simple_key = parser->simple_keys.top - 1;
+ if (simple_key->possible)
+ if (simple_key->required) {
+ int tmp;
+ tmp = yaml_parser_set_scanner_error(parser,
+ "while scanning a simple key",
+ simple_key->mark,
+ "could not find expected \':\'");
+ __retres = tmp;
+ goto return_label;
+ }
+ simple_key->possible = 0;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_increase_flow_level(yaml_parser_t *parser)
+{
+ int __retres;
+ int tmp_1;
+ yaml_simple_key_t empty_simple_key =
+ {.possible = 0,
+ .required = 0,
+ .token_number = (unsigned long)0,
+ .mark = {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0}};
+ if (parser->simple_keys.top != parser->simple_keys.end) goto _LOR;
+ else {
+ int tmp;
+ tmp = yaml_stack_extend((void **)(& parser->simple_keys.start),
+ (void **)(& parser->simple_keys.top),
+ (void **)(& parser->simple_keys.end));
+ if (tmp) {
+ yaml_simple_key_t *tmp_0;
+ _LOR: tmp_0 = parser->simple_keys.top;
+ (parser->simple_keys.top) ++;
+ *tmp_0 = empty_simple_key;
+ tmp_1 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_1 = 0;
+ }
+ }
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (parser->flow_level == 2147483647) {
+ parser->error = YAML_MEMORY_ERROR;
+ __retres = 0;
+ goto return_label;
+ }
+ (parser->flow_level) ++;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_decrease_flow_level(yaml_parser_t *parser)
+{
+ int __retres;
+ if (parser->flow_level) {
+ (parser->flow_level) --;
+ (parser->simple_keys.top) --;
+ ;
+ }
+ __retres = 1;
+ return __retres;
+}
+
+static int yaml_parser_roll_indent(yaml_parser_t *parser, ptrdiff_t column,
+ ptrdiff_t number, yaml_token_type_t type,
+ yaml_mark_t mark)
+{
+ int __retres;
+ yaml_token_t token;
+ if (parser->flow_level) {
+ __retres = 1;
+ goto return_label;
+ }
+ if ((ptrdiff_t)parser->indent < column) {
+ int tmp_1;
+ if (parser->indents.top != parser->indents.end) goto _LOR;
+ else {
+ int tmp;
+ tmp = yaml_stack_extend((void **)(& parser->indents.start),
+ (void **)(& parser->indents.top),
+ (void **)(& parser->indents.end));
+ if (tmp) {
+ int *tmp_0;
+ _LOR: tmp_0 = parser->indents.top;
+ (parser->indents.top) ++;
+ *tmp_0 = parser->indent;
+ tmp_1 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_1 = 0;
+ }
+ }
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (column > (ptrdiff_t)2147483647) {
+ parser->error = YAML_MEMORY_ERROR;
+ __retres = 0;
+ goto return_label;
+ }
+ parser->indent = (int)column;
+ memset((void *)(& token),0,sizeof(yaml_token_t));
+ token.type = type;
+ token.start_mark = mark;
+ token.end_mark = mark;
+ if (number == (ptrdiff_t)(-1)) {
+ int tmp_4;
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR_0;
+ else {
+ int tmp_2;
+ tmp_2 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_2) {
+ yaml_token_t *tmp_3;
+ _LOR_0: tmp_3 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_3 = token;
+ tmp_4 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_4 = 0;
+ }
+ }
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ else {
+ int tmp_6;
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR_1;
+ else {
+ int tmp_5;
+ tmp_5 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_5) {
+ _LOR_1:
+ {
+ memmove((void *)((parser->tokens.head + ((size_t)number - parser->tokens_parsed)) + 1),
+ (void const *)(parser->tokens.head + ((size_t)number - parser->tokens_parsed)),
+ ((size_t)(parser->tokens.tail - parser->tokens.head) - (
+ (size_t)number - parser->tokens_parsed)) * sizeof(*(parser->tokens.start)));
+ *(parser->tokens.head + ((size_t)number - parser->tokens_parsed)) = token;
+ (parser->tokens.tail) ++;
+ }
+ tmp_6 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_6 = 0;
+ }
+ }
+ if (! tmp_6) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_unroll_indent(yaml_parser_t *parser, ptrdiff_t column)
+{
+ int __retres;
+ yaml_token_t token;
+ if (parser->flow_level) {
+ __retres = 1;
+ goto return_label;
+ }
+ while ((ptrdiff_t)parser->indent > column) {
+ int tmp_1;
+ memset((void *)(& token),0,sizeof(yaml_token_t));
+ token.type = YAML_BLOCK_END_TOKEN;
+ token.start_mark = parser->mark;
+ token.end_mark = parser->mark;
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp;
+ tmp = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp) {
+ yaml_token_t *tmp_0;
+ _LOR: tmp_0 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_0 = token;
+ tmp_1 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_1 = 0;
+ }
+ }
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ (parser->indents.top) --;
+ parser->indent = *(parser->indents.top);
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_stream_start(yaml_parser_t *parser)
+{
+ int __retres;
+ yaml_token_t token;
+ int tmp_1;
+ int tmp_4;
+ yaml_simple_key_t simple_key =
+ {.possible = 0,
+ .required = 0,
+ .token_number = (unsigned long)0,
+ .mark = {.index = (unsigned long)0,
+ .line = (unsigned long)0,
+ .column = (unsigned long)0}};
+ parser->indent = -1;
+ if (parser->simple_keys.top != parser->simple_keys.end) goto _LOR;
+ else {
+ int tmp;
+ tmp = yaml_stack_extend((void **)(& parser->simple_keys.start),
+ (void **)(& parser->simple_keys.top),
+ (void **)(& parser->simple_keys.end));
+ if (tmp) {
+ yaml_simple_key_t *tmp_0;
+ _LOR: tmp_0 = parser->simple_keys.top;
+ (parser->simple_keys.top) ++;
+ *tmp_0 = simple_key;
+ tmp_1 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_1 = 0;
+ }
+ }
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = 1;
+ parser->stream_start_produced = 1;
+ memset((void *)(& token),0,sizeof(yaml_token_t));
+ token.type = YAML_STREAM_START_TOKEN;
+ token.start_mark = parser->mark;
+ token.end_mark = parser->mark;
+ token.data.stream_start.encoding = parser->encoding;
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR_0;
+ else {
+ int tmp_2;
+ tmp_2 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_2) {
+ yaml_token_t *tmp_3;
+ _LOR_0: tmp_3 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_3 = token;
+ tmp_4 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_4 = 0;
+ }
+ }
+ if (! tmp_4) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_stream_end(yaml_parser_t *parser)
+{
+ int __retres;
+ yaml_token_t token;
+ int tmp;
+ int tmp_0;
+ int tmp_3;
+ if (parser->mark.column != (size_t)0) {
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ }
+ tmp = yaml_parser_unroll_indent(parser,(long)(-1));
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_0 = yaml_parser_remove_simple_key(parser);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = 0;
+ memset((void *)(& token),0,sizeof(yaml_token_t));
+ token.type = YAML_STREAM_END_TOKEN;
+ token.start_mark = parser->mark;
+ token.end_mark = parser->mark;
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_1) {
+ yaml_token_t *tmp_2;
+ _LOR: tmp_2 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_2 = token;
+ tmp_3 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_directive(yaml_parser_t *parser)
+{
+ int __retres;
+ yaml_token_t token;
+ int tmp;
+ int tmp_0;
+ int tmp_1;
+ int tmp_4;
+ tmp = yaml_parser_unroll_indent(parser,(long)(-1));
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_0 = yaml_parser_remove_simple_key(parser);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = 0;
+ tmp_1 = yaml_parser_scan_directive(parser,& token);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp_2;
+ tmp_2 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_2) {
+ yaml_token_t *tmp_3;
+ _LOR: tmp_3 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_3 = token;
+ tmp_4 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_4 = 0;
+ }
+ }
+ if (! tmp_4) {
+ yaml_token_delete(& token);
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_document_indicator(yaml_parser_t *parser,
+ yaml_token_type_t type)
+{
+ int __retres;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ yaml_token_t token;
+ int tmp;
+ int tmp_0;
+ int tmp_4;
+ int tmp_8;
+ int tmp_12;
+ int tmp_15;
+ tmp = yaml_parser_unroll_indent(parser,(long)(-1));
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_0 = yaml_parser_remove_simple_key(parser);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = 0;
+ start_mark = parser->mark;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_4 = 1;
+ else {
+ int tmp_3;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_3 = 2;
+ else {
+ int tmp_2;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_2 = 3;
+ else {
+ int tmp_1;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_1 = 4;
+ else tmp_1 = 0;
+ tmp_2 = tmp_1;
+ }
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ parser->buffer.pointer += tmp_4;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_8 = 1;
+ else {
+ int tmp_7;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_7 = 2;
+ else {
+ int tmp_6;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_6 = 3;
+ else {
+ int tmp_5;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_5 = 4;
+ else tmp_5 = 0;
+ tmp_6 = tmp_5;
+ }
+ tmp_7 = tmp_6;
+ }
+ tmp_8 = tmp_7;
+ }
+ parser->buffer.pointer += tmp_8;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_12 = 1;
+ else {
+ int tmp_11;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_11 = 2;
+ else {
+ int tmp_10;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_10 = 3;
+ else {
+ int tmp_9;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_9 = 4;
+ else tmp_9 = 0;
+ tmp_10 = tmp_9;
+ }
+ tmp_11 = tmp_10;
+ }
+ tmp_12 = tmp_11;
+ }
+ parser->buffer.pointer += tmp_12;
+ end_mark = parser->mark;
+ memset((void *)(& token),0,sizeof(yaml_token_t));
+ token.type = type;
+ token.start_mark = start_mark;
+ token.end_mark = end_mark;
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp_13;
+ tmp_13 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_13) {
+ yaml_token_t *tmp_14;
+ _LOR: tmp_14 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_14 = token;
+ tmp_15 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_15 = 0;
+ }
+ }
+ if (! tmp_15) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_flow_collection_start(yaml_parser_t *parser,
+ yaml_token_type_t type)
+{
+ int __retres;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ yaml_token_t token;
+ int tmp;
+ int tmp_0;
+ int tmp_4;
+ int tmp_7;
+ tmp = yaml_parser_save_simple_key(parser);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_0 = yaml_parser_increase_flow_level(parser);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = 1;
+ start_mark = parser->mark;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_4 = 1;
+ else {
+ int tmp_3;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_3 = 2;
+ else {
+ int tmp_2;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_2 = 3;
+ else {
+ int tmp_1;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_1 = 4;
+ else tmp_1 = 0;
+ tmp_2 = tmp_1;
+ }
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ parser->buffer.pointer += tmp_4;
+ end_mark = parser->mark;
+ memset((void *)(& token),0,sizeof(yaml_token_t));
+ token.type = type;
+ token.start_mark = start_mark;
+ token.end_mark = end_mark;
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp_5;
+ tmp_5 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_5) {
+ yaml_token_t *tmp_6;
+ _LOR: tmp_6 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_6 = token;
+ tmp_7 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_7 = 0;
+ }
+ }
+ if (! tmp_7) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_flow_collection_end(yaml_parser_t *parser,
+ yaml_token_type_t type)
+{
+ int __retres;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ yaml_token_t token;
+ int tmp;
+ int tmp_0;
+ int tmp_4;
+ int tmp_7;
+ tmp = yaml_parser_remove_simple_key(parser);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_0 = yaml_parser_decrease_flow_level(parser);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = 0;
+ start_mark = parser->mark;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_4 = 1;
+ else {
+ int tmp_3;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_3 = 2;
+ else {
+ int tmp_2;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_2 = 3;
+ else {
+ int tmp_1;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_1 = 4;
+ else tmp_1 = 0;
+ tmp_2 = tmp_1;
+ }
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ parser->buffer.pointer += tmp_4;
+ end_mark = parser->mark;
+ memset((void *)(& token),0,sizeof(yaml_token_t));
+ token.type = type;
+ token.start_mark = start_mark;
+ token.end_mark = end_mark;
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp_5;
+ tmp_5 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_5) {
+ yaml_token_t *tmp_6;
+ _LOR: tmp_6 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_6 = token;
+ tmp_7 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_7 = 0;
+ }
+ }
+ if (! tmp_7) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_flow_entry(yaml_parser_t *parser)
+{
+ int __retres;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ yaml_token_t token;
+ int tmp;
+ int tmp_3;
+ int tmp_6;
+ tmp = yaml_parser_remove_simple_key(parser);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = 1;
+ start_mark = parser->mark;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_3 = 1;
+ else {
+ int tmp_2;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_2 = 2;
+ else {
+ int tmp_1;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_1 = 3;
+ else {
+ int tmp_0;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_0 = 4;
+ else tmp_0 = 0;
+ tmp_1 = tmp_0;
+ }
+ tmp_2 = tmp_1;
+ }
+ tmp_3 = tmp_2;
+ }
+ parser->buffer.pointer += tmp_3;
+ end_mark = parser->mark;
+ memset((void *)(& token),0,sizeof(yaml_token_t));
+ token.type = YAML_FLOW_ENTRY_TOKEN;
+ token.start_mark = start_mark;
+ token.end_mark = end_mark;
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp_4;
+ tmp_4 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_4) {
+ yaml_token_t *tmp_5;
+ _LOR: tmp_5 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_5 = token;
+ tmp_6 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_6 = 0;
+ }
+ }
+ if (! tmp_6) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_block_entry(yaml_parser_t *parser)
+{
+ int __retres;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ yaml_token_t token;
+ int tmp_1;
+ int tmp_5;
+ int tmp_8;
+ if (! parser->flow_level) {
+ int tmp_0;
+ if (! parser->simple_key_allowed) {
+ int tmp;
+ tmp = yaml_parser_set_scanner_error(parser,(char const *)0,
+ parser->mark,
+ "block sequence entries are not allowed in this context");
+ __retres = tmp;
+ goto return_label;
+ }
+ tmp_0 = yaml_parser_roll_indent(parser,(long)parser->mark.column,
+ (long)(-1),
+ YAML_BLOCK_SEQUENCE_START_TOKEN,
+ parser->mark);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ tmp_1 = yaml_parser_remove_simple_key(parser);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = 1;
+ start_mark = parser->mark;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_5 = 1;
+ else {
+ int tmp_4;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_4 = 2;
+ else {
+ int tmp_3;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_3 = 3;
+ else {
+ int tmp_2;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_2 = 4;
+ else tmp_2 = 0;
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ tmp_5 = tmp_4;
+ }
+ parser->buffer.pointer += tmp_5;
+ end_mark = parser->mark;
+ memset((void *)(& token),0,sizeof(yaml_token_t));
+ token.type = YAML_BLOCK_ENTRY_TOKEN;
+ token.start_mark = start_mark;
+ token.end_mark = end_mark;
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp_6;
+ tmp_6 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_6) {
+ yaml_token_t *tmp_7;
+ _LOR: tmp_7 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_7 = token;
+ tmp_8 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_8 = 0;
+ }
+ }
+ if (! tmp_8) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_key(yaml_parser_t *parser)
+{
+ int __retres;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ yaml_token_t token;
+ int tmp_1;
+ int tmp_5;
+ int tmp_8;
+ if (! parser->flow_level) {
+ int tmp_0;
+ if (! parser->simple_key_allowed) {
+ int tmp;
+ tmp = yaml_parser_set_scanner_error(parser,(char const *)0,
+ parser->mark,
+ "mapping keys are not allowed in this context");
+ __retres = tmp;
+ goto return_label;
+ }
+ tmp_0 = yaml_parser_roll_indent(parser,(long)parser->mark.column,
+ (long)(-1),
+ YAML_BLOCK_MAPPING_START_TOKEN,
+ parser->mark);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ tmp_1 = yaml_parser_remove_simple_key(parser);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = ! parser->flow_level;
+ start_mark = parser->mark;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_5 = 1;
+ else {
+ int tmp_4;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_4 = 2;
+ else {
+ int tmp_3;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_3 = 3;
+ else {
+ int tmp_2;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_2 = 4;
+ else tmp_2 = 0;
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ tmp_5 = tmp_4;
+ }
+ parser->buffer.pointer += tmp_5;
+ end_mark = parser->mark;
+ memset((void *)(& token),0,sizeof(yaml_token_t));
+ token.type = YAML_KEY_TOKEN;
+ token.start_mark = start_mark;
+ token.end_mark = end_mark;
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp_6;
+ tmp_6 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_6) {
+ yaml_token_t *tmp_7;
+ _LOR: tmp_7 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_7 = token;
+ tmp_8 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_8 = 0;
+ }
+ }
+ if (! tmp_8) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_value(yaml_parser_t *parser)
+{
+ int __retres;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ yaml_token_t token;
+ int tmp_7;
+ int tmp_10;
+ yaml_simple_key_t *simple_key = parser->simple_keys.top - 1;
+ if (simple_key->possible) {
+ int tmp_0;
+ int tmp_1;
+ memset((void *)(& token),0,sizeof(yaml_token_t));
+ token.type = YAML_KEY_TOKEN;
+ token.start_mark = simple_key->mark;
+ token.end_mark = simple_key->mark;
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp;
+ tmp = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp) {
+ _LOR:
+ {
+ memmove((void *)((parser->tokens.head + (simple_key->token_number - parser->tokens_parsed)) + 1),
+ (void const *)(parser->tokens.head + (simple_key->token_number - parser->tokens_parsed)),
+ ((size_t)(parser->tokens.tail - parser->tokens.head) - (
+ simple_key->token_number - parser->tokens_parsed)) * sizeof(*(parser->tokens.start)));
+ *(parser->tokens.head + (simple_key->token_number - parser->tokens_parsed)) = token;
+ (parser->tokens.tail) ++;
+ }
+ tmp_0 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_0 = 0;
+ }
+ }
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ tmp_1 = yaml_parser_roll_indent(parser,(long)simple_key->mark.column,
+ (long)simple_key->token_number,
+ YAML_BLOCK_MAPPING_START_TOKEN,
+ simple_key->mark);
+ if (! tmp_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ simple_key->possible = 0;
+ parser->simple_key_allowed = 0;
+ }
+ else {
+ if (! parser->flow_level) {
+ int tmp_3;
+ if (! parser->simple_key_allowed) {
+ int tmp_2;
+ tmp_2 = yaml_parser_set_scanner_error(parser,(char const *)0,
+ parser->mark,
+ "mapping values are not allowed in this context");
+ __retres = tmp_2;
+ goto return_label;
+ }
+ tmp_3 = yaml_parser_roll_indent(parser,(long)parser->mark.column,
+ (long)(-1),
+ YAML_BLOCK_MAPPING_START_TOKEN,
+ parser->mark);
+ if (! tmp_3) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ parser->simple_key_allowed = ! parser->flow_level;
+ }
+ start_mark = parser->mark;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_7 = 1;
+ else {
+ int tmp_6;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_6 = 2;
+ else {
+ int tmp_5;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_5 = 3;
+ else {
+ int tmp_4;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_4 = 4;
+ else tmp_4 = 0;
+ tmp_5 = tmp_4;
+ }
+ tmp_6 = tmp_5;
+ }
+ tmp_7 = tmp_6;
+ }
+ parser->buffer.pointer += tmp_7;
+ end_mark = parser->mark;
+ memset((void *)(& token),0,sizeof(yaml_token_t));
+ token.type = YAML_VALUE_TOKEN;
+ token.start_mark = start_mark;
+ token.end_mark = end_mark;
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR_0;
+ else {
+ int tmp_8;
+ tmp_8 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_8) {
+ yaml_token_t *tmp_9;
+ _LOR_0: tmp_9 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_9 = token;
+ tmp_10 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_10 = 0;
+ }
+ }
+ if (! tmp_10) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_anchor(yaml_parser_t *parser,
+ yaml_token_type_t type)
+{
+ int __retres;
+ yaml_token_t token;
+ int tmp;
+ int tmp_0;
+ int tmp_3;
+ tmp = yaml_parser_save_simple_key(parser);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = 0;
+ tmp_0 = yaml_parser_scan_anchor(parser,& token,type);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_1) {
+ yaml_token_t *tmp_2;
+ _LOR: tmp_2 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_2 = token;
+ tmp_3 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) {
+ yaml_token_delete(& token);
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_tag(yaml_parser_t *parser)
+{
+ int __retres;
+ yaml_token_t token;
+ int tmp;
+ int tmp_0;
+ int tmp_3;
+ tmp = yaml_parser_save_simple_key(parser);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = 0;
+ tmp_0 = yaml_parser_scan_tag(parser,& token);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_1) {
+ yaml_token_t *tmp_2;
+ _LOR: tmp_2 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_2 = token;
+ tmp_3 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) {
+ yaml_token_delete(& token);
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_block_scalar(yaml_parser_t *parser, int literal)
+{
+ int __retres;
+ yaml_token_t token;
+ int tmp;
+ int tmp_0;
+ int tmp_3;
+ tmp = yaml_parser_remove_simple_key(parser);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = 1;
+ tmp_0 = yaml_parser_scan_block_scalar(parser,& token,literal);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_1) {
+ yaml_token_t *tmp_2;
+ _LOR: tmp_2 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_2 = token;
+ tmp_3 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) {
+ yaml_token_delete(& token);
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_flow_scalar(yaml_parser_t *parser, int single)
+{
+ int __retres;
+ yaml_token_t token;
+ int tmp;
+ int tmp_0;
+ int tmp_3;
+ tmp = yaml_parser_save_simple_key(parser);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = 0;
+ tmp_0 = yaml_parser_scan_flow_scalar(parser,& token,single);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_1) {
+ yaml_token_t *tmp_2;
+ _LOR: tmp_2 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_2 = token;
+ tmp_3 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) {
+ yaml_token_delete(& token);
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_fetch_plain_scalar(yaml_parser_t *parser)
+{
+ int __retres;
+ yaml_token_t token;
+ int tmp;
+ int tmp_0;
+ int tmp_3;
+ tmp = yaml_parser_save_simple_key(parser);
+ if (! tmp) {
+ __retres = 0;
+ goto return_label;
+ }
+ parser->simple_key_allowed = 0;
+ tmp_0 = yaml_parser_scan_plain_scalar(parser,& token);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (parser->tokens.tail != parser->tokens.end) goto _LOR;
+ else {
+ int tmp_1;
+ tmp_1 = yaml_queue_extend((void **)(& parser->tokens.start),
+ (void **)(& parser->tokens.head),
+ (void **)(& parser->tokens.tail),
+ (void **)(& parser->tokens.end));
+ if (tmp_1) {
+ yaml_token_t *tmp_2;
+ _LOR: tmp_2 = parser->tokens.tail;
+ (parser->tokens.tail) ++;
+ *tmp_2 = token;
+ tmp_3 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_3 = 0;
+ }
+ }
+ if (! tmp_3) {
+ yaml_token_delete(& token);
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_to_next_token(yaml_parser_t *parser)
+{
+ int __retres;
+ while (1) {
+ {
+ int tmp_0;
+ int tmp_6;
+ if (parser->unread >= (size_t)1) tmp_0 = 1;
+ else tmp_0 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (parser->mark.column == (size_t)0)
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\357'))
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\273'))
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\277')) {
+ int tmp_4;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_4 = 1;
+ else {
+ int tmp_3;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_3 = 2;
+ else {
+ int tmp_2;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_2 = 3;
+ else {
+ int tmp_1;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_1 = 4;
+ else tmp_1 = 0;
+ tmp_2 = tmp_1;
+ }
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ parser->buffer.pointer += tmp_4;
+ }
+ if (parser->unread >= (size_t)1) tmp_6 = 1;
+ else tmp_6 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_6) {
+ __retres = 0;
+ goto return_label;
+ }
+ while (1) {
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (parser->flow_level) goto _LOR;
+ else
+ if (! parser->simple_key_allowed) {
+ _LOR: ;
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')))
+ break;
+ }
+ else break;
+ {
+ int tmp_10;
+ int tmp_12;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_10 = 1;
+ else {
+ int tmp_9;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_9 = 2;
+ else {
+ int tmp_8;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_8 = 3;
+ else {
+ int tmp_7;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_7 = 4;
+ else tmp_7 = 0;
+ tmp_8 = tmp_7;
+ }
+ tmp_9 = tmp_8;
+ }
+ tmp_10 = tmp_9;
+ }
+ parser->buffer.pointer += tmp_10;
+ if (parser->unread >= (size_t)1) tmp_12 = 1;
+ else tmp_12 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_12) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'#'))
+ while (1) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ break;
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ break;
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ _LAND_2: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251'))
+ break;
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000'))
+ break;
+ }
+ }
+ }
+ {
+ int tmp_16;
+ int tmp_18;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_16 = 1;
+ else {
+ int tmp_15;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_15 = 2;
+ else {
+ int tmp_14;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_14 = 3;
+ else {
+ int tmp_13;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_13 = 4;
+ else tmp_13 = 0;
+ tmp_14 = tmp_13;
+ }
+ tmp_15 = tmp_14;
+ }
+ tmp_16 = tmp_15;
+ }
+ parser->buffer.pointer += tmp_16;
+ if (parser->unread >= (size_t)1) tmp_18 = 1;
+ else tmp_18 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_18) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_1;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ goto _LOR_1;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_1;
+ else goto _LAND_12;
+ }
+ else {
+ _LAND_12: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_1;
+ else goto _LAND_11;
+ }
+ else goto _LAND_11;
+ }
+ else {
+ _LAND_11: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')) {
+ _LOR_1:
+ {
+ int tmp_20;
+ if (parser->unread >= (size_t)2) tmp_20 = 1;
+ else tmp_20 = yaml_parser_update_buffer(parser,
+ (unsigned long)2);
+ if (! tmp_20) {
+ __retres = 0;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\n')) {
+ parser->mark.index += (size_t)2;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)2;
+ parser->buffer.pointer += 2;
+ yaml_char_t *tmp_27 = parser->buffer.pointer;
+ }
+ else goto _LAND_7;
+ }
+ else {
+ _LAND_7: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_0;
+ else goto _LAND_6;
+ }
+ else {
+ _LAND_6: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_0;
+ else goto _LAND_5;
+ }
+ else goto _LAND_5;
+ }
+ else {
+ _LAND_5: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200'))
+ if ((int)*(parser->buffer.pointer + (
+ 0 + 2)) == (int)((unsigned char)'\251')) {
+ int tmp_24;
+ _LOR_0:
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_24 = 1;
+ else {
+ int tmp_23;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_23 = 2;
+ else {
+ int tmp_22;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_22 = 3;
+ else {
+ int tmp_21;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_21 = 4;
+ else tmp_21 = 0;
+ tmp_22 = tmp_21;
+ }
+ tmp_23 = tmp_22;
+ }
+ tmp_24 = tmp_23;
+ }
+ parser->buffer.pointer += tmp_24;
+ yaml_char_t *tmp_25 =
+ parser->buffer.pointer;
+ }
+ }
+ }
+ }
+ if (! parser->flow_level) parser->simple_key_allowed = 1;
+ }
+ }
+ else goto _LAND_9;
+ }
+ else goto _LAND_9;
+ }
+ else _LAND_9: break;
+ }
+ }
+ }
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_directive(yaml_parser_t *parser,
+ yaml_token_t *token)
+{
+ int __retres;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ int major;
+ int minor;
+ int tmp_2;
+ int tmp_3;
+ int tmp_7;
+ int tmp_9;
+ yaml_char_t *name = (yaml_char_t *)0;
+ yaml_char_t *handle = (yaml_char_t *)0;
+ yaml_char_t *prefix = (yaml_char_t *)0;
+ start_mark = parser->mark;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_2 = 1;
+ else {
+ int tmp_1;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_1 = 2;
+ else {
+ int tmp_0;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_0 = 3;
+ else {
+ int tmp;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp = 4;
+ else tmp = 0;
+ tmp_0 = tmp;
+ }
+ tmp_1 = tmp_0;
+ }
+ tmp_2 = tmp_1;
+ }
+ parser->buffer.pointer += tmp_2;
+ tmp_3 = yaml_parser_scan_directive_name(parser,start_mark,& name);
+ if (! tmp_3) goto error;
+ tmp_7 = strcmp((char const *)name,"YAML");
+ if (tmp_7 == 0) {
+ int tmp_4;
+ tmp_4 = yaml_parser_scan_version_directive_value(parser,start_mark,
+ & major,& minor);
+ if (! tmp_4) goto error;
+ end_mark = parser->mark;
+ memset((void *)token,0,sizeof(yaml_token_t));
+ token->type = YAML_VERSION_DIRECTIVE_TOKEN;
+ token->start_mark = start_mark;
+ token->end_mark = end_mark;
+ token->data.version_directive.major = major;
+ token->data.version_directive.minor = minor;
+ }
+ else {
+ int tmp_6;
+ tmp_6 = strcmp((char const *)name,"TAG");
+ if (tmp_6 == 0) {
+ int tmp_5;
+ tmp_5 = yaml_parser_scan_tag_directive_value(parser,start_mark,
+ & handle,& prefix);
+ if (! tmp_5) goto error;
+ end_mark = parser->mark;
+ memset((void *)token,0,sizeof(yaml_token_t));
+ token->type = YAML_TAG_DIRECTIVE_TOKEN;
+ token->start_mark = start_mark;
+ token->end_mark = end_mark;
+ token->data.tag_directive.handle = handle;
+ token->data.tag_directive.prefix = prefix;
+ }
+ else {
+ yaml_parser_set_scanner_error(parser,"while scanning a directive",
+ start_mark,
+ "found unknown directive name");
+ goto error;
+ }
+ }
+ if (parser->unread >= (size_t)1) tmp_9 = 1;
+ else tmp_9 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_9) goto error;
+ while (1) {
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')))
+ break;
+ {
+ int tmp_13;
+ int tmp_15;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_13 = 1;
+ else {
+ int tmp_12;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_12 = 2;
+ else {
+ int tmp_11;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_11 = 3;
+ else {
+ int tmp_10;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_10 = 4;
+ else tmp_10 = 0;
+ tmp_11 = tmp_10;
+ }
+ tmp_12 = tmp_11;
+ }
+ tmp_13 = tmp_12;
+ }
+ parser->buffer.pointer += tmp_13;
+ if (parser->unread >= (size_t)1) tmp_15 = 1;
+ else tmp_15 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_15) goto error;
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'#'))
+ while (1) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ break;
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ break;
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ _LAND_2: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251'))
+ break;
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000'))
+ break;
+ }
+ }
+ }
+ {
+ int tmp_19;
+ int tmp_21;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_19 = 1;
+ else {
+ int tmp_18;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_18 = 2;
+ else {
+ int tmp_17;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_17 = 3;
+ else {
+ int tmp_16;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_16 = 4;
+ else tmp_16 = 0;
+ tmp_17 = tmp_16;
+ }
+ tmp_18 = tmp_17;
+ }
+ tmp_19 = tmp_18;
+ }
+ parser->buffer.pointer += tmp_19;
+ if (parser->unread >= (size_t)1) tmp_21 = 1;
+ else tmp_21 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_21) goto error;
+ }
+ }
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')))
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205')))
+ goto _LAND_8;
+ }
+ else {
+ _LAND_8: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250')))
+ goto _LAND_7;
+ }
+ else goto _LAND_7;
+ }
+ else {
+ _LAND_7: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')))
+ goto _LAND_5;
+ }
+ else goto _LAND_5;
+ }
+ else {
+ _LAND_5: ;
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000'))) {
+ yaml_parser_set_scanner_error(parser,
+ "while scanning a directive",
+ start_mark,
+ "did not find expected comment or line break");
+ goto error;
+ }
+ }
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_0;
+ else goto _LAND_15;
+ }
+ else {
+ _LAND_15: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_0;
+ else goto _LAND_14;
+ }
+ else goto _LAND_14;
+ }
+ else {
+ _LAND_14: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200'))
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')) {
+ _LOR_0:
+ {
+ int tmp_23;
+ if (parser->unread >= (size_t)2) tmp_23 = 1;
+ else tmp_23 = yaml_parser_update_buffer(parser,
+ (unsigned long)2);
+ if (! tmp_23) goto error;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\n')) {
+ parser->mark.index += (size_t)2;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)2;
+ parser->buffer.pointer += 2;
+ yaml_char_t *tmp_30 = parser->buffer.pointer;
+ }
+ else goto _LAND_12;
+ }
+ else {
+ _LAND_12: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ goto _LOR;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR;
+ else goto _LAND_11;
+ }
+ else {
+ _LAND_11: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR;
+ else goto _LAND_10;
+ }
+ else goto _LAND_10;
+ }
+ else {
+ _LAND_10: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200'))
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')) {
+ int tmp_27;
+ _LOR: parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_27 = 1;
+ else {
+ int tmp_26;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_26 = 2;
+ else {
+ int tmp_25;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_25 = 3;
+ else {
+ int tmp_24;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_24 = 4;
+ else tmp_24 = 0;
+ tmp_25 = tmp_24;
+ }
+ tmp_26 = tmp_25;
+ }
+ tmp_27 = tmp_26;
+ }
+ parser->buffer.pointer += tmp_27;
+ yaml_char_t *tmp_28 =
+ parser->buffer.pointer;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ yaml_free((void *)name);
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)prefix);
+ yaml_free((void *)handle);
+ yaml_free((void *)name);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_directive_name(yaml_parser_t *parser,
+ yaml_mark_t start_mark,
+ yaml_char_t **name)
+{
+ int __retres;
+ int tmp_0;
+ int tmp_2;
+ yaml_string_t string =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ string.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (string.start) {
+ string.pointer = string.start;
+ string.end = string.start + 16;
+ memset((void *)string.start,0,(unsigned long)16);
+ tmp_0 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_0 = 0;
+ }
+ if (! tmp_0) goto error;
+ if (parser->unread >= (size_t)1) tmp_2 = 1;
+ else tmp_2 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_2) goto error;
+ while (1) {
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'0')) {
+ if (! ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'9')))
+ goto _LAND_1;
+ }
+ else {
+ _LAND_1: ;
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'A')) {
+ if (! ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'Z')))
+ goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'a')) {
+ if (! ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'z')))
+ goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (! ((int)*(parser->buffer.pointer + 0) == '_'))
+ if (! ((int)*(parser->buffer.pointer + 0) == '-')) break;
+ }
+ }
+ }
+ {
+ int tmp_25_1;
+ int tmp_4;
+ int tmp_27_1;
+ if (string.pointer + 5 < string.end) tmp_4 = 1;
+ else {
+ int tmp_3;
+ tmp_3 = yaml_string_extend(& string.start,& string.pointer,
+ & string.end);
+ if (tmp_3) tmp_4 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_4 = 0;
+ }
+ }
+ if (tmp_4) {
+ if (((int)*(parser->buffer.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_5;
+ yaml_char_t *tmp_6;
+ tmp_5 = string.pointer;
+ (string.pointer) ++;
+ tmp_6 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_5 = *tmp_6;
+ yaml_char_t tmp_31 = *tmp_5;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_7;
+ yaml_char_t *tmp_8;
+ yaml_char_t *tmp_9;
+ yaml_char_t *tmp_10;
+ tmp_7 = string.pointer;
+ (string.pointer) ++;
+ tmp_8 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_7 = *tmp_8;
+ tmp_9 = string.pointer;
+ (string.pointer) ++;
+ tmp_10 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_9 = *tmp_10;
+ yaml_char_t tmp_29 = *tmp_9;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_11;
+ yaml_char_t *tmp_12;
+ yaml_char_t *tmp_13;
+ yaml_char_t *tmp_14;
+ yaml_char_t *tmp_15;
+ yaml_char_t *tmp_16;
+ tmp_11 = string.pointer;
+ (string.pointer) ++;
+ tmp_12 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_11 = *tmp_12;
+ tmp_13 = string.pointer;
+ (string.pointer) ++;
+ tmp_14 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_13 = *tmp_14;
+ tmp_15 = string.pointer;
+ (string.pointer) ++;
+ tmp_16 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_15 = *tmp_16;
+ yaml_char_t tmp_27 = *tmp_15;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_17;
+ yaml_char_t *tmp_18;
+ yaml_char_t *tmp_19;
+ yaml_char_t *tmp_20;
+ yaml_char_t *tmp_21;
+ yaml_char_t *tmp_22;
+ yaml_char_t *tmp_23;
+ yaml_char_t *tmp_24;
+ tmp_17 = string.pointer;
+ (string.pointer) ++;
+ tmp_18 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_17 = *tmp_18;
+ tmp_19 = string.pointer;
+ (string.pointer) ++;
+ tmp_20 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_19 = *tmp_20;
+ tmp_21 = string.pointer;
+ (string.pointer) ++;
+ tmp_22 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_21 = *tmp_22;
+ tmp_23 = string.pointer;
+ (string.pointer) ++;
+ tmp_24 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_23 = *tmp_24;
+ yaml_char_t tmp_25 = *tmp_23;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ tmp_25_1 = 1;
+ }
+ else tmp_25_1 = 0;
+ if (! tmp_25_1) goto error;
+ if (parser->unread >= (size_t)1) tmp_27_1 = 1;
+ else tmp_27_1 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_27_1) goto error;
+ }
+ }
+ if (string.start == string.pointer) {
+ yaml_parser_set_scanner_error(parser,"while scanning a directive",
+ start_mark,
+ "could not find expected directive name");
+ goto error;
+ }
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')))
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205')))
+ goto _LAND_6;
+ }
+ else {
+ _LAND_6: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250')))
+ goto _LAND_5;
+ }
+ else goto _LAND_5;
+ }
+ else {
+ _LAND_5: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')))
+ goto _LAND_3;
+ }
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000'))) {
+ yaml_parser_set_scanner_error(parser,
+ "while scanning a directive",
+ start_mark,
+ "found unexpected non-alphabetical character");
+ goto error;
+ }
+ }
+ }
+ }
+ *name = string.start;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)string.start);
+ string.end = (yaml_char_t *)0;
+ string.pointer = string.end;
+ string.start = string.pointer;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_version_directive_value(yaml_parser_t *parser,
+ yaml_mark_t start_mark,
+ int *major, int *minor)
+{
+ int __retres;
+ int tmp_0;
+ int tmp_7;
+ int tmp_12;
+ int tmp_13;
+ if (parser->unread >= (size_t)1) tmp_0 = 1;
+ else tmp_0 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ while (1) {
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')))
+ break;
+ {
+ int tmp_4;
+ int tmp_6;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_4 = 1;
+ else {
+ int tmp_3;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_3 = 2;
+ else {
+ int tmp_2;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_2 = 3;
+ else {
+ int tmp_1;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_1 = 4;
+ else tmp_1 = 0;
+ tmp_2 = tmp_1;
+ }
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ parser->buffer.pointer += tmp_4;
+ if (parser->unread >= (size_t)1) tmp_6 = 1;
+ else tmp_6 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_6) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ tmp_7 = yaml_parser_scan_version_directive_number(parser,start_mark,major);
+ if (! tmp_7) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'.'))) {
+ int tmp_8;
+ tmp_8 = yaml_parser_set_scanner_error(parser,
+ "while scanning a %YAML directive",
+ start_mark,
+ "did not find expected digit or \'.\' character");
+ __retres = tmp_8;
+ goto return_label;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_12 = 1;
+ else {
+ int tmp_11;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_11 = 2;
+ else {
+ int tmp_10;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_10 = 3;
+ else {
+ int tmp_9;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_9 = 4;
+ else tmp_9 = 0;
+ tmp_10 = tmp_9;
+ }
+ tmp_11 = tmp_10;
+ }
+ tmp_12 = tmp_11;
+ }
+ parser->buffer.pointer += tmp_12;
+ tmp_13 = yaml_parser_scan_version_directive_number(parser,start_mark,minor);
+ if (! tmp_13) {
+ __retres = 0;
+ goto return_label;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_version_directive_number(yaml_parser_t *parser,
+ yaml_mark_t start_mark,
+ int *number)
+{
+ int __retres;
+ int tmp_0;
+ int value = 0;
+ size_t length = (unsigned long)0;
+ if (parser->unread >= (size_t)1) tmp_0 = 1;
+ else tmp_0 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ while (1) {
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'0')) {
+ if (! ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'9')))
+ break;
+ }
+ else break;
+ {
+ int tmp_5;
+ int tmp_7;
+ length += (size_t)1;
+ if (length > (size_t)9) {
+ int tmp_1;
+ tmp_1 = yaml_parser_set_scanner_error(parser,
+ "while scanning a %YAML directive",
+ start_mark,
+ "found extremely long version number");
+ __retres = tmp_1;
+ goto return_label;
+ }
+ value = value * 10 + ((int)*(parser->buffer.pointer + 0) - (int)((unsigned char)'0'));
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_5 = 1;
+ else {
+ int tmp_4;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_4 = 2;
+ else {
+ int tmp_3;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_3 = 3;
+ else {
+ int tmp_2;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_2 = 4;
+ else tmp_2 = 0;
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ tmp_5 = tmp_4;
+ }
+ parser->buffer.pointer += tmp_5;
+ if (parser->unread >= (size_t)1) tmp_7 = 1;
+ else tmp_7 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_7) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ if (! length) {
+ int tmp_8;
+ tmp_8 = yaml_parser_set_scanner_error(parser,
+ "while scanning a %YAML directive",
+ start_mark,
+ "did not find expected version number");
+ __retres = tmp_8;
+ goto return_label;
+ }
+ *number = value;
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_tag_directive_value(yaml_parser_t *parser,
+ yaml_mark_t start_mark,
+ yaml_char_t **handle,
+ yaml_char_t **prefix)
+{
+ int __retres;
+ int tmp_0;
+ int tmp_7;
+ int tmp_9;
+ int tmp_16;
+ int tmp_18;
+ yaml_char_t *handle_value = (yaml_char_t *)0;
+ yaml_char_t *prefix_value = (yaml_char_t *)0;
+ if (parser->unread >= (size_t)1) tmp_0 = 1;
+ else tmp_0 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_0) goto error;
+ while (1) {
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')))
+ break;
+ {
+ int tmp_4;
+ int tmp_6;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_4 = 1;
+ else {
+ int tmp_3;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_3 = 2;
+ else {
+ int tmp_2;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_2 = 3;
+ else {
+ int tmp_1;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_1 = 4;
+ else tmp_1 = 0;
+ tmp_2 = tmp_1;
+ }
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ parser->buffer.pointer += tmp_4;
+ if (parser->unread >= (size_t)1) tmp_6 = 1;
+ else tmp_6 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_6) goto error;
+ }
+ }
+ tmp_7 = yaml_parser_scan_tag_handle(parser,1,start_mark,& handle_value);
+ if (! tmp_7) goto error;
+ if (parser->unread >= (size_t)1) tmp_9 = 1;
+ else tmp_9 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_9) goto error;
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t'))) {
+ yaml_parser_set_scanner_error(parser,"while scanning a %TAG directive",
+ start_mark,
+ "did not find expected whitespace");
+ goto error;
+ }
+ while (1) {
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')))
+ break;
+ {
+ int tmp_13;
+ int tmp_15;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_13 = 1;
+ else {
+ int tmp_12;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_12 = 2;
+ else {
+ int tmp_11;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_11 = 3;
+ else {
+ int tmp_10;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_10 = 4;
+ else tmp_10 = 0;
+ tmp_11 = tmp_10;
+ }
+ tmp_12 = tmp_11;
+ }
+ tmp_13 = tmp_12;
+ }
+ parser->buffer.pointer += tmp_13;
+ if (parser->unread >= (size_t)1) tmp_15 = 1;
+ else tmp_15 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_15) goto error;
+ }
+ }
+ tmp_16 = yaml_parser_scan_tag_uri(parser,1,1,(yaml_char_t *)0,start_mark,
+ & prefix_value);
+ if (! tmp_16) goto error;
+ if (parser->unread >= (size_t)1) tmp_18 = 1;
+ else tmp_18 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_18) goto error;
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')))
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205')))
+ goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250')))
+ goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ _LAND_2: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')))
+ goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000'))) {
+ yaml_parser_set_scanner_error(parser,
+ "while scanning a %TAG directive",
+ start_mark,
+ "did not find expected whitespace or line break");
+ goto error;
+ }
+ }
+ }
+ }
+ *handle = handle_value;
+ *prefix = prefix_value;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)handle_value);
+ yaml_free((void *)prefix_value);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_anchor(yaml_parser_t *parser,
+ yaml_token_t *token,
+ yaml_token_type_t type)
+{
+ int __retres;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ int tmp_0;
+ int tmp_4;
+ int tmp_6;
+ int length = 0;
+ yaml_string_t string =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ string.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (string.start) {
+ string.pointer = string.start;
+ string.end = string.start + 16;
+ memset((void *)string.start,0,(unsigned long)16);
+ tmp_0 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_0 = 0;
+ }
+ if (! tmp_0) goto error;
+ start_mark = parser->mark;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_4 = 1;
+ else {
+ int tmp_3;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_3 = 2;
+ else {
+ int tmp_2;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_2 = 3;
+ else {
+ int tmp_1;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_1 = 4;
+ else tmp_1 = 0;
+ tmp_2 = tmp_1;
+ }
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ parser->buffer.pointer += tmp_4;
+ if (parser->unread >= (size_t)1) tmp_6 = 1;
+ else tmp_6 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_6) goto error;
+ while (1) {
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'0')) {
+ if (! ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'9')))
+ goto _LAND_1;
+ }
+ else {
+ _LAND_1: ;
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'A')) {
+ if (! ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'Z')))
+ goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'a')) {
+ if (! ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'z')))
+ goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (! ((int)*(parser->buffer.pointer + 0) == '_'))
+ if (! ((int)*(parser->buffer.pointer + 0) == '-')) break;
+ }
+ }
+ }
+ {
+ int tmp_29_1;
+ int tmp_8;
+ int tmp_31_1;
+ if (string.pointer + 5 < string.end) tmp_8 = 1;
+ else {
+ int tmp_7;
+ tmp_7 = yaml_string_extend(& string.start,& string.pointer,
+ & string.end);
+ if (tmp_7) tmp_8 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_8 = 0;
+ }
+ }
+ if (tmp_8) {
+ if (((int)*(parser->buffer.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_9;
+ yaml_char_t *tmp_10;
+ tmp_9 = string.pointer;
+ (string.pointer) ++;
+ tmp_10 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_9 = *tmp_10;
+ yaml_char_t tmp_35 = *tmp_9;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_11;
+ yaml_char_t *tmp_12;
+ yaml_char_t *tmp_13;
+ yaml_char_t *tmp_14;
+ tmp_11 = string.pointer;
+ (string.pointer) ++;
+ tmp_12 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_11 = *tmp_12;
+ tmp_13 = string.pointer;
+ (string.pointer) ++;
+ tmp_14 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_13 = *tmp_14;
+ yaml_char_t tmp_33 = *tmp_13;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_15;
+ yaml_char_t *tmp_16;
+ yaml_char_t *tmp_17;
+ yaml_char_t *tmp_18;
+ yaml_char_t *tmp_19;
+ yaml_char_t *tmp_20;
+ tmp_15 = string.pointer;
+ (string.pointer) ++;
+ tmp_16 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_15 = *tmp_16;
+ tmp_17 = string.pointer;
+ (string.pointer) ++;
+ tmp_18 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_17 = *tmp_18;
+ tmp_19 = string.pointer;
+ (string.pointer) ++;
+ tmp_20 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_19 = *tmp_20;
+ yaml_char_t tmp_31 = *tmp_19;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_21;
+ yaml_char_t *tmp_22;
+ yaml_char_t *tmp_23;
+ yaml_char_t *tmp_24;
+ yaml_char_t *tmp_25;
+ yaml_char_t *tmp_26;
+ yaml_char_t *tmp_27;
+ yaml_char_t *tmp_28;
+ tmp_21 = string.pointer;
+ (string.pointer) ++;
+ tmp_22 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_21 = *tmp_22;
+ tmp_23 = string.pointer;
+ (string.pointer) ++;
+ tmp_24 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_23 = *tmp_24;
+ tmp_25 = string.pointer;
+ (string.pointer) ++;
+ tmp_26 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_25 = *tmp_26;
+ tmp_27 = string.pointer;
+ (string.pointer) ++;
+ tmp_28 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_27 = *tmp_28;
+ yaml_char_t tmp_29 = *tmp_27;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ tmp_29_1 = 1;
+ }
+ else tmp_29_1 = 0;
+ if (! tmp_29_1) goto error;
+ if (parser->unread >= (size_t)1) tmp_31_1 = 1;
+ else tmp_31_1 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_31_1) goto error;
+ length ++;
+ }
+ }
+ end_mark = parser->mark;
+ if (! length) goto _LOR;
+ else
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')))
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205')))
+ goto _LAND_6;
+ }
+ else {
+ _LAND_6: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250')))
+ goto _LAND_5;
+ }
+ else goto _LAND_5;
+ }
+ else {
+ _LAND_5: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')))
+ goto _LAND_3;
+ }
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'?')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)':')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)',')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)']')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'}')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'%')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'@')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'`'))) {
+ _LOR:
+ {
+ char const *tmp_32;
+ ;
+ if (type == (unsigned int)YAML_ANCHOR_TOKEN)
+ tmp_32 = "while scanning an anchor";
+ else tmp_32 = "while scanning an alias";
+ ;
+ yaml_parser_set_scanner_error(parser,
+ tmp_32,
+ start_mark,
+ "did not find expected alphabetic or numeric character");
+ goto error;
+ }
+ }
+ }
+ }
+ }
+ if (type == (unsigned int)YAML_ANCHOR_TOKEN) {
+ memset((void *)token,0,sizeof(yaml_token_t));
+ token->type = YAML_ANCHOR_TOKEN;
+ token->start_mark = start_mark;
+ token->end_mark = end_mark;
+ token->data.anchor.value = string.start;
+ }
+ else {
+ memset((void *)token,0,sizeof(yaml_token_t));
+ token->type = YAML_ALIAS_TOKEN;
+ token->start_mark = start_mark;
+ token->end_mark = end_mark;
+ token->data.alias.value = string.start;
+ }
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)string.start);
+ string.end = (yaml_char_t *)0;
+ string.pointer = string.end;
+ string.start = string.pointer;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_tag(yaml_parser_t *parser, yaml_token_t *token)
+{
+ int __retres;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ int tmp_0;
+ int tmp_22;
+ yaml_char_t *handle = (yaml_char_t *)0;
+ yaml_char_t *suffix = (yaml_char_t *)0;
+ start_mark = parser->mark;
+ if (parser->unread >= (size_t)2) tmp_0 = 1;
+ else tmp_0 = yaml_parser_update_buffer(parser,(unsigned long)2);
+ if (! tmp_0) goto error;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'<')) {
+ int tmp_5;
+ int tmp_9;
+ int tmp_10;
+ int tmp_14;
+ handle = (yaml_char_t *)yaml_malloc((unsigned long)1);
+ if (! handle) goto error;
+ *(handle + 0) = (unsigned char)'\000';
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_5 = 1;
+ else {
+ int tmp_4;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_4 = 2;
+ else {
+ int tmp_3;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_3 = 3;
+ else {
+ int tmp_2;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_2 = 4;
+ else tmp_2 = 0;
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ tmp_5 = tmp_4;
+ }
+ parser->buffer.pointer += tmp_5;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_9 = 1;
+ else {
+ int tmp_8;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_8 = 2;
+ else {
+ int tmp_7;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_7 = 3;
+ else {
+ int tmp_6;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_6 = 4;
+ else tmp_6 = 0;
+ tmp_7 = tmp_6;
+ }
+ tmp_8 = tmp_7;
+ }
+ tmp_9 = tmp_8;
+ }
+ parser->buffer.pointer += tmp_9;
+ tmp_10 = yaml_parser_scan_tag_uri(parser,1,0,(yaml_char_t *)0,start_mark,
+ & suffix);
+ if (! tmp_10) goto error;
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'>'))) {
+ yaml_parser_set_scanner_error(parser,"while scanning a tag",start_mark,
+ "did not find the expected \'>\'");
+ goto error;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_14 = 1;
+ else {
+ int tmp_13;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_13 = 2;
+ else {
+ int tmp_12;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_12 = 3;
+ else {
+ int tmp_11;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_11 = 4;
+ else tmp_11 = 0;
+ tmp_12 = tmp_11;
+ }
+ tmp_13 = tmp_12;
+ }
+ tmp_14 = tmp_13;
+ }
+ parser->buffer.pointer += tmp_14;
+ }
+ else {
+ int tmp_15;
+ tmp_15 = yaml_parser_scan_tag_handle(parser,0,start_mark,& handle);
+ if (! tmp_15) goto error;
+ if ((int)*(handle + 0) == '!') {
+ if ((int)*(handle + 1) != '\000') {
+ size_t tmp_20;
+ tmp_20 = strlen((char const *)handle);
+ ;
+ if ((int)*(handle + (tmp_20 - (size_t)1)) == '!') {
+ int tmp_16;
+ tmp_16 = yaml_parser_scan_tag_uri(parser,0,0,(yaml_char_t *)0,
+ start_mark,& suffix);
+ if (! tmp_16) goto error;
+ }
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0:
+ {
+ int tmp_17;
+ tmp_17 = yaml_parser_scan_tag_uri(parser,0,0,handle,start_mark,
+ & suffix);
+ if (! tmp_17) goto error;
+ yaml_free((void *)handle);
+ handle = (yaml_char_t *)yaml_malloc((unsigned long)2);
+ if (! handle) goto error;
+ *(handle + 0) = (unsigned char)'!';
+ *(handle + 1) = (unsigned char)'\000';
+ if ((int)*(suffix + 0) == '\000') {
+ yaml_char_t *tmp_19 = handle;
+ handle = suffix;
+ suffix = tmp_19;
+ }
+ }
+ }
+ }
+ if (parser->unread >= (size_t)1) tmp_22 = 1;
+ else tmp_22 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_22) goto error;
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')))
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205')))
+ goto _LAND_5;
+ }
+ else {
+ _LAND_5: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250')))
+ goto _LAND_4;
+ }
+ else goto _LAND_4;
+ }
+ else {
+ _LAND_4: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')))
+ goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ _LAND_2: ;
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000')))
+ if (! parser->flow_level) goto _LOR;
+ else
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)','))) {
+ _LOR:
+ {
+ yaml_parser_set_scanner_error(parser,
+ "while scanning a tag",
+ start_mark,
+ "did not find expected whitespace or line break");
+ goto error;
+ }
+ }
+ }
+ }
+ }
+ end_mark = parser->mark;
+ memset((void *)token,0,sizeof(yaml_token_t));
+ token->type = YAML_TAG_TOKEN;
+ token->start_mark = start_mark;
+ token->end_mark = end_mark;
+ token->data.tag.handle = handle;
+ token->data.tag.suffix = suffix;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)handle);
+ yaml_free((void *)suffix);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_tag_handle(yaml_parser_t *parser, int directive,
+ yaml_mark_t start_mark,
+ yaml_char_t **handle)
+{
+ int __retres;
+ int tmp_0;
+ int tmp_2;
+ int tmp_26_2;
+ int tmp_5;
+ int tmp_28_2;
+ yaml_string_t string =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ string.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (string.start) {
+ string.pointer = string.start;
+ string.end = string.start + 16;
+ memset((void *)string.start,0,(unsigned long)16);
+ tmp_0 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_0 = 0;
+ }
+ if (! tmp_0) goto error;
+ if (parser->unread >= (size_t)1) tmp_2 = 1;
+ else tmp_2 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_2) goto error;
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'!'))) {
+ char const *tmp_3;
+ ;
+ if (directive) tmp_3 = "while scanning a tag directive";
+ else tmp_3 = "while scanning a tag";
+ ;
+ yaml_parser_set_scanner_error(parser,tmp_3,start_mark,
+ "did not find expected \'!\'");
+ goto error;
+ }
+ if (string.pointer + 5 < string.end) tmp_5 = 1;
+ else {
+ int tmp_4;
+ tmp_4 = yaml_string_extend(& string.start,& string.pointer,& string.end);
+ if (tmp_4) tmp_5 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_5 = 0;
+ }
+ }
+ if (tmp_5) {
+ if (((int)*(parser->buffer.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_6;
+ yaml_char_t *tmp_7;
+ tmp_6 = string.pointer;
+ (string.pointer) ++;
+ tmp_7 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_6 = *tmp_7;
+ yaml_char_t tmp_32 = *tmp_6;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_8;
+ yaml_char_t *tmp_9;
+ yaml_char_t *tmp_10;
+ yaml_char_t *tmp_11;
+ tmp_8 = string.pointer;
+ (string.pointer) ++;
+ tmp_9 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_8 = *tmp_9;
+ tmp_10 = string.pointer;
+ (string.pointer) ++;
+ tmp_11 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_10 = *tmp_11;
+ yaml_char_t tmp_30 = *tmp_10;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_12;
+ yaml_char_t *tmp_13;
+ yaml_char_t *tmp_14;
+ yaml_char_t *tmp_15;
+ yaml_char_t *tmp_16;
+ yaml_char_t *tmp_17;
+ tmp_12 = string.pointer;
+ (string.pointer) ++;
+ tmp_13 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_12 = *tmp_13;
+ tmp_14 = string.pointer;
+ (string.pointer) ++;
+ tmp_15 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_14 = *tmp_15;
+ tmp_16 = string.pointer;
+ (string.pointer) ++;
+ tmp_17 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_16 = *tmp_17;
+ yaml_char_t tmp_28 = *tmp_16;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_18;
+ yaml_char_t *tmp_19;
+ yaml_char_t *tmp_20;
+ yaml_char_t *tmp_21;
+ yaml_char_t *tmp_22;
+ yaml_char_t *tmp_23;
+ yaml_char_t *tmp_24;
+ yaml_char_t *tmp_25;
+ tmp_18 = string.pointer;
+ (string.pointer) ++;
+ tmp_19 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_18 = *tmp_19;
+ tmp_20 = string.pointer;
+ (string.pointer) ++;
+ tmp_21 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_20 = *tmp_21;
+ tmp_22 = string.pointer;
+ (string.pointer) ++;
+ tmp_23 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_22 = *tmp_23;
+ tmp_24 = string.pointer;
+ (string.pointer) ++;
+ tmp_25 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_24 = *tmp_25;
+ yaml_char_t tmp_26 = *tmp_24;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ tmp_26_2 = 1;
+ }
+ else tmp_26_2 = 0;
+ if (! tmp_26_2) goto error;
+ if (parser->unread >= (size_t)1) tmp_28_2 = 1;
+ else tmp_28_2 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_28_2) goto error;
+ while (1) {
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'0')) {
+ if (! ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'9')))
+ goto _LAND_1;
+ }
+ else {
+ _LAND_1: ;
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'A')) {
+ if (! ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'Z')))
+ goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'a')) {
+ if (! ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'z')))
+ goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (! ((int)*(parser->buffer.pointer + 0) == '_'))
+ if (! ((int)*(parser->buffer.pointer + 0) == '-')) break;
+ }
+ }
+ }
+ {
+ int tmp_51_0;
+ int tmp_30_1;
+ int tmp_53_0;
+ if (string.pointer + 5 < string.end) tmp_30_1 = 1;
+ else {
+ int tmp_29;
+ tmp_29 = yaml_string_extend(& string.start,& string.pointer,
+ & string.end);
+ if (tmp_29) tmp_30_1 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_30_1 = 0;
+ }
+ }
+ if (tmp_30_1) {
+ if (((int)*(parser->buffer.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_31;
+ yaml_char_t *tmp_32_1;
+ tmp_31 = string.pointer;
+ (string.pointer) ++;
+ tmp_32_1 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_31 = *tmp_32_1;
+ yaml_char_t tmp_57 = *tmp_31;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_33;
+ yaml_char_t *tmp_34;
+ yaml_char_t *tmp_35;
+ yaml_char_t *tmp_36;
+ tmp_33 = string.pointer;
+ (string.pointer) ++;
+ tmp_34 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_33 = *tmp_34;
+ tmp_35 = string.pointer;
+ (string.pointer) ++;
+ tmp_36 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_35 = *tmp_36;
+ yaml_char_t tmp_55 = *tmp_35;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_37;
+ yaml_char_t *tmp_38;
+ yaml_char_t *tmp_39;
+ yaml_char_t *tmp_40;
+ yaml_char_t *tmp_41;
+ yaml_char_t *tmp_42;
+ tmp_37 = string.pointer;
+ (string.pointer) ++;
+ tmp_38 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_37 = *tmp_38;
+ tmp_39 = string.pointer;
+ (string.pointer) ++;
+ tmp_40 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_39 = *tmp_40;
+ tmp_41 = string.pointer;
+ (string.pointer) ++;
+ tmp_42 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_41 = *tmp_42;
+ yaml_char_t tmp_53 = *tmp_41;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_43;
+ yaml_char_t *tmp_44;
+ yaml_char_t *tmp_45;
+ yaml_char_t *tmp_46;
+ yaml_char_t *tmp_47;
+ yaml_char_t *tmp_48;
+ yaml_char_t *tmp_49;
+ yaml_char_t *tmp_50;
+ tmp_43 = string.pointer;
+ (string.pointer) ++;
+ tmp_44 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_43 = *tmp_44;
+ tmp_45 = string.pointer;
+ (string.pointer) ++;
+ tmp_46 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_45 = *tmp_46;
+ tmp_47 = string.pointer;
+ (string.pointer) ++;
+ tmp_48 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_47 = *tmp_48;
+ tmp_49 = string.pointer;
+ (string.pointer) ++;
+ tmp_50 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_49 = *tmp_50;
+ yaml_char_t tmp_51 = *tmp_49;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ tmp_51_0 = 1;
+ }
+ else tmp_51_0 = 0;
+ if (! tmp_51_0) goto error;
+ if (parser->unread >= (size_t)1) tmp_53_0 = 1;
+ else tmp_53_0 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_53_0) goto error;
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'!')) {
+ int tmp_76_0;
+ int tmp_55_0;
+ if (string.pointer + 5 < string.end) tmp_55_0 = 1;
+ else {
+ int tmp_54;
+ tmp_54 = yaml_string_extend(& string.start,& string.pointer,
+ & string.end);
+ if (tmp_54) tmp_55_0 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_55_0 = 0;
+ }
+ }
+ if (tmp_55_0) {
+ if (((int)*(parser->buffer.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_56;
+ yaml_char_t *tmp_57_0;
+ tmp_56 = string.pointer;
+ (string.pointer) ++;
+ tmp_57_0 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_56 = *tmp_57_0;
+ yaml_char_t tmp_82 = *tmp_56;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_58;
+ yaml_char_t *tmp_59;
+ yaml_char_t *tmp_60;
+ yaml_char_t *tmp_61;
+ tmp_58 = string.pointer;
+ (string.pointer) ++;
+ tmp_59 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_58 = *tmp_59;
+ tmp_60 = string.pointer;
+ (string.pointer) ++;
+ tmp_61 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_60 = *tmp_61;
+ yaml_char_t tmp_80 = *tmp_60;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_62;
+ yaml_char_t *tmp_63;
+ yaml_char_t *tmp_64;
+ yaml_char_t *tmp_65;
+ yaml_char_t *tmp_66;
+ yaml_char_t *tmp_67;
+ tmp_62 = string.pointer;
+ (string.pointer) ++;
+ tmp_63 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_62 = *tmp_63;
+ tmp_64 = string.pointer;
+ (string.pointer) ++;
+ tmp_65 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_64 = *tmp_65;
+ tmp_66 = string.pointer;
+ (string.pointer) ++;
+ tmp_67 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_66 = *tmp_67;
+ yaml_char_t tmp_78 = *tmp_66;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_68;
+ yaml_char_t *tmp_69;
+ yaml_char_t *tmp_70;
+ yaml_char_t *tmp_71;
+ yaml_char_t *tmp_72;
+ yaml_char_t *tmp_73;
+ yaml_char_t *tmp_74;
+ yaml_char_t *tmp_75;
+ tmp_68 = string.pointer;
+ (string.pointer) ++;
+ tmp_69 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_68 = *tmp_69;
+ tmp_70 = string.pointer;
+ (string.pointer) ++;
+ tmp_71 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_70 = *tmp_71;
+ tmp_72 = string.pointer;
+ (string.pointer) ++;
+ tmp_73 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_72 = *tmp_73;
+ tmp_74 = string.pointer;
+ (string.pointer) ++;
+ tmp_75 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_74 = *tmp_75;
+ yaml_char_t tmp_76 = *tmp_74;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ tmp_76_0 = 1;
+ }
+ else tmp_76_0 = 0;
+ if (! tmp_76_0) goto error;
+ }
+ else
+ if (directive)
+ if ((int)*(string.start + 0) == '!') {
+ if (! ((int)*(string.start + 1) == '\000')) goto _LAND_2;
+ }
+ else {
+ _LAND_2:
+ {
+ yaml_parser_set_scanner_error(parser,
+ "while parsing a tag directive",
+ start_mark,
+ "did not find expected \'!\'");
+ goto error;
+ }
+ }
+ *handle = string.start;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)string.start);
+ string.end = (yaml_char_t *)0;
+ string.pointer = string.end;
+ string.start = string.pointer;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_tag_uri(yaml_parser_t *parser, int uri_char,
+ int directive, yaml_char_t *head,
+ yaml_mark_t start_mark, yaml_char_t **uri)
+{
+ int __retres;
+ size_t tmp_0;
+ int tmp_2;
+ int tmp_5;
+ if (head) tmp_0 = strlen((char const *)head);
+ else tmp_0 = (unsigned long)0;
+ size_t length = tmp_0;
+ yaml_string_t string =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ string.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (string.start) {
+ string.pointer = string.start;
+ string.end = string.start + 16;
+ memset((void *)string.start,0,(unsigned long)16);
+ tmp_2 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ if (! tmp_2) goto error;
+ while ((unsigned long)(string.end - string.start) <= length) {
+ int tmp_3;
+ tmp_3 = yaml_string_extend(& string.start,& string.pointer,& string.end);
+ if (! tmp_3) {
+ parser->error = YAML_MEMORY_ERROR;
+ goto error;
+ }
+ }
+ if (length > (size_t)1) {
+ memcpy((void *)string.start,(void const *)(head + 1),length - (size_t)1);
+ string.pointer += length - (size_t)1;
+ }
+ if (parser->unread >= (size_t)1) tmp_5 = 1;
+ else tmp_5 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_5) goto error;
+ while (1) {
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'0')) {
+ if (! ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'9')))
+ goto _LAND_1;
+ }
+ else {
+ _LAND_1: ;
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'A')) {
+ if (! ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'Z')))
+ goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'a')) {
+ if (! ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'z')))
+ goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (! ((int)*(parser->buffer.pointer + 0) == '_'))
+ if (! ((int)*(parser->buffer.pointer + 0) == '-'))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)';')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'/')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'?')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)':')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'@')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'&')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'=')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'+')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'$')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'.')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'%')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'!')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'~')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'*')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\'')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'(')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)')')))
+ if (uri_char) {
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)',')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'[')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)']')))
+ break;
+ }
+ else break;
+ }
+ }
+ }
+ {
+ int tmp_33_2;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'%')) {
+ int tmp_7;
+ int tmp_8;
+ if (string.pointer + 5 < string.end) tmp_7 = 1;
+ else {
+ int tmp_6;
+ tmp_6 = yaml_string_extend(& string.start,& string.pointer,
+ & string.end);
+ if (tmp_6) tmp_7 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_7 = 0;
+ }
+ }
+ if (! tmp_7) goto error;
+ tmp_8 = yaml_parser_scan_uri_escapes(parser,directive,start_mark,
+ & string);
+ if (! tmp_8) goto error;
+ }
+ else {
+ int tmp_31_2;
+ int tmp_10;
+ if (string.pointer + 5 < string.end) tmp_10 = 1;
+ else {
+ int tmp_9;
+ tmp_9 = yaml_string_extend(& string.start,& string.pointer,
+ & string.end);
+ if (tmp_9) tmp_10 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_10 = 0;
+ }
+ }
+ if (tmp_10) {
+ if (((int)*(parser->buffer.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_11;
+ yaml_char_t *tmp_12;
+ tmp_11 = string.pointer;
+ (string.pointer) ++;
+ tmp_12 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_11 = *tmp_12;
+ yaml_char_t tmp_37 = *tmp_11;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_13;
+ yaml_char_t *tmp_14;
+ yaml_char_t *tmp_15;
+ yaml_char_t *tmp_16;
+ tmp_13 = string.pointer;
+ (string.pointer) ++;
+ tmp_14 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_13 = *tmp_14;
+ tmp_15 = string.pointer;
+ (string.pointer) ++;
+ tmp_16 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_15 = *tmp_16;
+ yaml_char_t tmp_35 = *tmp_15;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_17;
+ yaml_char_t *tmp_18;
+ yaml_char_t *tmp_19;
+ yaml_char_t *tmp_20;
+ yaml_char_t *tmp_21;
+ yaml_char_t *tmp_22;
+ tmp_17 = string.pointer;
+ (string.pointer) ++;
+ tmp_18 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_17 = *tmp_18;
+ tmp_19 = string.pointer;
+ (string.pointer) ++;
+ tmp_20 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_19 = *tmp_20;
+ tmp_21 = string.pointer;
+ (string.pointer) ++;
+ tmp_22 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_21 = *tmp_22;
+ yaml_char_t tmp_33 = *tmp_21;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_23;
+ yaml_char_t *tmp_24;
+ yaml_char_t *tmp_25;
+ yaml_char_t *tmp_26;
+ yaml_char_t *tmp_27;
+ yaml_char_t *tmp_28;
+ yaml_char_t *tmp_29;
+ yaml_char_t *tmp_30;
+ tmp_23 = string.pointer;
+ (string.pointer) ++;
+ tmp_24 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_23 = *tmp_24;
+ tmp_25 = string.pointer;
+ (string.pointer) ++;
+ tmp_26 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_25 = *tmp_26;
+ tmp_27 = string.pointer;
+ (string.pointer) ++;
+ tmp_28 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_27 = *tmp_28;
+ tmp_29 = string.pointer;
+ (string.pointer) ++;
+ tmp_30 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_29 = *tmp_30;
+ yaml_char_t tmp_31 = *tmp_29;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ tmp_31_2 = 1;
+ }
+ else tmp_31_2 = 0;
+ if (! tmp_31_2) goto error;
+ }
+ length += (size_t)1;
+ if (parser->unread >= (size_t)1) tmp_33_2 = 1;
+ else tmp_33_2 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_33_2) goto error;
+ }
+ }
+ if (! length) {
+ int tmp_35_2;
+ char const *tmp_36;
+ if (string.pointer + 5 < string.end) tmp_35_2 = 1;
+ else {
+ int tmp_34;
+ tmp_34 = yaml_string_extend(& string.start,& string.pointer,
+ & string.end);
+ if (tmp_34) tmp_35_2 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_35_2 = 0;
+ }
+ }
+ if (! tmp_35_2) goto error;
+ ;
+ if (directive) tmp_36 = "while parsing a %TAG directive";
+ else tmp_36 = "while parsing a tag";
+ ;
+ yaml_parser_set_scanner_error(parser,tmp_36,start_mark,
+ "did not find expected tag URI");
+ goto error;
+ }
+ *uri = string.start;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)string.start);
+ string.end = (yaml_char_t *)0;
+ string.pointer = string.end;
+ string.start = string.pointer;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_uri_escapes(yaml_parser_t *parser, int directive,
+ yaml_mark_t start_mark,
+ yaml_string_t *string)
+{
+ int __retres;
+ int width = 0;
+ while (1) {
+ {
+ int tmp_0;
+ int tmp_4;
+ int tmp_6;
+ yaml_char_t *tmp_14;
+ int tmp_18;
+ int tmp_22;
+ int tmp_26;
+ unsigned char octet = (unsigned char)0;
+ if (parser->unread >= (size_t)3) tmp_0 = 1;
+ else tmp_0 = yaml_parser_update_buffer(parser,(unsigned long)3);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'%'))
+ if ((int)*(parser->buffer.pointer + 1) >= (int)((unsigned char)'0')) {
+ if ((int)*(parser->buffer.pointer + 1) <= (int)((unsigned char)'9'))
+ goto _LOR;
+ else goto _LAND_4;
+ }
+ else {
+ _LAND_4: ;
+ if ((int)*(parser->buffer.pointer + 1) >= (int)((unsigned char)'A')) {
+ if ((int)*(parser->buffer.pointer + 1) <= (int)((unsigned char)'F'))
+ goto _LOR;
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if ((int)*(parser->buffer.pointer + 1) >= (int)((unsigned char)'a')) {
+ if ((int)*(parser->buffer.pointer + 1) <= (int)((unsigned char)'f')) {
+ _LOR: ;
+ if ((int)*(parser->buffer.pointer + 2) >= (int)((unsigned char)'0')) {
+ if (! ((int)*(parser->buffer.pointer + 2) <= (int)((unsigned char)'9')))
+ goto _LAND_1;
+ }
+ else {
+ _LAND_1: ;
+ if ((int)*(parser->buffer.pointer + 2) >= (int)((unsigned char)'A')) {
+ if (! ((int)*(parser->buffer.pointer + 2) <= (int)((unsigned char)'F')))
+ goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(parser->buffer.pointer + 2) >= (int)((unsigned char)'a')) {
+ if (! ((int)*(parser->buffer.pointer + 2) <= (int)((unsigned char)'f')))
+ goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ }
+ }
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ }
+ else {
+ _LAND_2:
+ {
+ int tmp_2;
+ char const *tmp_1;
+ ;
+ if (directive) tmp_1 = "while parsing a %TAG directive";
+ else tmp_1 = "while parsing a tag";
+ ;
+ tmp_2 = yaml_parser_set_scanner_error(parser,tmp_1,start_mark,
+ "did not find URI escaped octet");
+ __retres = tmp_2;
+ goto return_label;
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 1) >= (int)((unsigned char)'A')) {
+ if ((int)*(parser->buffer.pointer + 1) <= (int)((unsigned char)'F'))
+ tmp_4 = ((int)*(parser->buffer.pointer + 1) - (int)((unsigned char)'A')) + 10;
+ else goto _LAND_5;
+ }
+ else {
+ int tmp_3;
+ _LAND_5:
+ if ((int)*(parser->buffer.pointer + 1) >= (int)((unsigned char)'a'))
+ if ((int)*(parser->buffer.pointer + 1) <= (int)((unsigned char)'f'))
+ tmp_3 = ((int)*(parser->buffer.pointer + 1) - (int)((unsigned char)'a')) + 10;
+ else tmp_3 = (int)*(parser->buffer.pointer + 1) - (int)((unsigned char)'0');
+ else tmp_3 = (int)*(parser->buffer.pointer + 1) - (int)((unsigned char)'0');
+ tmp_4 = tmp_3;
+ }
+ if ((int)*(parser->buffer.pointer + 2) >= (int)((unsigned char)'A')) {
+ if ((int)*(parser->buffer.pointer + 2) <= (int)((unsigned char)'F'))
+ tmp_6 = ((int)*(parser->buffer.pointer + 2) - (int)((unsigned char)'A')) + 10;
+ else goto _LAND_6;
+ }
+ else {
+ int tmp_5;
+ _LAND_6:
+ if ((int)*(parser->buffer.pointer + 2) >= (int)((unsigned char)'a'))
+ if ((int)*(parser->buffer.pointer + 2) <= (int)((unsigned char)'f'))
+ tmp_5 = ((int)*(parser->buffer.pointer + 2) - (int)((unsigned char)'a')) + 10;
+ else tmp_5 = (int)*(parser->buffer.pointer + 2) - (int)((unsigned char)'0');
+ else tmp_5 = (int)*(parser->buffer.pointer + 2) - (int)((unsigned char)'0');
+ tmp_6 = tmp_5;
+ }
+ octet = (unsigned char)((tmp_4 << 4) + tmp_6);
+ if (! width) {
+ if (((int)octet & 0x80) == 0x00) width = 1;
+ else {
+ int tmp_9;
+ if (((int)octet & 0xE0) == 0xC0) tmp_9 = 2;
+ else {
+ int tmp_8;
+ if (((int)octet & 0xF0) == 0xE0) tmp_8 = 3;
+ else {
+ int tmp_7;
+ if (((int)octet & 0xF8) == 0xF0) tmp_7 = 4; else tmp_7 = 0;
+ tmp_8 = tmp_7;
+ }
+ tmp_9 = tmp_8;
+ }
+ width = tmp_9;
+ }
+ if (! width) {
+ int tmp_11;
+ char const *tmp_10;
+ ;
+ if (directive) tmp_10 = "while parsing a %TAG directive";
+ else tmp_10 = "while parsing a tag";
+ ;
+ tmp_11 = yaml_parser_set_scanner_error(parser,tmp_10,start_mark,
+ "found an incorrect leading UTF-8 octet");
+ __retres = tmp_11;
+ goto return_label;
+ }
+ }
+ else
+ if (((int)octet & 0xC0) != 0x80) {
+ int tmp_13;
+ char const *tmp_12;
+ ;
+ if (directive) tmp_12 = "while parsing a %TAG directive";
+ else tmp_12 = "while parsing a tag";
+ ;
+ tmp_13 = yaml_parser_set_scanner_error(parser,tmp_12,start_mark,
+ "found an incorrect trailing UTF-8 octet");
+ __retres = tmp_13;
+ goto return_label;
+ }
+ tmp_14 = string->pointer;
+ (string->pointer) ++;
+ *tmp_14 = octet;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_18 = 1;
+ else {
+ int tmp_17;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_17 = 2;
+ else {
+ int tmp_16;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_16 = 3;
+ else {
+ int tmp_15;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_15 = 4;
+ else tmp_15 = 0;
+ tmp_16 = tmp_15;
+ }
+ tmp_17 = tmp_16;
+ }
+ tmp_18 = tmp_17;
+ }
+ parser->buffer.pointer += tmp_18;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_22 = 1;
+ else {
+ int tmp_21;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_21 = 2;
+ else {
+ int tmp_20;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_20 = 3;
+ else {
+ int tmp_19;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_19 = 4;
+ else tmp_19 = 0;
+ tmp_20 = tmp_19;
+ }
+ tmp_21 = tmp_20;
+ }
+ tmp_22 = tmp_21;
+ }
+ parser->buffer.pointer += tmp_22;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_26 = 1;
+ else {
+ int tmp_25;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_25 = 2;
+ else {
+ int tmp_24;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_24 = 3;
+ else {
+ int tmp_23;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_23 = 4;
+ else tmp_23 = 0;
+ tmp_24 = tmp_23;
+ }
+ tmp_25 = tmp_24;
+ }
+ tmp_26 = tmp_25;
+ }
+ parser->buffer.pointer += tmp_26;
+ }
+ width --;
+ if (! width) break;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_block_scalar(yaml_parser_t *parser,
+ yaml_token_t *token, int literal)
+{
+ int __retres;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ int tmp_0;
+ int tmp_2;
+ int tmp_4;
+ int tmp_8;
+ int tmp_10;
+ int tmp_32;
+ int tmp_51_1;
+ int tmp_53_1;
+ yaml_string_t string =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ yaml_string_t leading_break =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ yaml_string_t trailing_breaks =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ int chomping = 0;
+ int increment = 0;
+ int indent = 0;
+ int leading_blank = 0;
+ int trailing_blank = 0;
+ string.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (string.start) {
+ string.pointer = string.start;
+ string.end = string.start + 16;
+ memset((void *)string.start,0,(unsigned long)16);
+ tmp_0 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_0 = 0;
+ }
+ if (! tmp_0) goto error;
+ leading_break.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (leading_break.start) {
+ leading_break.pointer = leading_break.start;
+ leading_break.end = leading_break.start + 16;
+ memset((void *)leading_break.start,0,(unsigned long)16);
+ tmp_2 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ if (! tmp_2) goto error;
+ trailing_breaks.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (trailing_breaks.start) {
+ trailing_breaks.pointer = trailing_breaks.start;
+ trailing_breaks.end = trailing_breaks.start + 16;
+ memset((void *)trailing_breaks.start,0,(unsigned long)16);
+ tmp_4 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_4 = 0;
+ }
+ if (! tmp_4) goto error;
+ start_mark = parser->mark;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_8 = 1;
+ else {
+ int tmp_7;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_7 = 2;
+ else {
+ int tmp_6;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_6 = 3;
+ else {
+ int tmp_5;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_5 = 4;
+ else tmp_5 = 0;
+ tmp_6 = tmp_5;
+ }
+ tmp_7 = tmp_6;
+ }
+ tmp_8 = tmp_7;
+ }
+ parser->buffer.pointer += tmp_8;
+ if (parser->unread >= (size_t)1) tmp_10 = 1;
+ else tmp_10 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_10) goto error;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'+'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'-')) {
+ _LOR_0:
+ {
+ int tmp_14;
+ int tmp_16;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'+'))
+ chomping = 1;
+ else chomping = -1;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_14 = 1;
+ else {
+ int tmp_13;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_13 = 2;
+ else {
+ int tmp_12;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_12 = 3;
+ else {
+ int tmp_11;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_11 = 4;
+ else tmp_11 = 0;
+ tmp_12 = tmp_11;
+ }
+ tmp_13 = tmp_12;
+ }
+ tmp_14 = tmp_13;
+ }
+ parser->buffer.pointer += tmp_14;
+ if (parser->unread >= (size_t)1) tmp_16 = 1;
+ else tmp_16 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_16) goto error;
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'0'))
+ if ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'9')) {
+ int tmp_20;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'0')) {
+ yaml_parser_set_scanner_error(parser,
+ "while scanning a block scalar",
+ start_mark,
+ "found an indentation indicator equal to 0");
+ goto error;
+ }
+ increment = (int)*(parser->buffer.pointer + 0) - (int)((unsigned char)'0');
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_20 = 1;
+ else {
+ int tmp_19;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_19 = 2;
+ else {
+ int tmp_18;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_18 = 3;
+ else {
+ int tmp_17;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_17 = 4;
+ else tmp_17 = 0;
+ tmp_18 = tmp_17;
+ }
+ tmp_19 = tmp_18;
+ }
+ tmp_20 = tmp_19;
+ }
+ parser->buffer.pointer += tmp_20;
+ }
+ }
+ }
+ else
+ if ((int)*(parser->buffer.pointer + 0) >= (int)((unsigned char)'0'))
+ if ((int)*(parser->buffer.pointer + 0) <= (int)((unsigned char)'9')) {
+ int tmp_24;
+ int tmp_26;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'0')) {
+ yaml_parser_set_scanner_error(parser,
+ "while scanning a block scalar",
+ start_mark,
+ "found an indentation indicator equal to 0");
+ goto error;
+ }
+ increment = (int)*(parser->buffer.pointer + 0) - (int)((unsigned char)'0');
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_24 = 1;
+ else {
+ int tmp_23;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_23 = 2;
+ else {
+ int tmp_22;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_22 = 3;
+ else {
+ int tmp_21;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_21 = 4;
+ else tmp_21 = 0;
+ tmp_22 = tmp_21;
+ }
+ tmp_23 = tmp_22;
+ }
+ tmp_24 = tmp_23;
+ }
+ parser->buffer.pointer += tmp_24;
+ if (parser->unread >= (size_t)1) tmp_26 = 1;
+ else tmp_26 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_26) goto error;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'+'))
+ goto _LOR;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'-')) {
+ _LOR:
+ {
+ int tmp_30;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'+'))
+ chomping = 1;
+ else chomping = -1;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_30 = 1;
+ else {
+ int tmp_29;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_29 = 2;
+ else {
+ int tmp_28;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_28 = 3;
+ else {
+ int tmp_27;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_27 = 4;
+ else tmp_27 = 0;
+ tmp_28 = tmp_27;
+ }
+ tmp_29 = tmp_28;
+ }
+ tmp_30 = tmp_29;
+ }
+ parser->buffer.pointer += tmp_30;
+ }
+ }
+ }
+ if (parser->unread >= (size_t)1) tmp_32 = 1;
+ else tmp_32 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_32) goto error;
+ while (1) {
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')))
+ break;
+ {
+ int tmp_36;
+ int tmp_38;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_36 = 1;
+ else {
+ int tmp_35;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_35 = 2;
+ else {
+ int tmp_34;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_34 = 3;
+ else {
+ int tmp_33;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_33 = 4;
+ else tmp_33 = 0;
+ tmp_34 = tmp_33;
+ }
+ tmp_35 = tmp_34;
+ }
+ tmp_36 = tmp_35;
+ }
+ parser->buffer.pointer += tmp_36;
+ if (parser->unread >= (size_t)1) tmp_38 = 1;
+ else tmp_38 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_38) goto error;
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'#'))
+ while (1) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ break;
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ break;
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ _LAND_2: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251'))
+ break;
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000'))
+ break;
+ }
+ }
+ }
+ {
+ int tmp_42;
+ int tmp_44;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_42 = 1;
+ else {
+ int tmp_41;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_41 = 2;
+ else {
+ int tmp_40;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_40 = 3;
+ else {
+ int tmp_39;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_39 = 4;
+ else tmp_39 = 0;
+ tmp_40 = tmp_39;
+ }
+ tmp_41 = tmp_40;
+ }
+ tmp_42 = tmp_41;
+ }
+ parser->buffer.pointer += tmp_42;
+ if (parser->unread >= (size_t)1) tmp_44 = 1;
+ else tmp_44 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_44) goto error;
+ }
+ }
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')))
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205')))
+ goto _LAND_8;
+ }
+ else {
+ _LAND_8: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250')))
+ goto _LAND_7;
+ }
+ else goto _LAND_7;
+ }
+ else {
+ _LAND_7: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')))
+ goto _LAND_5;
+ }
+ else goto _LAND_5;
+ }
+ else {
+ _LAND_5: ;
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000'))) {
+ yaml_parser_set_scanner_error(parser,
+ "while scanning a block scalar",
+ start_mark,
+ "did not find expected comment or line break");
+ goto error;
+ }
+ }
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_2;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ goto _LOR_2;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_2;
+ else goto _LAND_15;
+ }
+ else {
+ _LAND_15: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_2;
+ else goto _LAND_14;
+ }
+ else goto _LAND_14;
+ }
+ else {
+ _LAND_14: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200'))
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')) {
+ _LOR_2:
+ {
+ int tmp_46;
+ if (parser->unread >= (size_t)2) tmp_46 = 1;
+ else tmp_46 = yaml_parser_update_buffer(parser,
+ (unsigned long)2);
+ if (! tmp_46) goto error;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\n')) {
+ parser->mark.index += (size_t)2;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)2;
+ parser->buffer.pointer += 2;
+ yaml_char_t *tmp_53 = parser->buffer.pointer;
+ }
+ else goto _LAND_12;
+ }
+ else {
+ _LAND_12: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_1;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ goto _LOR_1;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_1;
+ else goto _LAND_11;
+ }
+ else {
+ _LAND_11: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_1;
+ else goto _LAND_10;
+ }
+ else goto _LAND_10;
+ }
+ else {
+ _LAND_10: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200'))
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')) {
+ int tmp_50;
+ _LOR_1: parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_50 = 1;
+ else {
+ int tmp_49;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_49 = 2;
+ else {
+ int tmp_48;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_48 = 3;
+ else {
+ int tmp_47;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_47 = 4;
+ else tmp_47 = 0;
+ tmp_48 = tmp_47;
+ }
+ tmp_49 = tmp_48;
+ }
+ tmp_50 = tmp_49;
+ }
+ parser->buffer.pointer += tmp_50;
+ yaml_char_t *tmp_51 =
+ parser->buffer.pointer;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ end_mark = parser->mark;
+ if (increment)
+ if (parser->indent >= 0) indent = parser->indent + increment;
+ else indent = increment;
+ tmp_51_1 = yaml_parser_scan_block_scalar_breaks(parser,& indent,
+ & trailing_breaks,
+ start_mark,& end_mark);
+ if (! tmp_51_1) goto error;
+ if (parser->unread >= (size_t)1) tmp_53_1 = 1;
+ else tmp_53_1 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_53_1) goto error;
+ while (1) {
+ if ((int)parser->mark.column == indent) {
+ if (! (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000'))))
+ break;
+ }
+ else break;
+ {
+ int tmp_54;
+ int tmp_61;
+ int tmp_60;
+ int tmp_62;
+ int tmp_89_0;
+ int tmp_101_0;
+ int tmp_91_0;
+ int tmp_102;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' '))
+ tmp_54 = 1;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t'))
+ tmp_54 = 1;
+ else tmp_54 = 0;
+ trailing_blank = tmp_54;
+ if (! literal) {
+ if ((int)*(leading_break.start) == '\n') {
+ if (! leading_blank) {
+ if (! trailing_blank) {
+ if ((int)*(trailing_breaks.start) == '\000') {
+ int tmp_56;
+ yaml_char_t *tmp_57;
+ if (string.pointer + 5 < string.end) tmp_56 = 1;
+ else {
+ int tmp_55;
+ tmp_55 = yaml_string_extend(& string.start,
+ & string.pointer,& string.end);
+ if (tmp_55) tmp_56 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_56 = 0;
+ }
+ }
+ if (! tmp_56) goto error;
+ tmp_57 = string.pointer;
+ (string.pointer) ++;
+ *tmp_57 = (unsigned char)' ';
+ }
+ leading_break.pointer = leading_break.start;
+ memset((void *)leading_break.start,0,
+ (unsigned long)(leading_break.end - leading_break.start));
+ }
+ else goto _LAND_18;
+ }
+ else goto _LAND_18;
+ }
+ else goto _LAND_18;
+ }
+ else {
+ _LAND_18:
+ {
+ int tmp_59;
+ int tmp_58;
+ tmp_58 = yaml_string_join(& string.start,& string.pointer,
+ & string.end,& leading_break.start,
+ & leading_break.pointer,
+ & leading_break.end);
+ if (tmp_58) {
+ leading_break.pointer = leading_break.start;
+ tmp_59 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_59 = 0;
+ }
+ if (! tmp_59) goto error;
+ leading_break.pointer = leading_break.start;
+ memset((void *)leading_break.start,0,
+ (unsigned long)(leading_break.end - leading_break.start));
+ }
+ }
+ tmp_60 = yaml_string_join(& string.start,& string.pointer,& string.end,
+ & trailing_breaks.start,
+ & trailing_breaks.pointer,
+ & trailing_breaks.end);
+ if (tmp_60) {
+ trailing_breaks.pointer = trailing_breaks.start;
+ tmp_61 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_61 = 0;
+ }
+ if (! tmp_61) goto error;
+ trailing_breaks.pointer = trailing_breaks.start;
+ memset((void *)trailing_breaks.start,0,
+ (unsigned long)(trailing_breaks.end - trailing_breaks.start));
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' '))
+ tmp_62 = 1;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t'))
+ tmp_62 = 1;
+ else tmp_62 = 0;
+ leading_blank = tmp_62;
+ while (1) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ break;
+ else goto _LAND_23;
+ }
+ else {
+ _LAND_23: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ break;
+ else goto _LAND_22;
+ }
+ else goto _LAND_22;
+ }
+ else {
+ _LAND_22: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251'))
+ break;
+ else goto _LAND_20;
+ }
+ else goto _LAND_20;
+ }
+ else {
+ _LAND_20: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000'))
+ break;
+ }
+ }
+ }
+ {
+ int tmp_85_0;
+ int tmp_64;
+ int tmp_87_0;
+ if (string.pointer + 5 < string.end) tmp_64 = 1;
+ else {
+ int tmp_63;
+ tmp_63 = yaml_string_extend(& string.start,& string.pointer,
+ & string.end);
+ if (tmp_63) tmp_64 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_64 = 0;
+ }
+ }
+ if (tmp_64) {
+ if (((int)*(parser->buffer.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_65;
+ yaml_char_t *tmp_66;
+ tmp_65 = string.pointer;
+ (string.pointer) ++;
+ tmp_66 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_65 = *tmp_66;
+ yaml_char_t tmp_91 = *tmp_65;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_67;
+ yaml_char_t *tmp_68;
+ yaml_char_t *tmp_69;
+ yaml_char_t *tmp_70;
+ tmp_67 = string.pointer;
+ (string.pointer) ++;
+ tmp_68 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_67 = *tmp_68;
+ tmp_69 = string.pointer;
+ (string.pointer) ++;
+ tmp_70 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_69 = *tmp_70;
+ yaml_char_t tmp_89 = *tmp_69;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_71;
+ yaml_char_t *tmp_72;
+ yaml_char_t *tmp_73;
+ yaml_char_t *tmp_74;
+ yaml_char_t *tmp_75;
+ yaml_char_t *tmp_76;
+ tmp_71 = string.pointer;
+ (string.pointer) ++;
+ tmp_72 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_71 = *tmp_72;
+ tmp_73 = string.pointer;
+ (string.pointer) ++;
+ tmp_74 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_73 = *tmp_74;
+ tmp_75 = string.pointer;
+ (string.pointer) ++;
+ tmp_76 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_75 = *tmp_76;
+ yaml_char_t tmp_87 = *tmp_75;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_77;
+ yaml_char_t *tmp_78;
+ yaml_char_t *tmp_79;
+ yaml_char_t *tmp_80;
+ yaml_char_t *tmp_81;
+ yaml_char_t *tmp_82;
+ yaml_char_t *tmp_83;
+ yaml_char_t *tmp_84;
+ tmp_77 = string.pointer;
+ (string.pointer) ++;
+ tmp_78 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_77 = *tmp_78;
+ tmp_79 = string.pointer;
+ (string.pointer) ++;
+ tmp_80 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_79 = *tmp_80;
+ tmp_81 = string.pointer;
+ (string.pointer) ++;
+ tmp_82 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_81 = *tmp_82;
+ tmp_83 = string.pointer;
+ (string.pointer) ++;
+ tmp_84 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_83 = *tmp_84;
+ yaml_char_t tmp_85 = *tmp_83;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ tmp_85_0 = 1;
+ }
+ else tmp_85_0 = 0;
+ if (! tmp_85_0) goto error;
+ if (parser->unread >= (size_t)1) tmp_87_0 = 1;
+ else tmp_87_0 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_87_0) goto error;
+ }
+ }
+ if (parser->unread >= (size_t)2) tmp_89_0 = 1;
+ else tmp_89_0 = yaml_parser_update_buffer(parser,(unsigned long)2);
+ if (! tmp_89_0) goto error;
+ if (leading_break.pointer + 5 < leading_break.end) tmp_91_0 = 1;
+ else {
+ int tmp_90;
+ tmp_90 = yaml_string_extend(& leading_break.start,
+ & leading_break.pointer,
+ & leading_break.end);
+ if (tmp_90) tmp_91_0 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_91_0 = 0;
+ }
+ }
+ if (tmp_91_0) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\n')) {
+ yaml_char_t *tmp_92;
+ tmp_92 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ *tmp_92 = (unsigned char)'\n';
+ parser->buffer.pointer += 2;
+ parser->mark.index += (size_t)2;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)2;
+ size_t tmp_107 = parser->unread;
+ }
+ else goto _LAND_25;
+ }
+ else {
+ _LAND_25: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_4;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')) {
+ yaml_char_t *tmp_93;
+ _LOR_4:
+ { /* sequence */
+ tmp_93 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ *tmp_93 = (unsigned char)'\n';
+ }
+ (parser->buffer.pointer) ++;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_105 = parser->unread;
+ }
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\205')) {
+ yaml_char_t *tmp_94;
+ tmp_94 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ *tmp_94 = (unsigned char)'\n';
+ parser->buffer.pointer += 2;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_103 = parser->unread;
+ }
+ else goto _LAND_24;
+ }
+ else {
+ _LAND_24: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\200'))
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'\250'))
+ goto _LOR_3;
+ else
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'\251')) {
+ yaml_char_t *tmp_95;
+ yaml_char_t *tmp_96;
+ yaml_char_t *tmp_97;
+ yaml_char_t *tmp_98;
+ yaml_char_t *tmp_99;
+ yaml_char_t *tmp_100;
+ _LOR_3:
+ { /* sequence */
+ tmp_95 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ tmp_96 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_95 = *tmp_96;
+ }
+ tmp_97 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ tmp_98 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_97 = *tmp_98;
+ tmp_99 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ tmp_100 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_99 = *tmp_100;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_101 = parser->unread;
+ }
+ }
+ }
+ tmp_101_0 = 1;
+ }
+ else tmp_101_0 = 0;
+ if (! tmp_101_0) goto error;
+ tmp_102 = yaml_parser_scan_block_scalar_breaks(parser,& indent,
+ & trailing_breaks,
+ start_mark,& end_mark);
+ if (! tmp_102) goto error;
+ }
+ }
+ if (chomping != -1) {
+ int tmp_104;
+ int tmp_103_0;
+ tmp_103_0 = yaml_string_join(& string.start,& string.pointer,
+ & string.end,& leading_break.start,
+ & leading_break.pointer,& leading_break.end);
+ if (tmp_103_0) {
+ leading_break.pointer = leading_break.start;
+ tmp_104 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_104 = 0;
+ }
+ if (! tmp_104) goto error;
+ }
+ if (chomping == 1) {
+ int tmp_106;
+ int tmp_105_0;
+ tmp_105_0 = yaml_string_join(& string.start,& string.pointer,
+ & string.end,& trailing_breaks.start,
+ & trailing_breaks.pointer,
+ & trailing_breaks.end);
+ if (tmp_105_0) {
+ trailing_breaks.pointer = trailing_breaks.start;
+ tmp_106 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_106 = 0;
+ }
+ if (! tmp_106) goto error;
+ }
+ memset((void *)token,0,sizeof(yaml_token_t));
+ token->type = YAML_SCALAR_TOKEN;
+ token->start_mark = start_mark;
+ token->end_mark = end_mark;
+ token->data.scalar.value = string.start;
+ token->data.scalar.length = (unsigned long)(string.pointer - string.start);
+ if (literal) token->data.scalar.style = YAML_LITERAL_SCALAR_STYLE;
+ else token->data.scalar.style = YAML_FOLDED_SCALAR_STYLE;
+ yaml_free((void *)leading_break.start);
+ leading_break.end = (yaml_char_t *)0;
+ leading_break.pointer = leading_break.end;
+ leading_break.start = leading_break.pointer;
+ yaml_free((void *)trailing_breaks.start);
+ trailing_breaks.end = (yaml_char_t *)0;
+ trailing_breaks.pointer = trailing_breaks.end;
+ trailing_breaks.start = trailing_breaks.pointer;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)string.start);
+ string.end = (yaml_char_t *)0;
+ string.pointer = string.end;
+ string.start = string.pointer;
+ yaml_free((void *)leading_break.start);
+ leading_break.end = (yaml_char_t *)0;
+ leading_break.pointer = leading_break.end;
+ leading_break.start = leading_break.pointer;
+ yaml_free((void *)trailing_breaks.start);
+ trailing_breaks.end = (yaml_char_t *)0;
+ trailing_breaks.pointer = trailing_breaks.end;
+ trailing_breaks.start = trailing_breaks.pointer;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_block_scalar_breaks(yaml_parser_t *parser,
+ int *indent,
+ yaml_string_t *breaks,
+ yaml_mark_t start_mark,
+ yaml_mark_t *end_mark)
+{
+ int __retres;
+ int max_indent = 0;
+ *end_mark = parser->mark;
+ while (1) {
+ {
+ int tmp_0;
+ int tmp_9;
+ int tmp_21_1;
+ int tmp_11;
+ if (parser->unread >= (size_t)1) tmp_0 = 1;
+ else tmp_0 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_0) {
+ __retres = 0;
+ goto return_label;
+ }
+ while (1) {
+ if (! *indent) goto _LOR;
+ else
+ if ((int)parser->mark.column < *indent) {
+ _LOR: ;
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ break;
+ }
+ else break;
+ {
+ int tmp_4;
+ int tmp_6;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_4 = 1;
+ else {
+ int tmp_3;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_3 = 2;
+ else {
+ int tmp_2;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_2 = 3;
+ else {
+ int tmp_1;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_1 = 4;
+ else tmp_1 = 0;
+ tmp_2 = tmp_1;
+ }
+ tmp_3 = tmp_2;
+ }
+ tmp_4 = tmp_3;
+ }
+ parser->buffer.pointer += tmp_4;
+ if (parser->unread >= (size_t)1) tmp_6 = 1;
+ else tmp_6 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_6) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ if ((int)parser->mark.column > max_indent) max_indent = (int)parser->mark.column;
+ if (! *indent) goto _LOR_0;
+ else
+ if ((int)parser->mark.column < *indent) {
+ _LOR_0: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')) {
+ int tmp_7;
+ tmp_7 = yaml_parser_set_scanner_error(parser,
+ "while scanning a block scalar",
+ start_mark,
+ "found a tab character where an indentation space is expected");
+ __retres = tmp_7;
+ goto return_label;
+ }
+ }
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')))
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205')))
+ goto _LAND_1;
+ }
+ else {
+ _LAND_1: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250')))
+ goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')))
+ break;
+ }
+ else break;
+ else break;
+ }
+ }
+ if (parser->unread >= (size_t)2) tmp_9 = 1;
+ else tmp_9 = yaml_parser_update_buffer(parser,(unsigned long)2);
+ if (! tmp_9) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (breaks->pointer + 5 < breaks->end) tmp_11 = 1;
+ else {
+ int tmp_10;
+ tmp_10 = yaml_string_extend(& breaks->start,& breaks->pointer,
+ & breaks->end);
+ if (tmp_10) tmp_11 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_11 = 0;
+ }
+ }
+ if (tmp_11) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\n')) {
+ yaml_char_t *tmp_12;
+ tmp_12 = breaks->pointer;
+ (breaks->pointer) ++;
+ *tmp_12 = (unsigned char)'\n';
+ parser->buffer.pointer += 2;
+ parser->mark.index += (size_t)2;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)2;
+ size_t tmp_27 = parser->unread;
+ }
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_2;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')) {
+ yaml_char_t *tmp_13;
+ _LOR_2:
+ { /* sequence */
+ tmp_13 = breaks->pointer;
+ (breaks->pointer) ++;
+ *tmp_13 = (unsigned char)'\n';
+ }
+ (parser->buffer.pointer) ++;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_25 = parser->unread;
+ }
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\205')) {
+ yaml_char_t *tmp_14;
+ tmp_14 = breaks->pointer;
+ (breaks->pointer) ++;
+ *tmp_14 = (unsigned char)'\n';
+ parser->buffer.pointer += 2;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_23 = parser->unread;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ _LAND_2: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\200'))
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'\250'))
+ goto _LOR_1;
+ else
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'\251')) {
+ yaml_char_t *tmp_15;
+ yaml_char_t *tmp_16;
+ yaml_char_t *tmp_17;
+ yaml_char_t *tmp_18;
+ yaml_char_t *tmp_19;
+ yaml_char_t *tmp_20;
+ _LOR_1:
+ { /* sequence */
+ tmp_15 = breaks->pointer;
+ (breaks->pointer) ++;
+ tmp_16 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_15 = *tmp_16;
+ }
+ tmp_17 = breaks->pointer;
+ (breaks->pointer) ++;
+ tmp_18 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_17 = *tmp_18;
+ tmp_19 = breaks->pointer;
+ (breaks->pointer) ++;
+ tmp_20 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_19 = *tmp_20;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_21 = parser->unread;
+ }
+ }
+ }
+ tmp_21_1 = 1;
+ }
+ else tmp_21_1 = 0;
+ if (! tmp_21_1) {
+ __retres = 0;
+ goto return_label;
+ }
+ *end_mark = parser->mark;
+ }
+ }
+ if (! *indent) {
+ *indent = max_indent;
+ if (*indent < parser->indent + 1) *indent = parser->indent + 1;
+ if (*indent < 1) *indent = 1;
+ }
+ __retres = 1;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_flow_scalar(yaml_parser_t *parser,
+ yaml_token_t *token, int single)
+{
+ int __retres;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ int leading_blanks;
+ int tmp_0;
+ int tmp_2;
+ int tmp_4;
+ int tmp_6;
+ int tmp_10;
+ int tmp_187;
+ yaml_string_t string =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ yaml_string_t leading_break =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ yaml_string_t trailing_breaks =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ yaml_string_t whitespaces =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ string.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (string.start) {
+ string.pointer = string.start;
+ string.end = string.start + 16;
+ memset((void *)string.start,0,(unsigned long)16);
+ tmp_0 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_0 = 0;
+ }
+ if (! tmp_0) goto error;
+ leading_break.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (leading_break.start) {
+ leading_break.pointer = leading_break.start;
+ leading_break.end = leading_break.start + 16;
+ memset((void *)leading_break.start,0,(unsigned long)16);
+ tmp_2 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ if (! tmp_2) goto error;
+ trailing_breaks.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (trailing_breaks.start) {
+ trailing_breaks.pointer = trailing_breaks.start;
+ trailing_breaks.end = trailing_breaks.start + 16;
+ memset((void *)trailing_breaks.start,0,(unsigned long)16);
+ tmp_4 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_4 = 0;
+ }
+ if (! tmp_4) goto error;
+ whitespaces.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (whitespaces.start) {
+ whitespaces.pointer = whitespaces.start;
+ whitespaces.end = whitespaces.start + 16;
+ memset((void *)whitespaces.start,0,(unsigned long)16);
+ tmp_6 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_6 = 0;
+ }
+ if (! tmp_6) goto error;
+ start_mark = parser->mark;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_10 = 1;
+ else {
+ int tmp_9;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_9 = 2;
+ else {
+ int tmp_8;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_8 = 3;
+ else {
+ int tmp_7;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_7 = 4;
+ else tmp_7 = 0;
+ tmp_8 = tmp_7;
+ }
+ tmp_9 = tmp_8;
+ }
+ tmp_10 = tmp_9;
+ }
+ parser->buffer.pointer += tmp_10;
+ while (1) {
+ {
+ int tmp_12;
+ int tmp_14;
+ int tmp_114;
+ int tmp_115_0;
+ int tmp_117;
+ if (parser->unread >= (size_t)4) tmp_12 = 1;
+ else tmp_12 = yaml_parser_update_buffer(parser,(unsigned long)4);
+ if (! tmp_12) goto error;
+ if (parser->mark.column == (size_t)0)
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'-')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'-')) {
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'-'))
+ goto _LOR_1;
+ else goto _LAND_5;
+ }
+ else goto _LAND_5;
+ }
+ else {
+ _LAND_5: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'.'))
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'.'))
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'.')) {
+ _LOR_1: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)' '))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\t'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\r'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\n'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (3 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_0;
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (3 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (3 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_0;
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ _LAND_2: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (3 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (3 + 2)) == (int)((unsigned char)'\251'))
+ goto _LOR_0;
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\000')) {
+ _LOR_0:
+ {
+ yaml_parser_set_scanner_error(parser,
+ "while scanning a quoted scalar",
+ start_mark,
+ "found unexpected document indicator");
+ goto error;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000')) {
+ yaml_parser_set_scanner_error(parser,
+ "while scanning a quoted scalar",
+ start_mark,
+ "found unexpected end of stream");
+ goto error;
+ }
+ if (parser->unread >= (size_t)2) tmp_14 = 1;
+ else tmp_14 = yaml_parser_update_buffer(parser,(unsigned long)2);
+ if (! tmp_14) goto error;
+ leading_blanks = 0;
+ while (1) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' '))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ break;
+ else goto _LAND_27;
+ }
+ else {
+ _LAND_27: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ break;
+ else goto _LAND_26;
+ }
+ else goto _LAND_26;
+ }
+ else {
+ _LAND_26: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251'))
+ break;
+ else goto _LAND_24;
+ }
+ else goto _LAND_24;
+ }
+ else {
+ _LAND_24: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000'))
+ break;
+ }
+ }
+ }
+ {
+ int tmp_112;
+ if (single) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\'')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\'')) {
+ int tmp_16;
+ yaml_char_t *tmp_17;
+ int tmp_21;
+ int tmp_25;
+ if (string.pointer + 5 < string.end) tmp_16 = 1;
+ else {
+ int tmp_15;
+ tmp_15 = yaml_string_extend(& string.start,
+ & string.pointer,& string.end);
+ if (tmp_15) tmp_16 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_16 = 0;
+ }
+ }
+ if (! tmp_16) goto error;
+ tmp_17 = string.pointer;
+ (string.pointer) ++;
+ *tmp_17 = (unsigned char)'\'';
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_21 = 1;
+ else {
+ int tmp_20;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_20 = 2;
+ else {
+ int tmp_19;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_19 = 3;
+ else {
+ int tmp_18;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_18 = 4;
+ else tmp_18 = 0;
+ tmp_19 = tmp_18;
+ }
+ tmp_20 = tmp_19;
+ }
+ tmp_21 = tmp_20;
+ }
+ parser->buffer.pointer += tmp_21;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_25 = 1;
+ else {
+ int tmp_24;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_24 = 2;
+ else {
+ int tmp_23;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_23 = 3;
+ else {
+ int tmp_22;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_22 = 4;
+ else tmp_22 = 0;
+ tmp_23 = tmp_22;
+ }
+ tmp_24 = tmp_23;
+ }
+ tmp_25 = tmp_24;
+ }
+ parser->buffer.pointer += tmp_25;
+ }
+ else goto _LAND_22;
+ }
+ else goto _LAND_22;
+ }
+ else {
+ int tmp_110;
+ _LAND_22:
+ { /* sequence */
+ if (single) tmp_110 = '\''; else tmp_110 = '\"';
+ ;
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)tmp_110))
+ break;
+ else
+ if (! single) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\\')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\r'))
+ goto _LOR_4;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\n'))
+ goto _LOR_4;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_4;
+ else goto _LAND_19;
+ }
+ else {
+ _LAND_19: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (1 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_4;
+ else goto _LAND_18;
+ }
+ else goto _LAND_18;
+ }
+ else {
+ _LAND_18: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (1 + 2)) == (int)((unsigned char)'\251')) {
+ _LOR_4:
+ {
+ int tmp_27;
+ int tmp_31;
+ if (parser->unread >= (size_t)3) tmp_27 = 1;
+ else tmp_27 = yaml_parser_update_buffer
+ (parser,(unsigned long)3);
+ if (! tmp_27) goto error;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_31 = 1;
+ else {
+ int tmp_30;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_30 = 2;
+ else {
+ int tmp_29;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_29 = 3;
+ else {
+ int tmp_28;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_28 = 4;
+ else tmp_28 = 0;
+ tmp_29 = tmp_28;
+ }
+ tmp_30 = tmp_29;
+ }
+ tmp_31 = tmp_30;
+ }
+ parser->buffer.pointer += tmp_31;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')) {
+ if ((int)*(parser->buffer.pointer + (
+ 0 + 1)) == (int)((unsigned char)'\n')) {
+ parser->mark.index += (size_t)2;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)2;
+ parser->buffer.pointer += 2;
+ yaml_char_t *tmp_38 =
+ parser->buffer.pointer;
+ }
+ else goto _LAND_9;
+ }
+ else {
+ _LAND_9: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_2;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ goto _LOR_2;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (
+ 0 + 1)) == (int)((unsigned char)'\205'))
+ goto _LOR_2;
+ else goto _LAND_8;
+ }
+ else {
+ _LAND_8: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (
+ 0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (
+ 0 + 2)) == (int)((unsigned char)'\250'))
+ goto _LOR_2;
+ else goto _LAND_7;
+ }
+ else goto _LAND_7;
+ }
+ else {
+ _LAND_7: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + (
+ 0 + 1)) == (int)((unsigned char)'\200'))
+ if ((int)*(parser->buffer.pointer + (
+ 0 + 2)) == (int)((unsigned char)'\251')) {
+ int tmp_35;
+ _LOR_2:
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_35 = 1;
+ else {
+ int tmp_34;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_34 = 2;
+ else {
+ int tmp_33;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_33 = 3;
+ else {
+ int tmp_32;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_32 = 4;
+ else tmp_32 = 0;
+ tmp_33 = tmp_32;
+ }
+ tmp_34 = tmp_33;
+ }
+ tmp_35 = tmp_34;
+ }
+ parser->buffer.pointer += tmp_35;
+ yaml_char_t *tmp_36 =
+ parser->buffer.pointer;
+ }
+ }
+ }
+ }
+ leading_blanks = 1;
+ break;
+ }
+ }
+ else goto _LAND_20;
+ }
+ else goto _LAND_20;
+ }
+ else goto _LAND_20;
+ }
+ }
+ }
+ else goto _LAND_20;
+ }
+ else
+ _LAND_20:
+ if (! single) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\\')) {
+ int tmp_37;
+ int tmp_64;
+ int tmp_68;
+ size_t code_length = (unsigned long)0;
+ if (string.pointer + 5 < string.end) tmp_37 = 1;
+ else {
+ int tmp_36_1;
+ tmp_36_1 = yaml_string_extend(& string.start,
+ & string.pointer,
+ & string.end);
+ if (tmp_36_1) tmp_37 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_37 = 0;
+ }
+ }
+ if (! tmp_37) goto error;
+ switch ((int)*(parser->buffer.pointer + 1)) {
+ yaml_char_t *tmp_38_1;
+ yaml_char_t *tmp_39;
+ yaml_char_t *tmp_40;
+ yaml_char_t *tmp_41;
+ yaml_char_t *tmp_42;
+ yaml_char_t *tmp_43;
+ yaml_char_t *tmp_44;
+ yaml_char_t *tmp_45;
+ yaml_char_t *tmp_46;
+ yaml_char_t *tmp_47;
+ yaml_char_t *tmp_48;
+ yaml_char_t *tmp_49;
+ yaml_char_t *tmp_50;
+ yaml_char_t *tmp_51;
+ yaml_char_t *tmp_52;
+ yaml_char_t *tmp_53;
+ yaml_char_t *tmp_54;
+ yaml_char_t *tmp_55;
+ yaml_char_t *tmp_56;
+ yaml_char_t *tmp_57;
+ yaml_char_t *tmp_58;
+ yaml_char_t *tmp_59;
+ yaml_char_t *tmp_60;
+ case '0':
+ { /* sequence */
+ tmp_38_1 = string.pointer;
+ (string.pointer) ++;
+ *tmp_38_1 = (unsigned char)'\000';
+ }
+ break;
+ case 'a':
+ { /* sequence */
+ tmp_39 = string.pointer;
+ (string.pointer) ++;
+ *tmp_39 = (unsigned char)'\a';
+ }
+ break;
+ case 'b':
+ { /* sequence */
+ tmp_40 = string.pointer;
+ (string.pointer) ++;
+ *tmp_40 = (unsigned char)'\b';
+ }
+ break;
+ case 't': case '\t':
+ { /* sequence */
+ tmp_41 = string.pointer;
+ (string.pointer) ++;
+ *tmp_41 = (unsigned char)'\t';
+ }
+ break;
+ case 'n':
+ { /* sequence */
+ tmp_42 = string.pointer;
+ (string.pointer) ++;
+ *tmp_42 = (unsigned char)'\n';
+ }
+ break;
+ case 'v':
+ { /* sequence */
+ tmp_43 = string.pointer;
+ (string.pointer) ++;
+ *tmp_43 = (unsigned char)'\v';
+ }
+ break;
+ case 'f':
+ { /* sequence */
+ tmp_44 = string.pointer;
+ (string.pointer) ++;
+ *tmp_44 = (unsigned char)'\f';
+ }
+ break;
+ case 'r':
+ { /* sequence */
+ tmp_45 = string.pointer;
+ (string.pointer) ++;
+ *tmp_45 = (unsigned char)'\r';
+ }
+ break;
+ case 'e':
+ { /* sequence */
+ tmp_46 = string.pointer;
+ (string.pointer) ++;
+ *tmp_46 = (unsigned char)'\033';
+ }
+ break;
+ case ' ':
+ { /* sequence */
+ tmp_47 = string.pointer;
+ (string.pointer) ++;
+ *tmp_47 = (unsigned char)' ';
+ }
+ break;
+ case '\"':
+ { /* sequence */
+ tmp_48 = string.pointer;
+ (string.pointer) ++;
+ *tmp_48 = (unsigned char)'\"';
+ }
+ break;
+ case '/':
+ { /* sequence */
+ tmp_49 = string.pointer;
+ (string.pointer) ++;
+ *tmp_49 = (unsigned char)'/';
+ }
+ break;
+ case '\\':
+ { /* sequence */
+ tmp_50 = string.pointer;
+ (string.pointer) ++;
+ *tmp_50 = (unsigned char)'\\';
+ }
+ break;
+ case 'N':
+ { /* sequence */
+ tmp_51 = string.pointer;
+ (string.pointer) ++;
+ *tmp_51 = (unsigned char)'\302';
+ }
+ tmp_52 = string.pointer;
+ (string.pointer) ++;
+ *tmp_52 = (unsigned char)'\205';
+ break;
+ case '_':
+ { /* sequence */
+ tmp_53 = string.pointer;
+ (string.pointer) ++;
+ *tmp_53 = (unsigned char)'\302';
+ }
+ tmp_54 = string.pointer;
+ (string.pointer) ++;
+ *tmp_54 = (unsigned char)'\240';
+ break;
+ case 'L':
+ { /* sequence */
+ tmp_55 = string.pointer;
+ (string.pointer) ++;
+ *tmp_55 = (unsigned char)'\342';
+ }
+ tmp_56 = string.pointer;
+ (string.pointer) ++;
+ *tmp_56 = (unsigned char)'\200';
+ tmp_57 = string.pointer;
+ (string.pointer) ++;
+ *tmp_57 = (unsigned char)'\250';
+ break;
+ case 'P':
+ { /* sequence */
+ tmp_58 = string.pointer;
+ (string.pointer) ++;
+ *tmp_58 = (unsigned char)'\342';
+ }
+ tmp_59 = string.pointer;
+ (string.pointer) ++;
+ *tmp_59 = (unsigned char)'\200';
+ tmp_60 = string.pointer;
+ (string.pointer) ++;
+ *tmp_60 = (unsigned char)'\251';
+ break;
+ case 'x': code_length = (unsigned long)2;
+ break;
+ case 'u': code_length = (unsigned long)4;
+ break;
+ case 'U': code_length = (unsigned long)8;
+ break;
+ default:
+ yaml_parser_set_scanner_error(parser,
+ "while parsing a quoted scalar",
+ start_mark,
+ "found unknown escape character");
+ goto error;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_64 = 1;
+ else {
+ int tmp_63;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_63 = 2;
+ else {
+ int tmp_62;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_62 = 3;
+ else {
+ int tmp_61;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_61 = 4;
+ else tmp_61 = 0;
+ tmp_62 = tmp_61;
+ }
+ tmp_63 = tmp_62;
+ }
+ tmp_64 = tmp_63;
+ }
+ parser->buffer.pointer += tmp_64;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_68 = 1;
+ else {
+ int tmp_67;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_67 = 2;
+ else {
+ int tmp_66;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_66 = 3;
+ else {
+ int tmp_65;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_65 = 4;
+ else tmp_65 = 0;
+ tmp_66 = tmp_65;
+ }
+ tmp_67 = tmp_66;
+ }
+ tmp_68 = tmp_67;
+ }
+ parser->buffer.pointer += tmp_68;
+ if (code_length) {
+ size_t k;
+ int tmp_70;
+ unsigned int value = (unsigned int)0;
+ if (parser->unread >= code_length) tmp_70 = 1;
+ else tmp_70 = yaml_parser_update_buffer(parser,
+ code_length);
+ if (! tmp_70) goto error;
+ k = (unsigned long)0;
+ while (k < code_length) {
+ {
+ int tmp_72;
+ if ((int)*(parser->buffer.pointer + k) >= (int)((unsigned char)'0')) {
+ if (! ((int)*(parser->buffer.pointer + k) <= (int)((unsigned char)'9')))
+ goto _LAND_12;
+ }
+ else {
+ _LAND_12: ;
+ if ((int)*(parser->buffer.pointer + k) >= (int)((unsigned char)'A')) {
+ if (! ((int)*(parser->buffer.pointer + k) <= (int)((unsigned char)'F')))
+ goto _LAND_11;
+ }
+ else {
+ _LAND_11: ;
+ if ((int)*(parser->buffer.pointer + k) >= (int)((unsigned char)'a')) {
+ if (! ((int)*(parser->buffer.pointer + k) <= (int)((unsigned char)'f')))
+ goto _LAND_10;
+ }
+ else {
+ _LAND_10:
+ {
+ yaml_parser_set_scanner_error(parser,
+ "while parsing a quoted scalar",
+ start_mark,
+ "did not find expected hexdecimal number");
+ goto error;
+ }
+ }
+ }
+ }
+ if ((int)*(parser->buffer.pointer + k) >= (int)((unsigned char)'A')) {
+ if ((int)*(parser->buffer.pointer + k) <= (int)((unsigned char)'F'))
+ tmp_72 = ((int)*(parser->buffer.pointer + k) - (int)((unsigned char)'A')) + 10;
+ else goto _LAND_13;
+ }
+ else {
+ int tmp_71;
+ _LAND_13:
+ if ((int)*(parser->buffer.pointer + k) >= (int)((unsigned char)'a'))
+ if ((int)*(parser->buffer.pointer + k) <= (int)((unsigned char)'f'))
+ tmp_71 = ((int)*(parser->buffer.pointer + k) - (int)((unsigned char)'a')) + 10;
+ else tmp_71 = (int)*(parser->buffer.pointer + k) - (int)((unsigned char)'0');
+ else tmp_71 = (int)*(parser->buffer.pointer + k) - (int)((unsigned char)'0');
+ tmp_72 = tmp_71;
+ }
+ value = (value << 4) + (unsigned int)tmp_72;
+ }
+ k += (size_t)1;
+ }
+ if (value >= (unsigned int)0xD800) {
+ if (value <= (unsigned int)0xDFFF) goto _LOR_3;
+ else goto _LAND_14;
+ }
+ else {
+ _LAND_14: ;
+ if (value > (unsigned int)0x10FFFF) {
+ _LOR_3:
+ {
+ yaml_parser_set_scanner_error(parser,
+ "while parsing a quoted scalar",
+ start_mark,
+ "found invalid Unicode character escape code");
+ goto error;
+ }
+ }
+ }
+ if (value <= (unsigned int)0x7F) {
+ yaml_char_t *tmp_73;
+ tmp_73 = string.pointer;
+ (string.pointer) ++;
+ *tmp_73 = (unsigned char)value;
+ }
+ else
+ if (value <= (unsigned int)0x7FF) {
+ yaml_char_t *tmp_74;
+ yaml_char_t *tmp_75;
+ tmp_74 = string.pointer;
+ (string.pointer) ++;
+ *tmp_74 = (unsigned char)((unsigned int)0xC0 + (
+ value >> 6));
+ tmp_75 = string.pointer;
+ (string.pointer) ++;
+ *tmp_75 = (unsigned char)((unsigned int)0x80 + (
+ value & (unsigned int)0x3F));
+ }
+ else
+ if (value <= (unsigned int)0xFFFF) {
+ yaml_char_t *tmp_76;
+ yaml_char_t *tmp_77;
+ yaml_char_t *tmp_78;
+ tmp_76 = string.pointer;
+ (string.pointer) ++;
+ *tmp_76 = (unsigned char)((unsigned int)0xE0 + (
+ value >> 12));
+ tmp_77 = string.pointer;
+ (string.pointer) ++;
+ *tmp_77 = (unsigned char)((unsigned int)0x80 + (
+ (value >> 6) & (unsigned int)0x3F));
+ tmp_78 = string.pointer;
+ (string.pointer) ++;
+ *tmp_78 = (unsigned char)((unsigned int)0x80 + (
+ value & (unsigned int)0x3F));
+ }
+ else {
+ yaml_char_t *tmp_79;
+ yaml_char_t *tmp_80;
+ yaml_char_t *tmp_81;
+ yaml_char_t *tmp_82;
+ tmp_79 = string.pointer;
+ (string.pointer) ++;
+ *tmp_79 = (unsigned char)((unsigned int)0xF0 + (
+ value >> 18));
+ tmp_80 = string.pointer;
+ (string.pointer) ++;
+ *tmp_80 = (unsigned char)((unsigned int)0x80 + (
+ (value >> 12) & (unsigned int)0x3F));
+ tmp_81 = string.pointer;
+ (string.pointer) ++;
+ *tmp_81 = (unsigned char)((unsigned int)0x80 + (
+ (value >> 6) & (unsigned int)0x3F));
+ tmp_82 = string.pointer;
+ (string.pointer) ++;
+ *tmp_82 = (unsigned char)((unsigned int)0x80 + (
+ value & (unsigned int)0x3F));
+ }
+ k = (unsigned long)0;
+ while (k < code_length) {
+ {
+ int tmp_86;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_86 = 1;
+ else {
+ int tmp_85;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_85 = 2;
+ else {
+ int tmp_84;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_84 = 3;
+ else {
+ int tmp_83;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_83 = 4;
+ else tmp_83 = 0;
+ tmp_84 = tmp_83;
+ }
+ tmp_85 = tmp_84;
+ }
+ tmp_86 = tmp_85;
+ }
+ parser->buffer.pointer += tmp_86;
+ }
+ k += (size_t)1;
+ }
+ }
+ }
+ else goto _LAND_15;
+ }
+ else {
+ _LAND_15:
+ {
+ int tmp_109_0;
+ int tmp_88;
+ if (string.pointer + 5 < string.end) tmp_88 = 1;
+ else {
+ int tmp_87;
+ tmp_87 = yaml_string_extend(& string.start,
+ & string.pointer,
+ & string.end);
+ if (tmp_87) tmp_88 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_88 = 0;
+ }
+ }
+ if (tmp_88) {
+ if (((int)*(parser->buffer.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_89;
+ yaml_char_t *tmp_90;
+ tmp_89 = string.pointer;
+ (string.pointer) ++;
+ tmp_90 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_89 = *tmp_90;
+ yaml_char_t tmp_115 = *tmp_89;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_91;
+ yaml_char_t *tmp_92;
+ yaml_char_t *tmp_93;
+ yaml_char_t *tmp_94;
+ tmp_91 = string.pointer;
+ (string.pointer) ++;
+ tmp_92 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_91 = *tmp_92;
+ tmp_93 = string.pointer;
+ (string.pointer) ++;
+ tmp_94 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_93 = *tmp_94;
+ yaml_char_t tmp_113 = *tmp_93;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_95;
+ yaml_char_t *tmp_96;
+ yaml_char_t *tmp_97;
+ yaml_char_t *tmp_98;
+ yaml_char_t *tmp_99;
+ yaml_char_t *tmp_100;
+ tmp_95 = string.pointer;
+ (string.pointer) ++;
+ tmp_96 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_95 = *tmp_96;
+ tmp_97 = string.pointer;
+ (string.pointer) ++;
+ tmp_98 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_97 = *tmp_98;
+ tmp_99 = string.pointer;
+ (string.pointer) ++;
+ tmp_100 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_99 = *tmp_100;
+ yaml_char_t tmp_111 = *tmp_99;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_101;
+ yaml_char_t *tmp_102;
+ yaml_char_t *tmp_103;
+ yaml_char_t *tmp_104;
+ yaml_char_t *tmp_105;
+ yaml_char_t *tmp_106;
+ yaml_char_t *tmp_107;
+ yaml_char_t *tmp_108;
+ tmp_101 = string.pointer;
+ (string.pointer) ++;
+ tmp_102 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_101 = *tmp_102;
+ tmp_103 = string.pointer;
+ (string.pointer) ++;
+ tmp_104 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_103 = *tmp_104;
+ tmp_105 = string.pointer;
+ (string.pointer) ++;
+ tmp_106 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_105 = *tmp_106;
+ tmp_107 = string.pointer;
+ (string.pointer) ++;
+ tmp_108 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_107 = *tmp_108;
+ yaml_char_t tmp_109 = *tmp_107;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ tmp_109_0 = 1;
+ }
+ else tmp_109_0 = 0;
+ if (! tmp_109_0) goto error;
+ }
+ }
+ }
+ if (parser->unread >= (size_t)2) tmp_112 = 1;
+ else tmp_112 = yaml_parser_update_buffer(parser,(unsigned long)2);
+ if (! tmp_112) goto error;
+ }
+ }
+ if (parser->unread >= (size_t)1) tmp_114 = 1;
+ else tmp_114 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_114) goto error;
+ if (single) tmp_115_0 = '\''; else tmp_115_0 = '\"';
+ ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)tmp_115_0))
+ break;
+ if (parser->unread >= (size_t)1) tmp_117 = 1;
+ else tmp_117 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_117) goto error;
+ while (1) {
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')))
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205')))
+ goto _LAND_34;
+ }
+ else {
+ _LAND_34: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250')))
+ goto _LAND_33;
+ }
+ else goto _LAND_33;
+ }
+ else {
+ _LAND_33: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')))
+ break;
+ }
+ else break;
+ else break;
+ }
+ }
+ {
+ int tmp_172_0;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' '))
+ goto _LOR_9;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t'))
+ _LOR_9:
+ if (! leading_blanks) {
+ int tmp_140_0;
+ int tmp_119;
+ if (whitespaces.pointer + 5 < whitespaces.end) tmp_119 = 1;
+ else {
+ int tmp_118;
+ tmp_118 = yaml_string_extend(& whitespaces.start,
+ & whitespaces.pointer,
+ & whitespaces.end);
+ if (tmp_118) tmp_119 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_119 = 0;
+ }
+ }
+ if (tmp_119) {
+ if (((int)*(parser->buffer.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_120;
+ yaml_char_t *tmp_121;
+ tmp_120 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_121 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_120 = *tmp_121;
+ yaml_char_t tmp_146 = *tmp_120;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_122;
+ yaml_char_t *tmp_123;
+ yaml_char_t *tmp_124;
+ yaml_char_t *tmp_125;
+ tmp_122 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_123 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_122 = *tmp_123;
+ tmp_124 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_125 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_124 = *tmp_125;
+ yaml_char_t tmp_144 = *tmp_124;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_126;
+ yaml_char_t *tmp_127;
+ yaml_char_t *tmp_128;
+ yaml_char_t *tmp_129;
+ yaml_char_t *tmp_130;
+ yaml_char_t *tmp_131;
+ tmp_126 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_127 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_126 = *tmp_127;
+ tmp_128 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_129 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_128 = *tmp_129;
+ tmp_130 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_131 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_130 = *tmp_131;
+ yaml_char_t tmp_142 = *tmp_130;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_132;
+ yaml_char_t *tmp_133;
+ yaml_char_t *tmp_134;
+ yaml_char_t *tmp_135;
+ yaml_char_t *tmp_136;
+ yaml_char_t *tmp_137;
+ yaml_char_t *tmp_138;
+ yaml_char_t *tmp_139;
+ tmp_132 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_133 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_132 = *tmp_133;
+ tmp_134 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_135 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_134 = *tmp_135;
+ tmp_136 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_137 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_136 = *tmp_137;
+ tmp_138 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_139 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_138 = *tmp_139;
+ yaml_char_t tmp_140 = *tmp_138;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ tmp_140_0 = 1;
+ }
+ else tmp_140_0 = 0;
+ if (! tmp_140_0) goto error;
+ }
+ else {
+ int tmp_144_0;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_144_0 = 1;
+ else {
+ int tmp_143;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_143 = 2;
+ else {
+ int tmp_142_0;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_142_0 = 3;
+ else {
+ int tmp_141;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_141 = 4;
+ else tmp_141 = 0;
+ tmp_142_0 = tmp_141;
+ }
+ tmp_143 = tmp_142_0;
+ }
+ tmp_144_0 = tmp_143;
+ }
+ parser->buffer.pointer += tmp_144_0;
+ }
+ else {
+ int tmp_146_0;
+ if (parser->unread >= (size_t)2) tmp_146_0 = 1;
+ else tmp_146_0 = yaml_parser_update_buffer(parser,
+ (unsigned long)2);
+ if (! tmp_146_0) goto error;
+ if (! leading_blanks) {
+ int tmp_158_0;
+ int tmp_148;
+ whitespaces.pointer = whitespaces.start;
+ memset((void *)whitespaces.start,0,
+ (unsigned long)(whitespaces.end - whitespaces.start));
+ if (leading_break.pointer + 5 < leading_break.end) tmp_148 = 1;
+ else {
+ int tmp_147;
+ tmp_147 = yaml_string_extend(& leading_break.start,
+ & leading_break.pointer,
+ & leading_break.end);
+ if (tmp_147) tmp_148 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_148 = 0;
+ }
+ }
+ if (tmp_148) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\n')) {
+ yaml_char_t *tmp_149;
+ tmp_149 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ *tmp_149 = (unsigned char)'\n';
+ parser->buffer.pointer += 2;
+ parser->mark.index += (size_t)2;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)2;
+ size_t tmp_164 = parser->unread;
+ }
+ else goto _LAND_29;
+ }
+ else {
+ _LAND_29: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_6;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')) {
+ yaml_char_t *tmp_150;
+ _LOR_6:
+ { /* sequence */
+ tmp_150 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ *tmp_150 = (unsigned char)'\n';
+ }
+ (parser->buffer.pointer) ++;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_162 = parser->unread;
+ }
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\205')) {
+ yaml_char_t *tmp_151;
+ tmp_151 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ *tmp_151 = (unsigned char)'\n';
+ parser->buffer.pointer += 2;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_160 = parser->unread;
+ }
+ else goto _LAND_28;
+ }
+ else {
+ _LAND_28: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\200'))
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'\250'))
+ goto _LOR_5;
+ else
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'\251')) {
+ yaml_char_t *tmp_152;
+ yaml_char_t *tmp_153;
+ yaml_char_t *tmp_154;
+ yaml_char_t *tmp_155;
+ yaml_char_t *tmp_156;
+ yaml_char_t *tmp_157;
+ _LOR_5:
+ { /* sequence */
+ tmp_152 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ tmp_153 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_152 = *tmp_153;
+ }
+ tmp_154 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ tmp_155 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_154 = *tmp_155;
+ tmp_156 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ tmp_157 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_156 = *tmp_157;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_158 = parser->unread;
+ }
+ }
+ }
+ tmp_158_0 = 1;
+ }
+ else tmp_158_0 = 0;
+ if (! tmp_158_0) goto error;
+ leading_blanks = 1;
+ }
+ else {
+ int tmp_170_0;
+ int tmp_160_0;
+ if (trailing_breaks.pointer + 5 < trailing_breaks.end)
+ tmp_160_0 = 1;
+ else {
+ int tmp_159;
+ tmp_159 = yaml_string_extend(& trailing_breaks.start,
+ & trailing_breaks.pointer,
+ & trailing_breaks.end);
+ if (tmp_159) tmp_160_0 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_160_0 = 0;
+ }
+ }
+ if (tmp_160_0) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\n')) {
+ yaml_char_t *tmp_161;
+ tmp_161 = trailing_breaks.pointer;
+ (trailing_breaks.pointer) ++;
+ *tmp_161 = (unsigned char)'\n';
+ parser->buffer.pointer += 2;
+ parser->mark.index += (size_t)2;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)2;
+ size_t tmp_176 = parser->unread;
+ }
+ else goto _LAND_31;
+ }
+ else {
+ _LAND_31: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_8;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')) {
+ yaml_char_t *tmp_162_0;
+ _LOR_8:
+ { /* sequence */
+ tmp_162_0 = trailing_breaks.pointer;
+ (trailing_breaks.pointer) ++;
+ *tmp_162_0 = (unsigned char)'\n';
+ }
+ (parser->buffer.pointer) ++;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_174 = parser->unread;
+ }
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\205')) {
+ yaml_char_t *tmp_163;
+ tmp_163 = trailing_breaks.pointer;
+ (trailing_breaks.pointer) ++;
+ *tmp_163 = (unsigned char)'\n';
+ parser->buffer.pointer += 2;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_172 = parser->unread;
+ }
+ else goto _LAND_30;
+ }
+ else {
+ _LAND_30: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\200'))
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'\250'))
+ goto _LOR_7;
+ else
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'\251')) {
+ yaml_char_t *tmp_164_0;
+ yaml_char_t *tmp_165;
+ yaml_char_t *tmp_166;
+ yaml_char_t *tmp_167;
+ yaml_char_t *tmp_168;
+ yaml_char_t *tmp_169;
+ _LOR_7:
+ { /* sequence */
+ tmp_164_0 = trailing_breaks.pointer;
+ (trailing_breaks.pointer) ++;
+ tmp_165 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_164_0 = *tmp_165;
+ }
+ tmp_166 = trailing_breaks.pointer;
+ (trailing_breaks.pointer) ++;
+ tmp_167 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_166 = *tmp_167;
+ tmp_168 = trailing_breaks.pointer;
+ (trailing_breaks.pointer) ++;
+ tmp_169 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_168 = *tmp_169;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_170 = parser->unread;
+ }
+ }
+ }
+ tmp_170_0 = 1;
+ }
+ else tmp_170_0 = 0;
+ if (! tmp_170_0) goto error;
+ }
+ }
+ if (parser->unread >= (size_t)1) tmp_172_0 = 1;
+ else tmp_172_0 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_172_0) goto error;
+ }
+ }
+ if (leading_blanks)
+ if ((int)*(leading_break.start + 0) == '\n') {
+ if ((int)*(trailing_breaks.start + 0) == '\000') {
+ int tmp_174_0;
+ yaml_char_t *tmp_175;
+ if (string.pointer + 5 < string.end) tmp_174_0 = 1;
+ else {
+ int tmp_173;
+ tmp_173 = yaml_string_extend(& string.start,& string.pointer,
+ & string.end);
+ if (tmp_173) tmp_174_0 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_174_0 = 0;
+ }
+ }
+ if (! tmp_174_0) goto error;
+ tmp_175 = string.pointer;
+ (string.pointer) ++;
+ *tmp_175 = (unsigned char)' ';
+ }
+ else {
+ int tmp_177;
+ int tmp_176_0;
+ tmp_176_0 = yaml_string_join(& string.start,& string.pointer,
+ & string.end,
+ & trailing_breaks.start,
+ & trailing_breaks.pointer,
+ & trailing_breaks.end);
+ if (tmp_176_0) {
+ trailing_breaks.pointer = trailing_breaks.start;
+ tmp_177 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_177 = 0;
+ }
+ if (! tmp_177) goto error;
+ trailing_breaks.pointer = trailing_breaks.start;
+ memset((void *)trailing_breaks.start,0,
+ (unsigned long)(trailing_breaks.end - trailing_breaks.start));
+ }
+ leading_break.pointer = leading_break.start;
+ memset((void *)leading_break.start,0,
+ (unsigned long)(leading_break.end - leading_break.start));
+ }
+ else {
+ int tmp_179;
+ int tmp_178;
+ int tmp_181;
+ int tmp_180;
+ tmp_178 = yaml_string_join(& string.start,& string.pointer,
+ & string.end,& leading_break.start,
+ & leading_break.pointer,
+ & leading_break.end);
+ if (tmp_178) {
+ leading_break.pointer = leading_break.start;
+ tmp_179 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_179 = 0;
+ }
+ if (! tmp_179) goto error;
+ tmp_180 = yaml_string_join(& string.start,& string.pointer,
+ & string.end,& trailing_breaks.start,
+ & trailing_breaks.pointer,
+ & trailing_breaks.end);
+ if (tmp_180) {
+ trailing_breaks.pointer = trailing_breaks.start;
+ tmp_181 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_181 = 0;
+ }
+ if (! tmp_181) goto error;
+ leading_break.pointer = leading_break.start;
+ memset((void *)leading_break.start,0,
+ (unsigned long)(leading_break.end - leading_break.start));
+ trailing_breaks.pointer = trailing_breaks.start;
+ memset((void *)trailing_breaks.start,0,
+ (unsigned long)(trailing_breaks.end - trailing_breaks.start));
+ }
+ else {
+ int tmp_183;
+ int tmp_182;
+ tmp_182 = yaml_string_join(& string.start,& string.pointer,
+ & string.end,& whitespaces.start,
+ & whitespaces.pointer,& whitespaces.end);
+ if (tmp_182) {
+ whitespaces.pointer = whitespaces.start;
+ tmp_183 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_183 = 0;
+ }
+ if (! tmp_183) goto error;
+ whitespaces.pointer = whitespaces.start;
+ memset((void *)whitespaces.start,0,
+ (unsigned long)(whitespaces.end - whitespaces.start));
+ }
+ }
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00) tmp_187 = 1;
+ else {
+ int tmp_186;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0) tmp_186 = 2;
+ else {
+ int tmp_185;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0) tmp_185 = 3;
+ else {
+ int tmp_184;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0) tmp_184 = 4;
+ else tmp_184 = 0;
+ tmp_185 = tmp_184;
+ }
+ tmp_186 = tmp_185;
+ }
+ tmp_187 = tmp_186;
+ }
+ parser->buffer.pointer += tmp_187;
+ end_mark = parser->mark;
+ memset((void *)token,0,sizeof(yaml_token_t));
+ token->type = YAML_SCALAR_TOKEN;
+ token->start_mark = start_mark;
+ token->end_mark = end_mark;
+ token->data.scalar.value = string.start;
+ token->data.scalar.length = (unsigned long)(string.pointer - string.start);
+ if (single) token->data.scalar.style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
+ else token->data.scalar.style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
+ yaml_free((void *)leading_break.start);
+ leading_break.end = (yaml_char_t *)0;
+ leading_break.pointer = leading_break.end;
+ leading_break.start = leading_break.pointer;
+ yaml_free((void *)trailing_breaks.start);
+ trailing_breaks.end = (yaml_char_t *)0;
+ trailing_breaks.pointer = trailing_breaks.end;
+ trailing_breaks.start = trailing_breaks.pointer;
+ yaml_free((void *)whitespaces.start);
+ whitespaces.end = (yaml_char_t *)0;
+ whitespaces.pointer = whitespaces.end;
+ whitespaces.start = whitespaces.pointer;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)string.start);
+ string.end = (yaml_char_t *)0;
+ string.pointer = string.end;
+ string.start = string.pointer;
+ yaml_free((void *)leading_break.start);
+ leading_break.end = (yaml_char_t *)0;
+ leading_break.pointer = leading_break.end;
+ leading_break.start = leading_break.pointer;
+ yaml_free((void *)trailing_breaks.start);
+ trailing_breaks.end = (yaml_char_t *)0;
+ trailing_breaks.pointer = trailing_breaks.end;
+ trailing_breaks.start = trailing_breaks.pointer;
+ yaml_free((void *)whitespaces.start);
+ whitespaces.end = (yaml_char_t *)0;
+ whitespaces.pointer = whitespaces.end;
+ whitespaces.start = whitespaces.pointer;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_parser_scan_plain_scalar(yaml_parser_t *parser,
+ yaml_token_t *token)
+{
+ int __retres;
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ int tmp_0;
+ int tmp_2;
+ int tmp_4;
+ int tmp_6;
+ yaml_string_t string =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ yaml_string_t leading_break =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ yaml_string_t trailing_breaks =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ yaml_string_t whitespaces =
+ {.start = (yaml_char_t *)0,
+ .end = (yaml_char_t *)0,
+ .pointer = (yaml_char_t *)0};
+ int leading_blanks = 0;
+ int indent = parser->indent + 1;
+ string.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (string.start) {
+ string.pointer = string.start;
+ string.end = string.start + 16;
+ memset((void *)string.start,0,(unsigned long)16);
+ tmp_0 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_0 = 0;
+ }
+ if (! tmp_0) goto error;
+ leading_break.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (leading_break.start) {
+ leading_break.pointer = leading_break.start;
+ leading_break.end = leading_break.start + 16;
+ memset((void *)leading_break.start,0,(unsigned long)16);
+ tmp_2 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_2 = 0;
+ }
+ if (! tmp_2) goto error;
+ trailing_breaks.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (trailing_breaks.start) {
+ trailing_breaks.pointer = trailing_breaks.start;
+ trailing_breaks.end = trailing_breaks.start + 16;
+ memset((void *)trailing_breaks.start,0,(unsigned long)16);
+ tmp_4 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_4 = 0;
+ }
+ if (! tmp_4) goto error;
+ whitespaces.start = (yaml_char_t *)yaml_malloc((unsigned long)16);
+ if (whitespaces.start) {
+ whitespaces.pointer = whitespaces.start;
+ whitespaces.end = whitespaces.start + 16;
+ memset((void *)whitespaces.start,0,(unsigned long)16);
+ tmp_6 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_6 = 0;
+ }
+ if (! tmp_6) goto error;
+ end_mark = parser->mark;
+ start_mark = end_mark;
+ while (1) {
+ {
+ int tmp_8;
+ int tmp_46_1;
+ if (parser->unread >= (size_t)4) tmp_8 = 1;
+ else tmp_8 = yaml_parser_update_buffer(parser,(unsigned long)4);
+ if (! tmp_8) goto error;
+ if (parser->mark.column == (size_t)0)
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'-')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'-')) {
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'-'))
+ goto _LOR;
+ else goto _LAND_5;
+ }
+ else goto _LAND_5;
+ }
+ else {
+ _LAND_5: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'.'))
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'.'))
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'.')) {
+ _LOR: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)' '))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\t'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\r'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\n'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (3 + 1)) == (int)((unsigned char)'\205'))
+ break;
+ else goto _LAND_3;
+ }
+ else {
+ _LAND_3: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (3 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (3 + 2)) == (int)((unsigned char)'\250'))
+ break;
+ else goto _LAND_2;
+ }
+ else goto _LAND_2;
+ }
+ else {
+ _LAND_2: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (3 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (3 + 2)) == (int)((unsigned char)'\251'))
+ break;
+ else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if ((int)*(parser->buffer.pointer + 3) == (int)((unsigned char)'\000'))
+ break;
+ }
+ }
+ }
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'#'))
+ break;
+ while (1) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' '))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205'))
+ break;
+ else goto _LAND_16;
+ }
+ else {
+ _LAND_16: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250'))
+ break;
+ else goto _LAND_15;
+ }
+ else goto _LAND_15;
+ }
+ else {
+ _LAND_15: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251'))
+ break;
+ else goto _LAND_13;
+ }
+ else goto _LAND_13;
+ }
+ else {
+ _LAND_13: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\000'))
+ break;
+ }
+ }
+ }
+ {
+ int tmp_42_2;
+ int tmp_21;
+ int tmp_44_2;
+ if (parser->flow_level)
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)':'))
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)','))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'?'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'['))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)']'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'{'))
+ goto _LOR_0;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'}')) {
+ _LOR_0:
+ {
+ yaml_parser_set_scanner_error(parser,
+ "while scanning a plain scalar",
+ start_mark,
+ "found unexpected \':\'");
+ goto error;
+ }
+ }
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)':'))
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)' '))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\t'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\r'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\n'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\205'))
+ break;
+ else goto _LAND_11;
+ }
+ else {
+ _LAND_11: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (1 + 2)) == (int)((unsigned char)'\250'))
+ break;
+ else goto _LAND_10;
+ }
+ else goto _LAND_10;
+ }
+ else {
+ _LAND_10: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (1 + 1)) == (int)((unsigned char)'\200')) {
+ if ((int)*(parser->buffer.pointer + (1 + 2)) == (int)((unsigned char)'\251'))
+ break;
+ else goto _LAND_8;
+ }
+ else goto _LAND_8;
+ }
+ else {
+ _LAND_8: ;
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\000'))
+ break;
+ else goto _LAND_6;
+ }
+ }
+ }
+ else {
+ _LAND_6: ;
+ if (parser->flow_level)
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)','))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'['))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)']'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'{'))
+ break;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'}'))
+ break;
+ }
+ if (leading_blanks) goto _LOR_1;
+ else
+ if (whitespaces.start != whitespaces.pointer)
+ _LOR_1:
+ if (leading_blanks) {
+ if ((int)*(leading_break.start + 0) == '\n') {
+ if ((int)*(trailing_breaks.start + 0) == '\000') {
+ int tmp_10;
+ yaml_char_t *tmp_11;
+ if (string.pointer + 5 < string.end) tmp_10 = 1;
+ else {
+ int tmp_9;
+ tmp_9 = yaml_string_extend(& string.start,
+ & string.pointer,
+ & string.end);
+ if (tmp_9) tmp_10 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_10 = 0;
+ }
+ }
+ if (! tmp_10) goto error;
+ tmp_11 = string.pointer;
+ (string.pointer) ++;
+ *tmp_11 = (unsigned char)' ';
+ }
+ else {
+ int tmp_13;
+ int tmp_12;
+ tmp_12 = yaml_string_join(& string.start,
+ & string.pointer,& string.end,
+ & trailing_breaks.start,
+ & trailing_breaks.pointer,
+ & trailing_breaks.end);
+ if (tmp_12) {
+ trailing_breaks.pointer = trailing_breaks.start;
+ tmp_13 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_13 = 0;
+ }
+ if (! tmp_13) goto error;
+ trailing_breaks.pointer = trailing_breaks.start;
+ memset((void *)trailing_breaks.start,0,
+ (unsigned long)(trailing_breaks.end - trailing_breaks.start));
+ }
+ leading_break.pointer = leading_break.start;
+ memset((void *)leading_break.start,0,
+ (unsigned long)(leading_break.end - leading_break.start));
+ }
+ else {
+ int tmp_15;
+ int tmp_14;
+ int tmp_17;
+ int tmp_16;
+ tmp_14 = yaml_string_join(& string.start,& string.pointer,
+ & string.end,
+ & leading_break.start,
+ & leading_break.pointer,
+ & leading_break.end);
+ if (tmp_14) {
+ leading_break.pointer = leading_break.start;
+ tmp_15 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_15 = 0;
+ }
+ if (! tmp_15) goto error;
+ tmp_16 = yaml_string_join(& string.start,& string.pointer,
+ & string.end,
+ & trailing_breaks.start,
+ & trailing_breaks.pointer,
+ & trailing_breaks.end);
+ if (tmp_16) {
+ trailing_breaks.pointer = trailing_breaks.start;
+ tmp_17 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_17 = 0;
+ }
+ if (! tmp_17) goto error;
+ leading_break.pointer = leading_break.start;
+ memset((void *)leading_break.start,0,
+ (unsigned long)(leading_break.end - leading_break.start));
+ trailing_breaks.pointer = trailing_breaks.start;
+ memset((void *)trailing_breaks.start,0,
+ (unsigned long)(trailing_breaks.end - trailing_breaks.start));
+ }
+ leading_blanks = 0;
+ }
+ else {
+ int tmp_19;
+ int tmp_18;
+ tmp_18 = yaml_string_join(& string.start,& string.pointer,
+ & string.end,& whitespaces.start,
+ & whitespaces.pointer,
+ & whitespaces.end);
+ if (tmp_18) {
+ whitespaces.pointer = whitespaces.start;
+ tmp_19 = 1;
+ }
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_19 = 0;
+ }
+ if (! tmp_19) goto error;
+ whitespaces.pointer = whitespaces.start;
+ memset((void *)whitespaces.start,0,
+ (unsigned long)(whitespaces.end - whitespaces.start));
+ }
+ if (string.pointer + 5 < string.end) tmp_21 = 1;
+ else {
+ int tmp_20;
+ tmp_20 = yaml_string_extend(& string.start,& string.pointer,
+ & string.end);
+ if (tmp_20) tmp_21 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_21 = 0;
+ }
+ }
+ if (tmp_21) {
+ if (((int)*(parser->buffer.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_22;
+ yaml_char_t *tmp_23;
+ tmp_22 = string.pointer;
+ (string.pointer) ++;
+ tmp_23 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_22 = *tmp_23;
+ yaml_char_t tmp_48 = *tmp_22;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_24;
+ yaml_char_t *tmp_25;
+ yaml_char_t *tmp_26;
+ yaml_char_t *tmp_27;
+ tmp_24 = string.pointer;
+ (string.pointer) ++;
+ tmp_25 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_24 = *tmp_25;
+ tmp_26 = string.pointer;
+ (string.pointer) ++;
+ tmp_27 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_26 = *tmp_27;
+ yaml_char_t tmp_46 = *tmp_26;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_28;
+ yaml_char_t *tmp_29;
+ yaml_char_t *tmp_30;
+ yaml_char_t *tmp_31;
+ yaml_char_t *tmp_32;
+ yaml_char_t *tmp_33;
+ tmp_28 = string.pointer;
+ (string.pointer) ++;
+ tmp_29 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_28 = *tmp_29;
+ tmp_30 = string.pointer;
+ (string.pointer) ++;
+ tmp_31 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_30 = *tmp_31;
+ tmp_32 = string.pointer;
+ (string.pointer) ++;
+ tmp_33 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_32 = *tmp_33;
+ yaml_char_t tmp_44 = *tmp_32;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_34;
+ yaml_char_t *tmp_35;
+ yaml_char_t *tmp_36;
+ yaml_char_t *tmp_37;
+ yaml_char_t *tmp_38;
+ yaml_char_t *tmp_39;
+ yaml_char_t *tmp_40;
+ yaml_char_t *tmp_41;
+ tmp_34 = string.pointer;
+ (string.pointer) ++;
+ tmp_35 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_34 = *tmp_35;
+ tmp_36 = string.pointer;
+ (string.pointer) ++;
+ tmp_37 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_36 = *tmp_37;
+ tmp_38 = string.pointer;
+ (string.pointer) ++;
+ tmp_39 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_38 = *tmp_39;
+ tmp_40 = string.pointer;
+ (string.pointer) ++;
+ tmp_41 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_40 = *tmp_41;
+ yaml_char_t tmp_42 = *tmp_40;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ tmp_42_2 = 1;
+ }
+ else tmp_42_2 = 0;
+ if (! tmp_42_2) goto error;
+ end_mark = parser->mark;
+ if (parser->unread >= (size_t)2) tmp_44_2 = 1;
+ else tmp_44_2 = yaml_parser_update_buffer(parser,(unsigned long)2);
+ if (! tmp_44_2) goto error;
+ }
+ }
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')))
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205')))
+ goto _LAND_19;
+ }
+ else {
+ _LAND_19: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250')))
+ goto _LAND_18;
+ }
+ else goto _LAND_18;
+ }
+ else {
+ _LAND_18: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')))
+ break;
+ }
+ else break;
+ else break;
+ }
+ }
+ if (parser->unread >= (size_t)1) tmp_46_1 = 1;
+ else tmp_46_1 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_46_1) goto error;
+ while (1) {
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' ')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')))
+ if (! ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')))
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\205')))
+ goto _LAND_26;
+ }
+ else {
+ _LAND_26: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342')) {
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\250')))
+ goto _LAND_25;
+ }
+ else goto _LAND_25;
+ }
+ else {
+ _LAND_25: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + (0 + 1)) == (int)((unsigned char)'\200')) {
+ if (! ((int)*(parser->buffer.pointer + (0 + 2)) == (int)((unsigned char)'\251')))
+ break;
+ }
+ else break;
+ else break;
+ }
+ }
+ {
+ int tmp_101_1;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)' '))
+ goto _LOR_6;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')) {
+ _LOR_6:
+ {
+ if (leading_blanks)
+ if ((int)parser->mark.column < indent)
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\t')) {
+ yaml_parser_set_scanner_error(parser,
+ "while scanning a plain scalar",
+ start_mark,
+ "found a tab character that violates indentation");
+ goto error;
+ }
+ if (! leading_blanks) {
+ int tmp_69_0;
+ int tmp_48_1;
+ if (whitespaces.pointer + 5 < whitespaces.end) tmp_48_1 = 1;
+ else {
+ int tmp_47;
+ tmp_47 = yaml_string_extend(& whitespaces.start,
+ & whitespaces.pointer,
+ & whitespaces.end);
+ if (tmp_47) tmp_48_1 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_48_1 = 0;
+ }
+ }
+ if (tmp_48_1) {
+ if (((int)*(parser->buffer.pointer) & 0x80) == 0x00) {
+ yaml_char_t *tmp_49;
+ yaml_char_t *tmp_50;
+ tmp_49 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_50 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_49 = *tmp_50;
+ yaml_char_t tmp_75 = *tmp_49;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xE0) == 0xC0) {
+ yaml_char_t *tmp_51;
+ yaml_char_t *tmp_52;
+ yaml_char_t *tmp_53;
+ yaml_char_t *tmp_54;
+ tmp_51 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_52 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_51 = *tmp_52;
+ tmp_53 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_54 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_53 = *tmp_54;
+ yaml_char_t tmp_73 = *tmp_53;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF0) == 0xE0) {
+ yaml_char_t *tmp_55;
+ yaml_char_t *tmp_56;
+ yaml_char_t *tmp_57;
+ yaml_char_t *tmp_58;
+ yaml_char_t *tmp_59;
+ yaml_char_t *tmp_60;
+ tmp_55 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_56 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_55 = *tmp_56;
+ tmp_57 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_58 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_57 = *tmp_58;
+ tmp_59 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_60 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_59 = *tmp_60;
+ yaml_char_t tmp_71 = *tmp_59;
+ }
+ else
+ if (((int)*(parser->buffer.pointer) & 0xF8) == 0xF0) {
+ yaml_char_t *tmp_61;
+ yaml_char_t *tmp_62;
+ yaml_char_t *tmp_63;
+ yaml_char_t *tmp_64;
+ yaml_char_t *tmp_65;
+ yaml_char_t *tmp_66;
+ yaml_char_t *tmp_67;
+ yaml_char_t *tmp_68;
+ tmp_61 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_62 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_61 = *tmp_62;
+ tmp_63 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_64 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_63 = *tmp_64;
+ tmp_65 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_66 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_65 = *tmp_66;
+ tmp_67 = whitespaces.pointer;
+ (whitespaces.pointer) ++;
+ tmp_68 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_67 = *tmp_68;
+ yaml_char_t tmp_69 = *tmp_67;
+ }
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ tmp_69_0 = 1;
+ }
+ else tmp_69_0 = 0;
+ if (! tmp_69_0) goto error;
+ }
+ else {
+ int tmp_73_0;
+ parser->mark.index += (size_t)1;
+ parser->mark.column += (size_t)1;
+ parser->unread -= (size_t)1;
+ if (((int)*(parser->buffer.pointer + 0) & 0x80) == 0x00)
+ tmp_73_0 = 1;
+ else {
+ int tmp_72;
+ if (((int)*(parser->buffer.pointer + 0) & 0xE0) == 0xC0)
+ tmp_72 = 2;
+ else {
+ int tmp_71_0;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF0) == 0xE0)
+ tmp_71_0 = 3;
+ else {
+ int tmp_70;
+ if (((int)*(parser->buffer.pointer + 0) & 0xF8) == 0xF0)
+ tmp_70 = 4;
+ else tmp_70 = 0;
+ tmp_71_0 = tmp_70;
+ }
+ tmp_72 = tmp_71_0;
+ }
+ tmp_73_0 = tmp_72;
+ }
+ parser->buffer.pointer += tmp_73_0;
+ }
+ }
+ }
+ else {
+ int tmp_75_1;
+ if (parser->unread >= (size_t)2) tmp_75_1 = 1;
+ else tmp_75_1 = yaml_parser_update_buffer(parser,
+ (unsigned long)2);
+ if (! tmp_75_1) goto error;
+ if (! leading_blanks) {
+ int tmp_87_1;
+ int tmp_77;
+ whitespaces.pointer = whitespaces.start;
+ memset((void *)whitespaces.start,0,
+ (unsigned long)(whitespaces.end - whitespaces.start));
+ if (leading_break.pointer + 5 < leading_break.end) tmp_77 = 1;
+ else {
+ int tmp_76;
+ tmp_76 = yaml_string_extend(& leading_break.start,
+ & leading_break.pointer,
+ & leading_break.end);
+ if (tmp_76) tmp_77 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_77 = 0;
+ }
+ }
+ if (tmp_77) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\n')) {
+ yaml_char_t *tmp_78;
+ tmp_78 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ *tmp_78 = (unsigned char)'\n';
+ parser->buffer.pointer += 2;
+ parser->mark.index += (size_t)2;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)2;
+ size_t tmp_93 = parser->unread;
+ }
+ else goto _LAND_21;
+ }
+ else {
+ _LAND_21: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_3;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')) {
+ yaml_char_t *tmp_79;
+ _LOR_3:
+ { /* sequence */
+ tmp_79 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ *tmp_79 = (unsigned char)'\n';
+ }
+ (parser->buffer.pointer) ++;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_91 = parser->unread;
+ }
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\205')) {
+ yaml_char_t *tmp_80;
+ tmp_80 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ *tmp_80 = (unsigned char)'\n';
+ parser->buffer.pointer += 2;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_89 = parser->unread;
+ }
+ else goto _LAND_20;
+ }
+ else {
+ _LAND_20: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\200'))
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'\250'))
+ goto _LOR_2;
+ else
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'\251')) {
+ yaml_char_t *tmp_81;
+ yaml_char_t *tmp_82;
+ yaml_char_t *tmp_83;
+ yaml_char_t *tmp_84;
+ yaml_char_t *tmp_85;
+ yaml_char_t *tmp_86;
+ _LOR_2:
+ { /* sequence */
+ tmp_81 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ tmp_82 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_81 = *tmp_82;
+ }
+ tmp_83 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ tmp_84 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_83 = *tmp_84;
+ tmp_85 = leading_break.pointer;
+ (leading_break.pointer) ++;
+ tmp_86 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_85 = *tmp_86;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_87 = parser->unread;
+ }
+ }
+ }
+ tmp_87_1 = 1;
+ }
+ else tmp_87_1 = 0;
+ if (! tmp_87_1) goto error;
+ leading_blanks = 1;
+ }
+ else {
+ int tmp_99_0;
+ int tmp_89_1;
+ if (trailing_breaks.pointer + 5 < trailing_breaks.end)
+ tmp_89_1 = 1;
+ else {
+ int tmp_88;
+ tmp_88 = yaml_string_extend(& trailing_breaks.start,
+ & trailing_breaks.pointer,
+ & trailing_breaks.end);
+ if (tmp_88) tmp_89_1 = 1;
+ else {
+ parser->error = YAML_MEMORY_ERROR;
+ tmp_89_1 = 0;
+ }
+ }
+ if (tmp_89_1) {
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\n')) {
+ yaml_char_t *tmp_90;
+ tmp_90 = trailing_breaks.pointer;
+ (trailing_breaks.pointer) ++;
+ *tmp_90 = (unsigned char)'\n';
+ parser->buffer.pointer += 2;
+ parser->mark.index += (size_t)2;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)2;
+ size_t tmp_105 = parser->unread;
+ }
+ else goto _LAND_23;
+ }
+ else {
+ _LAND_23: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\r'))
+ goto _LOR_5;
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\n')) {
+ yaml_char_t *tmp_91_1;
+ _LOR_5:
+ { /* sequence */
+ tmp_91_1 = trailing_breaks.pointer;
+ (trailing_breaks.pointer) ++;
+ *tmp_91_1 = (unsigned char)'\n';
+ }
+ (parser->buffer.pointer) ++;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_103 = parser->unread;
+ }
+ else
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\302')) {
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\205')) {
+ yaml_char_t *tmp_92;
+ tmp_92 = trailing_breaks.pointer;
+ (trailing_breaks.pointer) ++;
+ *tmp_92 = (unsigned char)'\n';
+ parser->buffer.pointer += 2;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_101 = parser->unread;
+ }
+ else goto _LAND_22;
+ }
+ else {
+ _LAND_22: ;
+ if ((int)*(parser->buffer.pointer + 0) == (int)((unsigned char)'\342'))
+ if ((int)*(parser->buffer.pointer + 1) == (int)((unsigned char)'\200'))
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'\250'))
+ goto _LOR_4;
+ else
+ if ((int)*(parser->buffer.pointer + 2) == (int)((unsigned char)'\251')) {
+ yaml_char_t *tmp_93_0;
+ yaml_char_t *tmp_94;
+ yaml_char_t *tmp_95;
+ yaml_char_t *tmp_96;
+ yaml_char_t *tmp_97;
+ yaml_char_t *tmp_98;
+ _LOR_4:
+ { /* sequence */
+ tmp_93_0 = trailing_breaks.pointer;
+ (trailing_breaks.pointer) ++;
+ tmp_94 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_93_0 = *tmp_94;
+ }
+ tmp_95 = trailing_breaks.pointer;
+ (trailing_breaks.pointer) ++;
+ tmp_96 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_95 = *tmp_96;
+ tmp_97 = trailing_breaks.pointer;
+ (trailing_breaks.pointer) ++;
+ tmp_98 = parser->buffer.pointer;
+ (parser->buffer.pointer) ++;
+ *tmp_97 = *tmp_98;
+ parser->mark.index += (size_t)1;
+ parser->mark.column = (unsigned long)0;
+ parser->mark.line += (size_t)1;
+ parser->unread -= (size_t)1;
+ size_t tmp_99 = parser->unread;
+ }
+ }
+ }
+ tmp_99_0 = 1;
+ }
+ else tmp_99_0 = 0;
+ if (! tmp_99_0) goto error;
+ }
+ }
+ if (parser->unread >= (size_t)1) tmp_101_1 = 1;
+ else tmp_101_1 = yaml_parser_update_buffer(parser,(unsigned long)1);
+ if (! tmp_101_1) goto error;
+ }
+ }
+ if (! parser->flow_level)
+ if ((int)parser->mark.column < indent) break;
+ }
+ }
+ memset((void *)token,0,sizeof(yaml_token_t));
+ token->type = YAML_SCALAR_TOKEN;
+ token->start_mark = start_mark;
+ token->end_mark = end_mark;
+ token->data.scalar.value = string.start;
+ token->data.scalar.length = (unsigned long)(string.pointer - string.start);
+ token->data.scalar.style = YAML_PLAIN_SCALAR_STYLE;
+ if (leading_blanks) parser->simple_key_allowed = 1;
+ yaml_free((void *)leading_break.start);
+ leading_break.end = (yaml_char_t *)0;
+ leading_break.pointer = leading_break.end;
+ leading_break.start = leading_break.pointer;
+ yaml_free((void *)trailing_breaks.start);
+ trailing_breaks.end = (yaml_char_t *)0;
+ trailing_breaks.pointer = trailing_breaks.end;
+ trailing_breaks.start = trailing_breaks.pointer;
+ yaml_free((void *)whitespaces.start);
+ whitespaces.end = (yaml_char_t *)0;
+ whitespaces.pointer = whitespaces.end;
+ whitespaces.start = whitespaces.pointer;
+ __retres = 1;
+ goto return_label;
+ error: yaml_free((void *)string.start);
+ string.end = (yaml_char_t *)0;
+ string.pointer = string.end;
+ string.start = string.pointer;
+ yaml_free((void *)leading_break.start);
+ leading_break.end = (yaml_char_t *)0;
+ leading_break.pointer = leading_break.end;
+ leading_break.start = leading_break.pointer;
+ yaml_free((void *)trailing_breaks.start);
+ trailing_breaks.end = (yaml_char_t *)0;
+ trailing_breaks.pointer = trailing_breaks.end;
+ trailing_breaks.start = trailing_breaks.pointer;
+ yaml_free((void *)whitespaces.start);
+ whitespaces.end = (yaml_char_t *)0;
+ whitespaces.pointer = whitespaces.end;
+ whitespaces.start = whitespaces.pointer;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int yaml_emitter_set_writer_error(yaml_emitter_t *emitter,
+ char const *problem);
+
+static int yaml_emitter_set_writer_error(yaml_emitter_t *emitter,
+ char const *problem)
+{
+ int __retres;
+ emitter->error = YAML_WRITER_ERROR;
+ emitter->problem = problem;
+ __retres = 0;
+ return __retres;
+}
+
+int yaml_emitter_flush(yaml_emitter_t *emitter)
+{
+ int __retres;
+ int low;
+ int high;
+ int tmp_8;
+ __FC_assert(emitter != (yaml_emitter_t *)0,"src/writer.c",36,"emitter");
+ __FC_assert(emitter->write_handler != (yaml_write_handler_t *)0,
+ "src/writer.c",37,"emitter->write_handler");
+ __FC_assert(emitter->encoding != (unsigned int)0,"src/writer.c",38,
+ "emitter->encoding");
+ emitter->buffer.last = emitter->buffer.pointer;
+ emitter->buffer.pointer = emitter->buffer.start;
+ if (emitter->buffer.start == emitter->buffer.last) {
+ __retres = 1;
+ goto return_label;
+ }
+ if (emitter->encoding == (unsigned int)YAML_UTF8_ENCODING) {
+ int tmp_0;
+ tmp_0 = (*(emitter->write_handler))(emitter->write_handler_data,
+ emitter->buffer.start,
+ (unsigned long)(emitter->buffer.last - emitter->buffer.start));
+ if (tmp_0) {
+ emitter->buffer.last = emitter->buffer.start;
+ emitter->buffer.pointer = emitter->buffer.start;
+ __retres = 1;
+ goto return_label;
+ }
+ else {
+ int tmp;
+ tmp = yaml_emitter_set_writer_error(emitter,"write error");
+ __retres = tmp;
+ goto return_label;
+ }
+ }
+ if (emitter->encoding == (unsigned int)YAML_UTF16LE_ENCODING) low = 0;
+ else low = 1;
+ if (emitter->encoding == (unsigned int)YAML_UTF16LE_ENCODING) high = 1;
+ else high = 0;
+ while (emitter->buffer.pointer != emitter->buffer.last) {
+ unsigned char octet;
+ unsigned int width;
+ unsigned int value;
+ size_t k;
+ octet = *(emitter->buffer.pointer + 0);
+ if (((int)octet & 0x80) == 0x00) width = (unsigned int)1;
+ else {
+ int tmp_3;
+ if (((int)octet & 0xE0) == 0xC0) tmp_3 = 2;
+ else {
+ int tmp_2;
+ if (((int)octet & 0xF0) == 0xE0) tmp_2 = 3;
+ else {
+ int tmp_1;
+ if (((int)octet & 0xF8) == 0xF0) tmp_1 = 4; else tmp_1 = 0;
+ tmp_2 = tmp_1;
+ }
+ tmp_3 = tmp_2;
+ }
+ width = (unsigned int)tmp_3;
+ }
+ if (((int)octet & 0x80) == 0x00) value = (unsigned int)((int)octet & 0x7F);
+ else {
+ int tmp_6;
+ if (((int)octet & 0xE0) == 0xC0) tmp_6 = (int)octet & 0x1F;
+ else {
+ int tmp_5;
+ if (((int)octet & 0xF0) == 0xE0) tmp_5 = (int)octet & 0x0F;
+ else {
+ int tmp_4;
+ if (((int)octet & 0xF8) == 0xF0) tmp_4 = (int)octet & 0x07;
+ else tmp_4 = 0;
+ tmp_5 = tmp_4;
+ }
+ tmp_6 = tmp_5;
+ }
+ value = (unsigned int)tmp_6;
+ }
+ k = (unsigned long)1;
+ while (k < (size_t)width) {
+ octet = *(emitter->buffer.pointer + k);
+ value = (value << 6) + (unsigned int)((int)octet & 0x3F);
+ k += (size_t)1;
+ }
+ emitter->buffer.pointer += width;
+ if (value < (unsigned int)0x10000) {
+ *(emitter->raw_buffer.last + high) = (unsigned char)(value >> 8);
+ *(emitter->raw_buffer.last + low) = (unsigned char)(value & (unsigned int)0xFF);
+ emitter->raw_buffer.last += 2;
+ }
+ else {
+ value -= (unsigned int)0x10000;
+ *(emitter->raw_buffer.last + high) = (unsigned char)((unsigned int)0xD8 + (
+ value >> 18));
+ *(emitter->raw_buffer.last + low) = (unsigned char)((value >> 10) & (unsigned int)0xFF);
+ *(emitter->raw_buffer.last + (high + 2)) = (unsigned char)((unsigned int)0xDC + (
+ (value >> 8) & (unsigned int)0xFF));
+ *(emitter->raw_buffer.last + (low + 2)) = (unsigned char)(value & (unsigned int)0xFF);
+ emitter->raw_buffer.last += 4;
+ }
+ }
+ tmp_8 = (*(emitter->write_handler))(emitter->write_handler_data,
+ emitter->raw_buffer.start,
+ (unsigned long)(emitter->raw_buffer.last - emitter->raw_buffer.start));
+ if (tmp_8) {
+ emitter->buffer.last = emitter->buffer.start;
+ emitter->buffer.pointer = emitter->buffer.start;
+ emitter->raw_buffer.last = emitter->raw_buffer.start;
+ emitter->raw_buffer.pointer = emitter->raw_buffer.start;
+ __retres = 1;
+ goto return_label;
+ }
+ else {
+ int tmp_7;
+ tmp_7 = yaml_emitter_set_writer_error(emitter,"write error");
+ __retres = tmp_7;
+ goto return_label;
+ }
+ return_label: return __retres;
+}
+
+/*@ requires valid_read_string(format);
+ assigns \result, *(s + (0 ..));
+ assigns \result
+ \from (indirect: *(format + (0 ..))), (indirect: param2),
+ (indirect: param1), (indirect: param0);
+ assigns *(s + (0 ..))
+ \from (indirect: *(format + (0 ..))), param2, param1, param0;
+ */
+int sprintf_va_2(char * __restrict s, char const * __restrict format,
+ int param0, int param1, int param2);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param0);
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ param0;
+ */
+int printf_va_1(char const * __restrict format, long param0);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param0);
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ param0;
+ */
+int printf_va_2(char const * __restrict format, long param0);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param0);
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ param0;
+ */
+int printf_va_3(char const * __restrict format, long param0);
+
+int main(void)
+{
+ int __retres;
+ char buf[64];
+ int tmp_0;
+ char const *tmp;
+ int major = -1;
+ int minor = -1;
+ int patch = -1;
+ yaml_get_version(& major,& minor,& patch);
+ sprintf(buf,"%d.%d.%d",major,minor,patch); /* sprintf_va_2 */
+ tmp = yaml_get_version_string();
+ tmp_0 = strcmp((char const *)(buf),tmp);
+ __FC_assert((tmp_0 == 0) != 0,"tests/test-version.c",21,
+ "strcmp(buf, yaml_get_version_string()) == 0");
+ printf("sizeof(token) = %ld\n",(long)sizeof(yaml_token_t)); /* printf_va_1 */
+ printf("sizeof(event) = %ld\n",(long)sizeof(yaml_event_t)); /* printf_va_2 */
+ printf("sizeof(parser) = %ld\n",(long)sizeof(yaml_parser_t)); /* printf_va_3 */
+ __retres = 0;
+ return __retres;
+}
+
+
diff --git a/libyaml/.frama-c/test-version.parse/metrics.log b/libyaml/.frama-c/test-version.parse/metrics.log
new file mode 100644
index 0000000000000000000000000000000000000000..0dfe11a53900bb5efa95f68846bac89e74f90853
--- /dev/null
+++ b/libyaml/.frama-c/test-version.parse/metrics.log
@@ -0,0 +1,192 @@
+[metrics] Defined functions (195)
+=======================
+ main (0 call); yaml_alias_event_initialize (0 call);
+ yaml_check_utf8 (16 calls); yaml_document_add_mapping (0 call);
+ yaml_document_add_scalar (0 call); yaml_document_add_sequence (0 call);
+ yaml_document_append_mapping_pair (0 call);
+ yaml_document_append_sequence_item (0 call); yaml_document_delete (2 calls);
+ yaml_document_end_event_initialize (0 call);
+ yaml_document_get_node (0 call); yaml_document_get_root_node (0 call);
+ yaml_document_initialize (0 call);
+ yaml_document_start_event_initialize (0 call);
+ yaml_emitter_analyze_anchor (4 calls); yaml_emitter_analyze_event (1 call);
+ yaml_emitter_analyze_scalar (1 call); yaml_emitter_analyze_tag (3 calls);
+ yaml_emitter_analyze_tag_directive (1 call);
+ yaml_emitter_analyze_version_directive (1 call);
+ yaml_emitter_anchor_node (4 calls);
+ yaml_emitter_append_tag_directive (2 calls);
+ yaml_emitter_check_empty_document (1 call);
+ yaml_emitter_check_empty_mapping (2 calls);
+ yaml_emitter_check_empty_sequence (2 calls);
+ yaml_emitter_check_simple_key (2 calls); yaml_emitter_close (1 call);
+ yaml_emitter_delete (0 call);
+ yaml_emitter_delete_document_and_anchors (3 calls);
+ yaml_emitter_dump (0 call); yaml_emitter_dump_alias (1 call);
+ yaml_emitter_dump_mapping (1 call); yaml_emitter_dump_node (4 calls);
+ yaml_emitter_dump_scalar (1 call); yaml_emitter_dump_sequence (1 call);
+ yaml_emitter_emit (10 calls); yaml_emitter_emit_alias (1 call);
+ yaml_emitter_emit_block_mapping_key (2 calls);
+ yaml_emitter_emit_block_mapping_value (2 calls);
+ yaml_emitter_emit_block_sequence_item (2 calls);
+ yaml_emitter_emit_document_content (1 call);
+ yaml_emitter_emit_document_end (1 call);
+ yaml_emitter_emit_document_start (2 calls);
+ yaml_emitter_emit_flow_mapping_key (2 calls);
+ yaml_emitter_emit_flow_mapping_value (2 calls);
+ yaml_emitter_emit_flow_sequence_item (2 calls);
+ yaml_emitter_emit_mapping_start (1 call); yaml_emitter_emit_node (9 calls);
+ yaml_emitter_emit_scalar (1 call);
+ yaml_emitter_emit_sequence_start (1 call);
+ yaml_emitter_emit_stream_start (1 call); yaml_emitter_flush (60 calls);
+ yaml_emitter_generate_anchor (1 call);
+ yaml_emitter_increase_indent (5 calls); yaml_emitter_initialize (0 call);
+ yaml_emitter_need_more_events (1 call); yaml_emitter_open (1 call);
+ yaml_emitter_process_anchor (4 calls); yaml_emitter_process_scalar (1 call);
+ yaml_emitter_process_tag (3 calls);
+ yaml_emitter_select_scalar_style (1 call); yaml_emitter_set_break (0 call);
+ yaml_emitter_set_canonical (0 call);
+ yaml_emitter_set_emitter_error (16 calls);
+ yaml_emitter_set_encoding (0 call); yaml_emitter_set_indent (0 call);
+ yaml_emitter_set_output (0 call); yaml_emitter_set_output_file (0 call);
+ yaml_emitter_set_output_string (0 call); yaml_emitter_set_unicode (0 call);
+ yaml_emitter_set_width (0 call); yaml_emitter_set_writer_error (2 calls);
+ yaml_emitter_state_machine (1 call); yaml_emitter_write_anchor (1 call);
+ yaml_emitter_write_block_scalar_hints (2 calls);
+ yaml_emitter_write_bom (1 call);
+ yaml_emitter_write_double_quoted_scalar (1 call);
+ yaml_emitter_write_folded_scalar (1 call);
+ yaml_emitter_write_indent (25 calls);
+ yaml_emitter_write_indicator (34 calls);
+ yaml_emitter_write_literal_scalar (1 call);
+ yaml_emitter_write_plain_scalar (1 call);
+ yaml_emitter_write_single_quoted_scalar (1 call);
+ yaml_emitter_write_tag_content (3 calls);
+ yaml_emitter_write_tag_handle (2 calls); yaml_event_delete (3 calls);
+ yaml_file_read_handler (address taken) (0 call);
+ yaml_file_write_handler (address taken) (0 call); yaml_free (169 calls);
+ yaml_get_version (1 call); yaml_get_version_string (1 call);
+ yaml_malloc (52 calls); yaml_mapping_end_event_initialize (0 call);
+ yaml_mapping_start_event_initialize (0 call);
+ yaml_parser_append_tag_directive (2 calls);
+ yaml_parser_decrease_flow_level (1 call); yaml_parser_delete (0 call);
+ yaml_parser_delete_aliases (2 calls);
+ yaml_parser_determine_encoding (1 call); yaml_parser_fetch_anchor (2 calls);
+ yaml_parser_fetch_block_entry (1 call);
+ yaml_parser_fetch_block_scalar (2 calls);
+ yaml_parser_fetch_directive (1 call);
+ yaml_parser_fetch_document_indicator (2 calls);
+ yaml_parser_fetch_flow_collection_end (2 calls);
+ yaml_parser_fetch_flow_collection_start (2 calls);
+ yaml_parser_fetch_flow_entry (1 call);
+ yaml_parser_fetch_flow_scalar (2 calls); yaml_parser_fetch_key (1 call);
+ yaml_parser_fetch_more_tokens (37 calls);
+ yaml_parser_fetch_next_token (1 call);
+ yaml_parser_fetch_plain_scalar (1 call);
+ yaml_parser_fetch_stream_end (1 call);
+ yaml_parser_fetch_stream_start (1 call); yaml_parser_fetch_tag (1 call);
+ yaml_parser_fetch_value (1 call); yaml_parser_increase_flow_level (1 call);
+ yaml_parser_initialize (0 call); yaml_parser_load (0 call);
+ yaml_parser_load_alias (1 call); yaml_parser_load_document (1 call);
+ yaml_parser_load_mapping (1 call); yaml_parser_load_mapping_end (1 call);
+ yaml_parser_load_node_add (4 calls); yaml_parser_load_nodes (1 call);
+ yaml_parser_load_scalar (1 call); yaml_parser_load_sequence (1 call);
+ yaml_parser_load_sequence_end (1 call); yaml_parser_parse (3 calls);
+ yaml_parser_parse_block_mapping_key (2 calls);
+ yaml_parser_parse_block_mapping_value (1 call);
+ yaml_parser_parse_block_sequence_entry (2 calls);
+ yaml_parser_parse_document_content (1 call);
+ yaml_parser_parse_document_end (1 call);
+ yaml_parser_parse_document_start (2 calls);
+ yaml_parser_parse_flow_mapping_key (2 calls);
+ yaml_parser_parse_flow_mapping_value (2 calls);
+ yaml_parser_parse_flow_sequence_entry (2 calls);
+ yaml_parser_parse_flow_sequence_entry_mapping_end (1 call);
+ yaml_parser_parse_flow_sequence_entry_mapping_key (1 call);
+ yaml_parser_parse_flow_sequence_entry_mapping_value (1 call);
+ yaml_parser_parse_indentless_sequence_entry (1 call);
+ yaml_parser_parse_node (14 calls); yaml_parser_parse_stream_start (1 call);
+ yaml_parser_process_directives (2 calls);
+ yaml_parser_process_empty_scalar (11 calls);
+ yaml_parser_register_anchor (3 calls);
+ yaml_parser_remove_simple_key (9 calls); yaml_parser_roll_indent (4 calls);
+ yaml_parser_save_simple_key (5 calls); yaml_parser_scan (0 call);
+ yaml_parser_scan_anchor (1 call); yaml_parser_scan_block_scalar (1 call);
+ yaml_parser_scan_block_scalar_breaks (2 calls);
+ yaml_parser_scan_directive (1 call);
+ yaml_parser_scan_directive_name (1 call);
+ yaml_parser_scan_flow_scalar (1 call);
+ yaml_parser_scan_plain_scalar (1 call); yaml_parser_scan_tag (1 call);
+ yaml_parser_scan_tag_directive_value (1 call);
+ yaml_parser_scan_tag_handle (2 calls); yaml_parser_scan_tag_uri (4 calls);
+ yaml_parser_scan_to_next_token (1 call);
+ yaml_parser_scan_uri_escapes (1 call);
+ yaml_parser_scan_version_directive_number (2 calls);
+ yaml_parser_scan_version_directive_value (1 call);
+ yaml_parser_set_composer_error (1 call);
+ yaml_parser_set_composer_error_context (1 call);
+ yaml_parser_set_encoding (0 call); yaml_parser_set_input (0 call);
+ yaml_parser_set_input_file (0 call); yaml_parser_set_input_string (0 call);
+ yaml_parser_set_parser_error (5 calls);
+ yaml_parser_set_parser_error_context (6 calls);
+ yaml_parser_set_reader_error (12 calls);
+ yaml_parser_set_scanner_error (35 calls);
+ yaml_parser_stale_simple_keys (2 calls); yaml_parser_state_machine (1 call);
+ yaml_parser_unroll_indent (4 calls); yaml_parser_update_buffer (59 calls);
+ yaml_parser_update_raw_buffer (2 calls); yaml_queue_extend (20 calls);
+ yaml_realloc (3 calls); yaml_scalar_event_initialize (0 call);
+ yaml_sequence_end_event_initialize (0 call);
+ yaml_sequence_start_event_initialize (0 call); yaml_stack_extend (47 calls);
+ yaml_strdup (21 calls); yaml_stream_end_event_initialize (0 call);
+ yaml_stream_start_event_initialize (0 call); yaml_string_extend (26 calls);
+ yaml_string_join (12 calls);
+ yaml_string_read_handler (address taken) (0 call);
+ yaml_string_write_handler (address taken) (0 call);
+ yaml_token_delete (7 calls);
+
+Specified-only functions (0)
+============================
+
+
+Undefined and unspecified functions (0)
+=======================================
+
+
+'Extern' global variables (0)
+=============================
+
+
+Potential entry points (39)
+===========================
+ main; yaml_alias_event_initialize; yaml_document_add_mapping;
+ yaml_document_add_scalar; yaml_document_add_sequence;
+ yaml_document_append_mapping_pair; yaml_document_append_sequence_item;
+ yaml_document_end_event_initialize; yaml_document_get_node;
+ yaml_document_get_root_node; yaml_document_initialize;
+ yaml_document_start_event_initialize; yaml_emitter_delete;
+ yaml_emitter_dump; yaml_emitter_initialize; yaml_emitter_set_break;
+ yaml_emitter_set_canonical; yaml_emitter_set_encoding;
+ yaml_emitter_set_indent; yaml_emitter_set_output;
+ yaml_emitter_set_output_file; yaml_emitter_set_output_string;
+ yaml_emitter_set_unicode; yaml_emitter_set_width;
+ yaml_mapping_end_event_initialize; yaml_mapping_start_event_initialize;
+ yaml_parser_delete; yaml_parser_initialize; yaml_parser_load;
+ yaml_parser_scan; yaml_parser_set_encoding; yaml_parser_set_input;
+ yaml_parser_set_input_file; yaml_parser_set_input_string;
+ yaml_scalar_event_initialize; yaml_sequence_end_event_initialize;
+ yaml_sequence_start_event_initialize; yaml_stream_end_event_initialize;
+ yaml_stream_start_event_initialize;
+
+Global metrics
+==============
+Sloc = 16343
+Decision point = 3300
+Global variables = 0
+If = 3173
+Loop = 97
+Goto = 1586
+Assignment = 7619
+Exit point = 195
+Function = 195
+Function call = 1212
+Pointer dereferencing = 8721
+Cyclomatic complexity = 3495
diff --git a/libyaml/.frama-c/test-version.parse/warnings.log b/libyaml/.frama-c/test-version.parse/warnings.log
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git a/libyaml/CMakeLists.txt b/libyaml/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..4f811481779aefba73f49e8657a6b8db6e7c5436
--- /dev/null
+++ b/libyaml/CMakeLists.txt
@@ -0,0 +1,160 @@
+
+cmake_minimum_required(VERSION 3.0)
+project (yaml C)
+
+set (YAML_VERSION_MAJOR 0)
+set (YAML_VERSION_MINOR 2)
+set (YAML_VERSION_PATCH 5)
+set (YAML_VERSION_STRING "${YAML_VERSION_MAJOR}.${YAML_VERSION_MINOR}.${YAML_VERSION_PATCH}")
+
+option(BUILD_SHARED_LIBS "Build libyaml as a shared library" OFF)
+set(YAML_STATIC_LIB_NAME "yaml" CACHE STRING "Base name of static library output")
+
+#
+# Output directories for a build tree
+#
+if(NOT DEFINED CMAKE_RUNTIME_OUTPUT_DIRECTORY)
+ set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
+endif()
+
+#
+# Install relative directories
+#
+if(NOT DEFINED INSTALL_LIB_DIR)
+ set(INSTALL_LIB_DIR lib)
+endif()
+if(NOT DEFINED INSTALL_BIN_DIR)
+ set(INSTALL_BIN_DIR bin)
+endif()
+if(NOT DEFINED INSTALL_INCLUDE_DIR)
+ set(INSTALL_INCLUDE_DIR include)
+endif()
+if(NOT DEFINED INSTALL_CMAKE_DIR)
+ set(INSTALL_CMAKE_DIR cmake)
+endif()
+
+#
+# Build library
+#
+set(SRCS
+ src/api.c
+ src/dumper.c
+ src/emitter.c
+ src/loader.c
+ src/parser.c
+ src/reader.c
+ src/scanner.c
+ src/writer.c
+ )
+
+set(config_h ${CMAKE_CURRENT_BINARY_DIR}/include/config.h)
+configure_file(
+ cmake/config.h.in
+ ${config_h}
+ )
+
+add_library(yaml ${SRCS})
+
+if(NOT BUILD_SHARED_LIBS)
+ set_target_properties(yaml
+ PROPERTIES OUTPUT_NAME ${YAML_STATIC_LIB_NAME}
+ )
+endif()
+
+set_target_properties(yaml
+ PROPERTIES DEFINE_SYMBOL YAML_DECLARE_EXPORT
+ )
+
+target_compile_definitions(yaml
+ PRIVATE HAVE_CONFIG_H
+ PUBLIC
+ $<$<NOT:$<BOOL:${BUILD_SHARED_LIBS}>>:YAML_DECLARE_STATIC>
+ $<$<BOOL:${MSVC}>:_CRT_SECURE_NO_WARNINGS>
+ )
+
+target_include_directories(yaml PUBLIC
+ $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
+ $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}/include>
+ $<INSTALL_INTERFACE:${INSTALL_INCLUDE_DIR}>
+ )
+
+#
+# Install rules
+#
+install(
+ FILES
+ include/yaml.h
+ DESTINATION include COMPONENT Development
+ )
+
+install(
+ TARGETS yaml
+ EXPORT yamlTargets
+ RUNTIME DESTINATION "${INSTALL_BIN_DIR}" COMPONENT Runtime
+ LIBRARY DESTINATION "${INSTALL_LIB_DIR}" COMPONENT Development
+ ARCHIVE DESTINATION "${INSTALL_LIB_DIR}" COMPONENT Development
+ )
+
+#
+# Add tests
+#
+include(CTest) # This module defines BUILD_TESTING option
+if(BUILD_TESTING)
+ add_subdirectory(tests)
+endif()
+
+#
+# Generate 'yamlConfig.cmake', 'yamlConfigVersion.cmake' and 'yamlTargets.cmake'
+#
+include(CMakePackageConfigHelpers)
+
+# Configure 'yamlConfig.cmake' for a build tree
+set(CONFIG_DIR_CONFIG ${PROJECT_BINARY_DIR})
+set(config_file ${PROJECT_BINARY_DIR}/yamlConfig.cmake)
+configure_package_config_file(
+ yamlConfig.cmake.in
+ ${config_file}
+ INSTALL_DESTINATION ${PROJECT_BINARY_DIR}
+ PATH_VARS CONFIG_DIR_CONFIG
+ NO_CHECK_REQUIRED_COMPONENTS_MACRO
+ )
+
+# Configure 'yamlTargets.cmake' for a build tree
+export(TARGETS yaml
+ FILE ${PROJECT_BINARY_DIR}/yamlTargets.cmake
+ )
+
+# Configure and install 'yamlConfig.cmake' for an install tree
+set(CONFIG_DIR_CONFIG ${INSTALL_CMAKE_DIR})
+set(install_config_file ${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/yamlConfig.cmake )
+configure_package_config_file(
+ yamlConfig.cmake.in
+ ${install_config_file}
+ INSTALL_DESTINATION ${CMAKE_INSTALL_PREFIX}/${INSTALL_CMAKE_DIR}
+ PATH_VARS CONFIG_DIR_CONFIG
+ NO_CHECK_REQUIRED_COMPONENTS_MACRO
+ )
+install(
+ FILES ${install_config_file}
+ DESTINATION ${INSTALL_CMAKE_DIR} COMPONENT Development
+ )
+
+# Configure and install 'yamlTargets.cmake' for an install tree
+install(EXPORT yamlTargets
+ FILE yamlTargets.cmake
+ DESTINATION ${INSTALL_CMAKE_DIR}
+ COMPONENT Development
+ )
+
+# Configure 'yamlConfigVersion.cmake' for a build tree
+set(config_version_file ${PROJECT_BINARY_DIR}/yamlConfigVersion.cmake)
+write_basic_package_version_file(
+ ${config_version_file}
+ VERSION ${YAML_VERSION_STRING}
+ COMPATIBILITY AnyNewerVersion
+)
+# ... and install for an install tree
+install(
+ FILES ${config_version_file}
+ DESTINATION ${INSTALL_CMAKE_DIR} COMPONENT Development
+ )
diff --git a/libyaml/Changes b/libyaml/Changes
new file mode 100644
index 0000000000000000000000000000000000000000..e4b96edcbef77a8c662ea665ff046df2ae57fab9
--- /dev/null
+++ b/libyaml/Changes
@@ -0,0 +1,372 @@
+0.2.5 2020-06-01
+
+https://github.com/yaml/libyaml/pull/105
+Allow question marks in plain scalars in flow collections
+
+https://github.com/yaml/libyaml/pull/186
+Emitter: Don't output trailing space for empty scalar nodes
+
+https://github.com/yaml/libyaml/pull/185
+Emitter: Output space after an alias mapping key
+
+https://github.com/yaml/libyaml/pull/187
+Add -h and --flow (on|off|keep) to run-*-test-suite
+
+https://github.com/yaml/libyaml/pull/182
+Remove unnecessary include and malloc
+
+https://github.com/yaml/libyaml/pull/177
+Add specific files back to .gitignore
+
+https://github.com/yaml/libyaml/pull/181
+Output error position in run-parser-test-suite.c
+
+https://github.com/yaml/libyaml/pull/191
+A couple patches to improve test suite support
+
+0.2.4 2020-04-19
+
+ - https://github.com/yaml/libyaml/pull/143
+ Add packaging/docker-dist to Makefile.am
+
+ - https://github.com/yaml/libyaml/pull/174
+ Fix logic for document end before directive
+
+
+0.2.3 2020-04-11
+
+ - https://github.com/yaml/libyaml/pull/130
+ Fixed typo.
+
+ - https://github.com/yaml/libyaml/pull/144
+ Fix typo in comment
+
+ - https://github.com/yaml/libyaml/pull/140
+ Use pointer to const for strings that aren't/shouldn't be modified
+
+ - https://github.com/yaml/libyaml/pull/128
+ Squash a couple of warnings in example-deconstructor-alt
+
+ - https://github.com/yaml/libyaml/pull/151
+ Fix spelling for error message
+
+ - https://github.com/yaml/libyaml/pull/161
+ Make appveyor config be a hidden file
+
+ - https://github.com/yaml/libyaml/pull/159
+ Add CHANGES file
+
+ - https://github.com/yaml/libyaml/pull/160
+ Always output document end before directive (YAML 1.2 compatibility)
+
+ - https://github.com/yaml/libyaml/pull/162
+ Output document end marker after open ended scalars
+
+ - https://github.com/yaml/libyaml/pull/157
+ change cmake target name from libOFF.a to libyaml.a
+
+ - https://github.com/yaml/libyaml/pull/155
+ include/yaml.h: fix comments
+
+ - https://github.com/yaml/libyaml/pull/169
+ Fixed missing token in example
+
+ - https://github.com/yaml/libyaml/pull/127
+ Avoid recursion in the document loader.
+
+ - https://github.com/yaml/libyaml/pull/172
+ Support %YAML 1.2 directives
+
+ - https://github.com/yaml/libyaml/pull/66
+ Change dllexport controlling macro to use _WIN32
+
+0.2.2 2019-03-12
+
+ - https://github.com/yaml/libyaml/pull/95
+ build: do not install config.h
+
+ - https://github.com/yaml/libyaml/pull/97
+ appveyor.yml: fix Release build
+
+ - https://github.com/yaml/libyaml/pull/103
+ Remove unused code in yaml_document_delete
+
+ - https://github.com/yaml/libyaml/pull/104
+ Allow colons in plain scalars inside flow collections
+
+ - https://github.com/yaml/libyaml/pull/109
+ Fix comparison in tests/run-emitter.c
+
+ - https://github.com/yaml/libyaml/pull/117
+ Fix typo error
+
+ - https://github.com/yaml/libyaml/pull/119
+ The closing single quote needs to be indented...
+
+ - https://github.com/yaml/libyaml/pull/121
+ fix token name typos in comments
+
+ - https://github.com/yaml/libyaml/pull/122
+ Revert removing of open_ended after top level plain scalar
+
+ - https://github.com/yaml/libyaml/pull/125
+ Cherry-picks from PR 27
+
+ - https://github.com/yaml/libyaml/pull/135
+ Windows/C89 compatibility
+
+ - https://github.com/yaml/libyaml/pull/136
+ allow override of Windows static lib name
+
+0.2.1 2018-06-24
+
+ - https://github.com/yaml/libyaml/pull/10
+ Support static and dynamic libraries
+
+ - https://github.com/yaml/libyaml/pull/12
+ Use .gitignore instead of .hgignore
+
+ - https://github.com/yaml/libyaml/pull/13
+ Add support for `make test` and travis
+
+ - https://github.com/yaml/libyaml/pull/14
+ Dockerfile for testing
+
+ - https://github.com/yaml/libyaml/pull/15
+ Apply old fix for `\/` that is not in master.
+
+ - https://github.com/yaml/libyaml/pull/17
+ Update license to include all years until now.
+
+ - https://github.com/yaml/libyaml/pull/18
+ Port bug fix from Perl binding
+
+ - https://github.com/yaml/libyaml/pull/22
+ Fix misspell: preceed
+
+ - https://github.com/yaml/libyaml/pull/23
+ Removed trailing-whitespaces
+
+ - https://github.com/yaml/libyaml/pull/24
+ Fix typo
+
+ - https://github.com/yaml/libyaml/pull/25
+ added an examples directory with a few yaml examples
+
+ - https://github.com/yaml/libyaml/pull/26
+ Added missing Cflags path in pkg-config file
+
+ - https://github.com/yaml/libyaml/pull/31
+ add unit tests to cmake configuration
+
+ - https://github.com/yaml/libyaml/pull/32
+ Include an example of a custom tag from Python
+
+ - https://github.com/yaml/libyaml/pull/33
+ Include an example of a %YAML tag
+
+ - https://github.com/yaml/libyaml/pull/34
+ Added an example of using a global tag
+
+ - https://github.com/yaml/libyaml/pull/36
+ Fix -Wformat compilation errors in tests
+
+ - https://github.com/yaml/libyaml/pull/37
+ Update bug report URL in LibYAML
+
+ - https://github.com/yaml/libyaml/pull/38
+ Use AM_CPPFLAGS since autotools deprecated INCLUDE
+
+ - https://github.com/yaml/libyaml/pull/39
+ Update bug report URL in README
+
+ - https://github.com/yaml/libyaml/pull/41
+ Add travis and Makefile support for libyaml-test
+
+ - https://github.com/yaml/libyaml/pull/43
+ Add Dockerfile for Fedora 25
+
+ - https://github.com/yaml/libyaml/pull/44
+ WIP: Enable all warnings (-Wall) in libyaml and tests
+
+ - https://github.com/yaml/libyaml/pull/45
+ Fix typo
+
+ - https://github.com/yaml/libyaml/pull/47
+ Move travis script guts to separate file
+
+ - https://github.com/yaml/libyaml/pull/48
+ `yaml/libyaml-test` should become part of `yaml/libyaml`
+
+ - https://github.com/yaml/libyaml/pull/50
+ Add a GNUMakefile for immediate make targets
+
+ - https://github.com/yaml/libyaml/pull/53
+ Switch from test blacklist to whitelist
+
+ - https://github.com/yaml/libyaml/pull/55
+ Update defs for MingGW support on Windows
+
+ - https://github.com/yaml/libyaml/pull/58
+ Improve CMakeLists
+
+ - https://github.com/yaml/libyaml/pull/64
+ README: Update libyaml link
+
+ - https://github.com/yaml/libyaml/pull/69
+ Skip 5 tests in libyaml-emitter.list
+
+ - https://github.com/yaml/libyaml/pull/74
+ Forbid escaped singlequote in doublequotes
+
+ - https://github.com/yaml/libyaml/pull/76
+ Rewrite make test-suite
+
+ - https://github.com/yaml/libyaml/pull/77
+ Undefined PTRDIFF_MAX on HP-UX
+
+ - https://github.com/yaml/libyaml/pull/78
+ Fixed most compiler warnings -Wall -Wextra
+
+ - https://github.com/yaml/libyaml/pull/82
+ Move yaml-test-suite integration onto a separate branch.
+
+ - https://github.com/yaml/libyaml/pull/86
+ Fix problems in CI failures (travis and semaphore)
+
+ - https://github.com/yaml/libyaml/pull/87
+ appveyor.yml: add mingw-w64 builds
+
+ - https://github.com/yaml/libyaml/pull/88
+ add -no-undefined to src/Makefile.am
+
+ - https://github.com/yaml/libyaml/pull/89
+ Added alpine linux testing to dockerfiles
+
+ - https://github.com/yaml/libyaml/pull/93
+ remove need for PTRDIFF_MAX
+
+ - https://github.com/yaml/libyaml/pull/94
+ .gitignore: major cleanup
+
+ - https://github.com/yaml/libyaml/pull/120
+ Fix doc.
+
+0.1.7 2016-08-27
+
+ - Fixed segfault in yaml_string_write_handler.
+
+ - Fixed invalid simple key assertion.
+
+ - Fixed error handling in some examples (thank to Mathias Svensson).
+
+ - Removed obsolete VS project files.
+
+0.1.6 2014-03-26
+
+ - https://github.com/yaml/libyaml/commit/d1003a9
+ Fixed heap overflow in yaml_parser_scan_uri_escapes (Thanks
+ Ivan Fratric of the Google Security Team).
+
+ - https://github.com/yaml/libyaml/commit/662f4be
+ Added tag 0.1.5 for changeset a5142b24428b
+
+0.1.5 2014-02-03
+
+ - https://github.com/yaml/libyaml/commit/303b455
+ Manually define PTRDIFF_MAX for VS C compiler.
+
+ - https://github.com/yaml/libyaml/commit/1ef1171
+ Forgot to set the error state.
+
+ - https://github.com/yaml/libyaml/commit/c9479c7
+ Limit input size to SIZE_MAX/2.
+
+ - https://github.com/yaml/libyaml/commit/c201bf6
+ Guard against overflows in indent and flow_level.
+
+ - https://github.com/yaml/libyaml/commit/bb8ab82
+ Added .hgignore.
+
+ - https://github.com/yaml/libyaml/commit/2d94fc5
+ Prevent node index overflow (Reported by Florian Weimer).
+
+ - https://github.com/yaml/libyaml/commit/df33f25
+ Bumped the version number.
+
+ - https://github.com/yaml/libyaml/commit/f56726b
+ Fixed invalid size_t->int cast (Thank to Florian Weimer).
+
+ - https://github.com/yaml/libyaml/commit/01e8dad
+ Added a basic CMake project.
+
+ - https://github.com/yaml/libyaml/commit/f54fc40
+ Added tag 0.1.4 for changeset 3e6507fa0c26
+
+0.1.4 2012-12-24
+
+ - Fixed a bug that prevented an empty mapping being used as a simple key
+ (thank to spitzak(at)rhythm(dot)com).
+
+ - Fixed pointer overflow when calculating the position of a potential
+ simple key (thank to ppelletier(at)oblong(dot)com).
+
+ - Fixed yaml.dll not exporting any symbols
+ (thank to pxn11432(at)nifty(dot)com).
+
+ - Added pkg-config support (thank to rainwoodman(at)gmail(dot)com).
+
+0.1.3 2009-08-29
+
+ - This release fixes non-standard structure initialization and
+ a streaming-related issue.
+
+0.1.2 2008-12-27
+
+ - Minor bugfix release
+
+0.1.1 2006-08-01
+
+ - https://github.com/yaml/libyaml/commit/5e52c31
+ Fixed a problem when the DOCUMENT-END event is not emitted until
+ the beginning of the next document is available. Fixed #51.
+ Thanks edward(at)sweetbytes.net for the bug report.
+
+ - https://github.com/yaml/libyaml/commit/dd71484
+ Add project files for Visual Studio 2003.
+
+ - https://github.com/yaml/libyaml/commit/ce8a93e
+ Fix the example_deconstructor project.
+
+ - https://github.com/yaml/libyaml/commit/c9b74de
+ Eliminate some warnings and add more doxygen definitions.
+
+ - https://github.com/yaml/libyaml/commit/0122490
+ Undefine the NDEBUG directive for the test programs.
+
+ - https://github.com/yaml/libyaml/commit/071329a
+ Fix a bug in the emitter introduced while fixing warnings for VC6.
+
+ - https://github.com/yaml/libyaml/commit/6f6bbb8
+ Add VC6 projects for the test executables.
+
+ - https://github.com/yaml/libyaml/commit/0174ed6
+ Add win32 fixes and project files for VC6.
+
+ - https://github.com/yaml/libyaml/commit/e27a3c8
+ Add functions for constructing, parsing and emitting YAML documents.
+
+ - https://github.com/yaml/libyaml/commit/a907bf8
+ Add `const` qualifier for `yaml_parser_set_input_string` parameter `input`.
+
+ - https://github.com/yaml/libyaml/commit/c83b67a
+ Force a new line at the end of the input stream even if there
+ are no a new line character. This fixes a nasty bug when libyaml hangs on
+ documents like `[[[[`. Thanks ciaranm for reporting the bug.
+
+ - https://github.com/yaml/libyaml/commit/609cce0
+ Older versions of gcc do not know about -Wno-pointer-sign.
+
+0.0.1 2006-08-01
+
+ - Initial release
diff --git a/libyaml/License b/libyaml/License
new file mode 100644
index 0000000000000000000000000000000000000000..3d82c281ee8ceb45368153139f5935bd8d39c816
--- /dev/null
+++ b/libyaml/License
@@ -0,0 +1,20 @@
+Copyright (c) 2017-2020 Ingy döt Net
+Copyright (c) 2006-2016 Kirill Simonov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/libyaml/Makefile.am b/libyaml/Makefile.am
new file mode 100644
index 0000000000000000000000000000000000000000..45d9c27023ffb9aef7d34d35e04fd5bf3aab3946
--- /dev/null
+++ b/libyaml/Makefile.am
@@ -0,0 +1,51 @@
+## Run `./bootstrap` to generate the "Makefile.in" files in this directory and
+## the "$SUBDIRS" subdirectories.
+
+SUBDIRS = include src . tests
+
+EXTRA_DIST = Changes ReadMe.md License CMakeLists.txt doc/doxygen.cfg
+
+LIBYAML_TEST_SUITE_RUN_REPO_DEFAULT := https://github.com/yaml/libyaml
+LIBYAML_TEST_SUITE_RUN_REPO ?= $(LIBYAML_TEST_SUITE_RUN_REPO_DEFAULT)
+LIBYAML_TEST_SUITE_RUN_BRANCH ?= run-test-suite
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = yaml-0.1.pc
+
+maintainer-clean-local:
+ rm -f aclocal.m4 config.h.in configure config/*
+ -find ${builddir} -name Makefile.in -exec rm -f '{}' ';'
+
+distclean-local:
+ rm -fr tests/run-test-suite
+ -git worktree prune
+
+.PHONY: bootstrap
+bootstrap: maintainer-clean
+ ./bootstrap
+ ./configure
+ make
+
+test: all
+ make -C tests check-TESTS
+
+test-suite: tests/run-test-suite all
+ make -C $< test
+
+test-all: test test-suite
+
+tests/run-test-suite:
+ifeq ($(LIBYAML_TEST_SUITE_RUN_REPO),$(LIBYAML_TEST_SUITE_RUN_REPO_DEFAULT))
+ -git branch --track $(LIBYAML_TEST_SUITE_RUN_BRANCH) origin/$(LIBYAML_TEST_SUITE_RUN_BRANCH)
+ -git worktree prune
+ git worktree add $@ $(LIBYAML_TEST_SUITE_RUN_BRANCH)
+ else
+ git clone --branch $(LIBYAML_TEST_SUITE_RUN_BRANCH) $(LIBYAML_TEST_SUITE_RUN_REPO) $@
+ endif
+
+docker-build:
+ make -C pkg/docker build
+
+docker-dist:
+ make -C pkg/docker libyaml-dist
+
diff --git a/libyaml/ReadMe.md b/libyaml/ReadMe.md
new file mode 100644
index 0000000000000000000000000000000000000000..2dfcc4476dcd42c7f76b64bb8df8651fa0e2322f
--- /dev/null
+++ b/libyaml/ReadMe.md
@@ -0,0 +1,46 @@
+## LibYAML - A C library for parsing and emitting YAML.
+
+To build and install the library, run:
+
+ $ ./configure
+ $ make
+ # make install
+
+Required packages:
+
+- gcc
+- libtool
+- make
+
+If you checked the source code from the Git repository, run
+
+ $ ./bootstrap
+ $ ./configure
+ $ make
+ # make install
+
+Required packages:
+
+- autoconf
+- libtool
+- make
+
+For more information, check the [LibYAML
+homepage](https://github.com/yaml/libyaml).
+
+Discuss LibYAML with the maintainers in IRC #libyaml irc.freenode.net.
+
+You may also use the [YAML-Core mailing
+list](http://lists.sourceforge.net/lists/listinfo/yaml-core).
+
+Submit bug reports and feature requests to the [LibYAML bug
+tracker](https://github.com/yaml/libyaml/issues/new).
+
+This project was developed for Python Software Foundation as a part of Google
+Summer of Code under the mentorship of Clark Evans.
+
+The LibYAML module was written by Kirill Simonov <xi@resolvent.net>.
+It is currently maintained by the YAML community.
+
+LibYAML is released under the MIT license.
+See the file LICENSE for more details.
diff --git a/libyaml/announcement.msg b/libyaml/announcement.msg
new file mode 100644
index 0000000000000000000000000000000000000000..080a864b65d531f63a452be77cb99fcdd30f5256
--- /dev/null
+++ b/libyaml/announcement.msg
@@ -0,0 +1,89 @@
+From: Tina Müller <post@tinita.de>
+To: yaml-core@lists.sourceforge.net
+Subject: [ANN] LibYAML-0.2.5: A new release
+
+=========================
+ Announcing LibYAML-0.2.5
+=========================
+
+A new release of LibYAML is now available:
+https://github.com/yaml/libyaml/tree/0.2.5
+
+The LibYAML project is now maintained by the YAML community. Planning happens
+on the #yaml-dev and #libyaml IRC channels on irc.freenode.net.
+
+
+Changes
+=======
+
+
+https://github.com/yaml/libyaml/pull/187
+Add -h and --flow (on|off|keep) to run-*-test-suite
+
+https://github.com/yaml/libyaml/pull/182
+Remove unnecessary include and malloc
+
+https://github.com/yaml/libyaml/pull/177
+Add specific files back to .gitignore
+
+https://github.com/yaml/libyaml/pull/181
+Output error position in run-parser-test-suite.c
+
+https://github.com/yaml/libyaml/pull/105
+Allow question marks in plain scalars in flow collections
+
+https://github.com/yaml/libyaml/pull/186
+Emitter: Don't output trailing space for empty scalar nodes
+
+https://github.com/yaml/libyaml/pull/185
+Emitter: Output space after an alias mapping key
+
+https://github.com/yaml/libyaml/pull/191
+A couple patches to improve test suite support
+
+
+Resources
+=========
+
+LibYAML IRC Channel: #libyaml on irc.freenode.net
+LibYAML homepage: https://github.com/yaml/libyaml
+Source download: https://github.com/yaml/libyaml/archive/dist-0.2.3.zip
+GitHub repository: https://github.com/yaml/libyaml
+Bug tracking: https://github.com/yaml/libyaml/issues
+
+YAML homepage: http://yaml.org/
+YAML-core mailing list: http://lists.sourceforge.net/lists/listinfo/yaml-core
+
+
+About LibYAML
+=============
+
+YAML is a data serialization format designed for human readability and
+interaction with scripting languages.
+
+LibYAML is a C library for parsing and emitting YAML. LibYAML is the underlying
+parser/emitter code for YAML frameworks in many programming languages.
+
+
+Maintainers
+===========
+
+The following people are responsible for maintaining LibYAML:
+
+* Ingy döt Net
+
+and many thanks to all who have contribributed!
+See: https://github.com/yaml/libyaml/pulls
+
+
+Copyright
+=========
+
+Copyright (c) 2017-2020 Ingy döt Net <ingy@ingy.net>
+Copyright (c) 2006-2016 Kirill Simonov <xi@resolvent.net>
+
+The LibYAML module was written by Kirill Simonov.
+It is currently maintained by the YAML community.
+
+LibYAML is released under the MIT license.
+See the file LICENSE for more details.
diff --git a/libyaml/bootstrap b/libyaml/bootstrap
new file mode 100755
index 0000000000000000000000000000000000000000..1745838c5364f1a1c35fb95a1afb9daaca08bc8b
--- /dev/null
+++ b/libyaml/bootstrap
@@ -0,0 +1,3 @@
+#!/bin/sh
+
+exec autoreconf -fvi
diff --git a/libyaml/cmake/config.h.in b/libyaml/cmake/config.h.in
new file mode 100644
index 0000000000000000000000000000000000000000..51e2e24b524b2fd69e8234d0d7014a6eeeb659f4
--- /dev/null
+++ b/libyaml/cmake/config.h.in
@@ -0,0 +1,4 @@
+#define YAML_VERSION_MAJOR @YAML_VERSION_MAJOR@
+#define YAML_VERSION_MINOR @YAML_VERSION_MINOR@
+#define YAML_VERSION_PATCH @YAML_VERSION_PATCH@
+#define YAML_VERSION_STRING "@YAML_VERSION_STRING@"
diff --git a/libyaml/configure.ac b/libyaml/configure.ac
new file mode 100644
index 0000000000000000000000000000000000000000..92426f04ec4347da5061927d2e9b3ad5442bb736
--- /dev/null
+++ b/libyaml/configure.ac
@@ -0,0 +1,73 @@
+# Run `./bootstrap` to generate the "configure" script.
+
+# Define the package version numbers and the bug reporting link.
+m4_define([YAML_MAJOR], 0)
+m4_define([YAML_MINOR], 2)
+m4_define([YAML_PATCH], 5)
+m4_define([YAML_BUGS], [https://github.com/yaml/libyaml/issues/new])
+
+# Define the libtool version numbers; check the Autobook, Section 11.4.
+# Bump the libtool version numbers using the following algorithm:
+# if (the current interface has not been changed):
+# YAML_REVISION += 1
+# else:
+# YAML_REVISION = 0
+# YAML_CURRENT += 1
+# if (this release is backward compatible with the previous release):
+# YAML_AGE += 1
+# else:
+# YAML_AGE = 0
+m4_define([YAML_RELEASE], 0)
+m4_define([YAML_CURRENT], 2)
+m4_define([YAML_REVISION], 9)
+m4_define([YAML_AGE], 0)
+
+# Initialize autoconf & automake.
+AC_PREREQ(2.59)
+AC_INIT([yaml], [YAML_MAJOR.YAML_MINOR.YAML_PATCH], [YAML_BUGS])
+AC_CONFIG_AUX_DIR([config])
+AC_CONFIG_HEADERS([include/config.h])
+AM_INIT_AUTOMAKE([1.9 foreign])
+
+# Define macro variables for the package version numbers.
+AC_DEFINE(YAML_VERSION_MAJOR, YAML_MAJOR, [Define the major version number.])
+AC_DEFINE(YAML_VERSION_MINOR, YAML_MINOR, [Define the minor version number.])
+AC_DEFINE(YAML_VERSION_PATCH, YAML_PATCH, [Define the patch version number.])
+AC_DEFINE(YAML_VERSION_STRING, "YAML_MAJOR.YAML_MINOR.YAML_PATCH", [Define the version string.])
+
+# Define substitutions for the libtool version numbers.
+YAML_LT_RELEASE=YAML_RELEASE
+YAML_LT_CURRENT=YAML_CURRENT
+YAML_LT_REVISION=YAML_REVISION
+YAML_LT_AGE=YAML_AGE
+AC_SUBST(YAML_LT_RELEASE)
+AC_SUBST(YAML_LT_CURRENT)
+AC_SUBST(YAML_LT_REVISION)
+AC_SUBST(YAML_LT_AGE)
+
+# Note: in order to update checks, run `autoscan` and look through "configure.scan".
+
+# Checks for programs.
+AC_PROG_CC
+AC_PROG_CPP
+AC_PROG_INSTALL
+AC_PROG_LN_S
+AC_PROG_MAKE_SET
+AC_PROG_LIBTOOL
+
+AC_CHECK_PROG(DOXYGEN, [doxygen], [true], [false])
+AM_CONDITIONAL(DOXYGEN, [test "$DOXYGEN" = true])
+
+# Checks for header files.
+AC_HEADER_STDC
+AC_CHECK_HEADERS([stdlib.h])
+
+# Checks for typedefs, structures, and compiler characteristics.
+AC_C_CONST
+AC_TYPE_SIZE_T
+
+# Define Makefiles.
+AC_CONFIG_FILES([yaml-0.1.pc include/Makefile src/Makefile Makefile tests/Makefile])
+
+# Generate the "configure" script.
+AC_OUTPUT
diff --git a/libyaml/doc/doxygen.cfg b/libyaml/doc/doxygen.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..a58bb177a4d21075dee2a18b6a2448cbaaccd083
--- /dev/null
+++ b/libyaml/doc/doxygen.cfg
@@ -0,0 +1,222 @@
+# Doxyfile 1.4.4
+
+#---------------------------------------------------------------------------
+# Project related configuration options
+#---------------------------------------------------------------------------
+PROJECT_NAME = $(PACKAGE)
+PROJECT_NUMBER = $(VERSION)
+OUTPUT_DIRECTORY = $(top_builddir)/doc/
+CREATE_SUBDIRS = NO
+OUTPUT_LANGUAGE = English
+USE_WINDOWS_ENCODING = NO
+BRIEF_MEMBER_DESC = YES
+REPEAT_BRIEF = YES
+ABBREVIATE_BRIEF =
+ALWAYS_DETAILED_SEC = NO
+INLINE_INHERITED_MEMB = NO
+FULL_PATH_NAMES = YES
+STRIP_FROM_PATH =
+STRIP_FROM_INC_PATH =
+SHORT_NAMES = NO
+JAVADOC_AUTOBRIEF = YES
+MULTILINE_CPP_IS_BRIEF = NO
+DETAILS_AT_TOP = NO
+INHERIT_DOCS = YES
+DISTRIBUTE_GROUP_DOC = NO
+SEPARATE_MEMBER_PAGES = NO
+TAB_SIZE = 8
+ALIASES =
+OPTIMIZE_OUTPUT_FOR_C = YES
+OPTIMIZE_OUTPUT_JAVA = NO
+SUBGROUPING = YES
+#---------------------------------------------------------------------------
+# Build related configuration options
+#---------------------------------------------------------------------------
+EXTRACT_ALL = NO
+EXTRACT_PRIVATE = NO
+EXTRACT_STATIC = NO
+EXTRACT_LOCAL_CLASSES = NO
+EXTRACT_LOCAL_METHODS = NO
+HIDE_UNDOC_MEMBERS = NO
+HIDE_UNDOC_CLASSES = NO
+HIDE_FRIEND_COMPOUNDS = NO
+HIDE_IN_BODY_DOCS = NO
+INTERNAL_DOCS = NO
+CASE_SENSE_NAMES = YES
+HIDE_SCOPE_NAMES = NO
+SHOW_INCLUDE_FILES = YES
+INLINE_INFO = YES
+SORT_MEMBER_DOCS = NO
+SORT_BRIEF_DOCS = NO
+SORT_BY_SCOPE_NAME = NO
+GENERATE_TODOLIST = YES
+GENERATE_TESTLIST = YES
+GENERATE_BUGLIST = YES
+GENERATE_DEPRECATEDLIST= YES
+ENABLED_SECTIONS =
+MAX_INITIALIZER_LINES = 30
+SHOW_USED_FILES = YES
+SHOW_DIRECTORIES = YES
+FILE_VERSION_FILTER =
+#---------------------------------------------------------------------------
+# configuration options related to warning and progress messages
+#---------------------------------------------------------------------------
+QUIET = NO
+WARNINGS = YES
+WARN_IF_UNDOCUMENTED = YES
+WARN_IF_DOC_ERROR = YES
+WARN_NO_PARAMDOC = NO
+WARN_FORMAT = "$file:$line: $text"
+WARN_LOGFILE =
+#---------------------------------------------------------------------------
+# configuration options related to the input files
+#---------------------------------------------------------------------------
+INPUT = $(top_srcdir)/include/
+FILE_PATTERNS = *.h
+RECURSIVE = YES
+EXCLUDE =
+EXCLUDE_SYMLINKS = NO
+EXCLUDE_PATTERNS =
+EXAMPLE_PATH =
+EXAMPLE_PATTERNS =
+EXAMPLE_RECURSIVE = NO
+IMAGE_PATH =
+INPUT_FILTER =
+FILTER_PATTERNS =
+FILTER_SOURCE_FILES = NO
+#---------------------------------------------------------------------------
+# configuration options related to source browsing
+#---------------------------------------------------------------------------
+SOURCE_BROWSER = NO
+INLINE_SOURCES = NO
+STRIP_CODE_COMMENTS = YES
+REFERENCED_BY_RELATION = NO
+REFERENCES_RELATION = NO
+USE_HTAGS = NO
+VERBATIM_HEADERS = NO
+#---------------------------------------------------------------------------
+# configuration options related to the alphabetical class index
+#---------------------------------------------------------------------------
+ALPHABETICAL_INDEX = NO
+COLS_IN_ALPHA_INDEX = 5
+IGNORE_PREFIX =
+#---------------------------------------------------------------------------
+# configuration options related to the HTML output
+#---------------------------------------------------------------------------
+GENERATE_HTML = YES
+HTML_OUTPUT = html
+HTML_FILE_EXTENSION = .html
+HTML_HEADER =
+HTML_FOOTER =
+HTML_STYLESHEET =
+HTML_ALIGN_MEMBERS = YES
+GENERATE_HTMLHELP = NO
+CHM_FILE =
+HHC_LOCATION =
+GENERATE_CHI = NO
+BINARY_TOC = NO
+TOC_EXPAND = NO
+DISABLE_INDEX = NO
+ENUM_VALUES_PER_LINE = 1
+GENERATE_TREEVIEW = NO
+TREEVIEW_WIDTH = 250
+#---------------------------------------------------------------------------
+# configuration options related to the LaTeX output
+#---------------------------------------------------------------------------
+GENERATE_LATEX = NO
+LATEX_OUTPUT = latex
+LATEX_CMD_NAME = latex
+MAKEINDEX_CMD_NAME = makeindex
+COMPACT_LATEX = NO
+PAPER_TYPE = a4wide
+EXTRA_PACKAGES =
+LATEX_HEADER =
+PDF_HYPERLINKS = NO
+USE_PDFLATEX = NO
+LATEX_BATCHMODE = NO
+LATEX_HIDE_INDICES = NO
+#---------------------------------------------------------------------------
+# configuration options related to the RTF output
+#---------------------------------------------------------------------------
+GENERATE_RTF = NO
+RTF_OUTPUT = rtf
+COMPACT_RTF = NO
+RTF_HYPERLINKS = NO
+RTF_STYLESHEET_FILE =
+RTF_EXTENSIONS_FILE =
+#---------------------------------------------------------------------------
+# configuration options related to the man page output
+#---------------------------------------------------------------------------
+GENERATE_MAN = NO
+MAN_OUTPUT = man
+MAN_EXTENSION = .3
+MAN_LINKS = NO
+#---------------------------------------------------------------------------
+# configuration options related to the XML output
+#---------------------------------------------------------------------------
+GENERATE_XML = NO
+XML_OUTPUT = xml
+XML_SCHEMA =
+XML_DTD =
+XML_PROGRAMLISTING = YES
+#---------------------------------------------------------------------------
+# configuration options for the AutoGen Definitions output
+#---------------------------------------------------------------------------
+GENERATE_AUTOGEN_DEF = NO
+#---------------------------------------------------------------------------
+# configuration options related to the Perl module output
+#---------------------------------------------------------------------------
+GENERATE_PERLMOD = NO
+PERLMOD_LATEX = NO
+PERLMOD_PRETTY = YES
+PERLMOD_MAKEVAR_PREFIX =
+#---------------------------------------------------------------------------
+# Configuration options related to the preprocessor
+#---------------------------------------------------------------------------
+ENABLE_PREPROCESSING = YES
+MACRO_EXPANSION = YES
+EXPAND_ONLY_PREDEF = YES
+SEARCH_INCLUDES = YES
+INCLUDE_PATH =
+INCLUDE_FILE_PATTERNS =
+PREDEFINED = "YAML_DECLARE(type)=type"
+EXPAND_AS_DEFINED =
+SKIP_FUNCTION_MACROS = YES
+#---------------------------------------------------------------------------
+# Configuration::additions related to external references
+#---------------------------------------------------------------------------
+TAGFILES =
+GENERATE_TAGFILE =
+ALLEXTERNALS = NO
+EXTERNAL_GROUPS = YES
+PERL_PATH = /usr/bin/perl
+#---------------------------------------------------------------------------
+# Configuration options related to the dot tool
+#---------------------------------------------------------------------------
+CLASS_DIAGRAMS = NO
+HIDE_UNDOC_RELATIONS = YES
+HAVE_DOT = NO
+CLASS_GRAPH = YES
+COLLABORATION_GRAPH = YES
+GROUP_GRAPHS = YES
+UML_LOOK = NO
+TEMPLATE_RELATIONS = NO
+INCLUDE_GRAPH = YES
+INCLUDED_BY_GRAPH = YES
+CALL_GRAPH = NO
+GRAPHICAL_HIERARCHY = YES
+DIRECTORY_GRAPH = YES
+DOT_IMAGE_FORMAT = png
+DOT_PATH =
+DOTFILE_DIRS =
+MAX_DOT_GRAPH_WIDTH = 1024
+MAX_DOT_GRAPH_HEIGHT = 1024
+MAX_DOT_GRAPH_DEPTH = 0
+DOT_TRANSPARENT = NO
+DOT_MULTI_TARGETS = NO
+GENERATE_LEGEND = YES
+DOT_CLEANUP = YES
+#---------------------------------------------------------------------------
+# Configuration::additions related to the search engine
+#---------------------------------------------------------------------------
+SEARCHENGINE = NO
diff --git a/libyaml/docker/README.mkd b/libyaml/docker/README.mkd
new file mode 100644
index 0000000000000000000000000000000000000000..71c13e17cb12c6b2b83efe52bad404c9fcb0b33e
--- /dev/null
+++ b/libyaml/docker/README.mkd
@@ -0,0 +1,17 @@
+# LibYAML Dockerfiles
+
+This directory is a collection of dockerfiles that can be used when developing
+and testing LibYAML.
+
+The current list is supports:
+
+- Ubuntu 16.04
+- Ubuntu 14.04
+
+## Example Usage
+
+```bash
+$ docker pull ubuntu
+$ docker build -t libyaml-ubuntu:16.04 -f dockerfiles/ubuntu-16.04 .
+$ docker run -it libyaml-ubuntu:16.04 make test
+```
diff --git a/libyaml/docker/alpine-3.7 b/libyaml/docker/alpine-3.7
new file mode 100644
index 0000000000000000000000000000000000000000..ac2d625beda91dbd693ab9f555028e7164d52a29
--- /dev/null
+++ b/libyaml/docker/alpine-3.7
@@ -0,0 +1,26 @@
+# vim: ft=dockerfile
+FROM alpine:3.7
+MAINTAINER Ingy döt Net <ingy@ingy.net>
+
+RUN apk update && \
+ apk add --no-cache \
+ autoconf \
+ automake \
+ build-base \
+ cmake \
+ git \
+ libtool \
+ perl-dev && \
+ mkdir /libyaml
+
+COPY . /libyaml/
+WORKDIR /libyaml
+
+ENV LD_LIBRARY_PATH=/libyaml/src/.libs
+
+RUN ./bootstrap && \
+ ./configure && \
+ make && \
+ make install
+
+CMD ["bash"]
diff --git a/libyaml/docker/fedora-25 b/libyaml/docker/fedora-25
new file mode 100644
index 0000000000000000000000000000000000000000..36e58ab0186d11f4b94656e7cb253d2a52b613c1
--- /dev/null
+++ b/libyaml/docker/fedora-25
@@ -0,0 +1,26 @@
+# vim: ft=dockerfile
+FROM fedora:25
+MAINTAINER Ian Cordasco <graffatcolmingov@gmail.com>
+
+# NOTE(sigmavirus24): We need "perl-core" here for the "prove" binary
+# required by the test-all Makefile target
+RUN dnf install -y \
+ automake \
+ gcc \
+ git \
+ make \
+ libtool \
+ perl-core && \
+ mkdir /libyaml
+
+COPY . /libyaml/
+WORKDIR /libyaml
+
+ENV LD_LIBRARY_PATH=/libyaml/src/.libs
+
+RUN ./bootstrap && \
+ ./configure && \
+ make && \
+ make install
+
+CMD ["bash"]
diff --git a/libyaml/docker/ubuntu-14.04 b/libyaml/docker/ubuntu-14.04
new file mode 100644
index 0000000000000000000000000000000000000000..6a2b1346fca10667d42687a98386a5dfaf1052a5
--- /dev/null
+++ b/libyaml/docker/ubuntu-14.04
@@ -0,0 +1,29 @@
+# vim: ft=dockerfile
+FROM ubuntu:14.04
+MAINTAINER Ian Cordasco <graffatcolmingov@gmail.com>
+
+RUN apt-get update && \
+ apt-get install -y \
+ software-properties-common \
+ python-software-properties && \
+ add-apt-repository ppa:git-core/ppa && \
+ apt-get update && \
+ apt-get install -y \
+ autoconf \
+ build-essential \
+ git \
+ libtool && \
+ rm -rf /var/lib/apt/lists/* && \
+ mkdir /libyaml
+
+COPY . /libyaml/
+WORKDIR /libyaml
+
+ENV LD_LIBRARY_PATH=/libyaml/src/.libs
+
+RUN ./bootstrap && \
+ ./configure && \
+ make && \
+ make install
+
+CMD ["bash"]
diff --git a/libyaml/docker/ubuntu-16.04 b/libyaml/docker/ubuntu-16.04
new file mode 100644
index 0000000000000000000000000000000000000000..87b7afdfc20ebdcc2dd894fb622bf66082d71093
--- /dev/null
+++ b/libyaml/docker/ubuntu-16.04
@@ -0,0 +1,24 @@
+# vim: ft=dockerfile
+FROM ubuntu:16.04
+MAINTAINER Ian Cordasco <graffatcolmingov@gmail.com>
+
+RUN apt-get update && \
+ apt-get install -y \
+ autoconf \
+ build-essential \
+ git \
+ libtool && \
+ rm -rf /var/lib/apt/lists/* && \
+ mkdir /libyaml
+
+COPY . /libyaml/
+WORKDIR /libyaml
+
+ENV LD_LIBRARY_PATH=/libyaml/src/.libs
+
+RUN ./bootstrap && \
+ ./configure && \
+ make && \
+ make install
+
+CMD ["bash"]
diff --git a/libyaml/examples/anchors.yaml b/libyaml/examples/anchors.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..875585317000faac1a979034a703710379cfb64e
--- /dev/null
+++ b/libyaml/examples/anchors.yaml
@@ -0,0 +1,10 @@
+base: &base
+ name: Everyone has same name
+
+foo: &foo
+ <<: *base
+ age: 10
+
+bar: &bar
+ <<: *base
+ age: 20
diff --git a/libyaml/examples/array.yaml b/libyaml/examples/array.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..18efd12efbde50523034b6ae6c079c6a236152a3
--- /dev/null
+++ b/libyaml/examples/array.yaml
@@ -0,0 +1,2 @@
+- member
+- member2
diff --git a/libyaml/examples/global-tag.yaml b/libyaml/examples/global-tag.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..1180757d81cb6c1149dc3ac2838518d0ca86b39f
--- /dev/null
+++ b/libyaml/examples/global-tag.yaml
@@ -0,0 +1,14 @@
+%TAG ! tag:clarkevans.com,2002:
+--- !shape
+ # Use the ! handle for presenting
+ # tag:clarkevans.com,2002:circle
+- !circle
+ center: &ORIGIN {x: 73, y: 129}
+ radius: 7
+- !line
+ start: *ORIGIN
+ finish: { x: 89, y: 102 }
+- !label
+ start: *ORIGIN
+ color: 0xFFEEBB
+ text: Pretty vector drawing.
diff --git a/libyaml/examples/json.yaml b/libyaml/examples/json.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..7822ddc8342fa6259d666dead563c54fa3f6b9b7
--- /dev/null
+++ b/libyaml/examples/json.yaml
@@ -0,0 +1 @@
+{"key": ["value", 3]}
diff --git a/libyaml/examples/mapping.yaml b/libyaml/examples/mapping.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..53d256787c9f82e9bb1203d659d98eafd6890ae0
--- /dev/null
+++ b/libyaml/examples/mapping.yaml
@@ -0,0 +1,2 @@
+key: value
+other-key: other-value
diff --git a/libyaml/examples/numbers.yaml b/libyaml/examples/numbers.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..45d2bf01b2ff863130b7453cb0c443584dbd8e2c
--- /dev/null
+++ b/libyaml/examples/numbers.yaml
@@ -0,0 +1 @@
+[100, 12.5, -130, 1.3e+9]
diff --git a/libyaml/examples/strings.yaml b/libyaml/examples/strings.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..31b641f4f3cdc211808500329ab370d02152d788
--- /dev/null
+++ b/libyaml/examples/strings.yaml
@@ -0,0 +1,7 @@
+unqouted: string
+literal-block: |
+ This entire block of text will be the value of the 'literal-block' key,
+ with line breaks being preserved.
+folded: >
+ This entire block of text will be the value of 'folded', but this
+ time, all newlines will be replaced with a single space.
diff --git a/libyaml/examples/tags.yaml b/libyaml/examples/tags.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..3d5a010ac0a6e8154c7cc500a61f707cb1dd788e
--- /dev/null
+++ b/libyaml/examples/tags.yaml
@@ -0,0 +1,7 @@
+gif_file: !!binary |
+ R0lGODlhDAAMAIQAAP//9/X17unp5WZmZgAAAOfn515eXvPz7Y6OjuDg4J+fn5
+ OTk6enp56enmlpaWNjY6Ojo4SEhP/++f/++f/++f/++f/++f/++f/++f/++f/+
+ +f/++f/++f/++f/++f/++SH+Dk1hZGUgd2l0aCBHSU1QACwAAAAADAAMAAAFLC
+ AgjoEwnuNAFOhpEMTRiggcz4BNJHrv/zCFcLiwMWYNG84BwwEeECcgggoBADs=
+explicit_string: !!str 0.5
+python_tag: !!python/complex '1.0+2.0j'
diff --git a/libyaml/examples/yaml-version.yaml b/libyaml/examples/yaml-version.yaml
new file mode 100644
index 0000000000000000000000000000000000000000..122b5082b6a7203d91be14176094316571beb7a2
--- /dev/null
+++ b/libyaml/examples/yaml-version.yaml
@@ -0,0 +1,3 @@
+%YAML 1.1
+---
+[1, 2, 3]
diff --git a/libyaml/include/Makefile.am b/libyaml/include/Makefile.am
new file mode 100644
index 0000000000000000000000000000000000000000..3882a2f63dd525e3cd5eff64f6ecbe21bb320b2b
--- /dev/null
+++ b/libyaml/include/Makefile.am
@@ -0,0 +1,17 @@
+AM_CPPFLAGS = yaml.h
+DOXYGEN_CFG = $(top_srcdir)/doc/doxygen.cfg
+
+nobase_include_HEADERS = $(AM_CPPFLAGS)
+
+if DOXYGEN
+
+html: $(AM_CPPFLAGS) $(DOXYGEN_CFG)
+ PACKAGE=$(PACKAGE) VERSION=$(VERSION) top_srcdir=$(top_srcdir) top_builddir=$(top_builddir) doxygen $(DOXYGEN_CFG)
+
+endif
+
+maintainer-clean-local:
+ -rm -rf $(top_builddir)/doc/html
+
+dist-hook: html
+ cp -a $(top_builddir)/doc/html $(top_distdir)/doc
diff --git a/libyaml/include/config.h b/libyaml/include/config.h
new file mode 100644
index 0000000000000000000000000000000000000000..3cdb04fafc90f6b5a14b52a1c96654fd84aeed5c
--- /dev/null
+++ b/libyaml/include/config.h
@@ -0,0 +1,4 @@
+#define YAML_VERSION_MAJOR 0
+#define YAML_VERSION_MINOR 2
+#define YAML_VERSION_PATCH 5
+#define YAML_VERSION_STRING "0.2.5"
diff --git a/libyaml/include/yaml.h b/libyaml/include/yaml.h
new file mode 100644
index 0000000000000000000000000000000000000000..89050e4f7dc60c6f9fd606b849d1096d503d4991
--- /dev/null
+++ b/libyaml/include/yaml.h
@@ -0,0 +1,1985 @@
+/**
+ * @file yaml.h
+ * @brief Public interface for libyaml.
+ *
+ * Include the header file with the code:
+ * @code
+ * #include <yaml.h>
+ * @endcode
+ */
+
+#ifndef YAML_H
+#define YAML_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+/**
+ * @defgroup export Export Definitions
+ * @{
+ */
+
+/** The public API declaration. */
+
+#if defined(__MINGW32__)
+# define YAML_DECLARE(type) type
+#elif defined(_WIN32)
+# if defined(YAML_DECLARE_STATIC)
+# define YAML_DECLARE(type) type
+# elif defined(YAML_DECLARE_EXPORT)
+# define YAML_DECLARE(type) __declspec(dllexport) type
+# else
+# define YAML_DECLARE(type) __declspec(dllimport) type
+# endif
+#else
+# define YAML_DECLARE(type) type
+#endif
+
+/** @} */
+
+/**
+ * @defgroup version Version Information
+ * @{
+ */
+
+/**
+ * Get the library version as a string.
+ *
+ * @returns The function returns the pointer to a static string of the form
+ * @c "X.Y.Z", where @c X is the major version number, @c Y is a minor version
+ * number, and @c Z is the patch version number.
+ */
+
+YAML_DECLARE(const char *)
+yaml_get_version_string(void);
+
+/**
+ * Get the library version numbers.
+ *
+ * @param[out] major Major version number.
+ * @param[out] minor Minor version number.
+ * @param[out] patch Patch version number.
+ */
+
+YAML_DECLARE(void)
+yaml_get_version(int *major, int *minor, int *patch);
+
+/** @} */
+
+/**
+ * @defgroup basic Basic Types
+ * @{
+ */
+
+/** The character type (UTF-8 octet). */
+typedef unsigned char yaml_char_t;
+
+/** The version directive data. */
+typedef struct yaml_version_directive_s {
+ /** The major version number. */
+ int major;
+ /** The minor version number. */
+ int minor;
+} yaml_version_directive_t;
+
+/** The tag directive data. */
+typedef struct yaml_tag_directive_s {
+ /** The tag handle. */
+ yaml_char_t *handle;
+ /** The tag prefix. */
+ yaml_char_t *prefix;
+} yaml_tag_directive_t;
+
+/** The stream encoding. */
+typedef enum yaml_encoding_e {
+ /** Let the parser choose the encoding. */
+ YAML_ANY_ENCODING,
+ /** The default UTF-8 encoding. */
+ YAML_UTF8_ENCODING,
+ /** The UTF-16-LE encoding with BOM. */
+ YAML_UTF16LE_ENCODING,
+ /** The UTF-16-BE encoding with BOM. */
+ YAML_UTF16BE_ENCODING
+} yaml_encoding_t;
+
+/** Line break types. */
+
+typedef enum yaml_break_e {
+ /** Let the parser choose the break type. */
+ YAML_ANY_BREAK,
+ /** Use CR for line breaks (Mac style). */
+ YAML_CR_BREAK,
+ /** Use LN for line breaks (Unix style). */
+ YAML_LN_BREAK,
+ /** Use CR LN for line breaks (DOS style). */
+ YAML_CRLN_BREAK
+} yaml_break_t;
+
+/** Many bad things could happen with the parser and emitter. */
+typedef enum yaml_error_type_e {
+ /** No error is produced. */
+ YAML_NO_ERROR,
+
+ /** Cannot allocate or reallocate a block of memory. */
+ YAML_MEMORY_ERROR,
+
+ /** Cannot read or decode the input stream. */
+ YAML_READER_ERROR,
+ /** Cannot scan the input stream. */
+ YAML_SCANNER_ERROR,
+ /** Cannot parse the input stream. */
+ YAML_PARSER_ERROR,
+ /** Cannot compose a YAML document. */
+ YAML_COMPOSER_ERROR,
+
+ /** Cannot write to the output stream. */
+ YAML_WRITER_ERROR,
+ /** Cannot emit a YAML stream. */
+ YAML_EMITTER_ERROR
+} yaml_error_type_t;
+
+/** The pointer position. */
+typedef struct yaml_mark_s {
+ /** The position index. */
+ size_t index;
+
+ /** The position line. */
+ size_t line;
+
+ /** The position column. */
+ size_t column;
+} yaml_mark_t;
+
+/** @} */
+
+/**
+ * @defgroup styles Node Styles
+ * @{
+ */
+
+/** Scalar styles. */
+typedef enum yaml_scalar_style_e {
+ /** Let the emitter choose the style. */
+ YAML_ANY_SCALAR_STYLE,
+
+ /** The plain scalar style. */
+ YAML_PLAIN_SCALAR_STYLE,
+
+ /** The single-quoted scalar style. */
+ YAML_SINGLE_QUOTED_SCALAR_STYLE,
+ /** The double-quoted scalar style. */
+ YAML_DOUBLE_QUOTED_SCALAR_STYLE,
+
+ /** The literal scalar style. */
+ YAML_LITERAL_SCALAR_STYLE,
+ /** The folded scalar style. */
+ YAML_FOLDED_SCALAR_STYLE
+} yaml_scalar_style_t;
+
+/** Sequence styles. */
+typedef enum yaml_sequence_style_e {
+ /** Let the emitter choose the style. */
+ YAML_ANY_SEQUENCE_STYLE,
+
+ /** The block sequence style. */
+ YAML_BLOCK_SEQUENCE_STYLE,
+ /** The flow sequence style. */
+ YAML_FLOW_SEQUENCE_STYLE
+} yaml_sequence_style_t;
+
+/** Mapping styles. */
+typedef enum yaml_mapping_style_e {
+ /** Let the emitter choose the style. */
+ YAML_ANY_MAPPING_STYLE,
+
+ /** The block mapping style. */
+ YAML_BLOCK_MAPPING_STYLE,
+ /** The flow mapping style. */
+ YAML_FLOW_MAPPING_STYLE
+/* YAML_FLOW_SET_MAPPING_STYLE */
+} yaml_mapping_style_t;
+
+/** @} */
+
+/**
+ * @defgroup tokens Tokens
+ * @{
+ */
+
+/** Token types. */
+typedef enum yaml_token_type_e {
+ /** An empty token. */
+ YAML_NO_TOKEN,
+
+ /** A STREAM-START token. */
+ YAML_STREAM_START_TOKEN,
+ /** A STREAM-END token. */
+ YAML_STREAM_END_TOKEN,
+
+ /** A VERSION-DIRECTIVE token. */
+ YAML_VERSION_DIRECTIVE_TOKEN,
+ /** A TAG-DIRECTIVE token. */
+ YAML_TAG_DIRECTIVE_TOKEN,
+ /** A DOCUMENT-START token. */
+ YAML_DOCUMENT_START_TOKEN,
+ /** A DOCUMENT-END token. */
+ YAML_DOCUMENT_END_TOKEN,
+
+ /** A BLOCK-SEQUENCE-START token. */
+ YAML_BLOCK_SEQUENCE_START_TOKEN,
+ /** A BLOCK-MAPPING-START token. */
+ YAML_BLOCK_MAPPING_START_TOKEN,
+ /** A BLOCK-END token. */
+ YAML_BLOCK_END_TOKEN,
+
+ /** A FLOW-SEQUENCE-START token. */
+ YAML_FLOW_SEQUENCE_START_TOKEN,
+ /** A FLOW-SEQUENCE-END token. */
+ YAML_FLOW_SEQUENCE_END_TOKEN,
+ /** A FLOW-MAPPING-START token. */
+ YAML_FLOW_MAPPING_START_TOKEN,
+ /** A FLOW-MAPPING-END token. */
+ YAML_FLOW_MAPPING_END_TOKEN,
+
+ /** A BLOCK-ENTRY token. */
+ YAML_BLOCK_ENTRY_TOKEN,
+ /** A FLOW-ENTRY token. */
+ YAML_FLOW_ENTRY_TOKEN,
+ /** A KEY token. */
+ YAML_KEY_TOKEN,
+ /** A VALUE token. */
+ YAML_VALUE_TOKEN,
+
+ /** An ALIAS token. */
+ YAML_ALIAS_TOKEN,
+ /** An ANCHOR token. */
+ YAML_ANCHOR_TOKEN,
+ /** A TAG token. */
+ YAML_TAG_TOKEN,
+ /** A SCALAR token. */
+ YAML_SCALAR_TOKEN
+} yaml_token_type_t;
+
+/** The token structure. */
+typedef struct yaml_token_s {
+
+ /** The token type. */
+ yaml_token_type_t type;
+
+ /** The token data. */
+ union {
+
+ /** The stream start (for @c YAML_STREAM_START_TOKEN). */
+ struct {
+ /** The stream encoding. */
+ yaml_encoding_t encoding;
+ } stream_start;
+
+ /** The alias (for @c YAML_ALIAS_TOKEN). */
+ struct {
+ /** The alias value. */
+ yaml_char_t *value;
+ } alias;
+
+ /** The anchor (for @c YAML_ANCHOR_TOKEN). */
+ struct {
+ /** The anchor value. */
+ yaml_char_t *value;
+ } anchor;
+
+ /** The tag (for @c YAML_TAG_TOKEN). */
+ struct {
+ /** The tag handle. */
+ yaml_char_t *handle;
+ /** The tag suffix. */
+ yaml_char_t *suffix;
+ } tag;
+
+ /** The scalar value (for @c YAML_SCALAR_TOKEN). */
+ struct {
+ /** The scalar value. */
+ yaml_char_t *value;
+ /** The length of the scalar value. */
+ size_t length;
+ /** The scalar style. */
+ yaml_scalar_style_t style;
+ } scalar;
+
+ /** The version directive (for @c YAML_VERSION_DIRECTIVE_TOKEN). */
+ struct {
+ /** The major version number. */
+ int major;
+ /** The minor version number. */
+ int minor;
+ } version_directive;
+
+ /** The tag directive (for @c YAML_TAG_DIRECTIVE_TOKEN). */
+ struct {
+ /** The tag handle. */
+ yaml_char_t *handle;
+ /** The tag prefix. */
+ yaml_char_t *prefix;
+ } tag_directive;
+
+ } data;
+
+ /** The beginning of the token. */
+ yaml_mark_t start_mark;
+ /** The end of the token. */
+ yaml_mark_t end_mark;
+
+} yaml_token_t;
+
+/**
+ * Free any memory allocated for a token object.
+ *
+ * @param[in,out] token A token object.
+ */
+
+YAML_DECLARE(void)
+yaml_token_delete(yaml_token_t *token);
+
+/** @} */
+
+/**
+ * @defgroup events Events
+ * @{
+ */
+
+/** Event types. */
+typedef enum yaml_event_type_e {
+ /** An empty event. */
+ YAML_NO_EVENT,
+
+ /** A STREAM-START event. */
+ YAML_STREAM_START_EVENT,
+ /** A STREAM-END event. */
+ YAML_STREAM_END_EVENT,
+
+ /** A DOCUMENT-START event. */
+ YAML_DOCUMENT_START_EVENT,
+ /** A DOCUMENT-END event. */
+ YAML_DOCUMENT_END_EVENT,
+
+ /** An ALIAS event. */
+ YAML_ALIAS_EVENT,
+ /** A SCALAR event. */
+ YAML_SCALAR_EVENT,
+
+ /** A SEQUENCE-START event. */
+ YAML_SEQUENCE_START_EVENT,
+ /** A SEQUENCE-END event. */
+ YAML_SEQUENCE_END_EVENT,
+
+ /** A MAPPING-START event. */
+ YAML_MAPPING_START_EVENT,
+ /** A MAPPING-END event. */
+ YAML_MAPPING_END_EVENT
+} yaml_event_type_t;
+
+/** The event structure. */
+typedef struct yaml_event_s {
+
+ /** The event type. */
+ yaml_event_type_t type;
+
+ /** The event data. */
+ union {
+
+ /** The stream parameters (for @c YAML_STREAM_START_EVENT). */
+ struct {
+ /** The document encoding. */
+ yaml_encoding_t encoding;
+ } stream_start;
+
+ /** The document parameters (for @c YAML_DOCUMENT_START_EVENT). */
+ struct {
+ /** The version directive. */
+ yaml_version_directive_t *version_directive;
+
+ /** The list of tag directives. */
+ struct {
+ /** The beginning of the tag directives list. */
+ yaml_tag_directive_t *start;
+ /** The end of the tag directives list. */
+ yaml_tag_directive_t *end;
+ } tag_directives;
+
+ /** Is the document indicator implicit? */
+ int implicit;
+ } document_start;
+
+ /** The document end parameters (for @c YAML_DOCUMENT_END_EVENT). */
+ struct {
+ /** Is the document end indicator implicit? */
+ int implicit;
+ } document_end;
+
+ /** The alias parameters (for @c YAML_ALIAS_EVENT). */
+ struct {
+ /** The anchor. */
+ yaml_char_t *anchor;
+ } alias;
+
+ /** The scalar parameters (for @c YAML_SCALAR_EVENT). */
+ struct {
+ /** The anchor. */
+ yaml_char_t *anchor;
+ /** The tag. */
+ yaml_char_t *tag;
+ /** The scalar value. */
+ yaml_char_t *value;
+ /** The length of the scalar value. */
+ size_t length;
+ /** Is the tag optional for the plain style? */
+ int plain_implicit;
+ /** Is the tag optional for any non-plain style? */
+ int quoted_implicit;
+ /** The scalar style. */
+ yaml_scalar_style_t style;
+ } scalar;
+
+ /** The sequence parameters (for @c YAML_SEQUENCE_START_EVENT). */
+ struct {
+ /** The anchor. */
+ yaml_char_t *anchor;
+ /** The tag. */
+ yaml_char_t *tag;
+ /** Is the tag optional? */
+ int implicit;
+ /** The sequence style. */
+ yaml_sequence_style_t style;
+ } sequence_start;
+
+ /** The mapping parameters (for @c YAML_MAPPING_START_EVENT). */
+ struct {
+ /** The anchor. */
+ yaml_char_t *anchor;
+ /** The tag. */
+ yaml_char_t *tag;
+ /** Is the tag optional? */
+ int implicit;
+ /** The mapping style. */
+ yaml_mapping_style_t style;
+ } mapping_start;
+
+ } data;
+
+ /** The beginning of the event. */
+ yaml_mark_t start_mark;
+ /** The end of the event. */
+ yaml_mark_t end_mark;
+
+} yaml_event_t;
+
+/**
+ * Create the STREAM-START event.
+ *
+ * @param[out] event An empty event object.
+ * @param[in] encoding The stream encoding.
+ *
+ * @returns @c 1 if the function succeeded, @c 0 on error.
+ */
+
+YAML_DECLARE(int)
+yaml_stream_start_event_initialize(yaml_event_t *event,
+ yaml_encoding_t encoding);
+
+/**
+ * Create the STREAM-END event.
+ *
+ * @param[out] event An empty event object.
+ *
+ * @returns @c 1 if the function succeeded, @c 0 on error.
+ */
+
+YAML_DECLARE(int)
+yaml_stream_end_event_initialize(yaml_event_t *event);
+
+/**
+ * Create the DOCUMENT-START event.
+ *
+ * The @a implicit argument is considered as a stylistic parameter and may be
+ * ignored by the emitter.
+ *
+ * @param[out] event An empty event object.
+ * @param[in] version_directive The %YAML directive value or
+ * @c NULL.
+ * @param[in] tag_directives_start The beginning of the %TAG
+ * directives list.
+ * @param[in] tag_directives_end The end of the %TAG directives
+ * list.
+ * @param[in] implicit If the document start indicator is
+ * implicit.
+ *
+ * @returns @c 1 if the function succeeded, @c 0 on error.
+ */
+
+YAML_DECLARE(int)
+yaml_document_start_event_initialize(yaml_event_t *event,
+ yaml_version_directive_t *version_directive,
+ yaml_tag_directive_t *tag_directives_start,
+ yaml_tag_directive_t *tag_directives_end,
+ int implicit);
+
+/**
+ * Create the DOCUMENT-END event.
+ *
+ * The @a implicit argument is considered as a stylistic parameter and may be
+ * ignored by the emitter.
+ *
+ * @param[out] event An empty event object.
+ * @param[in] implicit If the document end indicator is implicit.
+ *
+ * @returns @c 1 if the function succeeded, @c 0 on error.
+ */
+
+YAML_DECLARE(int)
+yaml_document_end_event_initialize(yaml_event_t *event, int implicit);
+
+/**
+ * Create an ALIAS event.
+ *
+ * @param[out] event An empty event object.
+ * @param[in] anchor The anchor value.
+ *
+ * @returns @c 1 if the function succeeded, @c 0 on error.
+ */
+
+YAML_DECLARE(int)
+yaml_alias_event_initialize(yaml_event_t *event, const yaml_char_t *anchor);
+
+/**
+ * Create a SCALAR event.
+ *
+ * The @a style argument may be ignored by the emitter.
+ *
+ * Either the @a tag attribute or one of the @a plain_implicit and
+ * @a quoted_implicit flags must be set.
+ *
+ * @param[out] event An empty event object.
+ * @param[in] anchor The scalar anchor or @c NULL.
+ * @param[in] tag The scalar tag or @c NULL.
+ * @param[in] value The scalar value.
+ * @param[in] length The length of the scalar value.
+ * @param[in] plain_implicit If the tag may be omitted for the plain
+ * style.
+ * @param[in] quoted_implicit If the tag may be omitted for any
+ * non-plain style.
+ * @param[in] style The scalar style.
+ *
+ * @returns @c 1 if the function succeeded, @c 0 on error.
+ */
+
+YAML_DECLARE(int)
+yaml_scalar_event_initialize(yaml_event_t *event,
+ const yaml_char_t *anchor, const yaml_char_t *tag,
+ const yaml_char_t *value, int length,
+ int plain_implicit, int quoted_implicit,
+ yaml_scalar_style_t style);
+
+/**
+ * Create a SEQUENCE-START event.
+ *
+ * The @a style argument may be ignored by the emitter.
+ *
+ * Either the @a tag attribute or the @a implicit flag must be set.
+ *
+ * @param[out] event An empty event object.
+ * @param[in] anchor The sequence anchor or @c NULL.
+ * @param[in] tag The sequence tag or @c NULL.
+ * @param[in] implicit If the tag may be omitted.
+ * @param[in] style The sequence style.
+ *
+ * @returns @c 1 if the function succeeded, @c 0 on error.
+ */
+
+YAML_DECLARE(int)
+yaml_sequence_start_event_initialize(yaml_event_t *event,
+ const yaml_char_t *anchor, const yaml_char_t *tag, int implicit,
+ yaml_sequence_style_t style);
+
+/**
+ * Create a SEQUENCE-END event.
+ *
+ * @param[out] event An empty event object.
+ *
+ * @returns @c 1 if the function succeeded, @c 0 on error.
+ */
+
+YAML_DECLARE(int)
+yaml_sequence_end_event_initialize(yaml_event_t *event);
+
+/**
+ * Create a MAPPING-START event.
+ *
+ * The @a style argument may be ignored by the emitter.
+ *
+ * Either the @a tag attribute or the @a implicit flag must be set.
+ *
+ * @param[out] event An empty event object.
+ * @param[in] anchor The mapping anchor or @c NULL.
+ * @param[in] tag The mapping tag or @c NULL.
+ * @param[in] implicit If the tag may be omitted.
+ * @param[in] style The mapping style.
+ *
+ * @returns @c 1 if the function succeeded, @c 0 on error.
+ */
+
+YAML_DECLARE(int)
+yaml_mapping_start_event_initialize(yaml_event_t *event,
+ const yaml_char_t *anchor, const yaml_char_t *tag, int implicit,
+ yaml_mapping_style_t style);
+
+/**
+ * Create a MAPPING-END event.
+ *
+ * @param[out] event An empty event object.
+ *
+ * @returns @c 1 if the function succeeded, @c 0 on error.
+ */
+
+YAML_DECLARE(int)
+yaml_mapping_end_event_initialize(yaml_event_t *event);
+
+/**
+ * Free any memory allocated for an event object.
+ *
+ * @param[in,out] event An event object.
+ */
+
+YAML_DECLARE(void)
+yaml_event_delete(yaml_event_t *event);
+
+/** @} */
+
+/**
+ * @defgroup nodes Nodes
+ * @{
+ */
+
+/** The tag @c !!null with the only possible value: @c null. */
+#define YAML_NULL_TAG "tag:yaml.org,2002:null"
+/** The tag @c !!bool with the values: @c true and @c false. */
+#define YAML_BOOL_TAG "tag:yaml.org,2002:bool"
+/** The tag @c !!str for string values. */
+#define YAML_STR_TAG "tag:yaml.org,2002:str"
+/** The tag @c !!int for integer values. */
+#define YAML_INT_TAG "tag:yaml.org,2002:int"
+/** The tag @c !!float for float values. */
+#define YAML_FLOAT_TAG "tag:yaml.org,2002:float"
+/** The tag @c !!timestamp for date and time values. */
+#define YAML_TIMESTAMP_TAG "tag:yaml.org,2002:timestamp"
+
+/** The tag @c !!seq is used to denote sequences. */
+#define YAML_SEQ_TAG "tag:yaml.org,2002:seq"
+/** The tag @c !!map is used to denote mapping. */
+#define YAML_MAP_TAG "tag:yaml.org,2002:map"
+
+/** The default scalar tag is @c !!str. */
+#define YAML_DEFAULT_SCALAR_TAG YAML_STR_TAG
+/** The default sequence tag is @c !!seq. */
+#define YAML_DEFAULT_SEQUENCE_TAG YAML_SEQ_TAG
+/** The default mapping tag is @c !!map. */
+#define YAML_DEFAULT_MAPPING_TAG YAML_MAP_TAG
+
+/** Node types. */
+typedef enum yaml_node_type_e {
+ /** An empty node. */
+ YAML_NO_NODE,
+
+ /** A scalar node. */
+ YAML_SCALAR_NODE,
+ /** A sequence node. */
+ YAML_SEQUENCE_NODE,
+ /** A mapping node. */
+ YAML_MAPPING_NODE
+} yaml_node_type_t;
+
+/** The forward definition of a document node structure. */
+typedef struct yaml_node_s yaml_node_t;
+
+/** An element of a sequence node. */
+typedef int yaml_node_item_t;
+
+/** An element of a mapping node. */
+typedef struct yaml_node_pair_s {
+ /** The key of the element. */
+ int key;
+ /** The value of the element. */
+ int value;
+} yaml_node_pair_t;
+
+/** The node structure. */
+struct yaml_node_s {
+
+ /** The node type. */
+ yaml_node_type_t type;
+
+ /** The node tag. */
+ yaml_char_t *tag;
+
+ /** The node data. */
+ union {
+
+ /** The scalar parameters (for @c YAML_SCALAR_NODE). */
+ struct {
+ /** The scalar value. */
+ yaml_char_t *value;
+ /** The length of the scalar value. */
+ size_t length;
+ /** The scalar style. */
+ yaml_scalar_style_t style;
+ } scalar;
+
+ /** The sequence parameters (for @c YAML_SEQUENCE_NODE). */
+ struct {
+ /** The stack of sequence items. */
+ struct {
+ /** The beginning of the stack. */
+ yaml_node_item_t *start;
+ /** The end of the stack. */
+ yaml_node_item_t *end;
+ /** The top of the stack. */
+ yaml_node_item_t *top;
+ } items;
+ /** The sequence style. */
+ yaml_sequence_style_t style;
+ } sequence;
+
+ /** The mapping parameters (for @c YAML_MAPPING_NODE). */
+ struct {
+ /** The stack of mapping pairs (key, value). */
+ struct {
+ /** The beginning of the stack. */
+ yaml_node_pair_t *start;
+ /** The end of the stack. */
+ yaml_node_pair_t *end;
+ /** The top of the stack. */
+ yaml_node_pair_t *top;
+ } pairs;
+ /** The mapping style. */
+ yaml_mapping_style_t style;
+ } mapping;
+
+ } data;
+
+ /** The beginning of the node. */
+ yaml_mark_t start_mark;
+ /** The end of the node. */
+ yaml_mark_t end_mark;
+
+};
+
+/** The document structure. */
+typedef struct yaml_document_s {
+
+ /** The document nodes. */
+ struct {
+ /** The beginning of the stack. */
+ yaml_node_t *start;
+ /** The end of the stack. */
+ yaml_node_t *end;
+ /** The top of the stack. */
+ yaml_node_t *top;
+ } nodes;
+
+ /** The version directive. */
+ yaml_version_directive_t *version_directive;
+
+ /** The list of tag directives. */
+ struct {
+ /** The beginning of the tag directives list. */
+ yaml_tag_directive_t *start;
+ /** The end of the tag directives list. */
+ yaml_tag_directive_t *end;
+ } tag_directives;
+
+ /** Is the document start indicator implicit? */
+ int start_implicit;
+ /** Is the document end indicator implicit? */
+ int end_implicit;
+
+ /** The beginning of the document. */
+ yaml_mark_t start_mark;
+ /** The end of the document. */
+ yaml_mark_t end_mark;
+
+} yaml_document_t;
+
+/**
+ * Create a YAML document.
+ *
+ * @param[out] document An empty document object.
+ * @param[in] version_directive The %YAML directive value or
+ * @c NULL.
+ * @param[in] tag_directives_start The beginning of the %TAG
+ * directives list.
+ * @param[in] tag_directives_end The end of the %TAG directives
+ * list.
+ * @param[in] start_implicit If the document start indicator is
+ * implicit.
+ * @param[in] end_implicit If the document end indicator is
+ * implicit.
+ *
+ * @returns @c 1 if the function succeeded, @c 0 on error.
+ */
+
+YAML_DECLARE(int)
+yaml_document_initialize(yaml_document_t *document,
+ yaml_version_directive_t *version_directive,
+ yaml_tag_directive_t *tag_directives_start,
+ yaml_tag_directive_t *tag_directives_end,
+ int start_implicit, int end_implicit);
+
+/**
+ * Delete a YAML document and all its nodes.
+ *
+ * @param[in,out] document A document object.
+ */
+
+YAML_DECLARE(void)
+yaml_document_delete(yaml_document_t *document);
+
+/**
+ * Get a node of a YAML document.
+ *
+ * The pointer returned by this function is valid until any of the functions
+ * modifying the documents are called.
+ *
+ * @param[in] document A document object.
+ * @param[in] index The node id.
+ *
+ * @returns the node objct or @c NULL if @c node_id is out of range.
+ */
+
+YAML_DECLARE(yaml_node_t *)
+yaml_document_get_node(yaml_document_t *document, int index);
+
+/**
+ * Get the root of a YAML document node.
+ *
+ * The root object is the first object added to the document.
+ *
+ * The pointer returned by this function is valid until any of the functions
+ * modifying the documents are called.
+ *
+ * An empty document produced by the parser signifies the end of a YAML
+ * stream.
+ *
+ * @param[in] document A document object.
+ *
+ * @returns the node object or @c NULL if the document is empty.
+ */
+
+YAML_DECLARE(yaml_node_t *)
+yaml_document_get_root_node(yaml_document_t *document);
+
+/**
+ * Create a SCALAR node and attach it to the document.
+ *
+ * The @a style argument may be ignored by the emitter.
+ *
+ * @param[in,out] document A document object.
+ * @param[in] tag The scalar tag.
+ * @param[in] value The scalar value.
+ * @param[in] length The length of the scalar value.
+ * @param[in] style The scalar style.
+ *
+ * @returns the node id or @c 0 on error.
+ */
+
+YAML_DECLARE(int)
+yaml_document_add_scalar(yaml_document_t *document,
+ const yaml_char_t *tag, const yaml_char_t *value, int length,
+ yaml_scalar_style_t style);
+
+/**
+ * Create a SEQUENCE node and attach it to the document.
+ *
+ * The @a style argument may be ignored by the emitter.
+ *
+ * @param[in,out] document A document object.
+ * @param[in] tag The sequence tag.
+ * @param[in] style The sequence style.
+ *
+ * @returns the node id or @c 0 on error.
+ */
+
+YAML_DECLARE(int)
+yaml_document_add_sequence(yaml_document_t *document,
+ const yaml_char_t *tag, yaml_sequence_style_t style);
+
+/**
+ * Create a MAPPING node and attach it to the document.
+ *
+ * The @a style argument may be ignored by the emitter.
+ *
+ * @param[in,out] document A document object.
+ * @param[in] tag The sequence tag.
+ * @param[in] style The sequence style.
+ *
+ * @returns the node id or @c 0 on error.
+ */
+
+YAML_DECLARE(int)
+yaml_document_add_mapping(yaml_document_t *document,
+ const yaml_char_t *tag, yaml_mapping_style_t style);
+
+/**
+ * Add an item to a SEQUENCE node.
+ *
+ * @param[in,out] document A document object.
+ * @param[in] sequence The sequence node id.
+ * @param[in] item The item node id.
+ *
+ * @returns @c 1 if the function succeeded, @c 0 on error.
+ */
+
+YAML_DECLARE(int)
+yaml_document_append_sequence_item(yaml_document_t *document,
+ int sequence, int item);
+
+/**
+ * Add a pair of a key and a value to a MAPPING node.
+ *
+ * @param[in,out] document A document object.
+ * @param[in] mapping The mapping node id.
+ * @param[in] key The key node id.
+ * @param[in] value The value node id.
+ *
+ * @returns @c 1 if the function succeeded, @c 0 on error.
+ */
+
+YAML_DECLARE(int)
+yaml_document_append_mapping_pair(yaml_document_t *document,
+ int mapping, int key, int value);
+
+/** @} */
+
+/**
+ * @defgroup parser Parser Definitions
+ * @{
+ */
+
+/**
+ * The prototype of a read handler.
+ *
+ * The read handler is called when the parser needs to read more bytes from the
+ * source. The handler should write not more than @a size bytes to the @a
+ * buffer. The number of written bytes should be set to the @a length variable.
+ *
+ * @param[in,out] data A pointer to an application data specified by
+ * yaml_parser_set_input().
+ * @param[out] buffer The buffer to write the data from the source.
+ * @param[in] size The size of the buffer.
+ * @param[out] size_read The actual number of bytes read from the source.
+ *
+ * @returns On success, the handler should return @c 1. If the handler failed,
+ * the returned value should be @c 0. On EOF, the handler should set the
+ * @a size_read to @c 0 and return @c 1.
+ */
+
+typedef int yaml_read_handler_t(void *data, unsigned char *buffer, size_t size,
+ size_t *size_read);
+
+/**
+ * This structure holds information about a potential simple key.
+ */
+
+typedef struct yaml_simple_key_s {
+ /** Is a simple key possible? */
+ int possible;
+
+ /** Is a simple key required? */
+ int required;
+
+ /** The number of the token. */
+ size_t token_number;
+
+ /** The position mark. */
+ yaml_mark_t mark;
+} yaml_simple_key_t;
+
+/**
+ * The states of the parser.
+ */
+typedef enum yaml_parser_state_e {
+ /** Expect STREAM-START. */
+ YAML_PARSE_STREAM_START_STATE,
+ /** Expect the beginning of an implicit document. */
+ YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE,
+ /** Expect DOCUMENT-START. */
+ YAML_PARSE_DOCUMENT_START_STATE,
+ /** Expect the content of a document. */
+ YAML_PARSE_DOCUMENT_CONTENT_STATE,
+ /** Expect DOCUMENT-END. */
+ YAML_PARSE_DOCUMENT_END_STATE,
+
+ /** Expect a block node. */
+ YAML_PARSE_BLOCK_NODE_STATE,
+ /** Expect a block node or indentless sequence. */
+ YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE,
+ /** Expect a flow node. */
+ YAML_PARSE_FLOW_NODE_STATE,
+ /** Expect the first entry of a block sequence. */
+ YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE,
+ /** Expect an entry of a block sequence. */
+ YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE,
+
+ /** Expect an entry of an indentless sequence. */
+ YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE,
+ /** Expect the first key of a block mapping. */
+ YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE,
+ /** Expect a block mapping key. */
+ YAML_PARSE_BLOCK_MAPPING_KEY_STATE,
+ /** Expect a block mapping value. */
+ YAML_PARSE_BLOCK_MAPPING_VALUE_STATE,
+ /** Expect the first entry of a flow sequence. */
+ YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE,
+
+ /** Expect an entry of a flow sequence. */
+ YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE,
+ /** Expect a key of an ordered mapping. */
+ YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE,
+ /** Expect a value of an ordered mapping. */
+ YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE,
+ /** Expect the and of an ordered mapping entry. */
+ YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE,
+ /** Expect the first key of a flow mapping. */
+ YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE,
+ /** Expect a key of a flow mapping. */
+
+ YAML_PARSE_FLOW_MAPPING_KEY_STATE,
+ /** Expect a value of a flow mapping. */
+ YAML_PARSE_FLOW_MAPPING_VALUE_STATE,
+ /** Expect an empty value of a flow mapping. */
+ YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE,
+ /** Expect nothing. */
+ YAML_PARSE_END_STATE
+} yaml_parser_state_t;
+
+/**
+ * This structure holds aliases data.
+ */
+
+typedef struct yaml_alias_data_s {
+ /** The anchor. */
+ yaml_char_t *anchor;
+ /** The node id. */
+ int index;
+ /** The anchor mark. */
+ yaml_mark_t mark;
+} yaml_alias_data_t;
+
+/**
+ * The parser structure.
+ *
+ * All members are internal. Manage the structure using the @c yaml_parser_
+ * family of functions.
+ */
+
+typedef struct yaml_parser_s {
+
+ /**
+ * @name Error handling
+ * @{
+ */
+
+ /** Error type. */
+ yaml_error_type_t error;
+ /** Error description. */
+ const char *problem;
+ /** The byte about which the problem occured. */
+ size_t problem_offset;
+ /** The problematic value (@c -1 is none). */
+ int problem_value;
+ /** The problem position. */
+ yaml_mark_t problem_mark;
+ /** The error context. */
+ const char *context;
+ /** The context position. */
+ yaml_mark_t context_mark;
+
+ /**
+ * @}
+ */
+
+ /**
+ * @name Reader stuff
+ * @{
+ */
+
+ /** Read handler. */
+ yaml_read_handler_t *read_handler;
+
+ /** A pointer for passing to the read handler. */
+ void *read_handler_data;
+
+ /** Standard (string or file) input data. */
+ union {
+ /** String input data. */
+ struct {
+ /** The string start pointer. */
+ const unsigned char *start;
+ /** The string end pointer. */
+ const unsigned char *end;
+ /** The string current position. */
+ const unsigned char *current;
+ } string;
+
+ /** File input data. */
+ FILE *file;
+ } input;
+
+ /** EOF flag */
+ int eof;
+
+ /** The working buffer. */
+ struct {
+ /** The beginning of the buffer. */
+ yaml_char_t *start;
+ /** The end of the buffer. */
+ yaml_char_t *end;
+ /** The current position of the buffer. */
+ yaml_char_t *pointer;
+ /** The last filled position of the buffer. */
+ yaml_char_t *last;
+ } buffer;
+
+ /* The number of unread characters in the buffer. */
+ size_t unread;
+
+ /** The raw buffer. */
+ struct {
+ /** The beginning of the buffer. */
+ unsigned char *start;
+ /** The end of the buffer. */
+ unsigned char *end;
+ /** The current position of the buffer. */
+ unsigned char *pointer;
+ /** The last filled position of the buffer. */
+ unsigned char *last;
+ } raw_buffer;
+
+ /** The input encoding. */
+ yaml_encoding_t encoding;
+
+ /** The offset of the current position (in bytes). */
+ size_t offset;
+
+ /** The mark of the current position. */
+ yaml_mark_t mark;
+
+ /**
+ * @}
+ */
+
+ /**
+ * @name Scanner stuff
+ * @{
+ */
+
+ /** Have we started to scan the input stream? */
+ int stream_start_produced;
+
+ /** Have we reached the end of the input stream? */
+ int stream_end_produced;
+
+ /** The number of unclosed '[' and '{' indicators. */
+ int flow_level;
+
+ /** The tokens queue. */
+ struct {
+ /** The beginning of the tokens queue. */
+ yaml_token_t *start;
+ /** The end of the tokens queue. */
+ yaml_token_t *end;
+ /** The head of the tokens queue. */
+ yaml_token_t *head;
+ /** The tail of the tokens queue. */
+ yaml_token_t *tail;
+ } tokens;
+
+ /** The number of tokens fetched from the queue. */
+ size_t tokens_parsed;
+
+ /** Does the tokens queue contain a token ready for dequeueing. */
+ int token_available;
+
+ /** The indentation levels stack. */
+ struct {
+ /** The beginning of the stack. */
+ int *start;
+ /** The end of the stack. */
+ int *end;
+ /** The top of the stack. */
+ int *top;
+ } indents;
+
+ /** The current indentation level. */
+ int indent;
+
+ /** May a simple key occur at the current position? */
+ int simple_key_allowed;
+
+ /** The stack of simple keys. */
+ struct {
+ /** The beginning of the stack. */
+ yaml_simple_key_t *start;
+ /** The end of the stack. */
+ yaml_simple_key_t *end;
+ /** The top of the stack. */
+ yaml_simple_key_t *top;
+ } simple_keys;
+
+ /**
+ * @}
+ */
+
+ /**
+ * @name Parser stuff
+ * @{
+ */
+
+ /** The parser states stack. */
+ struct {
+ /** The beginning of the stack. */
+ yaml_parser_state_t *start;
+ /** The end of the stack. */
+ yaml_parser_state_t *end;
+ /** The top of the stack. */
+ yaml_parser_state_t *top;
+ } states;
+
+ /** The current parser state. */
+ yaml_parser_state_t state;
+
+ /** The stack of marks. */
+ struct {
+ /** The beginning of the stack. */
+ yaml_mark_t *start;
+ /** The end of the stack. */
+ yaml_mark_t *end;
+ /** The top of the stack. */
+ yaml_mark_t *top;
+ } marks;
+
+ /** The list of TAG directives. */
+ struct {
+ /** The beginning of the list. */
+ yaml_tag_directive_t *start;
+ /** The end of the list. */
+ yaml_tag_directive_t *end;
+ /** The top of the list. */
+ yaml_tag_directive_t *top;
+ } tag_directives;
+
+ /**
+ * @}
+ */
+
+ /**
+ * @name Dumper stuff
+ * @{
+ */
+
+ /** The alias data. */
+ struct {
+ /** The beginning of the list. */
+ yaml_alias_data_t *start;
+ /** The end of the list. */
+ yaml_alias_data_t *end;
+ /** The top of the list. */
+ yaml_alias_data_t *top;
+ } aliases;
+
+ /** The currently parsed document. */
+ yaml_document_t *document;
+
+ /**
+ * @}
+ */
+
+} yaml_parser_t;
+
+/**
+ * Initialize a parser.
+ *
+ * This function creates a new parser object. An application is responsible
+ * for destroying the object using the yaml_parser_delete() function.
+ *
+ * @param[out] parser An empty parser object.
+ *
+ * @returns @c 1 if the function succeeded, @c 0 on error.
+ */
+
+YAML_DECLARE(int)
+yaml_parser_initialize(yaml_parser_t *parser);
+
+/**
+ * Destroy a parser.
+ *
+ * @param[in,out] parser A parser object.
+ */
+
+YAML_DECLARE(void)
+yaml_parser_delete(yaml_parser_t *parser);
+
+/**
+ * Set a string input.
+ *
+ * Note that the @a input pointer must be valid while the @a parser object
+ * exists. The application is responsible for destroing @a input after
+ * destroying the @a parser.
+ *
+ * @param[in,out] parser A parser object.
+ * @param[in] input A source data.
+ * @param[in] size The length of the source data in bytes.
+ */
+
+YAML_DECLARE(void)
+yaml_parser_set_input_string(yaml_parser_t *parser,
+ const unsigned char *input, size_t size);
+
+/**
+ * Set a file input.
+ *
+ * @a file should be a file object open for reading. The application is
+ * responsible for closing the @a file.
+ *
+ * @param[in,out] parser A parser object.
+ * @param[in] file An open file.
+ */
+
+YAML_DECLARE(void)
+yaml_parser_set_input_file(yaml_parser_t *parser, FILE *file);
+
+/**
+ * Set a generic input handler.
+ *
+ * @param[in,out] parser A parser object.
+ * @param[in] handler A read handler.
+ * @param[in] data Any application data for passing to the read
+ * handler.
+ */
+
+YAML_DECLARE(void)
+yaml_parser_set_input(yaml_parser_t *parser,
+ yaml_read_handler_t *handler, void *data);
+
+/**
+ * Set the source encoding.
+ *
+ * @param[in,out] parser A parser object.
+ * @param[in] encoding The source encoding.
+ */
+
+YAML_DECLARE(void)
+yaml_parser_set_encoding(yaml_parser_t *parser, yaml_encoding_t encoding);
+
+/**
+ * Scan the input stream and produce the next token.
+ *
+ * Call the function subsequently to produce a sequence of tokens corresponding
+ * to the input stream. The initial token has the type
+ * @c YAML_STREAM_START_TOKEN while the ending token has the type
+ * @c YAML_STREAM_END_TOKEN.
+ *
+ * An application is responsible for freeing any buffers associated with the
+ * produced token object using the @c yaml_token_delete function.
+ *
+ * An application must not alternate the calls of yaml_parser_scan() with the
+ * calls of yaml_parser_parse() or yaml_parser_load(). Doing this will break
+ * the parser.
+ *
+ * @param[in,out] parser A parser object.
+ * @param[out] token An empty token object.
+ *
+ * @returns @c 1 if the function succeeded, @c 0 on error.
+ */
+
+YAML_DECLARE(int)
+yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token);
+
+/**
+ * Parse the input stream and produce the next parsing event.
+ *
+ * Call the function subsequently to produce a sequence of events corresponding
+ * to the input stream. The initial event has the type
+ * @c YAML_STREAM_START_EVENT while the ending event has the type
+ * @c YAML_STREAM_END_EVENT.
+ *
+ * An application is responsible for freeing any buffers associated with the
+ * produced event object using the yaml_event_delete() function.
+ *
+ * An application must not alternate the calls of yaml_parser_parse() with the
+ * calls of yaml_parser_scan() or yaml_parser_load(). Doing this will break the
+ * parser.
+ *
+ * @param[in,out] parser A parser object.
+ * @param[out] event An empty event object.
+ *
+ * @returns @c 1 if the function succeeded, @c 0 on error.
+ */
+
+YAML_DECLARE(int)
+yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event);
+
+/**
+ * Parse the input stream and produce the next YAML document.
+ *
+ * Call this function subsequently to produce a sequence of documents
+ * constituting the input stream.
+ *
+ * If the produced document has no root node, it means that the document
+ * end has been reached.
+ *
+ * An application is responsible for freeing any data associated with the
+ * produced document object using the yaml_document_delete() function.
+ *
+ * An application must not alternate the calls of yaml_parser_load() with the
+ * calls of yaml_parser_scan() or yaml_parser_parse(). Doing this will break
+ * the parser.
+ *
+ * @param[in,out] parser A parser object.
+ * @param[out] document An empty document object.
+ *
+ * @returns @c 1 if the function succeeded, @c 0 on error.
+ */
+
+YAML_DECLARE(int)
+yaml_parser_load(yaml_parser_t *parser, yaml_document_t *document);
+
+/** @} */
+
+/**
+ * @defgroup emitter Emitter Definitions
+ * @{
+ */
+
+/**
+ * The prototype of a write handler.
+ *
+ * The write handler is called when the emitter needs to flush the accumulated
+ * characters to the output. The handler should write @a size bytes of the
+ * @a buffer to the output.
+ *
+ * @param[in,out] data A pointer to an application data specified by
+ * yaml_emitter_set_output().
+ * @param[in] buffer The buffer with bytes to be written.
+ * @param[in] size The size of the buffer.
+ *
+ * @returns On success, the handler should return @c 1. If the handler failed,
+ * the returned value should be @c 0.
+ */
+
+typedef int yaml_write_handler_t(void *data, unsigned char *buffer, size_t size);
+
+/** The emitter states. */
+typedef enum yaml_emitter_state_e {
+ /** Expect STREAM-START. */
+ YAML_EMIT_STREAM_START_STATE,
+ /** Expect the first DOCUMENT-START or STREAM-END. */
+ YAML_EMIT_FIRST_DOCUMENT_START_STATE,
+ /** Expect DOCUMENT-START or STREAM-END. */
+ YAML_EMIT_DOCUMENT_START_STATE,
+ /** Expect the content of a document. */
+ YAML_EMIT_DOCUMENT_CONTENT_STATE,
+ /** Expect DOCUMENT-END. */
+ YAML_EMIT_DOCUMENT_END_STATE,
+
+ /** Expect the first item of a flow sequence. */
+ YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE,
+ /** Expect an item of a flow sequence. */
+ YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE,
+ /** Expect the first key of a flow mapping. */
+ YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE,
+ /** Expect a key of a flow mapping. */
+ YAML_EMIT_FLOW_MAPPING_KEY_STATE,
+ /** Expect a value for a simple key of a flow mapping. */
+ YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE,
+
+ /** Expect a value of a flow mapping. */
+ YAML_EMIT_FLOW_MAPPING_VALUE_STATE,
+ /** Expect the first item of a block sequence. */
+ YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE,
+ /** Expect an item of a block sequence. */
+ YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE,
+ /** Expect the first key of a block mapping. */
+ YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE,
+ /** Expect the key of a block mapping. */
+ YAML_EMIT_BLOCK_MAPPING_KEY_STATE,
+
+ /** Expect a value for a simple key of a block mapping. */
+ YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE,
+ /** Expect a value of a block mapping. */
+ YAML_EMIT_BLOCK_MAPPING_VALUE_STATE,
+ /** Expect nothing. */
+ YAML_EMIT_END_STATE
+} yaml_emitter_state_t;
+
+
+/* This is needed for C++ */
+
+typedef struct yaml_anchors_s {
+ /** The number of references. */
+ int references;
+ /** The anchor id. */
+ int anchor;
+ /** If the node has been emitted? */
+ int serialized;
+} yaml_anchors_t;
+
+/**
+ * The emitter structure.
+ *
+ * All members are internal. Manage the structure using the @c yaml_emitter_
+ * family of functions.
+ */
+
+typedef struct yaml_emitter_s {
+
+ /**
+ * @name Error handling
+ * @{
+ */
+
+ /** Error type. */
+ yaml_error_type_t error;
+ /** Error description. */
+ const char *problem;
+
+ /**
+ * @}
+ */
+
+ /**
+ * @name Writer stuff
+ * @{
+ */
+
+ /** Write handler. */
+ yaml_write_handler_t *write_handler;
+
+ /** A pointer for passing to the write handler. */
+ void *write_handler_data;
+
+ /** Standard (string or file) output data. */
+ union {
+ /** String output data. */
+ struct {
+ /** The buffer pointer. */
+ unsigned char *buffer;
+ /** The buffer size. */
+ size_t size;
+ /** The number of written bytes. */
+ size_t *size_written;
+ } string;
+
+ /** File output data. */
+ FILE *file;
+ } output;
+
+ /** The working buffer. */
+ struct {
+ /** The beginning of the buffer. */
+ yaml_char_t *start;
+ /** The end of the buffer. */
+ yaml_char_t *end;
+ /** The current position of the buffer. */
+ yaml_char_t *pointer;
+ /** The last filled position of the buffer. */
+ yaml_char_t *last;
+ } buffer;
+
+ /** The raw buffer. */
+ struct {
+ /** The beginning of the buffer. */
+ unsigned char *start;
+ /** The end of the buffer. */
+ unsigned char *end;
+ /** The current position of the buffer. */
+ unsigned char *pointer;
+ /** The last filled position of the buffer. */
+ unsigned char *last;
+ } raw_buffer;
+
+ /** The stream encoding. */
+ yaml_encoding_t encoding;
+
+ /**
+ * @}
+ */
+
+ /**
+ * @name Emitter stuff
+ * @{
+ */
+
+ /** If the output is in the canonical style? */
+ int canonical;
+ /** The number of indentation spaces. */
+ int best_indent;
+ /** The preferred width of the output lines. */
+ int best_width;
+ /** Allow unescaped non-ASCII characters? */
+ int unicode;
+ /** The preferred line break. */
+ yaml_break_t line_break;
+
+ /** The stack of states. */
+ struct {
+ /** The beginning of the stack. */
+ yaml_emitter_state_t *start;
+ /** The end of the stack. */
+ yaml_emitter_state_t *end;
+ /** The top of the stack. */
+ yaml_emitter_state_t *top;
+ } states;
+
+ /** The current emitter state. */
+ yaml_emitter_state_t state;
+
+ /** The event queue. */
+ struct {
+ /** The beginning of the event queue. */
+ yaml_event_t *start;
+ /** The end of the event queue. */
+ yaml_event_t *end;
+ /** The head of the event queue. */
+ yaml_event_t *head;
+ /** The tail of the event queue. */
+ yaml_event_t *tail;
+ } events;
+
+ /** The stack of indentation levels. */
+ struct {
+ /** The beginning of the stack. */
+ int *start;
+ /** The end of the stack. */
+ int *end;
+ /** The top of the stack. */
+ int *top;
+ } indents;
+
+ /** The list of tag directives. */
+ struct {
+ /** The beginning of the list. */
+ yaml_tag_directive_t *start;
+ /** The end of the list. */
+ yaml_tag_directive_t *end;
+ /** The top of the list. */
+ yaml_tag_directive_t *top;
+ } tag_directives;
+
+ /** The current indentation level. */
+ int indent;
+
+ /** The current flow level. */
+ int flow_level;
+
+ /** Is it the document root context? */
+ int root_context;
+ /** Is it a sequence context? */
+ int sequence_context;
+ /** Is it a mapping context? */
+ int mapping_context;
+ /** Is it a simple mapping key context? */
+ int simple_key_context;
+
+ /** The current line. */
+ int line;
+ /** The current column. */
+ int column;
+ /** If the last character was a whitespace? */
+ int whitespace;
+ /** If the last character was an indentation character (' ', '-', '?', ':')? */
+ int indention;
+ /** If an explicit document end is required? */
+ int open_ended;
+
+ /** Anchor analysis. */
+ struct {
+ /** The anchor value. */
+ yaml_char_t *anchor;
+ /** The anchor length. */
+ size_t anchor_length;
+ /** Is it an alias? */
+ int alias;
+ } anchor_data;
+
+ /** Tag analysis. */
+ struct {
+ /** The tag handle. */
+ yaml_char_t *handle;
+ /** The tag handle length. */
+ size_t handle_length;
+ /** The tag suffix. */
+ yaml_char_t *suffix;
+ /** The tag suffix length. */
+ size_t suffix_length;
+ } tag_data;
+
+ /** Scalar analysis. */
+ struct {
+ /** The scalar value. */
+ yaml_char_t *value;
+ /** The scalar length. */
+ size_t length;
+ /** Does the scalar contain line breaks? */
+ int multiline;
+ /** Can the scalar be expessed in the flow plain style? */
+ int flow_plain_allowed;
+ /** Can the scalar be expressed in the block plain style? */
+ int block_plain_allowed;
+ /** Can the scalar be expressed in the single quoted style? */
+ int single_quoted_allowed;
+ /** Can the scalar be expressed in the literal or folded styles? */
+ int block_allowed;
+ /** The output style. */
+ yaml_scalar_style_t style;
+ } scalar_data;
+
+ /**
+ * @}
+ */
+
+ /**
+ * @name Dumper stuff
+ * @{
+ */
+
+ /** If the stream was already opened? */
+ int opened;
+ /** If the stream was already closed? */
+ int closed;
+
+ /** The information associated with the document nodes. */
+ yaml_anchors_t *anchors;
+
+ /** The last assigned anchor id. */
+ int last_anchor_id;
+
+ /** The currently emitted document. */
+ yaml_document_t *document;
+
+ /**
+ * @}
+ */
+
+} yaml_emitter_t;
+
+/**
+ * Initialize an emitter.
+ *
+ * This function creates a new emitter object. An application is responsible
+ * for destroying the object using the yaml_emitter_delete() function.
+ *
+ * @param[out] emitter An empty parser object.
+ *
+ * @returns @c 1 if the function succeeded, @c 0 on error.
+ */
+
+YAML_DECLARE(int)
+yaml_emitter_initialize(yaml_emitter_t *emitter);
+
+/**
+ * Destroy an emitter.
+ *
+ * @param[in,out] emitter An emitter object.
+ */
+
+YAML_DECLARE(void)
+yaml_emitter_delete(yaml_emitter_t *emitter);
+
+/**
+ * Set a string output.
+ *
+ * The emitter will write the output characters to the @a output buffer of the
+ * size @a size. The emitter will set @a size_written to the number of written
+ * bytes. If the buffer is smaller than required, the emitter produces the
+ * YAML_WRITE_ERROR error.
+ *
+ * @param[in,out] emitter An emitter object.
+ * @param[in] output An output buffer.
+ * @param[in] size The buffer size.
+ * @param[in] size_written The pointer to save the number of written
+ * bytes.
+ */
+
+YAML_DECLARE(void)
+yaml_emitter_set_output_string(yaml_emitter_t *emitter,
+ unsigned char *output, size_t size, size_t *size_written);
+
+/**
+ * Set a file output.
+ *
+ * @a file should be a file object open for writing. The application is
+ * responsible for closing the @a file.
+ *
+ * @param[in,out] emitter An emitter object.
+ * @param[in] file An open file.
+ */
+
+YAML_DECLARE(void)
+yaml_emitter_set_output_file(yaml_emitter_t *emitter, FILE *file);
+
+/**
+ * Set a generic output handler.
+ *
+ * @param[in,out] emitter An emitter object.
+ * @param[in] handler A write handler.
+ * @param[in] data Any application data for passing to the write
+ * handler.
+ */
+
+YAML_DECLARE(void)
+yaml_emitter_set_output(yaml_emitter_t *emitter,
+ yaml_write_handler_t *handler, void *data);
+
+/**
+ * Set the output encoding.
+ *
+ * @param[in,out] emitter An emitter object.
+ * @param[in] encoding The output encoding.
+ */
+
+YAML_DECLARE(void)
+yaml_emitter_set_encoding(yaml_emitter_t *emitter, yaml_encoding_t encoding);
+
+/**
+ * Set if the output should be in the "canonical" format as in the YAML
+ * specification.
+ *
+ * @param[in,out] emitter An emitter object.
+ * @param[in] canonical If the output is canonical.
+ */
+
+YAML_DECLARE(void)
+yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical);
+
+/**
+ * Set the indentation increment.
+ *
+ * @param[in,out] emitter An emitter object.
+ * @param[in] indent The indentation increment (1 < . < 10).
+ */
+
+YAML_DECLARE(void)
+yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent);
+
+/**
+ * Set the preferred line width. @c -1 means unlimited.
+ *
+ * @param[in,out] emitter An emitter object.
+ * @param[in] width The preferred line width.
+ */
+
+YAML_DECLARE(void)
+yaml_emitter_set_width(yaml_emitter_t *emitter, int width);
+
+/**
+ * Set if unescaped non-ASCII characters are allowed.
+ *
+ * @param[in,out] emitter An emitter object.
+ * @param[in] unicode If unescaped Unicode characters are allowed.
+ */
+
+YAML_DECLARE(void)
+yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode);
+
+/**
+ * Set the preferred line break.
+ *
+ * @param[in,out] emitter An emitter object.
+ * @param[in] line_break The preferred line break.
+ */
+
+YAML_DECLARE(void)
+yaml_emitter_set_break(yaml_emitter_t *emitter, yaml_break_t line_break);
+
+/**
+ * Emit an event.
+ *
+ * The event object may be generated using the yaml_parser_parse() function.
+ * The emitter takes the responsibility for the event object and destroys its
+ * content after it is emitted. The event object is destroyed even if the
+ * function fails.
+ *
+ * @param[in,out] emitter An emitter object.
+ * @param[in,out] event An event object.
+ *
+ * @returns @c 1 if the function succeeded, @c 0 on error.
+ */
+
+YAML_DECLARE(int)
+yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event);
+
+/**
+ * Start a YAML stream.
+ *
+ * This function should be used before yaml_emitter_dump() is called.
+ *
+ * @param[in,out] emitter An emitter object.
+ *
+ * @returns @c 1 if the function succeeded, @c 0 on error.
+ */
+
+YAML_DECLARE(int)
+yaml_emitter_open(yaml_emitter_t *emitter);
+
+/**
+ * Finish a YAML stream.
+ *
+ * This function should be used after yaml_emitter_dump() is called.
+ *
+ * @param[in,out] emitter An emitter object.
+ *
+ * @returns @c 1 if the function succeeded, @c 0 on error.
+ */
+
+YAML_DECLARE(int)
+yaml_emitter_close(yaml_emitter_t *emitter);
+
+/**
+ * Emit a YAML document.
+ *
+ * The documen object may be generated using the yaml_parser_load() function
+ * or the yaml_document_initialize() function. The emitter takes the
+ * responsibility for the document object and destroys its content after
+ * it is emitted. The document object is destroyed even if the function fails.
+ *
+ * @param[in,out] emitter An emitter object.
+ * @param[in,out] document A document object.
+ *
+ * @returns @c 1 if the function succeeded, @c 0 on error.
+ */
+
+YAML_DECLARE(int)
+yaml_emitter_dump(yaml_emitter_t *emitter, yaml_document_t *document);
+
+/**
+ * Flush the accumulated characters to the output.
+ *
+ * @param[in,out] emitter An emitter object.
+ *
+ * @returns @c 1 if the function succeeded, @c 0 on error.
+ */
+
+YAML_DECLARE(int)
+yaml_emitter_flush(yaml_emitter_t *emitter);
+
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* #ifndef YAML_H */
+
diff --git a/libyaml/pkg/ReadMe.md b/libyaml/pkg/ReadMe.md
new file mode 100644
index 0000000000000000000000000000000000000000..7faede8bf87c48e738a4869945b28bbc2e52b062
--- /dev/null
+++ b/libyaml/pkg/ReadMe.md
@@ -0,0 +1,77 @@
+# How to Make a `libyaml` Release
+
+## Versioning
+
+Update libyaml version in:
+* announcement.msg
+* Changes
+* CMakeLists.txt
+ * `YAML_VERSION_MAJOR`, `YAML_VERSION_MINOR`, `YAML_VERSION_PATCH`
+* .appveyor.yml
+* configure.ac
+ * `YAML_MAJOR`, `YAML_MINOR`, `YAML_PATCH`, `YAML_RELEASE`, `YAML_CURRENT`, `YAML_REVISION`
+
+Commit and push everything to `release/0.x.y`.
+
+## Test and Create Release Archives
+
+### GitHub Actions Automation
+
+The github workflow:
+
+ .github/workflows/dist.yaml
+
+will do this automatically for you.
+
+#### .github/workflows/dist.yaml
+
+This workflow will create release archives (`tar.gz` and `zip`).
+
+### Manually
+
+Make sure you have a clean git repository (no changed files).
+The following process will clone your current git directory.
+
+This will need the docker image `yamlio/libyaml-dev`.
+You can either pull it, or create it yourself:
+
+ make docker-build
+
+### Create dist archives
+
+Run:
+
+ make docker-dist
+
+It will run `make dist` in the container to create a tarball written to
+`pkg/docker/output`.
+It will also create a zipfile.
+
+## Update master
+
+ git merge release/0.x.y
+ git tag -a 0.x.y
+ # <Editor opens>
+ # Paste the corresponding entry from the Changes file
+ # Look at an earlier release for how it should look like:
+ # git show 0.2.3
+ git push origin master 0.x.y
+
+## Create a GitHub release
+
+Go to "Releases" and click on "Draft a new release".
+
+Fill in the tag you just created in the previous step.
+
+Fill in the release title: v0.x.y
+
+Paste the changelog into the description field.
+
+Upload the tar.gz and .zip file.
+
+You can "Save draft" and publish later, or directly click on "Publish release".
+
+## Update pyyaml.org
+
+See <https://github.com/yaml/pyyaml.org/blob/master/ReadMe.md>.
+
diff --git a/libyaml/pkg/docker/.gitignore b/libyaml/pkg/docker/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..f5b0d6de728b62ccfad8adf69424a87bdc3c7c31
--- /dev/null
+++ b/libyaml/pkg/docker/.gitignore
@@ -0,0 +1,3 @@
+output/*
+!Makefile
+!output/ReadMe
diff --git a/libyaml/pkg/docker/Dockerfile b/libyaml/pkg/docker/Dockerfile
new file mode 100644
index 0000000000000000000000000000000000000000..71f9df1677bedf06af76f8ed46a02f2328451610
--- /dev/null
+++ b/libyaml/pkg/docker/Dockerfile
@@ -0,0 +1,32 @@
+FROM ubuntu:18.04
+
+RUN apt-get update \
+ && apt-get install -y \
+ automake \
+ bison \
+ build-essential \
+ cmake \
+ curl \
+ doxygen \
+ flex \
+ git \
+ less \
+ libtool \
+ python \
+ vim \
+ zip \
+ && true
+
+# http://www.doxygen.nl/manual/install.html
+
+RUN curl https://sourceforge.net/projects/doxygen/files/rel-1.8.14/doxygen-1.8.14.src.tar.gz/download \
+ -L -o /doxygen-1.8.14.src.tar.gz \
+ && cd / \
+ && tar -xvf doxygen-1.8.14.src.tar.gz \
+ && cd doxygen-1.8.14 \
+ && mkdir build \
+ && cd build \
+ && cmake -G "Unix Makefiles" .. \
+ && make \
+ && make install \
+ && true
diff --git a/libyaml/pkg/docker/Makefile b/libyaml/pkg/docker/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..8a53ed30bec02a94e81522e22805615d9589504f
--- /dev/null
+++ b/libyaml/pkg/docker/Makefile
@@ -0,0 +1,23 @@
+DOCKER_IMAGE ?= yamlio/libyaml-dev
+
+build:
+ docker build -t $(DOCKER_IMAGE) .
+
+run: build
+ docker run -it --rm $(DOCKER_IMAGE) bash
+
+prepare-git:
+ rm -rf output/libyaml.git
+ git clone ../../.git output/libyaml.git
+
+libyaml-dist: libyaml-dist-ci
+
+libyaml-dist-ci: prepare-git
+ docker run --rm -u $$(id -u) \
+ -v"$$PWD/output:/output" \
+ -v"$$PWD/scripts:/scripts" \
+ $(DOCKER_IMAGE) /scripts/libyaml-dist.sh
+
+clean:
+ rm -rf output/libyaml.git
+ rm -rf output/yaml-*.*
diff --git a/libyaml/pkg/docker/output/ReadMe b/libyaml/pkg/docker/output/ReadMe
new file mode 100644
index 0000000000000000000000000000000000000000..acdc333151632c9246063313e7a138e9c47ba56a
--- /dev/null
+++ b/libyaml/pkg/docker/output/ReadMe
@@ -0,0 +1 @@
+Output directory for build files created by docker
diff --git a/libyaml/pkg/docker/scripts/libyaml-dist.sh b/libyaml/pkg/docker/scripts/libyaml-dist.sh
new file mode 100755
index 0000000000000000000000000000000000000000..94e76965ae057759ac5a2d885e4fd8890c126f92
--- /dev/null
+++ b/libyaml/pkg/docker/scripts/libyaml-dist.sh
@@ -0,0 +1,23 @@
+#!/usr/bin/env bash
+
+set -ex
+
+cp -r /output/libyaml.git /tmp/
+cd /tmp/libyaml.git
+./bootstrap
+./configure
+make dist
+
+# get the tarball filename
+tarballs=(yaml-*.tar.gz)
+tarball=${tarballs[0]:?}
+dirname=${tarball/.tar.gz/}
+
+# Copy to output dir
+cp "$tarball" /output
+
+# Create zip archive
+cd /tmp
+cp "/output/$tarball" .
+tar xvf "$tarball"
+zip -r "/output/$dirname.zip" "$dirname"
diff --git a/libyaml/regression-inputs/clusterfuzz-testcase-minimized-5607885063061504.yml b/libyaml/regression-inputs/clusterfuzz-testcase-minimized-5607885063061504.yml
new file mode 100644
index 0000000000000000000000000000000000000000..72e9492c13480b82773ad7ab415f758ebcc00262
--- /dev/null
+++ b/libyaml/regression-inputs/clusterfuzz-testcase-minimized-5607885063061504.yml
@@ -0,0 +1 @@
+"(\
diff --git a/libyaml/src/Makefile.am b/libyaml/src/Makefile.am
new file mode 100644
index 0000000000000000000000000000000000000000..24cf89d241dddf4ee937140beb0f053c562d4943
--- /dev/null
+++ b/libyaml/src/Makefile.am
@@ -0,0 +1,4 @@
+AM_CPPFLAGS = -I$(top_srcdir)/include -Wall
+lib_LTLIBRARIES = libyaml.la
+libyaml_la_SOURCES = yaml_private.h api.c reader.c scanner.c parser.c loader.c writer.c emitter.c dumper.c
+libyaml_la_LDFLAGS = -no-undefined -release $(YAML_LT_RELEASE) -version-info $(YAML_LT_CURRENT):$(YAML_LT_REVISION):$(YAML_LT_AGE)
diff --git a/libyaml/src/api.c b/libyaml/src/api.c
new file mode 100644
index 0000000000000000000000000000000000000000..16f88bd762aaff80d15248a0501a864375c0ee28
--- /dev/null
+++ b/libyaml/src/api.c
@@ -0,0 +1,1393 @@
+
+#include "yaml_private.h"
+
+/*
+ * Get the library version.
+ */
+
+YAML_DECLARE(const char *)
+yaml_get_version_string(void)
+{
+ return YAML_VERSION_STRING;
+}
+
+/*
+ * Get the library version numbers.
+ */
+
+YAML_DECLARE(void)
+yaml_get_version(int *major, int *minor, int *patch)
+{
+ *major = YAML_VERSION_MAJOR;
+ *minor = YAML_VERSION_MINOR;
+ *patch = YAML_VERSION_PATCH;
+}
+
+/*
+ * Allocate a dynamic memory block.
+ */
+
+YAML_DECLARE(void *)
+yaml_malloc(size_t size)
+{
+ return malloc(size ? size : 1);
+}
+
+/*
+ * Reallocate a dynamic memory block.
+ */
+
+YAML_DECLARE(void *)
+yaml_realloc(void *ptr, size_t size)
+{
+ return ptr ? realloc(ptr, size ? size : 1) : malloc(size ? size : 1);
+}
+
+/*
+ * Free a dynamic memory block.
+ */
+
+YAML_DECLARE(void)
+yaml_free(void *ptr)
+{
+ if (ptr) free(ptr);
+}
+
+/*
+ * Duplicate a string.
+ */
+
+YAML_DECLARE(yaml_char_t *)
+yaml_strdup(const yaml_char_t *str)
+{
+ if (!str)
+ return NULL;
+
+ return (yaml_char_t *)strdup((char *)str);
+}
+
+/*
+ * Extend a string.
+ */
+
+YAML_DECLARE(int)
+yaml_string_extend(yaml_char_t **start,
+ yaml_char_t **pointer, yaml_char_t **end)
+{
+ yaml_char_t *new_start = (yaml_char_t *)yaml_realloc((void*)*start, (*end - *start)*2);
+
+ if (!new_start) return 0;
+
+ memset(new_start + (*end - *start), 0, *end - *start);
+
+ *pointer = new_start + (*pointer - *start);
+ *end = new_start + (*end - *start)*2;
+ *start = new_start;
+
+ return 1;
+}
+
+/*
+ * Append a string B to a string A.
+ */
+
+YAML_DECLARE(int)
+yaml_string_join(
+ yaml_char_t **a_start, yaml_char_t **a_pointer, yaml_char_t **a_end,
+ yaml_char_t **b_start, yaml_char_t **b_pointer, SHIM(yaml_char_t **b_end))
+{
+ UNUSED_PARAM(b_end)
+ if (*b_start == *b_pointer)
+ return 1;
+
+ while (*a_end - *a_pointer <= *b_pointer - *b_start) {
+ if (!yaml_string_extend(a_start, a_pointer, a_end))
+ return 0;
+ }
+
+ memcpy(*a_pointer, *b_start, *b_pointer - *b_start);
+ *a_pointer += *b_pointer - *b_start;
+
+ return 1;
+}
+
+/*
+ * Extend a stack.
+ */
+
+YAML_DECLARE(int)
+yaml_stack_extend(void **start, void **top, void **end)
+{
+ void *new_start;
+
+ if ((char *)*end - (char *)*start >= INT_MAX / 2)
+ return 0;
+
+ new_start = yaml_realloc(*start, ((char *)*end - (char *)*start)*2);
+
+ if (!new_start) return 0;
+
+ *top = (char *)new_start + ((char *)*top - (char *)*start);
+ *end = (char *)new_start + ((char *)*end - (char *)*start)*2;
+ *start = new_start;
+
+ return 1;
+}
+
+/*
+ * Extend or move a queue.
+ */
+
+YAML_DECLARE(int)
+yaml_queue_extend(void **start, void **head, void **tail, void **end)
+{
+ /* Check if we need to resize the queue. */
+
+ if (*start == *head && *tail == *end) {
+ void *new_start = yaml_realloc(*start,
+ ((char *)*end - (char *)*start)*2);
+
+ if (!new_start) return 0;
+
+ *head = (char *)new_start + ((char *)*head - (char *)*start);
+ *tail = (char *)new_start + ((char *)*tail - (char *)*start);
+ *end = (char *)new_start + ((char *)*end - (char *)*start)*2;
+ *start = new_start;
+ }
+
+ /* Check if we need to move the queue at the beginning of the buffer. */
+
+ if (*tail == *end) {
+ if (*head != *tail) {
+ memmove(*start, *head, (char *)*tail - (char *)*head);
+ }
+ *tail = (char *)*tail - (char *)*head + (char *)*start;
+ *head = *start;
+ }
+
+ return 1;
+}
+
+
+/*
+ * Create a new parser object.
+ */
+
+YAML_DECLARE(int)
+yaml_parser_initialize(yaml_parser_t *parser)
+{
+ assert(parser); /* Non-NULL parser object expected. */
+
+ memset(parser, 0, sizeof(yaml_parser_t));
+ if (!BUFFER_INIT(parser, parser->raw_buffer, INPUT_RAW_BUFFER_SIZE))
+ goto error;
+ if (!BUFFER_INIT(parser, parser->buffer, INPUT_BUFFER_SIZE))
+ goto error;
+ if (!QUEUE_INIT(parser, parser->tokens, INITIAL_QUEUE_SIZE, yaml_token_t*))
+ goto error;
+ if (!STACK_INIT(parser, parser->indents, int*))
+ goto error;
+ if (!STACK_INIT(parser, parser->simple_keys, yaml_simple_key_t*))
+ goto error;
+ if (!STACK_INIT(parser, parser->states, yaml_parser_state_t*))
+ goto error;
+ if (!STACK_INIT(parser, parser->marks, yaml_mark_t*))
+ goto error;
+ if (!STACK_INIT(parser, parser->tag_directives, yaml_tag_directive_t*))
+ goto error;
+
+ return 1;
+
+error:
+
+ BUFFER_DEL(parser, parser->raw_buffer);
+ BUFFER_DEL(parser, parser->buffer);
+ QUEUE_DEL(parser, parser->tokens);
+ STACK_DEL(parser, parser->indents);
+ STACK_DEL(parser, parser->simple_keys);
+ STACK_DEL(parser, parser->states);
+ STACK_DEL(parser, parser->marks);
+ STACK_DEL(parser, parser->tag_directives);
+
+ return 0;
+}
+
+/*
+ * Destroy a parser object.
+ */
+
+YAML_DECLARE(void)
+yaml_parser_delete(yaml_parser_t *parser)
+{
+ assert(parser); /* Non-NULL parser object expected. */
+
+ BUFFER_DEL(parser, parser->raw_buffer);
+ BUFFER_DEL(parser, parser->buffer);
+ while (!QUEUE_EMPTY(parser, parser->tokens)) {
+ yaml_token_delete(&DEQUEUE(parser, parser->tokens));
+ }
+ QUEUE_DEL(parser, parser->tokens);
+ STACK_DEL(parser, parser->indents);
+ STACK_DEL(parser, parser->simple_keys);
+ STACK_DEL(parser, parser->states);
+ STACK_DEL(parser, parser->marks);
+ while (!STACK_EMPTY(parser, parser->tag_directives)) {
+ yaml_tag_directive_t tag_directive = POP(parser, parser->tag_directives);
+ yaml_free(tag_directive.handle);
+ yaml_free(tag_directive.prefix);
+ }
+ STACK_DEL(parser, parser->tag_directives);
+
+ memset(parser, 0, sizeof(yaml_parser_t));
+}
+
+/*
+ * String read handler.
+ */
+
+static int
+yaml_string_read_handler(void *data, unsigned char *buffer, size_t size,
+ size_t *size_read)
+{
+ yaml_parser_t *parser = (yaml_parser_t *)data;
+
+ if (parser->input.string.current == parser->input.string.end) {
+ *size_read = 0;
+ return 1;
+ }
+
+ if (size > (size_t)(parser->input.string.end
+ - parser->input.string.current)) {
+ size = parser->input.string.end - parser->input.string.current;
+ }
+
+ memcpy(buffer, parser->input.string.current, size);
+ parser->input.string.current += size;
+ *size_read = size;
+ return 1;
+}
+
+/*
+ * File read handler.
+ */
+
+static int
+yaml_file_read_handler(void *data, unsigned char *buffer, size_t size,
+ size_t *size_read)
+{
+ yaml_parser_t *parser = (yaml_parser_t *)data;
+
+ *size_read = fread(buffer, 1, size, parser->input.file);
+ return !ferror(parser->input.file);
+}
+
+/*
+ * Set a string input.
+ */
+
+YAML_DECLARE(void)
+yaml_parser_set_input_string(yaml_parser_t *parser,
+ const unsigned char *input, size_t size)
+{
+ assert(parser); /* Non-NULL parser object expected. */
+ assert(!parser->read_handler); /* You can set the source only once. */
+ assert(input); /* Non-NULL input string expected. */
+
+ parser->read_handler = yaml_string_read_handler;
+ parser->read_handler_data = parser;
+
+ parser->input.string.start = input;
+ parser->input.string.current = input;
+ parser->input.string.end = input+size;
+}
+
+/*
+ * Set a file input.
+ */
+
+YAML_DECLARE(void)
+yaml_parser_set_input_file(yaml_parser_t *parser, FILE *file)
+{
+ assert(parser); /* Non-NULL parser object expected. */
+ assert(!parser->read_handler); /* You can set the source only once. */
+ assert(file); /* Non-NULL file object expected. */
+
+ parser->read_handler = yaml_file_read_handler;
+ parser->read_handler_data = parser;
+
+ parser->input.file = file;
+}
+
+/*
+ * Set a generic input.
+ */
+
+YAML_DECLARE(void)
+yaml_parser_set_input(yaml_parser_t *parser,
+ yaml_read_handler_t *handler, void *data)
+{
+ assert(parser); /* Non-NULL parser object expected. */
+ assert(!parser->read_handler); /* You can set the source only once. */
+ assert(handler); /* Non-NULL read handler expected. */
+
+ parser->read_handler = handler;
+ parser->read_handler_data = data;
+}
+
+/*
+ * Set the source encoding.
+ */
+
+YAML_DECLARE(void)
+yaml_parser_set_encoding(yaml_parser_t *parser, yaml_encoding_t encoding)
+{
+ assert(parser); /* Non-NULL parser object expected. */
+ assert(!parser->encoding); /* Encoding is already set or detected. */
+
+ parser->encoding = encoding;
+}
+
+/*
+ * Create a new emitter object.
+ */
+
+YAML_DECLARE(int)
+yaml_emitter_initialize(yaml_emitter_t *emitter)
+{
+ assert(emitter); /* Non-NULL emitter object expected. */
+
+ memset(emitter, 0, sizeof(yaml_emitter_t));
+ if (!BUFFER_INIT(emitter, emitter->buffer, OUTPUT_BUFFER_SIZE))
+ goto error;
+ if (!BUFFER_INIT(emitter, emitter->raw_buffer, OUTPUT_RAW_BUFFER_SIZE))
+ goto error;
+ if (!STACK_INIT(emitter, emitter->states, yaml_emitter_state_t*))
+ goto error;
+ if (!QUEUE_INIT(emitter, emitter->events, INITIAL_QUEUE_SIZE, yaml_event_t*))
+ goto error;
+ if (!STACK_INIT(emitter, emitter->indents, int*))
+ goto error;
+ if (!STACK_INIT(emitter, emitter->tag_directives, yaml_tag_directive_t*))
+ goto error;
+
+ return 1;
+
+error:
+
+ BUFFER_DEL(emitter, emitter->buffer);
+ BUFFER_DEL(emitter, emitter->raw_buffer);
+ STACK_DEL(emitter, emitter->states);
+ QUEUE_DEL(emitter, emitter->events);
+ STACK_DEL(emitter, emitter->indents);
+ STACK_DEL(emitter, emitter->tag_directives);
+
+ return 0;
+}
+
+/*
+ * Destroy an emitter object.
+ */
+
+YAML_DECLARE(void)
+yaml_emitter_delete(yaml_emitter_t *emitter)
+{
+ assert(emitter); /* Non-NULL emitter object expected. */
+
+ BUFFER_DEL(emitter, emitter->buffer);
+ BUFFER_DEL(emitter, emitter->raw_buffer);
+ STACK_DEL(emitter, emitter->states);
+ while (!QUEUE_EMPTY(emitter, emitter->events)) {
+ yaml_event_delete(&DEQUEUE(emitter, emitter->events));
+ }
+ QUEUE_DEL(emitter, emitter->events);
+ STACK_DEL(emitter, emitter->indents);
+ while (!STACK_EMPTY(empty, emitter->tag_directives)) {
+ yaml_tag_directive_t tag_directive = POP(emitter, emitter->tag_directives);
+ yaml_free(tag_directive.handle);
+ yaml_free(tag_directive.prefix);
+ }
+ STACK_DEL(emitter, emitter->tag_directives);
+ yaml_free(emitter->anchors);
+
+ memset(emitter, 0, sizeof(yaml_emitter_t));
+}
+
+/*
+ * String write handler.
+ */
+
+static int
+yaml_string_write_handler(void *data, unsigned char *buffer, size_t size)
+{
+ yaml_emitter_t *emitter = (yaml_emitter_t *)data;
+
+ if (emitter->output.string.size - *emitter->output.string.size_written
+ < size) {
+ memcpy(emitter->output.string.buffer
+ + *emitter->output.string.size_written,
+ buffer,
+ emitter->output.string.size
+ - *emitter->output.string.size_written);
+ *emitter->output.string.size_written = emitter->output.string.size;
+ return 0;
+ }
+
+ memcpy(emitter->output.string.buffer
+ + *emitter->output.string.size_written, buffer, size);
+ *emitter->output.string.size_written += size;
+ return 1;
+}
+
+/*
+ * File write handler.
+ */
+
+static int
+yaml_file_write_handler(void *data, unsigned char *buffer, size_t size)
+{
+ yaml_emitter_t *emitter = (yaml_emitter_t *)data;
+
+ return (fwrite(buffer, 1, size, emitter->output.file) == size);
+}
+/*
+ * Set a string output.
+ */
+
+YAML_DECLARE(void)
+yaml_emitter_set_output_string(yaml_emitter_t *emitter,
+ unsigned char *output, size_t size, size_t *size_written)
+{
+ assert(emitter); /* Non-NULL emitter object expected. */
+ assert(!emitter->write_handler); /* You can set the output only once. */
+ assert(output); /* Non-NULL output string expected. */
+
+ emitter->write_handler = yaml_string_write_handler;
+ emitter->write_handler_data = emitter;
+
+ emitter->output.string.buffer = output;
+ emitter->output.string.size = size;
+ emitter->output.string.size_written = size_written;
+ *size_written = 0;
+}
+
+/*
+ * Set a file output.
+ */
+
+YAML_DECLARE(void)
+yaml_emitter_set_output_file(yaml_emitter_t *emitter, FILE *file)
+{
+ assert(emitter); /* Non-NULL emitter object expected. */
+ assert(!emitter->write_handler); /* You can set the output only once. */
+ assert(file); /* Non-NULL file object expected. */
+
+ emitter->write_handler = yaml_file_write_handler;
+ emitter->write_handler_data = emitter;
+
+ emitter->output.file = file;
+}
+
+/*
+ * Set a generic output handler.
+ */
+
+YAML_DECLARE(void)
+yaml_emitter_set_output(yaml_emitter_t *emitter,
+ yaml_write_handler_t *handler, void *data)
+{
+ assert(emitter); /* Non-NULL emitter object expected. */
+ assert(!emitter->write_handler); /* You can set the output only once. */
+ assert(handler); /* Non-NULL handler object expected. */
+
+ emitter->write_handler = handler;
+ emitter->write_handler_data = data;
+}
+
+/*
+ * Set the output encoding.
+ */
+
+YAML_DECLARE(void)
+yaml_emitter_set_encoding(yaml_emitter_t *emitter, yaml_encoding_t encoding)
+{
+ assert(emitter); /* Non-NULL emitter object expected. */
+ assert(!emitter->encoding); /* You can set encoding only once. */
+
+ emitter->encoding = encoding;
+}
+
+/*
+ * Set the canonical output style.
+ */
+
+YAML_DECLARE(void)
+yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical)
+{
+ assert(emitter); /* Non-NULL emitter object expected. */
+
+ emitter->canonical = (canonical != 0);
+}
+
+/*
+ * Set the indentation increment.
+ */
+
+YAML_DECLARE(void)
+yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent)
+{
+ assert(emitter); /* Non-NULL emitter object expected. */
+
+ emitter->best_indent = (1 < indent && indent < 10) ? indent : 2;
+}
+
+/*
+ * Set the preferred line width.
+ */
+
+YAML_DECLARE(void)
+yaml_emitter_set_width(yaml_emitter_t *emitter, int width)
+{
+ assert(emitter); /* Non-NULL emitter object expected. */
+
+ emitter->best_width = (width >= 0) ? width : -1;
+}
+
+/*
+ * Set if unescaped non-ASCII characters are allowed.
+ */
+
+YAML_DECLARE(void)
+yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode)
+{
+ assert(emitter); /* Non-NULL emitter object expected. */
+
+ emitter->unicode = (unicode != 0);
+}
+
+/*
+ * Set the preferred line break character.
+ */
+
+YAML_DECLARE(void)
+yaml_emitter_set_break(yaml_emitter_t *emitter, yaml_break_t line_break)
+{
+ assert(emitter); /* Non-NULL emitter object expected. */
+
+ emitter->line_break = line_break;
+}
+
+/*
+ * Destroy a token object.
+ */
+
+YAML_DECLARE(void)
+yaml_token_delete(yaml_token_t *token)
+{
+ assert(token); /* Non-NULL token object expected. */
+
+ switch (token->type)
+ {
+ case YAML_TAG_DIRECTIVE_TOKEN:
+ yaml_free(token->data.tag_directive.handle);
+ yaml_free(token->data.tag_directive.prefix);
+ break;
+
+ case YAML_ALIAS_TOKEN:
+ yaml_free(token->data.alias.value);
+ break;
+
+ case YAML_ANCHOR_TOKEN:
+ yaml_free(token->data.anchor.value);
+ break;
+
+ case YAML_TAG_TOKEN:
+ yaml_free(token->data.tag.handle);
+ yaml_free(token->data.tag.suffix);
+ break;
+
+ case YAML_SCALAR_TOKEN:
+ yaml_free(token->data.scalar.value);
+ break;
+
+ default:
+ break;
+ }
+
+ memset(token, 0, sizeof(yaml_token_t));
+}
+
+/*
+ * Check if a string is a valid UTF-8 sequence.
+ *
+ * Check 'reader.c' for more details on UTF-8 encoding.
+ */
+
+static int
+yaml_check_utf8(const yaml_char_t *start, size_t length)
+{
+ const yaml_char_t *end = start+length;
+ const yaml_char_t *pointer = start;
+
+ while (pointer < end) {
+ unsigned char octet;
+ unsigned int width;
+ unsigned int value;
+ size_t k;
+
+ octet = pointer[0];
+ width = (octet & 0x80) == 0x00 ? 1 :
+ (octet & 0xE0) == 0xC0 ? 2 :
+ (octet & 0xF0) == 0xE0 ? 3 :
+ (octet & 0xF8) == 0xF0 ? 4 : 0;
+ value = (octet & 0x80) == 0x00 ? octet & 0x7F :
+ (octet & 0xE0) == 0xC0 ? octet & 0x1F :
+ (octet & 0xF0) == 0xE0 ? octet & 0x0F :
+ (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
+ if (!width) return 0;
+ if (pointer+width > end) return 0;
+ for (k = 1; k < width; k ++) {
+ octet = pointer[k];
+ if ((octet & 0xC0) != 0x80) return 0;
+ value = (value << 6) + (octet & 0x3F);
+ }
+ if (!((width == 1) ||
+ (width == 2 && value >= 0x80) ||
+ (width == 3 && value >= 0x800) ||
+ (width == 4 && value >= 0x10000))) return 0;
+
+ pointer += width;
+ }
+
+ return 1;
+}
+
+/*
+ * Create STREAM-START.
+ */
+
+YAML_DECLARE(int)
+yaml_stream_start_event_initialize(yaml_event_t *event,
+ yaml_encoding_t encoding)
+{
+ yaml_mark_t mark = { 0, 0, 0 };
+
+ assert(event); /* Non-NULL event object is expected. */
+
+ STREAM_START_EVENT_INIT(*event, encoding, mark, mark);
+
+ return 1;
+}
+
+/*
+ * Create STREAM-END.
+ */
+
+YAML_DECLARE(int)
+yaml_stream_end_event_initialize(yaml_event_t *event)
+{
+ yaml_mark_t mark = { 0, 0, 0 };
+
+ assert(event); /* Non-NULL event object is expected. */
+
+ STREAM_END_EVENT_INIT(*event, mark, mark);
+
+ return 1;
+}
+
+/*
+ * Create DOCUMENT-START.
+ */
+
+YAML_DECLARE(int)
+yaml_document_start_event_initialize(yaml_event_t *event,
+ yaml_version_directive_t *version_directive,
+ yaml_tag_directive_t *tag_directives_start,
+ yaml_tag_directive_t *tag_directives_end,
+ int implicit)
+{
+ struct {
+ yaml_error_type_t error;
+ } context;
+ yaml_mark_t mark = { 0, 0, 0 };
+ yaml_version_directive_t *version_directive_copy = NULL;
+ struct {
+ yaml_tag_directive_t *start;
+ yaml_tag_directive_t *end;
+ yaml_tag_directive_t *top;
+ } tag_directives_copy = { NULL, NULL, NULL };
+ yaml_tag_directive_t value = { NULL, NULL };
+
+ assert(event); /* Non-NULL event object is expected. */
+ assert((tag_directives_start && tag_directives_end) ||
+ (tag_directives_start == tag_directives_end));
+ /* Valid tag directives are expected. */
+
+ if (version_directive) {
+ version_directive_copy = YAML_MALLOC_STATIC(yaml_version_directive_t);
+ if (!version_directive_copy) goto error;
+ version_directive_copy->major = version_directive->major;
+ version_directive_copy->minor = version_directive->minor;
+ }
+
+ if (tag_directives_start != tag_directives_end) {
+ yaml_tag_directive_t *tag_directive;
+ if (!STACK_INIT(&context, tag_directives_copy, yaml_tag_directive_t*))
+ goto error;
+ for (tag_directive = tag_directives_start;
+ tag_directive != tag_directives_end; tag_directive ++) {
+ assert(tag_directive->handle);
+ assert(tag_directive->prefix);
+ if (!yaml_check_utf8(tag_directive->handle,
+ strlen((char *)tag_directive->handle)))
+ goto error;
+ if (!yaml_check_utf8(tag_directive->prefix,
+ strlen((char *)tag_directive->prefix)))
+ goto error;
+ value.handle = yaml_strdup(tag_directive->handle);
+ value.prefix = yaml_strdup(tag_directive->prefix);
+ if (!value.handle || !value.prefix) goto error;
+ if (!PUSH(&context, tag_directives_copy, value))
+ goto error;
+ value.handle = NULL;
+ value.prefix = NULL;
+ }
+ }
+
+ DOCUMENT_START_EVENT_INIT(*event, version_directive_copy,
+ tag_directives_copy.start, tag_directives_copy.top,
+ implicit, mark, mark);
+
+ return 1;
+
+error:
+ yaml_free(version_directive_copy);
+ while (!STACK_EMPTY(context, tag_directives_copy)) {
+ yaml_tag_directive_t value = POP(context, tag_directives_copy);
+ yaml_free(value.handle);
+ yaml_free(value.prefix);
+ }
+ STACK_DEL(context, tag_directives_copy);
+ yaml_free(value.handle);
+ yaml_free(value.prefix);
+
+ return 0;
+}
+
+/*
+ * Create DOCUMENT-END.
+ */
+
+YAML_DECLARE(int)
+yaml_document_end_event_initialize(yaml_event_t *event, int implicit)
+{
+ yaml_mark_t mark = { 0, 0, 0 };
+
+ assert(event); /* Non-NULL emitter object is expected. */
+
+ DOCUMENT_END_EVENT_INIT(*event, implicit, mark, mark);
+
+ return 1;
+}
+
+/*
+ * Create ALIAS.
+ */
+
+YAML_DECLARE(int)
+yaml_alias_event_initialize(yaml_event_t *event, const yaml_char_t *anchor)
+{
+ yaml_mark_t mark = { 0, 0, 0 };
+ yaml_char_t *anchor_copy = NULL;
+
+ assert(event); /* Non-NULL event object is expected. */
+ assert(anchor); /* Non-NULL anchor is expected. */
+
+ if (!yaml_check_utf8(anchor, strlen((char *)anchor))) return 0;
+
+ anchor_copy = yaml_strdup(anchor);
+ if (!anchor_copy)
+ return 0;
+
+ ALIAS_EVENT_INIT(*event, anchor_copy, mark, mark);
+
+ return 1;
+}
+
+/*
+ * Create SCALAR.
+ */
+
+YAML_DECLARE(int)
+yaml_scalar_event_initialize(yaml_event_t *event,
+ const yaml_char_t *anchor, const yaml_char_t *tag,
+ const yaml_char_t *value, int length,
+ int plain_implicit, int quoted_implicit,
+ yaml_scalar_style_t style)
+{
+ yaml_mark_t mark = { 0, 0, 0 };
+ yaml_char_t *anchor_copy = NULL;
+ yaml_char_t *tag_copy = NULL;
+ yaml_char_t *value_copy = NULL;
+
+ assert(event); /* Non-NULL event object is expected. */
+ assert(value); /* Non-NULL anchor is expected. */
+
+ if (anchor) {
+ if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
+ anchor_copy = yaml_strdup(anchor);
+ if (!anchor_copy) goto error;
+ }
+
+ if (tag) {
+ if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
+ tag_copy = yaml_strdup(tag);
+ if (!tag_copy) goto error;
+ }
+
+ if (length < 0) {
+ length = strlen((char *)value);
+ }
+
+ if (!yaml_check_utf8(value, length)) goto error;
+ value_copy = YAML_MALLOC(length+1);
+ if (!value_copy) goto error;
+ memcpy(value_copy, value, length);
+ value_copy[length] = '\0';
+
+ SCALAR_EVENT_INIT(*event, anchor_copy, tag_copy, value_copy, length,
+ plain_implicit, quoted_implicit, style, mark, mark);
+
+ return 1;
+
+error:
+ yaml_free(anchor_copy);
+ yaml_free(tag_copy);
+ yaml_free(value_copy);
+
+ return 0;
+}
+
+/*
+ * Create SEQUENCE-START.
+ */
+
+YAML_DECLARE(int)
+yaml_sequence_start_event_initialize(yaml_event_t *event,
+ const yaml_char_t *anchor, const yaml_char_t *tag, int implicit,
+ yaml_sequence_style_t style)
+{
+ yaml_mark_t mark = { 0, 0, 0 };
+ yaml_char_t *anchor_copy = NULL;
+ yaml_char_t *tag_copy = NULL;
+
+ assert(event); /* Non-NULL event object is expected. */
+
+ if (anchor) {
+ if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
+ anchor_copy = yaml_strdup(anchor);
+ if (!anchor_copy) goto error;
+ }
+
+ if (tag) {
+ if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
+ tag_copy = yaml_strdup(tag);
+ if (!tag_copy) goto error;
+ }
+
+ SEQUENCE_START_EVENT_INIT(*event, anchor_copy, tag_copy,
+ implicit, style, mark, mark);
+
+ return 1;
+
+error:
+ yaml_free(anchor_copy);
+ yaml_free(tag_copy);
+
+ return 0;
+}
+
+/*
+ * Create SEQUENCE-END.
+ */
+
+YAML_DECLARE(int)
+yaml_sequence_end_event_initialize(yaml_event_t *event)
+{
+ yaml_mark_t mark = { 0, 0, 0 };
+
+ assert(event); /* Non-NULL event object is expected. */
+
+ SEQUENCE_END_EVENT_INIT(*event, mark, mark);
+
+ return 1;
+}
+
+/*
+ * Create MAPPING-START.
+ */
+
+YAML_DECLARE(int)
+yaml_mapping_start_event_initialize(yaml_event_t *event,
+ const yaml_char_t *anchor, const yaml_char_t *tag, int implicit,
+ yaml_mapping_style_t style)
+{
+ yaml_mark_t mark = { 0, 0, 0 };
+ yaml_char_t *anchor_copy = NULL;
+ yaml_char_t *tag_copy = NULL;
+
+ assert(event); /* Non-NULL event object is expected. */
+
+ if (anchor) {
+ if (!yaml_check_utf8(anchor, strlen((char *)anchor))) goto error;
+ anchor_copy = yaml_strdup(anchor);
+ if (!anchor_copy) goto error;
+ }
+
+ if (tag) {
+ if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
+ tag_copy = yaml_strdup(tag);
+ if (!tag_copy) goto error;
+ }
+
+ MAPPING_START_EVENT_INIT(*event, anchor_copy, tag_copy,
+ implicit, style, mark, mark);
+
+ return 1;
+
+error:
+ yaml_free(anchor_copy);
+ yaml_free(tag_copy);
+
+ return 0;
+}
+
+/*
+ * Create MAPPING-END.
+ */
+
+YAML_DECLARE(int)
+yaml_mapping_end_event_initialize(yaml_event_t *event)
+{
+ yaml_mark_t mark = { 0, 0, 0 };
+
+ assert(event); /* Non-NULL event object is expected. */
+
+ MAPPING_END_EVENT_INIT(*event, mark, mark);
+
+ return 1;
+}
+
+/*
+ * Destroy an event object.
+ */
+
+YAML_DECLARE(void)
+yaml_event_delete(yaml_event_t *event)
+{
+ yaml_tag_directive_t *tag_directive;
+
+ assert(event); /* Non-NULL event object expected. */
+
+ switch (event->type)
+ {
+ case YAML_DOCUMENT_START_EVENT:
+ yaml_free(event->data.document_start.version_directive);
+ for (tag_directive = event->data.document_start.tag_directives.start;
+ tag_directive != event->data.document_start.tag_directives.end;
+ tag_directive++) {
+ yaml_free(tag_directive->handle);
+ yaml_free(tag_directive->prefix);
+ }
+ yaml_free(event->data.document_start.tag_directives.start);
+ break;
+
+ case YAML_ALIAS_EVENT:
+ yaml_free(event->data.alias.anchor);
+ break;
+
+ case YAML_SCALAR_EVENT:
+ yaml_free(event->data.scalar.anchor);
+ yaml_free(event->data.scalar.tag);
+ yaml_free(event->data.scalar.value);
+ break;
+
+ case YAML_SEQUENCE_START_EVENT:
+ yaml_free(event->data.sequence_start.anchor);
+ yaml_free(event->data.sequence_start.tag);
+ break;
+
+ case YAML_MAPPING_START_EVENT:
+ yaml_free(event->data.mapping_start.anchor);
+ yaml_free(event->data.mapping_start.tag);
+ break;
+
+ default:
+ break;
+ }
+
+ memset(event, 0, sizeof(yaml_event_t));
+}
+
+/*
+ * Create a document object.
+ */
+
+YAML_DECLARE(int)
+yaml_document_initialize(yaml_document_t *document,
+ yaml_version_directive_t *version_directive,
+ yaml_tag_directive_t *tag_directives_start,
+ yaml_tag_directive_t *tag_directives_end,
+ int start_implicit, int end_implicit)
+{
+ struct {
+ yaml_error_type_t error;
+ } context;
+ struct {
+ yaml_node_t *start;
+ yaml_node_t *end;
+ yaml_node_t *top;
+ } nodes = { NULL, NULL, NULL };
+ yaml_version_directive_t *version_directive_copy = NULL;
+ struct {
+ yaml_tag_directive_t *start;
+ yaml_tag_directive_t *end;
+ yaml_tag_directive_t *top;
+ } tag_directives_copy = { NULL, NULL, NULL };
+ yaml_tag_directive_t value = { NULL, NULL };
+ yaml_mark_t mark = { 0, 0, 0 };
+
+ assert(document); /* Non-NULL document object is expected. */
+ assert((tag_directives_start && tag_directives_end) ||
+ (tag_directives_start == tag_directives_end));
+ /* Valid tag directives are expected. */
+
+ if (!STACK_INIT(&context, nodes, yaml_node_t*)) goto error;
+
+ if (version_directive) {
+ version_directive_copy = YAML_MALLOC_STATIC(yaml_version_directive_t);
+ if (!version_directive_copy) goto error;
+ version_directive_copy->major = version_directive->major;
+ version_directive_copy->minor = version_directive->minor;
+ }
+
+ if (tag_directives_start != tag_directives_end) {
+ yaml_tag_directive_t *tag_directive;
+ if (!STACK_INIT(&context, tag_directives_copy, yaml_tag_directive_t*))
+ goto error;
+ for (tag_directive = tag_directives_start;
+ tag_directive != tag_directives_end; tag_directive ++) {
+ assert(tag_directive->handle);
+ assert(tag_directive->prefix);
+ if (!yaml_check_utf8(tag_directive->handle,
+ strlen((char *)tag_directive->handle)))
+ goto error;
+ if (!yaml_check_utf8(tag_directive->prefix,
+ strlen((char *)tag_directive->prefix)))
+ goto error;
+ value.handle = yaml_strdup(tag_directive->handle);
+ value.prefix = yaml_strdup(tag_directive->prefix);
+ if (!value.handle || !value.prefix) goto error;
+ if (!PUSH(&context, tag_directives_copy, value))
+ goto error;
+ value.handle = NULL;
+ value.prefix = NULL;
+ }
+ }
+
+ DOCUMENT_INIT(*document, nodes.start, nodes.end, version_directive_copy,
+ tag_directives_copy.start, tag_directives_copy.top,
+ start_implicit, end_implicit, mark, mark);
+
+ return 1;
+
+error:
+ STACK_DEL(&context, nodes);
+ yaml_free(version_directive_copy);
+ while (!STACK_EMPTY(&context, tag_directives_copy)) {
+ yaml_tag_directive_t value = POP(&context, tag_directives_copy);
+ yaml_free(value.handle);
+ yaml_free(value.prefix);
+ }
+ STACK_DEL(&context, tag_directives_copy);
+ yaml_free(value.handle);
+ yaml_free(value.prefix);
+
+ return 0;
+}
+
+/*
+ * Destroy a document object.
+ */
+
+YAML_DECLARE(void)
+yaml_document_delete(yaml_document_t *document)
+{
+ yaml_tag_directive_t *tag_directive;
+
+ assert(document); /* Non-NULL document object is expected. */
+
+ while (!STACK_EMPTY(&context, document->nodes)) {
+ yaml_node_t node = POP(&context, document->nodes);
+ yaml_free(node.tag);
+ switch (node.type) {
+ case YAML_SCALAR_NODE:
+ yaml_free(node.data.scalar.value);
+ break;
+ case YAML_SEQUENCE_NODE:
+ STACK_DEL(&context, node.data.sequence.items);
+ break;
+ case YAML_MAPPING_NODE:
+ STACK_DEL(&context, node.data.mapping.pairs);
+ break;
+ default:
+ assert(0); /* Should not happen. */
+ }
+ }
+ STACK_DEL(&context, document->nodes);
+
+ yaml_free(document->version_directive);
+ for (tag_directive = document->tag_directives.start;
+ tag_directive != document->tag_directives.end;
+ tag_directive++) {
+ yaml_free(tag_directive->handle);
+ yaml_free(tag_directive->prefix);
+ }
+ yaml_free(document->tag_directives.start);
+
+ memset(document, 0, sizeof(yaml_document_t));
+}
+
+/**
+ * Get a document node.
+ */
+
+YAML_DECLARE(yaml_node_t *)
+yaml_document_get_node(yaml_document_t *document, int index)
+{
+ assert(document); /* Non-NULL document object is expected. */
+
+ if (index > 0 && document->nodes.start + index <= document->nodes.top) {
+ return document->nodes.start + index - 1;
+ }
+ return NULL;
+}
+
+/**
+ * Get the root object.
+ */
+
+YAML_DECLARE(yaml_node_t *)
+yaml_document_get_root_node(yaml_document_t *document)
+{
+ assert(document); /* Non-NULL document object is expected. */
+
+ if (document->nodes.top != document->nodes.start) {
+ return document->nodes.start;
+ }
+ return NULL;
+}
+
+/*
+ * Add a scalar node to a document.
+ */
+
+YAML_DECLARE(int)
+yaml_document_add_scalar(yaml_document_t *document,
+ const yaml_char_t *tag, const yaml_char_t *value, int length,
+ yaml_scalar_style_t style)
+{
+ struct {
+ yaml_error_type_t error;
+ } context;
+ yaml_mark_t mark = { 0, 0, 0 };
+ yaml_char_t *tag_copy = NULL;
+ yaml_char_t *value_copy = NULL;
+ yaml_node_t node;
+
+ assert(document); /* Non-NULL document object is expected. */
+ assert(value); /* Non-NULL value is expected. */
+
+ if (!tag) {
+ tag = (yaml_char_t *)YAML_DEFAULT_SCALAR_TAG;
+ }
+
+ if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
+ tag_copy = yaml_strdup(tag);
+ if (!tag_copy) goto error;
+
+ if (length < 0) {
+ length = strlen((char *)value);
+ }
+
+ if (!yaml_check_utf8(value, length)) goto error;
+ value_copy = YAML_MALLOC(length+1);
+ if (!value_copy) goto error;
+ memcpy(value_copy, value, length);
+ value_copy[length] = '\0';
+
+ SCALAR_NODE_INIT(node, tag_copy, value_copy, length, style, mark, mark);
+ if (!PUSH(&context, document->nodes, node)) goto error;
+
+ return document->nodes.top - document->nodes.start;
+
+error:
+ yaml_free(tag_copy);
+ yaml_free(value_copy);
+
+ return 0;
+}
+
+/*
+ * Add a sequence node to a document.
+ */
+
+YAML_DECLARE(int)
+yaml_document_add_sequence(yaml_document_t *document,
+ const yaml_char_t *tag, yaml_sequence_style_t style)
+{
+ struct {
+ yaml_error_type_t error;
+ } context;
+ yaml_mark_t mark = { 0, 0, 0 };
+ yaml_char_t *tag_copy = NULL;
+ struct {
+ yaml_node_item_t *start;
+ yaml_node_item_t *end;
+ yaml_node_item_t *top;
+ } items = { NULL, NULL, NULL };
+ yaml_node_t node;
+
+ assert(document); /* Non-NULL document object is expected. */
+
+ if (!tag) {
+ tag = (yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG;
+ }
+
+ if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
+ tag_copy = yaml_strdup(tag);
+ if (!tag_copy) goto error;
+
+ if (!STACK_INIT(&context, items, yaml_node_item_t*)) goto error;
+
+ SEQUENCE_NODE_INIT(node, tag_copy, items.start, items.end,
+ style, mark, mark);
+ if (!PUSH(&context, document->nodes, node)) goto error;
+
+ return document->nodes.top - document->nodes.start;
+
+error:
+ STACK_DEL(&context, items);
+ yaml_free(tag_copy);
+
+ return 0;
+}
+
+/*
+ * Add a mapping node to a document.
+ */
+
+YAML_DECLARE(int)
+yaml_document_add_mapping(yaml_document_t *document,
+ const yaml_char_t *tag, yaml_mapping_style_t style)
+{
+ struct {
+ yaml_error_type_t error;
+ } context;
+ yaml_mark_t mark = { 0, 0, 0 };
+ yaml_char_t *tag_copy = NULL;
+ struct {
+ yaml_node_pair_t *start;
+ yaml_node_pair_t *end;
+ yaml_node_pair_t *top;
+ } pairs = { NULL, NULL, NULL };
+ yaml_node_t node;
+
+ assert(document); /* Non-NULL document object is expected. */
+
+ if (!tag) {
+ tag = (yaml_char_t *)YAML_DEFAULT_MAPPING_TAG;
+ }
+
+ if (!yaml_check_utf8(tag, strlen((char *)tag))) goto error;
+ tag_copy = yaml_strdup(tag);
+ if (!tag_copy) goto error;
+
+ if (!STACK_INIT(&context, pairs, yaml_node_pair_t*)) goto error;
+
+ MAPPING_NODE_INIT(node, tag_copy, pairs.start, pairs.end,
+ style, mark, mark);
+ if (!PUSH(&context, document->nodes, node)) goto error;
+
+ return document->nodes.top - document->nodes.start;
+
+error:
+ STACK_DEL(&context, pairs);
+ yaml_free(tag_copy);
+
+ return 0;
+}
+
+/*
+ * Append an item to a sequence node.
+ */
+
+YAML_DECLARE(int)
+yaml_document_append_sequence_item(yaml_document_t *document,
+ int sequence, int item)
+{
+ struct {
+ yaml_error_type_t error;
+ } context;
+
+ assert(document); /* Non-NULL document is required. */
+ assert(sequence > 0
+ && document->nodes.start + sequence <= document->nodes.top);
+ /* Valid sequence id is required. */
+ assert(document->nodes.start[sequence-1].type == YAML_SEQUENCE_NODE);
+ /* A sequence node is required. */
+ assert(item > 0 && document->nodes.start + item <= document->nodes.top);
+ /* Valid item id is required. */
+
+ if (!PUSH(&context,
+ document->nodes.start[sequence-1].data.sequence.items, item))
+ return 0;
+
+ return 1;
+}
+
+/*
+ * Append a pair of a key and a value to a mapping node.
+ */
+
+YAML_DECLARE(int)
+yaml_document_append_mapping_pair(yaml_document_t *document,
+ int mapping, int key, int value)
+{
+ struct {
+ yaml_error_type_t error;
+ } context;
+
+ yaml_node_pair_t pair;
+
+ assert(document); /* Non-NULL document is required. */
+ assert(mapping > 0
+ && document->nodes.start + mapping <= document->nodes.top);
+ /* Valid mapping id is required. */
+ assert(document->nodes.start[mapping-1].type == YAML_MAPPING_NODE);
+ /* A mapping node is required. */
+ assert(key > 0 && document->nodes.start + key <= document->nodes.top);
+ /* Valid key id is required. */
+ assert(value > 0 && document->nodes.start + value <= document->nodes.top);
+ /* Valid value id is required. */
+
+ pair.key = key;
+ pair.value = value;
+
+ if (!PUSH(&context,
+ document->nodes.start[mapping-1].data.mapping.pairs, pair))
+ return 0;
+
+ return 1;
+}
+
+
diff --git a/libyaml/src/dumper.c b/libyaml/src/dumper.c
new file mode 100644
index 0000000000000000000000000000000000000000..1fe940b674dafd6174d086a1994568461b43f8ba
--- /dev/null
+++ b/libyaml/src/dumper.c
@@ -0,0 +1,394 @@
+
+#include "yaml_private.h"
+
+/*
+ * API functions.
+ */
+
+YAML_DECLARE(int)
+yaml_emitter_open(yaml_emitter_t *emitter);
+
+YAML_DECLARE(int)
+yaml_emitter_close(yaml_emitter_t *emitter);
+
+YAML_DECLARE(int)
+yaml_emitter_dump(yaml_emitter_t *emitter, yaml_document_t *document);
+
+/*
+ * Clean up functions.
+ */
+
+static void
+yaml_emitter_delete_document_and_anchors(yaml_emitter_t *emitter);
+
+/*
+ * Anchor functions.
+ */
+
+static void
+yaml_emitter_anchor_node(yaml_emitter_t *emitter, int index);
+
+static yaml_char_t *
+yaml_emitter_generate_anchor(yaml_emitter_t *emitter, int anchor_id);
+
+
+/*
+ * Serialize functions.
+ */
+
+static int
+yaml_emitter_dump_node(yaml_emitter_t *emitter, int index);
+
+static int
+yaml_emitter_dump_alias(yaml_emitter_t *emitter, yaml_char_t *anchor);
+
+static int
+yaml_emitter_dump_scalar(yaml_emitter_t *emitter, yaml_node_t *node,
+ yaml_char_t *anchor);
+
+static int
+yaml_emitter_dump_sequence(yaml_emitter_t *emitter, yaml_node_t *node,
+ yaml_char_t *anchor);
+
+static int
+yaml_emitter_dump_mapping(yaml_emitter_t *emitter, yaml_node_t *node,
+ yaml_char_t *anchor);
+
+/*
+ * Issue a STREAM-START event.
+ */
+
+YAML_DECLARE(int)
+yaml_emitter_open(yaml_emitter_t *emitter)
+{
+ yaml_event_t event;
+ yaml_mark_t mark = { 0, 0, 0 };
+
+ assert(emitter); /* Non-NULL emitter object is required. */
+ assert(!emitter->opened); /* Emitter should not be opened yet. */
+
+ STREAM_START_EVENT_INIT(event, YAML_ANY_ENCODING, mark, mark);
+
+ if (!yaml_emitter_emit(emitter, &event)) {
+ return 0;
+ }
+
+ emitter->opened = 1;
+
+ return 1;
+}
+
+/*
+ * Issue a STREAM-END event.
+ */
+
+YAML_DECLARE(int)
+yaml_emitter_close(yaml_emitter_t *emitter)
+{
+ yaml_event_t event;
+ yaml_mark_t mark = { 0, 0, 0 };
+
+ assert(emitter); /* Non-NULL emitter object is required. */
+ assert(emitter->opened); /* Emitter should be opened. */
+
+ if (emitter->closed) return 1;
+
+ STREAM_END_EVENT_INIT(event, mark, mark);
+
+ if (!yaml_emitter_emit(emitter, &event)) {
+ return 0;
+ }
+
+ emitter->closed = 1;
+
+ return 1;
+}
+
+/*
+ * Dump a YAML document.
+ */
+
+YAML_DECLARE(int)
+yaml_emitter_dump(yaml_emitter_t *emitter, yaml_document_t *document)
+{
+ yaml_event_t event;
+ yaml_mark_t mark = { 0, 0, 0 };
+
+ assert(emitter); /* Non-NULL emitter object is required. */
+ assert(document); /* Non-NULL emitter object is expected. */
+
+ emitter->document = document;
+
+ if (!emitter->opened) {
+ if (!yaml_emitter_open(emitter)) goto error;
+ }
+
+ if (STACK_EMPTY(emitter, document->nodes)) {
+ if (!yaml_emitter_close(emitter)) goto error;
+ yaml_emitter_delete_document_and_anchors(emitter);
+ return 1;
+ }
+
+ assert(emitter->opened); /* Emitter should be opened. */
+
+ emitter->anchors = (yaml_anchors_t*)yaml_malloc(sizeof(*(emitter->anchors))
+ * (document->nodes.top - document->nodes.start));
+ if (!emitter->anchors) goto error;
+ memset(emitter->anchors, 0, sizeof(*(emitter->anchors))
+ * (document->nodes.top - document->nodes.start));
+
+ DOCUMENT_START_EVENT_INIT(event, document->version_directive,
+ document->tag_directives.start, document->tag_directives.end,
+ document->start_implicit, mark, mark);
+ if (!yaml_emitter_emit(emitter, &event)) goto error;
+
+ yaml_emitter_anchor_node(emitter, 1);
+ if (!yaml_emitter_dump_node(emitter, 1)) goto error;
+
+ DOCUMENT_END_EVENT_INIT(event, document->end_implicit, mark, mark);
+ if (!yaml_emitter_emit(emitter, &event)) goto error;
+
+ yaml_emitter_delete_document_and_anchors(emitter);
+
+ return 1;
+
+error:
+
+ yaml_emitter_delete_document_and_anchors(emitter);
+
+ return 0;
+}
+
+/*
+ * Clean up the emitter object after a document is dumped.
+ */
+
+static void
+yaml_emitter_delete_document_and_anchors(yaml_emitter_t *emitter)
+{
+ int index;
+
+ if (!emitter->anchors) {
+ yaml_document_delete(emitter->document);
+ emitter->document = NULL;
+ return;
+ }
+
+ for (index = 0; emitter->document->nodes.start + index
+ < emitter->document->nodes.top; index ++) {
+ yaml_node_t node = emitter->document->nodes.start[index];
+ if (!emitter->anchors[index].serialized) {
+ yaml_free(node.tag);
+ if (node.type == YAML_SCALAR_NODE) {
+ yaml_free(node.data.scalar.value);
+ }
+ }
+ if (node.type == YAML_SEQUENCE_NODE) {
+ STACK_DEL(emitter, node.data.sequence.items);
+ }
+ if (node.type == YAML_MAPPING_NODE) {
+ STACK_DEL(emitter, node.data.mapping.pairs);
+ }
+ }
+
+ STACK_DEL(emitter, emitter->document->nodes);
+ yaml_free(emitter->anchors);
+
+ emitter->anchors = NULL;
+ emitter->last_anchor_id = 0;
+ emitter->document = NULL;
+}
+
+/*
+ * Check the references of a node and assign the anchor id if needed.
+ */
+
+static void
+yaml_emitter_anchor_node(yaml_emitter_t *emitter, int index)
+{
+ yaml_node_t *node = emitter->document->nodes.start + index - 1;
+ yaml_node_item_t *item;
+ yaml_node_pair_t *pair;
+
+ emitter->anchors[index-1].references ++;
+
+ if (emitter->anchors[index-1].references == 1) {
+ switch (node->type) {
+ case YAML_SEQUENCE_NODE:
+ for (item = node->data.sequence.items.start;
+ item < node->data.sequence.items.top; item ++) {
+ yaml_emitter_anchor_node(emitter, *item);
+ }
+ break;
+ case YAML_MAPPING_NODE:
+ for (pair = node->data.mapping.pairs.start;
+ pair < node->data.mapping.pairs.top; pair ++) {
+ yaml_emitter_anchor_node(emitter, pair->key);
+ yaml_emitter_anchor_node(emitter, pair->value);
+ }
+ break;
+ default:
+ break;
+ }
+ }
+
+ else if (emitter->anchors[index-1].references == 2) {
+ emitter->anchors[index-1].anchor = (++ emitter->last_anchor_id);
+ }
+}
+
+/*
+ * Generate a textual representation for an anchor.
+ */
+
+#define ANCHOR_TEMPLATE "id%03d"
+#define ANCHOR_TEMPLATE_LENGTH 16
+
+static yaml_char_t *
+yaml_emitter_generate_anchor(SHIM(yaml_emitter_t *emitter), int anchor_id)
+{
+ yaml_char_t *anchor = YAML_MALLOC(ANCHOR_TEMPLATE_LENGTH);
+
+ if (!anchor) return NULL;
+
+ sprintf((char *)anchor, ANCHOR_TEMPLATE, anchor_id);
+
+ return anchor;
+}
+
+/*
+ * Serialize a node.
+ */
+
+static int
+yaml_emitter_dump_node(yaml_emitter_t *emitter, int index)
+{
+ yaml_node_t *node = emitter->document->nodes.start + index - 1;
+ int anchor_id = emitter->anchors[index-1].anchor;
+ yaml_char_t *anchor = NULL;
+
+ if (anchor_id) {
+ anchor = yaml_emitter_generate_anchor(emitter, anchor_id);
+ if (!anchor) return 0;
+ }
+
+ if (emitter->anchors[index-1].serialized) {
+ return yaml_emitter_dump_alias(emitter, anchor);
+ }
+
+ emitter->anchors[index-1].serialized = 1;
+
+ switch (node->type) {
+ case YAML_SCALAR_NODE:
+ return yaml_emitter_dump_scalar(emitter, node, anchor);
+ case YAML_SEQUENCE_NODE:
+ return yaml_emitter_dump_sequence(emitter, node, anchor);
+ case YAML_MAPPING_NODE:
+ return yaml_emitter_dump_mapping(emitter, node, anchor);
+ default:
+ assert(0); /* Could not happen. */
+ break;
+ }
+
+ return 0; /* Could not happen. */
+}
+
+/*
+ * Serialize an alias.
+ */
+
+static int
+yaml_emitter_dump_alias(yaml_emitter_t *emitter, yaml_char_t *anchor)
+{
+ yaml_event_t event;
+ yaml_mark_t mark = { 0, 0, 0 };
+
+ ALIAS_EVENT_INIT(event, anchor, mark, mark);
+
+ return yaml_emitter_emit(emitter, &event);
+}
+
+/*
+ * Serialize a scalar.
+ */
+
+static int
+yaml_emitter_dump_scalar(yaml_emitter_t *emitter, yaml_node_t *node,
+ yaml_char_t *anchor)
+{
+ yaml_event_t event;
+ yaml_mark_t mark = { 0, 0, 0 };
+
+ int plain_implicit = (strcmp((char *)node->tag,
+ YAML_DEFAULT_SCALAR_TAG) == 0);
+ int quoted_implicit = (strcmp((char *)node->tag,
+ YAML_DEFAULT_SCALAR_TAG) == 0);
+
+ SCALAR_EVENT_INIT(event, anchor, node->tag, node->data.scalar.value,
+ node->data.scalar.length, plain_implicit, quoted_implicit,
+ node->data.scalar.style, mark, mark);
+
+ return yaml_emitter_emit(emitter, &event);
+}
+
+/*
+ * Serialize a sequence.
+ */
+
+static int
+yaml_emitter_dump_sequence(yaml_emitter_t *emitter, yaml_node_t *node,
+ yaml_char_t *anchor)
+{
+ yaml_event_t event;
+ yaml_mark_t mark = { 0, 0, 0 };
+
+ int implicit = (strcmp((char *)node->tag, YAML_DEFAULT_SEQUENCE_TAG) == 0);
+
+ yaml_node_item_t *item;
+
+ SEQUENCE_START_EVENT_INIT(event, anchor, node->tag, implicit,
+ node->data.sequence.style, mark, mark);
+ if (!yaml_emitter_emit(emitter, &event)) return 0;
+
+ for (item = node->data.sequence.items.start;
+ item < node->data.sequence.items.top; item ++) {
+ if (!yaml_emitter_dump_node(emitter, *item)) return 0;
+ }
+
+ SEQUENCE_END_EVENT_INIT(event, mark, mark);
+ if (!yaml_emitter_emit(emitter, &event)) return 0;
+
+ return 1;
+}
+
+/*
+ * Serialize a mapping.
+ */
+
+static int
+yaml_emitter_dump_mapping(yaml_emitter_t *emitter, yaml_node_t *node,
+ yaml_char_t *anchor)
+{
+ yaml_event_t event;
+ yaml_mark_t mark = { 0, 0, 0 };
+
+ int implicit = (strcmp((char *)node->tag, YAML_DEFAULT_MAPPING_TAG) == 0);
+
+ yaml_node_pair_t *pair;
+
+ MAPPING_START_EVENT_INIT(event, anchor, node->tag, implicit,
+ node->data.mapping.style, mark, mark);
+ if (!yaml_emitter_emit(emitter, &event)) return 0;
+
+ for (pair = node->data.mapping.pairs.start;
+ pair < node->data.mapping.pairs.top; pair ++) {
+ if (!yaml_emitter_dump_node(emitter, pair->key)) return 0;
+ if (!yaml_emitter_dump_node(emitter, pair->value)) return 0;
+ }
+
+ MAPPING_END_EVENT_INIT(event, mark, mark);
+ if (!yaml_emitter_emit(emitter, &event)) return 0;
+
+ return 1;
+}
+
diff --git a/libyaml/src/emitter.c b/libyaml/src/emitter.c
new file mode 100644
index 0000000000000000000000000000000000000000..609b28a4c6e1b025ee973eebe655ea73905c8ac2
--- /dev/null
+++ b/libyaml/src/emitter.c
@@ -0,0 +1,2358 @@
+
+#include "yaml_private.h"
+
+/*
+ * Flush the buffer if needed.
+ */
+
+#define FLUSH(emitter) \
+ ((emitter->buffer.pointer+5 < emitter->buffer.end) \
+ || yaml_emitter_flush(emitter))
+
+/*
+ * Put a character to the output buffer.
+ */
+
+#define PUT(emitter,value) \
+ (FLUSH(emitter) \
+ && (*(emitter->buffer.pointer++) = (yaml_char_t)(value), \
+ emitter->column++, \
+ 1))
+
+/*
+ * Put a line break to the output buffer.
+ */
+
+#define PUT_BREAK(emitter) \
+ (FLUSH(emitter) \
+ && ((emitter->line_break == YAML_CR_BREAK ? \
+ (*(emitter->buffer.pointer++) = (yaml_char_t) '\r') : \
+ emitter->line_break == YAML_LN_BREAK ? \
+ (*(emitter->buffer.pointer++) = (yaml_char_t) '\n') : \
+ emitter->line_break == YAML_CRLN_BREAK ? \
+ (*(emitter->buffer.pointer++) = (yaml_char_t) '\r', \
+ *(emitter->buffer.pointer++) = (yaml_char_t) '\n') : 0), \
+ emitter->column = 0, \
+ emitter->line ++, \
+ 1))
+
+/*
+ * Copy a character from a string into buffer.
+ */
+
+#define WRITE(emitter,string) \
+ (FLUSH(emitter) \
+ && (COPY(emitter->buffer,string), \
+ emitter->column ++, \
+ 1))
+
+/*
+ * Copy a line break character from a string into buffer.
+ */
+
+#define WRITE_BREAK(emitter,string) \
+ (FLUSH(emitter) \
+ && (CHECK(string,'\n') ? \
+ (PUT_BREAK(emitter), \
+ string.pointer ++, \
+ 1) : \
+ (COPY(emitter->buffer,string), \
+ emitter->column = 0, \
+ emitter->line ++, \
+ 1)))
+
+/*
+ * API functions.
+ */
+
+YAML_DECLARE(int)
+yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event);
+
+/*
+ * Utility functions.
+ */
+
+static int
+yaml_emitter_set_emitter_error(yaml_emitter_t *emitter, const char *problem);
+
+static int
+yaml_emitter_need_more_events(yaml_emitter_t *emitter);
+
+static int
+yaml_emitter_append_tag_directive(yaml_emitter_t *emitter,
+ yaml_tag_directive_t value, int allow_duplicates);
+
+static int
+yaml_emitter_increase_indent(yaml_emitter_t *emitter,
+ int flow, int indentless);
+
+/*
+ * State functions.
+ */
+
+static int
+yaml_emitter_state_machine(yaml_emitter_t *emitter, yaml_event_t *event);
+
+static int
+yaml_emitter_emit_stream_start(yaml_emitter_t *emitter,
+ yaml_event_t *event);
+
+static int
+yaml_emitter_emit_document_start(yaml_emitter_t *emitter,
+ yaml_event_t *event, int first);
+
+static int
+yaml_emitter_emit_document_content(yaml_emitter_t *emitter,
+ yaml_event_t *event);
+
+static int
+yaml_emitter_emit_document_end(yaml_emitter_t *emitter,
+ yaml_event_t *event);
+
+static int
+yaml_emitter_emit_flow_sequence_item(yaml_emitter_t *emitter,
+ yaml_event_t *event, int first);
+
+static int
+yaml_emitter_emit_flow_mapping_key(yaml_emitter_t *emitter,
+ yaml_event_t *event, int first);
+
+static int
+yaml_emitter_emit_flow_mapping_value(yaml_emitter_t *emitter,
+ yaml_event_t *event, int simple);
+
+static int
+yaml_emitter_emit_block_sequence_item(yaml_emitter_t *emitter,
+ yaml_event_t *event, int first);
+
+static int
+yaml_emitter_emit_block_mapping_key(yaml_emitter_t *emitter,
+ yaml_event_t *event, int first);
+
+static int
+yaml_emitter_emit_block_mapping_value(yaml_emitter_t *emitter,
+ yaml_event_t *event, int simple);
+
+static int
+yaml_emitter_emit_node(yaml_emitter_t *emitter, yaml_event_t *event,
+ int root, int sequence, int mapping, int simple_key);
+
+static int
+yaml_emitter_emit_alias(yaml_emitter_t *emitter, yaml_event_t *event);
+
+static int
+yaml_emitter_emit_scalar(yaml_emitter_t *emitter, yaml_event_t *event);
+
+static int
+yaml_emitter_emit_sequence_start(yaml_emitter_t *emitter, yaml_event_t *event);
+
+static int
+yaml_emitter_emit_mapping_start(yaml_emitter_t *emitter, yaml_event_t *event);
+
+/*
+ * Checkers.
+ */
+
+static int
+yaml_emitter_check_empty_document(yaml_emitter_t *emitter);
+
+static int
+yaml_emitter_check_empty_sequence(yaml_emitter_t *emitter);
+
+static int
+yaml_emitter_check_empty_mapping(yaml_emitter_t *emitter);
+
+static int
+yaml_emitter_check_simple_key(yaml_emitter_t *emitter);
+
+static int
+yaml_emitter_select_scalar_style(yaml_emitter_t *emitter, yaml_event_t *event);
+
+/*
+ * Processors.
+ */
+
+static int
+yaml_emitter_process_anchor(yaml_emitter_t *emitter);
+
+static int
+yaml_emitter_process_tag(yaml_emitter_t *emitter);
+
+static int
+yaml_emitter_process_scalar(yaml_emitter_t *emitter);
+
+/*
+ * Analyzers.
+ */
+
+static int
+yaml_emitter_analyze_version_directive(yaml_emitter_t *emitter,
+ yaml_version_directive_t version_directive);
+
+static int
+yaml_emitter_analyze_tag_directive(yaml_emitter_t *emitter,
+ yaml_tag_directive_t tag_directive);
+
+static int
+yaml_emitter_analyze_anchor(yaml_emitter_t *emitter,
+ yaml_char_t *anchor, int alias);
+
+static int
+yaml_emitter_analyze_tag(yaml_emitter_t *emitter,
+ yaml_char_t *tag);
+
+static int
+yaml_emitter_analyze_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length);
+
+static int
+yaml_emitter_analyze_event(yaml_emitter_t *emitter,
+ yaml_event_t *event);
+
+/*
+ * Writers.
+ */
+
+static int
+yaml_emitter_write_bom(yaml_emitter_t *emitter);
+
+static int
+yaml_emitter_write_indent(yaml_emitter_t *emitter);
+
+static int
+yaml_emitter_write_indicator(yaml_emitter_t *emitter,
+ const char *indicator, int need_whitespace,
+ int is_whitespace, int is_indention);
+
+static int
+yaml_emitter_write_anchor(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length);
+
+static int
+yaml_emitter_write_tag_handle(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length);
+
+static int
+yaml_emitter_write_tag_content(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length, int need_whitespace);
+
+static int
+yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length, int allow_breaks);
+
+static int
+yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length, int allow_breaks);
+
+static int
+yaml_emitter_write_double_quoted_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length, int allow_breaks);
+
+static int
+yaml_emitter_write_block_scalar_hints(yaml_emitter_t *emitter,
+ yaml_string_t string);
+
+static int
+yaml_emitter_write_literal_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length);
+
+static int
+yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length);
+
+/*
+ * Set an emitter error and return 0.
+ */
+
+static int
+yaml_emitter_set_emitter_error(yaml_emitter_t *emitter, const char *problem)
+{
+ emitter->error = YAML_EMITTER_ERROR;
+ emitter->problem = problem;
+
+ return 0;
+}
+
+/*
+ * Emit an event.
+ */
+
+YAML_DECLARE(int)
+yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event)
+{
+ if (!ENQUEUE(emitter, emitter->events, *event)) {
+ yaml_event_delete(event);
+ return 0;
+ }
+
+ while (!yaml_emitter_need_more_events(emitter)) {
+ if (!yaml_emitter_analyze_event(emitter, emitter->events.head))
+ return 0;
+ if (!yaml_emitter_state_machine(emitter, emitter->events.head))
+ return 0;
+ yaml_event_delete(&DEQUEUE(emitter, emitter->events));
+ }
+
+ return 1;
+}
+
+/*
+ * Check if we need to accumulate more events before emitting.
+ *
+ * We accumulate extra
+ * - 1 event for DOCUMENT-START
+ * - 2 events for SEQUENCE-START
+ * - 3 events for MAPPING-START
+ */
+
+static int
+yaml_emitter_need_more_events(yaml_emitter_t *emitter)
+{
+ int level = 0;
+ int accumulate = 0;
+ yaml_event_t *event;
+
+ if (QUEUE_EMPTY(emitter, emitter->events))
+ return 1;
+
+ switch (emitter->events.head->type) {
+ case YAML_DOCUMENT_START_EVENT:
+ accumulate = 1;
+ break;
+ case YAML_SEQUENCE_START_EVENT:
+ accumulate = 2;
+ break;
+ case YAML_MAPPING_START_EVENT:
+ accumulate = 3;
+ break;
+ default:
+ return 0;
+ }
+
+ if (emitter->events.tail - emitter->events.head > accumulate)
+ return 0;
+
+ for (event = emitter->events.head; event != emitter->events.tail; event ++) {
+ switch (event->type) {
+ case YAML_STREAM_START_EVENT:
+ case YAML_DOCUMENT_START_EVENT:
+ case YAML_SEQUENCE_START_EVENT:
+ case YAML_MAPPING_START_EVENT:
+ level += 1;
+ break;
+ case YAML_STREAM_END_EVENT:
+ case YAML_DOCUMENT_END_EVENT:
+ case YAML_SEQUENCE_END_EVENT:
+ case YAML_MAPPING_END_EVENT:
+ level -= 1;
+ break;
+ default:
+ break;
+ }
+ if (!level)
+ return 0;
+ }
+
+ return 1;
+}
+
+/*
+ * Append a directive to the directives stack.
+ */
+
+static int
+yaml_emitter_append_tag_directive(yaml_emitter_t *emitter,
+ yaml_tag_directive_t value, int allow_duplicates)
+{
+ yaml_tag_directive_t *tag_directive;
+ yaml_tag_directive_t copy = { NULL, NULL };
+
+ for (tag_directive = emitter->tag_directives.start;
+ tag_directive != emitter->tag_directives.top; tag_directive ++) {
+ if (strcmp((char *)value.handle, (char *)tag_directive->handle) == 0) {
+ if (allow_duplicates)
+ return 1;
+ return yaml_emitter_set_emitter_error(emitter,
+ "duplicate %TAG directive");
+ }
+ }
+
+ copy.handle = yaml_strdup(value.handle);
+ copy.prefix = yaml_strdup(value.prefix);
+ if (!copy.handle || !copy.prefix) {
+ emitter->error = YAML_MEMORY_ERROR;
+ goto error;
+ }
+
+ if (!PUSH(emitter, emitter->tag_directives, copy))
+ goto error;
+
+ return 1;
+
+error:
+ yaml_free(copy.handle);
+ yaml_free(copy.prefix);
+ return 0;
+}
+
+/*
+ * Increase the indentation level.
+ */
+
+static int
+yaml_emitter_increase_indent(yaml_emitter_t *emitter,
+ int flow, int indentless)
+{
+ if (!PUSH(emitter, emitter->indents, emitter->indent))
+ return 0;
+
+ if (emitter->indent < 0) {
+ emitter->indent = flow ? emitter->best_indent : 0;
+ }
+ else if (!indentless) {
+ emitter->indent += emitter->best_indent;
+ }
+
+ return 1;
+}
+
+/*
+ * State dispatcher.
+ */
+
+static int
+yaml_emitter_state_machine(yaml_emitter_t *emitter, yaml_event_t *event)
+{
+ switch (emitter->state)
+ {
+ case YAML_EMIT_STREAM_START_STATE:
+ return yaml_emitter_emit_stream_start(emitter, event);
+
+ case YAML_EMIT_FIRST_DOCUMENT_START_STATE:
+ return yaml_emitter_emit_document_start(emitter, event, 1);
+
+ case YAML_EMIT_DOCUMENT_START_STATE:
+ return yaml_emitter_emit_document_start(emitter, event, 0);
+
+ case YAML_EMIT_DOCUMENT_CONTENT_STATE:
+ return yaml_emitter_emit_document_content(emitter, event);
+
+ case YAML_EMIT_DOCUMENT_END_STATE:
+ return yaml_emitter_emit_document_end(emitter, event);
+
+ case YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE:
+ return yaml_emitter_emit_flow_sequence_item(emitter, event, 1);
+
+ case YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE:
+ return yaml_emitter_emit_flow_sequence_item(emitter, event, 0);
+
+ case YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE:
+ return yaml_emitter_emit_flow_mapping_key(emitter, event, 1);
+
+ case YAML_EMIT_FLOW_MAPPING_KEY_STATE:
+ return yaml_emitter_emit_flow_mapping_key(emitter, event, 0);
+
+ case YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE:
+ return yaml_emitter_emit_flow_mapping_value(emitter, event, 1);
+
+ case YAML_EMIT_FLOW_MAPPING_VALUE_STATE:
+ return yaml_emitter_emit_flow_mapping_value(emitter, event, 0);
+
+ case YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE:
+ return yaml_emitter_emit_block_sequence_item(emitter, event, 1);
+
+ case YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE:
+ return yaml_emitter_emit_block_sequence_item(emitter, event, 0);
+
+ case YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE:
+ return yaml_emitter_emit_block_mapping_key(emitter, event, 1);
+
+ case YAML_EMIT_BLOCK_MAPPING_KEY_STATE:
+ return yaml_emitter_emit_block_mapping_key(emitter, event, 0);
+
+ case YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE:
+ return yaml_emitter_emit_block_mapping_value(emitter, event, 1);
+
+ case YAML_EMIT_BLOCK_MAPPING_VALUE_STATE:
+ return yaml_emitter_emit_block_mapping_value(emitter, event, 0);
+
+ case YAML_EMIT_END_STATE:
+ return yaml_emitter_set_emitter_error(emitter,
+ "expected nothing after STREAM-END");
+
+ default:
+ assert(1); /* Invalid state. */
+ }
+
+ return 0;
+}
+
+/*
+ * Expect STREAM-START.
+ */
+
+static int
+yaml_emitter_emit_stream_start(yaml_emitter_t *emitter,
+ yaml_event_t *event)
+{
+ emitter->open_ended = 0;
+ if (event->type == YAML_STREAM_START_EVENT)
+ {
+ if (!emitter->encoding) {
+ emitter->encoding = event->data.stream_start.encoding;
+ }
+
+ if (!emitter->encoding) {
+ emitter->encoding = YAML_UTF8_ENCODING;
+ }
+
+ if (emitter->best_indent < 2 || emitter->best_indent > 9) {
+ emitter->best_indent = 2;
+ }
+
+ if (emitter->best_width >= 0
+ && emitter->best_width <= emitter->best_indent*2) {
+ emitter->best_width = 80;
+ }
+
+ if (emitter->best_width < 0) {
+ emitter->best_width = INT_MAX;
+ }
+
+ if (!emitter->line_break) {
+ emitter->line_break = YAML_LN_BREAK;
+ }
+
+ emitter->indent = -1;
+
+ emitter->line = 0;
+ emitter->column = 0;
+ emitter->whitespace = 1;
+ emitter->indention = 1;
+
+ if (emitter->encoding != YAML_UTF8_ENCODING) {
+ if (!yaml_emitter_write_bom(emitter))
+ return 0;
+ }
+
+ emitter->state = YAML_EMIT_FIRST_DOCUMENT_START_STATE;
+
+ return 1;
+ }
+
+ return yaml_emitter_set_emitter_error(emitter,
+ "expected STREAM-START");
+}
+
+/*
+ * Expect DOCUMENT-START or STREAM-END.
+ */
+
+static int
+yaml_emitter_emit_document_start(yaml_emitter_t *emitter,
+ yaml_event_t *event, int first)
+{
+ if (event->type == YAML_DOCUMENT_START_EVENT)
+ {
+ yaml_tag_directive_t default_tag_directives[] = {
+ {(yaml_char_t *)"!", (yaml_char_t *)"!"},
+ {(yaml_char_t *)"!!", (yaml_char_t *)"tag:yaml.org,2002:"},
+ {NULL, NULL}
+ };
+ yaml_tag_directive_t *tag_directive;
+ int implicit;
+
+ if (event->data.document_start.version_directive) {
+ if (!yaml_emitter_analyze_version_directive(emitter,
+ *event->data.document_start.version_directive))
+ return 0;
+ }
+
+ for (tag_directive = event->data.document_start.tag_directives.start;
+ tag_directive != event->data.document_start.tag_directives.end;
+ tag_directive ++) {
+ if (!yaml_emitter_analyze_tag_directive(emitter, *tag_directive))
+ return 0;
+ if (!yaml_emitter_append_tag_directive(emitter, *tag_directive, 0))
+ return 0;
+ }
+
+ for (tag_directive = default_tag_directives;
+ tag_directive->handle; tag_directive ++) {
+ if (!yaml_emitter_append_tag_directive(emitter, *tag_directive, 1))
+ return 0;
+ }
+
+ implicit = event->data.document_start.implicit;
+ if (!first || emitter->canonical) {
+ implicit = 0;
+ }
+
+ if ((event->data.document_start.version_directive ||
+ (event->data.document_start.tag_directives.start
+ != event->data.document_start.tag_directives.end)) &&
+ emitter->open_ended)
+ {
+ if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0))
+ return 0;
+ if (!yaml_emitter_write_indent(emitter))
+ return 0;
+ }
+ emitter->open_ended = 0;
+
+ if (event->data.document_start.version_directive) {
+ implicit = 0;
+ if (!yaml_emitter_write_indicator(emitter, "%YAML", 1, 0, 0))
+ return 0;
+ if (event->data.document_start.version_directive->minor == 1) {
+ if (!yaml_emitter_write_indicator(emitter, "1.1", 1, 0, 0))
+ return 0;
+ }
+ else {
+ if (!yaml_emitter_write_indicator(emitter, "1.2", 1, 0, 0))
+ return 0;
+ }
+ if (!yaml_emitter_write_indent(emitter))
+ return 0;
+ }
+
+ if (event->data.document_start.tag_directives.start
+ != event->data.document_start.tag_directives.end) {
+ implicit = 0;
+ for (tag_directive = event->data.document_start.tag_directives.start;
+ tag_directive != event->data.document_start.tag_directives.end;
+ tag_directive ++) {
+ if (!yaml_emitter_write_indicator(emitter, "%TAG", 1, 0, 0))
+ return 0;
+ if (!yaml_emitter_write_tag_handle(emitter, tag_directive->handle,
+ strlen((char *)tag_directive->handle)))
+ return 0;
+ if (!yaml_emitter_write_tag_content(emitter, tag_directive->prefix,
+ strlen((char *)tag_directive->prefix), 1))
+ return 0;
+ if (!yaml_emitter_write_indent(emitter))
+ return 0;
+ }
+ }
+
+ if (yaml_emitter_check_empty_document(emitter)) {
+ implicit = 0;
+ }
+
+ if (!implicit) {
+ if (!yaml_emitter_write_indent(emitter))
+ return 0;
+ if (!yaml_emitter_write_indicator(emitter, "---", 1, 0, 0))
+ return 0;
+ if (emitter->canonical) {
+ if (!yaml_emitter_write_indent(emitter))
+ return 0;
+ }
+ }
+
+ emitter->state = YAML_EMIT_DOCUMENT_CONTENT_STATE;
+
+ emitter->open_ended = 0;
+ return 1;
+ }
+
+ else if (event->type == YAML_STREAM_END_EVENT)
+ {
+
+ /**
+ * This can happen if a block scalar with trailing empty lines
+ * is at the end of the stream
+ */
+ if (emitter->open_ended == 2)
+ {
+ if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0))
+ return 0;
+ emitter->open_ended = 0;
+ if (!yaml_emitter_write_indent(emitter))
+ return 0;
+ }
+ if (!yaml_emitter_flush(emitter))
+ return 0;
+
+ emitter->state = YAML_EMIT_END_STATE;
+
+ return 1;
+ }
+
+ return yaml_emitter_set_emitter_error(emitter,
+ "expected DOCUMENT-START or STREAM-END");
+}
+
+/*
+ * Expect the root node.
+ */
+
+static int
+yaml_emitter_emit_document_content(yaml_emitter_t *emitter,
+ yaml_event_t *event)
+{
+ if (!PUSH(emitter, emitter->states, YAML_EMIT_DOCUMENT_END_STATE))
+ return 0;
+
+ return yaml_emitter_emit_node(emitter, event, 1, 0, 0, 0);
+}
+
+/*
+ * Expect DOCUMENT-END.
+ */
+
+static int
+yaml_emitter_emit_document_end(yaml_emitter_t *emitter,
+ yaml_event_t *event)
+{
+ if (event->type == YAML_DOCUMENT_END_EVENT)
+ {
+ if (!yaml_emitter_write_indent(emitter))
+ return 0;
+ if (!event->data.document_end.implicit) {
+ if (!yaml_emitter_write_indicator(emitter, "...", 1, 0, 0))
+ return 0;
+ emitter->open_ended = 0;
+ if (!yaml_emitter_write_indent(emitter))
+ return 0;
+ }
+ else if (!emitter->open_ended)
+ emitter->open_ended = 1;
+ if (!yaml_emitter_flush(emitter))
+ return 0;
+
+ emitter->state = YAML_EMIT_DOCUMENT_START_STATE;
+
+ while (!STACK_EMPTY(emitter, emitter->tag_directives)) {
+ yaml_tag_directive_t tag_directive = POP(emitter,
+ emitter->tag_directives);
+ yaml_free(tag_directive.handle);
+ yaml_free(tag_directive.prefix);
+ }
+
+ return 1;
+ }
+
+ return yaml_emitter_set_emitter_error(emitter,
+ "expected DOCUMENT-END");
+}
+
+/*
+ *
+ * Expect a flow item node.
+ */
+
+static int
+yaml_emitter_emit_flow_sequence_item(yaml_emitter_t *emitter,
+ yaml_event_t *event, int first)
+{
+ if (first)
+ {
+ if (!yaml_emitter_write_indicator(emitter, "[", 1, 1, 0))
+ return 0;
+ if (!yaml_emitter_increase_indent(emitter, 1, 0))
+ return 0;
+ emitter->flow_level ++;
+ }
+
+ if (event->type == YAML_SEQUENCE_END_EVENT)
+ {
+ emitter->flow_level --;
+ emitter->indent = POP(emitter, emitter->indents);
+ if (emitter->canonical && !first) {
+ if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0))
+ return 0;
+ if (!yaml_emitter_write_indent(emitter))
+ return 0;
+ }
+ if (!yaml_emitter_write_indicator(emitter, "]", 0, 0, 0))
+ return 0;
+ emitter->state = POP(emitter, emitter->states);
+
+ return 1;
+ }
+
+ if (!first) {
+ if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0))
+ return 0;
+ }
+
+ if (emitter->canonical || emitter->column > emitter->best_width) {
+ if (!yaml_emitter_write_indent(emitter))
+ return 0;
+ }
+ if (!PUSH(emitter, emitter->states, YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE))
+ return 0;
+
+ return yaml_emitter_emit_node(emitter, event, 0, 1, 0, 0);
+}
+
+/*
+ * Expect a flow key node.
+ */
+
+static int
+yaml_emitter_emit_flow_mapping_key(yaml_emitter_t *emitter,
+ yaml_event_t *event, int first)
+{
+ if (first)
+ {
+ if (!yaml_emitter_write_indicator(emitter, "{", 1, 1, 0))
+ return 0;
+ if (!yaml_emitter_increase_indent(emitter, 1, 0))
+ return 0;
+ emitter->flow_level ++;
+ }
+
+ if (event->type == YAML_MAPPING_END_EVENT)
+ {
+ emitter->flow_level --;
+ emitter->indent = POP(emitter, emitter->indents);
+ if (emitter->canonical && !first) {
+ if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0))
+ return 0;
+ if (!yaml_emitter_write_indent(emitter))
+ return 0;
+ }
+ if (!yaml_emitter_write_indicator(emitter, "}", 0, 0, 0))
+ return 0;
+ emitter->state = POP(emitter, emitter->states);
+
+ return 1;
+ }
+
+ if (!first) {
+ if (!yaml_emitter_write_indicator(emitter, ",", 0, 0, 0))
+ return 0;
+ }
+ if (emitter->canonical || emitter->column > emitter->best_width) {
+ if (!yaml_emitter_write_indent(emitter))
+ return 0;
+ }
+
+ if (!emitter->canonical && yaml_emitter_check_simple_key(emitter))
+ {
+ if (!PUSH(emitter, emitter->states,
+ YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE))
+ return 0;
+
+ return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 1);
+ }
+ else
+ {
+ if (!yaml_emitter_write_indicator(emitter, "?", 1, 0, 0))
+ return 0;
+ if (!PUSH(emitter, emitter->states,
+ YAML_EMIT_FLOW_MAPPING_VALUE_STATE))
+ return 0;
+
+ return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0);
+ }
+}
+
+/*
+ * Expect a flow value node.
+ */
+
+static int
+yaml_emitter_emit_flow_mapping_value(yaml_emitter_t *emitter,
+ yaml_event_t *event, int simple)
+{
+ if (simple) {
+ if (!yaml_emitter_write_indicator(emitter, ":", 0, 0, 0))
+ return 0;
+ }
+ else {
+ if (emitter->canonical || emitter->column > emitter->best_width) {
+ if (!yaml_emitter_write_indent(emitter))
+ return 0;
+ }
+ if (!yaml_emitter_write_indicator(emitter, ":", 1, 0, 0))
+ return 0;
+ }
+ if (!PUSH(emitter, emitter->states, YAML_EMIT_FLOW_MAPPING_KEY_STATE))
+ return 0;
+ return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0);
+}
+
+/*
+ * Expect a block item node.
+ */
+
+static int
+yaml_emitter_emit_block_sequence_item(yaml_emitter_t *emitter,
+ yaml_event_t *event, int first)
+{
+ if (first)
+ {
+ if (!yaml_emitter_increase_indent(emitter, 0,
+ (emitter->mapping_context && !emitter->indention)))
+ return 0;
+ }
+
+ if (event->type == YAML_SEQUENCE_END_EVENT)
+ {
+ emitter->indent = POP(emitter, emitter->indents);
+ emitter->state = POP(emitter, emitter->states);
+
+ return 1;
+ }
+
+ if (!yaml_emitter_write_indent(emitter))
+ return 0;
+ if (!yaml_emitter_write_indicator(emitter, "-", 1, 0, 1))
+ return 0;
+ if (!PUSH(emitter, emitter->states,
+ YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE))
+ return 0;
+
+ return yaml_emitter_emit_node(emitter, event, 0, 1, 0, 0);
+}
+
+/*
+ * Expect a block key node.
+ */
+
+static int
+yaml_emitter_emit_block_mapping_key(yaml_emitter_t *emitter,
+ yaml_event_t *event, int first)
+{
+ if (first)
+ {
+ if (!yaml_emitter_increase_indent(emitter, 0, 0))
+ return 0;
+ }
+
+ if (event->type == YAML_MAPPING_END_EVENT)
+ {
+ emitter->indent = POP(emitter, emitter->indents);
+ emitter->state = POP(emitter, emitter->states);
+
+ return 1;
+ }
+
+ if (!yaml_emitter_write_indent(emitter))
+ return 0;
+
+ if (yaml_emitter_check_simple_key(emitter))
+ {
+ if (!PUSH(emitter, emitter->states,
+ YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE))
+ return 0;
+
+ return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 1);
+ }
+ else
+ {
+ if (!yaml_emitter_write_indicator(emitter, "?", 1, 0, 1))
+ return 0;
+ if (!PUSH(emitter, emitter->states,
+ YAML_EMIT_BLOCK_MAPPING_VALUE_STATE))
+ return 0;
+
+ return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0);
+ }
+}
+
+/*
+ * Expect a block value node.
+ */
+
+static int
+yaml_emitter_emit_block_mapping_value(yaml_emitter_t *emitter,
+ yaml_event_t *event, int simple)
+{
+ if (simple) {
+ if (!yaml_emitter_write_indicator(emitter, ":", 0, 0, 0))
+ return 0;
+ }
+ else {
+ if (!yaml_emitter_write_indent(emitter))
+ return 0;
+ if (!yaml_emitter_write_indicator(emitter, ":", 1, 0, 1))
+ return 0;
+ }
+ if (!PUSH(emitter, emitter->states,
+ YAML_EMIT_BLOCK_MAPPING_KEY_STATE))
+ return 0;
+
+ return yaml_emitter_emit_node(emitter, event, 0, 0, 1, 0);
+}
+
+/*
+ * Expect a node.
+ */
+
+static int
+yaml_emitter_emit_node(yaml_emitter_t *emitter, yaml_event_t *event,
+ int root, int sequence, int mapping, int simple_key)
+{
+ emitter->root_context = root;
+ emitter->sequence_context = sequence;
+ emitter->mapping_context = mapping;
+ emitter->simple_key_context = simple_key;
+
+ switch (event->type)
+ {
+ case YAML_ALIAS_EVENT:
+ return yaml_emitter_emit_alias(emitter, event);
+
+ case YAML_SCALAR_EVENT:
+ return yaml_emitter_emit_scalar(emitter, event);
+
+ case YAML_SEQUENCE_START_EVENT:
+ return yaml_emitter_emit_sequence_start(emitter, event);
+
+ case YAML_MAPPING_START_EVENT:
+ return yaml_emitter_emit_mapping_start(emitter, event);
+
+ default:
+ return yaml_emitter_set_emitter_error(emitter,
+ "expected SCALAR, SEQUENCE-START, MAPPING-START, or ALIAS");
+ }
+
+ return 0;
+}
+
+/*
+ * Expect ALIAS.
+ */
+
+static int
+yaml_emitter_emit_alias(yaml_emitter_t *emitter, SHIM(yaml_event_t *event))
+{
+ if (!yaml_emitter_process_anchor(emitter))
+ return 0;
+ if (emitter->simple_key_context)
+ if (!PUT(emitter, ' ')) return 0;
+ emitter->state = POP(emitter, emitter->states);
+
+ return 1;
+}
+
+/*
+ * Expect SCALAR.
+ */
+
+static int
+yaml_emitter_emit_scalar(yaml_emitter_t *emitter, yaml_event_t *event)
+{
+ if (!yaml_emitter_select_scalar_style(emitter, event))
+ return 0;
+ if (!yaml_emitter_process_anchor(emitter))
+ return 0;
+ if (!yaml_emitter_process_tag(emitter))
+ return 0;
+ if (!yaml_emitter_increase_indent(emitter, 1, 0))
+ return 0;
+ if (!yaml_emitter_process_scalar(emitter))
+ return 0;
+ emitter->indent = POP(emitter, emitter->indents);
+ emitter->state = POP(emitter, emitter->states);
+
+ return 1;
+}
+
+/*
+ * Expect SEQUENCE-START.
+ */
+
+static int
+yaml_emitter_emit_sequence_start(yaml_emitter_t *emitter, yaml_event_t *event)
+{
+ if (!yaml_emitter_process_anchor(emitter))
+ return 0;
+ if (!yaml_emitter_process_tag(emitter))
+ return 0;
+
+ if (emitter->flow_level || emitter->canonical
+ || event->data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE
+ || yaml_emitter_check_empty_sequence(emitter)) {
+ emitter->state = YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE;
+ }
+ else {
+ emitter->state = YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE;
+ }
+
+ return 1;
+}
+
+/*
+ * Expect MAPPING-START.
+ */
+
+static int
+yaml_emitter_emit_mapping_start(yaml_emitter_t *emitter, yaml_event_t *event)
+{
+ if (!yaml_emitter_process_anchor(emitter))
+ return 0;
+ if (!yaml_emitter_process_tag(emitter))
+ return 0;
+
+ if (emitter->flow_level || emitter->canonical
+ || event->data.mapping_start.style == YAML_FLOW_MAPPING_STYLE
+ || yaml_emitter_check_empty_mapping(emitter)) {
+ emitter->state = YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE;
+ }
+ else {
+ emitter->state = YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE;
+ }
+
+ return 1;
+}
+
+/*
+ * Check if the document content is an empty scalar.
+ */
+
+static int
+yaml_emitter_check_empty_document(SHIM(yaml_emitter_t *emitter))
+{
+ return 0;
+}
+
+/*
+ * Check if the next events represent an empty sequence.
+ */
+
+static int
+yaml_emitter_check_empty_sequence(yaml_emitter_t *emitter)
+{
+ if (emitter->events.tail - emitter->events.head < 2)
+ return 0;
+
+ return (emitter->events.head[0].type == YAML_SEQUENCE_START_EVENT
+ && emitter->events.head[1].type == YAML_SEQUENCE_END_EVENT);
+}
+
+/*
+ * Check if the next events represent an empty mapping.
+ */
+
+static int
+yaml_emitter_check_empty_mapping(yaml_emitter_t *emitter)
+{
+ if (emitter->events.tail - emitter->events.head < 2)
+ return 0;
+
+ return (emitter->events.head[0].type == YAML_MAPPING_START_EVENT
+ && emitter->events.head[1].type == YAML_MAPPING_END_EVENT);
+}
+
+/*
+ * Check if the next node can be expressed as a simple key.
+ */
+
+static int
+yaml_emitter_check_simple_key(yaml_emitter_t *emitter)
+{
+ yaml_event_t *event = emitter->events.head;
+ size_t length = 0;
+
+ switch (event->type)
+ {
+ case YAML_ALIAS_EVENT:
+ length += emitter->anchor_data.anchor_length;
+ break;
+
+ case YAML_SCALAR_EVENT:
+ if (emitter->scalar_data.multiline)
+ return 0;
+ length += emitter->anchor_data.anchor_length
+ + emitter->tag_data.handle_length
+ + emitter->tag_data.suffix_length
+ + emitter->scalar_data.length;
+ break;
+
+ case YAML_SEQUENCE_START_EVENT:
+ if (!yaml_emitter_check_empty_sequence(emitter))
+ return 0;
+ length += emitter->anchor_data.anchor_length
+ + emitter->tag_data.handle_length
+ + emitter->tag_data.suffix_length;
+ break;
+
+ case YAML_MAPPING_START_EVENT:
+ if (!yaml_emitter_check_empty_mapping(emitter))
+ return 0;
+ length += emitter->anchor_data.anchor_length
+ + emitter->tag_data.handle_length
+ + emitter->tag_data.suffix_length;
+ break;
+
+ default:
+ return 0;
+ }
+
+ if (length > 128)
+ return 0;
+
+ return 1;
+}
+
+/*
+ * Determine an acceptable scalar style.
+ */
+
+static int
+yaml_emitter_select_scalar_style(yaml_emitter_t *emitter, yaml_event_t *event)
+{
+ yaml_scalar_style_t style = event->data.scalar.style;
+ int no_tag = (!emitter->tag_data.handle && !emitter->tag_data.suffix);
+
+ if (no_tag && !event->data.scalar.plain_implicit
+ && !event->data.scalar.quoted_implicit) {
+ return yaml_emitter_set_emitter_error(emitter,
+ "neither tag nor implicit flags are specified");
+ }
+
+ if (style == YAML_ANY_SCALAR_STYLE)
+ style = YAML_PLAIN_SCALAR_STYLE;
+
+ if (emitter->canonical)
+ style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
+
+ if (emitter->simple_key_context && emitter->scalar_data.multiline)
+ style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
+
+ if (style == YAML_PLAIN_SCALAR_STYLE)
+ {
+ if ((emitter->flow_level && !emitter->scalar_data.flow_plain_allowed)
+ || (!emitter->flow_level && !emitter->scalar_data.block_plain_allowed))
+ style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
+ if (!emitter->scalar_data.length
+ && (emitter->flow_level || emitter->simple_key_context))
+ style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
+ if (no_tag && !event->data.scalar.plain_implicit)
+ style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
+ }
+
+ if (style == YAML_SINGLE_QUOTED_SCALAR_STYLE)
+ {
+ if (!emitter->scalar_data.single_quoted_allowed)
+ style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
+ }
+
+ if (style == YAML_LITERAL_SCALAR_STYLE || style == YAML_FOLDED_SCALAR_STYLE)
+ {
+ if (!emitter->scalar_data.block_allowed
+ || emitter->flow_level || emitter->simple_key_context)
+ style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
+ }
+
+ if (no_tag && !event->data.scalar.quoted_implicit
+ && style != YAML_PLAIN_SCALAR_STYLE)
+ {
+ emitter->tag_data.handle = (yaml_char_t *)"!";
+ emitter->tag_data.handle_length = 1;
+ }
+
+ emitter->scalar_data.style = style;
+
+ return 1;
+}
+
+/*
+ * Write an anchor.
+ */
+
+static int
+yaml_emitter_process_anchor(yaml_emitter_t *emitter)
+{
+ if (!emitter->anchor_data.anchor)
+ return 1;
+
+ if (!yaml_emitter_write_indicator(emitter,
+ (emitter->anchor_data.alias ? "*" : "&"), 1, 0, 0))
+ return 0;
+
+ return yaml_emitter_write_anchor(emitter,
+ emitter->anchor_data.anchor, emitter->anchor_data.anchor_length);
+}
+
+/*
+ * Write a tag.
+ */
+
+static int
+yaml_emitter_process_tag(yaml_emitter_t *emitter)
+{
+ if (!emitter->tag_data.handle && !emitter->tag_data.suffix)
+ return 1;
+
+ if (emitter->tag_data.handle)
+ {
+ if (!yaml_emitter_write_tag_handle(emitter, emitter->tag_data.handle,
+ emitter->tag_data.handle_length))
+ return 0;
+ if (emitter->tag_data.suffix) {
+ if (!yaml_emitter_write_tag_content(emitter, emitter->tag_data.suffix,
+ emitter->tag_data.suffix_length, 0))
+ return 0;
+ }
+ }
+ else
+ {
+ if (!yaml_emitter_write_indicator(emitter, "!<", 1, 0, 0))
+ return 0;
+ if (!yaml_emitter_write_tag_content(emitter, emitter->tag_data.suffix,
+ emitter->tag_data.suffix_length, 0))
+ return 0;
+ if (!yaml_emitter_write_indicator(emitter, ">", 0, 0, 0))
+ return 0;
+ }
+
+ return 1;
+}
+
+/*
+ * Write a scalar.
+ */
+
+static int
+yaml_emitter_process_scalar(yaml_emitter_t *emitter)
+{
+ switch (emitter->scalar_data.style)
+ {
+ case YAML_PLAIN_SCALAR_STYLE:
+ return yaml_emitter_write_plain_scalar(emitter,
+ emitter->scalar_data.value, emitter->scalar_data.length,
+ !emitter->simple_key_context);
+
+ case YAML_SINGLE_QUOTED_SCALAR_STYLE:
+ return yaml_emitter_write_single_quoted_scalar(emitter,
+ emitter->scalar_data.value, emitter->scalar_data.length,
+ !emitter->simple_key_context);
+
+ case YAML_DOUBLE_QUOTED_SCALAR_STYLE:
+ return yaml_emitter_write_double_quoted_scalar(emitter,
+ emitter->scalar_data.value, emitter->scalar_data.length,
+ !emitter->simple_key_context);
+
+ case YAML_LITERAL_SCALAR_STYLE:
+ return yaml_emitter_write_literal_scalar(emitter,
+ emitter->scalar_data.value, emitter->scalar_data.length);
+
+ case YAML_FOLDED_SCALAR_STYLE:
+ return yaml_emitter_write_folded_scalar(emitter,
+ emitter->scalar_data.value, emitter->scalar_data.length);
+
+ default:
+ assert(1); /* Impossible. */
+ }
+
+ return 0;
+}
+
+/*
+ * Check if a %YAML directive is valid.
+ */
+
+static int
+yaml_emitter_analyze_version_directive(yaml_emitter_t *emitter,
+ yaml_version_directive_t version_directive)
+{
+ if (version_directive.major != 1 || (
+ version_directive.minor != 1
+ && version_directive.minor != 2
+ )) {
+ return yaml_emitter_set_emitter_error(emitter,
+ "incompatible %YAML directive");
+ }
+
+ return 1;
+}
+
+/*
+ * Check if a %TAG directive is valid.
+ */
+
+static int
+yaml_emitter_analyze_tag_directive(yaml_emitter_t *emitter,
+ yaml_tag_directive_t tag_directive)
+{
+ yaml_string_t handle;
+ yaml_string_t prefix;
+ size_t handle_length;
+ size_t prefix_length;
+
+ handle_length = strlen((char *)tag_directive.handle);
+ prefix_length = strlen((char *)tag_directive.prefix);
+ STRING_ASSIGN(handle, tag_directive.handle, handle_length);
+ STRING_ASSIGN(prefix, tag_directive.prefix, prefix_length);
+
+ if (handle.start == handle.end) {
+ return yaml_emitter_set_emitter_error(emitter,
+ "tag handle must not be empty");
+ }
+
+ if (handle.start[0] != '!') {
+ return yaml_emitter_set_emitter_error(emitter,
+ "tag handle must start with '!'");
+ }
+
+ if (handle.end[-1] != '!') {
+ return yaml_emitter_set_emitter_error(emitter,
+ "tag handle must end with '!'");
+ }
+
+ handle.pointer ++;
+
+ while (handle.pointer < handle.end-1) {
+ if (!IS_ALPHA(handle)) {
+ return yaml_emitter_set_emitter_error(emitter,
+ "tag handle must contain alphanumerical characters only");
+ }
+ MOVE(handle);
+ }
+
+ if (prefix.start == prefix.end) {
+ return yaml_emitter_set_emitter_error(emitter,
+ "tag prefix must not be empty");
+ }
+
+ return 1;
+}
+
+/*
+ * Check if an anchor is valid.
+ */
+
+static int
+yaml_emitter_analyze_anchor(yaml_emitter_t *emitter,
+ yaml_char_t *anchor, int alias)
+{
+ size_t anchor_length;
+ yaml_string_t string;
+
+ anchor_length = strlen((char *)anchor);
+ STRING_ASSIGN(string, anchor, anchor_length);
+
+ if (string.start == string.end) {
+ return yaml_emitter_set_emitter_error(emitter, alias ?
+ "alias value must not be empty" :
+ "anchor value must not be empty");
+ }
+
+ while (string.pointer != string.end) {
+ if (!IS_ALPHA(string)) {
+ return yaml_emitter_set_emitter_error(emitter, alias ?
+ "alias value must contain alphanumerical characters only" :
+ "anchor value must contain alphanumerical characters only");
+ }
+ MOVE(string);
+ }
+
+ emitter->anchor_data.anchor = string.start;
+ emitter->anchor_data.anchor_length = string.end - string.start;
+ emitter->anchor_data.alias = alias;
+
+ return 1;
+}
+
+/*
+ * Check if a tag is valid.
+ */
+
+static int
+yaml_emitter_analyze_tag(yaml_emitter_t *emitter,
+ yaml_char_t *tag)
+{
+ size_t tag_length;
+ yaml_string_t string;
+ yaml_tag_directive_t *tag_directive;
+
+ tag_length = strlen((char *)tag);
+ STRING_ASSIGN(string, tag, tag_length);
+
+ if (string.start == string.end) {
+ return yaml_emitter_set_emitter_error(emitter,
+ "tag value must not be empty");
+ }
+
+ for (tag_directive = emitter->tag_directives.start;
+ tag_directive != emitter->tag_directives.top; tag_directive ++) {
+ size_t prefix_length = strlen((char *)tag_directive->prefix);
+ if (prefix_length < (size_t)(string.end - string.start)
+ && strncmp((char *)tag_directive->prefix, (char *)string.start,
+ prefix_length) == 0)
+ {
+ emitter->tag_data.handle = tag_directive->handle;
+ emitter->tag_data.handle_length =
+ strlen((char *)tag_directive->handle);
+ emitter->tag_data.suffix = string.start + prefix_length;
+ emitter->tag_data.suffix_length =
+ (string.end - string.start) - prefix_length;
+ return 1;
+ }
+ }
+
+ emitter->tag_data.suffix = string.start;
+ emitter->tag_data.suffix_length = string.end - string.start;
+
+ return 1;
+}
+
+/*
+ * Check if a scalar is valid.
+ */
+
+static int
+yaml_emitter_analyze_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length)
+{
+ yaml_string_t string;
+
+ int block_indicators = 0;
+ int flow_indicators = 0;
+ int line_breaks = 0;
+ int special_characters = 0;
+
+ int leading_space = 0;
+ int leading_break = 0;
+ int trailing_space = 0;
+ int trailing_break = 0;
+ int break_space = 0;
+ int space_break = 0;
+
+ int preceded_by_whitespace = 0;
+ int followed_by_whitespace = 0;
+ int previous_space = 0;
+ int previous_break = 0;
+
+ STRING_ASSIGN(string, value, length);
+
+ emitter->scalar_data.value = value;
+ emitter->scalar_data.length = length;
+
+ if (string.start == string.end)
+ {
+ emitter->scalar_data.multiline = 0;
+ emitter->scalar_data.flow_plain_allowed = 0;
+ emitter->scalar_data.block_plain_allowed = 1;
+ emitter->scalar_data.single_quoted_allowed = 1;
+ emitter->scalar_data.block_allowed = 0;
+
+ return 1;
+ }
+
+ if ((CHECK_AT(string, '-', 0)
+ && CHECK_AT(string, '-', 1)
+ && CHECK_AT(string, '-', 2))
+ || (CHECK_AT(string, '.', 0)
+ && CHECK_AT(string, '.', 1)
+ && CHECK_AT(string, '.', 2))) {
+ block_indicators = 1;
+ flow_indicators = 1;
+ }
+
+ preceded_by_whitespace = 1;
+ followed_by_whitespace = IS_BLANKZ_AT(string, WIDTH(string));
+
+ while (string.pointer != string.end)
+ {
+ if (string.start == string.pointer)
+ {
+ if (CHECK(string, '#') || CHECK(string, ',')
+ || CHECK(string, '[') || CHECK(string, ']')
+ || CHECK(string, '{') || CHECK(string, '}')
+ || CHECK(string, '&') || CHECK(string, '*')
+ || CHECK(string, '!') || CHECK(string, '|')
+ || CHECK(string, '>') || CHECK(string, '\'')
+ || CHECK(string, '"') || CHECK(string, '%')
+ || CHECK(string, '@') || CHECK(string, '`')) {
+ flow_indicators = 1;
+ block_indicators = 1;
+ }
+
+ if (CHECK(string, '?') || CHECK(string, ':')) {
+ flow_indicators = 1;
+ if (followed_by_whitespace) {
+ block_indicators = 1;
+ }
+ }
+
+ if (CHECK(string, '-') && followed_by_whitespace) {
+ flow_indicators = 1;
+ block_indicators = 1;
+ }
+ }
+ else
+ {
+ if (CHECK(string, ',') || CHECK(string, '?')
+ || CHECK(string, '[') || CHECK(string, ']')
+ || CHECK(string, '{') || CHECK(string, '}')) {
+ flow_indicators = 1;
+ }
+
+ if (CHECK(string, ':')) {
+ flow_indicators = 1;
+ if (followed_by_whitespace) {
+ block_indicators = 1;
+ }
+ }
+
+ if (CHECK(string, '#') && preceded_by_whitespace) {
+ flow_indicators = 1;
+ block_indicators = 1;
+ }
+ }
+
+ if (!IS_PRINTABLE(string)
+ || (!IS_ASCII(string) && !emitter->unicode)) {
+ special_characters = 1;
+ }
+
+ if (IS_BREAK(string)) {
+ line_breaks = 1;
+ }
+
+ if (IS_SPACE(string))
+ {
+ if (string.start == string.pointer) {
+ leading_space = 1;
+ }
+ if (string.pointer+WIDTH(string) == string.end) {
+ trailing_space = 1;
+ }
+ if (previous_break) {
+ break_space = 1;
+ }
+ previous_space = 1;
+ previous_break = 0;
+ }
+ else if (IS_BREAK(string))
+ {
+ if (string.start == string.pointer) {
+ leading_break = 1;
+ }
+ if (string.pointer+WIDTH(string) == string.end) {
+ trailing_break = 1;
+ }
+ if (previous_space) {
+ space_break = 1;
+ }
+ previous_space = 0;
+ previous_break = 1;
+ }
+ else
+ {
+ previous_space = 0;
+ previous_break = 0;
+ }
+
+ preceded_by_whitespace = IS_BLANKZ(string);
+ MOVE(string);
+ if (string.pointer != string.end) {
+ followed_by_whitespace = IS_BLANKZ_AT(string, WIDTH(string));
+ }
+ }
+
+ emitter->scalar_data.multiline = line_breaks;
+
+ emitter->scalar_data.flow_plain_allowed = 1;
+ emitter->scalar_data.block_plain_allowed = 1;
+ emitter->scalar_data.single_quoted_allowed = 1;
+ emitter->scalar_data.block_allowed = 1;
+
+ if (leading_space || leading_break || trailing_space || trailing_break) {
+ emitter->scalar_data.flow_plain_allowed = 0;
+ emitter->scalar_data.block_plain_allowed = 0;
+ }
+
+ if (trailing_space) {
+ emitter->scalar_data.block_allowed = 0;
+ }
+
+ if (break_space) {
+ emitter->scalar_data.flow_plain_allowed = 0;
+ emitter->scalar_data.block_plain_allowed = 0;
+ emitter->scalar_data.single_quoted_allowed = 0;
+ }
+
+ if (space_break || special_characters) {
+ emitter->scalar_data.flow_plain_allowed = 0;
+ emitter->scalar_data.block_plain_allowed = 0;
+ emitter->scalar_data.single_quoted_allowed = 0;
+ emitter->scalar_data.block_allowed = 0;
+ }
+
+ if (line_breaks) {
+ emitter->scalar_data.flow_plain_allowed = 0;
+ emitter->scalar_data.block_plain_allowed = 0;
+ }
+
+ if (flow_indicators) {
+ emitter->scalar_data.flow_plain_allowed = 0;
+ }
+
+ if (block_indicators) {
+ emitter->scalar_data.block_plain_allowed = 0;
+ }
+
+ return 1;
+}
+
+/*
+ * Check if the event data is valid.
+ */
+
+static int
+yaml_emitter_analyze_event(yaml_emitter_t *emitter,
+ yaml_event_t *event)
+{
+ emitter->anchor_data.anchor = NULL;
+ emitter->anchor_data.anchor_length = 0;
+ emitter->tag_data.handle = NULL;
+ emitter->tag_data.handle_length = 0;
+ emitter->tag_data.suffix = NULL;
+ emitter->tag_data.suffix_length = 0;
+ emitter->scalar_data.value = NULL;
+ emitter->scalar_data.length = 0;
+
+ switch (event->type)
+ {
+ case YAML_ALIAS_EVENT:
+ if (!yaml_emitter_analyze_anchor(emitter,
+ event->data.alias.anchor, 1))
+ return 0;
+ return 1;
+
+ case YAML_SCALAR_EVENT:
+ if (event->data.scalar.anchor) {
+ if (!yaml_emitter_analyze_anchor(emitter,
+ event->data.scalar.anchor, 0))
+ return 0;
+ }
+ if (event->data.scalar.tag && (emitter->canonical ||
+ (!event->data.scalar.plain_implicit
+ && !event->data.scalar.quoted_implicit))) {
+ if (!yaml_emitter_analyze_tag(emitter, event->data.scalar.tag))
+ return 0;
+ }
+ if (!yaml_emitter_analyze_scalar(emitter,
+ event->data.scalar.value, event->data.scalar.length))
+ return 0;
+ return 1;
+
+ case YAML_SEQUENCE_START_EVENT:
+ if (event->data.sequence_start.anchor) {
+ if (!yaml_emitter_analyze_anchor(emitter,
+ event->data.sequence_start.anchor, 0))
+ return 0;
+ }
+ if (event->data.sequence_start.tag && (emitter->canonical ||
+ !event->data.sequence_start.implicit)) {
+ if (!yaml_emitter_analyze_tag(emitter,
+ event->data.sequence_start.tag))
+ return 0;
+ }
+ return 1;
+
+ case YAML_MAPPING_START_EVENT:
+ if (event->data.mapping_start.anchor) {
+ if (!yaml_emitter_analyze_anchor(emitter,
+ event->data.mapping_start.anchor, 0))
+ return 0;
+ }
+ if (event->data.mapping_start.tag && (emitter->canonical ||
+ !event->data.mapping_start.implicit)) {
+ if (!yaml_emitter_analyze_tag(emitter,
+ event->data.mapping_start.tag))
+ return 0;
+ }
+ return 1;
+
+ default:
+ return 1;
+ }
+}
+
+/*
+ * Write the BOM character.
+ */
+
+static int
+yaml_emitter_write_bom(yaml_emitter_t *emitter)
+{
+ if (!FLUSH(emitter)) return 0;
+
+ *(emitter->buffer.pointer++) = (yaml_char_t) '\xEF';
+ *(emitter->buffer.pointer++) = (yaml_char_t) '\xBB';
+ *(emitter->buffer.pointer++) = (yaml_char_t) '\xBF';
+
+ return 1;
+}
+
+static int
+yaml_emitter_write_indent(yaml_emitter_t *emitter)
+{
+ int indent = (emitter->indent >= 0) ? emitter->indent : 0;
+
+ if (!emitter->indention || emitter->column > indent
+ || (emitter->column == indent && !emitter->whitespace)) {
+ if (!PUT_BREAK(emitter)) return 0;
+ }
+
+ while (emitter->column < indent) {
+ if (!PUT(emitter, ' ')) return 0;
+ }
+
+ emitter->whitespace = 1;
+ emitter->indention = 1;
+
+ return 1;
+}
+
+static int
+yaml_emitter_write_indicator(yaml_emitter_t *emitter,
+ const char *indicator, int need_whitespace,
+ int is_whitespace, int is_indention)
+{
+ size_t indicator_length;
+ yaml_string_t string;
+
+ indicator_length = strlen(indicator);
+ STRING_ASSIGN(string, (yaml_char_t *)indicator, indicator_length);
+
+ if (need_whitespace && !emitter->whitespace) {
+ if (!PUT(emitter, ' ')) return 0;
+ }
+
+ while (string.pointer != string.end) {
+ if (!WRITE(emitter, string)) return 0;
+ }
+
+ emitter->whitespace = is_whitespace;
+ emitter->indention = (emitter->indention && is_indention);
+
+ return 1;
+}
+
+static int
+yaml_emitter_write_anchor(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length)
+{
+ yaml_string_t string;
+ STRING_ASSIGN(string, value, length);
+
+ while (string.pointer != string.end) {
+ if (!WRITE(emitter, string)) return 0;
+ }
+
+ emitter->whitespace = 0;
+ emitter->indention = 0;
+
+ return 1;
+}
+
+static int
+yaml_emitter_write_tag_handle(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length)
+{
+ yaml_string_t string;
+ STRING_ASSIGN(string, value, length);
+
+ if (!emitter->whitespace) {
+ if (!PUT(emitter, ' ')) return 0;
+ }
+
+ while (string.pointer != string.end) {
+ if (!WRITE(emitter, string)) return 0;
+ }
+
+ emitter->whitespace = 0;
+ emitter->indention = 0;
+
+ return 1;
+}
+
+static int
+yaml_emitter_write_tag_content(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length,
+ int need_whitespace)
+{
+ yaml_string_t string;
+ STRING_ASSIGN(string, value, length);
+
+ if (need_whitespace && !emitter->whitespace) {
+ if (!PUT(emitter, ' ')) return 0;
+ }
+
+ while (string.pointer != string.end) {
+ if (IS_ALPHA(string)
+ || CHECK(string, ';') || CHECK(string, '/')
+ || CHECK(string, '?') || CHECK(string, ':')
+ || CHECK(string, '@') || CHECK(string, '&')
+ || CHECK(string, '=') || CHECK(string, '+')
+ || CHECK(string, '$') || CHECK(string, ',')
+ || CHECK(string, '_') || CHECK(string, '.')
+ || CHECK(string, '~') || CHECK(string, '*')
+ || CHECK(string, '\'') || CHECK(string, '(')
+ || CHECK(string, ')') || CHECK(string, '[')
+ || CHECK(string, ']')) {
+ if (!WRITE(emitter, string)) return 0;
+ }
+ else {
+ int width = WIDTH(string);
+ unsigned int value;
+ while (width --) {
+ value = *(string.pointer++);
+ if (!PUT(emitter, '%')) return 0;
+ if (!PUT(emitter, (value >> 4)
+ + ((value >> 4) < 10 ? '0' : 'A' - 10)))
+ return 0;
+ if (!PUT(emitter, (value & 0x0F)
+ + ((value & 0x0F) < 10 ? '0' : 'A' - 10)))
+ return 0;
+ }
+ }
+ }
+
+ emitter->whitespace = 0;
+ emitter->indention = 0;
+
+ return 1;
+}
+
+static int
+yaml_emitter_write_plain_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length, int allow_breaks)
+{
+ yaml_string_t string;
+ int spaces = 0;
+ int breaks = 0;
+
+ STRING_ASSIGN(string, value, length);
+
+ /**
+ * Avoid trailing spaces for empty values in block mode.
+ * In flow mode, we still want the space to prevent ambiguous things
+ * like {a:}.
+ * Currently, the emitter forbids any plain empty scalar in flow mode
+ * (e.g. it outputs {a: ''} instead), so emitter->flow_level will
+ * never be true here.
+ * But if the emitter is ever changed to allow emitting empty values,
+ * the check for flow_level is already here.
+ */
+ if (!emitter->whitespace && (length || emitter->flow_level)) {
+ if (!PUT(emitter, ' ')) return 0;
+ }
+
+ while (string.pointer != string.end)
+ {
+ if (IS_SPACE(string))
+ {
+ if (allow_breaks && !spaces
+ && emitter->column > emitter->best_width
+ && !IS_SPACE_AT(string, 1)) {
+ if (!yaml_emitter_write_indent(emitter)) return 0;
+ MOVE(string);
+ }
+ else {
+ if (!WRITE(emitter, string)) return 0;
+ }
+ spaces = 1;
+ }
+ else if (IS_BREAK(string))
+ {
+ if (!breaks && CHECK(string, '\n')) {
+ if (!PUT_BREAK(emitter)) return 0;
+ }
+ if (!WRITE_BREAK(emitter, string)) return 0;
+ emitter->indention = 1;
+ breaks = 1;
+ }
+ else
+ {
+ if (breaks) {
+ if (!yaml_emitter_write_indent(emitter)) return 0;
+ }
+ if (!WRITE(emitter, string)) return 0;
+ emitter->indention = 0;
+ spaces = 0;
+ breaks = 0;
+ }
+ }
+
+ emitter->whitespace = 0;
+ emitter->indention = 0;
+
+ return 1;
+}
+
+static int
+yaml_emitter_write_single_quoted_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length, int allow_breaks)
+{
+ yaml_string_t string;
+ int spaces = 0;
+ int breaks = 0;
+
+ STRING_ASSIGN(string, value, length);
+
+ if (!yaml_emitter_write_indicator(emitter, "'", 1, 0, 0))
+ return 0;
+
+ while (string.pointer != string.end)
+ {
+ if (IS_SPACE(string))
+ {
+ if (allow_breaks && !spaces
+ && emitter->column > emitter->best_width
+ && string.pointer != string.start
+ && string.pointer != string.end - 1
+ && !IS_SPACE_AT(string, 1)) {
+ if (!yaml_emitter_write_indent(emitter)) return 0;
+ MOVE(string);
+ }
+ else {
+ if (!WRITE(emitter, string)) return 0;
+ }
+ spaces = 1;
+ }
+ else if (IS_BREAK(string))
+ {
+ if (!breaks && CHECK(string, '\n')) {
+ if (!PUT_BREAK(emitter)) return 0;
+ }
+ if (!WRITE_BREAK(emitter, string)) return 0;
+ emitter->indention = 1;
+ breaks = 1;
+ }
+ else
+ {
+ if (breaks) {
+ if (!yaml_emitter_write_indent(emitter)) return 0;
+ }
+ if (CHECK(string, '\'')) {
+ if (!PUT(emitter, '\'')) return 0;
+ }
+ if (!WRITE(emitter, string)) return 0;
+ emitter->indention = 0;
+ spaces = 0;
+ breaks = 0;
+ }
+ }
+
+ if (breaks)
+ if (!yaml_emitter_write_indent(emitter)) return 0;
+
+ if (!yaml_emitter_write_indicator(emitter, "'", 0, 0, 0))
+ return 0;
+
+ emitter->whitespace = 0;
+ emitter->indention = 0;
+
+ return 1;
+}
+
+static int
+yaml_emitter_write_double_quoted_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length, int allow_breaks)
+{
+ yaml_string_t string;
+ int spaces = 0;
+
+ STRING_ASSIGN(string, value, length);
+
+ if (!yaml_emitter_write_indicator(emitter, "\"", 1, 0, 0))
+ return 0;
+
+ while (string.pointer != string.end)
+ {
+ if (!IS_PRINTABLE(string) || (!emitter->unicode && !IS_ASCII(string))
+ || IS_BOM(string) || IS_BREAK(string)
+ || CHECK(string, '"') || CHECK(string, '\\'))
+ {
+ unsigned char octet;
+ unsigned int width;
+ unsigned int value;
+ int k;
+
+ octet = string.pointer[0];
+ width = (octet & 0x80) == 0x00 ? 1 :
+ (octet & 0xE0) == 0xC0 ? 2 :
+ (octet & 0xF0) == 0xE0 ? 3 :
+ (octet & 0xF8) == 0xF0 ? 4 : 0;
+ value = (octet & 0x80) == 0x00 ? octet & 0x7F :
+ (octet & 0xE0) == 0xC0 ? octet & 0x1F :
+ (octet & 0xF0) == 0xE0 ? octet & 0x0F :
+ (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
+ for (k = 1; k < (int)width; k ++) {
+ octet = string.pointer[k];
+ value = (value << 6) + (octet & 0x3F);
+ }
+ string.pointer += width;
+
+ if (!PUT(emitter, '\\')) return 0;
+
+ switch (value)
+ {
+ case 0x00:
+ if (!PUT(emitter, '0')) return 0;
+ break;
+
+ case 0x07:
+ if (!PUT(emitter, 'a')) return 0;
+ break;
+
+ case 0x08:
+ if (!PUT(emitter, 'b')) return 0;
+ break;
+
+ case 0x09:
+ if (!PUT(emitter, 't')) return 0;
+ break;
+
+ case 0x0A:
+ if (!PUT(emitter, 'n')) return 0;
+ break;
+
+ case 0x0B:
+ if (!PUT(emitter, 'v')) return 0;
+ break;
+
+ case 0x0C:
+ if (!PUT(emitter, 'f')) return 0;
+ break;
+
+ case 0x0D:
+ if (!PUT(emitter, 'r')) return 0;
+ break;
+
+ case 0x1B:
+ if (!PUT(emitter, 'e')) return 0;
+ break;
+
+ case 0x22:
+ if (!PUT(emitter, '\"')) return 0;
+ break;
+
+ case 0x5C:
+ if (!PUT(emitter, '\\')) return 0;
+ break;
+
+ case 0x85:
+ if (!PUT(emitter, 'N')) return 0;
+ break;
+
+ case 0xA0:
+ if (!PUT(emitter, '_')) return 0;
+ break;
+
+ case 0x2028:
+ if (!PUT(emitter, 'L')) return 0;
+ break;
+
+ case 0x2029:
+ if (!PUT(emitter, 'P')) return 0;
+ break;
+
+ default:
+ if (value <= 0xFF) {
+ if (!PUT(emitter, 'x')) return 0;
+ width = 2;
+ }
+ else if (value <= 0xFFFF) {
+ if (!PUT(emitter, 'u')) return 0;
+ width = 4;
+ }
+ else {
+ if (!PUT(emitter, 'U')) return 0;
+ width = 8;
+ }
+ for (k = (width-1)*4; k >= 0; k -= 4) {
+ int digit = (value >> k) & 0x0F;
+ if (!PUT(emitter, digit + (digit < 10 ? '0' : 'A'-10)))
+ return 0;
+ }
+ }
+ spaces = 0;
+ }
+ else if (IS_SPACE(string))
+ {
+ if (allow_breaks && !spaces
+ && emitter->column > emitter->best_width
+ && string.pointer != string.start
+ && string.pointer != string.end - 1) {
+ if (!yaml_emitter_write_indent(emitter)) return 0;
+ if (IS_SPACE_AT(string, 1)) {
+ if (!PUT(emitter, '\\')) return 0;
+ }
+ MOVE(string);
+ }
+ else {
+ if (!WRITE(emitter, string)) return 0;
+ }
+ spaces = 1;
+ }
+ else
+ {
+ if (!WRITE(emitter, string)) return 0;
+ spaces = 0;
+ }
+ }
+
+ if (!yaml_emitter_write_indicator(emitter, "\"", 0, 0, 0))
+ return 0;
+
+ emitter->whitespace = 0;
+ emitter->indention = 0;
+
+ return 1;
+}
+
+static int
+yaml_emitter_write_block_scalar_hints(yaml_emitter_t *emitter,
+ yaml_string_t string)
+{
+ char indent_hint[2];
+ const char *chomp_hint = NULL;
+
+ if (IS_SPACE(string) || IS_BREAK(string))
+ {
+ indent_hint[0] = '0' + (char)emitter->best_indent;
+ indent_hint[1] = '\0';
+ if (!yaml_emitter_write_indicator(emitter, indent_hint, 0, 0, 0))
+ return 0;
+ }
+
+ emitter->open_ended = 0;
+
+ string.pointer = string.end;
+ if (string.start == string.pointer)
+ {
+ chomp_hint = "-";
+ }
+ else
+ {
+ do {
+ string.pointer --;
+ } while ((*string.pointer & 0xC0) == 0x80);
+ if (!IS_BREAK(string))
+ {
+ chomp_hint = "-";
+ }
+ else if (string.start == string.pointer)
+ {
+ chomp_hint = "+";
+ emitter->open_ended = 2;
+ }
+ else
+ {
+ do {
+ string.pointer --;
+ } while ((*string.pointer & 0xC0) == 0x80);
+ if (IS_BREAK(string))
+ {
+ chomp_hint = "+";
+ emitter->open_ended = 2;
+ }
+ }
+ }
+
+ if (chomp_hint)
+ {
+ if (!yaml_emitter_write_indicator(emitter, chomp_hint, 0, 0, 0))
+ return 0;
+ }
+
+ return 1;
+}
+
+static int
+yaml_emitter_write_literal_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length)
+{
+ yaml_string_t string;
+ int breaks = 1;
+
+ STRING_ASSIGN(string, value, length);
+
+ if (!yaml_emitter_write_indicator(emitter, "|", 1, 0, 0))
+ return 0;
+ if (!yaml_emitter_write_block_scalar_hints(emitter, string))
+ return 0;
+ if (!PUT_BREAK(emitter)) return 0;
+ emitter->indention = 1;
+ emitter->whitespace = 1;
+
+ while (string.pointer != string.end)
+ {
+ if (IS_BREAK(string))
+ {
+ if (!WRITE_BREAK(emitter, string)) return 0;
+ emitter->indention = 1;
+ breaks = 1;
+ }
+ else
+ {
+ if (breaks) {
+ if (!yaml_emitter_write_indent(emitter)) return 0;
+ }
+ if (!WRITE(emitter, string)) return 0;
+ emitter->indention = 0;
+ breaks = 0;
+ }
+ }
+
+ return 1;
+}
+
+static int
+yaml_emitter_write_folded_scalar(yaml_emitter_t *emitter,
+ yaml_char_t *value, size_t length)
+{
+ yaml_string_t string;
+ int breaks = 1;
+ int leading_spaces = 1;
+
+ STRING_ASSIGN(string, value, length);
+
+ if (!yaml_emitter_write_indicator(emitter, ">", 1, 0, 0))
+ return 0;
+ if (!yaml_emitter_write_block_scalar_hints(emitter, string))
+ return 0;
+ if (!PUT_BREAK(emitter)) return 0;
+ emitter->indention = 1;
+ emitter->whitespace = 1;
+
+ while (string.pointer != string.end)
+ {
+ if (IS_BREAK(string))
+ {
+ if (!breaks && !leading_spaces && CHECK(string, '\n')) {
+ int k = 0;
+ while (IS_BREAK_AT(string, k)) {
+ k += WIDTH_AT(string, k);
+ }
+ if (!IS_BLANKZ_AT(string, k)) {
+ if (!PUT_BREAK(emitter)) return 0;
+ }
+ }
+ if (!WRITE_BREAK(emitter, string)) return 0;
+ emitter->indention = 1;
+ breaks = 1;
+ }
+ else
+ {
+ if (breaks) {
+ if (!yaml_emitter_write_indent(emitter)) return 0;
+ leading_spaces = IS_BLANK(string);
+ }
+ if (!breaks && IS_SPACE(string) && !IS_SPACE_AT(string, 1)
+ && emitter->column > emitter->best_width) {
+ if (!yaml_emitter_write_indent(emitter)) return 0;
+ MOVE(string);
+ }
+ else {
+ if (!WRITE(emitter, string)) return 0;
+ }
+ emitter->indention = 0;
+ breaks = 0;
+ }
+ }
+
+ return 1;
+}
diff --git a/libyaml/src/loader.c b/libyaml/src/loader.c
new file mode 100644
index 0000000000000000000000000000000000000000..dea8ac428c2aec88c23ffcaa9ac5c1b173eb7d1e
--- /dev/null
+++ b/libyaml/src/loader.c
@@ -0,0 +1,544 @@
+
+#include "yaml_private.h"
+
+/*
+ * API functions.
+ */
+
+YAML_DECLARE(int)
+yaml_parser_load(yaml_parser_t *parser, yaml_document_t *document);
+
+/*
+ * Error handling.
+ */
+
+static int
+yaml_parser_set_composer_error(yaml_parser_t *parser,
+ const char *problem, yaml_mark_t problem_mark);
+
+static int
+yaml_parser_set_composer_error_context(yaml_parser_t *parser,
+ const char *context, yaml_mark_t context_mark,
+ const char *problem, yaml_mark_t problem_mark);
+
+
+/*
+ * Alias handling.
+ */
+
+static int
+yaml_parser_register_anchor(yaml_parser_t *parser,
+ int index, yaml_char_t *anchor);
+
+/*
+ * Clean up functions.
+ */
+
+static void
+yaml_parser_delete_aliases(yaml_parser_t *parser);
+
+/*
+ * Document loading context.
+ */
+struct loader_ctx {
+ int *start;
+ int *end;
+ int *top;
+};
+
+/*
+ * Composer functions.
+ */
+static int
+yaml_parser_load_nodes(yaml_parser_t *parser, struct loader_ctx *ctx);
+
+static int
+yaml_parser_load_document(yaml_parser_t *parser, yaml_event_t *event);
+
+static int
+yaml_parser_load_alias(yaml_parser_t *parser, yaml_event_t *event,
+ struct loader_ctx *ctx);
+
+static int
+yaml_parser_load_scalar(yaml_parser_t *parser, yaml_event_t *event,
+ struct loader_ctx *ctx);
+
+static int
+yaml_parser_load_sequence(yaml_parser_t *parser, yaml_event_t *event,
+ struct loader_ctx *ctx);
+
+static int
+yaml_parser_load_mapping(yaml_parser_t *parser, yaml_event_t *event,
+ struct loader_ctx *ctx);
+
+static int
+yaml_parser_load_sequence_end(yaml_parser_t *parser, yaml_event_t *event,
+ struct loader_ctx *ctx);
+
+static int
+yaml_parser_load_mapping_end(yaml_parser_t *parser, yaml_event_t *event,
+ struct loader_ctx *ctx);
+
+/*
+ * Load the next document of the stream.
+ */
+
+YAML_DECLARE(int)
+yaml_parser_load(yaml_parser_t *parser, yaml_document_t *document)
+{
+ yaml_event_t event;
+
+ assert(parser); /* Non-NULL parser object is expected. */
+ assert(document); /* Non-NULL document object is expected. */
+
+ memset(document, 0, sizeof(yaml_document_t));
+ if (!STACK_INIT(parser, document->nodes, yaml_node_t*))
+ goto error;
+
+ if (!parser->stream_start_produced) {
+ if (!yaml_parser_parse(parser, &event)) goto error;
+ assert(event.type == YAML_STREAM_START_EVENT);
+ /* STREAM-START is expected. */
+ }
+
+ if (parser->stream_end_produced) {
+ return 1;
+ }
+
+ if (!yaml_parser_parse(parser, &event)) goto error;
+ if (event.type == YAML_STREAM_END_EVENT) {
+ return 1;
+ }
+
+ if (!STACK_INIT(parser, parser->aliases, yaml_alias_data_t*))
+ goto error;
+
+ parser->document = document;
+
+ if (!yaml_parser_load_document(parser, &event)) goto error;
+
+ yaml_parser_delete_aliases(parser);
+ parser->document = NULL;
+
+ return 1;
+
+error:
+
+ yaml_parser_delete_aliases(parser);
+ yaml_document_delete(document);
+ parser->document = NULL;
+
+ return 0;
+}
+
+/*
+ * Set composer error.
+ */
+
+static int
+yaml_parser_set_composer_error(yaml_parser_t *parser,
+ const char *problem, yaml_mark_t problem_mark)
+{
+ parser->error = YAML_COMPOSER_ERROR;
+ parser->problem = problem;
+ parser->problem_mark = problem_mark;
+
+ return 0;
+}
+
+/*
+ * Set composer error with context.
+ */
+
+static int
+yaml_parser_set_composer_error_context(yaml_parser_t *parser,
+ const char *context, yaml_mark_t context_mark,
+ const char *problem, yaml_mark_t problem_mark)
+{
+ parser->error = YAML_COMPOSER_ERROR;
+ parser->context = context;
+ parser->context_mark = context_mark;
+ parser->problem = problem;
+ parser->problem_mark = problem_mark;
+
+ return 0;
+}
+
+/*
+ * Delete the stack of aliases.
+ */
+
+static void
+yaml_parser_delete_aliases(yaml_parser_t *parser)
+{
+ while (!STACK_EMPTY(parser, parser->aliases)) {
+ yaml_free(POP(parser, parser->aliases).anchor);
+ }
+ STACK_DEL(parser, parser->aliases);
+}
+
+/*
+ * Compose a document object.
+ */
+
+static int
+yaml_parser_load_document(yaml_parser_t *parser, yaml_event_t *event)
+{
+ struct loader_ctx ctx = { NULL, NULL, NULL };
+
+ assert(event->type == YAML_DOCUMENT_START_EVENT);
+ /* DOCUMENT-START is expected. */
+
+ parser->document->version_directive
+ = event->data.document_start.version_directive;
+ parser->document->tag_directives.start
+ = event->data.document_start.tag_directives.start;
+ parser->document->tag_directives.end
+ = event->data.document_start.tag_directives.end;
+ parser->document->start_implicit
+ = event->data.document_start.implicit;
+ parser->document->start_mark = event->start_mark;
+
+ if (!STACK_INIT(parser, ctx, int*)) return 0;
+ if (!yaml_parser_load_nodes(parser, &ctx)) {
+ STACK_DEL(parser, ctx);
+ return 0;
+ }
+ STACK_DEL(parser, ctx);
+
+ return 1;
+}
+
+/*
+ * Compose a node tree.
+ */
+
+static int
+yaml_parser_load_nodes(yaml_parser_t *parser, struct loader_ctx *ctx)
+{
+ yaml_event_t event;
+
+ do {
+ if (!yaml_parser_parse(parser, &event)) return 0;
+
+ switch (event.type) {
+ case YAML_ALIAS_EVENT:
+ if (!yaml_parser_load_alias(parser, &event, ctx)) return 0;
+ break;
+ case YAML_SCALAR_EVENT:
+ if (!yaml_parser_load_scalar(parser, &event, ctx)) return 0;
+ break;
+ case YAML_SEQUENCE_START_EVENT:
+ if (!yaml_parser_load_sequence(parser, &event, ctx)) return 0;
+ break;
+ case YAML_SEQUENCE_END_EVENT:
+ if (!yaml_parser_load_sequence_end(parser, &event, ctx))
+ return 0;
+ break;
+ case YAML_MAPPING_START_EVENT:
+ if (!yaml_parser_load_mapping(parser, &event, ctx)) return 0;
+ break;
+ case YAML_MAPPING_END_EVENT:
+ if (!yaml_parser_load_mapping_end(parser, &event, ctx))
+ return 0;
+ break;
+ default:
+ assert(0); /* Could not happen. */
+ return 0;
+ case YAML_DOCUMENT_END_EVENT:
+ break;
+ }
+ } while (event.type != YAML_DOCUMENT_END_EVENT);
+
+ parser->document->end_implicit = event.data.document_end.implicit;
+ parser->document->end_mark = event.end_mark;
+
+ return 1;
+}
+
+/*
+ * Add an anchor.
+ */
+
+static int
+yaml_parser_register_anchor(yaml_parser_t *parser,
+ int index, yaml_char_t *anchor)
+{
+ yaml_alias_data_t data;
+ yaml_alias_data_t *alias_data;
+
+ if (!anchor) return 1;
+
+ data.anchor = anchor;
+ data.index = index;
+ data.mark = parser->document->nodes.start[index-1].start_mark;
+
+ for (alias_data = parser->aliases.start;
+ alias_data != parser->aliases.top; alias_data ++) {
+ if (strcmp((char *)alias_data->anchor, (char *)anchor) == 0) {
+ yaml_free(anchor);
+ return yaml_parser_set_composer_error_context(parser,
+ "found duplicate anchor; first occurrence",
+ alias_data->mark, "second occurrence", data.mark);
+ }
+ }
+
+ if (!PUSH(parser, parser->aliases, data)) {
+ yaml_free(anchor);
+ return 0;
+ }
+
+ return 1;
+}
+
+/*
+ * Compose node into its parent in the stree.
+ */
+
+static int
+yaml_parser_load_node_add(yaml_parser_t *parser, struct loader_ctx *ctx,
+ int index)
+{
+ struct yaml_node_s *parent;
+ int parent_index;
+
+ if (STACK_EMPTY(parser, *ctx)) {
+ /* This is the root node, there's no tree to add it to. */
+ return 1;
+ }
+
+ parent_index = *((*ctx).top - 1);
+ parent = &parser->document->nodes.start[parent_index-1];
+
+ switch (parent->type) {
+ case YAML_SEQUENCE_NODE:
+ if (!STACK_LIMIT(parser, parent->data.sequence.items, INT_MAX-1))
+ return 0;
+ if (!PUSH(parser, parent->data.sequence.items, index))
+ return 0;
+ break;
+ case YAML_MAPPING_NODE: {
+ yaml_node_pair_t pair;
+ if (!STACK_EMPTY(parser, parent->data.mapping.pairs)) {
+ yaml_node_pair_t *p = parent->data.mapping.pairs.top - 1;
+ if (p->key != 0 && p->value == 0) {
+ p->value = index;
+ break;
+ }
+ }
+
+ pair.key = index;
+ pair.value = 0;
+ if (!STACK_LIMIT(parser, parent->data.mapping.pairs, INT_MAX-1))
+ return 0;
+ if (!PUSH(parser, parent->data.mapping.pairs, pair))
+ return 0;
+
+ break;
+ }
+ default:
+ assert(0); /* Could not happen. */
+ return 0;
+ }
+ return 1;
+}
+
+/*
+ * Compose a node corresponding to an alias.
+ */
+
+static int
+yaml_parser_load_alias(yaml_parser_t *parser, yaml_event_t *event,
+ struct loader_ctx *ctx)
+{
+ yaml_char_t *anchor = event->data.alias.anchor;
+ yaml_alias_data_t *alias_data;
+
+ for (alias_data = parser->aliases.start;
+ alias_data != parser->aliases.top; alias_data ++) {
+ if (strcmp((char *)alias_data->anchor, (char *)anchor) == 0) {
+ yaml_free(anchor);
+ return yaml_parser_load_node_add(parser, ctx, alias_data->index);
+ }
+ }
+
+ yaml_free(anchor);
+ return yaml_parser_set_composer_error(parser, "found undefined alias",
+ event->start_mark);
+}
+
+/*
+ * Compose a scalar node.
+ */
+
+static int
+yaml_parser_load_scalar(yaml_parser_t *parser, yaml_event_t *event,
+ struct loader_ctx *ctx)
+{
+ yaml_node_t node;
+ int index;
+ yaml_char_t *tag = event->data.scalar.tag;
+
+ if (!STACK_LIMIT(parser, parser->document->nodes, INT_MAX-1)) goto error;
+
+ if (!tag || strcmp((char *)tag, "!") == 0) {
+ yaml_free(tag);
+ tag = yaml_strdup((yaml_char_t *)YAML_DEFAULT_SCALAR_TAG);
+ if (!tag) goto error;
+ }
+
+ SCALAR_NODE_INIT(node, tag, event->data.scalar.value,
+ event->data.scalar.length, event->data.scalar.style,
+ event->start_mark, event->end_mark);
+
+ if (!PUSH(parser, parser->document->nodes, node)) goto error;
+
+ index = parser->document->nodes.top - parser->document->nodes.start;
+
+ if (!yaml_parser_register_anchor(parser, index,
+ event->data.scalar.anchor)) return 0;
+
+ return yaml_parser_load_node_add(parser, ctx, index);
+
+error:
+ yaml_free(tag);
+ yaml_free(event->data.scalar.anchor);
+ yaml_free(event->data.scalar.value);
+ return 0;
+}
+
+/*
+ * Compose a sequence node.
+ */
+
+static int
+yaml_parser_load_sequence(yaml_parser_t *parser, yaml_event_t *event,
+ struct loader_ctx *ctx)
+{
+ yaml_node_t node;
+ struct {
+ yaml_node_item_t *start;
+ yaml_node_item_t *end;
+ yaml_node_item_t *top;
+ } items = { NULL, NULL, NULL };
+ int index;
+ yaml_char_t *tag = event->data.sequence_start.tag;
+
+ if (!STACK_LIMIT(parser, parser->document->nodes, INT_MAX-1)) goto error;
+
+ if (!tag || strcmp((char *)tag, "!") == 0) {
+ yaml_free(tag);
+ tag = yaml_strdup((yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG);
+ if (!tag) goto error;
+ }
+
+ if (!STACK_INIT(parser, items, yaml_node_item_t*)) goto error;
+
+ SEQUENCE_NODE_INIT(node, tag, items.start, items.end,
+ event->data.sequence_start.style,
+ event->start_mark, event->end_mark);
+
+ if (!PUSH(parser, parser->document->nodes, node)) goto error;
+
+ index = parser->document->nodes.top - parser->document->nodes.start;
+
+ if (!yaml_parser_register_anchor(parser, index,
+ event->data.sequence_start.anchor)) return 0;
+
+ if (!yaml_parser_load_node_add(parser, ctx, index)) return 0;
+
+ if (!STACK_LIMIT(parser, *ctx, INT_MAX-1)) return 0;
+ if (!PUSH(parser, *ctx, index)) return 0;
+
+ return 1;
+
+error:
+ yaml_free(tag);
+ yaml_free(event->data.sequence_start.anchor);
+ return 0;
+}
+
+static int
+yaml_parser_load_sequence_end(yaml_parser_t *parser, yaml_event_t *event,
+ struct loader_ctx *ctx)
+{
+ int index;
+
+ assert(((*ctx).top - (*ctx).start) > 0);
+
+ index = *((*ctx).top - 1);
+ assert(parser->document->nodes.start[index-1].type == YAML_SEQUENCE_NODE);
+ parser->document->nodes.start[index-1].end_mark = event->end_mark;
+
+ (void)POP(parser, *ctx);
+
+ return 1;
+}
+
+/*
+ * Compose a mapping node.
+ */
+
+static int
+yaml_parser_load_mapping(yaml_parser_t *parser, yaml_event_t *event,
+ struct loader_ctx *ctx)
+{
+ yaml_node_t node;
+ struct {
+ yaml_node_pair_t *start;
+ yaml_node_pair_t *end;
+ yaml_node_pair_t *top;
+ } pairs = { NULL, NULL, NULL };
+ int index;
+ yaml_char_t *tag = event->data.mapping_start.tag;
+
+ if (!STACK_LIMIT(parser, parser->document->nodes, INT_MAX-1)) goto error;
+
+ if (!tag || strcmp((char *)tag, "!") == 0) {
+ yaml_free(tag);
+ tag = yaml_strdup((yaml_char_t *)YAML_DEFAULT_MAPPING_TAG);
+ if (!tag) goto error;
+ }
+
+ if (!STACK_INIT(parser, pairs, yaml_node_pair_t*)) goto error;
+
+ MAPPING_NODE_INIT(node, tag, pairs.start, pairs.end,
+ event->data.mapping_start.style,
+ event->start_mark, event->end_mark);
+
+ if (!PUSH(parser, parser->document->nodes, node)) goto error;
+
+ index = parser->document->nodes.top - parser->document->nodes.start;
+
+ if (!yaml_parser_register_anchor(parser, index,
+ event->data.mapping_start.anchor)) return 0;
+
+ if (!yaml_parser_load_node_add(parser, ctx, index)) return 0;
+
+ if (!STACK_LIMIT(parser, *ctx, INT_MAX-1)) return 0;
+ if (!PUSH(parser, *ctx, index)) return 0;
+
+ return 1;
+
+error:
+ yaml_free(tag);
+ yaml_free(event->data.mapping_start.anchor);
+ return 0;
+}
+
+static int
+yaml_parser_load_mapping_end(yaml_parser_t *parser, yaml_event_t *event,
+ struct loader_ctx *ctx)
+{
+ int index;
+
+ assert(((*ctx).top - (*ctx).start) > 0);
+
+ index = *((*ctx).top - 1);
+ assert(parser->document->nodes.start[index-1].type == YAML_MAPPING_NODE);
+ parser->document->nodes.start[index-1].end_mark = event->end_mark;
+
+ (void)POP(parser, *ctx);
+
+ return 1;
+}
\ No newline at end of file
diff --git a/libyaml/src/parser.c b/libyaml/src/parser.c
new file mode 100644
index 0000000000000000000000000000000000000000..ec2f8d3e05516b5f53851db4125230362c3e7ae9
--- /dev/null
+++ b/libyaml/src/parser.c
@@ -0,0 +1,1375 @@
+
+/*
+ * The parser implements the following grammar:
+ *
+ * stream ::= STREAM-START implicit_document? explicit_document* STREAM-END
+ * implicit_document ::= block_node DOCUMENT-END*
+ * explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+ * block_node_or_indentless_sequence ::=
+ * ALIAS
+ * | properties (block_content | indentless_block_sequence)?
+ * | block_content
+ * | indentless_block_sequence
+ * block_node ::= ALIAS
+ * | properties block_content?
+ * | block_content
+ * flow_node ::= ALIAS
+ * | properties flow_content?
+ * | flow_content
+ * properties ::= TAG ANCHOR? | ANCHOR TAG?
+ * block_content ::= block_collection | flow_collection | SCALAR
+ * flow_content ::= flow_collection | SCALAR
+ * block_collection ::= block_sequence | block_mapping
+ * flow_collection ::= flow_sequence | flow_mapping
+ * block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
+ * indentless_sequence ::= (BLOCK-ENTRY block_node?)+
+ * block_mapping ::= BLOCK-MAPPING_START
+ * ((KEY block_node_or_indentless_sequence?)?
+ * (VALUE block_node_or_indentless_sequence?)?)*
+ * BLOCK-END
+ * flow_sequence ::= FLOW-SEQUENCE-START
+ * (flow_sequence_entry FLOW-ENTRY)*
+ * flow_sequence_entry?
+ * FLOW-SEQUENCE-END
+ * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+ * flow_mapping ::= FLOW-MAPPING-START
+ * (flow_mapping_entry FLOW-ENTRY)*
+ * flow_mapping_entry?
+ * FLOW-MAPPING-END
+ * flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+ */
+
+#include "yaml_private.h"
+
+/*
+ * Peek the next token in the token queue.
+ */
+
+#define PEEK_TOKEN(parser) \
+ ((parser->token_available || yaml_parser_fetch_more_tokens(parser)) ? \
+ parser->tokens.head : NULL)
+
+/*
+ * Remove the next token from the queue (must be called after PEEK_TOKEN).
+ */
+
+#define SKIP_TOKEN(parser) \
+ (parser->token_available = 0, \
+ parser->tokens_parsed ++, \
+ parser->stream_end_produced = \
+ (parser->tokens.head->type == YAML_STREAM_END_TOKEN), \
+ parser->tokens.head ++)
+
+/*
+ * Public API declarations.
+ */
+
+YAML_DECLARE(int)
+yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event);
+
+/*
+ * Error handling.
+ */
+
+static int
+yaml_parser_set_parser_error(yaml_parser_t *parser,
+ const char *problem, yaml_mark_t problem_mark);
+
+static int
+yaml_parser_set_parser_error_context(yaml_parser_t *parser,
+ const char *context, yaml_mark_t context_mark,
+ const char *problem, yaml_mark_t problem_mark);
+
+/*
+ * State functions.
+ */
+
+static int
+yaml_parser_state_machine(yaml_parser_t *parser, yaml_event_t *event);
+
+static int
+yaml_parser_parse_stream_start(yaml_parser_t *parser, yaml_event_t *event);
+
+static int
+yaml_parser_parse_document_start(yaml_parser_t *parser, yaml_event_t *event,
+ int implicit);
+
+static int
+yaml_parser_parse_document_content(yaml_parser_t *parser, yaml_event_t *event);
+
+static int
+yaml_parser_parse_document_end(yaml_parser_t *parser, yaml_event_t *event);
+
+static int
+yaml_parser_parse_node(yaml_parser_t *parser, yaml_event_t *event,
+ int block, int indentless_sequence);
+
+static int
+yaml_parser_parse_block_sequence_entry(yaml_parser_t *parser,
+ yaml_event_t *event, int first);
+
+static int
+yaml_parser_parse_indentless_sequence_entry(yaml_parser_t *parser,
+ yaml_event_t *event);
+
+static int
+yaml_parser_parse_block_mapping_key(yaml_parser_t *parser,
+ yaml_event_t *event, int first);
+
+static int
+yaml_parser_parse_block_mapping_value(yaml_parser_t *parser,
+ yaml_event_t *event);
+
+static int
+yaml_parser_parse_flow_sequence_entry(yaml_parser_t *parser,
+ yaml_event_t *event, int first);
+
+static int
+yaml_parser_parse_flow_sequence_entry_mapping_key(yaml_parser_t *parser,
+ yaml_event_t *event);
+
+static int
+yaml_parser_parse_flow_sequence_entry_mapping_value(yaml_parser_t *parser,
+ yaml_event_t *event);
+
+static int
+yaml_parser_parse_flow_sequence_entry_mapping_end(yaml_parser_t *parser,
+ yaml_event_t *event);
+
+static int
+yaml_parser_parse_flow_mapping_key(yaml_parser_t *parser,
+ yaml_event_t *event, int first);
+
+static int
+yaml_parser_parse_flow_mapping_value(yaml_parser_t *parser,
+ yaml_event_t *event, int empty);
+
+/*
+ * Utility functions.
+ */
+
+static int
+yaml_parser_process_empty_scalar(yaml_parser_t *parser,
+ yaml_event_t *event, yaml_mark_t mark);
+
+static int
+yaml_parser_process_directives(yaml_parser_t *parser,
+ yaml_version_directive_t **version_directive_ref,
+ yaml_tag_directive_t **tag_directives_start_ref,
+ yaml_tag_directive_t **tag_directives_end_ref);
+
+static int
+yaml_parser_append_tag_directive(yaml_parser_t *parser,
+ yaml_tag_directive_t value, int allow_duplicates, yaml_mark_t mark);
+
+/*
+ * Get the next event.
+ */
+
+YAML_DECLARE(int)
+yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event)
+{
+ assert(parser); /* Non-NULL parser object is expected. */
+ assert(event); /* Non-NULL event object is expected. */
+
+ /* Erase the event object. */
+
+ memset(event, 0, sizeof(yaml_event_t));
+
+ /* No events after the end of the stream or error. */
+
+ if (parser->stream_end_produced || parser->error ||
+ parser->state == YAML_PARSE_END_STATE) {
+ return 1;
+ }
+
+ /* Generate the next event. */
+
+ return yaml_parser_state_machine(parser, event);
+}
+
+/*
+ * Set parser error.
+ */
+
+static int
+yaml_parser_set_parser_error(yaml_parser_t *parser,
+ const char *problem, yaml_mark_t problem_mark)
+{
+ parser->error = YAML_PARSER_ERROR;
+ parser->problem = problem;
+ parser->problem_mark = problem_mark;
+
+ return 0;
+}
+
+static int
+yaml_parser_set_parser_error_context(yaml_parser_t *parser,
+ const char *context, yaml_mark_t context_mark,
+ const char *problem, yaml_mark_t problem_mark)
+{
+ parser->error = YAML_PARSER_ERROR;
+ parser->context = context;
+ parser->context_mark = context_mark;
+ parser->problem = problem;
+ parser->problem_mark = problem_mark;
+
+ return 0;
+}
+
+
+/*
+ * State dispatcher.
+ */
+
+static int
+yaml_parser_state_machine(yaml_parser_t *parser, yaml_event_t *event)
+{
+ switch (parser->state)
+ {
+ case YAML_PARSE_STREAM_START_STATE:
+ return yaml_parser_parse_stream_start(parser, event);
+
+ case YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE:
+ return yaml_parser_parse_document_start(parser, event, 1);
+
+ case YAML_PARSE_DOCUMENT_START_STATE:
+ return yaml_parser_parse_document_start(parser, event, 0);
+
+ case YAML_PARSE_DOCUMENT_CONTENT_STATE:
+ return yaml_parser_parse_document_content(parser, event);
+
+ case YAML_PARSE_DOCUMENT_END_STATE:
+ return yaml_parser_parse_document_end(parser, event);
+
+ case YAML_PARSE_BLOCK_NODE_STATE:
+ return yaml_parser_parse_node(parser, event, 1, 0);
+
+ case YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE:
+ return yaml_parser_parse_node(parser, event, 1, 1);
+
+ case YAML_PARSE_FLOW_NODE_STATE:
+ return yaml_parser_parse_node(parser, event, 0, 0);
+
+ case YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE:
+ return yaml_parser_parse_block_sequence_entry(parser, event, 1);
+
+ case YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE:
+ return yaml_parser_parse_block_sequence_entry(parser, event, 0);
+
+ case YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE:
+ return yaml_parser_parse_indentless_sequence_entry(parser, event);
+
+ case YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE:
+ return yaml_parser_parse_block_mapping_key(parser, event, 1);
+
+ case YAML_PARSE_BLOCK_MAPPING_KEY_STATE:
+ return yaml_parser_parse_block_mapping_key(parser, event, 0);
+
+ case YAML_PARSE_BLOCK_MAPPING_VALUE_STATE:
+ return yaml_parser_parse_block_mapping_value(parser, event);
+
+ case YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE:
+ return yaml_parser_parse_flow_sequence_entry(parser, event, 1);
+
+ case YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE:
+ return yaml_parser_parse_flow_sequence_entry(parser, event, 0);
+
+ case YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE:
+ return yaml_parser_parse_flow_sequence_entry_mapping_key(parser, event);
+
+ case YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE:
+ return yaml_parser_parse_flow_sequence_entry_mapping_value(parser, event);
+
+ case YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE:
+ return yaml_parser_parse_flow_sequence_entry_mapping_end(parser, event);
+
+ case YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE:
+ return yaml_parser_parse_flow_mapping_key(parser, event, 1);
+
+ case YAML_PARSE_FLOW_MAPPING_KEY_STATE:
+ return yaml_parser_parse_flow_mapping_key(parser, event, 0);
+
+ case YAML_PARSE_FLOW_MAPPING_VALUE_STATE:
+ return yaml_parser_parse_flow_mapping_value(parser, event, 0);
+
+ case YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE:
+ return yaml_parser_parse_flow_mapping_value(parser, event, 1);
+
+ default:
+ assert(1); /* Invalid state. */
+ }
+
+ return 0;
+}
+
+/*
+ * Parse the production:
+ * stream ::= STREAM-START implicit_document? explicit_document* STREAM-END
+ * ************
+ */
+
+static int
+yaml_parser_parse_stream_start(yaml_parser_t *parser, yaml_event_t *event)
+{
+ yaml_token_t *token;
+
+ token = PEEK_TOKEN(parser);
+ if (!token) return 0;
+
+ if (token->type != YAML_STREAM_START_TOKEN) {
+ return yaml_parser_set_parser_error(parser,
+ "did not find expected <stream-start>", token->start_mark);
+ }
+
+ parser->state = YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE;
+ STREAM_START_EVENT_INIT(*event, token->data.stream_start.encoding,
+ token->start_mark, token->start_mark);
+ SKIP_TOKEN(parser);
+
+ return 1;
+}
+
+/*
+ * Parse the productions:
+ * implicit_document ::= block_node DOCUMENT-END*
+ * *
+ * explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+ * *************************
+ */
+
+static int
+yaml_parser_parse_document_start(yaml_parser_t *parser, yaml_event_t *event,
+ int implicit)
+{
+ yaml_token_t *token;
+ yaml_version_directive_t *version_directive = NULL;
+ struct {
+ yaml_tag_directive_t *start;
+ yaml_tag_directive_t *end;
+ } tag_directives = { NULL, NULL };
+
+ token = PEEK_TOKEN(parser);
+ if (!token) return 0;
+
+ /* Parse extra document end indicators. */
+
+ if (!implicit)
+ {
+ while (token->type == YAML_DOCUMENT_END_TOKEN) {
+ SKIP_TOKEN(parser);
+ token = PEEK_TOKEN(parser);
+ if (!token) return 0;
+ }
+ }
+
+ /* Parse an implicit document. */
+
+ if (implicit && token->type != YAML_VERSION_DIRECTIVE_TOKEN &&
+ token->type != YAML_TAG_DIRECTIVE_TOKEN &&
+ token->type != YAML_DOCUMENT_START_TOKEN &&
+ token->type != YAML_STREAM_END_TOKEN)
+ {
+ if (!yaml_parser_process_directives(parser, NULL, NULL, NULL))
+ return 0;
+ if (!PUSH(parser, parser->states, YAML_PARSE_DOCUMENT_END_STATE))
+ return 0;
+ parser->state = YAML_PARSE_BLOCK_NODE_STATE;
+ DOCUMENT_START_EVENT_INIT(*event, NULL, NULL, NULL, 1,
+ token->start_mark, token->start_mark);
+ return 1;
+ }
+
+ /* Parse an explicit document. */
+
+ else if (token->type != YAML_STREAM_END_TOKEN)
+ {
+ yaml_mark_t start_mark, end_mark;
+ start_mark = token->start_mark;
+ if (!yaml_parser_process_directives(parser, &version_directive,
+ &tag_directives.start, &tag_directives.end))
+ return 0;
+ token = PEEK_TOKEN(parser);
+ if (!token) goto error;
+ if (token->type != YAML_DOCUMENT_START_TOKEN) {
+ yaml_parser_set_parser_error(parser,
+ "did not find expected <document start>", token->start_mark);
+ goto error;
+ }
+ if (!PUSH(parser, parser->states, YAML_PARSE_DOCUMENT_END_STATE))
+ goto error;
+ parser->state = YAML_PARSE_DOCUMENT_CONTENT_STATE;
+ end_mark = token->end_mark;
+ DOCUMENT_START_EVENT_INIT(*event, version_directive,
+ tag_directives.start, tag_directives.end, 0,
+ start_mark, end_mark);
+ SKIP_TOKEN(parser);
+ version_directive = NULL;
+ tag_directives.start = tag_directives.end = NULL;
+ return 1;
+ }
+
+ /* Parse the stream end. */
+
+ else
+ {
+ parser->state = YAML_PARSE_END_STATE;
+ STREAM_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
+ SKIP_TOKEN(parser);
+ return 1;
+ }
+
+error:
+ yaml_free(version_directive);
+ while (tag_directives.start != tag_directives.end) {
+ yaml_free(tag_directives.end[-1].handle);
+ yaml_free(tag_directives.end[-1].prefix);
+ tag_directives.end --;
+ }
+ yaml_free(tag_directives.start);
+ return 0;
+}
+
+/*
+ * Parse the productions:
+ * explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+ * ***********
+ */
+
+static int
+yaml_parser_parse_document_content(yaml_parser_t *parser, yaml_event_t *event)
+{
+ yaml_token_t *token;
+
+ token = PEEK_TOKEN(parser);
+ if (!token) return 0;
+
+ if (token->type == YAML_VERSION_DIRECTIVE_TOKEN ||
+ token->type == YAML_TAG_DIRECTIVE_TOKEN ||
+ token->type == YAML_DOCUMENT_START_TOKEN ||
+ token->type == YAML_DOCUMENT_END_TOKEN ||
+ token->type == YAML_STREAM_END_TOKEN) {
+ parser->state = POP(parser, parser->states);
+ return yaml_parser_process_empty_scalar(parser, event,
+ token->start_mark);
+ }
+ else {
+ return yaml_parser_parse_node(parser, event, 1, 0);
+ }
+}
+
+/*
+ * Parse the productions:
+ * implicit_document ::= block_node DOCUMENT-END*
+ * *************
+ * explicit_document ::= DIRECTIVE* DOCUMENT-START block_node? DOCUMENT-END*
+ * *************
+ */
+
+static int
+yaml_parser_parse_document_end(yaml_parser_t *parser, yaml_event_t *event)
+{
+ yaml_token_t *token;
+ yaml_mark_t start_mark, end_mark;
+ int implicit = 1;
+
+ token = PEEK_TOKEN(parser);
+ if (!token) return 0;
+
+ start_mark = end_mark = token->start_mark;
+
+ if (token->type == YAML_DOCUMENT_END_TOKEN) {
+ end_mark = token->end_mark;
+ SKIP_TOKEN(parser);
+ implicit = 0;
+ }
+
+ while (!STACK_EMPTY(parser, parser->tag_directives)) {
+ yaml_tag_directive_t tag_directive = POP(parser, parser->tag_directives);
+ yaml_free(tag_directive.handle);
+ yaml_free(tag_directive.prefix);
+ }
+
+ parser->state = YAML_PARSE_DOCUMENT_START_STATE;
+ DOCUMENT_END_EVENT_INIT(*event, implicit, start_mark, end_mark);
+
+ return 1;
+}
+
+/*
+ * Parse the productions:
+ * block_node_or_indentless_sequence ::=
+ * ALIAS
+ * *****
+ * | properties (block_content | indentless_block_sequence)?
+ * ********** *
+ * | block_content | indentless_block_sequence
+ * *
+ * block_node ::= ALIAS
+ * *****
+ * | properties block_content?
+ * ********** *
+ * | block_content
+ * *
+ * flow_node ::= ALIAS
+ * *****
+ * | properties flow_content?
+ * ********** *
+ * | flow_content
+ * *
+ * properties ::= TAG ANCHOR? | ANCHOR TAG?
+ * *************************
+ * block_content ::= block_collection | flow_collection | SCALAR
+ * ******
+ * flow_content ::= flow_collection | SCALAR
+ * ******
+ */
+
+static int
+yaml_parser_parse_node(yaml_parser_t *parser, yaml_event_t *event,
+ int block, int indentless_sequence)
+{
+ yaml_token_t *token;
+ yaml_char_t *anchor = NULL;
+ yaml_char_t *tag_handle = NULL;
+ yaml_char_t *tag_suffix = NULL;
+ yaml_char_t *tag = NULL;
+ yaml_mark_t start_mark, end_mark, tag_mark;
+ int implicit;
+
+ token = PEEK_TOKEN(parser);
+ if (!token) return 0;
+
+ if (token->type == YAML_ALIAS_TOKEN)
+ {
+ parser->state = POP(parser, parser->states);
+ ALIAS_EVENT_INIT(*event, token->data.alias.value,
+ token->start_mark, token->end_mark);
+ SKIP_TOKEN(parser);
+ return 1;
+ }
+
+ else
+ {
+ start_mark = end_mark = token->start_mark;
+
+ if (token->type == YAML_ANCHOR_TOKEN)
+ {
+ anchor = token->data.anchor.value;
+ start_mark = token->start_mark;
+ end_mark = token->end_mark;
+ SKIP_TOKEN(parser);
+ token = PEEK_TOKEN(parser);
+ if (!token) goto error;
+ if (token->type == YAML_TAG_TOKEN)
+ {
+ tag_handle = token->data.tag.handle;
+ tag_suffix = token->data.tag.suffix;
+ tag_mark = token->start_mark;
+ end_mark = token->end_mark;
+ SKIP_TOKEN(parser);
+ token = PEEK_TOKEN(parser);
+ if (!token) goto error;
+ }
+ }
+ else if (token->type == YAML_TAG_TOKEN)
+ {
+ tag_handle = token->data.tag.handle;
+ tag_suffix = token->data.tag.suffix;
+ start_mark = tag_mark = token->start_mark;
+ end_mark = token->end_mark;
+ SKIP_TOKEN(parser);
+ token = PEEK_TOKEN(parser);
+ if (!token) goto error;
+ if (token->type == YAML_ANCHOR_TOKEN)
+ {
+ anchor = token->data.anchor.value;
+ end_mark = token->end_mark;
+ SKIP_TOKEN(parser);
+ token = PEEK_TOKEN(parser);
+ if (!token) goto error;
+ }
+ }
+
+ if (tag_handle) {
+ if (!*tag_handle) {
+ tag = tag_suffix;
+ yaml_free(tag_handle);
+ tag_handle = tag_suffix = NULL;
+ }
+ else {
+ yaml_tag_directive_t *tag_directive;
+ for (tag_directive = parser->tag_directives.start;
+ tag_directive != parser->tag_directives.top;
+ tag_directive ++) {
+ if (strcmp((char *)tag_directive->handle, (char *)tag_handle) == 0) {
+ size_t prefix_len = strlen((char *)tag_directive->prefix);
+ size_t suffix_len = strlen((char *)tag_suffix);
+ tag = YAML_MALLOC(prefix_len+suffix_len+1);
+ if (!tag) {
+ parser->error = YAML_MEMORY_ERROR;
+ goto error;
+ }
+ memcpy(tag, tag_directive->prefix, prefix_len);
+ memcpy(tag+prefix_len, tag_suffix, suffix_len);
+ tag[prefix_len+suffix_len] = '\0';
+ yaml_free(tag_handle);
+ yaml_free(tag_suffix);
+ tag_handle = tag_suffix = NULL;
+ break;
+ }
+ }
+ if (!tag) {
+ yaml_parser_set_parser_error_context(parser,
+ "while parsing a node", start_mark,
+ "found undefined tag handle", tag_mark);
+ goto error;
+ }
+ }
+ }
+
+ implicit = (!tag || !*tag);
+ if (indentless_sequence && token->type == YAML_BLOCK_ENTRY_TOKEN) {
+ end_mark = token->end_mark;
+ parser->state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE;
+ SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit,
+ YAML_BLOCK_SEQUENCE_STYLE, start_mark, end_mark);
+ return 1;
+ }
+ else {
+ if (token->type == YAML_SCALAR_TOKEN) {
+ int plain_implicit = 0;
+ int quoted_implicit = 0;
+ end_mark = token->end_mark;
+ if ((token->data.scalar.style == YAML_PLAIN_SCALAR_STYLE && !tag)
+ || (tag && strcmp((char *)tag, "!") == 0)) {
+ plain_implicit = 1;
+ }
+ else if (!tag) {
+ quoted_implicit = 1;
+ }
+ parser->state = POP(parser, parser->states);
+ SCALAR_EVENT_INIT(*event, anchor, tag,
+ token->data.scalar.value, token->data.scalar.length,
+ plain_implicit, quoted_implicit,
+ token->data.scalar.style, start_mark, end_mark);
+ SKIP_TOKEN(parser);
+ return 1;
+ }
+ else if (token->type == YAML_FLOW_SEQUENCE_START_TOKEN) {
+ end_mark = token->end_mark;
+ parser->state = YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE;
+ SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit,
+ YAML_FLOW_SEQUENCE_STYLE, start_mark, end_mark);
+ return 1;
+ }
+ else if (token->type == YAML_FLOW_MAPPING_START_TOKEN) {
+ end_mark = token->end_mark;
+ parser->state = YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE;
+ MAPPING_START_EVENT_INIT(*event, anchor, tag, implicit,
+ YAML_FLOW_MAPPING_STYLE, start_mark, end_mark);
+ return 1;
+ }
+ else if (block && token->type == YAML_BLOCK_SEQUENCE_START_TOKEN) {
+ end_mark = token->end_mark;
+ parser->state = YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE;
+ SEQUENCE_START_EVENT_INIT(*event, anchor, tag, implicit,
+ YAML_BLOCK_SEQUENCE_STYLE, start_mark, end_mark);
+ return 1;
+ }
+ else if (block && token->type == YAML_BLOCK_MAPPING_START_TOKEN) {
+ end_mark = token->end_mark;
+ parser->state = YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE;
+ MAPPING_START_EVENT_INIT(*event, anchor, tag, implicit,
+ YAML_BLOCK_MAPPING_STYLE, start_mark, end_mark);
+ return 1;
+ }
+ else if (anchor || tag) {
+ yaml_char_t *value = YAML_MALLOC(1);
+ if (!value) {
+ parser->error = YAML_MEMORY_ERROR;
+ goto error;
+ }
+ value[0] = '\0';
+ parser->state = POP(parser, parser->states);
+ SCALAR_EVENT_INIT(*event, anchor, tag, value, 0,
+ implicit, 0, YAML_PLAIN_SCALAR_STYLE,
+ start_mark, end_mark);
+ return 1;
+ }
+ else {
+ yaml_parser_set_parser_error_context(parser,
+ (block ? "while parsing a block node"
+ : "while parsing a flow node"), start_mark,
+ "did not find expected node content", token->start_mark);
+ goto error;
+ }
+ }
+ }
+
+error:
+ yaml_free(anchor);
+ yaml_free(tag_handle);
+ yaml_free(tag_suffix);
+ yaml_free(tag);
+
+ return 0;
+}
+
+/*
+ * Parse the productions:
+ * block_sequence ::= BLOCK-SEQUENCE-START (BLOCK-ENTRY block_node?)* BLOCK-END
+ * ******************** *********** * *********
+ */
+
+static int
+yaml_parser_parse_block_sequence_entry(yaml_parser_t *parser,
+ yaml_event_t *event, int first)
+{
+ yaml_token_t *token;
+
+ if (first) {
+ token = PEEK_TOKEN(parser);
+ if (!PUSH(parser, parser->marks, token->start_mark))
+ return 0;
+ SKIP_TOKEN(parser);
+ }
+
+ token = PEEK_TOKEN(parser);
+ if (!token) return 0;
+
+ if (token->type == YAML_BLOCK_ENTRY_TOKEN)
+ {
+ yaml_mark_t mark = token->end_mark;
+ SKIP_TOKEN(parser);
+ token = PEEK_TOKEN(parser);
+ if (!token) return 0;
+ if (token->type != YAML_BLOCK_ENTRY_TOKEN &&
+ token->type != YAML_BLOCK_END_TOKEN) {
+ if (!PUSH(parser, parser->states,
+ YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE))
+ return 0;
+ return yaml_parser_parse_node(parser, event, 1, 0);
+ }
+ else {
+ parser->state = YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE;
+ return yaml_parser_process_empty_scalar(parser, event, mark);
+ }
+ }
+
+ else if (token->type == YAML_BLOCK_END_TOKEN)
+ {
+ parser->state = POP(parser, parser->states);
+ (void)POP(parser, parser->marks);
+ SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
+ SKIP_TOKEN(parser);
+ return 1;
+ }
+
+ else
+ {
+ return yaml_parser_set_parser_error_context(parser,
+ "while parsing a block collection", POP(parser, parser->marks),
+ "did not find expected '-' indicator", token->start_mark);
+ }
+}
+
+/*
+ * Parse the productions:
+ * indentless_sequence ::= (BLOCK-ENTRY block_node?)+
+ * *********** *
+ */
+
+static int
+yaml_parser_parse_indentless_sequence_entry(yaml_parser_t *parser,
+ yaml_event_t *event)
+{
+ yaml_token_t *token;
+
+ token = PEEK_TOKEN(parser);
+ if (!token) return 0;
+
+ if (token->type == YAML_BLOCK_ENTRY_TOKEN)
+ {
+ yaml_mark_t mark = token->end_mark;
+ SKIP_TOKEN(parser);
+ token = PEEK_TOKEN(parser);
+ if (!token) return 0;
+ if (token->type != YAML_BLOCK_ENTRY_TOKEN &&
+ token->type != YAML_KEY_TOKEN &&
+ token->type != YAML_VALUE_TOKEN &&
+ token->type != YAML_BLOCK_END_TOKEN) {
+ if (!PUSH(parser, parser->states,
+ YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE))
+ return 0;
+ return yaml_parser_parse_node(parser, event, 1, 0);
+ }
+ else {
+ parser->state = YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE;
+ return yaml_parser_process_empty_scalar(parser, event, mark);
+ }
+ }
+
+ else
+ {
+ parser->state = POP(parser, parser->states);
+ SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->start_mark);
+ return 1;
+ }
+}
+
+/*
+ * Parse the productions:
+ * block_mapping ::= BLOCK-MAPPING_START
+ * *******************
+ * ((KEY block_node_or_indentless_sequence?)?
+ * *** *
+ * (VALUE block_node_or_indentless_sequence?)?)*
+ *
+ * BLOCK-END
+ * *********
+ */
+
+static int
+yaml_parser_parse_block_mapping_key(yaml_parser_t *parser,
+ yaml_event_t *event, int first)
+{
+ yaml_token_t *token;
+
+ if (first) {
+ token = PEEK_TOKEN(parser);
+ if (!PUSH(parser, parser->marks, token->start_mark))
+ return 0;
+ SKIP_TOKEN(parser);
+ }
+
+ token = PEEK_TOKEN(parser);
+ if (!token) return 0;
+
+ if (token->type == YAML_KEY_TOKEN)
+ {
+ yaml_mark_t mark = token->end_mark;
+ SKIP_TOKEN(parser);
+ token = PEEK_TOKEN(parser);
+ if (!token) return 0;
+ if (token->type != YAML_KEY_TOKEN &&
+ token->type != YAML_VALUE_TOKEN &&
+ token->type != YAML_BLOCK_END_TOKEN) {
+ if (!PUSH(parser, parser->states,
+ YAML_PARSE_BLOCK_MAPPING_VALUE_STATE))
+ return 0;
+ return yaml_parser_parse_node(parser, event, 1, 1);
+ }
+ else {
+ parser->state = YAML_PARSE_BLOCK_MAPPING_VALUE_STATE;
+ return yaml_parser_process_empty_scalar(parser, event, mark);
+ }
+ }
+
+ else if (token->type == YAML_BLOCK_END_TOKEN)
+ {
+ parser->state = POP(parser, parser->states);
+ (void)POP(parser, parser->marks);
+ MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
+ SKIP_TOKEN(parser);
+ return 1;
+ }
+
+ else
+ {
+ return yaml_parser_set_parser_error_context(parser,
+ "while parsing a block mapping", POP(parser, parser->marks),
+ "did not find expected key", token->start_mark);
+ }
+}
+
+/*
+ * Parse the productions:
+ * block_mapping ::= BLOCK-MAPPING_START
+ *
+ * ((KEY block_node_or_indentless_sequence?)?
+ *
+ * (VALUE block_node_or_indentless_sequence?)?)*
+ * ***** *
+ * BLOCK-END
+ *
+ */
+
+static int
+yaml_parser_parse_block_mapping_value(yaml_parser_t *parser,
+ yaml_event_t *event)
+{
+ yaml_token_t *token;
+
+ token = PEEK_TOKEN(parser);
+ if (!token) return 0;
+
+ if (token->type == YAML_VALUE_TOKEN)
+ {
+ yaml_mark_t mark = token->end_mark;
+ SKIP_TOKEN(parser);
+ token = PEEK_TOKEN(parser);
+ if (!token) return 0;
+ if (token->type != YAML_KEY_TOKEN &&
+ token->type != YAML_VALUE_TOKEN &&
+ token->type != YAML_BLOCK_END_TOKEN) {
+ if (!PUSH(parser, parser->states,
+ YAML_PARSE_BLOCK_MAPPING_KEY_STATE))
+ return 0;
+ return yaml_parser_parse_node(parser, event, 1, 1);
+ }
+ else {
+ parser->state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE;
+ return yaml_parser_process_empty_scalar(parser, event, mark);
+ }
+ }
+
+ else
+ {
+ parser->state = YAML_PARSE_BLOCK_MAPPING_KEY_STATE;
+ return yaml_parser_process_empty_scalar(parser, event, token->start_mark);
+ }
+}
+
+/*
+ * Parse the productions:
+ * flow_sequence ::= FLOW-SEQUENCE-START
+ * *******************
+ * (flow_sequence_entry FLOW-ENTRY)*
+ * * **********
+ * flow_sequence_entry?
+ * *
+ * FLOW-SEQUENCE-END
+ * *****************
+ * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+ * *
+ */
+
+static int
+yaml_parser_parse_flow_sequence_entry(yaml_parser_t *parser,
+ yaml_event_t *event, int first)
+{
+ yaml_token_t *token;
+
+ if (first) {
+ token = PEEK_TOKEN(parser);
+ if (!PUSH(parser, parser->marks, token->start_mark))
+ return 0;
+ SKIP_TOKEN(parser);
+ }
+
+ token = PEEK_TOKEN(parser);
+ if (!token) return 0;
+
+ if (token->type != YAML_FLOW_SEQUENCE_END_TOKEN)
+ {
+ if (!first) {
+ if (token->type == YAML_FLOW_ENTRY_TOKEN) {
+ SKIP_TOKEN(parser);
+ token = PEEK_TOKEN(parser);
+ if (!token) return 0;
+ }
+ else {
+ return yaml_parser_set_parser_error_context(parser,
+ "while parsing a flow sequence", POP(parser, parser->marks),
+ "did not find expected ',' or ']'", token->start_mark);
+ }
+ }
+
+ if (token->type == YAML_KEY_TOKEN) {
+ parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE;
+ MAPPING_START_EVENT_INIT(*event, NULL, NULL,
+ 1, YAML_FLOW_MAPPING_STYLE,
+ token->start_mark, token->end_mark);
+ SKIP_TOKEN(parser);
+ return 1;
+ }
+
+ else if (token->type != YAML_FLOW_SEQUENCE_END_TOKEN) {
+ if (!PUSH(parser, parser->states,
+ YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE))
+ return 0;
+ return yaml_parser_parse_node(parser, event, 0, 0);
+ }
+ }
+
+ parser->state = POP(parser, parser->states);
+ (void)POP(parser, parser->marks);
+ SEQUENCE_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
+ SKIP_TOKEN(parser);
+ return 1;
+}
+
+/*
+ * Parse the productions:
+ * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+ * *** *
+ */
+
+static int
+yaml_parser_parse_flow_sequence_entry_mapping_key(yaml_parser_t *parser,
+ yaml_event_t *event)
+{
+ yaml_token_t *token;
+
+ token = PEEK_TOKEN(parser);
+ if (!token) return 0;
+
+ if (token->type != YAML_VALUE_TOKEN && token->type != YAML_FLOW_ENTRY_TOKEN
+ && token->type != YAML_FLOW_SEQUENCE_END_TOKEN) {
+ if (!PUSH(parser, parser->states,
+ YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE))
+ return 0;
+ return yaml_parser_parse_node(parser, event, 0, 0);
+ }
+ else {
+ yaml_mark_t mark = token->end_mark;
+ SKIP_TOKEN(parser);
+ parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE;
+ return yaml_parser_process_empty_scalar(parser, event, mark);
+ }
+}
+
+/*
+ * Parse the productions:
+ * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+ * ***** *
+ */
+
+static int
+yaml_parser_parse_flow_sequence_entry_mapping_value(yaml_parser_t *parser,
+ yaml_event_t *event)
+{
+ yaml_token_t *token;
+
+ token = PEEK_TOKEN(parser);
+ if (!token) return 0;
+
+ if (token->type == YAML_VALUE_TOKEN) {
+ SKIP_TOKEN(parser);
+ token = PEEK_TOKEN(parser);
+ if (!token) return 0;
+ if (token->type != YAML_FLOW_ENTRY_TOKEN
+ && token->type != YAML_FLOW_SEQUENCE_END_TOKEN) {
+ if (!PUSH(parser, parser->states,
+ YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE))
+ return 0;
+ return yaml_parser_parse_node(parser, event, 0, 0);
+ }
+ }
+ parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE;
+ return yaml_parser_process_empty_scalar(parser, event, token->start_mark);
+}
+
+/*
+ * Parse the productions:
+ * flow_sequence_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+ * *
+ */
+
+static int
+yaml_parser_parse_flow_sequence_entry_mapping_end(yaml_parser_t *parser,
+ yaml_event_t *event)
+{
+ yaml_token_t *token;
+
+ token = PEEK_TOKEN(parser);
+ if (!token) return 0;
+
+ parser->state = YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE;
+
+ MAPPING_END_EVENT_INIT(*event, token->start_mark, token->start_mark);
+ return 1;
+}
+
+/*
+ * Parse the productions:
+ * flow_mapping ::= FLOW-MAPPING-START
+ * ******************
+ * (flow_mapping_entry FLOW-ENTRY)*
+ * * **********
+ * flow_mapping_entry?
+ * ******************
+ * FLOW-MAPPING-END
+ * ****************
+ * flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+ * * *** *
+ */
+
+static int
+yaml_parser_parse_flow_mapping_key(yaml_parser_t *parser,
+ yaml_event_t *event, int first)
+{
+ yaml_token_t *token;
+
+ if (first) {
+ token = PEEK_TOKEN(parser);
+ if (!PUSH(parser, parser->marks, token->start_mark))
+ return 0;
+ SKIP_TOKEN(parser);
+ }
+
+ token = PEEK_TOKEN(parser);
+ if (!token) return 0;
+
+ if (token->type != YAML_FLOW_MAPPING_END_TOKEN)
+ {
+ if (!first) {
+ if (token->type == YAML_FLOW_ENTRY_TOKEN) {
+ SKIP_TOKEN(parser);
+ token = PEEK_TOKEN(parser);
+ if (!token) return 0;
+ }
+ else {
+ return yaml_parser_set_parser_error_context(parser,
+ "while parsing a flow mapping", POP(parser, parser->marks),
+ "did not find expected ',' or '}'", token->start_mark);
+ }
+ }
+
+ if (token->type == YAML_KEY_TOKEN) {
+ SKIP_TOKEN(parser);
+ token = PEEK_TOKEN(parser);
+ if (!token) return 0;
+ if (token->type != YAML_VALUE_TOKEN
+ && token->type != YAML_FLOW_ENTRY_TOKEN
+ && token->type != YAML_FLOW_MAPPING_END_TOKEN) {
+ if (!PUSH(parser, parser->states,
+ YAML_PARSE_FLOW_MAPPING_VALUE_STATE))
+ return 0;
+ return yaml_parser_parse_node(parser, event, 0, 0);
+ }
+ else {
+ parser->state = YAML_PARSE_FLOW_MAPPING_VALUE_STATE;
+ return yaml_parser_process_empty_scalar(parser, event,
+ token->start_mark);
+ }
+ }
+ else if (token->type != YAML_FLOW_MAPPING_END_TOKEN) {
+ if (!PUSH(parser, parser->states,
+ YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE))
+ return 0;
+ return yaml_parser_parse_node(parser, event, 0, 0);
+ }
+ }
+
+ parser->state = POP(parser, parser->states);
+ (void)POP(parser, parser->marks);
+ MAPPING_END_EVENT_INIT(*event, token->start_mark, token->end_mark);
+ SKIP_TOKEN(parser);
+ return 1;
+}
+
+/*
+ * Parse the productions:
+ * flow_mapping_entry ::= flow_node | KEY flow_node? (VALUE flow_node?)?
+ * * ***** *
+ */
+
+static int
+yaml_parser_parse_flow_mapping_value(yaml_parser_t *parser,
+ yaml_event_t *event, int empty)
+{
+ yaml_token_t *token;
+
+ token = PEEK_TOKEN(parser);
+ if (!token) return 0;
+
+ if (empty) {
+ parser->state = YAML_PARSE_FLOW_MAPPING_KEY_STATE;
+ return yaml_parser_process_empty_scalar(parser, event,
+ token->start_mark);
+ }
+
+ if (token->type == YAML_VALUE_TOKEN) {
+ SKIP_TOKEN(parser);
+ token = PEEK_TOKEN(parser);
+ if (!token) return 0;
+ if (token->type != YAML_FLOW_ENTRY_TOKEN
+ && token->type != YAML_FLOW_MAPPING_END_TOKEN) {
+ if (!PUSH(parser, parser->states,
+ YAML_PARSE_FLOW_MAPPING_KEY_STATE))
+ return 0;
+ return yaml_parser_parse_node(parser, event, 0, 0);
+ }
+ }
+
+ parser->state = YAML_PARSE_FLOW_MAPPING_KEY_STATE;
+ return yaml_parser_process_empty_scalar(parser, event, token->start_mark);
+}
+
+/*
+ * Generate an empty scalar event.
+ */
+
+static int
+yaml_parser_process_empty_scalar(yaml_parser_t *parser, yaml_event_t *event,
+ yaml_mark_t mark)
+{
+ yaml_char_t *value;
+
+ value = YAML_MALLOC(1);
+ if (!value) {
+ parser->error = YAML_MEMORY_ERROR;
+ return 0;
+ }
+ value[0] = '\0';
+
+ SCALAR_EVENT_INIT(*event, NULL, NULL, value, 0,
+ 1, 0, YAML_PLAIN_SCALAR_STYLE, mark, mark);
+
+ return 1;
+}
+
+/*
+ * Parse directives.
+ */
+
+static int
+yaml_parser_process_directives(yaml_parser_t *parser,
+ yaml_version_directive_t **version_directive_ref,
+ yaml_tag_directive_t **tag_directives_start_ref,
+ yaml_tag_directive_t **tag_directives_end_ref)
+{
+ yaml_tag_directive_t default_tag_directives[] = {
+ {(yaml_char_t *)"!", (yaml_char_t *)"!"},
+ {(yaml_char_t *)"!!", (yaml_char_t *)"tag:yaml.org,2002:"},
+ {NULL, NULL}
+ };
+ yaml_tag_directive_t *default_tag_directive;
+ yaml_version_directive_t *version_directive = NULL;
+ struct {
+ yaml_tag_directive_t *start;
+ yaml_tag_directive_t *end;
+ yaml_tag_directive_t *top;
+ } tag_directives = { NULL, NULL, NULL };
+ yaml_token_t *token;
+
+ if (!STACK_INIT(parser, tag_directives, yaml_tag_directive_t*))
+ goto error;
+
+ token = PEEK_TOKEN(parser);
+ if (!token) goto error;
+
+ while (token->type == YAML_VERSION_DIRECTIVE_TOKEN ||
+ token->type == YAML_TAG_DIRECTIVE_TOKEN)
+ {
+ if (token->type == YAML_VERSION_DIRECTIVE_TOKEN) {
+ if (version_directive) {
+ yaml_parser_set_parser_error(parser,
+ "found duplicate %YAML directive", token->start_mark);
+ goto error;
+ }
+ if (token->data.version_directive.major != 1
+ || (
+ token->data.version_directive.minor != 1
+ && token->data.version_directive.minor != 2
+ )) {
+ yaml_parser_set_parser_error(parser,
+ "found incompatible YAML document", token->start_mark);
+ goto error;
+ }
+ version_directive = YAML_MALLOC_STATIC(yaml_version_directive_t);
+ if (!version_directive) {
+ parser->error = YAML_MEMORY_ERROR;
+ goto error;
+ }
+ version_directive->major = token->data.version_directive.major;
+ version_directive->minor = token->data.version_directive.minor;
+ }
+
+ else if (token->type == YAML_TAG_DIRECTIVE_TOKEN) {
+ yaml_tag_directive_t value;
+ value.handle = token->data.tag_directive.handle;
+ value.prefix = token->data.tag_directive.prefix;
+
+ if (!yaml_parser_append_tag_directive(parser, value, 0,
+ token->start_mark))
+ goto error;
+ if (!PUSH(parser, tag_directives, value))
+ goto error;
+ }
+
+ SKIP_TOKEN(parser);
+ token = PEEK_TOKEN(parser);
+ if (!token) goto error;
+ }
+
+ for (default_tag_directive = default_tag_directives;
+ default_tag_directive->handle; default_tag_directive++) {
+ if (!yaml_parser_append_tag_directive(parser, *default_tag_directive, 1,
+ token->start_mark))
+ goto error;
+ }
+
+ if (version_directive_ref) {
+ *version_directive_ref = version_directive;
+ }
+ if (tag_directives_start_ref) {
+ if (STACK_EMPTY(parser, tag_directives)) {
+ *tag_directives_start_ref = *tag_directives_end_ref = NULL;
+ STACK_DEL(parser, tag_directives);
+ }
+ else {
+ *tag_directives_start_ref = tag_directives.start;
+ *tag_directives_end_ref = tag_directives.top;
+ }
+ }
+ else {
+ STACK_DEL(parser, tag_directives);
+ }
+
+ if (!version_directive_ref)
+ yaml_free(version_directive);
+ return 1;
+
+error:
+ yaml_free(version_directive);
+ while (!STACK_EMPTY(parser, tag_directives)) {
+ yaml_tag_directive_t tag_directive = POP(parser, tag_directives);
+ yaml_free(tag_directive.handle);
+ yaml_free(tag_directive.prefix);
+ }
+ STACK_DEL(parser, tag_directives);
+ return 0;
+}
+
+/*
+ * Append a tag directive to the directives stack.
+ */
+
+static int
+yaml_parser_append_tag_directive(yaml_parser_t *parser,
+ yaml_tag_directive_t value, int allow_duplicates, yaml_mark_t mark)
+{
+ yaml_tag_directive_t *tag_directive;
+ yaml_tag_directive_t copy = { NULL, NULL };
+
+ for (tag_directive = parser->tag_directives.start;
+ tag_directive != parser->tag_directives.top; tag_directive ++) {
+ if (strcmp((char *)value.handle, (char *)tag_directive->handle) == 0) {
+ if (allow_duplicates)
+ return 1;
+ return yaml_parser_set_parser_error(parser,
+ "found duplicate %TAG directive", mark);
+ }
+ }
+
+ copy.handle = yaml_strdup(value.handle);
+ copy.prefix = yaml_strdup(value.prefix);
+ if (!copy.handle || !copy.prefix) {
+ parser->error = YAML_MEMORY_ERROR;
+ goto error;
+ }
+
+ if (!PUSH(parser, parser->tag_directives, copy))
+ goto error;
+
+ return 1;
+
+error:
+ yaml_free(copy.handle);
+ yaml_free(copy.prefix);
+ return 0;
+}
+
diff --git a/libyaml/src/reader.c b/libyaml/src/reader.c
new file mode 100644
index 0000000000000000000000000000000000000000..f3ac54c2517dd06a0dffc81c4a93c30619dde631
--- /dev/null
+++ b/libyaml/src/reader.c
@@ -0,0 +1,469 @@
+
+#include "yaml_private.h"
+
+/*
+ * Declarations.
+ */
+
+static int
+yaml_parser_set_reader_error(yaml_parser_t *parser, const char *problem,
+ size_t offset, int value);
+
+static int
+yaml_parser_update_raw_buffer(yaml_parser_t *parser);
+
+static int
+yaml_parser_determine_encoding(yaml_parser_t *parser);
+
+YAML_DECLARE(int)
+yaml_parser_update_buffer(yaml_parser_t *parser, size_t length);
+
+/*
+ * Set the reader error and return 0.
+ */
+
+static int
+yaml_parser_set_reader_error(yaml_parser_t *parser, const char *problem,
+ size_t offset, int value)
+{
+ parser->error = YAML_READER_ERROR;
+ parser->problem = problem;
+ parser->problem_offset = offset;
+ parser->problem_value = value;
+
+ return 0;
+}
+
+/*
+ * Byte order marks.
+ */
+
+#define BOM_UTF8 "\xef\xbb\xbf"
+#define BOM_UTF16LE "\xff\xfe"
+#define BOM_UTF16BE "\xfe\xff"
+
+/*
+ * Determine the input stream encoding by checking the BOM symbol. If no BOM is
+ * found, the UTF-8 encoding is assumed. Return 1 on success, 0 on failure.
+ */
+
+static int
+yaml_parser_determine_encoding(yaml_parser_t *parser)
+{
+ /* Ensure that we had enough bytes in the raw buffer. */
+
+ while (!parser->eof
+ && parser->raw_buffer.last - parser->raw_buffer.pointer < 3) {
+ if (!yaml_parser_update_raw_buffer(parser)) {
+ return 0;
+ }
+ }
+
+ /* Determine the encoding. */
+
+ if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 2
+ && !memcmp(parser->raw_buffer.pointer, BOM_UTF16LE, 2)) {
+ parser->encoding = YAML_UTF16LE_ENCODING;
+ parser->raw_buffer.pointer += 2;
+ parser->offset += 2;
+ }
+ else if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 2
+ && !memcmp(parser->raw_buffer.pointer, BOM_UTF16BE, 2)) {
+ parser->encoding = YAML_UTF16BE_ENCODING;
+ parser->raw_buffer.pointer += 2;
+ parser->offset += 2;
+ }
+ else if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 3
+ && !memcmp(parser->raw_buffer.pointer, BOM_UTF8, 3)) {
+ parser->encoding = YAML_UTF8_ENCODING;
+ parser->raw_buffer.pointer += 3;
+ parser->offset += 3;
+ }
+ else {
+ parser->encoding = YAML_UTF8_ENCODING;
+ }
+
+ return 1;
+}
+
+/*
+ * Update the raw buffer.
+ */
+
+static int
+yaml_parser_update_raw_buffer(yaml_parser_t *parser)
+{
+ size_t size_read = 0;
+
+ /* Return if the raw buffer is full. */
+
+ if (parser->raw_buffer.start == parser->raw_buffer.pointer
+ && parser->raw_buffer.last == parser->raw_buffer.end)
+ return 1;
+
+ /* Return on EOF. */
+
+ if (parser->eof) return 1;
+
+ /* Move the remaining bytes in the raw buffer to the beginning. */
+
+ if (parser->raw_buffer.start < parser->raw_buffer.pointer
+ && parser->raw_buffer.pointer < parser->raw_buffer.last) {
+ memmove(parser->raw_buffer.start, parser->raw_buffer.pointer,
+ parser->raw_buffer.last - parser->raw_buffer.pointer);
+ }
+ parser->raw_buffer.last -=
+ parser->raw_buffer.pointer - parser->raw_buffer.start;
+ parser->raw_buffer.pointer = parser->raw_buffer.start;
+
+ /* Call the read handler to fill the buffer. */
+
+ if (!parser->read_handler(parser->read_handler_data, parser->raw_buffer.last,
+ parser->raw_buffer.end - parser->raw_buffer.last, &size_read)) {
+ return yaml_parser_set_reader_error(parser, "input error",
+ parser->offset, -1);
+ }
+ parser->raw_buffer.last += size_read;
+ if (!size_read) {
+ parser->eof = 1;
+ }
+
+ return 1;
+}
+
+/*
+ * Ensure that the buffer contains at least `length` characters.
+ * Return 1 on success, 0 on failure.
+ *
+ * The length is supposed to be significantly less that the buffer size.
+ */
+
+YAML_DECLARE(int)
+yaml_parser_update_buffer(yaml_parser_t *parser, size_t length)
+{
+ int first = 1;
+
+ assert(parser->read_handler); /* Read handler must be set. */
+
+ /* If the EOF flag is set and the raw buffer is empty, do nothing. */
+
+ if (parser->eof && parser->raw_buffer.pointer == parser->raw_buffer.last)
+ return 1;
+
+ /* Return if the buffer contains enough characters. */
+
+ if (parser->unread >= length)
+ return 1;
+
+ /* Determine the input encoding if it is not known yet. */
+
+ if (!parser->encoding) {
+ if (!yaml_parser_determine_encoding(parser))
+ return 0;
+ }
+
+ /* Move the unread characters to the beginning of the buffer. */
+
+ if (parser->buffer.start < parser->buffer.pointer
+ && parser->buffer.pointer < parser->buffer.last) {
+ size_t size = parser->buffer.last - parser->buffer.pointer;
+ memmove(parser->buffer.start, parser->buffer.pointer, size);
+ parser->buffer.pointer = parser->buffer.start;
+ parser->buffer.last = parser->buffer.start + size;
+ }
+ else if (parser->buffer.pointer == parser->buffer.last) {
+ parser->buffer.pointer = parser->buffer.start;
+ parser->buffer.last = parser->buffer.start;
+ }
+
+ /* Fill the buffer until it has enough characters. */
+
+ while (parser->unread < length)
+ {
+ /* Fill the raw buffer if necessary. */
+
+ if (!first || parser->raw_buffer.pointer == parser->raw_buffer.last) {
+ if (!yaml_parser_update_raw_buffer(parser)) return 0;
+ }
+ first = 0;
+
+ /* Decode the raw buffer. */
+
+ while (parser->raw_buffer.pointer != parser->raw_buffer.last)
+ {
+ unsigned int value = 0, value2 = 0;
+ int incomplete = 0;
+ unsigned char octet;
+ unsigned int width = 0;
+ int low, high;
+ size_t k;
+ size_t raw_unread = parser->raw_buffer.last - parser->raw_buffer.pointer;
+
+ /* Decode the next character. */
+
+ switch (parser->encoding)
+ {
+ case YAML_UTF8_ENCODING:
+
+ /*
+ * Decode a UTF-8 character. Check RFC 3629
+ * (http://www.ietf.org/rfc/rfc3629.txt) for more details.
+ *
+ * The following table (taken from the RFC) is used for
+ * decoding.
+ *
+ * Char. number range | UTF-8 octet sequence
+ * (hexadecimal) | (binary)
+ * --------------------+------------------------------------
+ * 0000 0000-0000 007F | 0xxxxxxx
+ * 0000 0080-0000 07FF | 110xxxxx 10xxxxxx
+ * 0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
+ * 0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+ *
+ * Additionally, the characters in the range 0xD800-0xDFFF
+ * are prohibited as they are reserved for use with UTF-16
+ * surrogate pairs.
+ */
+
+ /* Determine the length of the UTF-8 sequence. */
+
+ octet = parser->raw_buffer.pointer[0];
+ width = (octet & 0x80) == 0x00 ? 1 :
+ (octet & 0xE0) == 0xC0 ? 2 :
+ (octet & 0xF0) == 0xE0 ? 3 :
+ (octet & 0xF8) == 0xF0 ? 4 : 0;
+
+ /* Check if the leading octet is valid. */
+
+ if (!width)
+ return yaml_parser_set_reader_error(parser,
+ "invalid leading UTF-8 octet",
+ parser->offset, octet);
+
+ /* Check if the raw buffer contains an incomplete character. */
+
+ if (width > raw_unread) {
+ if (parser->eof) {
+ return yaml_parser_set_reader_error(parser,
+ "incomplete UTF-8 octet sequence",
+ parser->offset, -1);
+ }
+ incomplete = 1;
+ break;
+ }
+
+ /* Decode the leading octet. */
+
+ value = (octet & 0x80) == 0x00 ? octet & 0x7F :
+ (octet & 0xE0) == 0xC0 ? octet & 0x1F :
+ (octet & 0xF0) == 0xE0 ? octet & 0x0F :
+ (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
+
+ /* Check and decode the trailing octets. */
+
+ for (k = 1; k < width; k ++)
+ {
+ octet = parser->raw_buffer.pointer[k];
+
+ /* Check if the octet is valid. */
+
+ if ((octet & 0xC0) != 0x80)
+ return yaml_parser_set_reader_error(parser,
+ "invalid trailing UTF-8 octet",
+ parser->offset+k, octet);
+
+ /* Decode the octet. */
+
+ value = (value << 6) + (octet & 0x3F);
+ }
+
+ /* Check the length of the sequence against the value. */
+
+ if (!((width == 1) ||
+ (width == 2 && value >= 0x80) ||
+ (width == 3 && value >= 0x800) ||
+ (width == 4 && value >= 0x10000)))
+ return yaml_parser_set_reader_error(parser,
+ "invalid length of a UTF-8 sequence",
+ parser->offset, -1);
+
+ /* Check the range of the value. */
+
+ if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF)
+ return yaml_parser_set_reader_error(parser,
+ "invalid Unicode character",
+ parser->offset, value);
+
+ break;
+
+ case YAML_UTF16LE_ENCODING:
+ case YAML_UTF16BE_ENCODING:
+
+ low = (parser->encoding == YAML_UTF16LE_ENCODING ? 0 : 1);
+ high = (parser->encoding == YAML_UTF16LE_ENCODING ? 1 : 0);
+
+ /*
+ * The UTF-16 encoding is not as simple as one might
+ * naively think. Check RFC 2781
+ * (http://www.ietf.org/rfc/rfc2781.txt).
+ *
+ * Normally, two subsequent bytes describe a Unicode
+ * character. However a special technique (called a
+ * surrogate pair) is used for specifying character
+ * values larger than 0xFFFF.
+ *
+ * A surrogate pair consists of two pseudo-characters:
+ * high surrogate area (0xD800-0xDBFF)
+ * low surrogate area (0xDC00-0xDFFF)
+ *
+ * The following formulas are used for decoding
+ * and encoding characters using surrogate pairs:
+ *
+ * U = U' + 0x10000 (0x01 00 00 <= U <= 0x10 FF FF)
+ * U' = yyyyyyyyyyxxxxxxxxxx (0 <= U' <= 0x0F FF FF)
+ * W1 = 110110yyyyyyyyyy
+ * W2 = 110111xxxxxxxxxx
+ *
+ * where U is the character value, W1 is the high surrogate
+ * area, W2 is the low surrogate area.
+ */
+
+ /* Check for incomplete UTF-16 character. */
+
+ if (raw_unread < 2) {
+ if (parser->eof) {
+ return yaml_parser_set_reader_error(parser,
+ "incomplete UTF-16 character",
+ parser->offset, -1);
+ }
+ incomplete = 1;
+ break;
+ }
+
+ /* Get the character. */
+
+ value = parser->raw_buffer.pointer[low]
+ + (parser->raw_buffer.pointer[high] << 8);
+
+ /* Check for unexpected low surrogate area. */
+
+ if ((value & 0xFC00) == 0xDC00)
+ return yaml_parser_set_reader_error(parser,
+ "unexpected low surrogate area",
+ parser->offset, value);
+
+ /* Check for a high surrogate area. */
+
+ if ((value & 0xFC00) == 0xD800) {
+
+ width = 4;
+
+ /* Check for incomplete surrogate pair. */
+
+ if (raw_unread < 4) {
+ if (parser->eof) {
+ return yaml_parser_set_reader_error(parser,
+ "incomplete UTF-16 surrogate pair",
+ parser->offset, -1);
+ }
+ incomplete = 1;
+ break;
+ }
+
+ /* Get the next character. */
+
+ value2 = parser->raw_buffer.pointer[low+2]
+ + (parser->raw_buffer.pointer[high+2] << 8);
+
+ /* Check for a low surrogate area. */
+
+ if ((value2 & 0xFC00) != 0xDC00)
+ return yaml_parser_set_reader_error(parser,
+ "expected low surrogate area",
+ parser->offset+2, value2);
+
+ /* Generate the value of the surrogate pair. */
+
+ value = 0x10000 + ((value & 0x3FF) << 10) + (value2 & 0x3FF);
+ }
+
+ else {
+ width = 2;
+ }
+
+ break;
+
+ default:
+ assert(1); /* Impossible. */
+ }
+
+ /* Check if the raw buffer contains enough bytes to form a character. */
+
+ if (incomplete) break;
+
+ /*
+ * Check if the character is in the allowed range:
+ * #x9 | #xA | #xD | [#x20-#x7E] (8 bit)
+ * | #x85 | [#xA0-#xD7FF] | [#xE000-#xFFFD] (16 bit)
+ * | [#x10000-#x10FFFF] (32 bit)
+ */
+
+ if (! (value == 0x09 || value == 0x0A || value == 0x0D
+ || (value >= 0x20 && value <= 0x7E)
+ || (value == 0x85) || (value >= 0xA0 && value <= 0xD7FF)
+ || (value >= 0xE000 && value <= 0xFFFD)
+ || (value >= 0x10000 && value <= 0x10FFFF)))
+ return yaml_parser_set_reader_error(parser,
+ "control characters are not allowed",
+ parser->offset, value);
+
+ /* Move the raw pointers. */
+
+ parser->raw_buffer.pointer += width;
+ parser->offset += width;
+
+ /* Finally put the character into the buffer. */
+
+ /* 0000 0000-0000 007F -> 0xxxxxxx */
+ if (value <= 0x7F) {
+ *(parser->buffer.last++) = value;
+ }
+ /* 0000 0080-0000 07FF -> 110xxxxx 10xxxxxx */
+ else if (value <= 0x7FF) {
+ *(parser->buffer.last++) = 0xC0 + (value >> 6);
+ *(parser->buffer.last++) = 0x80 + (value & 0x3F);
+ }
+ /* 0000 0800-0000 FFFF -> 1110xxxx 10xxxxxx 10xxxxxx */
+ else if (value <= 0xFFFF) {
+ *(parser->buffer.last++) = 0xE0 + (value >> 12);
+ *(parser->buffer.last++) = 0x80 + ((value >> 6) & 0x3F);
+ *(parser->buffer.last++) = 0x80 + (value & 0x3F);
+ }
+ /* 0001 0000-0010 FFFF -> 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
+ else {
+ *(parser->buffer.last++) = 0xF0 + (value >> 18);
+ *(parser->buffer.last++) = 0x80 + ((value >> 12) & 0x3F);
+ *(parser->buffer.last++) = 0x80 + ((value >> 6) & 0x3F);
+ *(parser->buffer.last++) = 0x80 + (value & 0x3F);
+ }
+
+ parser->unread ++;
+ }
+
+ /* On EOF, put NUL into the buffer and return. */
+
+ if (parser->eof) {
+ *(parser->buffer.last++) = '\0';
+ parser->unread ++;
+ return 1;
+ }
+
+ }
+
+ if (parser->offset >= MAX_FILE_SIZE) {
+ return yaml_parser_set_reader_error(parser, "input is too long",
+ parser->offset, -1);
+ }
+
+ return 1;
+}
diff --git a/libyaml/src/scanner.c b/libyaml/src/scanner.c
new file mode 100644
index 0000000000000000000000000000000000000000..c6b498765646e07628c54305c9eada85c4521d17
--- /dev/null
+++ b/libyaml/src/scanner.c
@@ -0,0 +1,3598 @@
+
+/*
+ * Introduction
+ * ************
+ *
+ * The following notes assume that you are familiar with the YAML specification
+ * (http://yaml.org/spec/cvs/current.html). We mostly follow it, although in
+ * some cases we are less restrictive that it requires.
+ *
+ * The process of transforming a YAML stream into a sequence of events is
+ * divided on two steps: Scanning and Parsing.
+ *
+ * The Scanner transforms the input stream into a sequence of tokens, while the
+ * parser transform the sequence of tokens produced by the Scanner into a
+ * sequence of parsing events.
+ *
+ * The Scanner is rather clever and complicated. The Parser, on the contrary,
+ * is a straightforward implementation of a recursive-descendant parser (or,
+ * LL(1) parser, as it is usually called).
+ *
+ * Actually there are two issues of Scanning that might be called "clever", the
+ * rest is quite straightforward. The issues are "block collection start" and
+ * "simple keys". Both issues are explained below in details.
+ *
+ * Here the Scanning step is explained and implemented. We start with the list
+ * of all the tokens produced by the Scanner together with short descriptions.
+ *
+ * Now, tokens:
+ *
+ * STREAM-START(encoding) # The stream start.
+ * STREAM-END # The stream end.
+ * VERSION-DIRECTIVE(major,minor) # The '%YAML' directive.
+ * TAG-DIRECTIVE(handle,prefix) # The '%TAG' directive.
+ * DOCUMENT-START # '---'
+ * DOCUMENT-END # '...'
+ * BLOCK-SEQUENCE-START # Indentation increase denoting a block
+ * BLOCK-MAPPING-START # sequence or a block mapping.
+ * BLOCK-END # Indentation decrease.
+ * FLOW-SEQUENCE-START # '['
+ * FLOW-SEQUENCE-END # ']'
+ * FLOW-MAPPING-START # '{'
+ * FLOW-MAPPING-END # '}'
+ * BLOCK-ENTRY # '-'
+ * FLOW-ENTRY # ','
+ * KEY # '?' or nothing (simple keys).
+ * VALUE # ':'
+ * ALIAS(anchor) # '*anchor'
+ * ANCHOR(anchor) # '&anchor'
+ * TAG(handle,suffix) # '!handle!suffix'
+ * SCALAR(value,style) # A scalar.
+ *
+ * The following two tokens are "virtual" tokens denoting the beginning and the
+ * end of the stream:
+ *
+ * STREAM-START(encoding)
+ * STREAM-END
+ *
+ * We pass the information about the input stream encoding with the
+ * STREAM-START token.
+ *
+ * The next two tokens are responsible for tags:
+ *
+ * VERSION-DIRECTIVE(major,minor)
+ * TAG-DIRECTIVE(handle,prefix)
+ *
+ * Example:
+ *
+ * %YAML 1.1
+ * %TAG ! !foo
+ * %TAG !yaml! tag:yaml.org,2002:
+ * ---
+ *
+ * The corresponding sequence of tokens:
+ *
+ * STREAM-START(utf-8)
+ * VERSION-DIRECTIVE(1,1)
+ * TAG-DIRECTIVE("!","!foo")
+ * TAG-DIRECTIVE("!yaml","tag:yaml.org,2002:")
+ * DOCUMENT-START
+ * STREAM-END
+ *
+ * Note that the VERSION-DIRECTIVE and TAG-DIRECTIVE tokens occupy a whole
+ * line.
+ *
+ * The document start and end indicators are represented by:
+ *
+ * DOCUMENT-START
+ * DOCUMENT-END
+ *
+ * Note that if a YAML stream contains an implicit document (without '---'
+ * and '...' indicators), no DOCUMENT-START and DOCUMENT-END tokens will be
+ * produced.
+ *
+ * In the following examples, we present whole documents together with the
+ * produced tokens.
+ *
+ * 1. An implicit document:
+ *
+ * 'a scalar'
+ *
+ * Tokens:
+ *
+ * STREAM-START(utf-8)
+ * SCALAR("a scalar",single-quoted)
+ * STREAM-END
+ *
+ * 2. An explicit document:
+ *
+ * ---
+ * 'a scalar'
+ * ...
+ *
+ * Tokens:
+ *
+ * STREAM-START(utf-8)
+ * DOCUMENT-START
+ * SCALAR("a scalar",single-quoted)
+ * DOCUMENT-END
+ * STREAM-END
+ *
+ * 3. Several documents in a stream:
+ *
+ * 'a scalar'
+ * ---
+ * 'another scalar'
+ * ---
+ * 'yet another scalar'
+ *
+ * Tokens:
+ *
+ * STREAM-START(utf-8)
+ * SCALAR("a scalar",single-quoted)
+ * DOCUMENT-START
+ * SCALAR("another scalar",single-quoted)
+ * DOCUMENT-START
+ * SCALAR("yet another scalar",single-quoted)
+ * STREAM-END
+ *
+ * We have already introduced the SCALAR token above. The following tokens are
+ * used to describe aliases, anchors, tag, and scalars:
+ *
+ * ALIAS(anchor)
+ * ANCHOR(anchor)
+ * TAG(handle,suffix)
+ * SCALAR(value,style)
+ *
+ * The following series of examples illustrate the usage of these tokens:
+ *
+ * 1. A recursive sequence:
+ *
+ * &A [ *A ]
+ *
+ * Tokens:
+ *
+ * STREAM-START(utf-8)
+ * ANCHOR("A")
+ * FLOW-SEQUENCE-START
+ * ALIAS("A")
+ * FLOW-SEQUENCE-END
+ * STREAM-END
+ *
+ * 2. A tagged scalar:
+ *
+ * !!float "3.14" # A good approximation.
+ *
+ * Tokens:
+ *
+ * STREAM-START(utf-8)
+ * TAG("!!","float")
+ * SCALAR("3.14",double-quoted)
+ * STREAM-END
+ *
+ * 3. Various scalar styles:
+ *
+ * --- # Implicit empty plain scalars do not produce tokens.
+ * --- a plain scalar
+ * --- 'a single-quoted scalar'
+ * --- "a double-quoted scalar"
+ * --- |-
+ * a literal scalar
+ * --- >-
+ * a folded
+ * scalar
+ *
+ * Tokens:
+ *
+ * STREAM-START(utf-8)
+ * DOCUMENT-START
+ * DOCUMENT-START
+ * SCALAR("a plain scalar",plain)
+ * DOCUMENT-START
+ * SCALAR("a single-quoted scalar",single-quoted)
+ * DOCUMENT-START
+ * SCALAR("a double-quoted scalar",double-quoted)
+ * DOCUMENT-START
+ * SCALAR("a literal scalar",literal)
+ * DOCUMENT-START
+ * SCALAR("a folded scalar",folded)
+ * STREAM-END
+ *
+ * Now it's time to review collection-related tokens. We will start with
+ * flow collections:
+ *
+ * FLOW-SEQUENCE-START
+ * FLOW-SEQUENCE-END
+ * FLOW-MAPPING-START
+ * FLOW-MAPPING-END
+ * FLOW-ENTRY
+ * KEY
+ * VALUE
+ *
+ * The tokens FLOW-SEQUENCE-START, FLOW-SEQUENCE-END, FLOW-MAPPING-START, and
+ * FLOW-MAPPING-END represent the indicators '[', ']', '{', and '}'
+ * correspondingly. FLOW-ENTRY represent the ',' indicator. Finally the
+ * indicators '?' and ':', which are used for denoting mapping keys and values,
+ * are represented by the KEY and VALUE tokens.
+ *
+ * The following examples show flow collections:
+ *
+ * 1. A flow sequence:
+ *
+ * [item 1, item 2, item 3]
+ *
+ * Tokens:
+ *
+ * STREAM-START(utf-8)
+ * FLOW-SEQUENCE-START
+ * SCALAR("item 1",plain)
+ * FLOW-ENTRY
+ * SCALAR("item 2",plain)
+ * FLOW-ENTRY
+ * SCALAR("item 3",plain)
+ * FLOW-SEQUENCE-END
+ * STREAM-END
+ *
+ * 2. A flow mapping:
+ *
+ * {
+ * a simple key: a value, # Note that the KEY token is produced.
+ * ? a complex key: another value,
+ * }
+ *
+ * Tokens:
+ *
+ * STREAM-START(utf-8)
+ * FLOW-MAPPING-START
+ * KEY
+ * SCALAR("a simple key",plain)
+ * VALUE
+ * SCALAR("a value",plain)
+ * FLOW-ENTRY
+ * KEY
+ * SCALAR("a complex key",plain)
+ * VALUE
+ * SCALAR("another value",plain)
+ * FLOW-ENTRY
+ * FLOW-MAPPING-END
+ * STREAM-END
+ *
+ * A simple key is a key which is not denoted by the '?' indicator. Note that
+ * the Scanner still produce the KEY token whenever it encounters a simple key.
+ *
+ * For scanning block collections, the following tokens are used (note that we
+ * repeat KEY and VALUE here):
+ *
+ * BLOCK-SEQUENCE-START
+ * BLOCK-MAPPING-START
+ * BLOCK-END
+ * BLOCK-ENTRY
+ * KEY
+ * VALUE
+ *
+ * The tokens BLOCK-SEQUENCE-START and BLOCK-MAPPING-START denote indentation
+ * increase that precedes a block collection (cf. the INDENT token in Python).
+ * The token BLOCK-END denote indentation decrease that ends a block collection
+ * (cf. the DEDENT token in Python). However YAML has some syntax pecularities
+ * that makes detections of these tokens more complex.
+ *
+ * The tokens BLOCK-ENTRY, KEY, and VALUE are used to represent the indicators
+ * '-', '?', and ':' correspondingly.
+ *
+ * The following examples show how the tokens BLOCK-SEQUENCE-START,
+ * BLOCK-MAPPING-START, and BLOCK-END are emitted by the Scanner:
+ *
+ * 1. Block sequences:
+ *
+ * - item 1
+ * - item 2
+ * -
+ * - item 3.1
+ * - item 3.2
+ * -
+ * key 1: value 1
+ * key 2: value 2
+ *
+ * Tokens:
+ *
+ * STREAM-START(utf-8)
+ * BLOCK-SEQUENCE-START
+ * BLOCK-ENTRY
+ * SCALAR("item 1",plain)
+ * BLOCK-ENTRY
+ * SCALAR("item 2",plain)
+ * BLOCK-ENTRY
+ * BLOCK-SEQUENCE-START
+ * BLOCK-ENTRY
+ * SCALAR("item 3.1",plain)
+ * BLOCK-ENTRY
+ * SCALAR("item 3.2",plain)
+ * BLOCK-END
+ * BLOCK-ENTRY
+ * BLOCK-MAPPING-START
+ * KEY
+ * SCALAR("key 1",plain)
+ * VALUE
+ * SCALAR("value 1",plain)
+ * KEY
+ * SCALAR("key 2",plain)
+ * VALUE
+ * SCALAR("value 2",plain)
+ * BLOCK-END
+ * BLOCK-END
+ * STREAM-END
+ *
+ * 2. Block mappings:
+ *
+ * a simple key: a value # The KEY token is produced here.
+ * ? a complex key
+ * : another value
+ * a mapping:
+ * key 1: value 1
+ * key 2: value 2
+ * a sequence:
+ * - item 1
+ * - item 2
+ *
+ * Tokens:
+ *
+ * STREAM-START(utf-8)
+ * BLOCK-MAPPING-START
+ * KEY
+ * SCALAR("a simple key",plain)
+ * VALUE
+ * SCALAR("a value",plain)
+ * KEY
+ * SCALAR("a complex key",plain)
+ * VALUE
+ * SCALAR("another value",plain)
+ * KEY
+ * SCALAR("a mapping",plain)
+ * VALUE
+ * BLOCK-MAPPING-START
+ * KEY
+ * SCALAR("key 1",plain)
+ * VALUE
+ * SCALAR("value 1",plain)
+ * KEY
+ * SCALAR("key 2",plain)
+ * VALUE
+ * SCALAR("value 2",plain)
+ * BLOCK-END
+ * KEY
+ * SCALAR("a sequence",plain)
+ * VALUE
+ * BLOCK-SEQUENCE-START
+ * BLOCK-ENTRY
+ * SCALAR("item 1",plain)
+ * BLOCK-ENTRY
+ * SCALAR("item 2",plain)
+ * BLOCK-END
+ * BLOCK-END
+ * STREAM-END
+ *
+ * YAML does not always require to start a new block collection from a new
+ * line. If the current line contains only '-', '?', and ':' indicators, a new
+ * block collection may start at the current line. The following examples
+ * illustrate this case:
+ *
+ * 1. Collections in a sequence:
+ *
+ * - - item 1
+ * - item 2
+ * - key 1: value 1
+ * key 2: value 2
+ * - ? complex key
+ * : complex value
+ *
+ * Tokens:
+ *
+ * STREAM-START(utf-8)
+ * BLOCK-SEQUENCE-START
+ * BLOCK-ENTRY
+ * BLOCK-SEQUENCE-START
+ * BLOCK-ENTRY
+ * SCALAR("item 1",plain)
+ * BLOCK-ENTRY
+ * SCALAR("item 2",plain)
+ * BLOCK-END
+ * BLOCK-ENTRY
+ * BLOCK-MAPPING-START
+ * KEY
+ * SCALAR("key 1",plain)
+ * VALUE
+ * SCALAR("value 1",plain)
+ * KEY
+ * SCALAR("key 2",plain)
+ * VALUE
+ * SCALAR("value 2",plain)
+ * BLOCK-END
+ * BLOCK-ENTRY
+ * BLOCK-MAPPING-START
+ * KEY
+ * SCALAR("complex key")
+ * VALUE
+ * SCALAR("complex value")
+ * BLOCK-END
+ * BLOCK-END
+ * STREAM-END
+ *
+ * 2. Collections in a mapping:
+ *
+ * ? a sequence
+ * : - item 1
+ * - item 2
+ * ? a mapping
+ * : key 1: value 1
+ * key 2: value 2
+ *
+ * Tokens:
+ *
+ * STREAM-START(utf-8)
+ * BLOCK-MAPPING-START
+ * KEY
+ * SCALAR("a sequence",plain)
+ * VALUE
+ * BLOCK-SEQUENCE-START
+ * BLOCK-ENTRY
+ * SCALAR("item 1",plain)
+ * BLOCK-ENTRY
+ * SCALAR("item 2",plain)
+ * BLOCK-END
+ * KEY
+ * SCALAR("a mapping",plain)
+ * VALUE
+ * BLOCK-MAPPING-START
+ * KEY
+ * SCALAR("key 1",plain)
+ * VALUE
+ * SCALAR("value 1",plain)
+ * KEY
+ * SCALAR("key 2",plain)
+ * VALUE
+ * SCALAR("value 2",plain)
+ * BLOCK-END
+ * BLOCK-END
+ * STREAM-END
+ *
+ * YAML also permits non-indented sequences if they are included into a block
+ * mapping. In this case, the token BLOCK-SEQUENCE-START is not produced:
+ *
+ * key:
+ * - item 1 # BLOCK-SEQUENCE-START is NOT produced here.
+ * - item 2
+ *
+ * Tokens:
+ *
+ * STREAM-START(utf-8)
+ * BLOCK-MAPPING-START
+ * KEY
+ * SCALAR("key",plain)
+ * VALUE
+ * BLOCK-ENTRY
+ * SCALAR("item 1",plain)
+ * BLOCK-ENTRY
+ * SCALAR("item 2",plain)
+ * BLOCK-END
+ */
+
+#include "yaml_private.h"
+
+/*
+ * Ensure that the buffer contains the required number of characters.
+ * Return 1 on success, 0 on failure (reader error or memory error).
+ */
+
+#define CACHE(parser,length) \
+ (parser->unread >= (length) \
+ ? 1 \
+ : yaml_parser_update_buffer(parser, (length)))
+
+/*
+ * Advance the buffer pointer.
+ */
+
+#define SKIP(parser) \
+ (parser->mark.index ++, \
+ parser->mark.column ++, \
+ parser->unread --, \
+ parser->buffer.pointer += WIDTH(parser->buffer))
+
+#define SKIP_LINE(parser) \
+ (IS_CRLF(parser->buffer) ? \
+ (parser->mark.index += 2, \
+ parser->mark.column = 0, \
+ parser->mark.line ++, \
+ parser->unread -= 2, \
+ parser->buffer.pointer += 2) : \
+ IS_BREAK(parser->buffer) ? \
+ (parser->mark.index ++, \
+ parser->mark.column = 0, \
+ parser->mark.line ++, \
+ parser->unread --, \
+ parser->buffer.pointer += WIDTH(parser->buffer)) : 0)
+
+/*
+ * Copy a character to a string buffer and advance pointers.
+ */
+
+#define READ(parser,string) \
+ (STRING_EXTEND(parser,string) ? \
+ (COPY(string,parser->buffer), \
+ parser->mark.index ++, \
+ parser->mark.column ++, \
+ parser->unread --, \
+ 1) : 0)
+
+/*
+ * Copy a line break character to a string buffer and advance pointers.
+ */
+
+#define READ_LINE(parser,string) \
+ (STRING_EXTEND(parser,string) ? \
+ (((CHECK_AT(parser->buffer,'\r',0) \
+ && CHECK_AT(parser->buffer,'\n',1)) ? /* CR LF -> LF */ \
+ (*((string).pointer++) = (yaml_char_t) '\n', \
+ parser->buffer.pointer += 2, \
+ parser->mark.index += 2, \
+ parser->mark.column = 0, \
+ parser->mark.line ++, \
+ parser->unread -= 2) : \
+ (CHECK_AT(parser->buffer,'\r',0) \
+ || CHECK_AT(parser->buffer,'\n',0)) ? /* CR|LF -> LF */ \
+ (*((string).pointer++) = (yaml_char_t) '\n', \
+ parser->buffer.pointer ++, \
+ parser->mark.index ++, \
+ parser->mark.column = 0, \
+ parser->mark.line ++, \
+ parser->unread --) : \
+ (CHECK_AT(parser->buffer,'\xC2',0) \
+ && CHECK_AT(parser->buffer,'\x85',1)) ? /* NEL -> LF */ \
+ (*((string).pointer++) = (yaml_char_t) '\n', \
+ parser->buffer.pointer += 2, \
+ parser->mark.index ++, \
+ parser->mark.column = 0, \
+ parser->mark.line ++, \
+ parser->unread --) : \
+ (CHECK_AT(parser->buffer,'\xE2',0) && \
+ CHECK_AT(parser->buffer,'\x80',1) && \
+ (CHECK_AT(parser->buffer,'\xA8',2) || \
+ CHECK_AT(parser->buffer,'\xA9',2))) ? /* LS|PS -> LS|PS */ \
+ (*((string).pointer++) = *(parser->buffer.pointer++), \
+ *((string).pointer++) = *(parser->buffer.pointer++), \
+ *((string).pointer++) = *(parser->buffer.pointer++), \
+ parser->mark.index ++, \
+ parser->mark.column = 0, \
+ parser->mark.line ++, \
+ parser->unread --) : 0), \
+ 1) : 0)
+
+/*
+ * Public API declarations.
+ */
+
+YAML_DECLARE(int)
+yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token);
+
+/*
+ * Error handling.
+ */
+
+static int
+yaml_parser_set_scanner_error(yaml_parser_t *parser, const char *context,
+ yaml_mark_t context_mark, const char *problem);
+
+/*
+ * High-level token API.
+ */
+
+YAML_DECLARE(int)
+yaml_parser_fetch_more_tokens(yaml_parser_t *parser);
+
+static int
+yaml_parser_fetch_next_token(yaml_parser_t *parser);
+
+/*
+ * Potential simple keys.
+ */
+
+static int
+yaml_parser_stale_simple_keys(yaml_parser_t *parser);
+
+static int
+yaml_parser_save_simple_key(yaml_parser_t *parser);
+
+static int
+yaml_parser_remove_simple_key(yaml_parser_t *parser);
+
+static int
+yaml_parser_increase_flow_level(yaml_parser_t *parser);
+
+static int
+yaml_parser_decrease_flow_level(yaml_parser_t *parser);
+
+/*
+ * Indentation treatment.
+ */
+
+static int
+yaml_parser_roll_indent(yaml_parser_t *parser, ptrdiff_t column,
+ ptrdiff_t number, yaml_token_type_t type, yaml_mark_t mark);
+
+static int
+yaml_parser_unroll_indent(yaml_parser_t *parser, ptrdiff_t column);
+
+/*
+ * Token fetchers.
+ */
+
+static int
+yaml_parser_fetch_stream_start(yaml_parser_t *parser);
+
+static int
+yaml_parser_fetch_stream_end(yaml_parser_t *parser);
+
+static int
+yaml_parser_fetch_directive(yaml_parser_t *parser);
+
+static int
+yaml_parser_fetch_document_indicator(yaml_parser_t *parser,
+ yaml_token_type_t type);
+
+static int
+yaml_parser_fetch_flow_collection_start(yaml_parser_t *parser,
+ yaml_token_type_t type);
+
+static int
+yaml_parser_fetch_flow_collection_end(yaml_parser_t *parser,
+ yaml_token_type_t type);
+
+static int
+yaml_parser_fetch_flow_entry(yaml_parser_t *parser);
+
+static int
+yaml_parser_fetch_block_entry(yaml_parser_t *parser);
+
+static int
+yaml_parser_fetch_key(yaml_parser_t *parser);
+
+static int
+yaml_parser_fetch_value(yaml_parser_t *parser);
+
+static int
+yaml_parser_fetch_anchor(yaml_parser_t *parser, yaml_token_type_t type);
+
+static int
+yaml_parser_fetch_tag(yaml_parser_t *parser);
+
+static int
+yaml_parser_fetch_block_scalar(yaml_parser_t *parser, int literal);
+
+static int
+yaml_parser_fetch_flow_scalar(yaml_parser_t *parser, int single);
+
+static int
+yaml_parser_fetch_plain_scalar(yaml_parser_t *parser);
+
+/*
+ * Token scanners.
+ */
+
+static int
+yaml_parser_scan_to_next_token(yaml_parser_t *parser);
+
+static int
+yaml_parser_scan_directive(yaml_parser_t *parser, yaml_token_t *token);
+
+static int
+yaml_parser_scan_directive_name(yaml_parser_t *parser,
+ yaml_mark_t start_mark, yaml_char_t **name);
+
+static int
+yaml_parser_scan_version_directive_value(yaml_parser_t *parser,
+ yaml_mark_t start_mark, int *major, int *minor);
+
+static int
+yaml_parser_scan_version_directive_number(yaml_parser_t *parser,
+ yaml_mark_t start_mark, int *number);
+
+static int
+yaml_parser_scan_tag_directive_value(yaml_parser_t *parser,
+ yaml_mark_t mark, yaml_char_t **handle, yaml_char_t **prefix);
+
+static int
+yaml_parser_scan_anchor(yaml_parser_t *parser, yaml_token_t *token,
+ yaml_token_type_t type);
+
+static int
+yaml_parser_scan_tag(yaml_parser_t *parser, yaml_token_t *token);
+
+static int
+yaml_parser_scan_tag_handle(yaml_parser_t *parser, int directive,
+ yaml_mark_t start_mark, yaml_char_t **handle);
+
+static int
+yaml_parser_scan_tag_uri(yaml_parser_t *parser, int uri_char, int directive,
+ yaml_char_t *head, yaml_mark_t start_mark, yaml_char_t **uri);
+
+static int
+yaml_parser_scan_uri_escapes(yaml_parser_t *parser, int directive,
+ yaml_mark_t start_mark, yaml_string_t *string);
+
+static int
+yaml_parser_scan_block_scalar(yaml_parser_t *parser, yaml_token_t *token,
+ int literal);
+
+static int
+yaml_parser_scan_block_scalar_breaks(yaml_parser_t *parser,
+ int *indent, yaml_string_t *breaks,
+ yaml_mark_t start_mark, yaml_mark_t *end_mark);
+
+static int
+yaml_parser_scan_flow_scalar(yaml_parser_t *parser, yaml_token_t *token,
+ int single);
+
+static int
+yaml_parser_scan_plain_scalar(yaml_parser_t *parser, yaml_token_t *token);
+
+/*
+ * Get the next token.
+ */
+
+YAML_DECLARE(int)
+yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token)
+{
+ assert(parser); /* Non-NULL parser object is expected. */
+ assert(token); /* Non-NULL token object is expected. */
+
+ /* Erase the token object. */
+
+ memset(token, 0, sizeof(yaml_token_t));
+
+ /* No tokens after STREAM-END or error. */
+
+ if (parser->stream_end_produced || parser->error) {
+ return 1;
+ }
+
+ /* Ensure that the tokens queue contains enough tokens. */
+
+ if (!parser->token_available) {
+ if (!yaml_parser_fetch_more_tokens(parser))
+ return 0;
+ }
+
+ /* Fetch the next token from the queue. */
+
+ *token = DEQUEUE(parser, parser->tokens);
+ parser->token_available = 0;
+ parser->tokens_parsed ++;
+
+ if (token->type == YAML_STREAM_END_TOKEN) {
+ parser->stream_end_produced = 1;
+ }
+
+ return 1;
+}
+
+/*
+ * Set the scanner error and return 0.
+ */
+
+static int
+yaml_parser_set_scanner_error(yaml_parser_t *parser, const char *context,
+ yaml_mark_t context_mark, const char *problem)
+{
+ parser->error = YAML_SCANNER_ERROR;
+ parser->context = context;
+ parser->context_mark = context_mark;
+ parser->problem = problem;
+ parser->problem_mark = parser->mark;
+
+ return 0;
+}
+
+/*
+ * Ensure that the tokens queue contains at least one token which can be
+ * returned to the Parser.
+ */
+
+YAML_DECLARE(int)
+yaml_parser_fetch_more_tokens(yaml_parser_t *parser)
+{
+ int need_more_tokens;
+
+ /* While we need more tokens to fetch, do it. */
+
+ while (1)
+ {
+ /*
+ * Check if we really need to fetch more tokens.
+ */
+
+ need_more_tokens = 0;
+
+ if (parser->tokens.head == parser->tokens.tail)
+ {
+ /* Queue is empty. */
+
+ need_more_tokens = 1;
+ }
+ else
+ {
+ yaml_simple_key_t *simple_key;
+
+ /* Check if any potential simple key may occupy the head position. */
+
+ if (!yaml_parser_stale_simple_keys(parser))
+ return 0;
+
+ for (simple_key = parser->simple_keys.start;
+ simple_key != parser->simple_keys.top; simple_key++) {
+ if (simple_key->possible
+ && simple_key->token_number == parser->tokens_parsed) {
+ need_more_tokens = 1;
+ break;
+ }
+ }
+ }
+
+ /* We are finished. */
+
+ if (!need_more_tokens)
+ break;
+
+ /* Fetch the next token. */
+
+ if (!yaml_parser_fetch_next_token(parser))
+ return 0;
+ }
+
+ parser->token_available = 1;
+
+ return 1;
+}
+
+/*
+ * The dispatcher for token fetchers.
+ */
+
+static int
+yaml_parser_fetch_next_token(yaml_parser_t *parser)
+{
+ /* Ensure that the buffer is initialized. */
+
+ if (!CACHE(parser, 1))
+ return 0;
+
+ /* Check if we just started scanning. Fetch STREAM-START then. */
+
+ if (!parser->stream_start_produced)
+ return yaml_parser_fetch_stream_start(parser);
+
+ /* Eat whitespaces and comments until we reach the next token. */
+
+ if (!yaml_parser_scan_to_next_token(parser))
+ return 0;
+
+ /* Remove obsolete potential simple keys. */
+
+ if (!yaml_parser_stale_simple_keys(parser))
+ return 0;
+
+ /* Check the indentation level against the current column. */
+
+ if (!yaml_parser_unroll_indent(parser, parser->mark.column))
+ return 0;
+
+ /*
+ * Ensure that the buffer contains at least 4 characters. 4 is the length
+ * of the longest indicators ('--- ' and '... ').
+ */
+
+ if (!CACHE(parser, 4))
+ return 0;
+
+ /* Is it the end of the stream? */
+
+ if (IS_Z(parser->buffer))
+ return yaml_parser_fetch_stream_end(parser);
+
+ /* Is it a directive? */
+
+ if (parser->mark.column == 0 && CHECK(parser->buffer, '%'))
+ return yaml_parser_fetch_directive(parser);
+
+ /* Is it the document start indicator? */
+
+ if (parser->mark.column == 0
+ && CHECK_AT(parser->buffer, '-', 0)
+ && CHECK_AT(parser->buffer, '-', 1)
+ && CHECK_AT(parser->buffer, '-', 2)
+ && IS_BLANKZ_AT(parser->buffer, 3))
+ return yaml_parser_fetch_document_indicator(parser,
+ YAML_DOCUMENT_START_TOKEN);
+
+ /* Is it the document end indicator? */
+
+ if (parser->mark.column == 0
+ && CHECK_AT(parser->buffer, '.', 0)
+ && CHECK_AT(parser->buffer, '.', 1)
+ && CHECK_AT(parser->buffer, '.', 2)
+ && IS_BLANKZ_AT(parser->buffer, 3))
+ return yaml_parser_fetch_document_indicator(parser,
+ YAML_DOCUMENT_END_TOKEN);
+
+ /* Is it the flow sequence start indicator? */
+
+ if (CHECK(parser->buffer, '['))
+ return yaml_parser_fetch_flow_collection_start(parser,
+ YAML_FLOW_SEQUENCE_START_TOKEN);
+
+ /* Is it the flow mapping start indicator? */
+
+ if (CHECK(parser->buffer, '{'))
+ return yaml_parser_fetch_flow_collection_start(parser,
+ YAML_FLOW_MAPPING_START_TOKEN);
+
+ /* Is it the flow sequence end indicator? */
+
+ if (CHECK(parser->buffer, ']'))
+ return yaml_parser_fetch_flow_collection_end(parser,
+ YAML_FLOW_SEQUENCE_END_TOKEN);
+
+ /* Is it the flow mapping end indicator? */
+
+ if (CHECK(parser->buffer, '}'))
+ return yaml_parser_fetch_flow_collection_end(parser,
+ YAML_FLOW_MAPPING_END_TOKEN);
+
+ /* Is it the flow entry indicator? */
+
+ if (CHECK(parser->buffer, ','))
+ return yaml_parser_fetch_flow_entry(parser);
+
+ /* Is it the block entry indicator? */
+
+ if (CHECK(parser->buffer, '-') && IS_BLANKZ_AT(parser->buffer, 1))
+ return yaml_parser_fetch_block_entry(parser);
+
+ /* Is it the key indicator? */
+
+ if (CHECK(parser->buffer, '?')
+ && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))
+ return yaml_parser_fetch_key(parser);
+
+ /* Is it the value indicator? */
+
+ if (CHECK(parser->buffer, ':')
+ && (parser->flow_level || IS_BLANKZ_AT(parser->buffer, 1)))
+ return yaml_parser_fetch_value(parser);
+
+ /* Is it an alias? */
+
+ if (CHECK(parser->buffer, '*'))
+ return yaml_parser_fetch_anchor(parser, YAML_ALIAS_TOKEN);
+
+ /* Is it an anchor? */
+
+ if (CHECK(parser->buffer, '&'))
+ return yaml_parser_fetch_anchor(parser, YAML_ANCHOR_TOKEN);
+
+ /* Is it a tag? */
+
+ if (CHECK(parser->buffer, '!'))
+ return yaml_parser_fetch_tag(parser);
+
+ /* Is it a literal scalar? */
+
+ if (CHECK(parser->buffer, '|') && !parser->flow_level)
+ return yaml_parser_fetch_block_scalar(parser, 1);
+
+ /* Is it a folded scalar? */
+
+ if (CHECK(parser->buffer, '>') && !parser->flow_level)
+ return yaml_parser_fetch_block_scalar(parser, 0);
+
+ /* Is it a single-quoted scalar? */
+
+ if (CHECK(parser->buffer, '\''))
+ return yaml_parser_fetch_flow_scalar(parser, 1);
+
+ /* Is it a double-quoted scalar? */
+
+ if (CHECK(parser->buffer, '"'))
+ return yaml_parser_fetch_flow_scalar(parser, 0);
+
+ /*
+ * Is it a plain scalar?
+ *
+ * A plain scalar may start with any non-blank characters except
+ *
+ * '-', '?', ':', ',', '[', ']', '{', '}',
+ * '#', '&', '*', '!', '|', '>', '\'', '\"',
+ * '%', '@', '`'.
+ *
+ * In the block context (and, for the '-' indicator, in the flow context
+ * too), it may also start with the characters
+ *
+ * '-', '?', ':'
+ *
+ * if it is followed by a non-space character.
+ *
+ * The last rule is more restrictive than the specification requires.
+ */
+
+ if (!(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '-')
+ || CHECK(parser->buffer, '?') || CHECK(parser->buffer, ':')
+ || CHECK(parser->buffer, ',') || CHECK(parser->buffer, '[')
+ || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '{')
+ || CHECK(parser->buffer, '}') || CHECK(parser->buffer, '#')
+ || CHECK(parser->buffer, '&') || CHECK(parser->buffer, '*')
+ || CHECK(parser->buffer, '!') || CHECK(parser->buffer, '|')
+ || CHECK(parser->buffer, '>') || CHECK(parser->buffer, '\'')
+ || CHECK(parser->buffer, '"') || CHECK(parser->buffer, '%')
+ || CHECK(parser->buffer, '@') || CHECK(parser->buffer, '`')) ||
+ (CHECK(parser->buffer, '-') && !IS_BLANK_AT(parser->buffer, 1)) ||
+ (!parser->flow_level &&
+ (CHECK(parser->buffer, '?') || CHECK(parser->buffer, ':'))
+ && !IS_BLANKZ_AT(parser->buffer, 1)))
+ return yaml_parser_fetch_plain_scalar(parser);
+
+ /*
+ * If we don't determine the token type so far, it is an error.
+ */
+
+ return yaml_parser_set_scanner_error(parser,
+ "while scanning for the next token", parser->mark,
+ "found character that cannot start any token");
+}
+
+/*
+ * Check the list of potential simple keys and remove the positions that
+ * cannot contain simple keys anymore.
+ */
+
+static int
+yaml_parser_stale_simple_keys(yaml_parser_t *parser)
+{
+ yaml_simple_key_t *simple_key;
+
+ /* Check for a potential simple key for each flow level. */
+
+ for (simple_key = parser->simple_keys.start;
+ simple_key != parser->simple_keys.top; simple_key ++)
+ {
+ /*
+ * The specification requires that a simple key
+ *
+ * - is limited to a single line,
+ * - is shorter than 1024 characters.
+ */
+
+ if (simple_key->possible
+ && (simple_key->mark.line < parser->mark.line
+ || simple_key->mark.index+1024 < parser->mark.index)) {
+
+ /* Check if the potential simple key to be removed is required. */
+
+ if (simple_key->required) {
+ return yaml_parser_set_scanner_error(parser,
+ "while scanning a simple key", simple_key->mark,
+ "could not find expected ':'");
+ }
+
+ simple_key->possible = 0;
+ }
+ }
+
+ return 1;
+}
+
+/*
+ * Check if a simple key may start at the current position and add it if
+ * needed.
+ */
+
+static int
+yaml_parser_save_simple_key(yaml_parser_t *parser)
+{
+ /*
+ * A simple key is required at the current position if the scanner is in
+ * the block context and the current column coincides with the indentation
+ * level.
+ */
+
+ int required = (!parser->flow_level
+ && parser->indent == (ptrdiff_t)parser->mark.column);
+
+ /*
+ * If the current position may start a simple key, save it.
+ */
+
+ if (parser->simple_key_allowed)
+ {
+ yaml_simple_key_t simple_key;
+ simple_key.possible = 1;
+ simple_key.required = required;
+ simple_key.token_number =
+ parser->tokens_parsed + (parser->tokens.tail - parser->tokens.head);
+ simple_key.mark = parser->mark;
+
+ if (!yaml_parser_remove_simple_key(parser)) return 0;
+
+ *(parser->simple_keys.top-1) = simple_key;
+ }
+
+ return 1;
+}
+
+/*
+ * Remove a potential simple key at the current flow level.
+ */
+
+static int
+yaml_parser_remove_simple_key(yaml_parser_t *parser)
+{
+ yaml_simple_key_t *simple_key = parser->simple_keys.top-1;
+
+ if (simple_key->possible)
+ {
+ /* If the key is required, it is an error. */
+
+ if (simple_key->required) {
+ return yaml_parser_set_scanner_error(parser,
+ "while scanning a simple key", simple_key->mark,
+ "could not find expected ':'");
+ }
+ }
+
+ /* Remove the key from the stack. */
+
+ simple_key->possible = 0;
+
+ return 1;
+}
+
+/*
+ * Increase the flow level and resize the simple key list if needed.
+ */
+
+static int
+yaml_parser_increase_flow_level(yaml_parser_t *parser)
+{
+ yaml_simple_key_t empty_simple_key = { 0, 0, 0, { 0, 0, 0 } };
+
+ /* Reset the simple key on the next level. */
+
+ if (!PUSH(parser, parser->simple_keys, empty_simple_key))
+ return 0;
+
+ /* Increase the flow level. */
+
+ if (parser->flow_level == INT_MAX) {
+ parser->error = YAML_MEMORY_ERROR;
+ return 0;
+ }
+
+ parser->flow_level++;
+
+ return 1;
+}
+
+/*
+ * Decrease the flow level.
+ */
+
+static int
+yaml_parser_decrease_flow_level(yaml_parser_t *parser)
+{
+ if (parser->flow_level) {
+ parser->flow_level --;
+ (void)POP(parser, parser->simple_keys);
+ }
+
+ return 1;
+}
+
+/*
+ * Push the current indentation level to the stack and set the new level
+ * the current column is greater than the indentation level. In this case,
+ * append or insert the specified token into the token queue.
+ *
+ */
+
+static int
+yaml_parser_roll_indent(yaml_parser_t *parser, ptrdiff_t column,
+ ptrdiff_t number, yaml_token_type_t type, yaml_mark_t mark)
+{
+ yaml_token_t token;
+
+ /* In the flow context, do nothing. */
+
+ if (parser->flow_level)
+ return 1;
+
+ if (parser->indent < column)
+ {
+ /*
+ * Push the current indentation level to the stack and set the new
+ * indentation level.
+ */
+
+ if (!PUSH(parser, parser->indents, parser->indent))
+ return 0;
+
+ if (column > INT_MAX) {
+ parser->error = YAML_MEMORY_ERROR;
+ return 0;
+ }
+
+ parser->indent = column;
+
+ /* Create a token and insert it into the queue. */
+
+ TOKEN_INIT(token, type, mark, mark);
+
+ if (number == -1) {
+ if (!ENQUEUE(parser, parser->tokens, token))
+ return 0;
+ }
+ else {
+ if (!QUEUE_INSERT(parser,
+ parser->tokens, number - parser->tokens_parsed, token))
+ return 0;
+ }
+ }
+
+ return 1;
+}
+
+/*
+ * Pop indentation levels from the indents stack until the current level
+ * becomes less or equal to the column. For each indentation level, append
+ * the BLOCK-END token.
+ */
+
+
+static int
+yaml_parser_unroll_indent(yaml_parser_t *parser, ptrdiff_t column)
+{
+ yaml_token_t token;
+
+ /* In the flow context, do nothing. */
+
+ if (parser->flow_level)
+ return 1;
+
+ /* Loop through the indentation levels in the stack. */
+
+ while (parser->indent > column)
+ {
+ /* Create a token and append it to the queue. */
+
+ TOKEN_INIT(token, YAML_BLOCK_END_TOKEN, parser->mark, parser->mark);
+
+ if (!ENQUEUE(parser, parser->tokens, token))
+ return 0;
+
+ /* Pop the indentation level. */
+
+ parser->indent = POP(parser, parser->indents);
+ }
+
+ return 1;
+}
+
+/*
+ * Initialize the scanner and produce the STREAM-START token.
+ */
+
+static int
+yaml_parser_fetch_stream_start(yaml_parser_t *parser)
+{
+ yaml_simple_key_t simple_key = { 0, 0, 0, { 0, 0, 0 } };
+ yaml_token_t token;
+
+ /* Set the initial indentation. */
+
+ parser->indent = -1;
+
+ /* Initialize the simple key stack. */
+
+ if (!PUSH(parser, parser->simple_keys, simple_key))
+ return 0;
+
+ /* A simple key is allowed at the beginning of the stream. */
+
+ parser->simple_key_allowed = 1;
+
+ /* We have started. */
+
+ parser->stream_start_produced = 1;
+
+ /* Create the STREAM-START token and append it to the queue. */
+
+ STREAM_START_TOKEN_INIT(token, parser->encoding,
+ parser->mark, parser->mark);
+
+ if (!ENQUEUE(parser, parser->tokens, token))
+ return 0;
+
+ return 1;
+}
+
+/*
+ * Produce the STREAM-END token and shut down the scanner.
+ */
+
+static int
+yaml_parser_fetch_stream_end(yaml_parser_t *parser)
+{
+ yaml_token_t token;
+
+ /* Force new line. */
+
+ if (parser->mark.column != 0) {
+ parser->mark.column = 0;
+ parser->mark.line ++;
+ }
+
+ /* Reset the indentation level. */
+
+ if (!yaml_parser_unroll_indent(parser, -1))
+ return 0;
+
+ /* Reset simple keys. */
+
+ if (!yaml_parser_remove_simple_key(parser))
+ return 0;
+
+ parser->simple_key_allowed = 0;
+
+ /* Create the STREAM-END token and append it to the queue. */
+
+ STREAM_END_TOKEN_INIT(token, parser->mark, parser->mark);
+
+ if (!ENQUEUE(parser, parser->tokens, token))
+ return 0;
+
+ return 1;
+}
+
+/*
+ * Produce a VERSION-DIRECTIVE or TAG-DIRECTIVE token.
+ */
+
+static int
+yaml_parser_fetch_directive(yaml_parser_t *parser)
+{
+ yaml_token_t token;
+
+ /* Reset the indentation level. */
+
+ if (!yaml_parser_unroll_indent(parser, -1))
+ return 0;
+
+ /* Reset simple keys. */
+
+ if (!yaml_parser_remove_simple_key(parser))
+ return 0;
+
+ parser->simple_key_allowed = 0;
+
+ /* Create the YAML-DIRECTIVE or TAG-DIRECTIVE token. */
+
+ if (!yaml_parser_scan_directive(parser, &token))
+ return 0;
+
+ /* Append the token to the queue. */
+
+ if (!ENQUEUE(parser, parser->tokens, token)) {
+ yaml_token_delete(&token);
+ return 0;
+ }
+
+ return 1;
+}
+
+/*
+ * Produce the DOCUMENT-START or DOCUMENT-END token.
+ */
+
+static int
+yaml_parser_fetch_document_indicator(yaml_parser_t *parser,
+ yaml_token_type_t type)
+{
+ yaml_mark_t start_mark, end_mark;
+ yaml_token_t token;
+
+ /* Reset the indentation level. */
+
+ if (!yaml_parser_unroll_indent(parser, -1))
+ return 0;
+
+ /* Reset simple keys. */
+
+ if (!yaml_parser_remove_simple_key(parser))
+ return 0;
+
+ parser->simple_key_allowed = 0;
+
+ /* Consume the token. */
+
+ start_mark = parser->mark;
+
+ SKIP(parser);
+ SKIP(parser);
+ SKIP(parser);
+
+ end_mark = parser->mark;
+
+ /* Create the DOCUMENT-START or DOCUMENT-END token. */
+
+ TOKEN_INIT(token, type, start_mark, end_mark);
+
+ /* Append the token to the queue. */
+
+ if (!ENQUEUE(parser, parser->tokens, token))
+ return 0;
+
+ return 1;
+}
+
+/*
+ * Produce the FLOW-SEQUENCE-START or FLOW-MAPPING-START token.
+ */
+
+static int
+yaml_parser_fetch_flow_collection_start(yaml_parser_t *parser,
+ yaml_token_type_t type)
+{
+ yaml_mark_t start_mark, end_mark;
+ yaml_token_t token;
+
+ /* The indicators '[' and '{' may start a simple key. */
+
+ if (!yaml_parser_save_simple_key(parser))
+ return 0;
+
+ /* Increase the flow level. */
+
+ if (!yaml_parser_increase_flow_level(parser))
+ return 0;
+
+ /* A simple key may follow the indicators '[' and '{'. */
+
+ parser->simple_key_allowed = 1;
+
+ /* Consume the token. */
+
+ start_mark = parser->mark;
+ SKIP(parser);
+ end_mark = parser->mark;
+
+ /* Create the FLOW-SEQUENCE-START of FLOW-MAPPING-START token. */
+
+ TOKEN_INIT(token, type, start_mark, end_mark);
+
+ /* Append the token to the queue. */
+
+ if (!ENQUEUE(parser, parser->tokens, token))
+ return 0;
+
+ return 1;
+}
+
+/*
+ * Produce the FLOW-SEQUENCE-END or FLOW-MAPPING-END token.
+ */
+
+static int
+yaml_parser_fetch_flow_collection_end(yaml_parser_t *parser,
+ yaml_token_type_t type)
+{
+ yaml_mark_t start_mark, end_mark;
+ yaml_token_t token;
+
+ /* Reset any potential simple key on the current flow level. */
+
+ if (!yaml_parser_remove_simple_key(parser))
+ return 0;
+
+ /* Decrease the flow level. */
+
+ if (!yaml_parser_decrease_flow_level(parser))
+ return 0;
+
+ /* No simple keys after the indicators ']' and '}'. */
+
+ parser->simple_key_allowed = 0;
+
+ /* Consume the token. */
+
+ start_mark = parser->mark;
+ SKIP(parser);
+ end_mark = parser->mark;
+
+ /* Create the FLOW-SEQUENCE-END of FLOW-MAPPING-END token. */
+
+ TOKEN_INIT(token, type, start_mark, end_mark);
+
+ /* Append the token to the queue. */
+
+ if (!ENQUEUE(parser, parser->tokens, token))
+ return 0;
+
+ return 1;
+}
+
+/*
+ * Produce the FLOW-ENTRY token.
+ */
+
+static int
+yaml_parser_fetch_flow_entry(yaml_parser_t *parser)
+{
+ yaml_mark_t start_mark, end_mark;
+ yaml_token_t token;
+
+ /* Reset any potential simple keys on the current flow level. */
+
+ if (!yaml_parser_remove_simple_key(parser))
+ return 0;
+
+ /* Simple keys are allowed after ','. */
+
+ parser->simple_key_allowed = 1;
+
+ /* Consume the token. */
+
+ start_mark = parser->mark;
+ SKIP(parser);
+ end_mark = parser->mark;
+
+ /* Create the FLOW-ENTRY token and append it to the queue. */
+
+ TOKEN_INIT(token, YAML_FLOW_ENTRY_TOKEN, start_mark, end_mark);
+
+ if (!ENQUEUE(parser, parser->tokens, token))
+ return 0;
+
+ return 1;
+}
+
+/*
+ * Produce the BLOCK-ENTRY token.
+ */
+
+static int
+yaml_parser_fetch_block_entry(yaml_parser_t *parser)
+{
+ yaml_mark_t start_mark, end_mark;
+ yaml_token_t token;
+
+ /* Check if the scanner is in the block context. */
+
+ if (!parser->flow_level)
+ {
+ /* Check if we are allowed to start a new entry. */
+
+ if (!parser->simple_key_allowed) {
+ return yaml_parser_set_scanner_error(parser, NULL, parser->mark,
+ "block sequence entries are not allowed in this context");
+ }
+
+ /* Add the BLOCK-SEQUENCE-START token if needed. */
+
+ if (!yaml_parser_roll_indent(parser, parser->mark.column, -1,
+ YAML_BLOCK_SEQUENCE_START_TOKEN, parser->mark))
+ return 0;
+ }
+ else
+ {
+ /*
+ * It is an error for the '-' indicator to occur in the flow context,
+ * but we let the Parser detect and report about it because the Parser
+ * is able to point to the context.
+ */
+ }
+
+ /* Reset any potential simple keys on the current flow level. */
+
+ if (!yaml_parser_remove_simple_key(parser))
+ return 0;
+
+ /* Simple keys are allowed after '-'. */
+
+ parser->simple_key_allowed = 1;
+
+ /* Consume the token. */
+
+ start_mark = parser->mark;
+ SKIP(parser);
+ end_mark = parser->mark;
+
+ /* Create the BLOCK-ENTRY token and append it to the queue. */
+
+ TOKEN_INIT(token, YAML_BLOCK_ENTRY_TOKEN, start_mark, end_mark);
+
+ if (!ENQUEUE(parser, parser->tokens, token))
+ return 0;
+
+ return 1;
+}
+
+/*
+ * Produce the KEY token.
+ */
+
+static int
+yaml_parser_fetch_key(yaml_parser_t *parser)
+{
+ yaml_mark_t start_mark, end_mark;
+ yaml_token_t token;
+
+ /* In the block context, additional checks are required. */
+
+ if (!parser->flow_level)
+ {
+ /* Check if we are allowed to start a new key (not necessary simple). */
+
+ if (!parser->simple_key_allowed) {
+ return yaml_parser_set_scanner_error(parser, NULL, parser->mark,
+ "mapping keys are not allowed in this context");
+ }
+
+ /* Add the BLOCK-MAPPING-START token if needed. */
+
+ if (!yaml_parser_roll_indent(parser, parser->mark.column, -1,
+ YAML_BLOCK_MAPPING_START_TOKEN, parser->mark))
+ return 0;
+ }
+
+ /* Reset any potential simple keys on the current flow level. */
+
+ if (!yaml_parser_remove_simple_key(parser))
+ return 0;
+
+ /* Simple keys are allowed after '?' in the block context. */
+
+ parser->simple_key_allowed = (!parser->flow_level);
+
+ /* Consume the token. */
+
+ start_mark = parser->mark;
+ SKIP(parser);
+ end_mark = parser->mark;
+
+ /* Create the KEY token and append it to the queue. */
+
+ TOKEN_INIT(token, YAML_KEY_TOKEN, start_mark, end_mark);
+
+ if (!ENQUEUE(parser, parser->tokens, token))
+ return 0;
+
+ return 1;
+}
+
+/*
+ * Produce the VALUE token.
+ */
+
+static int
+yaml_parser_fetch_value(yaml_parser_t *parser)
+{
+ yaml_mark_t start_mark, end_mark;
+ yaml_token_t token;
+ yaml_simple_key_t *simple_key = parser->simple_keys.top-1;
+
+ /* Have we found a simple key? */
+
+ if (simple_key->possible)
+ {
+
+ /* Create the KEY token and insert it into the queue. */
+
+ TOKEN_INIT(token, YAML_KEY_TOKEN, simple_key->mark, simple_key->mark);
+
+ if (!QUEUE_INSERT(parser, parser->tokens,
+ simple_key->token_number - parser->tokens_parsed, token))
+ return 0;
+
+ /* In the block context, we may need to add the BLOCK-MAPPING-START token. */
+
+ if (!yaml_parser_roll_indent(parser, simple_key->mark.column,
+ simple_key->token_number,
+ YAML_BLOCK_MAPPING_START_TOKEN, simple_key->mark))
+ return 0;
+
+ /* Remove the simple key. */
+
+ simple_key->possible = 0;
+
+ /* A simple key cannot follow another simple key. */
+
+ parser->simple_key_allowed = 0;
+ }
+ else
+ {
+ /* The ':' indicator follows a complex key. */
+
+ /* In the block context, extra checks are required. */
+
+ if (!parser->flow_level)
+ {
+ /* Check if we are allowed to start a complex value. */
+
+ if (!parser->simple_key_allowed) {
+ return yaml_parser_set_scanner_error(parser, NULL, parser->mark,
+ "mapping values are not allowed in this context");
+ }
+
+ /* Add the BLOCK-MAPPING-START token if needed. */
+
+ if (!yaml_parser_roll_indent(parser, parser->mark.column, -1,
+ YAML_BLOCK_MAPPING_START_TOKEN, parser->mark))
+ return 0;
+ }
+
+ /* Simple keys after ':' are allowed in the block context. */
+
+ parser->simple_key_allowed = (!parser->flow_level);
+ }
+
+ /* Consume the token. */
+
+ start_mark = parser->mark;
+ SKIP(parser);
+ end_mark = parser->mark;
+
+ /* Create the VALUE token and append it to the queue. */
+
+ TOKEN_INIT(token, YAML_VALUE_TOKEN, start_mark, end_mark);
+
+ if (!ENQUEUE(parser, parser->tokens, token))
+ return 0;
+
+ return 1;
+}
+
+/*
+ * Produce the ALIAS or ANCHOR token.
+ */
+
+static int
+yaml_parser_fetch_anchor(yaml_parser_t *parser, yaml_token_type_t type)
+{
+ yaml_token_t token;
+
+ /* An anchor or an alias could be a simple key. */
+
+ if (!yaml_parser_save_simple_key(parser))
+ return 0;
+
+ /* A simple key cannot follow an anchor or an alias. */
+
+ parser->simple_key_allowed = 0;
+
+ /* Create the ALIAS or ANCHOR token and append it to the queue. */
+
+ if (!yaml_parser_scan_anchor(parser, &token, type))
+ return 0;
+
+ if (!ENQUEUE(parser, parser->tokens, token)) {
+ yaml_token_delete(&token);
+ return 0;
+ }
+ return 1;
+}
+
+/*
+ * Produce the TAG token.
+ */
+
+static int
+yaml_parser_fetch_tag(yaml_parser_t *parser)
+{
+ yaml_token_t token;
+
+ /* A tag could be a simple key. */
+
+ if (!yaml_parser_save_simple_key(parser))
+ return 0;
+
+ /* A simple key cannot follow a tag. */
+
+ parser->simple_key_allowed = 0;
+
+ /* Create the TAG token and append it to the queue. */
+
+ if (!yaml_parser_scan_tag(parser, &token))
+ return 0;
+
+ if (!ENQUEUE(parser, parser->tokens, token)) {
+ yaml_token_delete(&token);
+ return 0;
+ }
+
+ return 1;
+}
+
+/*
+ * Produce the SCALAR(...,literal) or SCALAR(...,folded) tokens.
+ */
+
+static int
+yaml_parser_fetch_block_scalar(yaml_parser_t *parser, int literal)
+{
+ yaml_token_t token;
+
+ /* Remove any potential simple keys. */
+
+ if (!yaml_parser_remove_simple_key(parser))
+ return 0;
+
+ /* A simple key may follow a block scalar. */
+
+ parser->simple_key_allowed = 1;
+
+ /* Create the SCALAR token and append it to the queue. */
+
+ if (!yaml_parser_scan_block_scalar(parser, &token, literal))
+ return 0;
+
+ if (!ENQUEUE(parser, parser->tokens, token)) {
+ yaml_token_delete(&token);
+ return 0;
+ }
+
+ return 1;
+}
+
+/*
+ * Produce the SCALAR(...,single-quoted) or SCALAR(...,double-quoted) tokens.
+ */
+
+static int
+yaml_parser_fetch_flow_scalar(yaml_parser_t *parser, int single)
+{
+ yaml_token_t token;
+
+ /* A plain scalar could be a simple key. */
+
+ if (!yaml_parser_save_simple_key(parser))
+ return 0;
+
+ /* A simple key cannot follow a flow scalar. */
+
+ parser->simple_key_allowed = 0;
+
+ /* Create the SCALAR token and append it to the queue. */
+
+ if (!yaml_parser_scan_flow_scalar(parser, &token, single))
+ return 0;
+
+ if (!ENQUEUE(parser, parser->tokens, token)) {
+ yaml_token_delete(&token);
+ return 0;
+ }
+
+ return 1;
+}
+
+/*
+ * Produce the SCALAR(...,plain) token.
+ */
+
+static int
+yaml_parser_fetch_plain_scalar(yaml_parser_t *parser)
+{
+ yaml_token_t token;
+
+ /* A plain scalar could be a simple key. */
+
+ if (!yaml_parser_save_simple_key(parser))
+ return 0;
+
+ /* A simple key cannot follow a flow scalar. */
+
+ parser->simple_key_allowed = 0;
+
+ /* Create the SCALAR token and append it to the queue. */
+
+ if (!yaml_parser_scan_plain_scalar(parser, &token))
+ return 0;
+
+ if (!ENQUEUE(parser, parser->tokens, token)) {
+ yaml_token_delete(&token);
+ return 0;
+ }
+
+ return 1;
+}
+
+/*
+ * Eat whitespaces and comments until the next token is found.
+ */
+
+static int
+yaml_parser_scan_to_next_token(yaml_parser_t *parser)
+{
+ /* Until the next token is not found. */
+
+ while (1)
+ {
+ /* Allow the BOM mark to start a line. */
+
+ if (!CACHE(parser, 1)) return 0;
+
+ if (parser->mark.column == 0 && IS_BOM(parser->buffer))
+ SKIP(parser);
+
+ /*
+ * Eat whitespaces.
+ *
+ * Tabs are allowed:
+ *
+ * - in the flow context;
+ * - in the block context, but not at the beginning of the line or
+ * after '-', '?', or ':' (complex value).
+ */
+
+ if (!CACHE(parser, 1)) return 0;
+
+ while (CHECK(parser->buffer,' ') ||
+ ((parser->flow_level || !parser->simple_key_allowed) &&
+ CHECK(parser->buffer, '\t'))) {
+ SKIP(parser);
+ if (!CACHE(parser, 1)) return 0;
+ }
+
+ /* Eat a comment until a line break. */
+
+ if (CHECK(parser->buffer, '#')) {
+ while (!IS_BREAKZ(parser->buffer)) {
+ SKIP(parser);
+ if (!CACHE(parser, 1)) return 0;
+ }
+ }
+
+ /* If it is a line break, eat it. */
+
+ if (IS_BREAK(parser->buffer))
+ {
+ if (!CACHE(parser, 2)) return 0;
+ SKIP_LINE(parser);
+
+ /* In the block context, a new line may start a simple key. */
+
+ if (!parser->flow_level) {
+ parser->simple_key_allowed = 1;
+ }
+ }
+ else
+ {
+ /* We have found a token. */
+
+ break;
+ }
+ }
+
+ return 1;
+}
+
+/*
+ * Scan a YAML-DIRECTIVE or TAG-DIRECTIVE token.
+ *
+ * Scope:
+ * %YAML 1.1 # a comment \n
+ * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ * %TAG !yaml! tag:yaml.org,2002: \n
+ * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ */
+
+int
+yaml_parser_scan_directive(yaml_parser_t *parser, yaml_token_t *token)
+{
+ yaml_mark_t start_mark, end_mark;
+ yaml_char_t *name = NULL;
+ int major, minor;
+ yaml_char_t *handle = NULL, *prefix = NULL;
+
+ /* Eat '%'. */
+
+ start_mark = parser->mark;
+
+ SKIP(parser);
+
+ /* Scan the directive name. */
+
+ if (!yaml_parser_scan_directive_name(parser, start_mark, &name))
+ goto error;
+
+ /* Is it a YAML directive? */
+
+ if (strcmp((char *)name, "YAML") == 0)
+ {
+ /* Scan the VERSION directive value. */
+
+ if (!yaml_parser_scan_version_directive_value(parser, start_mark,
+ &major, &minor))
+ goto error;
+
+ end_mark = parser->mark;
+
+ /* Create a VERSION-DIRECTIVE token. */
+
+ VERSION_DIRECTIVE_TOKEN_INIT(*token, major, minor,
+ start_mark, end_mark);
+ }
+
+ /* Is it a TAG directive? */
+
+ else if (strcmp((char *)name, "TAG") == 0)
+ {
+ /* Scan the TAG directive value. */
+
+ if (!yaml_parser_scan_tag_directive_value(parser, start_mark,
+ &handle, &prefix))
+ goto error;
+
+ end_mark = parser->mark;
+
+ /* Create a TAG-DIRECTIVE token. */
+
+ TAG_DIRECTIVE_TOKEN_INIT(*token, handle, prefix,
+ start_mark, end_mark);
+ }
+
+ /* Unknown directive. */
+
+ else
+ {
+ yaml_parser_set_scanner_error(parser, "while scanning a directive",
+ start_mark, "found unknown directive name");
+ goto error;
+ }
+
+ /* Eat the rest of the line including any comments. */
+
+ if (!CACHE(parser, 1)) goto error;
+
+ while (IS_BLANK(parser->buffer)) {
+ SKIP(parser);
+ if (!CACHE(parser, 1)) goto error;
+ }
+
+ if (CHECK(parser->buffer, '#')) {
+ while (!IS_BREAKZ(parser->buffer)) {
+ SKIP(parser);
+ if (!CACHE(parser, 1)) goto error;
+ }
+ }
+
+ /* Check if we are at the end of the line. */
+
+ if (!IS_BREAKZ(parser->buffer)) {
+ yaml_parser_set_scanner_error(parser, "while scanning a directive",
+ start_mark, "did not find expected comment or line break");
+ goto error;
+ }
+
+ /* Eat a line break. */
+
+ if (IS_BREAK(parser->buffer)) {
+ if (!CACHE(parser, 2)) goto error;
+ SKIP_LINE(parser);
+ }
+
+ yaml_free(name);
+
+ return 1;
+
+error:
+ yaml_free(prefix);
+ yaml_free(handle);
+ yaml_free(name);
+ return 0;
+}
+
+/*
+ * Scan the directive name.
+ *
+ * Scope:
+ * %YAML 1.1 # a comment \n
+ * ^^^^
+ * %TAG !yaml! tag:yaml.org,2002: \n
+ * ^^^
+ */
+
+static int
+yaml_parser_scan_directive_name(yaml_parser_t *parser,
+ yaml_mark_t start_mark, yaml_char_t **name)
+{
+ yaml_string_t string = NULL_STRING;
+
+ if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
+
+ /* Consume the directive name. */
+
+ if (!CACHE(parser, 1)) goto error;
+
+ while (IS_ALPHA(parser->buffer))
+ {
+ if (!READ(parser, string)) goto error;
+ if (!CACHE(parser, 1)) goto error;
+ }
+
+ /* Check if the name is empty. */
+
+ if (string.start == string.pointer) {
+ yaml_parser_set_scanner_error(parser, "while scanning a directive",
+ start_mark, "could not find expected directive name");
+ goto error;
+ }
+
+ /* Check for an blank character after the name. */
+
+ if (!IS_BLANKZ(parser->buffer)) {
+ yaml_parser_set_scanner_error(parser, "while scanning a directive",
+ start_mark, "found unexpected non-alphabetical character");
+ goto error;
+ }
+
+ *name = string.start;
+
+ return 1;
+
+error:
+ STRING_DEL(parser, string);
+ return 0;
+}
+
+/*
+ * Scan the value of VERSION-DIRECTIVE.
+ *
+ * Scope:
+ * %YAML 1.1 # a comment \n
+ * ^^^^^^
+ */
+
+static int
+yaml_parser_scan_version_directive_value(yaml_parser_t *parser,
+ yaml_mark_t start_mark, int *major, int *minor)
+{
+ /* Eat whitespaces. */
+
+ if (!CACHE(parser, 1)) return 0;
+
+ while (IS_BLANK(parser->buffer)) {
+ SKIP(parser);
+ if (!CACHE(parser, 1)) return 0;
+ }
+
+ /* Consume the major version number. */
+
+ if (!yaml_parser_scan_version_directive_number(parser, start_mark, major))
+ return 0;
+
+ /* Eat '.'. */
+
+ if (!CHECK(parser->buffer, '.')) {
+ return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",
+ start_mark, "did not find expected digit or '.' character");
+ }
+
+ SKIP(parser);
+
+ /* Consume the minor version number. */
+
+ if (!yaml_parser_scan_version_directive_number(parser, start_mark, minor))
+ return 0;
+
+ return 1;
+}
+
+#define MAX_NUMBER_LENGTH 9
+
+/*
+ * Scan the version number of VERSION-DIRECTIVE.
+ *
+ * Scope:
+ * %YAML 1.1 # a comment \n
+ * ^
+ * %YAML 1.1 # a comment \n
+ * ^
+ */
+
+static int
+yaml_parser_scan_version_directive_number(yaml_parser_t *parser,
+ yaml_mark_t start_mark, int *number)
+{
+ int value = 0;
+ size_t length = 0;
+
+ /* Repeat while the next character is digit. */
+
+ if (!CACHE(parser, 1)) return 0;
+
+ while (IS_DIGIT(parser->buffer))
+ {
+ /* Check if the number is too long. */
+
+ if (++length > MAX_NUMBER_LENGTH) {
+ return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",
+ start_mark, "found extremely long version number");
+ }
+
+ value = value*10 + AS_DIGIT(parser->buffer);
+
+ SKIP(parser);
+
+ if (!CACHE(parser, 1)) return 0;
+ }
+
+ /* Check if the number was present. */
+
+ if (!length) {
+ return yaml_parser_set_scanner_error(parser, "while scanning a %YAML directive",
+ start_mark, "did not find expected version number");
+ }
+
+ *number = value;
+
+ return 1;
+}
+
+/*
+ * Scan the value of a TAG-DIRECTIVE token.
+ *
+ * Scope:
+ * %TAG !yaml! tag:yaml.org,2002: \n
+ * ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+ */
+
+static int
+yaml_parser_scan_tag_directive_value(yaml_parser_t *parser,
+ yaml_mark_t start_mark, yaml_char_t **handle, yaml_char_t **prefix)
+{
+ yaml_char_t *handle_value = NULL;
+ yaml_char_t *prefix_value = NULL;
+
+ /* Eat whitespaces. */
+
+ if (!CACHE(parser, 1)) goto error;
+
+ while (IS_BLANK(parser->buffer)) {
+ SKIP(parser);
+ if (!CACHE(parser, 1)) goto error;
+ }
+
+ /* Scan a handle. */
+
+ if (!yaml_parser_scan_tag_handle(parser, 1, start_mark, &handle_value))
+ goto error;
+
+ /* Expect a whitespace. */
+
+ if (!CACHE(parser, 1)) goto error;
+
+ if (!IS_BLANK(parser->buffer)) {
+ yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive",
+ start_mark, "did not find expected whitespace");
+ goto error;
+ }
+
+ /* Eat whitespaces. */
+
+ while (IS_BLANK(parser->buffer)) {
+ SKIP(parser);
+ if (!CACHE(parser, 1)) goto error;
+ }
+
+ /* Scan a prefix. */
+
+ if (!yaml_parser_scan_tag_uri(parser, 1, 1, NULL, start_mark, &prefix_value))
+ goto error;
+
+ /* Expect a whitespace or line break. */
+
+ if (!CACHE(parser, 1)) goto error;
+
+ if (!IS_BLANKZ(parser->buffer)) {
+ yaml_parser_set_scanner_error(parser, "while scanning a %TAG directive",
+ start_mark, "did not find expected whitespace or line break");
+ goto error;
+ }
+
+ *handle = handle_value;
+ *prefix = prefix_value;
+
+ return 1;
+
+error:
+ yaml_free(handle_value);
+ yaml_free(prefix_value);
+ return 0;
+}
+
+static int
+yaml_parser_scan_anchor(yaml_parser_t *parser, yaml_token_t *token,
+ yaml_token_type_t type)
+{
+ int length = 0;
+ yaml_mark_t start_mark, end_mark;
+ yaml_string_t string = NULL_STRING;
+
+ if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
+
+ /* Eat the indicator character. */
+
+ start_mark = parser->mark;
+
+ SKIP(parser);
+
+ /* Consume the value. */
+
+ if (!CACHE(parser, 1)) goto error;
+
+ while (IS_ALPHA(parser->buffer)) {
+ if (!READ(parser, string)) goto error;
+ if (!CACHE(parser, 1)) goto error;
+ length ++;
+ }
+
+ end_mark = parser->mark;
+
+ /*
+ * Check if length of the anchor is greater than 0 and it is followed by
+ * a whitespace character or one of the indicators:
+ *
+ * '?', ':', ',', ']', '}', '%', '@', '`'.
+ */
+
+ if (!length || !(IS_BLANKZ(parser->buffer) || CHECK(parser->buffer, '?')
+ || CHECK(parser->buffer, ':') || CHECK(parser->buffer, ',')
+ || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '}')
+ || CHECK(parser->buffer, '%') || CHECK(parser->buffer, '@')
+ || CHECK(parser->buffer, '`'))) {
+ yaml_parser_set_scanner_error(parser, type == YAML_ANCHOR_TOKEN ?
+ "while scanning an anchor" : "while scanning an alias", start_mark,
+ "did not find expected alphabetic or numeric character");
+ goto error;
+ }
+
+ /* Create a token. */
+
+ if (type == YAML_ANCHOR_TOKEN) {
+ ANCHOR_TOKEN_INIT(*token, string.start, start_mark, end_mark);
+ }
+ else {
+ ALIAS_TOKEN_INIT(*token, string.start, start_mark, end_mark);
+ }
+
+ return 1;
+
+error:
+ STRING_DEL(parser, string);
+ return 0;
+}
+
+/*
+ * Scan a TAG token.
+ */
+
+static int
+yaml_parser_scan_tag(yaml_parser_t *parser, yaml_token_t *token)
+{
+ yaml_char_t *handle = NULL;
+ yaml_char_t *suffix = NULL;
+ yaml_mark_t start_mark, end_mark;
+
+ start_mark = parser->mark;
+
+ /* Check if the tag is in the canonical form. */
+
+ if (!CACHE(parser, 2)) goto error;
+
+ if (CHECK_AT(parser->buffer, '<', 1))
+ {
+ /* Set the handle to '' */
+
+ handle = YAML_MALLOC(1);
+ if (!handle) goto error;
+ handle[0] = '\0';
+
+ /* Eat '!<' */
+
+ SKIP(parser);
+ SKIP(parser);
+
+ /* Consume the tag value. */
+
+ if (!yaml_parser_scan_tag_uri(parser, 1, 0, NULL, start_mark, &suffix))
+ goto error;
+
+ /* Check for '>' and eat it. */
+
+ if (!CHECK(parser->buffer, '>')) {
+ yaml_parser_set_scanner_error(parser, "while scanning a tag",
+ start_mark, "did not find the expected '>'");
+ goto error;
+ }
+
+ SKIP(parser);
+ }
+ else
+ {
+ /* The tag has either the '!suffix' or the '!handle!suffix' form. */
+
+ /* First, try to scan a handle. */
+
+ if (!yaml_parser_scan_tag_handle(parser, 0, start_mark, &handle))
+ goto error;
+
+ /* Check if it is, indeed, handle. */
+
+ if (handle[0] == '!' && handle[1] != '\0' && handle[strlen((char *)handle)-1] == '!')
+ {
+ /* Scan the suffix now. */
+
+ if (!yaml_parser_scan_tag_uri(parser, 0, 0, NULL, start_mark, &suffix))
+ goto error;
+ }
+ else
+ {
+ /* It wasn't a handle after all. Scan the rest of the tag. */
+
+ if (!yaml_parser_scan_tag_uri(parser, 0, 0, handle, start_mark, &suffix))
+ goto error;
+
+ /* Set the handle to '!'. */
+
+ yaml_free(handle);
+ handle = YAML_MALLOC(2);
+ if (!handle) goto error;
+ handle[0] = '!';
+ handle[1] = '\0';
+
+ /*
+ * A special case: the '!' tag. Set the handle to '' and the
+ * suffix to '!'.
+ */
+
+ if (suffix[0] == '\0') {
+ yaml_char_t *tmp = handle;
+ handle = suffix;
+ suffix = tmp;
+ }
+ }
+ }
+
+ /* Check the character which ends the tag. */
+
+ if (!CACHE(parser, 1)) goto error;
+
+ if (!IS_BLANKZ(parser->buffer)) {
+ if (!parser->flow_level || !CHECK(parser->buffer, ',') ) {
+ yaml_parser_set_scanner_error(parser, "while scanning a tag",
+ start_mark, "did not find expected whitespace or line break");
+ goto error;
+ }
+ }
+
+ end_mark = parser->mark;
+
+ /* Create a token. */
+
+ TAG_TOKEN_INIT(*token, handle, suffix, start_mark, end_mark);
+
+ return 1;
+
+error:
+ yaml_free(handle);
+ yaml_free(suffix);
+ return 0;
+}
+
+/*
+ * Scan a tag handle.
+ */
+
+static int
+yaml_parser_scan_tag_handle(yaml_parser_t *parser, int directive,
+ yaml_mark_t start_mark, yaml_char_t **handle)
+{
+ yaml_string_t string = NULL_STRING;
+
+ if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
+
+ /* Check the initial '!' character. */
+
+ if (!CACHE(parser, 1)) goto error;
+
+ if (!CHECK(parser->buffer, '!')) {
+ yaml_parser_set_scanner_error(parser, directive ?
+ "while scanning a tag directive" : "while scanning a tag",
+ start_mark, "did not find expected '!'");
+ goto error;
+ }
+
+ /* Copy the '!' character. */
+
+ if (!READ(parser, string)) goto error;
+
+ /* Copy all subsequent alphabetical and numerical characters. */
+
+ if (!CACHE(parser, 1)) goto error;
+
+ while (IS_ALPHA(parser->buffer))
+ {
+ if (!READ(parser, string)) goto error;
+ if (!CACHE(parser, 1)) goto error;
+ }
+
+ /* Check if the trailing character is '!' and copy it. */
+
+ if (CHECK(parser->buffer, '!'))
+ {
+ if (!READ(parser, string)) goto error;
+ }
+ else
+ {
+ /*
+ * It's either the '!' tag or not really a tag handle. If it's a %TAG
+ * directive, it's an error. If it's a tag token, it must be a part of
+ * URI.
+ */
+
+ if (directive && !(string.start[0] == '!' && string.start[1] == '\0')) {
+ yaml_parser_set_scanner_error(parser, "while parsing a tag directive",
+ start_mark, "did not find expected '!'");
+ goto error;
+ }
+ }
+
+ *handle = string.start;
+
+ return 1;
+
+error:
+ STRING_DEL(parser, string);
+ return 0;
+}
+
+/*
+ * Scan a tag.
+ */
+
+static int
+yaml_parser_scan_tag_uri(yaml_parser_t *parser, int uri_char, int directive,
+ yaml_char_t *head, yaml_mark_t start_mark, yaml_char_t **uri)
+{
+ size_t length = head ? strlen((char *)head) : 0;
+ yaml_string_t string = NULL_STRING;
+
+ if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
+
+ /* Resize the string to include the head. */
+
+ while ((size_t)(string.end - string.start) <= length) {
+ if (!yaml_string_extend(&string.start, &string.pointer, &string.end)) {
+ parser->error = YAML_MEMORY_ERROR;
+ goto error;
+ }
+ }
+
+ /*
+ * Copy the head if needed.
+ *
+ * Note that we don't copy the leading '!' character.
+ */
+
+ if (length > 1) {
+ memcpy(string.start, head+1, length-1);
+ string.pointer += length-1;
+ }
+
+ /* Scan the tag. */
+
+ if (!CACHE(parser, 1)) goto error;
+
+ /*
+ * The set of characters that may appear in URI is as follows:
+ *
+ * '0'-'9', 'A'-'Z', 'a'-'z', '_', '-', ';', '/', '?', ':', '@', '&',
+ * '=', '+', '$', '.', '!', '~', '*', '\'', '(', ')', '%'.
+ *
+ * If we are inside a verbatim tag <...> (parameter uri_char is true)
+ * then also the following flow indicators are allowed:
+ * ',', '[', ']'
+ */
+
+ while (IS_ALPHA(parser->buffer) || CHECK(parser->buffer, ';')
+ || CHECK(parser->buffer, '/') || CHECK(parser->buffer, '?')
+ || CHECK(parser->buffer, ':') || CHECK(parser->buffer, '@')
+ || CHECK(parser->buffer, '&') || CHECK(parser->buffer, '=')
+ || CHECK(parser->buffer, '+') || CHECK(parser->buffer, '$')
+ || CHECK(parser->buffer, '.') || CHECK(parser->buffer, '%')
+ || CHECK(parser->buffer, '!') || CHECK(parser->buffer, '~')
+ || CHECK(parser->buffer, '*') || CHECK(parser->buffer, '\'')
+ || CHECK(parser->buffer, '(') || CHECK(parser->buffer, ')')
+ || (uri_char && (
+ CHECK(parser->buffer, ',')
+ || CHECK(parser->buffer, '[') || CHECK(parser->buffer, ']')
+ )
+ ))
+ {
+ /* Check if it is a URI-escape sequence. */
+
+ if (CHECK(parser->buffer, '%')) {
+ if (!STRING_EXTEND(parser, string))
+ goto error;
+
+ if (!yaml_parser_scan_uri_escapes(parser,
+ directive, start_mark, &string)) goto error;
+ }
+ else {
+ if (!READ(parser, string)) goto error;
+ }
+
+ length ++;
+ if (!CACHE(parser, 1)) goto error;
+ }
+
+ /* Check if the tag is non-empty. */
+
+ if (!length) {
+ if (!STRING_EXTEND(parser, string))
+ goto error;
+
+ yaml_parser_set_scanner_error(parser, directive ?
+ "while parsing a %TAG directive" : "while parsing a tag",
+ start_mark, "did not find expected tag URI");
+ goto error;
+ }
+
+ *uri = string.start;
+
+ return 1;
+
+error:
+ STRING_DEL(parser, string);
+ return 0;
+}
+
+/*
+ * Decode an URI-escape sequence corresponding to a single UTF-8 character.
+ */
+
+static int
+yaml_parser_scan_uri_escapes(yaml_parser_t *parser, int directive,
+ yaml_mark_t start_mark, yaml_string_t *string)
+{
+ int width = 0;
+
+ /* Decode the required number of characters. */
+
+ do {
+
+ unsigned char octet = 0;
+
+ /* Check for a URI-escaped octet. */
+
+ if (!CACHE(parser, 3)) return 0;
+
+ if (!(CHECK(parser->buffer, '%')
+ && IS_HEX_AT(parser->buffer, 1)
+ && IS_HEX_AT(parser->buffer, 2))) {
+ return yaml_parser_set_scanner_error(parser, directive ?
+ "while parsing a %TAG directive" : "while parsing a tag",
+ start_mark, "did not find URI escaped octet");
+ }
+
+ /* Get the octet. */
+
+ octet = (AS_HEX_AT(parser->buffer, 1) << 4) + AS_HEX_AT(parser->buffer, 2);
+
+ /* If it is the leading octet, determine the length of the UTF-8 sequence. */
+
+ if (!width)
+ {
+ width = (octet & 0x80) == 0x00 ? 1 :
+ (octet & 0xE0) == 0xC0 ? 2 :
+ (octet & 0xF0) == 0xE0 ? 3 :
+ (octet & 0xF8) == 0xF0 ? 4 : 0;
+ if (!width) {
+ return yaml_parser_set_scanner_error(parser, directive ?
+ "while parsing a %TAG directive" : "while parsing a tag",
+ start_mark, "found an incorrect leading UTF-8 octet");
+ }
+ }
+ else
+ {
+ /* Check if the trailing octet is correct. */
+
+ if ((octet & 0xC0) != 0x80) {
+ return yaml_parser_set_scanner_error(parser, directive ?
+ "while parsing a %TAG directive" : "while parsing a tag",
+ start_mark, "found an incorrect trailing UTF-8 octet");
+ }
+ }
+
+ /* Copy the octet and move the pointers. */
+
+ *(string->pointer++) = octet;
+ SKIP(parser);
+ SKIP(parser);
+ SKIP(parser);
+
+ } while (--width);
+
+ return 1;
+}
+
+/*
+ * Scan a block scalar.
+ */
+
+static int
+yaml_parser_scan_block_scalar(yaml_parser_t *parser, yaml_token_t *token,
+ int literal)
+{
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ yaml_string_t string = NULL_STRING;
+ yaml_string_t leading_break = NULL_STRING;
+ yaml_string_t trailing_breaks = NULL_STRING;
+ int chomping = 0;
+ int increment = 0;
+ int indent = 0;
+ int leading_blank = 0;
+ int trailing_blank = 0;
+
+ if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
+ if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error;
+ if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error;
+
+ /* Eat the indicator '|' or '>'. */
+
+ start_mark = parser->mark;
+
+ SKIP(parser);
+
+ /* Scan the additional block scalar indicators. */
+
+ if (!CACHE(parser, 1)) goto error;
+
+ /* Check for a chomping indicator. */
+
+ if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-'))
+ {
+ /* Set the chomping method and eat the indicator. */
+
+ chomping = CHECK(parser->buffer, '+') ? +1 : -1;
+
+ SKIP(parser);
+
+ /* Check for an indentation indicator. */
+
+ if (!CACHE(parser, 1)) goto error;
+
+ if (IS_DIGIT(parser->buffer))
+ {
+ /* Check that the indentation is greater than 0. */
+
+ if (CHECK(parser->buffer, '0')) {
+ yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
+ start_mark, "found an indentation indicator equal to 0");
+ goto error;
+ }
+
+ /* Get the indentation level and eat the indicator. */
+
+ increment = AS_DIGIT(parser->buffer);
+
+ SKIP(parser);
+ }
+ }
+
+ /* Do the same as above, but in the opposite order. */
+
+ else if (IS_DIGIT(parser->buffer))
+ {
+ if (CHECK(parser->buffer, '0')) {
+ yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
+ start_mark, "found an indentation indicator equal to 0");
+ goto error;
+ }
+
+ increment = AS_DIGIT(parser->buffer);
+
+ SKIP(parser);
+
+ if (!CACHE(parser, 1)) goto error;
+
+ if (CHECK(parser->buffer, '+') || CHECK(parser->buffer, '-')) {
+ chomping = CHECK(parser->buffer, '+') ? +1 : -1;
+
+ SKIP(parser);
+ }
+ }
+
+ /* Eat whitespaces and comments to the end of the line. */
+
+ if (!CACHE(parser, 1)) goto error;
+
+ while (IS_BLANK(parser->buffer)) {
+ SKIP(parser);
+ if (!CACHE(parser, 1)) goto error;
+ }
+
+ if (CHECK(parser->buffer, '#')) {
+ while (!IS_BREAKZ(parser->buffer)) {
+ SKIP(parser);
+ if (!CACHE(parser, 1)) goto error;
+ }
+ }
+
+ /* Check if we are at the end of the line. */
+
+ if (!IS_BREAKZ(parser->buffer)) {
+ yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
+ start_mark, "did not find expected comment or line break");
+ goto error;
+ }
+
+ /* Eat a line break. */
+
+ if (IS_BREAK(parser->buffer)) {
+ if (!CACHE(parser, 2)) goto error;
+ SKIP_LINE(parser);
+ }
+
+ end_mark = parser->mark;
+
+ /* Set the indentation level if it was specified. */
+
+ if (increment) {
+ indent = parser->indent >= 0 ? parser->indent+increment : increment;
+ }
+
+ /* Scan the leading line breaks and determine the indentation level if needed. */
+
+ if (!yaml_parser_scan_block_scalar_breaks(parser, &indent, &trailing_breaks,
+ start_mark, &end_mark)) goto error;
+
+ /* Scan the block scalar content. */
+
+ if (!CACHE(parser, 1)) goto error;
+
+ while ((int)parser->mark.column == indent && !(IS_Z(parser->buffer)))
+ {
+ /*
+ * We are at the beginning of a non-empty line.
+ */
+
+ /* Is it a trailing whitespace? */
+
+ trailing_blank = IS_BLANK(parser->buffer);
+
+ /* Check if we need to fold the leading line break. */
+
+ if (!literal && (*leading_break.start == '\n')
+ && !leading_blank && !trailing_blank)
+ {
+ /* Do we need to join the lines by space? */
+
+ if (*trailing_breaks.start == '\0') {
+ if (!STRING_EXTEND(parser, string)) goto error;
+ *(string.pointer ++) = ' ';
+ }
+
+ CLEAR(parser, leading_break);
+ }
+ else {
+ if (!JOIN(parser, string, leading_break)) goto error;
+ CLEAR(parser, leading_break);
+ }
+
+ /* Append the remaining line breaks. */
+
+ if (!JOIN(parser, string, trailing_breaks)) goto error;
+ CLEAR(parser, trailing_breaks);
+
+ /* Is it a leading whitespace? */
+
+ leading_blank = IS_BLANK(parser->buffer);
+
+ /* Consume the current line. */
+
+ while (!IS_BREAKZ(parser->buffer)) {
+ if (!READ(parser, string)) goto error;
+ if (!CACHE(parser, 1)) goto error;
+ }
+
+ /* Consume the line break. */
+
+ if (!CACHE(parser, 2)) goto error;
+
+ if (!READ_LINE(parser, leading_break)) goto error;
+
+ /* Eat the following indentation spaces and line breaks. */
+
+ if (!yaml_parser_scan_block_scalar_breaks(parser,
+ &indent, &trailing_breaks, start_mark, &end_mark)) goto error;
+ }
+
+ /* Chomp the tail. */
+
+ if (chomping != -1) {
+ if (!JOIN(parser, string, leading_break)) goto error;
+ }
+ if (chomping == 1) {
+ if (!JOIN(parser, string, trailing_breaks)) goto error;
+ }
+
+ /* Create a token. */
+
+ SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start,
+ literal ? YAML_LITERAL_SCALAR_STYLE : YAML_FOLDED_SCALAR_STYLE,
+ start_mark, end_mark);
+
+ STRING_DEL(parser, leading_break);
+ STRING_DEL(parser, trailing_breaks);
+
+ return 1;
+
+error:
+ STRING_DEL(parser, string);
+ STRING_DEL(parser, leading_break);
+ STRING_DEL(parser, trailing_breaks);
+
+ return 0;
+}
+
+/*
+ * Scan indentation spaces and line breaks for a block scalar. Determine the
+ * indentation level if needed.
+ */
+
+static int
+yaml_parser_scan_block_scalar_breaks(yaml_parser_t *parser,
+ int *indent, yaml_string_t *breaks,
+ yaml_mark_t start_mark, yaml_mark_t *end_mark)
+{
+ int max_indent = 0;
+
+ *end_mark = parser->mark;
+
+ /* Eat the indentation spaces and line breaks. */
+
+ while (1)
+ {
+ /* Eat the indentation spaces. */
+
+ if (!CACHE(parser, 1)) return 0;
+
+ while ((!*indent || (int)parser->mark.column < *indent)
+ && IS_SPACE(parser->buffer)) {
+ SKIP(parser);
+ if (!CACHE(parser, 1)) return 0;
+ }
+
+ if ((int)parser->mark.column > max_indent)
+ max_indent = (int)parser->mark.column;
+
+ /* Check for a tab character messing the indentation. */
+
+ if ((!*indent || (int)parser->mark.column < *indent)
+ && IS_TAB(parser->buffer)) {
+ return yaml_parser_set_scanner_error(parser, "while scanning a block scalar",
+ start_mark, "found a tab character where an indentation space is expected");
+ }
+
+ /* Have we found a non-empty line? */
+
+ if (!IS_BREAK(parser->buffer)) break;
+
+ /* Consume the line break. */
+
+ if (!CACHE(parser, 2)) return 0;
+ if (!READ_LINE(parser, *breaks)) return 0;
+ *end_mark = parser->mark;
+ }
+
+ /* Determine the indentation level if needed. */
+
+ if (!*indent) {
+ *indent = max_indent;
+ if (*indent < parser->indent + 1)
+ *indent = parser->indent + 1;
+ if (*indent < 1)
+ *indent = 1;
+ }
+
+ return 1;
+}
+
+/*
+ * Scan a quoted scalar.
+ */
+
+static int
+yaml_parser_scan_flow_scalar(yaml_parser_t *parser, yaml_token_t *token,
+ int single)
+{
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ yaml_string_t string = NULL_STRING;
+ yaml_string_t leading_break = NULL_STRING;
+ yaml_string_t trailing_breaks = NULL_STRING;
+ yaml_string_t whitespaces = NULL_STRING;
+ int leading_blanks;
+
+ if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
+ if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error;
+ if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error;
+ if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_SIZE)) goto error;
+
+ /* Eat the left quote. */
+
+ start_mark = parser->mark;
+
+ SKIP(parser);
+
+ /* Consume the content of the quoted scalar. */
+
+ while (1)
+ {
+ /* Check that there are no document indicators at the beginning of the line. */
+
+ if (!CACHE(parser, 4)) goto error;
+
+ if (parser->mark.column == 0 &&
+ ((CHECK_AT(parser->buffer, '-', 0) &&
+ CHECK_AT(parser->buffer, '-', 1) &&
+ CHECK_AT(parser->buffer, '-', 2)) ||
+ (CHECK_AT(parser->buffer, '.', 0) &&
+ CHECK_AT(parser->buffer, '.', 1) &&
+ CHECK_AT(parser->buffer, '.', 2))) &&
+ IS_BLANKZ_AT(parser->buffer, 3))
+ {
+ yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar",
+ start_mark, "found unexpected document indicator");
+ goto error;
+ }
+
+ /* Check for EOF. */
+
+ if (IS_Z(parser->buffer)) {
+ yaml_parser_set_scanner_error(parser, "while scanning a quoted scalar",
+ start_mark, "found unexpected end of stream");
+ goto error;
+ }
+
+ /* Consume non-blank characters. */
+
+ if (!CACHE(parser, 2)) goto error;
+
+ leading_blanks = 0;
+
+ while (!IS_BLANKZ(parser->buffer))
+ {
+ /* Check for an escaped single quote. */
+
+ if (single && CHECK_AT(parser->buffer, '\'', 0)
+ && CHECK_AT(parser->buffer, '\'', 1))
+ {
+ if (!STRING_EXTEND(parser, string)) goto error;
+ *(string.pointer++) = '\'';
+ SKIP(parser);
+ SKIP(parser);
+ }
+
+ /* Check for the right quote. */
+
+ else if (CHECK(parser->buffer, single ? '\'' : '"'))
+ {
+ break;
+ }
+
+ /* Check for an escaped line break. */
+
+ else if (!single && CHECK(parser->buffer, '\\')
+ && IS_BREAK_AT(parser->buffer, 1))
+ {
+ if (!CACHE(parser, 3)) goto error;
+ SKIP(parser);
+ SKIP_LINE(parser);
+ leading_blanks = 1;
+ break;
+ }
+
+ /* Check for an escape sequence. */
+
+ else if (!single && CHECK(parser->buffer, '\\'))
+ {
+ size_t code_length = 0;
+
+ if (!STRING_EXTEND(parser, string)) goto error;
+
+ /* Check the escape character. */
+
+ switch (parser->buffer.pointer[1])
+ {
+ case '0':
+ *(string.pointer++) = '\0';
+ break;
+
+ case 'a':
+ *(string.pointer++) = '\x07';
+ break;
+
+ case 'b':
+ *(string.pointer++) = '\x08';
+ break;
+
+ case 't':
+ case '\t':
+ *(string.pointer++) = '\x09';
+ break;
+
+ case 'n':
+ *(string.pointer++) = '\x0A';
+ break;
+
+ case 'v':
+ *(string.pointer++) = '\x0B';
+ break;
+
+ case 'f':
+ *(string.pointer++) = '\x0C';
+ break;
+
+ case 'r':
+ *(string.pointer++) = '\x0D';
+ break;
+
+ case 'e':
+ *(string.pointer++) = '\x1B';
+ break;
+
+ case ' ':
+ *(string.pointer++) = '\x20';
+ break;
+
+ case '"':
+ *(string.pointer++) = '"';
+ break;
+
+ case '/':
+ *(string.pointer++) = '/';
+ break;
+
+ case '\\':
+ *(string.pointer++) = '\\';
+ break;
+
+ case 'N': /* NEL (#x85) */
+ *(string.pointer++) = '\xC2';
+ *(string.pointer++) = '\x85';
+ break;
+
+ case '_': /* #xA0 */
+ *(string.pointer++) = '\xC2';
+ *(string.pointer++) = '\xA0';
+ break;
+
+ case 'L': /* LS (#x2028) */
+ *(string.pointer++) = '\xE2';
+ *(string.pointer++) = '\x80';
+ *(string.pointer++) = '\xA8';
+ break;
+
+ case 'P': /* PS (#x2029) */
+ *(string.pointer++) = '\xE2';
+ *(string.pointer++) = '\x80';
+ *(string.pointer++) = '\xA9';
+ break;
+
+ case 'x':
+ code_length = 2;
+ break;
+
+ case 'u':
+ code_length = 4;
+ break;
+
+ case 'U':
+ code_length = 8;
+ break;
+
+ default:
+ yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar",
+ start_mark, "found unknown escape character");
+ goto error;
+ }
+
+ SKIP(parser);
+ SKIP(parser);
+
+ /* Consume an arbitrary escape code. */
+
+ if (code_length)
+ {
+ unsigned int value = 0;
+ size_t k;
+
+ /* Scan the character value. */
+
+ if (!CACHE(parser, code_length)) goto error;
+
+ for (k = 0; k < code_length; k ++) {
+ if (!IS_HEX_AT(parser->buffer, k)) {
+ yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar",
+ start_mark, "did not find expected hexdecimal number");
+ goto error;
+ }
+ value = (value << 4) + AS_HEX_AT(parser->buffer, k);
+ }
+
+ /* Check the value and write the character. */
+
+ if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF) {
+ yaml_parser_set_scanner_error(parser, "while parsing a quoted scalar",
+ start_mark, "found invalid Unicode character escape code");
+ goto error;
+ }
+
+ if (value <= 0x7F) {
+ *(string.pointer++) = value;
+ }
+ else if (value <= 0x7FF) {
+ *(string.pointer++) = 0xC0 + (value >> 6);
+ *(string.pointer++) = 0x80 + (value & 0x3F);
+ }
+ else if (value <= 0xFFFF) {
+ *(string.pointer++) = 0xE0 + (value >> 12);
+ *(string.pointer++) = 0x80 + ((value >> 6) & 0x3F);
+ *(string.pointer++) = 0x80 + (value & 0x3F);
+ }
+ else {
+ *(string.pointer++) = 0xF0 + (value >> 18);
+ *(string.pointer++) = 0x80 + ((value >> 12) & 0x3F);
+ *(string.pointer++) = 0x80 + ((value >> 6) & 0x3F);
+ *(string.pointer++) = 0x80 + (value & 0x3F);
+ }
+
+ /* Advance the pointer. */
+
+ for (k = 0; k < code_length; k ++) {
+ SKIP(parser);
+ }
+ }
+ }
+
+ else
+ {
+ /* It is a non-escaped non-blank character. */
+
+ if (!READ(parser, string)) goto error;
+ }
+
+ if (!CACHE(parser, 2)) goto error;
+ }
+
+ /* Check if we are at the end of the scalar. */
+
+ /* Fix for crash unitialized value crash
+ * Credit for the bug and input is to OSS Fuzz
+ * Credit for the fix to Alex Gaynor
+ */
+ if (!CACHE(parser, 1)) goto error;
+ if (CHECK(parser->buffer, single ? '\'' : '"'))
+ break;
+
+ /* Consume blank characters. */
+
+ if (!CACHE(parser, 1)) goto error;
+
+ while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))
+ {
+ if (IS_BLANK(parser->buffer))
+ {
+ /* Consume a space or a tab character. */
+
+ if (!leading_blanks) {
+ if (!READ(parser, whitespaces)) goto error;
+ }
+ else {
+ SKIP(parser);
+ }
+ }
+ else
+ {
+ if (!CACHE(parser, 2)) goto error;
+
+ /* Check if it is a first line break. */
+
+ if (!leading_blanks)
+ {
+ CLEAR(parser, whitespaces);
+ if (!READ_LINE(parser, leading_break)) goto error;
+ leading_blanks = 1;
+ }
+ else
+ {
+ if (!READ_LINE(parser, trailing_breaks)) goto error;
+ }
+ }
+ if (!CACHE(parser, 1)) goto error;
+ }
+
+ /* Join the whitespaces or fold line breaks. */
+
+ if (leading_blanks)
+ {
+ /* Do we need to fold line breaks? */
+
+ if (leading_break.start[0] == '\n') {
+ if (trailing_breaks.start[0] == '\0') {
+ if (!STRING_EXTEND(parser, string)) goto error;
+ *(string.pointer++) = ' ';
+ }
+ else {
+ if (!JOIN(parser, string, trailing_breaks)) goto error;
+ CLEAR(parser, trailing_breaks);
+ }
+ CLEAR(parser, leading_break);
+ }
+ else {
+ if (!JOIN(parser, string, leading_break)) goto error;
+ if (!JOIN(parser, string, trailing_breaks)) goto error;
+ CLEAR(parser, leading_break);
+ CLEAR(parser, trailing_breaks);
+ }
+ }
+ else
+ {
+ if (!JOIN(parser, string, whitespaces)) goto error;
+ CLEAR(parser, whitespaces);
+ }
+ }
+
+ /* Eat the right quote. */
+
+ SKIP(parser);
+
+ end_mark = parser->mark;
+
+ /* Create a token. */
+
+ SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start,
+ single ? YAML_SINGLE_QUOTED_SCALAR_STYLE : YAML_DOUBLE_QUOTED_SCALAR_STYLE,
+ start_mark, end_mark);
+
+ STRING_DEL(parser, leading_break);
+ STRING_DEL(parser, trailing_breaks);
+ STRING_DEL(parser, whitespaces);
+
+ return 1;
+
+error:
+ STRING_DEL(parser, string);
+ STRING_DEL(parser, leading_break);
+ STRING_DEL(parser, trailing_breaks);
+ STRING_DEL(parser, whitespaces);
+
+ return 0;
+}
+
+/*
+ * Scan a plain scalar.
+ */
+
+static int
+yaml_parser_scan_plain_scalar(yaml_parser_t *parser, yaml_token_t *token)
+{
+ yaml_mark_t start_mark;
+ yaml_mark_t end_mark;
+ yaml_string_t string = NULL_STRING;
+ yaml_string_t leading_break = NULL_STRING;
+ yaml_string_t trailing_breaks = NULL_STRING;
+ yaml_string_t whitespaces = NULL_STRING;
+ int leading_blanks = 0;
+ int indent = parser->indent+1;
+
+ if (!STRING_INIT(parser, string, INITIAL_STRING_SIZE)) goto error;
+ if (!STRING_INIT(parser, leading_break, INITIAL_STRING_SIZE)) goto error;
+ if (!STRING_INIT(parser, trailing_breaks, INITIAL_STRING_SIZE)) goto error;
+ if (!STRING_INIT(parser, whitespaces, INITIAL_STRING_SIZE)) goto error;
+
+ start_mark = end_mark = parser->mark;
+
+ /* Consume the content of the plain scalar. */
+
+ while (1)
+ {
+ /* Check for a document indicator. */
+
+ if (!CACHE(parser, 4)) goto error;
+
+ if (parser->mark.column == 0 &&
+ ((CHECK_AT(parser->buffer, '-', 0) &&
+ CHECK_AT(parser->buffer, '-', 1) &&
+ CHECK_AT(parser->buffer, '-', 2)) ||
+ (CHECK_AT(parser->buffer, '.', 0) &&
+ CHECK_AT(parser->buffer, '.', 1) &&
+ CHECK_AT(parser->buffer, '.', 2))) &&
+ IS_BLANKZ_AT(parser->buffer, 3)) break;
+
+ /* Check for a comment. */
+
+ if (CHECK(parser->buffer, '#'))
+ break;
+
+ /* Consume non-blank characters. */
+
+ while (!IS_BLANKZ(parser->buffer))
+ {
+ /* Check for "x:" + one of ',?[]{}' in the flow context. TODO: Fix the test "spec-08-13".
+ * This is not completely according to the spec
+ * See http://yaml.org/spec/1.1/#id907281 9.1.3. Plain
+ */
+
+ if (parser->flow_level
+ && CHECK(parser->buffer, ':')
+ && (
+ CHECK_AT(parser->buffer, ',', 1)
+ || CHECK_AT(parser->buffer, '?', 1)
+ || CHECK_AT(parser->buffer, '[', 1)
+ || CHECK_AT(parser->buffer, ']', 1)
+ || CHECK_AT(parser->buffer, '{', 1)
+ || CHECK_AT(parser->buffer, '}', 1)
+ )
+ ) {
+ yaml_parser_set_scanner_error(parser, "while scanning a plain scalar",
+ start_mark, "found unexpected ':'");
+ goto error;
+ }
+
+ /* Check for indicators that may end a plain scalar. */
+
+ if ((CHECK(parser->buffer, ':') && IS_BLANKZ_AT(parser->buffer, 1))
+ || (parser->flow_level &&
+ (CHECK(parser->buffer, ',')
+ || CHECK(parser->buffer, '[')
+ || CHECK(parser->buffer, ']') || CHECK(parser->buffer, '{')
+ || CHECK(parser->buffer, '}'))))
+ break;
+
+ /* Check if we need to join whitespaces and breaks. */
+
+ if (leading_blanks || whitespaces.start != whitespaces.pointer)
+ {
+ if (leading_blanks)
+ {
+ /* Do we need to fold line breaks? */
+
+ if (leading_break.start[0] == '\n') {
+ if (trailing_breaks.start[0] == '\0') {
+ if (!STRING_EXTEND(parser, string)) goto error;
+ *(string.pointer++) = ' ';
+ }
+ else {
+ if (!JOIN(parser, string, trailing_breaks)) goto error;
+ CLEAR(parser, trailing_breaks);
+ }
+ CLEAR(parser, leading_break);
+ }
+ else {
+ if (!JOIN(parser, string, leading_break)) goto error;
+ if (!JOIN(parser, string, trailing_breaks)) goto error;
+ CLEAR(parser, leading_break);
+ CLEAR(parser, trailing_breaks);
+ }
+
+ leading_blanks = 0;
+ }
+ else
+ {
+ if (!JOIN(parser, string, whitespaces)) goto error;
+ CLEAR(parser, whitespaces);
+ }
+ }
+
+ /* Copy the character. */
+
+ if (!READ(parser, string)) goto error;
+
+ end_mark = parser->mark;
+
+ if (!CACHE(parser, 2)) goto error;
+ }
+
+ /* Is it the end? */
+
+ if (!(IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer)))
+ break;
+
+ /* Consume blank characters. */
+
+ if (!CACHE(parser, 1)) goto error;
+
+ while (IS_BLANK(parser->buffer) || IS_BREAK(parser->buffer))
+ {
+ if (IS_BLANK(parser->buffer))
+ {
+ /* Check for tab characters that abuse indentation. */
+
+ if (leading_blanks && (int)parser->mark.column < indent
+ && IS_TAB(parser->buffer)) {
+ yaml_parser_set_scanner_error(parser, "while scanning a plain scalar",
+ start_mark, "found a tab character that violates indentation");
+ goto error;
+ }
+
+ /* Consume a space or a tab character. */
+
+ if (!leading_blanks) {
+ if (!READ(parser, whitespaces)) goto error;
+ }
+ else {
+ SKIP(parser);
+ }
+ }
+ else
+ {
+ if (!CACHE(parser, 2)) goto error;
+
+ /* Check if it is a first line break. */
+
+ if (!leading_blanks)
+ {
+ CLEAR(parser, whitespaces);
+ if (!READ_LINE(parser, leading_break)) goto error;
+ leading_blanks = 1;
+ }
+ else
+ {
+ if (!READ_LINE(parser, trailing_breaks)) goto error;
+ }
+ }
+ if (!CACHE(parser, 1)) goto error;
+ }
+
+ /* Check indentation level. */
+
+ if (!parser->flow_level && (int)parser->mark.column < indent)
+ break;
+ }
+
+ /* Create a token. */
+
+ SCALAR_TOKEN_INIT(*token, string.start, string.pointer-string.start,
+ YAML_PLAIN_SCALAR_STYLE, start_mark, end_mark);
+
+ /* Note that we change the 'simple_key_allowed' flag. */
+
+ if (leading_blanks) {
+ parser->simple_key_allowed = 1;
+ }
+
+ STRING_DEL(parser, leading_break);
+ STRING_DEL(parser, trailing_breaks);
+ STRING_DEL(parser, whitespaces);
+
+ return 1;
+
+error:
+ STRING_DEL(parser, string);
+ STRING_DEL(parser, leading_break);
+ STRING_DEL(parser, trailing_breaks);
+ STRING_DEL(parser, whitespaces);
+
+ return 0;
+}
diff --git a/libyaml/src/writer.c b/libyaml/src/writer.c
new file mode 100644
index 0000000000000000000000000000000000000000..5d57f392f1eb7fcaa8aba23a38c1489e572b2007
--- /dev/null
+++ b/libyaml/src/writer.c
@@ -0,0 +1,141 @@
+
+#include "yaml_private.h"
+
+/*
+ * Declarations.
+ */
+
+static int
+yaml_emitter_set_writer_error(yaml_emitter_t *emitter, const char *problem);
+
+YAML_DECLARE(int)
+yaml_emitter_flush(yaml_emitter_t *emitter);
+
+/*
+ * Set the writer error and return 0.
+ */
+
+static int
+yaml_emitter_set_writer_error(yaml_emitter_t *emitter, const char *problem)
+{
+ emitter->error = YAML_WRITER_ERROR;
+ emitter->problem = problem;
+
+ return 0;
+}
+
+/*
+ * Flush the output buffer.
+ */
+
+YAML_DECLARE(int)
+yaml_emitter_flush(yaml_emitter_t *emitter)
+{
+ int low, high;
+
+ assert(emitter); /* Non-NULL emitter object is expected. */
+ assert(emitter->write_handler); /* Write handler must be set. */
+ assert(emitter->encoding); /* Output encoding must be set. */
+
+ emitter->buffer.last = emitter->buffer.pointer;
+ emitter->buffer.pointer = emitter->buffer.start;
+
+ /* Check if the buffer is empty. */
+
+ if (emitter->buffer.start == emitter->buffer.last) {
+ return 1;
+ }
+
+ /* If the output encoding is UTF-8, we don't need to recode the buffer. */
+
+ if (emitter->encoding == YAML_UTF8_ENCODING)
+ {
+ if (emitter->write_handler(emitter->write_handler_data,
+ emitter->buffer.start,
+ emitter->buffer.last - emitter->buffer.start)) {
+ emitter->buffer.last = emitter->buffer.start;
+ emitter->buffer.pointer = emitter->buffer.start;
+ return 1;
+ }
+ else {
+ return yaml_emitter_set_writer_error(emitter, "write error");
+ }
+ }
+
+ /* Recode the buffer into the raw buffer. */
+
+ low = (emitter->encoding == YAML_UTF16LE_ENCODING ? 0 : 1);
+ high = (emitter->encoding == YAML_UTF16LE_ENCODING ? 1 : 0);
+
+ while (emitter->buffer.pointer != emitter->buffer.last)
+ {
+ unsigned char octet;
+ unsigned int width;
+ unsigned int value;
+ size_t k;
+
+ /*
+ * See the "reader.c" code for more details on UTF-8 encoding. Note
+ * that we assume that the buffer contains a valid UTF-8 sequence.
+ */
+
+ /* Read the next UTF-8 character. */
+
+ octet = emitter->buffer.pointer[0];
+
+ width = (octet & 0x80) == 0x00 ? 1 :
+ (octet & 0xE0) == 0xC0 ? 2 :
+ (octet & 0xF0) == 0xE0 ? 3 :
+ (octet & 0xF8) == 0xF0 ? 4 : 0;
+
+ value = (octet & 0x80) == 0x00 ? octet & 0x7F :
+ (octet & 0xE0) == 0xC0 ? octet & 0x1F :
+ (octet & 0xF0) == 0xE0 ? octet & 0x0F :
+ (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
+
+ for (k = 1; k < width; k ++) {
+ octet = emitter->buffer.pointer[k];
+ value = (value << 6) + (octet & 0x3F);
+ }
+
+ emitter->buffer.pointer += width;
+
+ /* Write the character. */
+
+ if (value < 0x10000)
+ {
+ emitter->raw_buffer.last[high] = value >> 8;
+ emitter->raw_buffer.last[low] = value & 0xFF;
+
+ emitter->raw_buffer.last += 2;
+ }
+ else
+ {
+ /* Write the character using a surrogate pair (check "reader.c"). */
+
+ value -= 0x10000;
+ emitter->raw_buffer.last[high] = 0xD8 + (value >> 18);
+ emitter->raw_buffer.last[low] = (value >> 10) & 0xFF;
+ emitter->raw_buffer.last[high+2] = 0xDC + ((value >> 8) & 0xFF);
+ emitter->raw_buffer.last[low+2] = value & 0xFF;
+
+ emitter->raw_buffer.last += 4;
+ }
+ }
+
+ /* Write the raw buffer. */
+
+ if (emitter->write_handler(emitter->write_handler_data,
+ emitter->raw_buffer.start,
+ emitter->raw_buffer.last - emitter->raw_buffer.start)) {
+ emitter->buffer.last = emitter->buffer.start;
+ emitter->buffer.pointer = emitter->buffer.start;
+ emitter->raw_buffer.last = emitter->raw_buffer.start;
+ emitter->raw_buffer.pointer = emitter->raw_buffer.start;
+ return 1;
+ }
+ else {
+ return yaml_emitter_set_writer_error(emitter, "write error");
+ }
+}
+
diff --git a/libyaml/src/yaml_private.h b/libyaml/src/yaml_private.h
new file mode 100644
index 0000000000000000000000000000000000000000..b3351c41655c2b37306269565ac8a97c934defd0
--- /dev/null
+++ b/libyaml/src/yaml_private.h
@@ -0,0 +1,684 @@
+#if HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <yaml.h>
+
+#include <assert.h>
+#include <limits.h>
+#include <stddef.h>
+
+/*
+ * Memory management.
+ */
+
+YAML_DECLARE(void *)
+yaml_malloc(size_t size);
+
+YAML_DECLARE(void *)
+yaml_realloc(void *ptr, size_t size);
+
+YAML_DECLARE(void)
+yaml_free(void *ptr);
+
+YAML_DECLARE(yaml_char_t *)
+yaml_strdup(const yaml_char_t *);
+
+/*
+ * Reader: Ensure that the buffer contains at least `length` characters.
+ */
+
+YAML_DECLARE(int)
+yaml_parser_update_buffer(yaml_parser_t *parser, size_t length);
+
+/*
+ * Scanner: Ensure that the token stack contains at least one token ready.
+ */
+
+YAML_DECLARE(int)
+yaml_parser_fetch_more_tokens(yaml_parser_t *parser);
+
+/*
+ * The size of the input raw buffer.
+ */
+
+#define INPUT_RAW_BUFFER_SIZE 16384
+
+/*
+ * The size of the input buffer.
+ *
+ * It should be possible to decode the whole raw buffer.
+ */
+
+#define INPUT_BUFFER_SIZE (INPUT_RAW_BUFFER_SIZE*3)
+
+/*
+ * The size of the output buffer.
+ */
+
+#define OUTPUT_BUFFER_SIZE 16384
+
+/*
+ * The size of the output raw buffer.
+ *
+ * It should be possible to encode the whole output buffer.
+ */
+
+#define OUTPUT_RAW_BUFFER_SIZE (OUTPUT_BUFFER_SIZE*2+2)
+
+/*
+ * The maximum size of a YAML input file.
+ * This used to be PTRDIFF_MAX, but that's not entirely portable
+ * because stdint.h isn't available on all platforms.
+ * It is not entirely clear why this isn't the maximum value
+ * that can fit into the parser->offset field.
+ */
+
+#define MAX_FILE_SIZE (~(size_t)0 / 2)
+
+
+/*
+ * The size of other stacks and queues.
+ */
+
+#define INITIAL_STACK_SIZE 16
+#define INITIAL_QUEUE_SIZE 16
+#define INITIAL_STRING_SIZE 16
+
+/*
+ * Buffer management.
+ */
+
+#define BUFFER_INIT(context,buffer,size) \
+ (((buffer).start = (yaml_char_t *)yaml_malloc(size)) ? \
+ ((buffer).last = (buffer).pointer = (buffer).start, \
+ (buffer).end = (buffer).start+(size), \
+ 1) : \
+ ((context)->error = YAML_MEMORY_ERROR, \
+ 0))
+
+#define BUFFER_DEL(context,buffer) \
+ (yaml_free((buffer).start), \
+ (buffer).start = (buffer).pointer = (buffer).end = 0)
+
+/*
+ * String management.
+ */
+
+typedef struct {
+ yaml_char_t *start;
+ yaml_char_t *end;
+ yaml_char_t *pointer;
+} yaml_string_t;
+
+YAML_DECLARE(int)
+yaml_string_extend(yaml_char_t **start,
+ yaml_char_t **pointer, yaml_char_t **end);
+
+YAML_DECLARE(int)
+yaml_string_join(
+ yaml_char_t **a_start, yaml_char_t **a_pointer, yaml_char_t **a_end,
+ yaml_char_t **b_start, yaml_char_t **b_pointer, yaml_char_t **b_end);
+
+#define NULL_STRING { NULL, NULL, NULL }
+
+#define STRING(string,length) { (string), (string)+(length), (string) }
+
+#define STRING_ASSIGN(value,string,length) \
+ ((value).start = (string), \
+ (value).end = (string)+(length), \
+ (value).pointer = (string))
+
+#define STRING_INIT(context,string,size) \
+ (((string).start = YAML_MALLOC(size)) ? \
+ ((string).pointer = (string).start, \
+ (string).end = (string).start+(size), \
+ memset((string).start, 0, (size)), \
+ 1) : \
+ ((context)->error = YAML_MEMORY_ERROR, \
+ 0))
+
+#define STRING_DEL(context,string) \
+ (yaml_free((string).start), \
+ (string).start = (string).pointer = (string).end = 0)
+
+#define STRING_EXTEND(context,string) \
+ ((((string).pointer+5 < (string).end) \
+ || yaml_string_extend(&(string).start, \
+ &(string).pointer, &(string).end)) ? \
+ 1 : \
+ ((context)->error = YAML_MEMORY_ERROR, \
+ 0))
+
+#define CLEAR(context,string) \
+ ((string).pointer = (string).start, \
+ memset((string).start, 0, (string).end-(string).start))
+
+#define JOIN(context,string_a,string_b) \
+ ((yaml_string_join(&(string_a).start, &(string_a).pointer, \
+ &(string_a).end, &(string_b).start, \
+ &(string_b).pointer, &(string_b).end)) ? \
+ ((string_b).pointer = (string_b).start, \
+ 1) : \
+ ((context)->error = YAML_MEMORY_ERROR, \
+ 0))
+
+/*
+ * String check operations.
+ */
+
+/*
+ * Check the octet at the specified position.
+ */
+
+#define CHECK_AT(string,octet,offset) \
+ ((string).pointer[offset] == (yaml_char_t)(octet))
+
+/*
+ * Check the current octet in the buffer.
+ */
+
+#define CHECK(string,octet) (CHECK_AT((string),(octet),0))
+
+/*
+ * Check if the character at the specified position is an alphabetical
+ * character, a digit, '_', or '-'.
+ */
+
+#define IS_ALPHA_AT(string,offset) \
+ (((string).pointer[offset] >= (yaml_char_t) '0' && \
+ (string).pointer[offset] <= (yaml_char_t) '9') || \
+ ((string).pointer[offset] >= (yaml_char_t) 'A' && \
+ (string).pointer[offset] <= (yaml_char_t) 'Z') || \
+ ((string).pointer[offset] >= (yaml_char_t) 'a' && \
+ (string).pointer[offset] <= (yaml_char_t) 'z') || \
+ (string).pointer[offset] == '_' || \
+ (string).pointer[offset] == '-')
+
+#define IS_ALPHA(string) IS_ALPHA_AT((string),0)
+
+/*
+ * Check if the character at the specified position is a digit.
+ */
+
+#define IS_DIGIT_AT(string,offset) \
+ (((string).pointer[offset] >= (yaml_char_t) '0' && \
+ (string).pointer[offset] <= (yaml_char_t) '9'))
+
+#define IS_DIGIT(string) IS_DIGIT_AT((string),0)
+
+/*
+ * Get the value of a digit.
+ */
+
+#define AS_DIGIT_AT(string,offset) \
+ ((string).pointer[offset] - (yaml_char_t) '0')
+
+#define AS_DIGIT(string) AS_DIGIT_AT((string),0)
+
+/*
+ * Check if the character at the specified position is a hex-digit.
+ */
+
+#define IS_HEX_AT(string,offset) \
+ (((string).pointer[offset] >= (yaml_char_t) '0' && \
+ (string).pointer[offset] <= (yaml_char_t) '9') || \
+ ((string).pointer[offset] >= (yaml_char_t) 'A' && \
+ (string).pointer[offset] <= (yaml_char_t) 'F') || \
+ ((string).pointer[offset] >= (yaml_char_t) 'a' && \
+ (string).pointer[offset] <= (yaml_char_t) 'f'))
+
+#define IS_HEX(string) IS_HEX_AT((string),0)
+
+/*
+ * Get the value of a hex-digit.
+ */
+
+#define AS_HEX_AT(string,offset) \
+ (((string).pointer[offset] >= (yaml_char_t) 'A' && \
+ (string).pointer[offset] <= (yaml_char_t) 'F') ? \
+ ((string).pointer[offset] - (yaml_char_t) 'A' + 10) : \
+ ((string).pointer[offset] >= (yaml_char_t) 'a' && \
+ (string).pointer[offset] <= (yaml_char_t) 'f') ? \
+ ((string).pointer[offset] - (yaml_char_t) 'a' + 10) : \
+ ((string).pointer[offset] - (yaml_char_t) '0'))
+
+#define AS_HEX(string) AS_HEX_AT((string),0)
+
+/*
+ * Check if the character is ASCII.
+ */
+
+#define IS_ASCII_AT(string,offset) \
+ ((string).pointer[offset] <= (yaml_char_t) '\x7F')
+
+#define IS_ASCII(string) IS_ASCII_AT((string),0)
+
+/*
+ * Check if the character can be printed unescaped.
+ */
+
+#define IS_PRINTABLE_AT(string,offset) \
+ (((string).pointer[offset] == 0x0A) /* . == #x0A */ \
+ || ((string).pointer[offset] >= 0x20 /* #x20 <= . <= #x7E */ \
+ && (string).pointer[offset] <= 0x7E) \
+ || ((string).pointer[offset] == 0xC2 /* #0xA0 <= . <= #xD7FF */ \
+ && (string).pointer[offset+1] >= 0xA0) \
+ || ((string).pointer[offset] > 0xC2 \
+ && (string).pointer[offset] < 0xED) \
+ || ((string).pointer[offset] == 0xED \
+ && (string).pointer[offset+1] < 0xA0) \
+ || ((string).pointer[offset] == 0xEE) \
+ || ((string).pointer[offset] == 0xEF /* #xE000 <= . <= #xFFFD */ \
+ && !((string).pointer[offset+1] == 0xBB /* && . != #xFEFF */ \
+ && (string).pointer[offset+2] == 0xBF) \
+ && !((string).pointer[offset+1] == 0xBF \
+ && ((string).pointer[offset+2] == 0xBE \
+ || (string).pointer[offset+2] == 0xBF))))
+
+#define IS_PRINTABLE(string) IS_PRINTABLE_AT((string),0)
+
+/*
+ * Check if the character at the specified position is NUL.
+ */
+
+#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset))
+
+#define IS_Z(string) IS_Z_AT((string),0)
+
+/*
+ * Check if the character at the specified position is BOM.
+ */
+
+#define IS_BOM_AT(string,offset) \
+ (CHECK_AT((string),'\xEF',(offset)) \
+ && CHECK_AT((string),'\xBB',(offset)+1) \
+ && CHECK_AT((string),'\xBF',(offset)+2)) /* BOM (#xFEFF) */
+
+#define IS_BOM(string) IS_BOM_AT(string,0)
+
+/*
+ * Check if the character at the specified position is space.
+ */
+
+#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset))
+
+#define IS_SPACE(string) IS_SPACE_AT((string),0)
+
+/*
+ * Check if the character at the specified position is tab.
+ */
+
+#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset))
+
+#define IS_TAB(string) IS_TAB_AT((string),0)
+
+/*
+ * Check if the character at the specified position is blank (space or tab).
+ */
+
+#define IS_BLANK_AT(string,offset) \
+ (IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset)))
+
+#define IS_BLANK(string) IS_BLANK_AT((string),0)
+
+/*
+ * Check if the character at the specified position is a line break.
+ */
+
+#define IS_BREAK_AT(string,offset) \
+ (CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \
+ || CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \
+ || (CHECK_AT((string),'\xC2',(offset)) \
+ && CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \
+ || (CHECK_AT((string),'\xE2',(offset)) \
+ && CHECK_AT((string),'\x80',(offset)+1) \
+ && CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \
+ || (CHECK_AT((string),'\xE2',(offset)) \
+ && CHECK_AT((string),'\x80',(offset)+1) \
+ && CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */
+
+#define IS_BREAK(string) IS_BREAK_AT((string),0)
+
+#define IS_CRLF_AT(string,offset) \
+ (CHECK_AT((string),'\r',(offset)) && CHECK_AT((string),'\n',(offset)+1))
+
+#define IS_CRLF(string) IS_CRLF_AT((string),0)
+
+/*
+ * Check if the character is a line break or NUL.
+ */
+
+#define IS_BREAKZ_AT(string,offset) \
+ (IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset)))
+
+#define IS_BREAKZ(string) IS_BREAKZ_AT((string),0)
+
+/*
+ * Check if the character is a line break, space, or NUL.
+ */
+
+#define IS_SPACEZ_AT(string,offset) \
+ (IS_SPACE_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset)))
+
+#define IS_SPACEZ(string) IS_SPACEZ_AT((string),0)
+
+/*
+ * Check if the character is a line break, space, tab, or NUL.
+ */
+
+#define IS_BLANKZ_AT(string,offset) \
+ (IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset)))
+
+#define IS_BLANKZ(string) IS_BLANKZ_AT((string),0)
+
+/*
+ * Determine the width of the character.
+ */
+
+#define WIDTH_AT(string,offset) \
+ (((string).pointer[offset] & 0x80) == 0x00 ? 1 : \
+ ((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \
+ ((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \
+ ((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0)
+
+#define WIDTH(string) WIDTH_AT((string),0)
+
+/*
+ * Move the string pointer to the next character.
+ */
+
+#define MOVE(string) ((string).pointer += WIDTH((string)))
+
+/*
+ * Copy a character and move the pointers of both strings.
+ */
+
+#define COPY(string_a,string_b) \
+ ((*(string_b).pointer & 0x80) == 0x00 ? \
+ (*((string_a).pointer++) = *((string_b).pointer++)) : \
+ (*(string_b).pointer & 0xE0) == 0xC0 ? \
+ (*((string_a).pointer++) = *((string_b).pointer++), \
+ *((string_a).pointer++) = *((string_b).pointer++)) : \
+ (*(string_b).pointer & 0xF0) == 0xE0 ? \
+ (*((string_a).pointer++) = *((string_b).pointer++), \
+ *((string_a).pointer++) = *((string_b).pointer++), \
+ *((string_a).pointer++) = *((string_b).pointer++)) : \
+ (*(string_b).pointer & 0xF8) == 0xF0 ? \
+ (*((string_a).pointer++) = *((string_b).pointer++), \
+ *((string_a).pointer++) = *((string_b).pointer++), \
+ *((string_a).pointer++) = *((string_b).pointer++), \
+ *((string_a).pointer++) = *((string_b).pointer++)) : 0)
+
+/*
+ * Stack and queue management.
+ */
+
+YAML_DECLARE(int)
+yaml_stack_extend(void **start, void **top, void **end);
+
+YAML_DECLARE(int)
+yaml_queue_extend(void **start, void **head, void **tail, void **end);
+
+#define STACK_INIT(context,stack,type) \
+ (((stack).start = (type)yaml_malloc(INITIAL_STACK_SIZE*sizeof(*(stack).start))) ? \
+ ((stack).top = (stack).start, \
+ (stack).end = (stack).start+INITIAL_STACK_SIZE, \
+ 1) : \
+ ((context)->error = YAML_MEMORY_ERROR, \
+ 0))
+
+#define STACK_DEL(context,stack) \
+ (yaml_free((stack).start), \
+ (stack).start = (stack).top = (stack).end = 0)
+
+#define STACK_EMPTY(context,stack) \
+ ((stack).start == (stack).top)
+
+#define STACK_LIMIT(context,stack,size) \
+ ((stack).top - (stack).start < (size) ? \
+ 1 : \
+ ((context)->error = YAML_MEMORY_ERROR, \
+ 0))
+
+#define PUSH(context,stack,value) \
+ (((stack).top != (stack).end \
+ || yaml_stack_extend((void **)&(stack).start, \
+ (void **)&(stack).top, (void **)&(stack).end)) ? \
+ (*((stack).top++) = value, \
+ 1) : \
+ ((context)->error = YAML_MEMORY_ERROR, \
+ 0))
+
+#define POP(context,stack) \
+ (*(--(stack).top))
+
+#define QUEUE_INIT(context,queue,size,type) \
+ (((queue).start = (type)yaml_malloc((size)*sizeof(*(queue).start))) ? \
+ ((queue).head = (queue).tail = (queue).start, \
+ (queue).end = (queue).start+(size), \
+ 1) : \
+ ((context)->error = YAML_MEMORY_ERROR, \
+ 0))
+
+#define QUEUE_DEL(context,queue) \
+ (yaml_free((queue).start), \
+ (queue).start = (queue).head = (queue).tail = (queue).end = 0)
+
+#define QUEUE_EMPTY(context,queue) \
+ ((queue).head == (queue).tail)
+
+#define ENQUEUE(context,queue,value) \
+ (((queue).tail != (queue).end \
+ || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \
+ (void **)&(queue).tail, (void **)&(queue).end)) ? \
+ (*((queue).tail++) = value, \
+ 1) : \
+ ((context)->error = YAML_MEMORY_ERROR, \
+ 0))
+
+#define DEQUEUE(context,queue) \
+ (*((queue).head++))
+
+#define QUEUE_INSERT(context,queue,index,value) \
+ (((queue).tail != (queue).end \
+ || yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \
+ (void **)&(queue).tail, (void **)&(queue).end)) ? \
+ (memmove((queue).head+(index)+1,(queue).head+(index), \
+ ((queue).tail-(queue).head-(index))*sizeof(*(queue).start)), \
+ *((queue).head+(index)) = value, \
+ (queue).tail++, \
+ 1) : \
+ ((context)->error = YAML_MEMORY_ERROR, \
+ 0))
+
+/*
+ * Token initializers.
+ */
+
+#define TOKEN_INIT(token,token_type,token_start_mark,token_end_mark) \
+ (memset(&(token), 0, sizeof(yaml_token_t)), \
+ (token).type = (token_type), \
+ (token).start_mark = (token_start_mark), \
+ (token).end_mark = (token_end_mark))
+
+#define STREAM_START_TOKEN_INIT(token,token_encoding,start_mark,end_mark) \
+ (TOKEN_INIT((token),YAML_STREAM_START_TOKEN,(start_mark),(end_mark)), \
+ (token).data.stream_start.encoding = (token_encoding))
+
+#define STREAM_END_TOKEN_INIT(token,start_mark,end_mark) \
+ (TOKEN_INIT((token),YAML_STREAM_END_TOKEN,(start_mark),(end_mark)))
+
+#define ALIAS_TOKEN_INIT(token,token_value,start_mark,end_mark) \
+ (TOKEN_INIT((token),YAML_ALIAS_TOKEN,(start_mark),(end_mark)), \
+ (token).data.alias.value = (token_value))
+
+#define ANCHOR_TOKEN_INIT(token,token_value,start_mark,end_mark) \
+ (TOKEN_INIT((token),YAML_ANCHOR_TOKEN,(start_mark),(end_mark)), \
+ (token).data.anchor.value = (token_value))
+
+#define TAG_TOKEN_INIT(token,token_handle,token_suffix,start_mark,end_mark) \
+ (TOKEN_INIT((token),YAML_TAG_TOKEN,(start_mark),(end_mark)), \
+ (token).data.tag.handle = (token_handle), \
+ (token).data.tag.suffix = (token_suffix))
+
+#define SCALAR_TOKEN_INIT(token,token_value,token_length,token_style,start_mark,end_mark) \
+ (TOKEN_INIT((token),YAML_SCALAR_TOKEN,(start_mark),(end_mark)), \
+ (token).data.scalar.value = (token_value), \
+ (token).data.scalar.length = (token_length), \
+ (token).data.scalar.style = (token_style))
+
+#define VERSION_DIRECTIVE_TOKEN_INIT(token,token_major,token_minor,start_mark,end_mark) \
+ (TOKEN_INIT((token),YAML_VERSION_DIRECTIVE_TOKEN,(start_mark),(end_mark)), \
+ (token).data.version_directive.major = (token_major), \
+ (token).data.version_directive.minor = (token_minor))
+
+#define TAG_DIRECTIVE_TOKEN_INIT(token,token_handle,token_prefix,start_mark,end_mark) \
+ (TOKEN_INIT((token),YAML_TAG_DIRECTIVE_TOKEN,(start_mark),(end_mark)), \
+ (token).data.tag_directive.handle = (token_handle), \
+ (token).data.tag_directive.prefix = (token_prefix))
+
+/*
+ * Event initializers.
+ */
+
+#define EVENT_INIT(event,event_type,event_start_mark,event_end_mark) \
+ (memset(&(event), 0, sizeof(yaml_event_t)), \
+ (event).type = (event_type), \
+ (event).start_mark = (event_start_mark), \
+ (event).end_mark = (event_end_mark))
+
+#define STREAM_START_EVENT_INIT(event,event_encoding,start_mark,end_mark) \
+ (EVENT_INIT((event),YAML_STREAM_START_EVENT,(start_mark),(end_mark)), \
+ (event).data.stream_start.encoding = (event_encoding))
+
+#define STREAM_END_EVENT_INIT(event,start_mark,end_mark) \
+ (EVENT_INIT((event),YAML_STREAM_END_EVENT,(start_mark),(end_mark)))
+
+#define DOCUMENT_START_EVENT_INIT(event,event_version_directive, \
+ event_tag_directives_start,event_tag_directives_end,event_implicit,start_mark,end_mark) \
+ (EVENT_INIT((event),YAML_DOCUMENT_START_EVENT,(start_mark),(end_mark)), \
+ (event).data.document_start.version_directive = (event_version_directive), \
+ (event).data.document_start.tag_directives.start = (event_tag_directives_start), \
+ (event).data.document_start.tag_directives.end = (event_tag_directives_end), \
+ (event).data.document_start.implicit = (event_implicit))
+
+#define DOCUMENT_END_EVENT_INIT(event,event_implicit,start_mark,end_mark) \
+ (EVENT_INIT((event),YAML_DOCUMENT_END_EVENT,(start_mark),(end_mark)), \
+ (event).data.document_end.implicit = (event_implicit))
+
+#define ALIAS_EVENT_INIT(event,event_anchor,start_mark,end_mark) \
+ (EVENT_INIT((event),YAML_ALIAS_EVENT,(start_mark),(end_mark)), \
+ (event).data.alias.anchor = (event_anchor))
+
+#define SCALAR_EVENT_INIT(event,event_anchor,event_tag,event_value,event_length, \
+ event_plain_implicit, event_quoted_implicit,event_style,start_mark,end_mark) \
+ (EVENT_INIT((event),YAML_SCALAR_EVENT,(start_mark),(end_mark)), \
+ (event).data.scalar.anchor = (event_anchor), \
+ (event).data.scalar.tag = (event_tag), \
+ (event).data.scalar.value = (event_value), \
+ (event).data.scalar.length = (event_length), \
+ (event).data.scalar.plain_implicit = (event_plain_implicit), \
+ (event).data.scalar.quoted_implicit = (event_quoted_implicit), \
+ (event).data.scalar.style = (event_style))
+
+#define SEQUENCE_START_EVENT_INIT(event,event_anchor,event_tag, \
+ event_implicit,event_style,start_mark,end_mark) \
+ (EVENT_INIT((event),YAML_SEQUENCE_START_EVENT,(start_mark),(end_mark)), \
+ (event).data.sequence_start.anchor = (event_anchor), \
+ (event).data.sequence_start.tag = (event_tag), \
+ (event).data.sequence_start.implicit = (event_implicit), \
+ (event).data.sequence_start.style = (event_style))
+
+#define SEQUENCE_END_EVENT_INIT(event,start_mark,end_mark) \
+ (EVENT_INIT((event),YAML_SEQUENCE_END_EVENT,(start_mark),(end_mark)))
+
+#define MAPPING_START_EVENT_INIT(event,event_anchor,event_tag, \
+ event_implicit,event_style,start_mark,end_mark) \
+ (EVENT_INIT((event),YAML_MAPPING_START_EVENT,(start_mark),(end_mark)), \
+ (event).data.mapping_start.anchor = (event_anchor), \
+ (event).data.mapping_start.tag = (event_tag), \
+ (event).data.mapping_start.implicit = (event_implicit), \
+ (event).data.mapping_start.style = (event_style))
+
+#define MAPPING_END_EVENT_INIT(event,start_mark,end_mark) \
+ (EVENT_INIT((event),YAML_MAPPING_END_EVENT,(start_mark),(end_mark)))
+
+/*
+ * Document initializer.
+ */
+
+#define DOCUMENT_INIT(document,document_nodes_start,document_nodes_end, \
+ document_version_directive,document_tag_directives_start, \
+ document_tag_directives_end,document_start_implicit, \
+ document_end_implicit,document_start_mark,document_end_mark) \
+ (memset(&(document), 0, sizeof(yaml_document_t)), \
+ (document).nodes.start = (document_nodes_start), \
+ (document).nodes.end = (document_nodes_end), \
+ (document).nodes.top = (document_nodes_start), \
+ (document).version_directive = (document_version_directive), \
+ (document).tag_directives.start = (document_tag_directives_start), \
+ (document).tag_directives.end = (document_tag_directives_end), \
+ (document).start_implicit = (document_start_implicit), \
+ (document).end_implicit = (document_end_implicit), \
+ (document).start_mark = (document_start_mark), \
+ (document).end_mark = (document_end_mark))
+
+/*
+ * Node initializers.
+ */
+
+#define NODE_INIT(node,node_type,node_tag,node_start_mark,node_end_mark) \
+ (memset(&(node), 0, sizeof(yaml_node_t)), \
+ (node).type = (node_type), \
+ (node).tag = (node_tag), \
+ (node).start_mark = (node_start_mark), \
+ (node).end_mark = (node_end_mark))
+
+#define SCALAR_NODE_INIT(node,node_tag,node_value,node_length, \
+ node_style,start_mark,end_mark) \
+ (NODE_INIT((node),YAML_SCALAR_NODE,(node_tag),(start_mark),(end_mark)), \
+ (node).data.scalar.value = (node_value), \
+ (node).data.scalar.length = (node_length), \
+ (node).data.scalar.style = (node_style))
+
+#define SEQUENCE_NODE_INIT(node,node_tag,node_items_start,node_items_end, \
+ node_style,start_mark,end_mark) \
+ (NODE_INIT((node),YAML_SEQUENCE_NODE,(node_tag),(start_mark),(end_mark)), \
+ (node).data.sequence.items.start = (node_items_start), \
+ (node).data.sequence.items.end = (node_items_end), \
+ (node).data.sequence.items.top = (node_items_start), \
+ (node).data.sequence.style = (node_style))
+
+#define MAPPING_NODE_INIT(node,node_tag,node_pairs_start,node_pairs_end, \
+ node_style,start_mark,end_mark) \
+ (NODE_INIT((node),YAML_MAPPING_NODE,(node_tag),(start_mark),(end_mark)), \
+ (node).data.mapping.pairs.start = (node_pairs_start), \
+ (node).data.mapping.pairs.end = (node_pairs_end), \
+ (node).data.mapping.pairs.top = (node_pairs_start), \
+ (node).data.mapping.style = (node_style))
+
+/* Strict C compiler warning helpers */
+
+#if defined(__clang__) || defined(__GNUC__)
+# define HASATTRIBUTE_UNUSED
+#endif
+#ifdef HASATTRIBUTE_UNUSED
+# define __attribute__unused__ __attribute__((__unused__))
+#else
+# define __attribute__unused__
+#endif
+
+/* Shim arguments are arguments that must be included in your function,
+ * but serve no purpose inside. Silence compiler warnings. */
+#define SHIM(a) /*@unused@*/ a __attribute__unused__
+
+/* UNUSED_PARAM() marks a shim argument in the body to silence compiler warnings */
+#ifdef __clang__
+# define UNUSED_PARAM(a) (void)(a);
+#else
+# define UNUSED_PARAM(a) /*@-noeffect*/if (0) (void)(a)/*@=noeffect*/;
+#endif
+
+#define YAML_MALLOC_STATIC(type) (type*)yaml_malloc(sizeof(type))
+#define YAML_MALLOC(size) (yaml_char_t *)yaml_malloc(size)
diff --git a/libyaml/tests/CMakeLists.txt b/libyaml/tests/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..be2ce399a6bf32f133c5db358081dd74b0c4b2b9
--- /dev/null
+++ b/libyaml/tests/CMakeLists.txt
@@ -0,0 +1,27 @@
+
+function(add_yaml_executable name)
+ add_executable(${name} ${name}.c)
+ target_link_libraries(${name} yaml)
+endfunction()
+
+foreach(name IN ITEMS
+ example-deconstructor
+ example-deconstructor-alt
+ example-reformatter
+ example-reformatter-alt
+ run-dumper
+ run-emitter
+ run-emitter-test-suite
+ run-loader
+ run-parser
+ run-parser-test-suite
+ run-scanner
+ test-reader
+ test-version
+ )
+ add_yaml_executable(${name})
+endforeach()
+
+add_test(NAME version COMMAND test-version)
+add_test(NAME reader COMMAND test-reader)
+
diff --git a/libyaml/tests/Makefile.am b/libyaml/tests/Makefile.am
new file mode 100644
index 0000000000000000000000000000000000000000..9597b7fef3ef8191287323b227e6d3affb328bb8
--- /dev/null
+++ b/libyaml/tests/Makefile.am
@@ -0,0 +1,9 @@
+AM_CPPFLAGS = -I$(top_srcdir)/include -Wall
+#AM_CFLAGS = -Wno-pointer-sign
+LDADD = $(top_builddir)/src/libyaml.la
+TESTS = test-version test-reader
+check_PROGRAMS = test-version test-reader
+noinst_PROGRAMS = run-scanner run-parser run-loader run-emitter run-dumper \
+ example-reformatter example-reformatter-alt \
+ example-deconstructor example-deconstructor-alt \
+ run-parser-test-suite run-emitter-test-suite
diff --git a/libyaml/tests/ReadMe.md b/libyaml/tests/ReadMe.md
new file mode 100644
index 0000000000000000000000000000000000000000..bf09447f53f37a443a15aa5608d489bea43abc26
--- /dev/null
+++ b/libyaml/tests/ReadMe.md
@@ -0,0 +1,63 @@
+# Testing the Parser and Emitter
+
+There are several programs to test the parser and emitter.
+
+## Parser
+
+ echo 'foo: bar' | ./tests/run-parser-test-suite
+
+This will output the parsing events in yaml-test-suite format:
+
+ +STR
+ +DOC
+ +MAP
+ =VAL :foo
+ =VAL :bar
+ -MAP
+ -DOC
+ -STR
+
+For flow style events, you have to enable it with the `--flow` option:
+
+ echo '{ foo: bar }' | ./tests/run-parser-test-suite --flow keep
+
+ ...
+ +MAP {}
+ ...
+
+In the future, this will be the default.
+
+You can also explicitly disable this style with `--flow off`, or output
+flow style always, with `--flow on`.
+
+## Emitter
+
+run-emitter-test-suite takes yaml-test-suite event format and emits YAML.
+
+ ./tests/run-parser-test-suite ... | ./tests/run-emitter-test-suite
+
+## Options
+
+* `--directive (1.1|1.2)`
+
+ Prints a version directive before every document.
+
+* `--flow on`
+
+ Will emit the whole document in flow style.
+
+* `--flow off`
+
+ Will emit the whole document in block style.
+
+* `--flow keep`
+
+ Will emit block/flow style like in the original document.
+
+Example:
+```
+% echo 'foo: [bar, {x: y}]' |
+ ./tests/run-parser-test-suite --flow keep |
+ ./tests/run-emitter-test-suite --flow keep
+foo: [bar, {x: y}]
+```
diff --git a/libyaml/tests/example-deconstructor-alt.c b/libyaml/tests/example-deconstructor-alt.c
new file mode 100644
index 0000000000000000000000000000000000000000..b29c0777b09ac10471d5121d6f4194b8e092b584
--- /dev/null
+++ b/libyaml/tests/example-deconstructor-alt.c
@@ -0,0 +1,800 @@
+
+#include <yaml.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+
+int
+main(int argc, char *argv[])
+{
+ int help = 0;
+ int canonical = 0;
+ int unicode = 0;
+ int k;
+ int done = 0;
+
+ yaml_parser_t parser;
+ yaml_emitter_t emitter;
+ yaml_event_t input_event;
+ yaml_document_t output_document;
+
+ int root;
+
+ /* Clear the objects. */
+
+ memset(&parser, 0, sizeof(parser));
+ memset(&emitter, 0, sizeof(emitter));
+ memset(&input_event, 0, sizeof(input_event));
+ memset(&output_document, 0, sizeof(output_document));
+
+ /* Analyze command line options. */
+
+ for (k = 1; k < argc; k ++)
+ {
+ if (strcmp(argv[k], "-h") == 0
+ || strcmp(argv[k], "--help") == 0) {
+ help = 1;
+ }
+
+ else if (strcmp(argv[k], "-c") == 0
+ || strcmp(argv[k], "--canonical") == 0) {
+ canonical = 1;
+ }
+
+ else if (strcmp(argv[k], "-u") == 0
+ || strcmp(argv[k], "--unicode") == 0) {
+ unicode = 1;
+ }
+
+ else {
+ fprintf(stderr, "Unrecognized option: %s\n"
+ "Try `%s --help` for more information.\n",
+ argv[k], argv[0]);
+ return 1;
+ }
+ }
+
+ /* Display the help string. */
+
+ if (help)
+ {
+ printf("%s <input\n"
+ "or\n%s -h | --help\nDeconstruct a YAML stream\n\nOptions:\n"
+ "-h, --help\t\tdisplay this help and exit\n"
+ "-c, --canonical\t\toutput in the canonical YAML format\n"
+ "-u, --unicode\t\toutput unescaped non-ASCII characters\n",
+ argv[0], argv[0]);
+ return 0;
+ }
+
+ /* Initialize the parser and emitter objects. */
+
+ if (!yaml_parser_initialize(&parser)) {
+ fprintf(stderr, "Could not initialize the parser object\n");
+ return 1;
+ }
+
+ if (!yaml_emitter_initialize(&emitter)) {
+ yaml_parser_delete(&parser);
+ fprintf(stderr, "Could not inialize the emitter object\n");
+ return 1;
+ }
+
+ /* Set the parser parameters. */
+
+ yaml_parser_set_input_file(&parser, stdin);
+
+ /* Set the emitter parameters. */
+
+ yaml_emitter_set_output_file(&emitter, stdout);
+
+ yaml_emitter_set_canonical(&emitter, canonical);
+ yaml_emitter_set_unicode(&emitter, unicode);
+
+ /* Create and emit the STREAM-START event. */
+
+ if (!yaml_emitter_open(&emitter))
+ goto emitter_error;
+
+ /* Create a output_document object. */
+
+ if (!yaml_document_initialize(&output_document, NULL, NULL, NULL, 0, 0))
+ goto document_error;
+
+ /* Create the root sequence. */
+
+ root = yaml_document_add_sequence(&output_document, NULL,
+ YAML_BLOCK_SEQUENCE_STYLE);
+ if (!root) goto document_error;
+
+ /* Loop through the input events. */
+
+ while (!done)
+ {
+ int properties, key, value, map, seq;
+
+ /* Get the next event. */
+
+ if (!yaml_parser_parse(&parser, &input_event))
+ goto parser_error;
+
+ /* Check if this is the stream end. */
+
+ if (input_event.type == YAML_STREAM_END_EVENT) {
+ done = 1;
+ }
+
+ /* Create a mapping node and attach it to the root sequence. */
+
+ properties = yaml_document_add_mapping(&output_document, NULL,
+ YAML_BLOCK_MAPPING_STYLE);
+ if (!properties) goto document_error;
+ if (!yaml_document_append_sequence_item(&output_document,
+ root, properties)) goto document_error;
+
+ /* Analyze the event. */
+
+ switch (input_event.type)
+ {
+ case YAML_STREAM_START_EVENT:
+
+ /* Add 'type': 'STREAM-START'. */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"type", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"STREAM-START", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, value)) goto document_error;
+
+ /* Add 'encoding': <encoding>. */
+
+ if (input_event.data.stream_start.encoding)
+ {
+ yaml_encoding_t encoding
+ = input_event.data.stream_start.encoding;
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"encoding", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)(encoding == YAML_UTF8_ENCODING ? "utf-8" :
+ encoding == YAML_UTF16LE_ENCODING ? "utf-16-le" :
+ encoding == YAML_UTF16BE_ENCODING ? "utf-16-be" :
+ "unknown"), -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, value)) goto document_error;
+ }
+
+ break;
+
+ case YAML_STREAM_END_EVENT:
+
+ /* Add 'type': 'STREAM-END'. */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"type", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"STREAM-END", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, value)) goto document_error;
+
+ break;
+
+ case YAML_DOCUMENT_START_EVENT:
+
+ /* Add 'type': 'DOCUMENT-START'. */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"type", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"DOCUMENT-START", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, value)) goto document_error;
+
+ /* Display the output_document version numbers. */
+
+ if (input_event.data.document_start.version_directive)
+ {
+ yaml_version_directive_t *version
+ = input_event.data.document_start.version_directive;
+ char number[64];
+
+ /* Add 'version': {}. */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"version", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ map = yaml_document_add_mapping(&output_document, NULL,
+ YAML_FLOW_MAPPING_STYLE);
+ if (!map) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, map)) goto document_error;
+
+ /* Add 'major': <number>. */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"major", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ sprintf(number, "%d", version->major);
+ value = yaml_document_add_scalar(&output_document, (yaml_char_t *)YAML_INT_TAG,
+ (yaml_char_t *)number, -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ map, key, value)) goto document_error;
+
+ /* Add 'minor': <number>. */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"minor", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ sprintf(number, "%d", version->minor);
+ value = yaml_document_add_scalar(&output_document, (yaml_char_t *)YAML_INT_TAG,
+ (yaml_char_t *)number, -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ map, key, value)) goto document_error;
+ }
+
+ /* Display the output_document tag directives. */
+
+ if (input_event.data.document_start.tag_directives.start
+ != input_event.data.document_start.tag_directives.end)
+ {
+ yaml_tag_directive_t *tag;
+
+ /* Add 'tags': []. */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"tags", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ seq = yaml_document_add_sequence(&output_document, NULL,
+ YAML_BLOCK_SEQUENCE_STYLE);
+ if (!seq) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, seq)) goto document_error;
+
+ for (tag = input_event.data.document_start.tag_directives.start;
+ tag != input_event.data.document_start.tag_directives.end;
+ tag ++)
+ {
+ /* Add {}. */
+
+ map = yaml_document_add_mapping(&output_document, NULL,
+ YAML_FLOW_MAPPING_STYLE);
+ if (!map) goto document_error;
+ if (!yaml_document_append_sequence_item(&output_document,
+ seq, map)) goto document_error;
+
+ /* Add 'handle': <handle>. */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"handle", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, NULL,
+ tag->handle, -1, YAML_DOUBLE_QUOTED_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ map, key, value)) goto document_error;
+
+ /* Add 'prefix': <prefix>. */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"prefix", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, NULL,
+ tag->prefix, -1, YAML_DOUBLE_QUOTED_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ map, key, value)) goto document_error;
+ }
+ }
+
+ /* Add 'implicit': <flag>. */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"implicit", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, (yaml_char_t *)YAML_BOOL_TAG,
+ (yaml_char_t *)(input_event.data.document_start.implicit ?
+ "true" : "false"), -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, value)) goto document_error;
+
+ break;
+
+ case YAML_DOCUMENT_END_EVENT:
+
+ /* Add 'type': 'DOCUMENT-END'. */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"type", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"DOCUMENT-END", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, value)) goto document_error;
+
+ /* Add 'implicit': <flag>. */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"implicit", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, (yaml_char_t *)YAML_BOOL_TAG,
+ (yaml_char_t *)(input_event.data.document_end.implicit ?
+ "true" : "false"), -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, value)) goto document_error;
+
+ break;
+
+ case YAML_ALIAS_EVENT:
+
+ /* Add 'type': 'ALIAS'. */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"type", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"ALIAS", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, value)) goto document_error;
+
+ /* Add 'anchor': <anchor>. */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"anchor", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, NULL,
+ input_event.data.alias.anchor, -1,
+ YAML_DOUBLE_QUOTED_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, value)) goto document_error;
+
+ break;
+
+ case YAML_SCALAR_EVENT:
+
+ /* Add 'type': 'SCALAR'. */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"type", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"SCALAR", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, value)) goto document_error;
+
+ /* Add 'anchor': <anchor>. */
+
+ if (input_event.data.scalar.anchor)
+ {
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"anchor", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, NULL,
+ input_event.data.scalar.anchor, -1,
+ YAML_DOUBLE_QUOTED_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, value)) goto document_error;
+ }
+
+ /* Add 'tag': <tag>. */
+
+ if (input_event.data.scalar.tag)
+ {
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"tag", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, NULL,
+ input_event.data.scalar.tag, -1,
+ YAML_DOUBLE_QUOTED_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, value)) goto document_error;
+ }
+
+ /* Add 'value': <value>. */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"value", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, NULL,
+ input_event.data.scalar.value,
+ input_event.data.scalar.length,
+ YAML_DOUBLE_QUOTED_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, value)) goto document_error;
+
+ /* Display if the scalar tag is implicit. */
+
+ /* Add 'implicit': {} */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"version", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ map = yaml_document_add_mapping(&output_document, NULL,
+ YAML_FLOW_MAPPING_STYLE);
+ if (!map) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, map)) goto document_error;
+
+ /* Add 'plain': <flag>. */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"plain", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, (yaml_char_t *)YAML_BOOL_TAG,
+ (yaml_char_t *)(input_event.data.scalar.plain_implicit ?
+ "true" : "false"), -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ map, key, value)) goto document_error;
+
+ /* Add 'quoted': <flag>. */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"quoted", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, (yaml_char_t *)YAML_BOOL_TAG,
+ (yaml_char_t *)(input_event.data.scalar.quoted_implicit ?
+ "true" : "false"), -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ map, key, value)) goto document_error;
+
+ /* Display the style information. */
+
+ if (input_event.data.scalar.style)
+ {
+ yaml_scalar_style_t style = input_event.data.scalar.style;
+
+ /* Add 'style': <style>. */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"style", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)(style == YAML_PLAIN_SCALAR_STYLE ? "plain" :
+ style == YAML_SINGLE_QUOTED_SCALAR_STYLE ?
+ "single-quoted" :
+ style == YAML_DOUBLE_QUOTED_SCALAR_STYLE ?
+ "double-quoted" :
+ style == YAML_LITERAL_SCALAR_STYLE ? "literal" :
+ style == YAML_FOLDED_SCALAR_STYLE ? "folded" :
+ "unknown"), -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, value)) goto document_error;
+ }
+
+ break;
+
+ case YAML_SEQUENCE_START_EVENT:
+
+ /* Add 'type': 'SEQUENCE-START'. */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"type", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"SEQUENCE-START", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, value)) goto document_error;
+
+ /* Add 'anchor': <anchor>. */
+
+ if (input_event.data.sequence_start.anchor)
+ {
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"anchor", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, NULL,
+ input_event.data.sequence_start.anchor, -1,
+ YAML_DOUBLE_QUOTED_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, value)) goto document_error;
+ }
+
+ /* Add 'tag': <tag>. */
+
+ if (input_event.data.sequence_start.tag)
+ {
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"tag", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, NULL,
+ input_event.data.sequence_start.tag, -1,
+ YAML_DOUBLE_QUOTED_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, value)) goto document_error;
+ }
+
+ /* Add 'implicit': <flag>. */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"implicit", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, (yaml_char_t *)YAML_BOOL_TAG,
+ (yaml_char_t *)(input_event.data.sequence_start.implicit ?
+ "true" : "false"), -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, value)) goto document_error;
+
+ /* Display the style information. */
+
+ if (input_event.data.sequence_start.style)
+ {
+ yaml_sequence_style_t style
+ = input_event.data.sequence_start.style;
+
+ /* Add 'style': <style>. */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"style", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)(style == YAML_BLOCK_SEQUENCE_STYLE ? "block" :
+ style == YAML_FLOW_SEQUENCE_STYLE ? "flow" :
+ "unknown"), -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, value)) goto document_error;
+ }
+
+ break;
+
+ case YAML_SEQUENCE_END_EVENT:
+
+ /* Add 'type': 'SEQUENCE-END'. */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"type", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"SEQUENCE-END", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, value)) goto document_error;
+
+ break;
+
+ case YAML_MAPPING_START_EVENT:
+
+ /* Add 'type': 'MAPPING-START'. */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"type", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"MAPPING-START", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, value)) goto document_error;
+
+ /* Add 'anchor': <anchor>. */
+
+ if (input_event.data.mapping_start.anchor)
+ {
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"anchor", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, NULL,
+ input_event.data.mapping_start.anchor, -1,
+ YAML_DOUBLE_QUOTED_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, value)) goto document_error;
+ }
+
+ /* Add 'tag': <tag>. */
+
+ if (input_event.data.mapping_start.tag)
+ {
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"tag", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, NULL,
+ input_event.data.mapping_start.tag, -1,
+ YAML_DOUBLE_QUOTED_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, value)) goto document_error;
+ }
+
+ /* Add 'implicit': <flag>. */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"implicit", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, (yaml_char_t *)YAML_BOOL_TAG,
+ (yaml_char_t *)(input_event.data.mapping_start.implicit ?
+ "true" : "false"), -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, value)) goto document_error;
+
+ /* Display the style information. */
+
+ if (input_event.data.mapping_start.style)
+ {
+ yaml_mapping_style_t style
+ = input_event.data.mapping_start.style;
+
+ /* Add 'style': <style>. */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"style", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)(style == YAML_BLOCK_MAPPING_STYLE ? "block" :
+ style == YAML_FLOW_MAPPING_STYLE ? "flow" :
+ "unknown"), -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, value)) goto document_error;
+ }
+
+ break;
+
+ case YAML_MAPPING_END_EVENT:
+
+ /* Add 'type': 'MAPPING-END'. */
+
+ key = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"type", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!key) goto document_error;
+ value = yaml_document_add_scalar(&output_document, NULL,
+ (yaml_char_t *)"MAPPING-END", -1, YAML_PLAIN_SCALAR_STYLE);
+ if (!value) goto document_error;
+ if (!yaml_document_append_mapping_pair(&output_document,
+ properties, key, value)) goto document_error;
+
+ break;
+
+ default:
+ /* It couldn't really happen. */
+ break;
+ }
+
+ /* Delete the event object. */
+
+ yaml_event_delete(&input_event);
+ }
+
+ if (!yaml_emitter_dump(&emitter, &output_document))
+ goto emitter_error;
+ if (!yaml_emitter_close(&emitter))
+ goto emitter_error;
+
+ yaml_parser_delete(&parser);
+ yaml_emitter_delete(&emitter);
+
+ return 0;
+
+parser_error:
+
+ /* Display a parser error message. */
+
+ switch (parser.error)
+ {
+ case YAML_MEMORY_ERROR:
+ fprintf(stderr, "Memory error: Not enough memory for parsing\n");
+ break;
+
+ case YAML_READER_ERROR:
+ if (parser.problem_value != -1) {
+ fprintf(stderr, "Reader error: %s: #%X at %zd\n", parser.problem,
+ parser.problem_value, parser.problem_offset);
+ }
+ else {
+ fprintf(stderr, "Reader error: %s at %zd\n", parser.problem,
+ parser.problem_offset);
+ }
+ break;
+
+ case YAML_SCANNER_ERROR:
+ if (parser.context) {
+ fprintf(stderr, "Scanner error: %s at line %lu, column %lu\n"
+ "%s at line %lu, column %lu\n", parser.context,
+ parser.context_mark.line+1, parser.context_mark.column+1,
+ parser.problem, parser.problem_mark.line+1,
+ parser.problem_mark.column+1);
+ }
+ else {
+ fprintf(stderr, "Scanner error: %s at line %lu, column %lu\n",
+ parser.problem, parser.problem_mark.line+1,
+ parser.problem_mark.column+1);
+ }
+ break;
+
+ case YAML_PARSER_ERROR:
+ if (parser.context) {
+ fprintf(stderr, "Parser error: %s at line %lu, column %lu\n"
+ "%s at line %lu, column %lu\n", parser.context,
+ parser.context_mark.line+1, parser.context_mark.column+1,
+ parser.problem, parser.problem_mark.line+1,
+ parser.problem_mark.column+1);
+ }
+ else {
+ fprintf(stderr, "Parser error: %s at line %lu, column %lu\n",
+ parser.problem, parser.problem_mark.line+1,
+ parser.problem_mark.column+1);
+ }
+ break;
+
+ default:
+ /* Couldn't happen. */
+ fprintf(stderr, "Internal error\n");
+ break;
+ }
+
+ yaml_event_delete(&input_event);
+ yaml_document_delete(&output_document);
+ yaml_parser_delete(&parser);
+ yaml_emitter_delete(&emitter);
+
+ return 1;
+
+emitter_error:
+
+ /* Display an emitter error message. */
+
+ switch (emitter.error)
+ {
+ case YAML_MEMORY_ERROR:
+ fprintf(stderr, "Memory error: Not enough memory for emitting\n");
+ break;
+
+ case YAML_WRITER_ERROR:
+ fprintf(stderr, "Writer error: %s\n", emitter.problem);
+ break;
+
+ case YAML_EMITTER_ERROR:
+ fprintf(stderr, "Emitter error: %s\n", emitter.problem);
+ break;
+
+ default:
+ /* Couldn't happen. */
+ fprintf(stderr, "Internal error\n");
+ break;
+ }
+
+ yaml_event_delete(&input_event);
+ yaml_document_delete(&output_document);
+ yaml_parser_delete(&parser);
+ yaml_emitter_delete(&emitter);
+
+ return 1;
+
+document_error:
+
+ fprintf(stderr, "Memory error: Not enough memory for creating a document\n");
+
+ yaml_event_delete(&input_event);
+ yaml_document_delete(&output_document);
+ yaml_parser_delete(&parser);
+ yaml_emitter_delete(&emitter);
+
+ return 1;
+}
+
diff --git a/libyaml/tests/example-deconstructor.c b/libyaml/tests/example-deconstructor.c
new file mode 100644
index 0000000000000000000000000000000000000000..e048ee6bf0ade1a5643bb43bf5ca07330c4e8dfc
--- /dev/null
+++ b/libyaml/tests/example-deconstructor.c
@@ -0,0 +1,1127 @@
+
+#include <yaml.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+
+int
+main(int argc, char *argv[])
+{
+ int help = 0;
+ int canonical = 0;
+ int unicode = 0;
+ int k;
+ int done = 0;
+
+ yaml_parser_t parser;
+ yaml_emitter_t emitter;
+ yaml_event_t input_event;
+ yaml_event_t output_event;
+
+ /* Clear the objects. */
+
+ memset(&parser, 0, sizeof(parser));
+ memset(&emitter, 0, sizeof(emitter));
+ memset(&input_event, 0, sizeof(input_event));
+ memset(&output_event, 0, sizeof(output_event));
+
+ /* Analyze command line options. */
+
+ for (k = 1; k < argc; k ++)
+ {
+ if (strcmp(argv[k], "-h") == 0
+ || strcmp(argv[k], "--help") == 0) {
+ help = 1;
+ }
+
+ else if (strcmp(argv[k], "-c") == 0
+ || strcmp(argv[k], "--canonical") == 0) {
+ canonical = 1;
+ }
+
+ else if (strcmp(argv[k], "-u") == 0
+ || strcmp(argv[k], "--unicode") == 0) {
+ unicode = 1;
+ }
+
+ else {
+ fprintf(stderr, "Unrecognized option: %s\n"
+ "Try `%s --help` for more information.\n",
+ argv[k], argv[0]);
+ return 1;
+ }
+ }
+
+ /* Display the help string. */
+
+ if (help)
+ {
+ printf("%s <input\n"
+ "or\n%s -h | --help\nDeconstruct a YAML stream\n\nOptions:\n"
+ "-h, --help\t\tdisplay this help and exit\n"
+ "-c, --canonical\t\toutput in the canonical YAML format\n"
+ "-u, --unicode\t\toutput unescaped non-ASCII characters\n",
+ argv[0], argv[0]);
+ return 0;
+ }
+
+ /* Initialize the parser and emitter objects. */
+
+ if (!yaml_parser_initialize(&parser)) {
+ fprintf(stderr, "Could not initialize the parser object\n");
+ return 1;
+ }
+
+ if (!yaml_emitter_initialize(&emitter)) {
+ yaml_parser_delete(&parser);
+ fprintf(stderr, "Could not inialize the emitter object\n");
+ return 1;
+ }
+
+ /* Set the parser parameters. */
+
+ yaml_parser_set_input_file(&parser, stdin);
+
+ /* Set the emitter parameters. */
+
+ yaml_emitter_set_output_file(&emitter, stdout);
+
+ yaml_emitter_set_canonical(&emitter, canonical);
+ yaml_emitter_set_unicode(&emitter, unicode);
+
+ /* Create and emit the STREAM-START event. */
+
+ if (!yaml_stream_start_event_initialize(&output_event, YAML_UTF8_ENCODING))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Create and emit the DOCUMENT-START event. */
+
+ if (!yaml_document_start_event_initialize(&output_event,
+ NULL, NULL, NULL, 0))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Create and emit the SEQUENCE-START event. */
+
+ if (!yaml_sequence_start_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:seq", 1,
+ YAML_BLOCK_SEQUENCE_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Loop through the input events. */
+
+ while (!done)
+ {
+ /* Get the next event. */
+
+ if (!yaml_parser_parse(&parser, &input_event))
+ goto parser_error;
+
+ /* Check if this is the stream end. */
+
+ if (input_event.type == YAML_STREAM_END_EVENT) {
+ done = 1;
+ }
+
+ /* Create and emit a MAPPING-START event. */
+
+ if (!yaml_mapping_start_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:map", 1,
+ YAML_BLOCK_MAPPING_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Analyze the event. */
+
+ switch (input_event.type)
+ {
+ case YAML_STREAM_START_EVENT:
+
+ /* Write 'type'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"type", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write 'STREAM-START'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"STREAM-START", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Display encoding information. */
+
+ if (input_event.data.stream_start.encoding)
+ {
+ yaml_encoding_t encoding
+ = input_event.data.stream_start.encoding;
+
+ /* Write 'encoding'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"encoding", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write the stream encoding. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str",
+ (yaml_char_t *)(encoding == YAML_UTF8_ENCODING ? "utf-8" :
+ encoding == YAML_UTF16LE_ENCODING ? "utf-16-le" :
+ encoding == YAML_UTF16BE_ENCODING ? "utf-16-be" :
+ "unknown"), -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+ }
+
+ break;
+
+ case YAML_STREAM_END_EVENT:
+
+ /* Write 'type'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"type", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write 'STREAM-END'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"STREAM-END", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ break;
+
+ case YAML_DOCUMENT_START_EVENT:
+
+ /* Write 'type'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"type", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write 'DOCUMENT-START'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"DOCUMENT-START", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Display the document version numbers. */
+
+ if (input_event.data.document_start.version_directive)
+ {
+ yaml_version_directive_t *version
+ = input_event.data.document_start.version_directive;
+ char number[64];
+
+ /* Write 'version'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"version", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write '{'. */
+
+ if (!yaml_mapping_start_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:map", 1,
+ YAML_FLOW_MAPPING_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write 'major'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"major", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write a number. */
+
+ sprintf(number, "%d", version->major);
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:int", (yaml_char_t *)number, -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write 'minor'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"minor", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write a number. */
+
+ sprintf(number, "%d", version->minor);
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:int", (yaml_char_t *)number, -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write '}'. */
+
+ if (!yaml_mapping_end_event_initialize(&output_event))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+ }
+
+ /* Display the document tag directives. */
+
+ if (input_event.data.document_start.tag_directives.start
+ != input_event.data.document_start.tag_directives.end)
+ {
+ yaml_tag_directive_t *tag;
+
+ /* Write 'tags'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"tags", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Start a block sequence. */
+
+ if (!yaml_sequence_start_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:seq", 1,
+ YAML_BLOCK_SEQUENCE_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ for (tag = input_event.data.document_start.tag_directives.start;
+ tag != input_event.data.document_start.tag_directives.end;
+ tag ++)
+ {
+ /* Write '{'. */
+
+ if (!yaml_mapping_start_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:map", 1,
+ YAML_FLOW_MAPPING_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write 'handle'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"handle", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write the tag directive handle. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str",
+ tag->handle, -1,
+ 0, 1, YAML_DOUBLE_QUOTED_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write 'prefix'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"prefix", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write the tag directive prefix. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str",
+ tag->prefix, -1,
+ 0, 1, YAML_DOUBLE_QUOTED_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write '}'. */
+
+ if (!yaml_mapping_end_event_initialize(&output_event))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+ }
+
+ /* End a block sequence. */
+
+ if (!yaml_sequence_end_event_initialize(&output_event))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+ }
+
+ /* Write 'implicit'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"implicit", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write if the document is implicit. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:bool",
+ (yaml_char_t *)(input_event.data.document_start.implicit ?
+ "true" : "false"), -1,
+ 1, 0, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ break;
+
+ case YAML_DOCUMENT_END_EVENT:
+
+ /* Write 'type'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"type", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write 'DOCUMENT-END'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"DOCUMENT-END", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write 'implicit'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"implicit", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write if the document is implicit. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:bool",
+ (yaml_char_t *)(input_event.data.document_end.implicit ?
+ "true" : "false"), -1,
+ 1, 0, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ break;
+
+ case YAML_ALIAS_EVENT:
+
+ /* Write 'type'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"type", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write 'ALIAS'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"ALIAS", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write 'anchor'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"anchor", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write the alias anchor. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str",
+ input_event.data.alias.anchor, -1,
+ 0, 1, YAML_DOUBLE_QUOTED_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ break;
+
+ case YAML_SCALAR_EVENT:
+
+ /* Write 'type'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"type", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write 'SCALAR'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"SCALAR", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Display the scalar anchor. */
+
+ if (input_event.data.scalar.anchor)
+ {
+ /* Write 'anchor'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"anchor", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write the scalar anchor. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str",
+ input_event.data.scalar.anchor, -1,
+ 0, 1, YAML_DOUBLE_QUOTED_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+ }
+
+ /* Display the scalar tag. */
+
+ if (input_event.data.scalar.tag)
+ {
+ /* Write 'tag'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"tag", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write the scalar tag. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str",
+ input_event.data.scalar.tag, -1,
+ 0, 1, YAML_DOUBLE_QUOTED_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+ }
+
+ /* Display the scalar value. */
+
+ /* Write 'value'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"value", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write the scalar value. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str",
+ input_event.data.scalar.value,
+ input_event.data.scalar.length,
+ 0, 1, YAML_DOUBLE_QUOTED_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Display if the scalar tag is implicit. */
+
+ /* Write 'implicit'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"implicit", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write '{'. */
+
+ if (!yaml_mapping_start_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:map", 1,
+ YAML_FLOW_MAPPING_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write 'plain'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"plain", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write if the scalar is implicit in the plain style. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:bool",
+ (yaml_char_t * )(input_event.data.scalar.plain_implicit ?
+ "true" : "false"), -1,
+ 1, 0, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write 'quoted'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"non-plain", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write if the scalar is implicit in a non-plain style. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:bool",
+ (yaml_char_t *)(input_event.data.scalar.quoted_implicit ?
+ "true" : "false"), -1,
+ 1, 0, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write '}'. */
+
+ if (!yaml_mapping_end_event_initialize(&output_event))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Display the style information. */
+
+ if (input_event.data.scalar.style)
+ {
+ yaml_scalar_style_t style = input_event.data.scalar.style;
+
+ /* Write 'style'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"style", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write the scalar style. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str",
+ (yaml_char_t *)(style == YAML_PLAIN_SCALAR_STYLE ? "plain" :
+ style == YAML_SINGLE_QUOTED_SCALAR_STYLE ?
+ "single-quoted" :
+ style == YAML_DOUBLE_QUOTED_SCALAR_STYLE ?
+ "double-quoted" :
+ style == YAML_LITERAL_SCALAR_STYLE ? "literal" :
+ style == YAML_FOLDED_SCALAR_STYLE ? "folded" :
+ "unknown"), -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+ }
+
+ break;
+
+ case YAML_SEQUENCE_START_EVENT:
+
+ /* Write 'type'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"type", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write 'SEQUENCE-START'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"SEQUENCE-START", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Display the sequence anchor. */
+
+ if (input_event.data.sequence_start.anchor)
+ {
+ /* Write 'anchor'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"anchor", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write the sequence anchor. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str",
+ input_event.data.sequence_start.anchor, -1,
+ 0, 1, YAML_DOUBLE_QUOTED_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+ }
+
+ /* Display the sequence tag. */
+
+ if (input_event.data.sequence_start.tag)
+ {
+ /* Write 'tag'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"tag", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write the sequence tag. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str",
+ input_event.data.sequence_start.tag, -1,
+ 0, 1, YAML_DOUBLE_QUOTED_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+ }
+
+ /* Write 'implicit'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"implicit", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write if the sequence tag is implicit. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:bool",
+ (yaml_char_t *)(input_event.data.sequence_start.implicit ?
+ "true" : "false"), -1,
+ 1, 0, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Display the style information. */
+
+ if (input_event.data.sequence_start.style)
+ {
+ yaml_sequence_style_t style
+ = input_event.data.sequence_start.style;
+
+ /* Write 'style'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"style", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write the scalar style. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str",
+ (yaml_char_t *)(style == YAML_BLOCK_SEQUENCE_STYLE ? "block" :
+ style == YAML_FLOW_SEQUENCE_STYLE ? "flow" :
+ "unknown"), -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+ }
+
+ break;
+
+ case YAML_SEQUENCE_END_EVENT:
+
+ /* Write 'type'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"type", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write 'SEQUENCE-END'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"SEQUENCE-END", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ break;
+
+ case YAML_MAPPING_START_EVENT:
+
+ /* Write 'type'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"type", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write 'MAPPING-START'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"MAPPING-START", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Display the mapping anchor. */
+
+ if (input_event.data.mapping_start.anchor)
+ {
+ /* Write 'anchor'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"anchor", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write the mapping anchor. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str",
+ input_event.data.mapping_start.anchor, -1,
+ 0, 1, YAML_DOUBLE_QUOTED_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+ }
+
+ /* Display the mapping tag. */
+
+ if (input_event.data.mapping_start.tag)
+ {
+ /* Write 'tag'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"tag", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write the mapping tag. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str",
+ input_event.data.mapping_start.tag, -1,
+ 0, 1, YAML_DOUBLE_QUOTED_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+ }
+
+ /* Write 'implicit'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"implicit", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write if the mapping tag is implicit. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:bool",
+ (yaml_char_t *)(input_event.data.mapping_start.implicit ?
+ "true" : "false"), -1,
+ 1, 0, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Display the style information. */
+
+ if (input_event.data.mapping_start.style)
+ {
+ yaml_mapping_style_t style
+ = input_event.data.mapping_start.style;
+
+ /* Write 'style'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"style", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write the scalar style. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str",
+ (yaml_char_t *)(style == YAML_BLOCK_MAPPING_STYLE ? "block" :
+ style == YAML_FLOW_MAPPING_STYLE ? "flow" :
+ "unknown"), -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+ }
+
+ break;
+
+ case YAML_MAPPING_END_EVENT:
+
+ /* Write 'type'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"type", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Write 'MAPPING-END'. */
+
+ if (!yaml_scalar_event_initialize(&output_event,
+ NULL, (yaml_char_t *)"tag:yaml.org,2002:str", (yaml_char_t *)"MAPPING-END", -1,
+ 1, 1, YAML_PLAIN_SCALAR_STYLE))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ break;
+
+ default:
+ /* It couldn't really happen. */
+ break;
+ }
+
+ /* Delete the event object. */
+
+ yaml_event_delete(&input_event);
+
+ /* Create and emit a MAPPING-END event. */
+
+ if (!yaml_mapping_end_event_initialize(&output_event))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+ }
+
+ /* Create and emit the SEQUENCE-END event. */
+
+ if (!yaml_sequence_end_event_initialize(&output_event))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Create and emit the DOCUMENT-END event. */
+
+ if (!yaml_document_end_event_initialize(&output_event, 0))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ /* Create and emit the STREAM-END event. */
+
+ if (!yaml_stream_end_event_initialize(&output_event))
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &output_event))
+ goto emitter_error;
+
+ yaml_parser_delete(&parser);
+ yaml_emitter_delete(&emitter);
+
+ return 0;
+
+parser_error:
+
+ /* Display a parser error message. */
+
+ switch (parser.error)
+ {
+ case YAML_MEMORY_ERROR:
+ fprintf(stderr, "Memory error: Not enough memory for parsing\n");
+ break;
+
+ case YAML_READER_ERROR:
+ if (parser.problem_value != -1) {
+ fprintf(stderr, "Reader error: %s: #%X at %ld\n", parser.problem,
+ parser.problem_value, (long)parser.problem_offset);
+ }
+ else {
+ fprintf(stderr, "Reader error: %s at %ld\n", parser.problem,
+ (long)parser.problem_offset);
+ }
+ break;
+
+ case YAML_SCANNER_ERROR:
+ if (parser.context) {
+ fprintf(stderr, "Scanner error: %s at line %d, column %d\n"
+ "%s at line %d, column %d\n", parser.context,
+ (int)parser.context_mark.line+1, (int)parser.context_mark.column+1,
+ parser.problem, (int)parser.problem_mark.line+1,
+ (int)parser.problem_mark.column+1);
+ }
+ else {
+ fprintf(stderr, "Scanner error: %s at line %d, column %d\n",
+ parser.problem, (int)parser.problem_mark.line+1,
+ (int)parser.problem_mark.column+1);
+ }
+ break;
+
+ case YAML_PARSER_ERROR:
+ if (parser.context) {
+ fprintf(stderr, "Parser error: %s at line %d, column %d\n"
+ "%s at line %d, column %d\n", parser.context,
+ (int)parser.context_mark.line+1, (int)parser.context_mark.column+1,
+ parser.problem, (int)parser.problem_mark.line+1,
+ (int)parser.problem_mark.column+1);
+ }
+ else {
+ fprintf(stderr, "Parser error: %s at line %d, column %d\n",
+ parser.problem, (int)parser.problem_mark.line+1,
+ (int)parser.problem_mark.column+1);
+ }
+ break;
+
+ default:
+ /* Couldn't happen. */
+ fprintf(stderr, "Internal error\n");
+ break;
+ }
+
+ yaml_event_delete(&input_event);
+ yaml_parser_delete(&parser);
+ yaml_emitter_delete(&emitter);
+
+ return 1;
+
+emitter_error:
+
+ /* Display an emitter error message. */
+
+ switch (emitter.error)
+ {
+ case YAML_MEMORY_ERROR:
+ fprintf(stderr, "Memory error: Not enough memory for emitting\n");
+ break;
+
+ case YAML_WRITER_ERROR:
+ fprintf(stderr, "Writer error: %s\n", emitter.problem);
+ break;
+
+ case YAML_EMITTER_ERROR:
+ fprintf(stderr, "Emitter error: %s\n", emitter.problem);
+ break;
+
+ default:
+ /* Couldn't happen. */
+ fprintf(stderr, "Internal error\n");
+ break;
+ }
+
+ yaml_event_delete(&input_event);
+ yaml_parser_delete(&parser);
+ yaml_emitter_delete(&emitter);
+
+ return 1;
+
+event_error:
+
+ fprintf(stderr, "Memory error: Not enough memory for creating an event\n");
+
+ yaml_event_delete(&input_event);
+ yaml_parser_delete(&parser);
+ yaml_emitter_delete(&emitter);
+
+ return 1;
+}
+
diff --git a/libyaml/tests/example-reformatter-alt.c b/libyaml/tests/example-reformatter-alt.c
new file mode 100644
index 0000000000000000000000000000000000000000..e7d006e4a64a73eafb779a887d67834d2b74645e
--- /dev/null
+++ b/libyaml/tests/example-reformatter-alt.c
@@ -0,0 +1,217 @@
+
+#include <yaml.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+
+int
+main(int argc, char *argv[])
+{
+ int help = 0;
+ int canonical = 0;
+ int unicode = 0;
+ int k;
+ int done = 0;
+
+ yaml_parser_t parser;
+ yaml_emitter_t emitter;
+ yaml_document_t document;
+
+ /* Clear the objects. */
+
+ memset(&parser, 0, sizeof(parser));
+ memset(&emitter, 0, sizeof(emitter));
+ memset(&document, 0, sizeof(document));
+
+ /* Analyze command line options. */
+
+ for (k = 1; k < argc; k ++)
+ {
+ if (strcmp(argv[k], "-h") == 0
+ || strcmp(argv[k], "--help") == 0) {
+ help = 1;
+ }
+
+ else if (strcmp(argv[k], "-c") == 0
+ || strcmp(argv[k], "--canonical") == 0) {
+ canonical = 1;
+ }
+
+ else if (strcmp(argv[k], "-u") == 0
+ || strcmp(argv[k], "--unicode") == 0) {
+ unicode = 1;
+ }
+
+ else {
+ fprintf(stderr, "Unrecognized option: %s\n"
+ "Try `%s --help` for more information.\n",
+ argv[k], argv[0]);
+ return 1;
+ }
+ }
+
+ /* Display the help string. */
+
+ if (help)
+ {
+ printf("%s [--canonical] [--unicode] <input >output\n"
+ "or\n%s -h | --help\nReformat a YAML stream\n\nOptions:\n"
+ "-h, --help\t\tdisplay this help and exit\n"
+ "-c, --canonical\t\toutput in the canonical YAML format\n"
+ "-u, --unicode\t\toutput unescaped non-ASCII characters\n",
+ argv[0], argv[0]);
+ return 0;
+ }
+
+ /* Initialize the parser and emitter objects. */
+
+ if (!yaml_parser_initialize(&parser))
+ goto parser_error;
+
+ if (!yaml_emitter_initialize(&emitter))
+ goto emitter_error;
+
+ /* Set the parser parameters. */
+
+ yaml_parser_set_input_file(&parser, stdin);
+
+ /* Set the emitter parameters. */
+
+ yaml_emitter_set_output_file(&emitter, stdout);
+
+ yaml_emitter_set_canonical(&emitter, canonical);
+ yaml_emitter_set_unicode(&emitter, unicode);
+
+ /* The main loop. */
+
+ while (!done)
+ {
+ /* Get the next event. */
+
+ if (!yaml_parser_load(&parser, &document))
+ goto parser_error;
+
+ /* Check if this is the stream end. */
+
+ if (!yaml_document_get_root_node(&document)) {
+ done = 1;
+ }
+
+ /* Emit the event. */
+
+ if (!yaml_emitter_dump(&emitter, &document))
+ goto emitter_error;
+ }
+
+ yaml_parser_delete(&parser);
+ yaml_emitter_delete(&emitter);
+
+ return 0;
+
+parser_error:
+
+ /* Display a parser error message. */
+
+ switch (parser.error)
+ {
+ case YAML_MEMORY_ERROR:
+ fprintf(stderr, "Memory error: Not enough memory for parsing\n");
+ break;
+
+ case YAML_READER_ERROR:
+ if (parser.problem_value != -1) {
+ fprintf(stderr, "Reader error: %s: #%X at %zd\n", parser.problem,
+ parser.problem_value, parser.problem_offset);
+ }
+ else {
+ fprintf(stderr, "Reader error: %s at %lu\n", parser.problem,
+ parser.problem_offset);
+ }
+ break;
+
+ case YAML_SCANNER_ERROR:
+ if (parser.context) {
+ fprintf(stderr, "Scanner error: %s at line %lu, column %lu\n"
+ "%s at line %lu, column %lu\n", parser.context,
+ parser.context_mark.line+1, parser.context_mark.column+1,
+ parser.problem, parser.problem_mark.line+1,
+ parser.problem_mark.column+1);
+ }
+ else {
+ fprintf(stderr, "Scanner error: %s at line %lu, column %lu\n",
+ parser.problem, parser.problem_mark.line+1,
+ parser.problem_mark.column+1);
+ }
+ break;
+
+ case YAML_PARSER_ERROR:
+ if (parser.context) {
+ fprintf(stderr, "Parser error: %s at line %lu, column %lu\n"
+ "%s at line %lu, column %lu\n", parser.context,
+ parser.context_mark.line+1, parser.context_mark.column+1,
+ parser.problem, parser.problem_mark.line+1,
+ parser.problem_mark.column+1);
+ }
+ else {
+ fprintf(stderr, "Parser error: %s at line %lu, column %lu\n",
+ parser.problem, parser.problem_mark.line+1,
+ parser.problem_mark.column+1);
+ }
+ break;
+
+ case YAML_COMPOSER_ERROR:
+ if (parser.context) {
+ fprintf(stderr, "Composer error: %s at line %lu, column %lu\n"
+ "%s at line %lu, column %lu\n", parser.context,
+ parser.context_mark.line+1, parser.context_mark.column+1,
+ parser.problem, parser.problem_mark.line+1,
+ parser.problem_mark.column+1);
+ }
+ else {
+ fprintf(stderr, "Composer error: %s at line %lu, column %lu\n",
+ parser.problem, parser.problem_mark.line+1,
+ parser.problem_mark.column+1);
+ }
+ break;
+
+ default:
+ /* Couldn't happen. */
+ fprintf(stderr, "Internal error\n");
+ break;
+ }
+
+ yaml_parser_delete(&parser);
+ yaml_emitter_delete(&emitter);
+
+ return 1;
+
+emitter_error:
+
+ /* Display an emitter error message. */
+
+ switch (emitter.error)
+ {
+ case YAML_MEMORY_ERROR:
+ fprintf(stderr, "Memory error: Not enough memory for emitting\n");
+ break;
+
+ case YAML_WRITER_ERROR:
+ fprintf(stderr, "Writer error: %s\n", emitter.problem);
+ break;
+
+ case YAML_EMITTER_ERROR:
+ fprintf(stderr, "Emitter error: %s\n", emitter.problem);
+ break;
+
+ default:
+ /* Couldn't happen. */
+ fprintf(stderr, "Internal error\n");
+ break;
+ }
+
+ yaml_parser_delete(&parser);
+ yaml_emitter_delete(&emitter);
+
+ return 1;
+}
+
diff --git a/libyaml/tests/example-reformatter.c b/libyaml/tests/example-reformatter.c
new file mode 100644
index 0000000000000000000000000000000000000000..08f860c4ef2f1cd40c96e4739e9278f6d2c54f38
--- /dev/null
+++ b/libyaml/tests/example-reformatter.c
@@ -0,0 +1,202 @@
+
+#include <yaml.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+
+int
+main(int argc, char *argv[])
+{
+ int help = 0;
+ int canonical = 0;
+ int unicode = 0;
+ int k;
+ int done = 0;
+
+ yaml_parser_t parser;
+ yaml_emitter_t emitter;
+ yaml_event_t event;
+
+ /* Clear the objects. */
+
+ memset(&parser, 0, sizeof(parser));
+ memset(&emitter, 0, sizeof(emitter));
+ memset(&event, 0, sizeof(event));
+
+ /* Analyze command line options. */
+
+ for (k = 1; k < argc; k ++)
+ {
+ if (strcmp(argv[k], "-h") == 0
+ || strcmp(argv[k], "--help") == 0) {
+ help = 1;
+ }
+
+ else if (strcmp(argv[k], "-c") == 0
+ || strcmp(argv[k], "--canonical") == 0) {
+ canonical = 1;
+ }
+
+ else if (strcmp(argv[k], "-u") == 0
+ || strcmp(argv[k], "--unicode") == 0) {
+ unicode = 1;
+ }
+
+ else {
+ fprintf(stderr, "Unrecognized option: %s\n"
+ "Try `%s --help` for more information.\n",
+ argv[k], argv[0]);
+ return 1;
+ }
+ }
+
+ /* Display the help string. */
+
+ if (help)
+ {
+ printf("%s [--canonical] [--unicode] <input >output\n"
+ "or\n%s -h | --help\nReformat a YAML stream\n\nOptions:\n"
+ "-h, --help\t\tdisplay this help and exit\n"
+ "-c, --canonical\t\toutput in the canonical YAML format\n"
+ "-u, --unicode\t\toutput unescaped non-ASCII characters\n",
+ argv[0], argv[0]);
+ return 0;
+ }
+
+ /* Initialize the parser and emitter objects. */
+
+ if (!yaml_parser_initialize(&parser))
+ goto parser_error;
+
+ if (!yaml_emitter_initialize(&emitter))
+ goto emitter_error;
+
+ /* Set the parser parameters. */
+
+ yaml_parser_set_input_file(&parser, stdin);
+
+ /* Set the emitter parameters. */
+
+ yaml_emitter_set_output_file(&emitter, stdout);
+
+ yaml_emitter_set_canonical(&emitter, canonical);
+ yaml_emitter_set_unicode(&emitter, unicode);
+
+ /* The main loop. */
+
+ while (!done)
+ {
+ /* Get the next event. */
+
+ if (!yaml_parser_parse(&parser, &event))
+ goto parser_error;
+
+ /* Check if this is the stream end. */
+
+ if (event.type == YAML_STREAM_END_EVENT) {
+ done = 1;
+ }
+
+ /* Emit the event. */
+
+ if (!yaml_emitter_emit(&emitter, &event))
+ goto emitter_error;
+ }
+
+ yaml_parser_delete(&parser);
+ yaml_emitter_delete(&emitter);
+
+ return 0;
+
+parser_error:
+
+ /* Display a parser error message. */
+
+ switch (parser.error)
+ {
+ case YAML_MEMORY_ERROR:
+ fprintf(stderr, "Memory error: Not enough memory for parsing\n");
+ break;
+
+ case YAML_READER_ERROR:
+ if (parser.problem_value != -1) {
+ fprintf(stderr, "Reader error: %s: #%X at %ld\n", parser.problem,
+ parser.problem_value, (long)parser.problem_offset);
+ }
+ else {
+ fprintf(stderr, "Reader error: %s at %ld\n", parser.problem,
+ (long)parser.problem_offset);
+ }
+ break;
+
+ case YAML_SCANNER_ERROR:
+ if (parser.context) {
+ fprintf(stderr, "Scanner error: %s at line %d, column %d\n"
+ "%s at line %d, column %d\n", parser.context,
+ (int)parser.context_mark.line+1, (int)parser.context_mark.column+1,
+ parser.problem, (int)parser.problem_mark.line+1,
+ (int)parser.problem_mark.column+1);
+ }
+ else {
+ fprintf(stderr, "Scanner error: %s at line %d, column %d\n",
+ parser.problem, (int)parser.problem_mark.line+1,
+ (int)parser.problem_mark.column+1);
+ }
+ break;
+
+ case YAML_PARSER_ERROR:
+ if (parser.context) {
+ fprintf(stderr, "Parser error: %s at line %d, column %d\n"
+ "%s at line %d, column %d\n", parser.context,
+ (int)parser.context_mark.line+1, (int)parser.context_mark.column+1,
+ parser.problem, (int)parser.problem_mark.line+1,
+ (int)parser.problem_mark.column+1);
+ }
+ else {
+ fprintf(stderr, "Parser error: %s at line %d, column %d\n",
+ parser.problem, (int)parser.problem_mark.line+1,
+ (int)parser.problem_mark.column+1);
+ }
+ break;
+
+ default:
+ /* Couldn't happen. */
+ fprintf(stderr, "Internal error\n");
+ break;
+ }
+
+ yaml_parser_delete(&parser);
+ yaml_emitter_delete(&emitter);
+
+ return 1;
+
+emitter_error:
+
+ /* Display an emitter error message. */
+
+ switch (emitter.error)
+ {
+ case YAML_MEMORY_ERROR:
+ fprintf(stderr, "Memory error: Not enough memory for emitting\n");
+ break;
+
+ case YAML_WRITER_ERROR:
+ fprintf(stderr, "Writer error: %s\n", emitter.problem);
+ break;
+
+ case YAML_EMITTER_ERROR:
+ fprintf(stderr, "Emitter error: %s\n", emitter.problem);
+ break;
+
+ default:
+ /* Couldn't happen. */
+ fprintf(stderr, "Internal error\n");
+ break;
+ }
+
+ yaml_parser_delete(&parser);
+ yaml_emitter_delete(&emitter);
+
+ return 1;
+}
+
diff --git a/libyaml/tests/run-all-tests.sh b/libyaml/tests/run-all-tests.sh
new file mode 100755
index 0000000000000000000000000000000000000000..9c92741eca3822f545332907d943a518363240bd
--- /dev/null
+++ b/libyaml/tests/run-all-tests.sh
@@ -0,0 +1,29 @@
+#!/bin/sh
+
+set -e
+
+main() {
+ # Autoconf based in-source build and tests
+ clean
+
+ ./bootstrap
+ ./configure
+ make test-all
+
+ # CMake based in-source build and tests
+ clean
+
+ cmake .
+ make
+ make test
+
+ clean
+}
+
+clean() {
+ git clean -d -x -f
+ rm -fr tests/run-test-suite
+ git worktree prune
+}
+
+main "$@"
diff --git a/libyaml/tests/run-dumper.c b/libyaml/tests/run-dumper.c
new file mode 100644
index 0000000000000000000000000000000000000000..04c5beeafa5798aeb22cc4163c2763ef6a5fdccf
--- /dev/null
+++ b/libyaml/tests/run-dumper.c
@@ -0,0 +1,314 @@
+#include <yaml.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#ifdef NDEBUG
+#undef NDEBUG
+#endif
+#include <assert.h>
+
+#define BUFFER_SIZE 65536
+#define MAX_DOCUMENTS 16
+
+int copy_document(yaml_document_t *document_to, yaml_document_t *document_from)
+{
+ yaml_node_t *node;
+ yaml_node_item_t *item;
+ yaml_node_pair_t *pair;
+
+ if (!yaml_document_initialize(document_to, document_from->version_directive,
+ document_from->tag_directives.start,
+ document_from->tag_directives.end,
+ document_from->start_implicit, document_from->end_implicit))
+ return 0;
+
+ for (node = document_from->nodes.start;
+ node < document_from->nodes.top; node ++) {
+ switch (node->type) {
+ case YAML_SCALAR_NODE:
+ if (!yaml_document_add_scalar(document_to, node->tag,
+ node->data.scalar.value, node->data.scalar.length,
+ node->data.scalar.style)) goto error;
+ break;
+ case YAML_SEQUENCE_NODE:
+ if (!yaml_document_add_sequence(document_to, node->tag,
+ node->data.sequence.style)) goto error;
+ break;
+ case YAML_MAPPING_NODE:
+ if (!yaml_document_add_mapping(document_to, node->tag,
+ node->data.mapping.style)) goto error;
+ break;
+ default:
+ assert(0);
+ break;
+ }
+ }
+
+ for (node = document_from->nodes.start;
+ node < document_from->nodes.top; node ++) {
+ switch (node->type) {
+ case YAML_SEQUENCE_NODE:
+ for (item = node->data.sequence.items.start;
+ item < node->data.sequence.items.top; item ++) {
+ if (!yaml_document_append_sequence_item(document_to,
+ node - document_from->nodes.start + 1,
+ *item)) goto error;
+ }
+ break;
+ case YAML_MAPPING_NODE:
+ for (pair = node->data.mapping.pairs.start;
+ pair < node->data.mapping.pairs.top; pair ++) {
+ if (!yaml_document_append_mapping_pair(document_to,
+ node - document_from->nodes.start + 1,
+ pair->key, pair->value)) goto error;
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ return 1;
+
+error:
+ yaml_document_delete(document_to);
+ return 0;
+}
+
+int compare_nodes(yaml_document_t *document1, int index1,
+ yaml_document_t *document2, int index2, int level)
+{
+ int k;
+ yaml_node_t *node1;
+ yaml_node_t *node2;
+ if (level++ > 1000) return 0;
+ node1 = yaml_document_get_node(document1, index1);
+ node2 = yaml_document_get_node(document2, index2);
+
+ assert(node1);
+ assert(node2);
+
+ if (node1->type != node2->type)
+ return 0;
+
+ if (strcmp((char *)node1->tag, (char *)node2->tag) != 0) return 0;
+
+ switch (node1->type) {
+ case YAML_SCALAR_NODE:
+ if (node1->data.scalar.length != node2->data.scalar.length)
+ return 0;
+ if (strncmp((char *)node1->data.scalar.value, (char *)node2->data.scalar.value,
+ node1->data.scalar.length) != 0) return 0;
+ break;
+ case YAML_SEQUENCE_NODE:
+ if ((node1->data.sequence.items.top - node1->data.sequence.items.start) !=
+ (node2->data.sequence.items.top - node2->data.sequence.items.start))
+ return 0;
+ for (k = 0; k < (node1->data.sequence.items.top - node1->data.sequence.items.start); k ++) {
+ if (!compare_nodes(document1, node1->data.sequence.items.start[k],
+ document2, node2->data.sequence.items.start[k], level)) return 0;
+ }
+ break;
+ case YAML_MAPPING_NODE:
+ if ((node1->data.mapping.pairs.top - node1->data.mapping.pairs.start) !=
+ (node2->data.mapping.pairs.top - node2->data.mapping.pairs.start))
+ return 0;
+ for (k = 0; k < (node1->data.mapping.pairs.top - node1->data.mapping.pairs.start); k ++) {
+ if (!compare_nodes(document1, node1->data.mapping.pairs.start[k].key,
+ document2, node2->data.mapping.pairs.start[k].key, level)) return 0;
+ if (!compare_nodes(document1, node1->data.mapping.pairs.start[k].value,
+ document2, node2->data.mapping.pairs.start[k].value, level)) return 0;
+ }
+ break;
+ default:
+ assert(0);
+ break;
+ }
+ return 1;
+}
+
+int compare_documents(yaml_document_t *document1, yaml_document_t *document2)
+{
+ int k;
+
+ if ((document1->version_directive && !document2->version_directive)
+ || (!document1->version_directive && document2->version_directive)
+ || (document1->version_directive && document2->version_directive
+ && (document1->version_directive->major != document2->version_directive->major
+ || document1->version_directive->minor != document2->version_directive->minor)))
+ return 0;
+
+ if ((document1->tag_directives.end - document1->tag_directives.start) !=
+ (document2->tag_directives.end - document2->tag_directives.start))
+ return 0;
+ for (k = 0; k < (document1->tag_directives.end - document1->tag_directives.start); k ++) {
+ if ((strcmp((char *)document1->tag_directives.start[k].handle,
+ (char *)document2->tag_directives.start[k].handle) != 0)
+ || (strcmp((char *)document1->tag_directives.start[k].prefix,
+ (char *)document2->tag_directives.start[k].prefix) != 0))
+ return 0;
+ }
+
+ if ((document1->nodes.top - document1->nodes.start) !=
+ (document2->nodes.top - document2->nodes.start))
+ return 0;
+
+ if (document1->nodes.top != document1->nodes.start) {
+ if (!compare_nodes(document1, 1, document2, 1, 0))
+ return 0;
+ }
+
+ return 1;
+}
+
+int print_output(char *name, unsigned char *buffer, size_t size, int count)
+{
+ FILE *file;
+ char data[BUFFER_SIZE];
+ size_t data_size = 1;
+ size_t total_size = 0;
+ if (count >= 0) {
+ printf("FAILED (at the document #%d)\nSOURCE:\n", count+1);
+ }
+ file = fopen(name, "rb");
+ assert(file);
+ while (data_size > 0) {
+ data_size = fread(data, 1, BUFFER_SIZE, file);
+ assert(!ferror(file));
+ if (!data_size) break;
+ assert(fwrite(data, 1, data_size, stdout) == data_size);
+ total_size += data_size;
+ if (feof(file)) break;
+ }
+ fclose(file);
+ printf("#### (length: %ld)\n", (long)total_size);
+ printf("OUTPUT:\n%s#### (length: %ld)\n", buffer, (long)size);
+ return 0;
+}
+
+int
+main(int argc, char *argv[])
+{
+ int number;
+ int canonical = 0;
+ int unicode = 0;
+
+ number = 1;
+ while (number < argc) {
+ if (strcmp(argv[number], "-c") == 0) {
+ canonical = 1;
+ }
+ else if (strcmp(argv[number], "-u") == 0) {
+ unicode = 1;
+ }
+ else if (argv[number][0] == '-') {
+ printf("Unknown option: '%s'\n", argv[number]);
+ return 0;
+ }
+ if (argv[number][0] == '-') {
+ if (number < argc-1) {
+ memmove(argv+number, argv+number+1, (argc-number-1)*sizeof(char *));
+ }
+ argc --;
+ }
+ else {
+ number ++;
+ }
+ }
+
+ if (argc < 2) {
+ printf("Usage: %s [-c] [-u] file1.yaml ...\n", argv[0]);
+ return 0;
+ }
+
+ for (number = 1; number < argc; number ++)
+ {
+ FILE *file;
+ yaml_parser_t parser;
+ yaml_emitter_t emitter;
+
+ yaml_document_t document;
+ unsigned char buffer[BUFFER_SIZE+1];
+ size_t written = 0;
+ yaml_document_t documents[MAX_DOCUMENTS];
+ size_t document_number = 0;
+ int done = 0;
+ int count = 0;
+ int error = 0;
+ int k;
+ memset(buffer, 0, BUFFER_SIZE+1);
+ memset(documents, 0, MAX_DOCUMENTS*sizeof(yaml_document_t));
+
+ printf("[%d] Loading, dumping, and loading again '%s': ", number, argv[number]);
+ fflush(stdout);
+
+ file = fopen(argv[number], "rb");
+ assert(file);
+
+ assert(yaml_parser_initialize(&parser));
+ yaml_parser_set_input_file(&parser, file);
+ assert(yaml_emitter_initialize(&emitter));
+ if (canonical) {
+ yaml_emitter_set_canonical(&emitter, 1);
+ }
+ if (unicode) {
+ yaml_emitter_set_unicode(&emitter, 1);
+ }
+ yaml_emitter_set_output_string(&emitter, buffer, BUFFER_SIZE, &written);
+ yaml_emitter_open(&emitter);
+
+ while (!done)
+ {
+ if (!yaml_parser_load(&parser, &document)) {
+ error = 1;
+ break;
+ }
+
+ done = (!yaml_document_get_root_node(&document));
+ if (!done) {
+ assert(document_number < MAX_DOCUMENTS);
+ assert(copy_document(&(documents[document_number++]), &document));
+ assert(yaml_emitter_dump(&emitter, &document) ||
+ (yaml_emitter_flush(&emitter) && print_output(argv[number], buffer, written, count)));
+ count ++;
+ }
+ else {
+ yaml_document_delete(&document);
+ }
+ }
+
+ yaml_parser_delete(&parser);
+ assert(!fclose(file));
+ yaml_emitter_close(&emitter);
+ yaml_emitter_delete(&emitter);
+
+ if (!error)
+ {
+ count = done = 0;
+ assert(yaml_parser_initialize(&parser));
+ yaml_parser_set_input_string(&parser, buffer, written);
+
+ while (!done)
+ {
+ assert(yaml_parser_load(&parser, &document) || print_output(argv[number], buffer, written, count));
+ done = (!yaml_document_get_root_node(&document));
+ if (!done) {
+ assert(compare_documents(documents+count, &document) || print_output(argv[number], buffer, written, count));
+ count ++;
+ }
+ yaml_document_delete(&document);
+ }
+ yaml_parser_delete(&parser);
+ }
+
+ for (k = 0; k < document_number; k ++) {
+ yaml_document_delete(documents+k);
+ }
+
+ printf("PASSED (length: %ld)\n", (long)written);
+ print_output(argv[number], buffer, written, -1);
+ }
+
+ return 0;
+}
diff --git a/libyaml/tests/run-emitter-test-suite.c b/libyaml/tests/run-emitter-test-suite.c
new file mode 100644
index 0000000000000000000000000000000000000000..ba0f163ad39f38d6ee7436b96e6dc7bc3e5f8700
--- /dev/null
+++ b/libyaml/tests/run-emitter-test-suite.c
@@ -0,0 +1,290 @@
+#include <yaml.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+#include "../src/yaml_private.h"
+
+int get_line(FILE * input, char *line);
+char *get_anchor(char sigil, char *line, char *anchor);
+char *get_tag(char *line, char *tag);
+void get_value(char *line, char *value, int *style);
+int usage(int ret);
+
+int main(int argc, char *argv[])
+{
+ FILE *input;
+ yaml_emitter_t emitter;
+ yaml_event_t event;
+ yaml_version_directive_t *version_directive = NULL;
+
+ int canonical = 0;
+ int unicode = 0;
+ char line[1024];
+ int foundfile = 0;
+ int i = 0;
+ int minor = 0;
+ int flow = -1; /** default no flow style collections */
+
+ for (i = 1; i < argc; i++) {
+ if (strncmp(argv[i], "--help", 6) == 0)
+ return usage(0);
+ if (strncmp(argv[i], "-h", 2) == 0)
+ return usage(0);
+ if (strncmp(argv[i], "--flow", 6) == 0) {
+ if (i+1 == argc)
+ return usage(1);
+ i++;
+ if (strncmp(argv[i], "keep", 4) == 0)
+ flow = 0;
+ else if (strncmp(argv[i], "on", 2) == 0)
+ flow = 1;
+ else if (strncmp(argv[i], "off", 3) == 0)
+ flow = -1;
+ else
+ return usage(1);
+ }
+ else if (strncmp(argv[i], "--directive", 11) == 0) {
+ if (i+1 == argc)
+ return usage(1);
+ i++;
+ if (strncmp(argv[i], "1.1", 3) == 0)
+ minor = 1;
+ else if (strncmp(argv[i], "1.2", 3) == 0)
+ minor = 2;
+ else
+ return usage(1);
+ }
+ else if (!foundfile) {
+ input = fopen(argv[i], "rb");
+ foundfile = 1;
+ }
+
+ }
+ if (minor) {
+ version_directive = YAML_MALLOC_STATIC(yaml_version_directive_t);
+ version_directive->major = 1;
+ version_directive->minor = minor;
+ }
+ if (!foundfile)
+ input = stdin;
+
+ assert(input);
+
+ if (!yaml_emitter_initialize(&emitter)) {
+ fprintf(stderr, "Could not initalize the emitter object\n");
+ return 1;
+ }
+ yaml_emitter_set_output_file(&emitter, stdout);
+ yaml_emitter_set_canonical(&emitter, canonical);
+ yaml_emitter_set_unicode(&emitter, unicode);
+
+
+ while (get_line(input, line)) {
+ int ok;
+ char anchor[256];
+ char tag[256];
+ int implicit;
+ int style;
+
+ if (strncmp(line, "+STR", 4) == 0) {
+ ok = yaml_stream_start_event_initialize(&event, YAML_UTF8_ENCODING);
+ }
+ else if (strncmp(line, "-STR", 4) == 0) {
+ ok = yaml_stream_end_event_initialize(&event);
+ }
+ else if (strncmp(line, "+DOC", 4) == 0) {
+ implicit = strncmp(line+4, " ---", 4) != 0;
+ ok = yaml_document_start_event_initialize(&event, version_directive, NULL, NULL, implicit);
+ }
+ else if (strncmp(line, "-DOC", 4) == 0) {
+ implicit = strncmp(line+4, " ...", 4) != 0;
+ ok = yaml_document_end_event_initialize(&event, implicit);
+ }
+ else if (strncmp(line, "+MAP", 4) == 0) {
+ style = YAML_BLOCK_MAPPING_STYLE;
+ if (flow == 1)
+ style = YAML_FLOW_MAPPING_STYLE;
+ else if (flow == 0 && strncmp(line+5, "{}", 2) == 0)
+ style = YAML_FLOW_MAPPING_STYLE;
+ ok = yaml_mapping_start_event_initialize(&event, (yaml_char_t *)
+ get_anchor('&', line, anchor), (yaml_char_t *)
+ get_tag(line, tag), 0, style);
+ }
+ else if (strncmp(line, "-MAP", 4) == 0) {
+ ok = yaml_mapping_end_event_initialize(&event);
+ }
+ else if (strncmp(line, "+SEQ", 4) == 0) {
+ style = YAML_BLOCK_SEQUENCE_STYLE;
+ if (flow == 1)
+ style = YAML_FLOW_MAPPING_STYLE;
+ else if (flow == 0 && strncmp(line+5, "[]", 2) == 0)
+ style = YAML_FLOW_SEQUENCE_STYLE;
+ ok = yaml_sequence_start_event_initialize(&event, (yaml_char_t *)
+ get_anchor('&', line, anchor), (yaml_char_t *)
+ get_tag(line, tag), 0, style);
+ }
+ else if (strncmp(line, "-SEQ", 4) == 0) {
+ ok = yaml_sequence_end_event_initialize(&event);
+ }
+ else if (strncmp(line, "=VAL", 4) == 0) {
+ char value[1024];
+ int style;
+
+ get_value(line, value, &style);
+ implicit = (get_tag(line, tag) == NULL);
+
+ ok = yaml_scalar_event_initialize(&event, (yaml_char_t *)
+ get_anchor('&', line, anchor), (yaml_char_t *) get_tag(line, tag), (yaml_char_t *) value, -1, implicit, implicit, style);
+ }
+ else if (strncmp(line, "=ALI", 4) == 0) {
+ ok = yaml_alias_event_initialize(&event, (yaml_char_t *)
+ get_anchor('*', line, anchor)
+ );
+ }
+ else {
+ fprintf(stderr, "Unknown event: '%s'\n", line);
+ fflush(stdout);
+ return 1;
+ }
+
+ if (!ok)
+ goto event_error;
+ if (!yaml_emitter_emit(&emitter, &event))
+ goto emitter_error;
+ }
+
+ assert(!fclose(input));
+ yaml_emitter_delete(&emitter);
+ fflush(stdout);
+
+ return 0;
+
+ emitter_error:
+ switch (emitter.error) {
+ case YAML_MEMORY_ERROR:
+ fprintf(stderr, "Memory error: Not enough memory for emitting\n");
+ break;
+ case YAML_WRITER_ERROR:
+ fprintf(stderr, "Writer error: %s\n", emitter.problem);
+ break;
+ case YAML_EMITTER_ERROR:
+ fprintf(stderr, "Emitter error: %s\n", emitter.problem);
+ break;
+ default:
+ /*
+ * Couldn't happen.
+ */
+ fprintf(stderr, "Internal error\n");
+ break;
+ }
+ yaml_emitter_delete(&emitter);
+ return 1;
+
+ event_error:
+ fprintf(stderr, "Memory error: Not enough memory for creating an event\n");
+ yaml_emitter_delete(&emitter);
+ return 1;
+}
+
+int get_line(FILE * input, char *line)
+{
+ char *newline;
+
+ if (!fgets(line, 1024 - 1, input))
+ return 0;
+
+ if ((newline = strchr(line, '\n')) == NULL) {
+ fprintf(stderr, "Line too long: '%s'", line);
+ abort();
+ }
+ *newline = '\0';
+
+ return 1;
+}
+
+char *get_anchor(char sigil, char *line, char *anchor)
+{
+ char *start;
+ char *end;
+ if ((start = strchr(line, sigil)) == NULL)
+ return NULL;
+ start++;
+ if ((end = strchr(start, ' ')) == NULL)
+ end = line + strlen(line);
+ memcpy(anchor, start, end - start);
+ anchor[end - start] = '\0';
+ return anchor;
+}
+
+char *get_tag(char *line, char *tag)
+{
+ char *start;
+ char *end;
+ if ((start = strchr(line, '<')) == NULL)
+ return NULL;
+ if ((end = strchr(line, '>')) == NULL)
+ return NULL;
+ memcpy(tag, start + 1, end - start - 1);
+ tag[end - start - 1] = '\0';
+ return tag;
+}
+
+void get_value(char *line, char *value, int *style)
+{
+ int i = 0;
+ char *c;
+ char *start = NULL;
+ char *end = line + strlen(line);
+
+ for (c = line + 4; c < end; c++) {
+ if (*c == ' ') {
+ start = c + 1;
+ if (*start == ':')
+ *style = YAML_PLAIN_SCALAR_STYLE;
+ else if (*start == '\'')
+ *style = YAML_SINGLE_QUOTED_SCALAR_STYLE;
+ else if (*start == '"')
+ *style = YAML_DOUBLE_QUOTED_SCALAR_STYLE;
+ else if (*start == '|')
+ *style = YAML_LITERAL_SCALAR_STYLE;
+ else if (*start == '>')
+ *style = YAML_FOLDED_SCALAR_STYLE;
+ else {
+ start = NULL;
+ continue;
+ }
+ start++;
+ break;
+ }
+ }
+ if (!start)
+ abort();
+
+ for (c = start; c < end; c++) {
+ if (*c == '\\') {
+ if (*++c == '\\')
+ value[i++] = '\\';
+ else if (*c == '0')
+ value[i++] = '\0';
+ else if (*c == 'b')
+ value[i++] = '\b';
+ else if (*c == 'n')
+ value[i++] = '\n';
+ else if (*c == 'r')
+ value[i++] = '\r';
+ else if (*c == 't')
+ value[i++] = '\t';
+ else
+ abort();
+ }
+ else
+ value[i++] = *c;
+ }
+ value[i] = '\0';
+}
+
+int usage(int ret) {
+ fprintf(stderr, "Usage: run-emitter-test-suite [--directive (1.1|1.2)] [--flow (on|off|keep)] [<input-file>]\n");
+ return ret;
+}
diff --git a/libyaml/tests/run-emitter.c b/libyaml/tests/run-emitter.c
new file mode 100644
index 0000000000000000000000000000000000000000..3ffe4754b23efc2f6d824a75a2acaa5fb67ac76a
--- /dev/null
+++ b/libyaml/tests/run-emitter.c
@@ -0,0 +1,327 @@
+#include <yaml.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#ifdef NDEBUG
+#undef NDEBUG
+#endif
+#include <assert.h>
+
+#define BUFFER_SIZE 65536
+#define MAX_EVENTS 1024
+
+int copy_event(yaml_event_t *event_to, yaml_event_t *event_from)
+{
+ switch (event_from->type)
+ {
+ case YAML_STREAM_START_EVENT:
+ return yaml_stream_start_event_initialize(event_to,
+ event_from->data.stream_start.encoding);
+
+ case YAML_STREAM_END_EVENT:
+ return yaml_stream_end_event_initialize(event_to);
+
+ case YAML_DOCUMENT_START_EVENT:
+ return yaml_document_start_event_initialize(event_to,
+ event_from->data.document_start.version_directive,
+ event_from->data.document_start.tag_directives.start,
+ event_from->data.document_start.tag_directives.end,
+ event_from->data.document_start.implicit);
+
+ case YAML_DOCUMENT_END_EVENT:
+ return yaml_document_end_event_initialize(event_to,
+ event_from->data.document_end.implicit);
+
+ case YAML_ALIAS_EVENT:
+ return yaml_alias_event_initialize(event_to,
+ event_from->data.alias.anchor);
+
+ case YAML_SCALAR_EVENT:
+ return yaml_scalar_event_initialize(event_to,
+ event_from->data.scalar.anchor,
+ event_from->data.scalar.tag,
+ event_from->data.scalar.value,
+ event_from->data.scalar.length,
+ event_from->data.scalar.plain_implicit,
+ event_from->data.scalar.quoted_implicit,
+ event_from->data.scalar.style);
+
+ case YAML_SEQUENCE_START_EVENT:
+ return yaml_sequence_start_event_initialize(event_to,
+ event_from->data.sequence_start.anchor,
+ event_from->data.sequence_start.tag,
+ event_from->data.sequence_start.implicit,
+ event_from->data.sequence_start.style);
+
+ case YAML_SEQUENCE_END_EVENT:
+ return yaml_sequence_end_event_initialize(event_to);
+
+ case YAML_MAPPING_START_EVENT:
+ return yaml_mapping_start_event_initialize(event_to,
+ event_from->data.mapping_start.anchor,
+ event_from->data.mapping_start.tag,
+ event_from->data.mapping_start.implicit,
+ event_from->data.mapping_start.style);
+
+ case YAML_MAPPING_END_EVENT:
+ return yaml_mapping_end_event_initialize(event_to);
+
+ default:
+ assert(1);
+ }
+
+ return 0;
+}
+
+int compare_events(yaml_event_t *event1, yaml_event_t *event2)
+{
+ int k;
+
+ if (event1->type != event2->type)
+ return 0;
+
+ switch (event1->type)
+ {
+ case YAML_STREAM_START_EVENT:
+ return 1;
+ /* return (event1->data.stream_start.encoding ==
+ event2->data.stream_start.encoding); */
+
+ case YAML_DOCUMENT_START_EVENT:
+ if ((event1->data.document_start.version_directive && !event2->data.document_start.version_directive)
+ || (!event1->data.document_start.version_directive && event2->data.document_start.version_directive)
+ || (event1->data.document_start.version_directive && event2->data.document_start.version_directive
+ && (event1->data.document_start.version_directive->major != event2->data.document_start.version_directive->major
+ || event1->data.document_start.version_directive->minor != event2->data.document_start.version_directive->minor)))
+ return 0;
+ if ((event1->data.document_start.tag_directives.end - event1->data.document_start.tag_directives.start) !=
+ (event2->data.document_start.tag_directives.end - event2->data.document_start.tag_directives.start))
+ return 0;
+ for (k = 0; k < (event1->data.document_start.tag_directives.end - event1->data.document_start.tag_directives.start); k ++) {
+ if ((strcmp((char *)event1->data.document_start.tag_directives.start[k].handle,
+ (char *)event2->data.document_start.tag_directives.start[k].handle) != 0)
+ || (strcmp((char *)event1->data.document_start.tag_directives.start[k].prefix,
+ (char *)event2->data.document_start.tag_directives.start[k].prefix) != 0))
+ return 0;
+ }
+ /* if (event1->data.document_start.implicit != event2->data.document_start.implicit)
+ return 0; */
+ return 1;
+
+ case YAML_DOCUMENT_END_EVENT:
+ return 1;
+ /* return (event1->data.document_end.implicit ==
+ event2->data.document_end.implicit); */
+
+ case YAML_ALIAS_EVENT:
+ return (strcmp((char *)event1->data.alias.anchor,
+ (char *)event2->data.alias.anchor) == 0);
+
+ case YAML_SCALAR_EVENT:
+ if ((event1->data.scalar.anchor && !event2->data.scalar.anchor)
+ || (!event1->data.scalar.anchor && event2->data.scalar.anchor)
+ || (event1->data.scalar.anchor && event2->data.scalar.anchor
+ && strcmp((char *)event1->data.scalar.anchor,
+ (char *)event2->data.scalar.anchor) != 0))
+ return 0;
+ if ((event1->data.scalar.tag && !event2->data.scalar.tag
+ && strcmp((char *)event1->data.scalar.tag, "!") != 0)
+ || (!event1->data.scalar.tag && event2->data.scalar.tag
+ && strcmp((char *)event2->data.scalar.tag, "!") != 0)
+ || (event1->data.scalar.tag && event2->data.scalar.tag
+ && strcmp((char *)event1->data.scalar.tag,
+ (char *)event2->data.scalar.tag) != 0))
+ return 0;
+ if ((event1->data.scalar.length != event2->data.scalar.length)
+ || memcmp(event1->data.scalar.value, event2->data.scalar.value,
+ event1->data.scalar.length) != 0)
+ return 0;
+ if ((event1->data.scalar.plain_implicit != event2->data.scalar.plain_implicit)
+ || (event1->data.scalar.quoted_implicit != event2->data.scalar.quoted_implicit)
+ /* || (event2->data.scalar.style != event2->data.scalar.style) */)
+ return 0;
+ return 1;
+
+ case YAML_SEQUENCE_START_EVENT:
+ if ((event1->data.sequence_start.anchor && !event2->data.sequence_start.anchor)
+ || (!event1->data.sequence_start.anchor && event2->data.sequence_start.anchor)
+ || (event1->data.sequence_start.anchor && event2->data.sequence_start.anchor
+ && strcmp((char *)event1->data.sequence_start.anchor,
+ (char *)event2->data.sequence_start.anchor) != 0))
+ return 0;
+ if ((event1->data.sequence_start.tag && !event2->data.sequence_start.tag)
+ || (!event1->data.sequence_start.tag && event2->data.sequence_start.tag)
+ || (event1->data.sequence_start.tag && event2->data.sequence_start.tag
+ && strcmp((char *)event1->data.sequence_start.tag,
+ (char *)event2->data.sequence_start.tag) != 0))
+ return 0;
+ if ((event1->data.sequence_start.implicit != event2->data.sequence_start.implicit)
+ /* || (event2->data.sequence_start.style != event2->data.sequence_start.style) */)
+ return 0;
+ return 1;
+
+ case YAML_MAPPING_START_EVENT:
+ if ((event1->data.mapping_start.anchor && !event2->data.mapping_start.anchor)
+ || (!event1->data.mapping_start.anchor && event2->data.mapping_start.anchor)
+ || (event1->data.mapping_start.anchor && event2->data.mapping_start.anchor
+ && strcmp((char *)event1->data.mapping_start.anchor,
+ (char *)event2->data.mapping_start.anchor) != 0))
+ return 0;
+ if ((event1->data.mapping_start.tag && !event2->data.mapping_start.tag)
+ || (!event1->data.mapping_start.tag && event2->data.mapping_start.tag)
+ || (event1->data.mapping_start.tag && event2->data.mapping_start.tag
+ && strcmp((char *)event1->data.mapping_start.tag,
+ (char *)event2->data.mapping_start.tag) != 0))
+ return 0;
+ if ((event1->data.mapping_start.implicit != event2->data.mapping_start.implicit)
+ /* || (event2->data.mapping_start.style != event2->data.mapping_start.style) */)
+ return 0;
+ return 1;
+
+ default:
+ return 1;
+ }
+}
+
+int print_output(char *name, unsigned char *buffer, size_t size, int count)
+{
+ FILE *file;
+ char data[BUFFER_SIZE];
+ size_t data_size = 1;
+ size_t total_size = 0;
+ if (count >= 0) {
+ printf("FAILED (at the event #%d)\nSOURCE:\n", count+1);
+ }
+ file = fopen(name, "rb");
+ assert(file);
+ while (data_size > 0) {
+ data_size = fread(data, 1, BUFFER_SIZE, file);
+ assert(!ferror(file));
+ if (!data_size) break;
+ assert(fwrite(data, 1, data_size, stdout) == data_size);
+ total_size += data_size;
+ if (feof(file)) break;
+ }
+ fclose(file);
+ printf("#### (length: %ld)\n", (long)total_size);
+ printf("OUTPUT:\n%s#### (length: %ld)\n", buffer, (long)size);
+ return 0;
+}
+
+int
+main(int argc, char *argv[])
+{
+ int number;
+ int canonical = 0;
+ int unicode = 0;
+
+ number = 1;
+ while (number < argc) {
+ if (strcmp(argv[number], "-c") == 0) {
+ canonical = 1;
+ }
+ else if (strcmp(argv[number], "-u") == 0) {
+ unicode = 1;
+ }
+ else if (argv[number][0] == '-') {
+ printf("Unknown option: '%s'\n", argv[number]);
+ return 0;
+ }
+ if (argv[number][0] == '-') {
+ if (number < argc-1) {
+ memmove(argv+number, argv+number+1, (argc-number-1)*sizeof(char *));
+ }
+ argc --;
+ }
+ else {
+ number ++;
+ }
+ }
+
+ if (argc < 2) {
+ printf("Usage: %s [-c] [-u] file1.yaml ...\n", argv[0]);
+ return 0;
+ }
+
+ for (number = 1; number < argc; number ++)
+ {
+ FILE *file;
+ yaml_parser_t parser;
+ yaml_emitter_t emitter;
+ yaml_event_t event;
+ unsigned char buffer[BUFFER_SIZE+1];
+ size_t written = 0;
+ yaml_event_t events[MAX_EVENTS];
+ size_t event_number = 0;
+ int done = 0;
+ int count = 0;
+ int error = 0;
+ int k;
+ memset(buffer, 0, BUFFER_SIZE+1);
+ memset(events, 0, MAX_EVENTS*sizeof(yaml_event_t));
+
+ printf("[%d] Parsing, emitting, and parsing again '%s': ", number, argv[number]);
+ fflush(stdout);
+
+ file = fopen(argv[number], "rb");
+ assert(file);
+
+ assert(yaml_parser_initialize(&parser));
+ yaml_parser_set_input_file(&parser, file);
+ assert(yaml_emitter_initialize(&emitter));
+ if (canonical) {
+ yaml_emitter_set_canonical(&emitter, 1);
+ }
+ if (unicode) {
+ yaml_emitter_set_unicode(&emitter, 1);
+ }
+ yaml_emitter_set_output_string(&emitter, buffer, BUFFER_SIZE, &written);
+
+ while (!done)
+ {
+ if (!yaml_parser_parse(&parser, &event)) {
+ error = 1;
+ break;
+ }
+
+ done = (event.type == YAML_STREAM_END_EVENT);
+ assert(event_number < MAX_EVENTS);
+ assert(copy_event(&(events[event_number++]), &event));
+ assert(yaml_emitter_emit(&emitter, &event) ||
+ print_output(argv[number], buffer, written, count));
+ count ++;
+ }
+
+ yaml_parser_delete(&parser);
+ assert(!fclose(file));
+ yaml_emitter_delete(&emitter);
+
+ if (!error)
+ {
+ count = done = 0;
+ assert(yaml_parser_initialize(&parser));
+ yaml_parser_set_input_string(&parser, buffer, written);
+
+ while (!done)
+ {
+ assert(yaml_parser_parse(&parser, &event) || print_output(argv[number], buffer, written, count));
+ done = (event.type == YAML_STREAM_END_EVENT);
+ assert(compare_events(events+count, &event) || print_output(argv[number], buffer, written, count));
+ yaml_event_delete(&event);
+ count ++;
+ }
+ yaml_parser_delete(&parser);
+ }
+
+ for (k = 0; k < event_number; k ++) {
+ yaml_event_delete(events+k);
+ }
+
+ printf("PASSED (length: %ld)\n", (long)written);
+ print_output(argv[number], buffer, written, -1);
+ }
+
+ return 0;
+}
diff --git a/libyaml/tests/run-loader.c b/libyaml/tests/run-loader.c
new file mode 100644
index 0000000000000000000000000000000000000000..8c36b668ce203aa9c8f4a3a48a8a9802e7c1f69c
--- /dev/null
+++ b/libyaml/tests/run-loader.c
@@ -0,0 +1,63 @@
+#include <yaml.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#ifdef NDEBUG
+#undef NDEBUG
+#endif
+#include <assert.h>
+
+int
+main(int argc, char *argv[])
+{
+ int number;
+
+ if (argc < 2) {
+ printf("Usage: %s file1.yaml ...\n", argv[0]);
+ return 0;
+ }
+
+ for (number = 1; number < argc; number ++)
+ {
+ FILE *file;
+ yaml_parser_t parser;
+ yaml_document_t document;
+ int done = 0;
+ int count = 0;
+ int error = 0;
+
+ printf("[%d] Loading '%s': ", number, argv[number]);
+ fflush(stdout);
+
+ file = fopen(argv[number], "rb");
+ assert(file);
+
+ assert(yaml_parser_initialize(&parser));
+
+ yaml_parser_set_input_file(&parser, file);
+
+ while (!done)
+ {
+ if (!yaml_parser_load(&parser, &document)) {
+ error = 1;
+ break;
+ }
+
+ done = (!yaml_document_get_root_node(&document));
+
+ yaml_document_delete(&document);
+
+ if (!done) count ++;
+ }
+
+ yaml_parser_delete(&parser);
+
+ assert(!fclose(file));
+
+ printf("%s (%d documents)\n", (error ? "FAILURE" : "SUCCESS"), count);
+ }
+
+ return 0;
+}
+
diff --git a/libyaml/tests/run-parser-test-suite.c b/libyaml/tests/run-parser-test-suite.c
new file mode 100644
index 0000000000000000000000000000000000000000..5bdd66238ddd38b7e9b83f8784ba0131e02f2076
--- /dev/null
+++ b/libyaml/tests/run-parser-test-suite.c
@@ -0,0 +1,189 @@
+#include <yaml.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <assert.h>
+
+void print_escaped(yaml_char_t * str, size_t length);
+int usage(int ret);
+
+int main(int argc, char *argv[])
+{
+ FILE *input;
+ yaml_parser_t parser;
+ yaml_event_t event;
+ int flow = -1; /** default no flow style collections */
+ int i = 0;
+ int foundfile = 0;
+
+ for (i = 1; i < argc; i++) {
+ if (strncmp(argv[i], "--flow", 6) == 0) {
+ if (i+1 == argc)
+ return usage(1);
+ i++;
+ if (strncmp(argv[i], "keep", 4) == 0)
+ flow = 0;
+ else if (strncmp(argv[i], "on", 2) == 0)
+ flow = 1;
+ else if (strncmp(argv[i], "off", 3) == 0)
+ flow = -1;
+ else
+ return usage(1);
+ }
+ else if (strncmp(argv[i], "--help", 6) == 0)
+ return usage(0);
+ else if (strncmp(argv[i], "-h", 2) == 0)
+ return usage(0);
+ else if (!foundfile) {
+ input = fopen(argv[i], "rb");
+ foundfile = 1;
+ }
+ else
+ return usage(1);
+ }
+ if (!foundfile) {
+ input = stdin;
+ }
+ assert(input);
+
+ if (!yaml_parser_initialize(&parser)) {
+ fprintf(stderr, "Could not initialize the parser object\n");
+ return 1;
+ }
+ yaml_parser_set_input_file(&parser, input);
+
+ while (1) {
+ yaml_event_type_t type;
+ if (!yaml_parser_parse(&parser, &event)) {
+ if ( parser.problem_mark.line || parser.problem_mark.column ) {
+ fprintf(stderr, "Parse error: %s\nLine: %lu Column: %lu\n",
+ parser.problem,
+ (unsigned long)parser.problem_mark.line + 1,
+ (unsigned long)parser.problem_mark.column + 1);
+ }
+ else {
+ fprintf(stderr, "Parse error: %s\n", parser.problem);
+ }
+ return 1;
+ }
+ type = event.type;
+
+ if (type == YAML_NO_EVENT)
+ printf("???\n");
+ else if (type == YAML_STREAM_START_EVENT)
+ printf("+STR\n");
+ else if (type == YAML_STREAM_END_EVENT)
+ printf("-STR\n");
+ else if (type == YAML_DOCUMENT_START_EVENT) {
+ printf("+DOC");
+ if (!event.data.document_start.implicit)
+ printf(" ---");
+ printf("\n");
+ }
+ else if (type == YAML_DOCUMENT_END_EVENT) {
+ printf("-DOC");
+ if (!event.data.document_end.implicit)
+ printf(" ...");
+ printf("\n");
+ }
+ else if (type == YAML_MAPPING_START_EVENT) {
+ printf("+MAP");
+ if (flow == 0 && event.data.mapping_start.style == YAML_FLOW_MAPPING_STYLE)
+ printf(" {}");
+ else if (flow == 1)
+ printf(" {}");
+ if (event.data.mapping_start.anchor)
+ printf(" &%s", event.data.mapping_start.anchor);
+ if (event.data.mapping_start.tag)
+ printf(" <%s>", event.data.mapping_start.tag);
+ printf("\n");
+ }
+ else if (type == YAML_MAPPING_END_EVENT)
+ printf("-MAP\n");
+ else if (type == YAML_SEQUENCE_START_EVENT) {
+ printf("+SEQ");
+ if (flow == 0 && event.data.sequence_start.style == YAML_FLOW_SEQUENCE_STYLE)
+ printf(" []");
+ else if (flow == 1)
+ printf(" []");
+ if (event.data.sequence_start.anchor)
+ printf(" &%s", event.data.sequence_start.anchor);
+ if (event.data.sequence_start.tag)
+ printf(" <%s>", event.data.sequence_start.tag);
+ printf("\n");
+ }
+ else if (type == YAML_SEQUENCE_END_EVENT)
+ printf("-SEQ\n");
+ else if (type == YAML_SCALAR_EVENT) {
+ printf("=VAL");
+ if (event.data.scalar.anchor)
+ printf(" &%s", event.data.scalar.anchor);
+ if (event.data.scalar.tag)
+ printf(" <%s>", event.data.scalar.tag);
+ switch (event.data.scalar.style) {
+ case YAML_PLAIN_SCALAR_STYLE:
+ printf(" :");
+ break;
+ case YAML_SINGLE_QUOTED_SCALAR_STYLE:
+ printf(" '");
+ break;
+ case YAML_DOUBLE_QUOTED_SCALAR_STYLE:
+ printf(" \"");
+ break;
+ case YAML_LITERAL_SCALAR_STYLE:
+ printf(" |");
+ break;
+ case YAML_FOLDED_SCALAR_STYLE:
+ printf(" >");
+ break;
+ case YAML_ANY_SCALAR_STYLE:
+ abort();
+ }
+ print_escaped(event.data.scalar.value, event.data.scalar.length);
+ printf("\n");
+ }
+ else if (type == YAML_ALIAS_EVENT)
+ printf("=ALI *%s\n", event.data.alias.anchor);
+ else
+ abort();
+
+ yaml_event_delete(&event);
+
+ if (type == YAML_STREAM_END_EVENT)
+ break;
+ }
+
+ assert(!fclose(input));
+ yaml_parser_delete(&parser);
+ fflush(stdout);
+
+ return 0;
+}
+
+void print_escaped(yaml_char_t * str, size_t length)
+{
+ int i;
+ char c;
+
+ for (i = 0; i < length; i++) {
+ c = *(str + i);
+ if (c == '\\')
+ printf("\\\\");
+ else if (c == '\0')
+ printf("\\0");
+ else if (c == '\b')
+ printf("\\b");
+ else if (c == '\n')
+ printf("\\n");
+ else if (c == '\r')
+ printf("\\r");
+ else if (c == '\t')
+ printf("\\t");
+ else
+ printf("%c", c);
+ }
+}
+
+int usage(int ret) {
+ fprintf(stderr, "Usage: libyaml-parser [--flow (on|off|keep)] [<input-file>]\n");
+ return ret;
+}
diff --git a/libyaml/tests/run-parser.c b/libyaml/tests/run-parser.c
new file mode 100644
index 0000000000000000000000000000000000000000..13031121ae49228a80d974fd47d8a5404b3129e0
--- /dev/null
+++ b/libyaml/tests/run-parser.c
@@ -0,0 +1,63 @@
+#include <yaml.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#ifdef NDEBUG
+#undef NDEBUG
+#endif
+#include <assert.h>
+
+int
+main(int argc, char *argv[])
+{
+ int number;
+
+ if (argc < 2) {
+ printf("Usage: %s file1.yaml ...\n", argv[0]);
+ return 0;
+ }
+
+ for (number = 1; number < argc; number ++)
+ {
+ FILE *file;
+ yaml_parser_t parser;
+ yaml_event_t event;
+ int done = 0;
+ int count = 0;
+ int error = 0;
+
+ printf("[%d] Parsing '%s': ", number, argv[number]);
+ fflush(stdout);
+
+ file = fopen(argv[number], "rb");
+ assert(file);
+
+ assert(yaml_parser_initialize(&parser));
+
+ yaml_parser_set_input_file(&parser, file);
+
+ while (!done)
+ {
+ if (!yaml_parser_parse(&parser, &event)) {
+ error = 1;
+ break;
+ }
+
+ done = (event.type == YAML_STREAM_END_EVENT);
+
+ yaml_event_delete(&event);
+
+ count ++;
+ }
+
+ yaml_parser_delete(&parser);
+
+ assert(!fclose(file));
+
+ printf("%s (%d events)\n", (error ? "FAILURE" : "SUCCESS"), count);
+ }
+
+ return 0;
+}
+
diff --git a/libyaml/tests/run-scanner.c b/libyaml/tests/run-scanner.c
new file mode 100644
index 0000000000000000000000000000000000000000..2c79e7ccf38001b3f9104f3859b22485a21deac8
--- /dev/null
+++ b/libyaml/tests/run-scanner.c
@@ -0,0 +1,63 @@
+#include <yaml.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#ifdef NDEBUG
+#undef NDEBUG
+#endif
+#include <assert.h>
+
+int
+main(int argc, char *argv[])
+{
+ int number;
+
+ if (argc < 2) {
+ printf("Usage: %s file1.yaml ...\n", argv[0]);
+ return 0;
+ }
+
+ for (number = 1; number < argc; number ++)
+ {
+ FILE *file;
+ yaml_parser_t parser;
+ yaml_token_t token;
+ int done = 0;
+ int count = 0;
+ int error = 0;
+
+ printf("[%d] Scanning '%s': ", number, argv[number]);
+ fflush(stdout);
+
+ file = fopen(argv[number], "rb");
+ assert(file);
+
+ assert(yaml_parser_initialize(&parser));
+
+ yaml_parser_set_input_file(&parser, file);
+
+ while (!done)
+ {
+ if (!yaml_parser_scan(&parser, &token)) {
+ error = 1;
+ break;
+ }
+
+ done = (token.type == YAML_STREAM_END_TOKEN);
+
+ yaml_token_delete(&token);
+
+ count ++;
+ }
+
+ yaml_parser_delete(&parser);
+
+ assert(!fclose(file));
+
+ printf("%s (%d tokens)\n", (error ? "FAILURE" : "SUCCESS"), count);
+ }
+
+ return 0;
+}
+
diff --git a/libyaml/tests/test-reader.c b/libyaml/tests/test-reader.c
new file mode 100644
index 0000000000000000000000000000000000000000..40f8199e009f85a254ef49bc013fa0dbd048c7e6
--- /dev/null
+++ b/libyaml/tests/test-reader.c
@@ -0,0 +1,354 @@
+#include <yaml.h>
+
+YAML_DECLARE(int)
+yaml_parser_update_buffer(yaml_parser_t *parser, size_t length);
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#ifdef NDEBUG
+#undef NDEBUG
+#endif
+#include <assert.h>
+
+/*
+ * Test cases are stolen from
+ * http://www.cl.cam.ac.uk/~mgk25/ucs/examples/UTF-8-test.txt
+ */
+
+typedef struct {
+ char *title;
+ char *test;
+ int result;
+} test_case;
+
+test_case utf8_sequences[] = {
+ /* {"title", "test 1|test 2|...|test N!", (0 or 1)}, */
+
+ {"a simple test", "'test' is '\xd0\xbf\xd1\x80\xd0\xbe\xd0\xb2\xd0\xb5\xd1\x80\xd0\xba\xd0\xb0' in Russian!", 1},
+ {"an empty line", "!", 1},
+
+ {"u-0 is a control character", "\x00!", 0},
+ {"u-80 is a control character", "\xc2\x80!", 0},
+ {"u-800 is valid", "\xe0\xa0\x80!", 1},
+ {"u-10000 is valid", "\xf0\x90\x80\x80!", 1},
+ {"5 bytes sequences are not allowed", "\xf8\x88\x80\x80\x80!", 0},
+ {"6 bytes sequences are not allowed", "\xfc\x84\x80\x80\x80\x80!", 0},
+
+ {"u-7f is a control character", "\x7f!", 0},
+ {"u-7FF is valid", "\xdf\xbf!", 1},
+ {"u-FFFF is a control character", "\xef\xbf\xbf!", 0},
+ {"u-1FFFFF is too large", "\xf7\xbf\xbf\xbf!", 0},
+ {"u-3FFFFFF is 5 bytes", "\xfb\xbf\xbf\xbf\xbf!", 0},
+ {"u-7FFFFFFF is 6 bytes", "\xfd\xbf\xbf\xbf\xbf\xbf!", 0},
+
+ {"u-D7FF", "\xed\x9f\xbf!", 1},
+ {"u-E000", "\xee\x80\x80!", 1},
+ {"u-FFFD", "\xef\xbf\xbd!", 1},
+ {"u-10FFFF", "\xf4\x8f\xbf\xbf!", 1},
+ {"u-110000", "\xf4\x90\x80\x80!", 0},
+
+ {"first continuation byte", "\x80!", 0},
+ {"last continuation byte", "\xbf!", 0},
+
+ {"2 continuation bytes", "\x80\xbf!", 0},
+ {"3 continuation bytes", "\x80\xbf\x80!", 0},
+ {"4 continuation bytes", "\x80\xbf\x80\xbf!", 0},
+ {"5 continuation bytes", "\x80\xbf\x80\xbf\x80!", 0},
+ {"6 continuation bytes", "\x80\xbf\x80\xbf\x80\xbf!", 0},
+ {"7 continuation bytes", "\x80\xbf\x80\xbf\x80\xbf\x80!", 0},
+
+ {"sequence of all 64 possible continuation bytes",
+ "\x80|\x81|\x82|\x83|\x84|\x85|\x86|\x87|\x88|\x89|\x8a|\x8b|\x8c|\x8d|\x8e|\x8f|"
+ "\x90|\x91|\x92|\x93|\x94|\x95|\x96|\x97|\x98|\x99|\x9a|\x9b|\x9c|\x9d|\x9e|\x9f|"
+ "\xa0|\xa1|\xa2|\xa3|\xa4|\xa5|\xa6|\xa7|\xa8|\xa9|\xaa|\xab|\xac|\xad|\xae|\xaf|"
+ "\xb0|\xb1|\xb2|\xb3|\xb4|\xb5|\xb6|\xb7|\xb8|\xb9|\xba|\xbb|\xbc|\xbd|\xbe|\xbf!", 0},
+ {"32 first bytes of 2-byte sequences {0xc0-0xdf}",
+ "\xc0 |\xc1 |\xc2 |\xc3 |\xc4 |\xc5 |\xc6 |\xc7 |\xc8 |\xc9 |\xca |\xcb |\xcc |\xcd |\xce |\xcf |"
+ "\xd0 |\xd1 |\xd2 |\xd3 |\xd4 |\xd5 |\xd6 |\xd7 |\xd8 |\xd9 |\xda |\xdb |\xdc |\xdd |\xde |\xdf !", 0},
+ {"16 first bytes of 3-byte sequences {0xe0-0xef}",
+ "\xe0 |\xe1 |\xe2 |\xe3 |\xe4 |\xe5 |\xe6 |\xe7 |\xe8 |\xe9 |\xea |\xeb |\xec |\xed |\xee |\xef !", 0},
+ {"8 first bytes of 4-byte sequences {0xf0-0xf7}", "\xf0 |\xf1 |\xf2 |\xf3 |\xf4 |\xf5 |\xf6 |\xf7 !", 0},
+ {"4 first bytes of 5-byte sequences {0xf8-0xfb}", "\xf8 |\xf9 |\xfa |\xfb !", 0},
+ {"2 first bytes of 6-byte sequences {0xfc-0xfd}", "\xfc |\xfd !", 0},
+
+ {"sequences with last byte missing {u-0}",
+ "\xc0|\xe0\x80|\xf0\x80\x80|\xf8\x80\x80\x80|\xfc\x80\x80\x80\x80!", 0},
+ {"sequences with last byte missing {u-...FF}",
+ "\xdf|\xef\xbf|\xf7\xbf\xbf|\xfb\xbf\xbf\xbf|\xfd\xbf\xbf\xbf\xbf!", 0},
+
+ {"impossible bytes", "\xfe|\xff|\xfe\xfe\xff\xff!", 0},
+
+ {"overlong sequences {u-2f}",
+ "\xc0\xaf|\xe0\x80\xaf|\xf0\x80\x80\xaf|\xf8\x80\x80\x80\xaf|\xfc\x80\x80\x80\x80\xaf!", 0},
+
+ {"maximum overlong sequences",
+ "\xc1\xbf|\xe0\x9f\xbf|\xf0\x8f\xbf\xbf|\xf8\x87\xbf\xbf\xbf|\xfc\x83\xbf\xbf\xbf\xbf!", 0},
+
+ {"overlong representation of the NUL character",
+ "\xc0\x80|\xe0\x80\x80|\xf0\x80\x80\x80|\xf8\x80\x80\x80\x80|\xfc\x80\x80\x80\x80\x80!", 0},
+
+ {"single UTF-16 surrogates",
+ "\xed\xa0\x80|\xed\xad\xbf|\xed\xae\x80|\xed\xaf\xbf|\xed\xb0\x80|\xed\xbe\x80|\xed\xbf\xbf!", 0},
+
+ {"paired UTF-16 surrogates",
+ "\xed\xa0\x80\xed\xb0\x80|\xed\xa0\x80\xed\xbf\xbf|\xed\xad\xbf\xed\xb0\x80|"
+ "\xed\xad\xbf\xed\xbf\xbf|\xed\xae\x80\xed\xb0\x80|\xed\xae\x80\xed\xbf\xbf|"
+ "\xed\xaf\xbf\xed\xb0\x80|\xed\xaf\xbf\xed\xbf\xbf!", 0},
+
+ {"other illegal code positions", "\xef\xbf\xbe|\xef\xbf\xbf!", 0},
+
+ {NULL, NULL, 0}
+};
+
+test_case boms[] = {
+
+ /* {"title", "test!", lenth}, */
+
+ {"no bom (utf-8)", "Hi is \xd0\x9f\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82!", 13},
+ {"bom (utf-8)", "\xef\xbb\xbfHi is \xd0\x9f\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82!", 13},
+ {"bom (utf-16-le)", "\xff\xfeH\x00i\x00 \x00i\x00s\x00 \x00\x1f\x04@\x04""8\x04""2\x04""5\x04""B\x04!", 13},
+ {"bom (utf-16-be)", "\xfe\xff\x00H\x00i\x00 \x00i\x00s\x00 \x04\x1f\x04@\x04""8\x04""2\x04""5\x04""B!", 13},
+ {NULL, NULL, 0}
+};
+
+char *bom_original = "Hi is \xd0\x9f\xd1\x80\xd0\xb8\xd0\xb2\xd0\xb5\xd1\x82";
+
+int check_utf8_sequences(void)
+{
+ yaml_parser_t parser;
+ int failed = 0;
+ int k;
+ printf("checking utf-8 sequences...\n");
+ for (k = 0; utf8_sequences[k].test; k++) {
+ char *title = utf8_sequences[k].title;
+ int check = utf8_sequences[k].result;
+ int result;
+ char *start = utf8_sequences[k].test;
+ char *end = start;
+ printf("\t%s:\n", title);
+ while(1) {
+ while (*end != '|' && *end != '!') end++;
+ yaml_parser_initialize(&parser);
+ yaml_parser_set_input_string(&parser, (unsigned char *)start, end-start);
+ result = yaml_parser_update_buffer(&parser, end-start);
+ if (result != check) {
+ printf("\t\t- ");
+ failed ++;
+ }
+ else {
+ printf("\t\t+ ");
+ }
+ if (!parser.error) {
+ printf("(no error)\n");
+ }
+ else if (parser.error == YAML_READER_ERROR) {
+ if (parser.problem_value != -1) {
+ printf("(reader error: %s: #%X at %ld)\n",
+ parser.problem, parser.problem_value, (long)parser.problem_offset);
+ }
+ else {
+ printf("(reader error: %s at %ld)\n",
+ parser.problem, (long)parser.problem_offset);
+ }
+ }
+ if (*end == '!') break;
+ start = ++end;
+ yaml_parser_delete(&parser);
+ };
+ printf("\n");
+ }
+ printf("checking utf-8 sequences: %d fail(s)\n", failed);
+ return failed;
+}
+
+int check_boms(void)
+{
+ yaml_parser_t parser;
+ int failed = 0;
+ int k;
+ printf("checking boms...\n");
+ for (k = 0; boms[k].test; k++) {
+ char *title = boms[k].title;
+ int check = boms[k].result;
+ int result;
+ char *start = boms[k].test;
+ char *end = start;
+ while (*end != '!') end++;
+ printf("\t%s: ", title);
+ yaml_parser_initialize(&parser);
+ yaml_parser_set_input_string(&parser, (unsigned char *)start, end-start);
+ result = yaml_parser_update_buffer(&parser, end-start);
+ if (!result) {
+ printf("- (reader error: %s at %ld)\n", parser.problem, (long)parser.problem_offset);
+ failed++;
+ }
+ else {
+ if (parser.unread != check) {
+ printf("- (length=%ld while expected length=%d)\n", (long)parser.unread, check);
+ failed++;
+ }
+ else if (memcmp(parser.buffer.start, bom_original, check) != 0) {
+ printf("- (value '%s' does not equal to the original value '%s')\n", parser.buffer.start, bom_original);
+ failed++;
+ }
+ else {
+ printf("+\n");
+ }
+ }
+ yaml_parser_delete(&parser);
+ }
+ printf("checking boms: %d fail(s)\n", failed);
+ return failed;
+}
+
+#define LONG 100000
+
+int check_long_utf8(void)
+{
+ yaml_parser_t parser;
+ int k = 0;
+ int j;
+ int failed = 0;
+ unsigned char ch0, ch1;
+ unsigned char *buffer = (unsigned char *)malloc(3+LONG*2);
+ assert(buffer);
+ printf("checking a long utf8 sequence...\n");
+ buffer[k++] = '\xef';
+ buffer[k++] = '\xbb';
+ buffer[k++] = '\xbf';
+ for (j = 0; j < LONG; j ++) {
+ if (j % 2) {
+ buffer[k++] = '\xd0';
+ buffer[k++] = '\x90';
+ }
+ else {
+ buffer[k++] = '\xd0';
+ buffer[k++] = '\xaf';
+ }
+ }
+ yaml_parser_initialize(&parser);
+ yaml_parser_set_input_string(&parser, buffer, 3+LONG*2);
+ for (k = 0; k < LONG; k++) {
+ if (!parser.unread) {
+ if (!yaml_parser_update_buffer(&parser, 1)) {
+ printf("\treader error: %s at %ld\n", parser.problem, (long)parser.problem_offset);
+ failed = 1;
+ break;
+ }
+ }
+ if (!parser.unread) {
+ printf("\tnot enough characters at %d\n", k);
+ failed = 1;
+ break;
+ }
+ if (k % 2) {
+ ch0 = '\xd0';
+ ch1 = '\x90';
+ }
+ else {
+ ch0 = '\xd0';
+ ch1 = '\xaf';
+ }
+ if (parser.buffer.pointer[0] != ch0 || parser.buffer.pointer[1] != ch1) {
+ printf("\tincorrect UTF-8 sequence: %X %X instead of %X %X\n",
+ (int)parser.buffer.pointer[0], (int)parser.buffer.pointer[1],
+ (int)ch0, (int)ch1);
+ failed = 1;
+ break;
+ }
+ parser.buffer.pointer += 2;
+ parser.unread -= 1;
+ }
+ if (!failed) {
+ if (!yaml_parser_update_buffer(&parser, 1)) {
+ printf("\treader error: %s at %ld\n", parser.problem, (long)parser.problem_offset);
+ failed = 1;
+ }
+ else if (parser.buffer.pointer[0] != '\0') {
+ printf("\texpected NUL, found %X (eof=%d, unread=%ld)\n", (int)parser.buffer.pointer[0], parser.eof, (long)parser.unread);
+ failed = 1;
+ }
+ }
+ yaml_parser_delete(&parser);
+ free(buffer);
+ printf("checking a long utf8 sequence: %d fail(s)\n", failed);
+ return failed;
+}
+
+int check_long_utf16(void)
+{
+ yaml_parser_t parser;
+ int k = 0;
+ int j;
+ int failed = 0;
+ unsigned char ch0, ch1;
+ unsigned char *buffer = (unsigned char *)malloc(2+LONG*2);
+ assert(buffer);
+ printf("checking a long utf16 sequence...\n");
+ buffer[k++] = '\xff';
+ buffer[k++] = '\xfe';
+ for (j = 0; j < LONG; j ++) {
+ if (j % 2) {
+ buffer[k++] = '\x10';
+ buffer[k++] = '\x04';
+ }
+ else {
+ buffer[k++] = '/';
+ buffer[k++] = '\x04';
+ }
+ }
+ yaml_parser_initialize(&parser);
+ yaml_parser_set_input_string(&parser, buffer, 2+LONG*2);
+ for (k = 0; k < LONG; k++) {
+ if (!parser.unread) {
+ if (!yaml_parser_update_buffer(&parser, 1)) {
+ printf("\treader error: %s at %ld\n", parser.problem, (long)parser.problem_offset);
+ failed = 1;
+ break;
+ }
+ }
+ if (!parser.unread) {
+ printf("\tnot enough characters at %d\n", k);
+ failed = 1;
+ break;
+ }
+ if (k % 2) {
+ ch0 = '\xd0';
+ ch1 = '\x90';
+ }
+ else {
+ ch0 = '\xd0';
+ ch1 = '\xaf';
+ }
+ if (parser.buffer.pointer[0] != ch0 || parser.buffer.pointer[1] != ch1) {
+ printf("\tincorrect UTF-8 sequence: %X %X instead of %X %X\n",
+ (int)parser.buffer.pointer[0], (int)parser.buffer.pointer[1],
+ (int)ch0, (int)ch1);
+ failed = 1;
+ break;
+ }
+ parser.buffer.pointer += 2;
+ parser.unread -= 1;
+ }
+ if (!failed) {
+ if (!yaml_parser_update_buffer(&parser, 1)) {
+ printf("\treader error: %s at %ld\n", parser.problem, (long)parser.problem_offset);
+ failed = 1;
+ }
+ else if (parser.buffer.pointer[0] != '\0') {
+ printf("\texpected NUL, found %X (eof=%d, unread=%ld)\n", (int)parser.buffer.pointer[0], parser.eof, (long)parser.unread);
+ failed = 1;
+ }
+ }
+ yaml_parser_delete(&parser);
+ free(buffer);
+ printf("checking a long utf16 sequence: %d fail(s)\n", failed);
+ return failed;
+}
+
+int
+main(void)
+{
+ return check_utf8_sequences() + check_boms() + check_long_utf8() + check_long_utf16();
+}
diff --git a/libyaml/tests/test-version.c b/libyaml/tests/test-version.c
new file mode 100644
index 0000000000000000000000000000000000000000..0c598377f95f609cdfc5123e79e22d3f3f1fbe0e
--- /dev/null
+++ b/libyaml/tests/test-version.c
@@ -0,0 +1,29 @@
+#include <yaml.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#ifdef NDEBUG
+#undef NDEBUG
+#endif
+#include <assert.h>
+
+int
+main(void)
+{
+ int major = -1;
+ int minor = -1;
+ int patch = -1;
+ char buf[64];
+
+ yaml_get_version(&major, &minor, &patch);
+ sprintf(buf, "%d.%d.%d", major, minor, patch);
+ assert(strcmp(buf, yaml_get_version_string()) == 0);
+
+ /* Print structure sizes. */
+ printf("sizeof(token) = %ld\n", (long)sizeof(yaml_token_t));
+ printf("sizeof(event) = %ld\n", (long)sizeof(yaml_event_t));
+ printf("sizeof(parser) = %ld\n", (long)sizeof(yaml_parser_t));
+
+ return 0;
+}
diff --git a/libyaml/yaml-0.1.pc.in b/libyaml/yaml-0.1.pc.in
new file mode 100644
index 0000000000000000000000000000000000000000..70c80084dd42731d494fca8f2c198e6972df976c
--- /dev/null
+++ b/libyaml/yaml-0.1.pc.in
@@ -0,0 +1,10 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+includedir=@includedir@
+libdir=@libdir@
+
+Name: LibYAML
+Description: Library to parse and emit YAML
+Version: @PACKAGE_VERSION@
+Cflags: -I${includedir}
+Libs: -L${libdir} -lyaml
diff --git a/libyaml/yamlConfig.cmake.in b/libyaml/yamlConfig.cmake.in
new file mode 100644
index 0000000000000000000000000000000000000000..dd3f8ee252855c316a809ef081c233500f33db2b
--- /dev/null
+++ b/libyaml/yamlConfig.cmake.in
@@ -0,0 +1,16 @@
+# Config file for the yaml library.
+#
+# It defines the following variables:
+# yaml_LIBRARIES - libraries to link against
+
+@PACKAGE_INIT@
+
+set_and_check(yaml_TARGETS "@PACKAGE_CONFIG_DIR_CONFIG@/yamlTargets.cmake")
+
+if(NOT yaml_TARGETS_IMPORTED)
+ set(yaml_TARGETS_IMPORTED 1)
+ include(${yaml_TARGETS})
+endif()
+
+set(yaml_LIBRARIES yaml)
+