! Copyright (C) 2013 Jon Harper.
! See http://factorcode.org/license.txt for BSD license.
! adapted from "yaml.h" libYAML 0.1.4
! http://pyyaml.org/wiki/LibYAML
USING: alien alien.c-types alien.destructors alien.libraries
alien.syntax classes.struct combinators literals system
alien.libraries.finder ;
IN: yaml.ffi

<<
"libyaml" { "yaml" "yaml-0" "libyaml-0-2" } find-library-from-list cdecl add-library
>>

C-TYPE: FILE

LIBRARY: libyaml

! /**
!  * @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.
!  */
FUNCTION: c-string
yaml_get_version_string ( )

! /**
!  * Get the library version numbers.
!  *
!  * @param[out]      major   Major version number.
!  * @param[out]      minor   Minor version number.
!  * @param[out]      patch   Patch version number.
!  */
FUNCTION: void
yaml_get_version ( int *major, int *minor, int *patch )

! /** @} */

! /**
!  * @defgroup basic Basic Types
!  * @{
!  */

! /** The character type (UTF-8 octet). */
! libYAML returns it's data as null-terminated UTF-8 string.
! It copies it's input and we can use null-terminated string
! if we give a negative length. So we can use factor's c-string
! for input and output.
TYPEDEF: uchar yaml_char_t

! /** The version directive data. */
STRUCT: yaml_version_directive_t
    { major int }
    { minor int }
;

! /** The tag directive data. */
STRUCT: yaml_tag_directive_t
    { handle c-string }
    { prefix c-string }
;

! /** The stream encoding. */
ENUM: yaml_encoding_t
    YAML_ANY_ENCODING
    YAML_UTF8_ENCODING
    YAML_UTF16LE_ENCODING
    YAML_UTF16BE_ENCODING
;

! /** Line break types. */
ENUM: yaml_break_t
    YAML_ANY_BREAK
    YAML_CR_BREAK
    YAML_LN_BREAK
    YAML_CRLN_BREAK
;

! /** Many bad things could happen with the parser and emitter. */
ENUM: yaml_error_type_t
    YAML_NO_ERROR

    YAML_MEMORY_ERROR

    YAML_READER_ERROR
    YAML_SCANNER_ERROR
    YAML_PARSER_ERROR
    YAML_COMPOSER_ERROR

    YAML_WRITER_ERROR
    YAML_EMITTER_ERROR
;

! /** The pointer position. */
STRUCT: yaml_mark_t
    { index size_t }
    { line size_t }
    { column size_t }
;

! /** @} */

! /**
!  * @defgroup styles Node Styles
!  * @{
!  */

! /** Scalar styles. */
ENUM: yaml_scalar_style_t
    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
;

! /** Sequence styles. */
ENUM: yaml_sequence_style_t
    YAML_ANY_SEQUENCE_STYLE

    YAML_BLOCK_SEQUENCE_STYLE
    YAML_FLOW_SEQUENCE_STYLE
;

! /** Mapping styles. */
ENUM: yaml_mapping_style_t
    YAML_ANY_MAPPING_STYLE

    YAML_BLOCK_MAPPING_STYLE
    YAML_FLOW_MAPPING_STYLE
;

! /** @} */

! /**
!  * @defgroup tokens Tokens
!  * @{
!  */

! /** Token types. */
ENUM: yaml_token_type_t
    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
;

! /** The token structure. */
! /** The stream start (for @c YAML_STREAM_START_TOKEN). */
STRUCT: stream_start_token_data
    { encoding yaml_encoding_t }
;
! /** The alias (for @c YAML_ALIAS_TOKEN). */
STRUCT: alias_token_data
    { value c-string }
;
! /** The anchor (for @c YAML_ANCHOR_TOKEN). */
STRUCT: anchor_token_data
    { value c-string }
;

! /** The tag (for @c YAML_TAG_TOKEN). */
STRUCT: tag_token_data
    { handle c-string }
    { suffix c-string }
;

! /** The scalar value (for @c YAML_SCALAR_TOKEN). */
STRUCT: scalar_token_data
    { value c-string }
    { length size_t }
    { style yaml_scalar_style_t }
;

! /** The version directive (for @c YAML_VERSION_DIRECTIVE_TOKEN). */
STRUCT: version_directive_token_data
    { major int }
    { minor int }
;

UNION-STRUCT: token_data
  { stream_start stream_start_token_data }
  { alias alias_token_data }
  { anchor anchor_token_data }
  { tag tag_token_data }
  { scalar scalar_token_data }
  { version_directive version_directive_token_data }
;
STRUCT: yaml_token_t

    { type yaml_token_type_t }

    { data token_data }

    { start_mark yaml_mark_t }
    { end_mark yaml_mark_t }
;

! /**
!  * Free any memory allocated for a token object.
!  *
!  * @param[in,out]   token   A token object.
!  */

FUNCTION: void
yaml_token_delete ( yaml_token_t *token )
DESTRUCTOR: yaml_token_delete

! /** @} */

! /**
!  * @defgroup events Events
!  * @{
!  */

! /** Event types. */
ENUM: yaml_event_type_t
    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
;

! /** The event structure. */

! /** The event data. */
! /** The stream parameters (for @c YAML_STREAM_START_EVENT). */
STRUCT: stream_start_event_data
    { encoding yaml_encoding_t }
;

! /** The document parameters (for @c YAML_DOCUMENT_START_EVENT). */
!   /** The list of tag directives. */
    STRUCT: tag_directives_document_start_event_data
        { start yaml_tag_directive_t* }
        { end yaml_tag_directive_t* }
    ;
STRUCT: document_start_event_data
    { version_directive yaml_version_directive_t* }
    { tag_directives tag_directives_document_start_event_data }
    { implicit int }
;

! /** The document end parameters (for @c YAML_DOCUMENT_END_EVENT). */
STRUCT: document_end_event_data
    { implicit int }
;

! /** The alias parameters (for @c YAML_ALIAS_EVENT). */
STRUCT: alias_event_data
    { anchor c-string }
;

! /** The scalar parameters (for @c YAML_SCALAR_EVENT). */
STRUCT: scalar_event_data
    { anchor c-string }
    { tag c-string }
    { value c-string }
    { length size_t }
    { plain_implicit int }
    { quoted_implicit int }
    { style yaml_scalar_style_t }
;

! /** The sequence parameters (for @c YAML_SEQUENCE_START_EVENT). */
STRUCT: sequence_start_event_data
    { anchor c-string }
    { tag c-string }
    { implicit int }
    { style yaml_sequence_style_t }
;

! /** The mapping parameters (for @c YAML_MAPPING_START_EVENT). */
STRUCT: mapping_start_event_data
    { anchor c-string }
    { tag c-string }
    { implicit int }
    { style yaml_mapping_style_t }
;

UNION-STRUCT: event_data
  { stream_start stream_start_event_data }
  { document_start document_start_event_data }
  { document_end document_end_event_data }
  { alias alias_event_data }
  { scalar scalar_event_data }
  { sequence_start sequence_start_event_data }
  { mapping_start mapping_start_event_data }
;

STRUCT: yaml_event_t

    { type yaml_event_type_t }

    { data event_data }

    { start_mark yaml_mark_t }
    { end_mark yaml_mark_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.
!  */

FUNCTION: bool
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.
!  */

FUNCTION: bool
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.
!  */

FUNCTION: bool
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,
        bool 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.
!  */

FUNCTION: bool
yaml_document_end_event_initialize ( yaml_event_t *event, bool 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.
!  */

FUNCTION: bool
yaml_alias_event_initialize ( yaml_event_t *event, c-string 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.
!  */

FUNCTION: bool
yaml_scalar_event_initialize ( yaml_event_t *event,
        c-string anchor, c-string tag,
        c-string value, int length,
        bool plain_implicit, bool 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.
!  */

FUNCTION: bool
yaml_sequence_start_event_initialize ( yaml_event_t *event,
        c-string anchor, c-string tag, bool 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.
!  */

FUNCTION: bool
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.
!  */

FUNCTION: bool
yaml_mapping_start_event_initialize ( yaml_event_t *event,
        c-string anchor, c-string tag, bool 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.
!  */

FUNCTION: bool
yaml_mapping_end_event_initialize ( yaml_event_t *event )

! /**
!  * Free any memory allocated for an event object.
!  *
!  * @param[in,out]   event   An event object.
!  */

FUNCTION: void
yaml_event_delete ( yaml_event_t *event )
DESTRUCTOR: yaml_event_delete

! /** @} */

! /**
!  * @defgroup nodes Nodes
!  * @{
!  */

! /** The tag @c !!null with the only possible value: @c null. */
CONSTANT:  YAML_NULL_TAG       "tag:yaml.org,2002:null"
! /** The tag @c !!bool with the values: @c true and @c falce. */
CONSTANT:  YAML_BOOL_TAG       "tag:yaml.org,2002:bool"
! /** The tag @c !!str for string values. */
CONSTANT:  YAML_STR_TAG        "tag:yaml.org,2002:str"
! /** The tag @c !!int for integer values. */
CONSTANT:  YAML_INT_TAG        "tag:yaml.org,2002:int"
! /** The tag @c !!float for float values. */
CONSTANT:  YAML_FLOAT_TAG      "tag:yaml.org,2002:float"
! /** The tag @c !!timestamp for date and time values. */
CONSTANT:  YAML_TIMESTAMP_TAG  "tag:yaml.org,2002:timestamp"

! /** The tag @c !!seq is used to denote sequences. */
CONSTANT:  YAML_SEQ_TAG        "tag:yaml.org,2002:seq"
! /** The tag @c !!map is used to denote mapping. */
CONSTANT:  YAML_MAP_TAG        "tag:yaml.org,2002:map"

! /** The default scalar tag is @c !!str. */
CONSTANT:  YAML_DEFAULT_SCALAR_TAG     $ YAML_STR_TAG
! /** The default sequence tag is @c !!seq. */
CONSTANT:  YAML_DEFAULT_SEQUENCE_TAG   $ YAML_SEQ_TAG
! /** The default mapping tag is @c !!map. */
CONSTANT:  YAML_DEFAULT_MAPPING_TAG    $ YAML_MAP_TAG

! /** Node types. */
ENUM: yaml_node_type_t
    YAML_NO_NODE

    YAML_SCALAR_NODE
    YAML_SEQUENCE_NODE
    YAML_MAPPING_NODE
;

! /** 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. */
STRUCT: yaml_node_pair_t
    { key int }
    { value int }
;

! /** The node structure. */
        ! /** The scalar parameters (for @c YAML_SCALAR_NODE). */
        STRUCT: scalar_node_data
            { value c-string }
            { length size_t }
            { style yaml_scalar_style_t }
        ;

        ! /** The sequence parameters (for @c YAML_SEQUENCE_NODE). */
            ! /** The stack of sequence items. */
            STRUCT: sequence_node_data_items
                { start yaml_node_item_t* }
                { end yaml_node_item_t* }
                { top yaml_node_item_t* }
            ;
        STRUCT: sequence_node_data
            { items sequence_node_data_items }
            { style yaml_sequence_style_t }
        ;

        ! /** The mapping parameters (for @c YAML_MAPPING_NODE). */
            ! /** The stack of mapping pairs (key, value). */
            STRUCT: mapping_node_data_pairs
                { start yaml_node_pair_t* }
                { end yaml_node_pair_t* }
                { top yaml_node_pair_t* }
            ;
        STRUCT: mapping_node_data
            { pairs mapping_node_data_pairs }
            { style yaml_mapping_style_t }
        ;
  UNION-STRUCT: node_data
     { scalar scalar_node_data }
     { sequence sequence_node_data }
     { mapping mapping_node_data }
  ;

STRUCT: yaml_node_t

    { type yaml_node_type_t }

    { tag c-string }

    { data node_data }

    { start_mark yaml_mark_t }
    { end_mark yaml_mark_t }

;

! /** The document structure. */
    ! /** The document nodes. */
    STRUCT: yaml_document_nodes
        { start yaml_node_t* }
        { end yaml_node_t* }
        { top yaml_node_t* }
    ;

    ! /** The list of tag directives. */
    STRUCT: yaml_document_tag_directives
        { start yaml_tag_directive_t* }
        { end yaml_tag_directive_t* }
    ;

STRUCT: yaml_document_t

    { nodes yaml_document_nodes }

    { version_directive yaml_version_directive_t* }

    { tag_directives yaml_document_tag_directives }

    { start_implicit int }
    { end_implicit int }

    { start_mark yaml_mark_t }
    { end_mark yaml_mark_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.
!  */

FUNCTION: bool
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,
        bool start_implicit, bool end_implicit )

! /**
!  * Delete a YAML document and all its nodes.
!  *
!  * @param[in,out]   document        A document object.
!  */

FUNCTION: void
yaml_document_delete ( yaml_document_t *document )
DESTRUCTOR: yaml_document_delete

! /**
!  * 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.
!  */

FUNCTION: 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.
!  */

FUNCTION: 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.
!  */

FUNCTION: int
yaml_document_add_scalar ( yaml_document_t *document,
        c-string tag, c-string 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.
!  */

FUNCTION: int
yaml_document_add_sequence ( yaml_document_t *document,
        c-string 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.
!  */

FUNCTION: int
yaml_document_add_mapping ( yaml_document_t *document,
        c-string 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.
!  */

FUNCTION: bool
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.
!  */

FUNCTION: bool
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.
!  */

CALLBACK: bool yaml_read_handler_t ( void *data,  uchar *buffer, size_t size,
         size_t *size_read )

! /**
!  * This structure holds information about a potential simple key.
!  */

STRUCT: yaml_simple_key_t
    { possible int }

    { required int }

    { token_number size_t }

    { mark yaml_mark_t }
;

! /**
!  * The states of the parser.
!  */
ENUM: yaml_parser_state_t
    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
;

! /**
!  * This structure holds aliases data.
!  */

STRUCT: yaml_alias_data_t
    { anchor c-string }
    { index int }
    { mark yaml_mark_t }
;

! /**
!  * The parser structure.
!  *
!  * All members are internal.  Manage the structure using the @c yaml_parser_
!  * family of functions.
!  */

    ! /** Standard (string or file) input data. */
        ! /** String input data. */
        STRUCT: string_yaml_parser_input
            { start uchar* }
            { end uchar* }
            { current uchar* }
        ;
    UNION-STRUCT: yaml_parser_input
        { string string_yaml_parser_input }
        { file FILE* }
    ;

    ! /** The working buffer. */
    STRUCT: yaml_parser_buffer
        { start yaml_char_t* }
        { end yaml_char_t* }
        { pointer yaml_char_t* }
        { last yaml_char_t* }
    ;

    ! /** The raw buffer. */
    STRUCT: yaml_parser_raw_buffer
        { start uchar* }
        { end uchar* }
        { pointer uchar* }
        { last uchar* }
    ;

    ! /** The tokens queue. */
    STRUCT: yaml_parser_tokens
        { start yaml_token_t* }
        { end yaml_token_t* }
        { head yaml_token_t* }
        { tail yaml_token_t* }
    ;

    ! /** The indentation levels stack. */
    STRUCT: yaml_parser_indents
        { start int* }
        { end int* }
        { top int* }
    ;

    ! /** The stack of simple keys. */
    STRUCT: yaml_parser_simple_keys
        { start yaml_simple_key_t* }
        { end yaml_simple_key_t* }
        { top yaml_simple_key_t* }
    ;

    ! /** The parser states stack. */
    STRUCT: yaml_parser_states
        { start yaml_parser_state_t* }
        { end yaml_parser_state_t* }
        { top yaml_parser_state_t* }
    ;

    ! /** The stack of marks. */
    STRUCT: yaml_parser_marks
        { start yaml_mark_t* }
        { end yaml_mark_t* }
        { top yaml_mark_t* }
    ;

    ! /** The list of TAG directives. */
    STRUCT: yaml_parser_tag_directives
        { start yaml_tag_directive_t* }
        { end yaml_tag_directive_t* }
        { top yaml_tag_directive_t* }
    ;

    ! /** The alias data. */
    STRUCT: yaml_parser_aliases
        { start yaml_alias_data_t* }
        { end yaml_alias_data_t* }
        { top yaml_alias_data_t* }
    ;
STRUCT: yaml_parser_t

    { error yaml_error_type_t }
    { problem c-string }
    { problem_offset size_t }
    { problem_value int }
    { problem_mark yaml_mark_t }
    { context c-string }
    { context_mark yaml_mark_t }

    { read_handler yaml_read_handler_t* }

    { read_handler_data void* }

    { input yaml_parser_input }

    { eof int }

    { buffer yaml_parser_buffer }

    { unread size_t }

    { raw_buffer yaml_parser_raw_buffer }

    { encoding yaml_encoding_t }

    { offset size_t }

    { mark yaml_mark_t }

    { stream_start_produced int }

    { stream_end_produced int }

    { flow_level int }

    { tokens yaml_parser_tokens }

    { tokens_parsed size_t }

    { token_available int }

    { indents yaml_parser_indents }

    { indent int }

    { simple_key_allowed int }

    { simple_keys yaml_parser_simple_keys }

    { states yaml_parser_states }

    { state yaml_parser_state_t }

    { marks yaml_parser_marks }

    { tag_directives yaml_parser_tag_directives }

    { aliases yaml_parser_aliases }

    { document yaml_document_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.
!  */

FUNCTION: bool
yaml_parser_initialize ( yaml_parser_t *parser )

! /**
!  * Destroy a parser.
!  *
!  * @param[in,out]   parser  A parser object.
!  */

FUNCTION: void
yaml_parser_delete ( yaml_parser_t *parser )
DESTRUCTOR: yaml_parser_delete

! /**
!  * 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.
!  */

FUNCTION: void
yaml_parser_set_input_string ( yaml_parser_t *parser,
        uchar *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.
!  */

FUNCTION: 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.
!  */

FUNCTION: 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.
!  */

FUNCTION: 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.
!  */

FUNCTION: bool
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.
!  */

FUNCTION: bool
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.
!  *
!  * @return @c 1 if the function succeeded, @c 0 on error.
!  */

FUNCTION: bool
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.
!  */

CALLBACK: bool yaml_write_handler_t ( void *data, uchar *buffer, size_t size )

! /** The emitter states. */
ENUM: yaml_emitter_state_t
    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
;

! /**
!  * The emitter structure.
!  *
!  * All members are internal.  Manage the structure using the @c yaml_emitter_
!  * family of functions.
!  */

    ! /** Standard (string or file) output data. */
        ! /** String output data. */
        STRUCT: yaml_emitter_output_string
            { buffer uchar* }
            { size size_t }
            { size_written size_t* }
        ;

    UNION-STRUCT: yaml_emitter_output
        { string yaml_emitter_output_string }

        { file FILE* }
    ;

    ! /** The working buffer. */
    STRUCT: yaml_emitter_buffer
        { start yaml_char_t* }
        { end yaml_char_t* }
        { pointer yaml_char_t* }
        { last yaml_char_t* }
    ;

    ! /** The raw buffer. */
    STRUCT: yaml_emitter_raw_buffer
        { start uchar* }
        { end uchar* }
        { pointer uchar* }
        { last uchar* }
    ;

    ! /** The stack of states. */
    STRUCT: yaml_emitter_states
        { start yaml_emitter_state_t* }
        { end yaml_emitter_state_t* }
        { top yaml_emitter_state_t* }
    ;

    ! /** The event queue. */
    STRUCT: yaml_emitter_events
        { start yaml_event_t* }
        { end yaml_event_t* }
        { head yaml_event_t* }
        { tail yaml_event_t* }
    ;

    ! /** The stack of indentation levels. */
    STRUCT: yaml_emitter_indents
        { start int* }
        { end int* }
        { top int* }
    ;

    ! /** The list of tag directives. */
    STRUCT: yaml_emitter_tag_directives
        { start yaml_tag_directive_t* }
        { end yaml_tag_directive_t* }
        { top yaml_tag_directive_t* }
    ;

    ! /** Anchor analysis. */
    STRUCT: yaml_emitter_anchor_data
        { anchor c-string }
        { anchor_length size_t }
        { alias int }
    ;

    ! /** Tag analysis. */
    STRUCT: yaml_emitter_tag_data
        { handle c-string }
        { handle_length size_t }
        { suffix c-string }
        { suffix_length size_t }
    ;

    ! /** Scalar analysis. */
    STRUCT: yaml_emitter_scalar_data
        { value c-string }
        { length size_t }
        { multiline int }
        { flow_plain_allowed int }
        { block_plain_allowed int }
        { single_quoted_allowed int }
        { block_allowed int }
        { style yaml_scalar_style_t }
    ;

    ! /** The information associated with the document nodes. */
    STRUCT: yaml_emitter_anchors
        { references int }
        { anchor int }
        { serialized int }
    ;
STRUCT: yaml_emitter_t

    { error yaml_error_type_t }
    { problem c-string }

    { write_handler yaml_write_handler_t* }

    { write_handler_data void* }

    { output yaml_emitter_output }

    { buffer yaml_emitter_buffer }

    { raw_buffer yaml_emitter_raw_buffer }

    { encoding yaml_encoding_t }

    { canonical int }
    { best_indent int }
    { best_width int }
    { unicode int }
    { line_break yaml_break_t }

    { states yaml_emitter_states }
    { state yaml_emitter_state_t }

    { events yaml_emitter_events }

    { indents yaml_emitter_indents }

    { tag_directives yaml_emitter_tag_directives }

    { 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 int }

    { anchor_data yaml_emitter_anchor_data }

    { tag_data yaml_emitter_tag_data }

    { scalar_data yaml_emitter_scalar_data }

    { opened int }
    { closed int }

    { anchors yaml_emitter_anchors* }

    { last_anchor_id int }

    { document yaml_document_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.
!  */

FUNCTION: bool
yaml_emitter_initialize ( yaml_emitter_t *emitter )

! /**
!  * Destroy an emitter.
!  *
!  * @param[in,out]   emitter     An emitter object.
!  */

FUNCTION: void
yaml_emitter_delete ( yaml_emitter_t *emitter )
DESTRUCTOR: yaml_emitter_delete

! /**
!  * 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.
!  */

FUNCTION: void
yaml_emitter_set_output_string ( yaml_emitter_t *emitter,
        uchar *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.
!  */

FUNCTION: 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.
!  */

FUNCTION: 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.
!  */

FUNCTION: 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.
!  */

FUNCTION: void
yaml_emitter_set_canonical ( yaml_emitter_t *emitter, bool canonical )

! /**
!  * Set the intendation increment.
!  *
!  * @param[in,out]   emitter     An emitter object.
!  * @param[in]       indent      The indentation increment (1 < . < 10).
!  */

FUNCTION: 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.
!  */

FUNCTION: 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.
!  */

FUNCTION: void
yaml_emitter_set_unicode ( yaml_emitter_t *emitter, bool unicode )

! /**
!  * Set the preferred line break.
!  *
!  * @param[in,out]   emitter     An emitter object.
!  * @param[in]       line_break  The preferred line break.
!  */

FUNCTION: 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.
!  */

FUNCTION: bool
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.
!  */

FUNCTION: bool
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.
!  */

FUNCTION: bool
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 destoys its content after
!  * it is emitted. The document object is destroyedeven 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.
!  */

FUNCTION: bool
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.
!  */

FUNCTION: bool
yaml_emitter_flush ( yaml_emitter_t *emitter )

! /** @} */

! #ifdef __cplusplus
! }
! #endif

! #endif /* #ifndef YAML_H */