79 if (!new_start)
return 0;
81 memset(new_start + (*end - *start), 0, *end - *start);
83 *pointer = new_start + (*pointer - *start);
84 *end = new_start + (*end - *start)*2;
99 if (*b_start == *b_pointer)
102 while (*a_end - *a_pointer <= *b_pointer - *b_start) {
107 memcpy(*a_pointer, *b_start, *b_pointer - *b_start);
108 *a_pointer += *b_pointer - *b_start;
120 void *new_start =
yaml_realloc(*start, ((
char *)*end - (
char *)*start)*2);
122 if (!new_start)
return 0;
124 *
top = (
char *)new_start + ((
char *)*
top - (
char *)*start);
125 *end = (
char *)new_start + ((
char *)*end - (
char *)*start)*2;
140 if (*start == *
head && *
tail == *end) {
142 ((
char *)*end - (
char *)*start)*2);
144 if (!new_start)
return 0;
146 *
head = (
char *)new_start + ((
char *)*
head - (
char *)*start);
147 *
tail = (
char *)new_start + ((
char *)*
tail - (
char *)*start);
148 *end = (
char *)new_start + ((
char *)*end - (
char *)*start)*2;
204 STACK_DEL(parser, parser->tag_directives);
228 while (!
STACK_EMPTY(parser, parser->tag_directives)) {
233 STACK_DEL(parser, parser->tag_directives);
287 assert(!parser->read_handler);
291 parser->read_handler_data = parser;
293 parser->input.string.start =
input;
294 parser->input.string.current =
input;
306 assert(!parser->read_handler);
310 parser->read_handler_data = parser;
312 parser->input.file = file;
324 assert(!parser->read_handler);
327 parser->read_handler = handler;
328 parser->read_handler_data = data;
339 assert(!parser->encoding);
341 parser->encoding = encoding;
376 STACK_DEL(emitter, emitter->tag_directives);
398 while (!
STACK_EMPTY(emitter, emitter->tag_directives)) {
403 STACK_DEL(emitter, emitter->tag_directives);
452 unsigned char *
output,
size_t size,
size_t *size_written)
455 assert(!emitter->write_handler);
459 emitter->write_handler_data = emitter;
461 emitter->output.string.buffer =
output;
462 emitter->output.string.size =
size;
463 emitter->output.string.size_written = size_written;
475 assert(!emitter->write_handler);
479 emitter->write_handler_data = emitter;
481 emitter->output.file = file;
493 assert(!emitter->write_handler);
496 emitter->write_handler = handler;
497 emitter->write_handler_data = data;
508 assert(!emitter->encoding);
510 emitter->encoding = encoding;
534 emitter->best_indent = (1 < indent && indent < 10) ? indent : 2;
546 emitter->best_width = (width >= 0) ? width : -1;
558 emitter->unicode = (unicode != 0);
570 emitter->line_break = line_break;
625 while (pointer < end) {
632 width = (octet & 0x80) == 0x00 ? 1 :
633 (octet & 0xE0) == 0xC0 ? 2 :
634 (octet & 0xF0) == 0xE0 ? 3 :
635 (octet & 0xF8) == 0xF0 ? 4 : 0;
636 value = (octet & 0x80) == 0x00 ? octet & 0x7F :
637 (octet & 0xE0) == 0xC0 ? octet & 0x1F :
638 (octet & 0xF0) == 0xE0 ? octet & 0x0F :
639 (octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
640 if (!width)
return 0;
641 if (pointer+width > end)
return 0;
642 for (k = 1; k < width; k ++) {
644 if ((octet & 0xC0) != 0x80)
return 0;
645 value = (value << 6) + (octet & 0x3F);
647 if (!((width == 1) ||
648 (width == 2 && value >= 0x80) ||
649 (width == 3 && value >= 0x800) ||
650 (width == 4 && value >= 0x10000)))
return 0;
715 assert((tag_directives_start && tag_directives_end) ||
716 (tag_directives_start == tag_directives_end));
719 if (version_directive) {
721 if (!version_directive_copy)
goto error;
722 version_directive_copy->
major = version_directive->major;
723 version_directive_copy->
minor = version_directive->minor;
726 if (tag_directives_start != tag_directives_end) {
730 for (tag_directive = tag_directives_start;
731 tag_directive != tag_directives_end; tag_directive ++) {
743 if (!
PUSH(&context, tag_directives_copy, value))
751 tag_directives_copy.start, tag_directives_copy.top,
758 while (!
STACK_EMPTY(context, tag_directives_copy)) {
818 int plain_implicit,
int quoted_implicit,
833 if (!anchor_copy)
goto error;
839 if (!tag_copy)
goto error;
843 value_length =
strlen((
char *)value);
846 value_length = (size_t)length;
851 if (!value_copy)
goto error;
852 memcpy(value_copy, value, value_length);
853 value_copy[value_length] =
'\0';
856 plain_implicit, quoted_implicit, style,
mark,
mark);
886 if (!anchor_copy)
goto error;
892 if (!tag_copy)
goto error;
941 if (!anchor_copy)
goto error;
947 if (!tag_copy)
goto error;
992 yaml_free(event->data.document_start.version_directive);
993 for (tag_directive = event->data.document_start.tag_directives.start;
994 tag_directive != event->data.document_start.tag_directives.end;
999 yaml_free(event->data.document_start.tag_directives.start);
1013 yaml_free(event->data.sequence_start.anchor);
1014 yaml_free(event->data.sequence_start.tag);
1018 yaml_free(event->data.mapping_start.anchor);
1019 yaml_free(event->data.mapping_start.tag);
1038 int start_implicit,
int end_implicit)
1058 assert((tag_directives_start && tag_directives_end) ||
1059 (tag_directives_start == tag_directives_end));
1064 if (version_directive) {
1066 if (!version_directive_copy)
goto error;
1067 version_directive_copy->
major = version_directive->major;
1068 version_directive_copy->
minor = version_directive->minor;
1071 if (tag_directives_start != tag_directives_end) {
1075 for (tag_directive = tag_directives_start;
1076 tag_directive != tag_directives_end; tag_directive ++) {
1088 if (!
PUSH(&context, tag_directives_copy, value))
1095 DOCUMENT_INIT(*document, nodes.start, nodes.end, version_directive_copy,
1096 tag_directives_copy.start, tag_directives_copy.top,
1097 start_implicit, end_implicit,
mark,
mark);
1104 while (!
STACK_EMPTY(&context, tag_directives_copy)) {
1109 STACK_DEL(&context, tag_directives_copy);
1135 switch (node.
type) {
1152 for (tag_directive = document->tag_directives.start;
1153 tag_directive != document->tag_directives.end;
1158 yaml_free(document->tag_directives.start);
1172 if (index > 0 && document->nodes.start + index <= document->nodes.top) {
1173 return document->nodes.start + index - 1;
1187 if (document->nodes.top != document->nodes.start) {
1188 return document->nodes.start;
1209 size_t value_length;
1221 if (!tag_copy)
goto error;
1224 value_length =
strlen((
char *)value);
1227 value_length = (size_t)length;
1232 if (!value_copy)
goto error;
1233 memcpy(value_copy, value, value_length);
1234 value_copy[value_length] =
'\0';
1237 if (!
PUSH(&context, document->nodes, node))
goto error;
1239 ret = document->nodes.top - document->nodes.start;
1240 #if PTRDIFF_MAX > INT_MAX 1241 if (ret > INT_MAX)
goto error;
1281 if (!tag_copy)
goto error;
1287 if (!
PUSH(&context, document->nodes, node))
goto error;
1289 ret = document->nodes.top - document->nodes.start;
1290 #if PTRDIFF_MAX > INT_MAX 1291 if (ret > INT_MAX)
goto error;
1331 if (!tag_copy)
goto error;
1337 if (!
PUSH(&context, document->nodes, node))
goto error;
1339 ret = document->nodes.top - document->nodes.start;
1340 #if PTRDIFF_MAX > INT_MAX 1341 if (ret > INT_MAX)
goto error;
1358 int sequence,
int item)
1366 && document->nodes.start + sequence <= document->nodes.top);
1370 assert(item > 0 && document->nodes.start + item <= document->nodes.top);
1374 document->nodes.start[sequence-1].data.sequence.items, item))
1386 int mapping,
int key,
int value)
1396 && document->nodes.start + mapping <= document->nodes.top);
1400 assert(
key > 0 && document->nodes.start + key <= document->nodes.top);
1402 assert(value > 0 && document->nodes.start + value <= document->nodes.top);
1409 document->nodes.start[mapping-1].data.mapping.pairs, pair))
#define MAPPING_START_EVENT_INIT(event, event_anchor, event_tag, event_implicit, event_style, start_mark, end_mark)
yaml_strdup(const yaml_char_t *str)
yaml_stream_end_event_initialize(yaml_event_t *event)
Create the STREAM-END event.
#define STREAM_END_EVENT_INIT(event, start_mark, end_mark)
static int yaml_file_read_handler(void *data, unsigned char *buffer, size_t size, size_t *size_read)
yaml_event_delete(yaml_event_t *event)
Free any memory allocated for an event object.
size_t strlen(const char *)
yaml_document_add_mapping(yaml_document_t *document, yaml_char_t *tag, yaml_mapping_style_t style)
Create a MAPPING node and attach it to the document.
#define INPUT_RAW_BUFFER_SIZE
enum yaml_encoding_e yaml_encoding_t
The stream encoding.
static int yaml_string_write_handler(void *data, unsigned char *buffer, size_t size)
yaml_parser_set_encoding(yaml_parser_t *parser, yaml_encoding_t encoding)
Set the source encoding.
enum yaml_sequence_style_e yaml_sequence_style_t
Sequence styles.
yaml_scalar_event_initialize(yaml_event_t *event, yaml_char_t *anchor, yaml_char_t *tag, yaml_char_t *value, int length, int plain_implicit, int quoted_implicit, yaml_scalar_style_t style)
Create a SCALAR event.
yaml_string_extend(yaml_char_t **start, yaml_char_t **pointer, yaml_char_t **end)
yaml_parser_set_input_string(yaml_parser_t *parser, const unsigned char *input, size_t size)
Set a string input.
int yaml_write_handler_t(void *data, unsigned char *buffer, size_t size)
The prototype of a write handler.
yaml_emitter_set_output(yaml_emitter_t *emitter, yaml_write_handler_t *handler, void *data)
Set a generic output handler.
#define STREAM_START_EVENT_INIT(event, event_encoding, start_mark, end_mark)
static int yaml_check_utf8(yaml_char_t *start, size_t length)
int yaml_read_handler_t(void *data, unsigned char *buffer, size_t size, size_t *size_read)
The prototype of a read handler.
yaml_node_type_t type
The node type.
struct yaml_node_s::@61::@64 mapping
The mapping parameters (for YAML_MAPPING_NODE).
#define INITIAL_STACK_SIZE
unsigned char yaml_char_t
The character type (UTF-8 octet).
The version directive data.
yaml_parser_delete(yaml_parser_t *parser)
Destroy a parser.
yaml_queue_extend(void **start, void **head, void **tail, void **end)
yaml_char_t * prefix
The tag prefix.
yaml_stream_start_event_initialize(yaml_event_t *event, yaml_encoding_t encoding)
Create the STREAM-START event.
yaml_emitter_set_break(yaml_emitter_t *emitter, yaml_break_t line_break)
Set the preferred line break.
yaml_alias_event_initialize(yaml_event_t *event, yaml_char_t *anchor)
Create an ALIAS event.
An element of a mapping node.
#define OUTPUT_RAW_BUFFER_SIZE
#define SCALAR_NODE_INIT(node, node_tag, node_value, node_length, node_style, start_mark, end_mark)
yaml_document_delete(yaml_document_t *document)
Delete a YAML document and all its nodes.
int yaml_node_item_t
An element of a sequence node.
#define SEQUENCE_END_EVENT_INIT(event, start_mark, end_mark)
yaml_document_append_mapping_pair(yaml_document_t *document, int mapping, int key, int value)
Add a pair of a key and a value to a MAPPING node.
RUBY_EXTERN void * memmove(void *, const void *, size_t)
yaml_document_append_sequence_item(yaml_document_t *document, int sequence, int item)
Add an item to a SEQUENCE node.
#define DEQUEUE(context, queue)
union yaml_parser_s::@69 input
Standard (string or file) input data.
yaml_get_version_string(void)
Get the library version as a string.
#define STACK_EMPTY(context, stack)
static unsigned char * output
union yaml_emitter_s::@80 output
Standard (string or file) output data.
int key
The key of the element.
#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)
FILE * file
File output data.
#define YAML_DEFAULT_SEQUENCE_TAG
The default sequence tag is !!seq.
#define QUEUE_EMPTY(context, queue)
static int yaml_file_write_handler(void *data, unsigned char *buffer, size_t size)
#define BUFFER_DEL(context, buffer)
#define OUTPUT_BUFFER_SIZE
yaml_emitter_set_encoding(yaml_emitter_t *emitter, yaml_encoding_t encoding)
Set the output encoding.
enum yaml_error_type_e yaml_error_type_t
Many bad things could happen with the parser and emitter.
static VALUE canonical(VALUE self)
#define MAPPING_NODE_INIT(node, node_tag, node_pairs_start, node_pairs_end, node_style, start_mark, end_mark)
union yaml_node_s::@61 data
The node data.
int major
The major version number.
yaml_emitter_set_output_string(yaml_emitter_t *emitter, unsigned char *output, size_t size, size_t *size_written)
Set a string output.
yaml_char_t * tag
The node tag.
enum yaml_scalar_style_e yaml_scalar_style_t
Scalar styles.
static int yaml_string_read_handler(void *data, unsigned char *buffer, size_t size, size_t *size_read)
yaml_token_delete(yaml_token_t *token)
Free any memory allocated for a token object.
yaml_sequence_end_event_initialize(yaml_event_t *event)
Create a SEQUENCE-END event.
yaml_parser_set_input_file(yaml_parser_t *parser, FILE *file)
Set a file input.
#define ALIAS_EVENT_INIT(event, event_anchor, start_mark, end_mark)
yaml_document_get_node(yaml_document_t *document, int index)
Get a document node.
#define YAML_DECLARE(type)
The public API declaration.
#define STACK_DEL(context, stack)
#define BUFFER_INIT(context, buffer, size)
yaml_parser_set_input(yaml_parser_t *parser, yaml_read_handler_t *handler, void *data)
Set a generic input handler.
#define DOCUMENT_END_EVENT_INIT(event, event_implicit, start_mark, end_mark)
#define MAPPING_END_EVENT_INIT(event, start_mark, end_mark)
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)
Create a YAML document.
#define SEQUENCE_START_EVENT_INIT(event, event_anchor, event_tag, event_implicit, event_style, start_mark, end_mark)
struct yaml_node_s::@61::@62 scalar
The scalar parameters (for YAML_SCALAR_NODE).
yaml_char_t * handle
The tag handle.
yaml_document_end_event_initialize(yaml_event_t *event, int implicit)
Create the DOCUMENT-END event.
yaml_emitter_set_width(yaml_emitter_t *emitter, int width)
Set the preferred line width.
struct yaml_emitter_s::@80::@91 string
String output data.
yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical)
Set if the output should be in the "canonical" format as in the YAML specification.
yaml_realloc(void *ptr, size_t size)
int value
The value of the element.
#define QUEUE_DEL(context, queue)
yaml_node_item_t * start
The beginning of the stack.
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-START event.
struct yaml_parser_s::@69::@79 string
String input data.
yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode)
Set if unescaped non-ASCII characters are allowed.
FILE * file
File input data.
yaml_mapping_start_event_initialize(yaml_event_t *event, yaml_char_t *anchor, yaml_char_t *tag, int implicit, yaml_mapping_style_t style)
Create a MAPPING-START event.
struct yaml_node_s::@61::@63 sequence
The sequence parameters (for YAML_SEQUENCE_NODE).
#define INITIAL_QUEUE_SIZE
yaml_document_add_scalar(yaml_document_t *document, yaml_char_t *tag, yaml_char_t *value, int length, yaml_scalar_style_t style)
Create a SCALAR node and attach it to the document.
#define QUEUE_INIT(context, queue, size)
#define YAML_DEFAULT_SCALAR_TAG
The default scalar tag is !!str.
yaml_parser_initialize(yaml_parser_t *parser)
Initialize a parser.
int minor
The minor version number.
#define POP(context, stack)
yaml_emitter_set_output_file(yaml_emitter_t *emitter, FILE *file)
Set a file output.
#define INPUT_BUFFER_SIZE
static VALUE mark(VALUE self)
#define DOCUMENT_START_EVENT_INIT(event, event_version_directive, event_tag_directives_start, event_tag_directives_end, event_implicit, start_mark, end_mark)
yaml_mapping_end_event_initialize(yaml_event_t *event)
Create a MAPPING-END event.
#define SEQUENCE_NODE_INIT(node, node_tag, node_items_start, node_items_end, node_style, start_mark, end_mark)
#define assert(condition)
yaml_document_add_sequence(yaml_document_t *document, yaml_char_t *tag, yaml_sequence_style_t style)
Create a SEQUENCE node and attach it to the document.
yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent)
Set the indentation increment.
#define YAML_VERSION_MINOR
#define STACK_INIT(context, stack, size)
#define YAML_DEFAULT_MAPPING_TAG
The default mapping tag is !!map.
yaml_get_version(int *major, int *minor, int *patch)
Get the library version numbers.
enum yaml_mapping_style_e yaml_mapping_style_t
Mapping styles.
#define YAML_VERSION_STRING
#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)
yaml_emitter_initialize(yaml_emitter_t *emitter)
Initialize an emitter.
#define YAML_VERSION_MAJOR
yaml_emitter_delete(yaml_emitter_t *emitter)
Destroy an emitter.
yaml_document_get_root_node(yaml_document_t *document)
Get the root object.
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 YAML_VERSION_PATCH
enum yaml_break_e yaml_break_t
Line break types.
yaml_sequence_start_event_initialize(yaml_event_t *event, yaml_char_t *anchor, yaml_char_t *tag, int implicit, yaml_sequence_style_t style)
Create a SEQUENCE-START event.
yaml_stack_extend(void **start, void **top, void **end)