yaml.h

Go to the documentation of this file.

#ifndef YAML_H
#define YAML_H

#ifdef __cplusplus
extern "C" {
#endif

#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#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

YAML_DECLARE(const char *)
yaml_get_version_string(void);

YAML_DECLARE(void)
yaml_get_version(int *major, int *minor, int *patch);

typedef unsigned char yaml_char_t;

typedef struct yaml_version_directive_s {
    int major;
    int minor;
} yaml_version_directive_t;

typedef struct yaml_tag_directive_s {
    yaml_char_t *handle;
    yaml_char_t *prefix;
} yaml_tag_directive_t;

typedef enum yaml_encoding_e {
    YAML_ANY_ENCODING,
    YAML_UTF8_ENCODING,
    YAML_UTF16LE_ENCODING,
    YAML_UTF16BE_ENCODING
} yaml_encoding_t;

typedef enum yaml_break_e {
    YAML_ANY_BREAK,
    YAML_CR_BREAK,
    YAML_LN_BREAK,
    YAML_CRLN_BREAK
} yaml_break_t;

typedef enum yaml_error_type_e {
    YAML_NO_ERROR,

    YAML_MEMORY_ERROR,

    YAML_READER_ERROR,
    YAML_SCANNER_ERROR,
    YAML_PARSER_ERROR,
    YAML_COMPOSER_ERROR,

    YAML_WRITER_ERROR,
    YAML_EMITTER_ERROR
} yaml_error_type_t;

typedef struct yaml_mark_s {
    size_t index;

    size_t line;

    size_t column;
} yaml_mark_t;

typedef enum yaml_scalar_style_e {
    YAML_ANY_SCALAR_STYLE,

    YAML_PLAIN_SCALAR_STYLE,

    YAML_SINGLE_QUOTED_SCALAR_STYLE,
    YAML_DOUBLE_QUOTED_SCALAR_STYLE,

    YAML_LITERAL_SCALAR_STYLE,
    YAML_FOLDED_SCALAR_STYLE
} yaml_scalar_style_t;

typedef enum yaml_sequence_style_e {
    YAML_ANY_SEQUENCE_STYLE,

    YAML_BLOCK_SEQUENCE_STYLE,
    YAML_FLOW_SEQUENCE_STYLE
} yaml_sequence_style_t;

typedef enum yaml_mapping_style_e {
    YAML_ANY_MAPPING_STYLE,

    YAML_BLOCK_MAPPING_STYLE,
    YAML_FLOW_MAPPING_STYLE
/*    YAML_FLOW_SET_MAPPING_STYLE   */
} yaml_mapping_style_t;

typedef enum yaml_token_type_e {
    YAML_NO_TOKEN,

    YAML_STREAM_START_TOKEN,
    YAML_STREAM_END_TOKEN,

    YAML_VERSION_DIRECTIVE_TOKEN,
    YAML_TAG_DIRECTIVE_TOKEN,
    YAML_DOCUMENT_START_TOKEN,
    YAML_DOCUMENT_END_TOKEN,

    YAML_BLOCK_SEQUENCE_START_TOKEN,
    YAML_BLOCK_MAPPING_START_TOKEN,
    YAML_BLOCK_END_TOKEN,

    YAML_FLOW_SEQUENCE_START_TOKEN,
    YAML_FLOW_SEQUENCE_END_TOKEN,
    YAML_FLOW_MAPPING_START_TOKEN,
    YAML_FLOW_MAPPING_END_TOKEN,

    YAML_BLOCK_ENTRY_TOKEN,
    YAML_FLOW_ENTRY_TOKEN,
    YAML_KEY_TOKEN,
    YAML_VALUE_TOKEN,

    YAML_ALIAS_TOKEN,
    YAML_ANCHOR_TOKEN,
    YAML_TAG_TOKEN,
    YAML_SCALAR_TOKEN
} yaml_token_type_t;

typedef struct yaml_token_s {

    yaml_token_type_t type;

    union {

        struct {
            yaml_encoding_t encoding;
        } stream_start;

        struct {
            yaml_char_t *value;
        } alias;

        struct {
            yaml_char_t *value;
        } anchor;

        struct {
            yaml_char_t *handle;
            yaml_char_t *suffix;
        } tag;

        struct {
            yaml_char_t *value;
            size_t length;
            yaml_scalar_style_t style;
        } scalar;

        struct {
            int major;
            int minor;
        } version_directive;

        struct {
            yaml_char_t *handle;
            yaml_char_t *prefix;
        } tag_directive;

    } data;

    yaml_mark_t start_mark;
    yaml_mark_t end_mark;

} yaml_token_t;

YAML_DECLARE(void)
yaml_token_delete(yaml_token_t *token);

typedef enum yaml_event_type_e {
    YAML_NO_EVENT,

    YAML_STREAM_START_EVENT,
    YAML_STREAM_END_EVENT,

    YAML_DOCUMENT_START_EVENT,
    YAML_DOCUMENT_END_EVENT,

    YAML_ALIAS_EVENT,
    YAML_SCALAR_EVENT,

    YAML_SEQUENCE_START_EVENT,
    YAML_SEQUENCE_END_EVENT,

    YAML_MAPPING_START_EVENT,
    YAML_MAPPING_END_EVENT
} yaml_event_type_t;

typedef struct yaml_event_s {

    yaml_event_type_t type;

    union {
        
        struct {
            yaml_encoding_t encoding;
        } stream_start;

        struct {
            yaml_version_directive_t *version_directive;

            struct {
                yaml_tag_directive_t *start;
                yaml_tag_directive_t *end;
            } tag_directives;

            int implicit;
        } document_start;

        struct {
            int implicit;
        } document_end;

        struct {
            yaml_char_t *anchor;
        } alias;

        struct {
            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;
        } scalar;

        struct {
            yaml_char_t *anchor;
            yaml_char_t *tag;
            int implicit;
            yaml_sequence_style_t style;
        } sequence_start;

        struct {
            yaml_char_t *anchor;
            yaml_char_t *tag;
            int implicit;
            yaml_mapping_style_t style;
        } mapping_start;

    } data;

    yaml_mark_t start_mark;
    yaml_mark_t end_mark;

} yaml_event_t;

YAML_DECLARE(int)
yaml_stream_start_event_initialize(yaml_event_t *event,
        yaml_encoding_t encoding);

YAML_DECLARE(int)
yaml_stream_end_event_initialize(yaml_event_t *event);

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);

YAML_DECLARE(int)
yaml_document_end_event_initialize(yaml_event_t *event, int implicit);

YAML_DECLARE(int)
yaml_alias_event_initialize(yaml_event_t *event, const yaml_char_t *anchor);

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_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_DECLARE(int)
yaml_sequence_end_event_initialize(yaml_event_t *event);

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_DECLARE(int)
yaml_mapping_end_event_initialize(yaml_event_t *event);

YAML_DECLARE(void)
yaml_event_delete(yaml_event_t *event);

#define YAML_NULL_TAG       "tag:yaml.org,2002:null"

#define YAML_BOOL_TAG       "tag:yaml.org,2002:bool"

#define YAML_STR_TAG        "tag:yaml.org,2002:str"

#define YAML_INT_TAG        "tag:yaml.org,2002:int"

#define YAML_FLOAT_TAG      "tag:yaml.org,2002:float"

#define YAML_TIMESTAMP_TAG  "tag:yaml.org,2002:timestamp"

#define YAML_SEQ_TAG        "tag:yaml.org,2002:seq"

#define YAML_MAP_TAG        "tag:yaml.org,2002:map"

#define YAML_DEFAULT_SCALAR_TAG     YAML_STR_TAG

#define YAML_DEFAULT_SEQUENCE_TAG   YAML_SEQ_TAG

#define YAML_DEFAULT_MAPPING_TAG    YAML_MAP_TAG

typedef enum yaml_node_type_e {
    YAML_NO_NODE,

    YAML_SCALAR_NODE,
    YAML_SEQUENCE_NODE,
    YAML_MAPPING_NODE
} yaml_node_type_t;

typedef struct yaml_node_s yaml_node_t;

typedef int yaml_node_item_t;

typedef struct yaml_node_pair_s {
    int key;
    int value;
} yaml_node_pair_t;

struct yaml_node_s {

    yaml_node_type_t type;

    yaml_char_t *tag;

    union {
        
        struct {
            yaml_char_t *value;
            size_t length;
            yaml_scalar_style_t style;
        } scalar;

        struct {
            struct {
                yaml_node_item_t *start;
                yaml_node_item_t *end;
                yaml_node_item_t *top;
            } items;
            yaml_sequence_style_t style;
        } sequence;

        struct {
            struct {
                yaml_node_pair_t *start;
                yaml_node_pair_t *end;
                yaml_node_pair_t *top;
            } pairs;
            yaml_mapping_style_t style;
        } mapping;

    } data;

    yaml_mark_t start_mark;
    yaml_mark_t end_mark;

};

typedef struct yaml_document_s {

    struct {
        yaml_node_t *start;
        yaml_node_t *end;
        yaml_node_t *top;
    } nodes;

    yaml_version_directive_t *version_directive;

    struct {
        yaml_tag_directive_t *start;
        yaml_tag_directive_t *end;
    } tag_directives;

    int start_implicit;
    int end_implicit;

    yaml_mark_t start_mark;
    yaml_mark_t end_mark;

} yaml_document_t;

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);

YAML_DECLARE(void)
yaml_document_delete(yaml_document_t *document);

YAML_DECLARE(yaml_node_t *)
yaml_document_get_node(yaml_document_t *document, int index);

YAML_DECLARE(yaml_node_t *)
yaml_document_get_root_node(yaml_document_t *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);

YAML_DECLARE(int)
yaml_document_add_sequence(yaml_document_t *document,
        const yaml_char_t *tag, yaml_sequence_style_t style);

YAML_DECLARE(int)
yaml_document_add_mapping(yaml_document_t *document,
        const yaml_char_t *tag, yaml_mapping_style_t style);

YAML_DECLARE(int)
yaml_document_append_sequence_item(yaml_document_t *document,
        int sequence, int item);

YAML_DECLARE(int)
yaml_document_append_mapping_pair(yaml_document_t *document,
        int mapping, int key, int value);

typedef int yaml_read_handler_t(void *data, unsigned char *buffer, size_t size,
        size_t *size_read);

typedef struct yaml_simple_key_s {
    int possible;

    int required;

    size_t token_number;

    yaml_mark_t mark;
} yaml_simple_key_t;

typedef enum yaml_parser_state_e {
    YAML_PARSE_STREAM_START_STATE,
    YAML_PARSE_IMPLICIT_DOCUMENT_START_STATE,
    YAML_PARSE_DOCUMENT_START_STATE,
    YAML_PARSE_DOCUMENT_CONTENT_STATE,
    YAML_PARSE_DOCUMENT_END_STATE,

    YAML_PARSE_BLOCK_NODE_STATE,
    YAML_PARSE_BLOCK_NODE_OR_INDENTLESS_SEQUENCE_STATE,
    YAML_PARSE_FLOW_NODE_STATE,
    YAML_PARSE_BLOCK_SEQUENCE_FIRST_ENTRY_STATE,
    YAML_PARSE_BLOCK_SEQUENCE_ENTRY_STATE,

    YAML_PARSE_INDENTLESS_SEQUENCE_ENTRY_STATE,
    YAML_PARSE_BLOCK_MAPPING_FIRST_KEY_STATE,
    YAML_PARSE_BLOCK_MAPPING_KEY_STATE,
    YAML_PARSE_BLOCK_MAPPING_VALUE_STATE,
    YAML_PARSE_FLOW_SEQUENCE_FIRST_ENTRY_STATE,

    YAML_PARSE_FLOW_SEQUENCE_ENTRY_STATE,
    YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_KEY_STATE,
    YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_VALUE_STATE,
    YAML_PARSE_FLOW_SEQUENCE_ENTRY_MAPPING_END_STATE,
    YAML_PARSE_FLOW_MAPPING_FIRST_KEY_STATE,
    YAML_PARSE_FLOW_MAPPING_KEY_STATE,
    YAML_PARSE_FLOW_MAPPING_VALUE_STATE,
    YAML_PARSE_FLOW_MAPPING_EMPTY_VALUE_STATE,
    YAML_PARSE_END_STATE
} yaml_parser_state_t;

typedef struct yaml_alias_data_s {
    yaml_char_t *anchor;
    int index;
    yaml_mark_t mark;
} yaml_alias_data_t;

typedef struct yaml_parser_s {

    yaml_error_type_t error;
    const char *problem;
    size_t problem_offset;
    int problem_value;
    yaml_mark_t problem_mark;
    const char *context;
    yaml_mark_t context_mark;

    yaml_read_handler_t *read_handler;

    void *read_handler_data;

    union {
        struct {
            const unsigned char *start;
            const unsigned char *end;
            const unsigned char *current;
        } string;

        FILE *file;
    } input;

    int eof;

    struct {
        yaml_char_t *start;
        yaml_char_t *end;
        yaml_char_t *pointer;
        yaml_char_t *last;
    } buffer;

    /* The number of unread characters in the buffer. */
    size_t unread;

    struct {
        unsigned char *start;
        unsigned char *end;
        unsigned char *pointer;
        unsigned char *last;
    } 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 {
        yaml_token_t *start;
        yaml_token_t *end;
        yaml_token_t *head;
        yaml_token_t *tail;
    } tokens;

    size_t tokens_parsed;

    int token_available;

    struct {
        int *start;
        int *end;
        int *top;
    } indents;

    int indent;

    int simple_key_allowed;

    struct {
        yaml_simple_key_t *start;
        yaml_simple_key_t *end;
        yaml_simple_key_t *top;
    } simple_keys;

    struct {
        yaml_parser_state_t *start;
        yaml_parser_state_t *end;
        yaml_parser_state_t *top;
    } states;

    yaml_parser_state_t state;

    struct {
        yaml_mark_t *start;
        yaml_mark_t *end;
        yaml_mark_t *top;
    } marks;

    struct {
        yaml_tag_directive_t *start;
        yaml_tag_directive_t *end;
        yaml_tag_directive_t *top;
    } tag_directives;

    struct {
        yaml_alias_data_t *start;
        yaml_alias_data_t *end;
        yaml_alias_data_t *top;
    } aliases;

    yaml_document_t *document;

} yaml_parser_t;

YAML_DECLARE(int)
yaml_parser_initialize(yaml_parser_t *parser);

YAML_DECLARE(void)
yaml_parser_delete(yaml_parser_t *parser);

YAML_DECLARE(void)
yaml_parser_set_input_string(yaml_parser_t *parser,
        const unsigned char *input, size_t size);

YAML_DECLARE(void)
yaml_parser_set_input_file(yaml_parser_t *parser, FILE *file);

YAML_DECLARE(void)
yaml_parser_set_input(yaml_parser_t *parser,
        yaml_read_handler_t *handler, void *data);

YAML_DECLARE(void)
yaml_parser_set_encoding(yaml_parser_t *parser, yaml_encoding_t encoding);

YAML_DECLARE(int)
yaml_parser_scan(yaml_parser_t *parser, yaml_token_t *token);

YAML_DECLARE(int)
yaml_parser_parse(yaml_parser_t *parser, yaml_event_t *event);

YAML_DECLARE(int)
yaml_parser_load(yaml_parser_t *parser, yaml_document_t *document);

typedef int yaml_write_handler_t(void *data, unsigned char *buffer, size_t size);

typedef enum yaml_emitter_state_e {
    YAML_EMIT_STREAM_START_STATE,
    YAML_EMIT_FIRST_DOCUMENT_START_STATE,
    YAML_EMIT_DOCUMENT_START_STATE,
    YAML_EMIT_DOCUMENT_CONTENT_STATE,
    YAML_EMIT_DOCUMENT_END_STATE,

    YAML_EMIT_FLOW_SEQUENCE_FIRST_ITEM_STATE,
    YAML_EMIT_FLOW_SEQUENCE_ITEM_STATE,
    YAML_EMIT_FLOW_MAPPING_FIRST_KEY_STATE,
    YAML_EMIT_FLOW_MAPPING_KEY_STATE,
    YAML_EMIT_FLOW_MAPPING_SIMPLE_VALUE_STATE,

    YAML_EMIT_FLOW_MAPPING_VALUE_STATE,
    YAML_EMIT_BLOCK_SEQUENCE_FIRST_ITEM_STATE,
    YAML_EMIT_BLOCK_SEQUENCE_ITEM_STATE,
    YAML_EMIT_BLOCK_MAPPING_FIRST_KEY_STATE,
    YAML_EMIT_BLOCK_MAPPING_KEY_STATE,

    YAML_EMIT_BLOCK_MAPPING_SIMPLE_VALUE_STATE,
    YAML_EMIT_BLOCK_MAPPING_VALUE_STATE,
    YAML_EMIT_END_STATE
} yaml_emitter_state_t;


/* This is needed for C++ */

typedef struct yaml_anchors_s {
    int references;
    int anchor;
    int serialized;
} yaml_anchors_t;

typedef struct yaml_emitter_s {

    yaml_error_type_t error;
    const char *problem;

    yaml_write_handler_t *write_handler;

    void *write_handler_data;

    union {
        struct {
            unsigned char *buffer;
            size_t size;
            size_t *size_written;
        } string;

        FILE *file;
    } output;

    struct {
        yaml_char_t *start;
        yaml_char_t *end;
        yaml_char_t *pointer;
        yaml_char_t *last;
    } buffer;

    struct {
        unsigned char *start;
        unsigned char *end;
        unsigned char *pointer;
        unsigned char *last;
    } raw_buffer;

    yaml_encoding_t encoding;

    int canonical;
    int best_indent;
    int best_width;
    int unicode;
    yaml_break_t line_break;

    struct {
        yaml_emitter_state_t *start;
        yaml_emitter_state_t *end;
        yaml_emitter_state_t *top;
    } states;

    yaml_emitter_state_t state;

    struct {
        yaml_event_t *start;
        yaml_event_t *end;
        yaml_event_t *head;
        yaml_event_t *tail;
    } events;

    struct {
        int *start;
        int *end;
        int *top;
    } indents;

    struct {
        yaml_tag_directive_t *start;
        yaml_tag_directive_t *end;
        yaml_tag_directive_t *top;
    } 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 {
        yaml_char_t *anchor;
        size_t anchor_length;
        int alias;
    } anchor_data;

    struct {
        yaml_char_t *handle;
        size_t handle_length;
        yaml_char_t *suffix;
        size_t suffix_length;
    } tag_data;

    struct {
        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;
    } scalar_data;

    int opened;
    int closed;

    yaml_anchors_t *anchors;

    int last_anchor_id;

    yaml_document_t *document;

} yaml_emitter_t;

YAML_DECLARE(int)
yaml_emitter_initialize(yaml_emitter_t *emitter);

YAML_DECLARE(void)
yaml_emitter_delete(yaml_emitter_t *emitter);

YAML_DECLARE(void)
yaml_emitter_set_output_string(yaml_emitter_t *emitter,
        unsigned char *output, size_t size, size_t *size_written);

YAML_DECLARE(void)
yaml_emitter_set_output_file(yaml_emitter_t *emitter, FILE *file);

YAML_DECLARE(void)
yaml_emitter_set_output(yaml_emitter_t *emitter,
        yaml_write_handler_t *handler, void *data);

YAML_DECLARE(void)
yaml_emitter_set_encoding(yaml_emitter_t *emitter, yaml_encoding_t encoding);

YAML_DECLARE(void)
yaml_emitter_set_canonical(yaml_emitter_t *emitter, int canonical);

YAML_DECLARE(void)
yaml_emitter_set_indent(yaml_emitter_t *emitter, int indent);

YAML_DECLARE(void)
yaml_emitter_set_width(yaml_emitter_t *emitter, int width);

YAML_DECLARE(void)
yaml_emitter_set_unicode(yaml_emitter_t *emitter, int unicode);

YAML_DECLARE(void)
yaml_emitter_set_break(yaml_emitter_t *emitter, yaml_break_t line_break);

YAML_DECLARE(int)
yaml_emitter_emit(yaml_emitter_t *emitter, yaml_event_t *event);

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);

YAML_DECLARE(int)
yaml_emitter_flush(yaml_emitter_t *emitter);

#ifdef __cplusplus
}
#endif

#endif /* #ifndef YAML_H */