diff --git a/extra/yaml/authors.txt b/extra/yaml/authors.txt new file mode 100644 index 0000000000..2c5e05bdac --- /dev/null +++ b/extra/yaml/authors.txt @@ -0,0 +1 @@ +Jon Harper diff --git a/extra/yaml/ffi/authors.txt b/extra/yaml/ffi/authors.txt new file mode 100644 index 0000000000..2c5e05bdac --- /dev/null +++ b/extra/yaml/ffi/authors.txt @@ -0,0 +1 @@ +Jon Harper diff --git a/extra/yaml/ffi/ffi.factor b/extra/yaml/ffi/ffi.factor new file mode 100644 index 0000000000..340ef4bb6d --- /dev/null +++ b/extra/yaml/ffi/ffi.factor @@ -0,0 +1,1601 @@ +! 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 +combinators system classes.struct ; +IN: yaml.ffi + +<< +"libyaml" { + { [ os unix? ] [ "libyaml.so" ] } +} cond 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). */ +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 yaml_char_t* } + { prefix yaml_char_t* } +; + +! /** 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 yaml_char_t* } +; +! /** The anchor (for @c YAML_ANCHOR_TOKEN). */ +STRUCT: anchor_token_data + { value yaml_char_t* } +; + +! /** The tag (for @c YAML_TAG_TOKEN). */ +STRUCT: tag_token_data + { handle yaml_char_t* } + { suffix yaml_char_t* } +; + +! /** The scalar value (for @c YAML_SCALAR_TOKEN). */ +STRUCT: scalar_token_data + { value yaml_char_t* } + { 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 yaml_char_t* } +; + +! /** The scalar parameters (for @c YAML_SCALAR_EVENT). */ +STRUCT: scalar_event_data + { anchor yaml_char_t* } + { tag yaml_char_t* } + { value yaml_char_t* } + { 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 yaml_char_t* } + { tag yaml_char_t* } + { implicit int } + { style yaml_sequence_style_t } +; + +! /** The mapping parameters (for @c YAML_MAPPING_START_EVENT). */ +STRUCT: mapping_start_event_data + { anchor yaml_char_t* } + { tag yaml_char_t* } + { 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: 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. +! */ + +FUNCTION: 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. +! */ + +FUNCTION: 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. +! */ + +FUNCTION: 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. +! */ + +FUNCTION: int +yaml_alias_event_initialize ( yaml_event_t *event, 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. +! */ + +FUNCTION: int +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 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: int +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-END event. +! * +! * @param[out] event An empty event object. +! * +! * @returns @c 1 if the function succeeded, @c 0 on error. +! */ + +FUNCTION: 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. +! */ + +FUNCTION: int +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-END event. +! * +! * @param[out] event An empty event object. +! * +! * @returns @c 1 if the function succeeded, @c 0 on error. +! */ + +FUNCTION: 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. +! */ + +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 yaml_char_t* } + { 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 yaml_char_t* } + + { 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: 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. +! */ + +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, + yaml_char_t *tag, 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. +! */ + +FUNCTION: int +yaml_document_add_sequence ( yaml_document_t *document, + 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. +! */ + +FUNCTION: int +yaml_document_add_mapping ( yaml_document_t *document, + 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. +! */ + +FUNCTION: 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. +! */ + +FUNCTION: 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. +! */ + +CALLBACK: int 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 yaml_char_t* } + { 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_idents + { 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_idents } + + { 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: int +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: 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. +! */ + +FUNCTION: 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. +! * +! * @return @c 1 if the function succeeded, @c 0 on error. +! */ + +FUNCTION: 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. +! */ + +CALLBACK: int 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 yaml_char_t* } + { anchor_length size_t } + { alias int } + ; + + ! /** Tag analysis. */ + STRUCT: yaml_emitter_tag_data + { handle yaml_char_t* } + { handle_length size_t } + { suffix yaml_char_t* } + { suffix_length size_t } + ; + + ! /** Scalar analysis. */ + STRUCT: yaml_emitter_scalar_data + { value yaml_char_t* } + { 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: int +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, int 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, int 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: 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. +! */ + +FUNCTION: 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. +! */ + +FUNCTION: 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 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: 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. +! */ + +FUNCTION: int +yaml_emitter_flush ( yaml_emitter_t *emitter ) ; + +! /** @} */ + +! #ifdef __cplusplus +! } +! #endif + +! #endif /* #ifndef YAML_H */ diff --git a/extra/yaml/yaml.factor b/extra/yaml/yaml.factor new file mode 100644 index 0000000000..687555f515 --- /dev/null +++ b/extra/yaml/yaml.factor @@ -0,0 +1,5 @@ +! Copyright (C) 2013 Jon Harper. +! See http://factorcode.org/license.txt for BSD license. +USING: ; +IN: yaml +