mirror of https://github.com/libAthena/athena.git
Added YAML serialization DNA subclass
This commit is contained in:
Jack Andersen
parent
43c317529c
commit
84591d4260
|
|
@ -17,7 +17,7 @@ set(ATHENA_VERSION
|
|||
|
||||
add_subdirectory(extern)
|
||||
|
||||
include_directories(include ${LZO_INCLUDE_DIR} ${ZLIB_INCLUDE_DIR})
|
||||
include_directories(include ${LZO_INCLUDE_DIR} ${ZLIB_INCLUDE_DIR} ${YAML_INCLUDE_DIR})
|
||||
if (NOT MSVC)
|
||||
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++11")
|
||||
endif()
|
||||
|
|
@ -45,6 +45,7 @@ add_library(AthenaCore
|
|||
src/LZ77/LZBase.cpp
|
||||
src/Athena/FileInfo.cpp
|
||||
src/Athena/Dir.cpp
|
||||
src/Athena/DNAYaml.cpp
|
||||
${CORE_EXTRA}
|
||||
|
||||
include/Athena/IStream.hpp
|
||||
|
|
@ -67,6 +68,7 @@ add_library(AthenaCore
|
|||
include/Athena/Dir.hpp
|
||||
include/gekko_support.h
|
||||
include/Athena/DNA.hpp
|
||||
include/Athena/DNAYaml.hpp
|
||||
)
|
||||
|
||||
add_library(AthenaSakura
|
||||
|
|
|
|||
4
PKGBUILD
4
PKGBUILD
|
|
@ -1,11 +1,11 @@
|
|||
# PKGBUILD for libAthena
|
||||
_pkgname=libathena
|
||||
pkgname=$_pkgname-git
|
||||
pkgver=2.2.0.3.g4a688a1
|
||||
pkgver=2.2.0.8.g2490fef
|
||||
pkgrel=1
|
||||
pkgdesc="Basic cross platform IO library"
|
||||
arch=('i686' 'x86_64')
|
||||
source=("${pkgname%-*}::git+https://github.com/libAthena/Athena.git")
|
||||
source=("${pkgname%-*}::git+https://github.com/libAthena/Athena.git#branch=yaml")
|
||||
options=(staticlibs)
|
||||
license="MIT"
|
||||
makedepends=('git cmake sed')
|
||||
|
|
|
|||
|
|
@ -1,2 +1,3 @@
|
|||
add_subdirectory(lzo)
|
||||
add_subdirectory(zlib)
|
||||
add_subdirectory(yaml)
|
||||
|
|
|
|||
|
|
@ -0,0 +1,21 @@
|
|||
# Minimal CMake project for building a static library under Windows.
|
||||
|
||||
cmake_minimum_required(VERSION 2.8)
|
||||
project(yaml C)
|
||||
|
||||
set(YAML_VERSION_MAJOR 0)
|
||||
set(YAML_VERSION_MINOR 1)
|
||||
set(YAML_VERSION_PATCH 6)
|
||||
set(YAML_VERSION_STRING "${YAML_VERSION_MAJOR}.${YAML_VERSION_MINOR}.${YAML_VERSION_PATCH}")
|
||||
|
||||
file(GLOB SRC src/*.c)
|
||||
|
||||
include_directories(include win32)
|
||||
add_definitions(-DYAML_DECLARE_STATIC)
|
||||
add_library(yaml STATIC ${SRC} include/yaml.h)
|
||||
|
||||
set(YAML_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/include CACHE PATH "YAML include path" FORCE)
|
||||
if(WIN32 AND NOT UNIX)
|
||||
install(DIRECTORY include/ DESTINATION include COMPONENT yaml)
|
||||
install(TARGETS yaml DESTINATION lib COMPONENT yaml)
|
||||
endif()
|
||||
|
|
@ -0,0 +1,19 @@
|
|||
Copyright (c) 2006 Kirill Simonov
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
this software and associated documentation files (the "Software"), to deal in
|
||||
the Software without restriction, including without limitation the rights to
|
||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
||||
of the Software, and to permit persons to whom the Software is furnished to do
|
||||
so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
|
|
@ -0,0 +1,27 @@
|
|||
LibYAML - A C library for parsing and emitting YAML.
|
||||
|
||||
To build and install the library, run:
|
||||
$ ./configure
|
||||
$ make
|
||||
# make install
|
||||
|
||||
If you checked the source code from the Subversion repository, run
|
||||
$ ./bootstrap
|
||||
$ ./configure
|
||||
$ make
|
||||
# make install
|
||||
|
||||
For more information, check the LibYAML homepage:
|
||||
'http://pyyaml.org/wiki/LibYAML'.
|
||||
|
||||
Post your questions and opinions to the YAML-Core mailing list:
|
||||
'http://lists.sourceforge.net/lists/listinfo/yaml-core'.
|
||||
|
||||
Submit bug reports and feature requests to the LibYAML bug tracker:
|
||||
'http://pyyaml.org/newticket?component=libyaml'.
|
||||
|
||||
LibYAML is written by Kirill Simonov <xi@resolvent.net>. It is released
|
||||
under the MIT license. See the file LICENSE for more details.
|
||||
|
||||
This project is developed for Python Software Foundation as a part of
|
||||
Google Summer of Code under the mentorship of Clark Evans.
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
From: Kirill Simonov <xi@resolvent.net>
|
||||
To: yaml-core@lists.sourceforge.net
|
||||
Subject: LibYAML-0.1.4: A minor bugfix release
|
||||
|
||||
This is a minor bugfix release of LibYAML, a YAML parser and emitter
|
||||
written in C:
|
||||
|
||||
* Fixed a bug that prevented an empty mapping being used as a simple key
|
||||
(thank to spitzak(at)rhythm(dot)com).
|
||||
* Fixed pointer overflow when calculating the position of a potential
|
||||
simple key (thank to ppelletier(at)oblong(dot)com).
|
||||
* Fixed yaml.dll not exporting any symbols
|
||||
(thank to pxn11432(at)nifty(dot)com).
|
||||
* Added pkg-config support (thank to rainwoodman(at)gmail(dot)com).
|
||||
|
||||
LibYAML homepage: http://pyyaml.org/wiki/LibYAML
|
||||
TAR.GZ package: http://pyyaml.org/download/libyaml/yaml-0.1.4.tar.gz
|
||||
SVN repository: http://svn.pyyaml.org/libyaml/branches/stable
|
||||
Bug tracker: http://pyyaml.org/newticket?component=libyaml
|
||||
|
||||
The library is functionally complete, but the documentation is scarce
|
||||
and the API may change. For more information, you may check the project
|
||||
homepage, the doxygen-generated documentation in the `doc` directory of
|
||||
the source distribution, and examples in the `tests` directory.
|
||||
|
||||
LibYAML is written by Kirill Simonov <xi@resolvent.net> and released
|
||||
under the MIT license; see the file LICENSE for more details.
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,4 @@
|
|||
#define YAML_VERSION_MAJOR 0
|
||||
#define YAML_VERSION_MINOR 1
|
||||
#define YAML_VERSION_PATCH 6
|
||||
#define YAML_VERSION_STRING "0.1.6"
|
||||
|
|
@ -0,0 +1,394 @@
|
|||
|
||||
#include "yaml_private.h"
|
||||
|
||||
/*
|
||||
* API functions.
|
||||
*/
|
||||
|
||||
YAML_DECLARE(int)
|
||||
yaml_emitter_open(yaml_emitter_t *emitter);
|
||||
|
||||
YAML_DECLARE(int)
|
||||
yaml_emitter_close(yaml_emitter_t *emitter);
|
||||
|
||||
YAML_DECLARE(int)
|
||||
yaml_emitter_dump(yaml_emitter_t *emitter, yaml_document_t *document);
|
||||
|
||||
/*
|
||||
* Clean up functions.
|
||||
*/
|
||||
|
||||
static void
|
||||
yaml_emitter_delete_document_and_anchors(yaml_emitter_t *emitter);
|
||||
|
||||
/*
|
||||
* Anchor functions.
|
||||
*/
|
||||
|
||||
static void
|
||||
yaml_emitter_anchor_node(yaml_emitter_t *emitter, int index);
|
||||
|
||||
static yaml_char_t *
|
||||
yaml_emitter_generate_anchor(yaml_emitter_t *emitter, int anchor_id);
|
||||
|
||||
|
||||
/*
|
||||
* Serialize functions.
|
||||
*/
|
||||
|
||||
static int
|
||||
yaml_emitter_dump_node(yaml_emitter_t *emitter, int index);
|
||||
|
||||
static int
|
||||
yaml_emitter_dump_alias(yaml_emitter_t *emitter, yaml_char_t *anchor);
|
||||
|
||||
static int
|
||||
yaml_emitter_dump_scalar(yaml_emitter_t *emitter, yaml_node_t *node,
|
||||
yaml_char_t *anchor);
|
||||
|
||||
static int
|
||||
yaml_emitter_dump_sequence(yaml_emitter_t *emitter, yaml_node_t *node,
|
||||
yaml_char_t *anchor);
|
||||
|
||||
static int
|
||||
yaml_emitter_dump_mapping(yaml_emitter_t *emitter, yaml_node_t *node,
|
||||
yaml_char_t *anchor);
|
||||
|
||||
/*
|
||||
* Issue a STREAM-START event.
|
||||
*/
|
||||
|
||||
YAML_DECLARE(int)
|
||||
yaml_emitter_open(yaml_emitter_t *emitter)
|
||||
{
|
||||
yaml_event_t event;
|
||||
yaml_mark_t mark = { 0, 0, 0 };
|
||||
|
||||
assert(emitter); /* Non-NULL emitter object is required. */
|
||||
assert(!emitter->opened); /* Emitter should not be opened yet. */
|
||||
|
||||
STREAM_START_EVENT_INIT(event, YAML_ANY_ENCODING, mark, mark);
|
||||
|
||||
if (!yaml_emitter_emit(emitter, &event)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
emitter->opened = 1;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Issue a STREAM-END event.
|
||||
*/
|
||||
|
||||
YAML_DECLARE(int)
|
||||
yaml_emitter_close(yaml_emitter_t *emitter)
|
||||
{
|
||||
yaml_event_t event;
|
||||
yaml_mark_t mark = { 0, 0, 0 };
|
||||
|
||||
assert(emitter); /* Non-NULL emitter object is required. */
|
||||
assert(emitter->opened); /* Emitter should be opened. */
|
||||
|
||||
if (emitter->closed) return 1;
|
||||
|
||||
STREAM_END_EVENT_INIT(event, mark, mark);
|
||||
|
||||
if (!yaml_emitter_emit(emitter, &event)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
emitter->closed = 1;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Dump a YAML document.
|
||||
*/
|
||||
|
||||
YAML_DECLARE(int)
|
||||
yaml_emitter_dump(yaml_emitter_t *emitter, yaml_document_t *document)
|
||||
{
|
||||
yaml_event_t event;
|
||||
yaml_mark_t mark = { 0, 0, 0 };
|
||||
|
||||
assert(emitter); /* Non-NULL emitter object is required. */
|
||||
assert(document); /* Non-NULL emitter object is expected. */
|
||||
|
||||
emitter->document = document;
|
||||
|
||||
if (!emitter->opened) {
|
||||
if (!yaml_emitter_open(emitter)) goto error;
|
||||
}
|
||||
|
||||
if (STACK_EMPTY(emitter, document->nodes)) {
|
||||
if (!yaml_emitter_close(emitter)) goto error;
|
||||
yaml_emitter_delete_document_and_anchors(emitter);
|
||||
return 1;
|
||||
}
|
||||
|
||||
assert(emitter->opened); /* Emitter should be opened. */
|
||||
|
||||
emitter->anchors = yaml_malloc(sizeof(*(emitter->anchors))
|
||||
* (document->nodes.top - document->nodes.start));
|
||||
if (!emitter->anchors) goto error;
|
||||
memset(emitter->anchors, 0, sizeof(*(emitter->anchors))
|
||||
* (document->nodes.top - document->nodes.start));
|
||||
|
||||
DOCUMENT_START_EVENT_INIT(event, document->version_directive,
|
||||
document->tag_directives.start, document->tag_directives.end,
|
||||
document->start_implicit, mark, mark);
|
||||
if (!yaml_emitter_emit(emitter, &event)) goto error;
|
||||
|
||||
yaml_emitter_anchor_node(emitter, 1);
|
||||
if (!yaml_emitter_dump_node(emitter, 1)) goto error;
|
||||
|
||||
DOCUMENT_END_EVENT_INIT(event, document->end_implicit, mark, mark);
|
||||
if (!yaml_emitter_emit(emitter, &event)) goto error;
|
||||
|
||||
yaml_emitter_delete_document_and_anchors(emitter);
|
||||
|
||||
return 1;
|
||||
|
||||
error:
|
||||
|
||||
yaml_emitter_delete_document_and_anchors(emitter);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Clean up the emitter object after a document is dumped.
|
||||
*/
|
||||
|
||||
static void
|
||||
yaml_emitter_delete_document_and_anchors(yaml_emitter_t *emitter)
|
||||
{
|
||||
int index;
|
||||
|
||||
if (!emitter->anchors) {
|
||||
yaml_document_delete(emitter->document);
|
||||
emitter->document = NULL;
|
||||
return;
|
||||
}
|
||||
|
||||
for (index = 0; emitter->document->nodes.start + index
|
||||
< emitter->document->nodes.top; index ++) {
|
||||
yaml_node_t node = emitter->document->nodes.start[index];
|
||||
if (!emitter->anchors[index].serialized) {
|
||||
yaml_free(node.tag);
|
||||
if (node.type == YAML_SCALAR_NODE) {
|
||||
yaml_free(node.data.scalar.value);
|
||||
}
|
||||
}
|
||||
if (node.type == YAML_SEQUENCE_NODE) {
|
||||
STACK_DEL(emitter, node.data.sequence.items);
|
||||
}
|
||||
if (node.type == YAML_MAPPING_NODE) {
|
||||
STACK_DEL(emitter, node.data.mapping.pairs);
|
||||
}
|
||||
}
|
||||
|
||||
STACK_DEL(emitter, emitter->document->nodes);
|
||||
yaml_free(emitter->anchors);
|
||||
|
||||
emitter->anchors = NULL;
|
||||
emitter->last_anchor_id = 0;
|
||||
emitter->document = NULL;
|
||||
}
|
||||
|
||||
/*
|
||||
* Check the references of a node and assign the anchor id if needed.
|
||||
*/
|
||||
|
||||
static void
|
||||
yaml_emitter_anchor_node(yaml_emitter_t *emitter, int index)
|
||||
{
|
||||
yaml_node_t *node = emitter->document->nodes.start + index - 1;
|
||||
yaml_node_item_t *item;
|
||||
yaml_node_pair_t *pair;
|
||||
|
||||
emitter->anchors[index-1].references ++;
|
||||
|
||||
if (emitter->anchors[index-1].references == 1) {
|
||||
switch (node->type) {
|
||||
case YAML_SEQUENCE_NODE:
|
||||
for (item = node->data.sequence.items.start;
|
||||
item < node->data.sequence.items.top; item ++) {
|
||||
yaml_emitter_anchor_node(emitter, *item);
|
||||
}
|
||||
break;
|
||||
case YAML_MAPPING_NODE:
|
||||
for (pair = node->data.mapping.pairs.start;
|
||||
pair < node->data.mapping.pairs.top; pair ++) {
|
||||
yaml_emitter_anchor_node(emitter, pair->key);
|
||||
yaml_emitter_anchor_node(emitter, pair->value);
|
||||
}
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
else if (emitter->anchors[index-1].references == 2) {
|
||||
emitter->anchors[index-1].anchor = (++ emitter->last_anchor_id);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Generate a textual representation for an anchor.
|
||||
*/
|
||||
|
||||
#define ANCHOR_TEMPLATE "id%03d"
|
||||
#define ANCHOR_TEMPLATE_LENGTH 16
|
||||
|
||||
static yaml_char_t *
|
||||
yaml_emitter_generate_anchor(yaml_emitter_t *emitter, int anchor_id)
|
||||
{
|
||||
yaml_char_t *anchor = yaml_malloc(ANCHOR_TEMPLATE_LENGTH);
|
||||
|
||||
if (!anchor) return NULL;
|
||||
|
||||
sprintf((char *)anchor, ANCHOR_TEMPLATE, anchor_id);
|
||||
|
||||
return anchor;
|
||||
}
|
||||
|
||||
/*
|
||||
* Serialize a node.
|
||||
*/
|
||||
|
||||
static int
|
||||
yaml_emitter_dump_node(yaml_emitter_t *emitter, int index)
|
||||
{
|
||||
yaml_node_t *node = emitter->document->nodes.start + index - 1;
|
||||
int anchor_id = emitter->anchors[index-1].anchor;
|
||||
yaml_char_t *anchor = NULL;
|
||||
|
||||
if (anchor_id) {
|
||||
anchor = yaml_emitter_generate_anchor(emitter, anchor_id);
|
||||
if (!anchor) return 0;
|
||||
}
|
||||
|
||||
if (emitter->anchors[index-1].serialized) {
|
||||
return yaml_emitter_dump_alias(emitter, anchor);
|
||||
}
|
||||
|
||||
emitter->anchors[index-1].serialized = 1;
|
||||
|
||||
switch (node->type) {
|
||||
case YAML_SCALAR_NODE:
|
||||
return yaml_emitter_dump_scalar(emitter, node, anchor);
|
||||
case YAML_SEQUENCE_NODE:
|
||||
return yaml_emitter_dump_sequence(emitter, node, anchor);
|
||||
case YAML_MAPPING_NODE:
|
||||
return yaml_emitter_dump_mapping(emitter, node, anchor);
|
||||
default:
|
||||
assert(0); /* Could not happen. */
|
||||
break;
|
||||
}
|
||||
|
||||
return 0; /* Could not happen. */
|
||||
}
|
||||
|
||||
/*
|
||||
* Serialize an alias.
|
||||
*/
|
||||
|
||||
static int
|
||||
yaml_emitter_dump_alias(yaml_emitter_t *emitter, yaml_char_t *anchor)
|
||||
{
|
||||
yaml_event_t event;
|
||||
yaml_mark_t mark = { 0, 0, 0 };
|
||||
|
||||
ALIAS_EVENT_INIT(event, anchor, mark, mark);
|
||||
|
||||
return yaml_emitter_emit(emitter, &event);
|
||||
}
|
||||
|
||||
/*
|
||||
* Serialize a scalar.
|
||||
*/
|
||||
|
||||
static int
|
||||
yaml_emitter_dump_scalar(yaml_emitter_t *emitter, yaml_node_t *node,
|
||||
yaml_char_t *anchor)
|
||||
{
|
||||
yaml_event_t event;
|
||||
yaml_mark_t mark = { 0, 0, 0 };
|
||||
|
||||
int plain_implicit = (strcmp((char *)node->tag,
|
||||
YAML_DEFAULT_SCALAR_TAG) == 0);
|
||||
int quoted_implicit = (strcmp((char *)node->tag,
|
||||
YAML_DEFAULT_SCALAR_TAG) == 0);
|
||||
|
||||
SCALAR_EVENT_INIT(event, anchor, node->tag, node->data.scalar.value,
|
||||
node->data.scalar.length, plain_implicit, quoted_implicit,
|
||||
node->data.scalar.style, mark, mark);
|
||||
|
||||
return yaml_emitter_emit(emitter, &event);
|
||||
}
|
||||
|
||||
/*
|
||||
* Serialize a sequence.
|
||||
*/
|
||||
|
||||
static int
|
||||
yaml_emitter_dump_sequence(yaml_emitter_t *emitter, yaml_node_t *node,
|
||||
yaml_char_t *anchor)
|
||||
{
|
||||
yaml_event_t event;
|
||||
yaml_mark_t mark = { 0, 0, 0 };
|
||||
|
||||
int implicit = (strcmp((char *)node->tag, YAML_DEFAULT_SEQUENCE_TAG) == 0);
|
||||
|
||||
yaml_node_item_t *item;
|
||||
|
||||
SEQUENCE_START_EVENT_INIT(event, anchor, node->tag, implicit,
|
||||
node->data.sequence.style, mark, mark);
|
||||
if (!yaml_emitter_emit(emitter, &event)) return 0;
|
||||
|
||||
for (item = node->data.sequence.items.start;
|
||||
item < node->data.sequence.items.top; item ++) {
|
||||
if (!yaml_emitter_dump_node(emitter, *item)) return 0;
|
||||
}
|
||||
|
||||
SEQUENCE_END_EVENT_INIT(event, mark, mark);
|
||||
if (!yaml_emitter_emit(emitter, &event)) return 0;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Serialize a mapping.
|
||||
*/
|
||||
|
||||
static int
|
||||
yaml_emitter_dump_mapping(yaml_emitter_t *emitter, yaml_node_t *node,
|
||||
yaml_char_t *anchor)
|
||||
{
|
||||
yaml_event_t event;
|
||||
yaml_mark_t mark = { 0, 0, 0 };
|
||||
|
||||
int implicit = (strcmp((char *)node->tag, YAML_DEFAULT_MAPPING_TAG) == 0);
|
||||
|
||||
yaml_node_pair_t *pair;
|
||||
|
||||
MAPPING_START_EVENT_INIT(event, anchor, node->tag, implicit,
|
||||
node->data.mapping.style, mark, mark);
|
||||
if (!yaml_emitter_emit(emitter, &event)) return 0;
|
||||
|
||||
for (pair = node->data.mapping.pairs.start;
|
||||
pair < node->data.mapping.pairs.top; pair ++) {
|
||||
if (!yaml_emitter_dump_node(emitter, pair->key)) return 0;
|
||||
if (!yaml_emitter_dump_node(emitter, pair->value)) return 0;
|
||||
}
|
||||
|
||||
MAPPING_END_EVENT_INIT(event, mark, mark);
|
||||
if (!yaml_emitter_emit(emitter, &event)) return 0;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,444 @@
|
|||
|
||||
#include "yaml_private.h"
|
||||
|
||||
/*
|
||||
* API functions.
|
||||
*/
|
||||
|
||||
YAML_DECLARE(int)
|
||||
yaml_parser_load(yaml_parser_t *parser, yaml_document_t *document);
|
||||
|
||||
/*
|
||||
* Error handling.
|
||||
*/
|
||||
|
||||
static int
|
||||
yaml_parser_set_composer_error(yaml_parser_t *parser,
|
||||
const char *problem, yaml_mark_t problem_mark);
|
||||
|
||||
static int
|
||||
yaml_parser_set_composer_error_context(yaml_parser_t *parser,
|
||||
const char *context, yaml_mark_t context_mark,
|
||||
const char *problem, yaml_mark_t problem_mark);
|
||||
|
||||
|
||||
/*
|
||||
* Alias handling.
|
||||
*/
|
||||
|
||||
static int
|
||||
yaml_parser_register_anchor(yaml_parser_t *parser,
|
||||
int index, yaml_char_t *anchor);
|
||||
|
||||
/*
|
||||
* Clean up functions.
|
||||
*/
|
||||
|
||||
static void
|
||||
yaml_parser_delete_aliases(yaml_parser_t *parser);
|
||||
|
||||
/*
|
||||
* Composer functions.
|
||||
*/
|
||||
|
||||
static int
|
||||
yaml_parser_load_document(yaml_parser_t *parser, yaml_event_t *first_event);
|
||||
|
||||
static int
|
||||
yaml_parser_load_node(yaml_parser_t *parser, yaml_event_t *first_event);
|
||||
|
||||
static int
|
||||
yaml_parser_load_alias(yaml_parser_t *parser, yaml_event_t *first_event);
|
||||
|
||||
static int
|
||||
yaml_parser_load_scalar(yaml_parser_t *parser, yaml_event_t *first_event);
|
||||
|
||||
static int
|
||||
yaml_parser_load_sequence(yaml_parser_t *parser, yaml_event_t *first_event);
|
||||
|
||||
static int
|
||||
yaml_parser_load_mapping(yaml_parser_t *parser, yaml_event_t *first_event);
|
||||
|
||||
/*
|
||||
* Load the next document of the stream.
|
||||
*/
|
||||
|
||||
YAML_DECLARE(int)
|
||||
yaml_parser_load(yaml_parser_t *parser, yaml_document_t *document)
|
||||
{
|
||||
yaml_event_t event;
|
||||
|
||||
assert(parser); /* Non-NULL parser object is expected. */
|
||||
assert(document); /* Non-NULL document object is expected. */
|
||||
|
||||
memset(document, 0, sizeof(yaml_document_t));
|
||||
if (!STACK_INIT(parser, document->nodes, INITIAL_STACK_SIZE))
|
||||
goto error;
|
||||
|
||||
if (!parser->stream_start_produced) {
|
||||
if (!yaml_parser_parse(parser, &event)) goto error;
|
||||
assert(event.type == YAML_STREAM_START_EVENT);
|
||||
/* STREAM-START is expected. */
|
||||
}
|
||||
|
||||
if (parser->stream_end_produced) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (!yaml_parser_parse(parser, &event)) goto error;
|
||||
if (event.type == YAML_STREAM_END_EVENT) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (!STACK_INIT(parser, parser->aliases, INITIAL_STACK_SIZE))
|
||||
goto error;
|
||||
|
||||
parser->document = document;
|
||||
|
||||
if (!yaml_parser_load_document(parser, &event)) goto error;
|
||||
|
||||
yaml_parser_delete_aliases(parser);
|
||||
parser->document = NULL;
|
||||
|
||||
return 1;
|
||||
|
||||
error:
|
||||
|
||||
yaml_parser_delete_aliases(parser);
|
||||
yaml_document_delete(document);
|
||||
parser->document = NULL;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Set composer error.
|
||||
*/
|
||||
|
||||
static int
|
||||
yaml_parser_set_composer_error(yaml_parser_t *parser,
|
||||
const char *problem, yaml_mark_t problem_mark)
|
||||
{
|
||||
parser->error = YAML_COMPOSER_ERROR;
|
||||
parser->problem = problem;
|
||||
parser->problem_mark = problem_mark;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Set composer error with context.
|
||||
*/
|
||||
|
||||
static int
|
||||
yaml_parser_set_composer_error_context(yaml_parser_t *parser,
|
||||
const char *context, yaml_mark_t context_mark,
|
||||
const char *problem, yaml_mark_t problem_mark)
|
||||
{
|
||||
parser->error = YAML_COMPOSER_ERROR;
|
||||
parser->context = context;
|
||||
parser->context_mark = context_mark;
|
||||
parser->problem = problem;
|
||||
parser->problem_mark = problem_mark;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Delete the stack of aliases.
|
||||
*/
|
||||
|
||||
static void
|
||||
yaml_parser_delete_aliases(yaml_parser_t *parser)
|
||||
{
|
||||
while (!STACK_EMPTY(parser, parser->aliases)) {
|
||||
yaml_free(POP(parser, parser->aliases).anchor);
|
||||
}
|
||||
STACK_DEL(parser, parser->aliases);
|
||||
}
|
||||
|
||||
/*
|
||||
* Compose a document object.
|
||||
*/
|
||||
|
||||
static int
|
||||
yaml_parser_load_document(yaml_parser_t *parser, yaml_event_t *first_event)
|
||||
{
|
||||
yaml_event_t event;
|
||||
|
||||
assert(first_event->type == YAML_DOCUMENT_START_EVENT);
|
||||
/* DOCUMENT-START is expected. */
|
||||
|
||||
parser->document->version_directive
|
||||
= first_event->data.document_start.version_directive;
|
||||
parser->document->tag_directives.start
|
||||
= first_event->data.document_start.tag_directives.start;
|
||||
parser->document->tag_directives.end
|
||||
= first_event->data.document_start.tag_directives.end;
|
||||
parser->document->start_implicit
|
||||
= first_event->data.document_start.implicit;
|
||||
parser->document->start_mark = first_event->start_mark;
|
||||
|
||||
if (!yaml_parser_parse(parser, &event)) return 0;
|
||||
|
||||
if (!yaml_parser_load_node(parser, &event)) return 0;
|
||||
|
||||
if (!yaml_parser_parse(parser, &event)) return 0;
|
||||
assert(event.type == YAML_DOCUMENT_END_EVENT);
|
||||
/* DOCUMENT-END is expected. */
|
||||
|
||||
parser->document->end_implicit = event.data.document_end.implicit;
|
||||
parser->document->end_mark = event.end_mark;
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Compose a node.
|
||||
*/
|
||||
|
||||
static int
|
||||
yaml_parser_load_node(yaml_parser_t *parser, yaml_event_t *first_event)
|
||||
{
|
||||
switch (first_event->type) {
|
||||
case YAML_ALIAS_EVENT:
|
||||
return yaml_parser_load_alias(parser, first_event);
|
||||
case YAML_SCALAR_EVENT:
|
||||
return yaml_parser_load_scalar(parser, first_event);
|
||||
case YAML_SEQUENCE_START_EVENT:
|
||||
return yaml_parser_load_sequence(parser, first_event);
|
||||
case YAML_MAPPING_START_EVENT:
|
||||
return yaml_parser_load_mapping(parser, first_event);
|
||||
default:
|
||||
assert(0); /* Could not happen. */
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Add an anchor.
|
||||
*/
|
||||
|
||||
static int
|
||||
yaml_parser_register_anchor(yaml_parser_t *parser,
|
||||
int index, yaml_char_t *anchor)
|
||||
{
|
||||
yaml_alias_data_t data;
|
||||
yaml_alias_data_t *alias_data;
|
||||
|
||||
if (!anchor) return 1;
|
||||
|
||||
data.anchor = anchor;
|
||||
data.index = index;
|
||||
data.mark = parser->document->nodes.start[index-1].start_mark;
|
||||
|
||||
for (alias_data = parser->aliases.start;
|
||||
alias_data != parser->aliases.top; alias_data ++) {
|
||||
if (strcmp((char *)alias_data->anchor, (char *)anchor) == 0) {
|
||||
yaml_free(anchor);
|
||||
return yaml_parser_set_composer_error_context(parser,
|
||||
"found duplicate anchor; first occurence",
|
||||
alias_data->mark, "second occurence", data.mark);
|
||||
}
|
||||
}
|
||||
|
||||
if (!PUSH(parser, parser->aliases, data)) {
|
||||
yaml_free(anchor);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Compose a node corresponding to an alias.
|
||||
*/
|
||||
|
||||
static int
|
||||
yaml_parser_load_alias(yaml_parser_t *parser, yaml_event_t *first_event)
|
||||
{
|
||||
yaml_char_t *anchor = first_event->data.alias.anchor;
|
||||
yaml_alias_data_t *alias_data;
|
||||
|
||||
for (alias_data = parser->aliases.start;
|
||||
alias_data != parser->aliases.top; alias_data ++) {
|
||||
if (strcmp((char *)alias_data->anchor, (char *)anchor) == 0) {
|
||||
yaml_free(anchor);
|
||||
return alias_data->index;
|
||||
}
|
||||
}
|
||||
|
||||
yaml_free(anchor);
|
||||
return yaml_parser_set_composer_error(parser, "found undefined alias",
|
||||
first_event->start_mark);
|
||||
}
|
||||
|
||||
/*
|
||||
* Compose a scalar node.
|
||||
*/
|
||||
|
||||
static int
|
||||
yaml_parser_load_scalar(yaml_parser_t *parser, yaml_event_t *first_event)
|
||||
{
|
||||
yaml_node_t node;
|
||||
int index;
|
||||
yaml_char_t *tag = first_event->data.scalar.tag;
|
||||
|
||||
if (!STACK_LIMIT(parser, parser->document->nodes, INT_MAX-1)) goto error;
|
||||
|
||||
if (!tag || strcmp((char *)tag, "!") == 0) {
|
||||
yaml_free(tag);
|
||||
tag = yaml_strdup((yaml_char_t *)YAML_DEFAULT_SCALAR_TAG);
|
||||
if (!tag) goto error;
|
||||
}
|
||||
|
||||
SCALAR_NODE_INIT(node, tag, first_event->data.scalar.value,
|
||||
first_event->data.scalar.length, first_event->data.scalar.style,
|
||||
first_event->start_mark, first_event->end_mark);
|
||||
|
||||
if (!PUSH(parser, parser->document->nodes, node)) goto error;
|
||||
|
||||
index = parser->document->nodes.top - parser->document->nodes.start;
|
||||
|
||||
if (!yaml_parser_register_anchor(parser, index,
|
||||
first_event->data.scalar.anchor)) return 0;
|
||||
|
||||
return index;
|
||||
|
||||
error:
|
||||
yaml_free(tag);
|
||||
yaml_free(first_event->data.scalar.anchor);
|
||||
yaml_free(first_event->data.scalar.value);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Compose a sequence node.
|
||||
*/
|
||||
|
||||
static int
|
||||
yaml_parser_load_sequence(yaml_parser_t *parser, yaml_event_t *first_event)
|
||||
{
|
||||
yaml_event_t event;
|
||||
yaml_node_t node;
|
||||
struct {
|
||||
yaml_node_item_t *start;
|
||||
yaml_node_item_t *end;
|
||||
yaml_node_item_t *top;
|
||||
} items = { NULL, NULL, NULL };
|
||||
int index, item_index;
|
||||
yaml_char_t *tag = first_event->data.sequence_start.tag;
|
||||
|
||||
if (!STACK_LIMIT(parser, parser->document->nodes, INT_MAX-1)) goto error;
|
||||
|
||||
if (!tag || strcmp((char *)tag, "!") == 0) {
|
||||
yaml_free(tag);
|
||||
tag = yaml_strdup((yaml_char_t *)YAML_DEFAULT_SEQUENCE_TAG);
|
||||
if (!tag) goto error;
|
||||
}
|
||||
|
||||
if (!STACK_INIT(parser, items, INITIAL_STACK_SIZE)) goto error;
|
||||
|
||||
SEQUENCE_NODE_INIT(node, tag, items.start, items.end,
|
||||
first_event->data.sequence_start.style,
|
||||
first_event->start_mark, first_event->end_mark);
|
||||
|
||||
if (!PUSH(parser, parser->document->nodes, node)) goto error;
|
||||
|
||||
index = parser->document->nodes.top - parser->document->nodes.start;
|
||||
|
||||
if (!yaml_parser_register_anchor(parser, index,
|
||||
first_event->data.sequence_start.anchor)) return 0;
|
||||
|
||||
if (!yaml_parser_parse(parser, &event)) return 0;
|
||||
|
||||
while (event.type != YAML_SEQUENCE_END_EVENT) {
|
||||
if (!STACK_LIMIT(parser,
|
||||
parser->document->nodes.start[index-1].data.sequence.items,
|
||||
INT_MAX-1)) return 0;
|
||||
item_index = yaml_parser_load_node(parser, &event);
|
||||
if (!item_index) return 0;
|
||||
if (!PUSH(parser,
|
||||
parser->document->nodes.start[index-1].data.sequence.items,
|
||||
item_index)) return 0;
|
||||
if (!yaml_parser_parse(parser, &event)) return 0;
|
||||
}
|
||||
|
||||
parser->document->nodes.start[index-1].end_mark = event.end_mark;
|
||||
|
||||
return index;
|
||||
|
||||
error:
|
||||
yaml_free(tag);
|
||||
yaml_free(first_event->data.sequence_start.anchor);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Compose a mapping node.
|
||||
*/
|
||||
|
||||
static int
|
||||
yaml_parser_load_mapping(yaml_parser_t *parser, yaml_event_t *first_event)
|
||||
{
|
||||
yaml_event_t event;
|
||||
yaml_node_t node;
|
||||
struct {
|
||||
yaml_node_pair_t *start;
|
||||
yaml_node_pair_t *end;
|
||||
yaml_node_pair_t *top;
|
||||
} pairs = { NULL, NULL, NULL };
|
||||
int index;
|
||||
yaml_node_pair_t pair;
|
||||
yaml_char_t *tag = first_event->data.mapping_start.tag;
|
||||
|
||||
if (!STACK_LIMIT(parser, parser->document->nodes, INT_MAX-1)) goto error;
|
||||
|
||||
if (!tag || strcmp((char *)tag, "!") == 0) {
|
||||
yaml_free(tag);
|
||||
tag = yaml_strdup((yaml_char_t *)YAML_DEFAULT_MAPPING_TAG);
|
||||
if (!tag) goto error;
|
||||
}
|
||||
|
||||
if (!STACK_INIT(parser, pairs, INITIAL_STACK_SIZE)) goto error;
|
||||
|
||||
MAPPING_NODE_INIT(node, tag, pairs.start, pairs.end,
|
||||
first_event->data.mapping_start.style,
|
||||
first_event->start_mark, first_event->end_mark);
|
||||
|
||||
if (!PUSH(parser, parser->document->nodes, node)) goto error;
|
||||
|
||||
index = parser->document->nodes.top - parser->document->nodes.start;
|
||||
|
||||
if (!yaml_parser_register_anchor(parser, index,
|
||||
first_event->data.mapping_start.anchor)) return 0;
|
||||
|
||||
if (!yaml_parser_parse(parser, &event)) return 0;
|
||||
|
||||
while (event.type != YAML_MAPPING_END_EVENT) {
|
||||
if (!STACK_LIMIT(parser,
|
||||
parser->document->nodes.start[index-1].data.mapping.pairs,
|
||||
INT_MAX-1)) return 0;
|
||||
pair.key = yaml_parser_load_node(parser, &event);
|
||||
if (!pair.key) return 0;
|
||||
if (!yaml_parser_parse(parser, &event)) return 0;
|
||||
pair.value = yaml_parser_load_node(parser, &event);
|
||||
if (!pair.value) return 0;
|
||||
if (!PUSH(parser,
|
||||
parser->document->nodes.start[index-1].data.mapping.pairs,
|
||||
pair)) return 0;
|
||||
if (!yaml_parser_parse(parser, &event)) return 0;
|
||||
}
|
||||
|
||||
parser->document->nodes.start[index-1].end_mark = event.end_mark;
|
||||
|
||||
return index;
|
||||
|
||||
error:
|
||||
yaml_free(tag);
|
||||
yaml_free(first_event->data.mapping_start.anchor);
|
||||
return 0;
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,469 @@
|
|||
|
||||
#include "yaml_private.h"
|
||||
|
||||
/*
|
||||
* Declarations.
|
||||
*/
|
||||
|
||||
static int
|
||||
yaml_parser_set_reader_error(yaml_parser_t *parser, const char *problem,
|
||||
size_t offset, int value);
|
||||
|
||||
static int
|
||||
yaml_parser_update_raw_buffer(yaml_parser_t *parser);
|
||||
|
||||
static int
|
||||
yaml_parser_determine_encoding(yaml_parser_t *parser);
|
||||
|
||||
YAML_DECLARE(int)
|
||||
yaml_parser_update_buffer(yaml_parser_t *parser, size_t length);
|
||||
|
||||
/*
|
||||
* Set the reader error and return 0.
|
||||
*/
|
||||
|
||||
static int
|
||||
yaml_parser_set_reader_error(yaml_parser_t *parser, const char *problem,
|
||||
size_t offset, int value)
|
||||
{
|
||||
parser->error = YAML_READER_ERROR;
|
||||
parser->problem = problem;
|
||||
parser->problem_offset = offset;
|
||||
parser->problem_value = value;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Byte order marks.
|
||||
*/
|
||||
|
||||
#define BOM_UTF8 "\xef\xbb\xbf"
|
||||
#define BOM_UTF16LE "\xff\xfe"
|
||||
#define BOM_UTF16BE "\xfe\xff"
|
||||
|
||||
/*
|
||||
* Determine the input stream encoding by checking the BOM symbol. If no BOM is
|
||||
* found, the UTF-8 encoding is assumed. Return 1 on success, 0 on failure.
|
||||
*/
|
||||
|
||||
static int
|
||||
yaml_parser_determine_encoding(yaml_parser_t *parser)
|
||||
{
|
||||
/* Ensure that we had enough bytes in the raw buffer. */
|
||||
|
||||
while (!parser->eof
|
||||
&& parser->raw_buffer.last - parser->raw_buffer.pointer < 3) {
|
||||
if (!yaml_parser_update_raw_buffer(parser)) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
/* Determine the encoding. */
|
||||
|
||||
if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 2
|
||||
&& !memcmp(parser->raw_buffer.pointer, BOM_UTF16LE, 2)) {
|
||||
parser->encoding = YAML_UTF16LE_ENCODING;
|
||||
parser->raw_buffer.pointer += 2;
|
||||
parser->offset += 2;
|
||||
}
|
||||
else if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 2
|
||||
&& !memcmp(parser->raw_buffer.pointer, BOM_UTF16BE, 2)) {
|
||||
parser->encoding = YAML_UTF16BE_ENCODING;
|
||||
parser->raw_buffer.pointer += 2;
|
||||
parser->offset += 2;
|
||||
}
|
||||
else if (parser->raw_buffer.last - parser->raw_buffer.pointer >= 3
|
||||
&& !memcmp(parser->raw_buffer.pointer, BOM_UTF8, 3)) {
|
||||
parser->encoding = YAML_UTF8_ENCODING;
|
||||
parser->raw_buffer.pointer += 3;
|
||||
parser->offset += 3;
|
||||
}
|
||||
else {
|
||||
parser->encoding = YAML_UTF8_ENCODING;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Update the raw buffer.
|
||||
*/
|
||||
|
||||
static int
|
||||
yaml_parser_update_raw_buffer(yaml_parser_t *parser)
|
||||
{
|
||||
size_t size_read = 0;
|
||||
|
||||
/* Return if the raw buffer is full. */
|
||||
|
||||
if (parser->raw_buffer.start == parser->raw_buffer.pointer
|
||||
&& parser->raw_buffer.last == parser->raw_buffer.end)
|
||||
return 1;
|
||||
|
||||
/* Return on EOF. */
|
||||
|
||||
if (parser->eof) return 1;
|
||||
|
||||
/* Move the remaining bytes in the raw buffer to the beginning. */
|
||||
|
||||
if (parser->raw_buffer.start < parser->raw_buffer.pointer
|
||||
&& parser->raw_buffer.pointer < parser->raw_buffer.last) {
|
||||
memmove(parser->raw_buffer.start, parser->raw_buffer.pointer,
|
||||
parser->raw_buffer.last - parser->raw_buffer.pointer);
|
||||
}
|
||||
parser->raw_buffer.last -=
|
||||
parser->raw_buffer.pointer - parser->raw_buffer.start;
|
||||
parser->raw_buffer.pointer = parser->raw_buffer.start;
|
||||
|
||||
/* Call the read handler to fill the buffer. */
|
||||
|
||||
if (!parser->read_handler(parser->read_handler_data, parser->raw_buffer.last,
|
||||
parser->raw_buffer.end - parser->raw_buffer.last, &size_read)) {
|
||||
return yaml_parser_set_reader_error(parser, "input error",
|
||||
parser->offset, -1);
|
||||
}
|
||||
parser->raw_buffer.last += size_read;
|
||||
if (!size_read) {
|
||||
parser->eof = 1;
|
||||
}
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* Ensure that the buffer contains at least `length` characters.
|
||||
* Return 1 on success, 0 on failure.
|
||||
*
|
||||
* The length is supposed to be significantly less that the buffer size.
|
||||
*/
|
||||
|
||||
YAML_DECLARE(int)
|
||||
yaml_parser_update_buffer(yaml_parser_t *parser, size_t length)
|
||||
{
|
||||
int first = 1;
|
||||
|
||||
assert(parser->read_handler); /* Read handler must be set. */
|
||||
|
||||
/* If the EOF flag is set and the raw buffer is empty, do nothing. */
|
||||
|
||||
if (parser->eof && parser->raw_buffer.pointer == parser->raw_buffer.last)
|
||||
return 1;
|
||||
|
||||
/* Return if the buffer contains enough characters. */
|
||||
|
||||
if (parser->unread >= length)
|
||||
return 1;
|
||||
|
||||
/* Determine the input encoding if it is not known yet. */
|
||||
|
||||
if (!parser->encoding) {
|
||||
if (!yaml_parser_determine_encoding(parser))
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Move the unread characters to the beginning of the buffer. */
|
||||
|
||||
if (parser->buffer.start < parser->buffer.pointer
|
||||
&& parser->buffer.pointer < parser->buffer.last) {
|
||||
size_t size = parser->buffer.last - parser->buffer.pointer;
|
||||
memmove(parser->buffer.start, parser->buffer.pointer, size);
|
||||
parser->buffer.pointer = parser->buffer.start;
|
||||
parser->buffer.last = parser->buffer.start + size;
|
||||
}
|
||||
else if (parser->buffer.pointer == parser->buffer.last) {
|
||||
parser->buffer.pointer = parser->buffer.start;
|
||||
parser->buffer.last = parser->buffer.start;
|
||||
}
|
||||
|
||||
/* Fill the buffer until it has enough characters. */
|
||||
|
||||
while (parser->unread < length)
|
||||
{
|
||||
/* Fill the raw buffer if necessary. */
|
||||
|
||||
if (!first || parser->raw_buffer.pointer == parser->raw_buffer.last) {
|
||||
if (!yaml_parser_update_raw_buffer(parser)) return 0;
|
||||
}
|
||||
first = 0;
|
||||
|
||||
/* Decode the raw buffer. */
|
||||
|
||||
while (parser->raw_buffer.pointer != parser->raw_buffer.last)
|
||||
{
|
||||
unsigned int value = 0, value2 = 0;
|
||||
int incomplete = 0;
|
||||
unsigned char octet;
|
||||
unsigned int width = 0;
|
||||
int low, high;
|
||||
size_t k;
|
||||
size_t raw_unread = parser->raw_buffer.last - parser->raw_buffer.pointer;
|
||||
|
||||
/* Decode the next character. */
|
||||
|
||||
switch (parser->encoding)
|
||||
{
|
||||
case YAML_UTF8_ENCODING:
|
||||
|
||||
/*
|
||||
* Decode a UTF-8 character. Check RFC 3629
|
||||
* (http://www.ietf.org/rfc/rfc3629.txt) for more details.
|
||||
*
|
||||
* The following table (taken from the RFC) is used for
|
||||
* decoding.
|
||||
*
|
||||
* Char. number range | UTF-8 octet sequence
|
||||
* (hexadecimal) | (binary)
|
||||
* --------------------+------------------------------------
|
||||
* 0000 0000-0000 007F | 0xxxxxxx
|
||||
* 0000 0080-0000 07FF | 110xxxxx 10xxxxxx
|
||||
* 0000 0800-0000 FFFF | 1110xxxx 10xxxxxx 10xxxxxx
|
||||
* 0001 0000-0010 FFFF | 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
|
||||
*
|
||||
* Additionally, the characters in the range 0xD800-0xDFFF
|
||||
* are prohibited as they are reserved for use with UTF-16
|
||||
* surrogate pairs.
|
||||
*/
|
||||
|
||||
/* Determine the length of the UTF-8 sequence. */
|
||||
|
||||
octet = parser->raw_buffer.pointer[0];
|
||||
width = (octet & 0x80) == 0x00 ? 1 :
|
||||
(octet & 0xE0) == 0xC0 ? 2 :
|
||||
(octet & 0xF0) == 0xE0 ? 3 :
|
||||
(octet & 0xF8) == 0xF0 ? 4 : 0;
|
||||
|
||||
/* Check if the leading octet is valid. */
|
||||
|
||||
if (!width)
|
||||
return yaml_parser_set_reader_error(parser,
|
||||
"invalid leading UTF-8 octet",
|
||||
parser->offset, octet);
|
||||
|
||||
/* Check if the raw buffer contains an incomplete character. */
|
||||
|
||||
if (width > raw_unread) {
|
||||
if (parser->eof) {
|
||||
return yaml_parser_set_reader_error(parser,
|
||||
"incomplete UTF-8 octet sequence",
|
||||
parser->offset, -1);
|
||||
}
|
||||
incomplete = 1;
|
||||
break;
|
||||
}
|
||||
|
||||
/* Decode the leading octet. */
|
||||
|
||||
value = (octet & 0x80) == 0x00 ? octet & 0x7F :
|
||||
(octet & 0xE0) == 0xC0 ? octet & 0x1F :
|
||||
(octet & 0xF0) == 0xE0 ? octet & 0x0F :
|
||||
(octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
|
||||
|
||||
/* Check and decode the trailing octets. */
|
||||
|
||||
for (k = 1; k < width; k ++)
|
||||
{
|
||||
octet = parser->raw_buffer.pointer[k];
|
||||
|
||||
/* Check if the octet is valid. */
|
||||
|
||||
if ((octet & 0xC0) != 0x80)
|
||||
return yaml_parser_set_reader_error(parser,
|
||||
"invalid trailing UTF-8 octet",
|
||||
parser->offset+k, octet);
|
||||
|
||||
/* Decode the octet. */
|
||||
|
||||
value = (value << 6) + (octet & 0x3F);
|
||||
}
|
||||
|
||||
/* Check the length of the sequence against the value. */
|
||||
|
||||
if (!((width == 1) ||
|
||||
(width == 2 && value >= 0x80) ||
|
||||
(width == 3 && value >= 0x800) ||
|
||||
(width == 4 && value >= 0x10000)))
|
||||
return yaml_parser_set_reader_error(parser,
|
||||
"invalid length of a UTF-8 sequence",
|
||||
parser->offset, -1);
|
||||
|
||||
/* Check the range of the value. */
|
||||
|
||||
if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF)
|
||||
return yaml_parser_set_reader_error(parser,
|
||||
"invalid Unicode character",
|
||||
parser->offset, value);
|
||||
|
||||
break;
|
||||
|
||||
case YAML_UTF16LE_ENCODING:
|
||||
case YAML_UTF16BE_ENCODING:
|
||||
|
||||
low = (parser->encoding == YAML_UTF16LE_ENCODING ? 0 : 1);
|
||||
high = (parser->encoding == YAML_UTF16LE_ENCODING ? 1 : 0);
|
||||
|
||||
/*
|
||||
* The UTF-16 encoding is not as simple as one might
|
||||
* naively think. Check RFC 2781
|
||||
* (http://www.ietf.org/rfc/rfc2781.txt).
|
||||
*
|
||||
* Normally, two subsequent bytes describe a Unicode
|
||||
* character. However a special technique (called a
|
||||
* surrogate pair) is used for specifying character
|
||||
* values larger than 0xFFFF.
|
||||
*
|
||||
* A surrogate pair consists of two pseudo-characters:
|
||||
* high surrogate area (0xD800-0xDBFF)
|
||||
* low surrogate area (0xDC00-0xDFFF)
|
||||
*
|
||||
* The following formulas are used for decoding
|
||||
* and encoding characters using surrogate pairs:
|
||||
*
|
||||
* U = U' + 0x10000 (0x01 00 00 <= U <= 0x10 FF FF)
|
||||
* U' = yyyyyyyyyyxxxxxxxxxx (0 <= U' <= 0x0F FF FF)
|
||||
* W1 = 110110yyyyyyyyyy
|
||||
* W2 = 110111xxxxxxxxxx
|
||||
*
|
||||
* where U is the character value, W1 is the high surrogate
|
||||
* area, W2 is the low surrogate area.
|
||||
*/
|
||||
|
||||
/* Check for incomplete UTF-16 character. */
|
||||
|
||||
if (raw_unread < 2) {
|
||||
if (parser->eof) {
|
||||
return yaml_parser_set_reader_error(parser,
|
||||
"incomplete UTF-16 character",
|
||||
parser->offset, -1);
|
||||
}
|
||||
incomplete = 1;
|
||||
break;
|
||||
}
|
||||
|
||||
/* Get the character. */
|
||||
|
||||
value = parser->raw_buffer.pointer[low]
|
||||
+ (parser->raw_buffer.pointer[high] << 8);
|
||||
|
||||
/* Check for unexpected low surrogate area. */
|
||||
|
||||
if ((value & 0xFC00) == 0xDC00)
|
||||
return yaml_parser_set_reader_error(parser,
|
||||
"unexpected low surrogate area",
|
||||
parser->offset, value);
|
||||
|
||||
/* Check for a high surrogate area. */
|
||||
|
||||
if ((value & 0xFC00) == 0xD800) {
|
||||
|
||||
width = 4;
|
||||
|
||||
/* Check for incomplete surrogate pair. */
|
||||
|
||||
if (raw_unread < 4) {
|
||||
if (parser->eof) {
|
||||
return yaml_parser_set_reader_error(parser,
|
||||
"incomplete UTF-16 surrogate pair",
|
||||
parser->offset, -1);
|
||||
}
|
||||
incomplete = 1;
|
||||
break;
|
||||
}
|
||||
|
||||
/* Get the next character. */
|
||||
|
||||
value2 = parser->raw_buffer.pointer[low+2]
|
||||
+ (parser->raw_buffer.pointer[high+2] << 8);
|
||||
|
||||
/* Check for a low surrogate area. */
|
||||
|
||||
if ((value2 & 0xFC00) != 0xDC00)
|
||||
return yaml_parser_set_reader_error(parser,
|
||||
"expected low surrogate area",
|
||||
parser->offset+2, value2);
|
||||
|
||||
/* Generate the value of the surrogate pair. */
|
||||
|
||||
value = 0x10000 + ((value & 0x3FF) << 10) + (value2 & 0x3FF);
|
||||
}
|
||||
|
||||
else {
|
||||
width = 2;
|
||||
}
|
||||
|
||||
break;
|
||||
|
||||
default:
|
||||
assert(1); /* Impossible. */
|
||||
}
|
||||
|
||||
/* Check if the raw buffer contains enough bytes to form a character. */
|
||||
|
||||
if (incomplete) break;
|
||||
|
||||
/*
|
||||
* Check if the character is in the allowed range:
|
||||
* #x9 | #xA | #xD | [#x20-#x7E] (8 bit)
|
||||
* | #x85 | [#xA0-#xD7FF] | [#xE000-#xFFFD] (16 bit)
|
||||
* | [#x10000-#x10FFFF] (32 bit)
|
||||
*/
|
||||
|
||||
if (! (value == 0x09 || value == 0x0A || value == 0x0D
|
||||
|| (value >= 0x20 && value <= 0x7E)
|
||||
|| (value == 0x85) || (value >= 0xA0 && value <= 0xD7FF)
|
||||
|| (value >= 0xE000 && value <= 0xFFFD)
|
||||
|| (value >= 0x10000 && value <= 0x10FFFF)))
|
||||
return yaml_parser_set_reader_error(parser,
|
||||
"control characters are not allowed",
|
||||
parser->offset, value);
|
||||
|
||||
/* Move the raw pointers. */
|
||||
|
||||
parser->raw_buffer.pointer += width;
|
||||
parser->offset += width;
|
||||
|
||||
/* Finally put the character into the buffer. */
|
||||
|
||||
/* 0000 0000-0000 007F -> 0xxxxxxx */
|
||||
if (value <= 0x7F) {
|
||||
*(parser->buffer.last++) = value;
|
||||
}
|
||||
/* 0000 0080-0000 07FF -> 110xxxxx 10xxxxxx */
|
||||
else if (value <= 0x7FF) {
|
||||
*(parser->buffer.last++) = 0xC0 + (value >> 6);
|
||||
*(parser->buffer.last++) = 0x80 + (value & 0x3F);
|
||||
}
|
||||
/* 0000 0800-0000 FFFF -> 1110xxxx 10xxxxxx 10xxxxxx */
|
||||
else if (value <= 0xFFFF) {
|
||||
*(parser->buffer.last++) = 0xE0 + (value >> 12);
|
||||
*(parser->buffer.last++) = 0x80 + ((value >> 6) & 0x3F);
|
||||
*(parser->buffer.last++) = 0x80 + (value & 0x3F);
|
||||
}
|
||||
/* 0001 0000-0010 FFFF -> 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
|
||||
else {
|
||||
*(parser->buffer.last++) = 0xF0 + (value >> 18);
|
||||
*(parser->buffer.last++) = 0x80 + ((value >> 12) & 0x3F);
|
||||
*(parser->buffer.last++) = 0x80 + ((value >> 6) & 0x3F);
|
||||
*(parser->buffer.last++) = 0x80 + (value & 0x3F);
|
||||
}
|
||||
|
||||
parser->unread ++;
|
||||
}
|
||||
|
||||
/* On EOF, put NUL into the buffer and return. */
|
||||
|
||||
if (parser->eof) {
|
||||
*(parser->buffer.last++) = '\0';
|
||||
parser->unread ++;
|
||||
return 1;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
if (parser->offset >= PTRDIFF_MAX)
|
||||
return yaml_parser_set_reader_error(parser, "input is too long",
|
||||
PTRDIFF_MAX, -1);
|
||||
|
||||
return 1;
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,141 @@
|
|||
|
||||
#include "yaml_private.h"
|
||||
|
||||
/*
|
||||
* Declarations.
|
||||
*/
|
||||
|
||||
static int
|
||||
yaml_emitter_set_writer_error(yaml_emitter_t *emitter, const char *problem);
|
||||
|
||||
YAML_DECLARE(int)
|
||||
yaml_emitter_flush(yaml_emitter_t *emitter);
|
||||
|
||||
/*
|
||||
* Set the writer error and return 0.
|
||||
*/
|
||||
|
||||
static int
|
||||
yaml_emitter_set_writer_error(yaml_emitter_t *emitter, const char *problem)
|
||||
{
|
||||
emitter->error = YAML_WRITER_ERROR;
|
||||
emitter->problem = problem;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Flush the output buffer.
|
||||
*/
|
||||
|
||||
YAML_DECLARE(int)
|
||||
yaml_emitter_flush(yaml_emitter_t *emitter)
|
||||
{
|
||||
int low, high;
|
||||
|
||||
assert(emitter); /* Non-NULL emitter object is expected. */
|
||||
assert(emitter->write_handler); /* Write handler must be set. */
|
||||
assert(emitter->encoding); /* Output encoding must be set. */
|
||||
|
||||
emitter->buffer.last = emitter->buffer.pointer;
|
||||
emitter->buffer.pointer = emitter->buffer.start;
|
||||
|
||||
/* Check if the buffer is empty. */
|
||||
|
||||
if (emitter->buffer.start == emitter->buffer.last) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
/* If the output encoding is UTF-8, we don't need to recode the buffer. */
|
||||
|
||||
if (emitter->encoding == YAML_UTF8_ENCODING)
|
||||
{
|
||||
if (emitter->write_handler(emitter->write_handler_data,
|
||||
emitter->buffer.start,
|
||||
emitter->buffer.last - emitter->buffer.start)) {
|
||||
emitter->buffer.last = emitter->buffer.start;
|
||||
emitter->buffer.pointer = emitter->buffer.start;
|
||||
return 1;
|
||||
}
|
||||
else {
|
||||
return yaml_emitter_set_writer_error(emitter, "write error");
|
||||
}
|
||||
}
|
||||
|
||||
/* Recode the buffer into the raw buffer. */
|
||||
|
||||
low = (emitter->encoding == YAML_UTF16LE_ENCODING ? 0 : 1);
|
||||
high = (emitter->encoding == YAML_UTF16LE_ENCODING ? 1 : 0);
|
||||
|
||||
while (emitter->buffer.pointer != emitter->buffer.last)
|
||||
{
|
||||
unsigned char octet;
|
||||
unsigned int width;
|
||||
unsigned int value;
|
||||
size_t k;
|
||||
|
||||
/*
|
||||
* See the "reader.c" code for more details on UTF-8 encoding. Note
|
||||
* that we assume that the buffer contains a valid UTF-8 sequence.
|
||||
*/
|
||||
|
||||
/* Read the next UTF-8 character. */
|
||||
|
||||
octet = emitter->buffer.pointer[0];
|
||||
|
||||
width = (octet & 0x80) == 0x00 ? 1 :
|
||||
(octet & 0xE0) == 0xC0 ? 2 :
|
||||
(octet & 0xF0) == 0xE0 ? 3 :
|
||||
(octet & 0xF8) == 0xF0 ? 4 : 0;
|
||||
|
||||
value = (octet & 0x80) == 0x00 ? octet & 0x7F :
|
||||
(octet & 0xE0) == 0xC0 ? octet & 0x1F :
|
||||
(octet & 0xF0) == 0xE0 ? octet & 0x0F :
|
||||
(octet & 0xF8) == 0xF0 ? octet & 0x07 : 0;
|
||||
|
||||
for (k = 1; k < width; k ++) {
|
||||
octet = emitter->buffer.pointer[k];
|
||||
value = (value << 6) + (octet & 0x3F);
|
||||
}
|
||||
|
||||
emitter->buffer.pointer += width;
|
||||
|
||||
/* Write the character. */
|
||||
|
||||
if (value < 0x10000)
|
||||
{
|
||||
emitter->raw_buffer.last[high] = value >> 8;
|
||||
emitter->raw_buffer.last[low] = value & 0xFF;
|
||||
|
||||
emitter->raw_buffer.last += 2;
|
||||
}
|
||||
else
|
||||
{
|
||||
/* Write the character using a surrogate pair (check "reader.c"). */
|
||||
|
||||
value -= 0x10000;
|
||||
emitter->raw_buffer.last[high] = 0xD8 + (value >> 18);
|
||||
emitter->raw_buffer.last[low] = (value >> 10) & 0xFF;
|
||||
emitter->raw_buffer.last[high+2] = 0xDC + ((value >> 8) & 0xFF);
|
||||
emitter->raw_buffer.last[low+2] = value & 0xFF;
|
||||
|
||||
emitter->raw_buffer.last += 4;
|
||||
}
|
||||
}
|
||||
|
||||
/* Write the raw buffer. */
|
||||
|
||||
if (emitter->write_handler(emitter->write_handler_data,
|
||||
emitter->raw_buffer.start,
|
||||
emitter->raw_buffer.last - emitter->raw_buffer.start)) {
|
||||
emitter->buffer.last = emitter->buffer.start;
|
||||
emitter->buffer.pointer = emitter->buffer.start;
|
||||
emitter->raw_buffer.last = emitter->raw_buffer.start;
|
||||
emitter->raw_buffer.pointer = emitter->raw_buffer.start;
|
||||
return 1;
|
||||
}
|
||||
else {
|
||||
return yaml_emitter_set_writer_error(emitter, "write error");
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -0,0 +1,658 @@
|
|||
|
||||
#include "config.h"
|
||||
|
||||
#include <yaml.h>
|
||||
|
||||
#include <assert.h>
|
||||
#include <limits.h>
|
||||
#include <stddef.h>
|
||||
|
||||
#ifndef _MSC_VER
|
||||
#include <stdint.h>
|
||||
#else
|
||||
#ifdef _WIN64
|
||||
#define PTRDIFF_MAX _I64_MAX
|
||||
#else
|
||||
#define PTRDIFF_MAX INT_MAX
|
||||
#endif
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Memory management.
|
||||
*/
|
||||
|
||||
YAML_DECLARE(void *)
|
||||
yaml_malloc(size_t size);
|
||||
|
||||
YAML_DECLARE(void *)
|
||||
yaml_realloc(void *ptr, size_t size);
|
||||
|
||||
YAML_DECLARE(void)
|
||||
yaml_free(void *ptr);
|
||||
|
||||
YAML_DECLARE(yaml_char_t *)
|
||||
yaml_strdup(const yaml_char_t *);
|
||||
|
||||
/*
|
||||
* Reader: Ensure that the buffer contains at least `length` characters.
|
||||
*/
|
||||
|
||||
YAML_DECLARE(int)
|
||||
yaml_parser_update_buffer(yaml_parser_t *parser, size_t length);
|
||||
|
||||
/*
|
||||
* Scanner: Ensure that the token stack contains at least one token ready.
|
||||
*/
|
||||
|
||||
YAML_DECLARE(int)
|
||||
yaml_parser_fetch_more_tokens(yaml_parser_t *parser);
|
||||
|
||||
/*
|
||||
* The size of the input raw buffer.
|
||||
*/
|
||||
|
||||
#define INPUT_RAW_BUFFER_SIZE 16384
|
||||
|
||||
/*
|
||||
* The size of the input buffer.
|
||||
*
|
||||
* It should be possible to decode the whole raw buffer.
|
||||
*/
|
||||
|
||||
#define INPUT_BUFFER_SIZE (INPUT_RAW_BUFFER_SIZE*3)
|
||||
|
||||
/*
|
||||
* The size of the output buffer.
|
||||
*/
|
||||
|
||||
#define OUTPUT_BUFFER_SIZE 16384
|
||||
|
||||
/*
|
||||
* The size of the output raw buffer.
|
||||
*
|
||||
* It should be possible to encode the whole output buffer.
|
||||
*/
|
||||
|
||||
#define OUTPUT_RAW_BUFFER_SIZE (OUTPUT_BUFFER_SIZE*2+2)
|
||||
|
||||
/*
|
||||
* The size of other stacks and queues.
|
||||
*/
|
||||
|
||||
#define INITIAL_STACK_SIZE 16
|
||||
#define INITIAL_QUEUE_SIZE 16
|
||||
#define INITIAL_STRING_SIZE 16
|
||||
|
||||
/*
|
||||
* Buffer management.
|
||||
*/
|
||||
|
||||
#define BUFFER_INIT(context,buffer,size) \
|
||||
(((buffer).start = yaml_malloc(size)) ? \
|
||||
((buffer).last = (buffer).pointer = (buffer).start, \
|
||||
(buffer).end = (buffer).start+(size), \
|
||||
1) : \
|
||||
((context)->error = YAML_MEMORY_ERROR, \
|
||||
0))
|
||||
|
||||
#define BUFFER_DEL(context,buffer) \
|
||||
(yaml_free((buffer).start), \
|
||||
(buffer).start = (buffer).pointer = (buffer).end = 0)
|
||||
|
||||
/*
|
||||
* String management.
|
||||
*/
|
||||
|
||||
typedef struct {
|
||||
yaml_char_t *start;
|
||||
yaml_char_t *end;
|
||||
yaml_char_t *pointer;
|
||||
} yaml_string_t;
|
||||
|
||||
YAML_DECLARE(int)
|
||||
yaml_string_extend(yaml_char_t **start,
|
||||
yaml_char_t **pointer, yaml_char_t **end);
|
||||
|
||||
YAML_DECLARE(int)
|
||||
yaml_string_join(
|
||||
yaml_char_t **a_start, yaml_char_t **a_pointer, yaml_char_t **a_end,
|
||||
yaml_char_t **b_start, yaml_char_t **b_pointer, yaml_char_t **b_end);
|
||||
|
||||
#define NULL_STRING { NULL, NULL, NULL }
|
||||
|
||||
#define STRING(string,length) { (string), (string)+(length), (string) }
|
||||
|
||||
#define STRING_ASSIGN(value,string,length) \
|
||||
((value).start = (string), \
|
||||
(value).end = (string)+(length), \
|
||||
(value).pointer = (string))
|
||||
|
||||
#define STRING_INIT(context,string,size) \
|
||||
(((string).start = yaml_malloc(size)) ? \
|
||||
((string).pointer = (string).start, \
|
||||
(string).end = (string).start+(size), \
|
||||
memset((string).start, 0, (size)), \
|
||||
1) : \
|
||||
((context)->error = YAML_MEMORY_ERROR, \
|
||||
0))
|
||||
|
||||
#define STRING_DEL(context,string) \
|
||||
(yaml_free((string).start), \
|
||||
(string).start = (string).pointer = (string).end = 0)
|
||||
|
||||
#define STRING_EXTEND(context,string) \
|
||||
((((string).pointer+5 < (string).end) \
|
||||
|| yaml_string_extend(&(string).start, \
|
||||
&(string).pointer, &(string).end)) ? \
|
||||
1 : \
|
||||
((context)->error = YAML_MEMORY_ERROR, \
|
||||
0))
|
||||
|
||||
#define CLEAR(context,string) \
|
||||
((string).pointer = (string).start, \
|
||||
memset((string).start, 0, (string).end-(string).start))
|
||||
|
||||
#define JOIN(context,string_a,string_b) \
|
||||
((yaml_string_join(&(string_a).start, &(string_a).pointer, \
|
||||
&(string_a).end, &(string_b).start, \
|
||||
&(string_b).pointer, &(string_b).end)) ? \
|
||||
((string_b).pointer = (string_b).start, \
|
||||
1) : \
|
||||
((context)->error = YAML_MEMORY_ERROR, \
|
||||
0))
|
||||
|
||||
/*
|
||||
* String check operations.
|
||||
*/
|
||||
|
||||
/*
|
||||
* Check the octet at the specified position.
|
||||
*/
|
||||
|
||||
#define CHECK_AT(string,octet,offset) \
|
||||
((string).pointer[offset] == (yaml_char_t)(octet))
|
||||
|
||||
/*
|
||||
* Check the current octet in the buffer.
|
||||
*/
|
||||
|
||||
#define CHECK(string,octet) CHECK_AT((string),(octet),0)
|
||||
|
||||
/*
|
||||
* Check if the character at the specified position is an alphabetical
|
||||
* character, a digit, '_', or '-'.
|
||||
*/
|
||||
|
||||
#define IS_ALPHA_AT(string,offset) \
|
||||
(((string).pointer[offset] >= (yaml_char_t) '0' && \
|
||||
(string).pointer[offset] <= (yaml_char_t) '9') || \
|
||||
((string).pointer[offset] >= (yaml_char_t) 'A' && \
|
||||
(string).pointer[offset] <= (yaml_char_t) 'Z') || \
|
||||
((string).pointer[offset] >= (yaml_char_t) 'a' && \
|
||||
(string).pointer[offset] <= (yaml_char_t) 'z') || \
|
||||
(string).pointer[offset] == '_' || \
|
||||
(string).pointer[offset] == '-')
|
||||
|
||||
#define IS_ALPHA(string) IS_ALPHA_AT((string),0)
|
||||
|
||||
/*
|
||||
* Check if the character at the specified position is a digit.
|
||||
*/
|
||||
|
||||
#define IS_DIGIT_AT(string,offset) \
|
||||
(((string).pointer[offset] >= (yaml_char_t) '0' && \
|
||||
(string).pointer[offset] <= (yaml_char_t) '9'))
|
||||
|
||||
#define IS_DIGIT(string) IS_DIGIT_AT((string),0)
|
||||
|
||||
/*
|
||||
* Get the value of a digit.
|
||||
*/
|
||||
|
||||
#define AS_DIGIT_AT(string,offset) \
|
||||
((string).pointer[offset] - (yaml_char_t) '0')
|
||||
|
||||
#define AS_DIGIT(string) AS_DIGIT_AT((string),0)
|
||||
|
||||
/*
|
||||
* Check if the character at the specified position is a hex-digit.
|
||||
*/
|
||||
|
||||
#define IS_HEX_AT(string,offset) \
|
||||
(((string).pointer[offset] >= (yaml_char_t) '0' && \
|
||||
(string).pointer[offset] <= (yaml_char_t) '9') || \
|
||||
((string).pointer[offset] >= (yaml_char_t) 'A' && \
|
||||
(string).pointer[offset] <= (yaml_char_t) 'F') || \
|
||||
((string).pointer[offset] >= (yaml_char_t) 'a' && \
|
||||
(string).pointer[offset] <= (yaml_char_t) 'f'))
|
||||
|
||||
#define IS_HEX(string) IS_HEX_AT((string),0)
|
||||
|
||||
/*
|
||||
* Get the value of a hex-digit.
|
||||
*/
|
||||
|
||||
#define AS_HEX_AT(string,offset) \
|
||||
(((string).pointer[offset] >= (yaml_char_t) 'A' && \
|
||||
(string).pointer[offset] <= (yaml_char_t) 'F') ? \
|
||||
((string).pointer[offset] - (yaml_char_t) 'A' + 10) : \
|
||||
((string).pointer[offset] >= (yaml_char_t) 'a' && \
|
||||
(string).pointer[offset] <= (yaml_char_t) 'f') ? \
|
||||
((string).pointer[offset] - (yaml_char_t) 'a' + 10) : \
|
||||
((string).pointer[offset] - (yaml_char_t) '0'))
|
||||
|
||||
#define AS_HEX(string) AS_HEX_AT((string),0)
|
||||
|
||||
/*
|
||||
* Check if the character is ASCII.
|
||||
*/
|
||||
|
||||
#define IS_ASCII_AT(string,offset) \
|
||||
((string).pointer[offset] <= (yaml_char_t) '\x7F')
|
||||
|
||||
#define IS_ASCII(string) IS_ASCII_AT((string),0)
|
||||
|
||||
/*
|
||||
* Check if the character can be printed unescaped.
|
||||
*/
|
||||
|
||||
#define IS_PRINTABLE_AT(string,offset) \
|
||||
(((string).pointer[offset] == 0x0A) /* . == #x0A */ \
|
||||
|| ((string).pointer[offset] >= 0x20 /* #x20 <= . <= #x7E */ \
|
||||
&& (string).pointer[offset] <= 0x7E) \
|
||||
|| ((string).pointer[offset] == 0xC2 /* #0xA0 <= . <= #xD7FF */ \
|
||||
&& (string).pointer[offset+1] >= 0xA0) \
|
||||
|| ((string).pointer[offset] > 0xC2 \
|
||||
&& (string).pointer[offset] < 0xED) \
|
||||
|| ((string).pointer[offset] == 0xED \
|
||||
&& (string).pointer[offset+1] < 0xA0) \
|
||||
|| ((string).pointer[offset] == 0xEE) \
|
||||
|| ((string).pointer[offset] == 0xEF /* #xE000 <= . <= #xFFFD */ \
|
||||
&& !((string).pointer[offset+1] == 0xBB /* && . != #xFEFF */ \
|
||||
&& (string).pointer[offset+2] == 0xBF) \
|
||||
&& !((string).pointer[offset+1] == 0xBF \
|
||||
&& ((string).pointer[offset+2] == 0xBE \
|
||||
|| (string).pointer[offset+2] == 0xBF))))
|
||||
|
||||
#define IS_PRINTABLE(string) IS_PRINTABLE_AT((string),0)
|
||||
|
||||
/*
|
||||
* Check if the character at the specified position is NUL.
|
||||
*/
|
||||
|
||||
#define IS_Z_AT(string,offset) CHECK_AT((string),'\0',(offset))
|
||||
|
||||
#define IS_Z(string) IS_Z_AT((string),0)
|
||||
|
||||
/*
|
||||
* Check if the character at the specified position is BOM.
|
||||
*/
|
||||
|
||||
#define IS_BOM_AT(string,offset) \
|
||||
(CHECK_AT((string),'\xEF',(offset)) \
|
||||
&& CHECK_AT((string),'\xBB',(offset)+1) \
|
||||
&& CHECK_AT((string),'\xBF',(offset)+2)) /* BOM (#xFEFF) */
|
||||
|
||||
#define IS_BOM(string) IS_BOM_AT(string,0)
|
||||
|
||||
/*
|
||||
* Check if the character at the specified position is space.
|
||||
*/
|
||||
|
||||
#define IS_SPACE_AT(string,offset) CHECK_AT((string),' ',(offset))
|
||||
|
||||
#define IS_SPACE(string) IS_SPACE_AT((string),0)
|
||||
|
||||
/*
|
||||
* Check if the character at the specified position is tab.
|
||||
*/
|
||||
|
||||
#define IS_TAB_AT(string,offset) CHECK_AT((string),'\t',(offset))
|
||||
|
||||
#define IS_TAB(string) IS_TAB_AT((string),0)
|
||||
|
||||
/*
|
||||
* Check if the character at the specified position is blank (space or tab).
|
||||
*/
|
||||
|
||||
#define IS_BLANK_AT(string,offset) \
|
||||
(IS_SPACE_AT((string),(offset)) || IS_TAB_AT((string),(offset)))
|
||||
|
||||
#define IS_BLANK(string) IS_BLANK_AT((string),0)
|
||||
|
||||
/*
|
||||
* Check if the character at the specified position is a line break.
|
||||
*/
|
||||
|
||||
#define IS_BREAK_AT(string,offset) \
|
||||
(CHECK_AT((string),'\r',(offset)) /* CR (#xD)*/ \
|
||||
|| CHECK_AT((string),'\n',(offset)) /* LF (#xA) */ \
|
||||
|| (CHECK_AT((string),'\xC2',(offset)) \
|
||||
&& CHECK_AT((string),'\x85',(offset)+1)) /* NEL (#x85) */ \
|
||||
|| (CHECK_AT((string),'\xE2',(offset)) \
|
||||
&& CHECK_AT((string),'\x80',(offset)+1) \
|
||||
&& CHECK_AT((string),'\xA8',(offset)+2)) /* LS (#x2028) */ \
|
||||
|| (CHECK_AT((string),'\xE2',(offset)) \
|
||||
&& CHECK_AT((string),'\x80',(offset)+1) \
|
||||
&& CHECK_AT((string),'\xA9',(offset)+2))) /* PS (#x2029) */
|
||||
|
||||
#define IS_BREAK(string) IS_BREAK_AT((string),0)
|
||||
|
||||
#define IS_CRLF_AT(string,offset) \
|
||||
(CHECK_AT((string),'\r',(offset)) && CHECK_AT((string),'\n',(offset)+1))
|
||||
|
||||
#define IS_CRLF(string) IS_CRLF_AT((string),0)
|
||||
|
||||
/*
|
||||
* Check if the character is a line break or NUL.
|
||||
*/
|
||||
|
||||
#define IS_BREAKZ_AT(string,offset) \
|
||||
(IS_BREAK_AT((string),(offset)) || IS_Z_AT((string),(offset)))
|
||||
|
||||
#define IS_BREAKZ(string) IS_BREAKZ_AT((string),0)
|
||||
|
||||
/*
|
||||
* Check if the character is a line break, space, or NUL.
|
||||
*/
|
||||
|
||||
#define IS_SPACEZ_AT(string,offset) \
|
||||
(IS_SPACE_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset)))
|
||||
|
||||
#define IS_SPACEZ(string) IS_SPACEZ_AT((string),0)
|
||||
|
||||
/*
|
||||
* Check if the character is a line break, space, tab, or NUL.
|
||||
*/
|
||||
|
||||
#define IS_BLANKZ_AT(string,offset) \
|
||||
(IS_BLANK_AT((string),(offset)) || IS_BREAKZ_AT((string),(offset)))
|
||||
|
||||
#define IS_BLANKZ(string) IS_BLANKZ_AT((string),0)
|
||||
|
||||
/*
|
||||
* Determine the width of the character.
|
||||
*/
|
||||
|
||||
#define WIDTH_AT(string,offset) \
|
||||
(((string).pointer[offset] & 0x80) == 0x00 ? 1 : \
|
||||
((string).pointer[offset] & 0xE0) == 0xC0 ? 2 : \
|
||||
((string).pointer[offset] & 0xF0) == 0xE0 ? 3 : \
|
||||
((string).pointer[offset] & 0xF8) == 0xF0 ? 4 : 0)
|
||||
|
||||
#define WIDTH(string) WIDTH_AT((string),0)
|
||||
|
||||
/*
|
||||
* Move the string pointer to the next character.
|
||||
*/
|
||||
|
||||
#define MOVE(string) ((string).pointer += WIDTH((string)))
|
||||
|
||||
/*
|
||||
* Copy a character and move the pointers of both strings.
|
||||
*/
|
||||
|
||||
#define COPY(string_a,string_b) \
|
||||
((*(string_b).pointer & 0x80) == 0x00 ? \
|
||||
(*((string_a).pointer++) = *((string_b).pointer++)) : \
|
||||
(*(string_b).pointer & 0xE0) == 0xC0 ? \
|
||||
(*((string_a).pointer++) = *((string_b).pointer++), \
|
||||
*((string_a).pointer++) = *((string_b).pointer++)) : \
|
||||
(*(string_b).pointer & 0xF0) == 0xE0 ? \
|
||||
(*((string_a).pointer++) = *((string_b).pointer++), \
|
||||
*((string_a).pointer++) = *((string_b).pointer++), \
|
||||
*((string_a).pointer++) = *((string_b).pointer++)) : \
|
||||
(*(string_b).pointer & 0xF8) == 0xF0 ? \
|
||||
(*((string_a).pointer++) = *((string_b).pointer++), \
|
||||
*((string_a).pointer++) = *((string_b).pointer++), \
|
||||
*((string_a).pointer++) = *((string_b).pointer++), \
|
||||
*((string_a).pointer++) = *((string_b).pointer++)) : 0)
|
||||
|
||||
/*
|
||||
* Stack and queue management.
|
||||
*/
|
||||
|
||||
YAML_DECLARE(int)
|
||||
yaml_stack_extend(void **start, void **top, void **end);
|
||||
|
||||
YAML_DECLARE(int)
|
||||
yaml_queue_extend(void **start, void **head, void **tail, void **end);
|
||||
|
||||
#define STACK_INIT(context,stack,size) \
|
||||
(((stack).start = yaml_malloc((size)*sizeof(*(stack).start))) ? \
|
||||
((stack).top = (stack).start, \
|
||||
(stack).end = (stack).start+(size), \
|
||||
1) : \
|
||||
((context)->error = YAML_MEMORY_ERROR, \
|
||||
0))
|
||||
|
||||
#define STACK_DEL(context,stack) \
|
||||
(yaml_free((stack).start), \
|
||||
(stack).start = (stack).top = (stack).end = 0)
|
||||
|
||||
#define STACK_EMPTY(context,stack) \
|
||||
((stack).start == (stack).top)
|
||||
|
||||
#define STACK_LIMIT(context,stack,size) \
|
||||
((stack).top - (stack).start < (size) ? \
|
||||
1 : \
|
||||
((context)->error = YAML_MEMORY_ERROR, \
|
||||
0))
|
||||
|
||||
#define PUSH(context,stack,value) \
|
||||
(((stack).top != (stack).end \
|
||||
|| yaml_stack_extend((void **)&(stack).start, \
|
||||
(void **)&(stack).top, (void **)&(stack).end)) ? \
|
||||
(*((stack).top++) = value, \
|
||||
1) : \
|
||||
((context)->error = YAML_MEMORY_ERROR, \
|
||||
0))
|
||||
|
||||
#define POP(context,stack) \
|
||||
(*(--(stack).top))
|
||||
|
||||
#define QUEUE_INIT(context,queue,size) \
|
||||
(((queue).start = yaml_malloc((size)*sizeof(*(queue).start))) ? \
|
||||
((queue).head = (queue).tail = (queue).start, \
|
||||
(queue).end = (queue).start+(size), \
|
||||
1) : \
|
||||
((context)->error = YAML_MEMORY_ERROR, \
|
||||
0))
|
||||
|
||||
#define QUEUE_DEL(context,queue) \
|
||||
(yaml_free((queue).start), \
|
||||
(queue).start = (queue).head = (queue).tail = (queue).end = 0)
|
||||
|
||||
#define QUEUE_EMPTY(context,queue) \
|
||||
((queue).head == (queue).tail)
|
||||
|
||||
#define ENQUEUE(context,queue,value) \
|
||||
(((queue).tail != (queue).end \
|
||||
|| yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \
|
||||
(void **)&(queue).tail, (void **)&(queue).end)) ? \
|
||||
(*((queue).tail++) = value, \
|
||||
1) : \
|
||||
((context)->error = YAML_MEMORY_ERROR, \
|
||||
0))
|
||||
|
||||
#define DEQUEUE(context,queue) \
|
||||
(*((queue).head++))
|
||||
|
||||
#define QUEUE_INSERT(context,queue,index,value) \
|
||||
(((queue).tail != (queue).end \
|
||||
|| yaml_queue_extend((void **)&(queue).start, (void **)&(queue).head, \
|
||||
(void **)&(queue).tail, (void **)&(queue).end)) ? \
|
||||
(memmove((queue).head+(index)+1,(queue).head+(index), \
|
||||
((queue).tail-(queue).head-(index))*sizeof(*(queue).start)), \
|
||||
*((queue).head+(index)) = value, \
|
||||
(queue).tail++, \
|
||||
1) : \
|
||||
((context)->error = YAML_MEMORY_ERROR, \
|
||||
0))
|
||||
|
||||
/*
|
||||
* Token initializers.
|
||||
*/
|
||||
|
||||
#define TOKEN_INIT(token,token_type,token_start_mark,token_end_mark) \
|
||||
(memset(&(token), 0, sizeof(yaml_token_t)), \
|
||||
(token).type = (token_type), \
|
||||
(token).start_mark = (token_start_mark), \
|
||||
(token).end_mark = (token_end_mark))
|
||||
|
||||
#define STREAM_START_TOKEN_INIT(token,token_encoding,start_mark,end_mark) \
|
||||
(TOKEN_INIT((token),YAML_STREAM_START_TOKEN,(start_mark),(end_mark)), \
|
||||
(token).data.stream_start.encoding = (token_encoding))
|
||||
|
||||
#define STREAM_END_TOKEN_INIT(token,start_mark,end_mark) \
|
||||
(TOKEN_INIT((token),YAML_STREAM_END_TOKEN,(start_mark),(end_mark)))
|
||||
|
||||
#define ALIAS_TOKEN_INIT(token,token_value,start_mark,end_mark) \
|
||||
(TOKEN_INIT((token),YAML_ALIAS_TOKEN,(start_mark),(end_mark)), \
|
||||
(token).data.alias.value = (token_value))
|
||||
|
||||
#define ANCHOR_TOKEN_INIT(token,token_value,start_mark,end_mark) \
|
||||
(TOKEN_INIT((token),YAML_ANCHOR_TOKEN,(start_mark),(end_mark)), \
|
||||
(token).data.anchor.value = (token_value))
|
||||
|
||||
#define TAG_TOKEN_INIT(token,token_handle,token_suffix,start_mark,end_mark) \
|
||||
(TOKEN_INIT((token),YAML_TAG_TOKEN,(start_mark),(end_mark)), \
|
||||
(token).data.tag.handle = (token_handle), \
|
||||
(token).data.tag.suffix = (token_suffix))
|
||||
|
||||
#define SCALAR_TOKEN_INIT(token,token_value,token_length,token_style,start_mark,end_mark) \
|
||||
(TOKEN_INIT((token),YAML_SCALAR_TOKEN,(start_mark),(end_mark)), \
|
||||
(token).data.scalar.value = (token_value), \
|
||||
(token).data.scalar.length = (token_length), \
|
||||
(token).data.scalar.style = (token_style))
|
||||
|
||||
#define VERSION_DIRECTIVE_TOKEN_INIT(token,token_major,token_minor,start_mark,end_mark) \
|
||||
(TOKEN_INIT((token),YAML_VERSION_DIRECTIVE_TOKEN,(start_mark),(end_mark)), \
|
||||
(token).data.version_directive.major = (token_major), \
|
||||
(token).data.version_directive.minor = (token_minor))
|
||||
|
||||
#define TAG_DIRECTIVE_TOKEN_INIT(token,token_handle,token_prefix,start_mark,end_mark) \
|
||||
(TOKEN_INIT((token),YAML_TAG_DIRECTIVE_TOKEN,(start_mark),(end_mark)), \
|
||||
(token).data.tag_directive.handle = (token_handle), \
|
||||
(token).data.tag_directive.prefix = (token_prefix))
|
||||
|
||||
/*
|
||||
* Event initializers.
|
||||
*/
|
||||
|
||||
#define EVENT_INIT(event,event_type,event_start_mark,event_end_mark) \
|
||||
(memset(&(event), 0, sizeof(yaml_event_t)), \
|
||||
(event).type = (event_type), \
|
||||
(event).start_mark = (event_start_mark), \
|
||||
(event).end_mark = (event_end_mark))
|
||||
|
||||
#define STREAM_START_EVENT_INIT(event,event_encoding,start_mark,end_mark) \
|
||||
(EVENT_INIT((event),YAML_STREAM_START_EVENT,(start_mark),(end_mark)), \
|
||||
(event).data.stream_start.encoding = (event_encoding))
|
||||
|
||||
#define STREAM_END_EVENT_INIT(event,start_mark,end_mark) \
|
||||
(EVENT_INIT((event),YAML_STREAM_END_EVENT,(start_mark),(end_mark)))
|
||||
|
||||
#define DOCUMENT_START_EVENT_INIT(event,event_version_directive, \
|
||||
event_tag_directives_start,event_tag_directives_end,event_implicit,start_mark,end_mark) \
|
||||
(EVENT_INIT((event),YAML_DOCUMENT_START_EVENT,(start_mark),(end_mark)), \
|
||||
(event).data.document_start.version_directive = (event_version_directive), \
|
||||
(event).data.document_start.tag_directives.start = (event_tag_directives_start), \
|
||||
(event).data.document_start.tag_directives.end = (event_tag_directives_end), \
|
||||
(event).data.document_start.implicit = (event_implicit))
|
||||
|
||||
#define DOCUMENT_END_EVENT_INIT(event,event_implicit,start_mark,end_mark) \
|
||||
(EVENT_INIT((event),YAML_DOCUMENT_END_EVENT,(start_mark),(end_mark)), \
|
||||
(event).data.document_end.implicit = (event_implicit))
|
||||
|
||||
#define ALIAS_EVENT_INIT(event,event_anchor,start_mark,end_mark) \
|
||||
(EVENT_INIT((event),YAML_ALIAS_EVENT,(start_mark),(end_mark)), \
|
||||
(event).data.alias.anchor = (event_anchor))
|
||||
|
||||
#define SCALAR_EVENT_INIT(event,event_anchor,event_tag,event_value,event_length, \
|
||||
event_plain_implicit, event_quoted_implicit,event_style,start_mark,end_mark) \
|
||||
(EVENT_INIT((event),YAML_SCALAR_EVENT,(start_mark),(end_mark)), \
|
||||
(event).data.scalar.anchor = (event_anchor), \
|
||||
(event).data.scalar.tag = (event_tag), \
|
||||
(event).data.scalar.value = (event_value), \
|
||||
(event).data.scalar.length = (event_length), \
|
||||
(event).data.scalar.plain_implicit = (event_plain_implicit), \
|
||||
(event).data.scalar.quoted_implicit = (event_quoted_implicit), \
|
||||
(event).data.scalar.style = (event_style))
|
||||
|
||||
#define SEQUENCE_START_EVENT_INIT(event,event_anchor,event_tag, \
|
||||
event_implicit,event_style,start_mark,end_mark) \
|
||||
(EVENT_INIT((event),YAML_SEQUENCE_START_EVENT,(start_mark),(end_mark)), \
|
||||
(event).data.sequence_start.anchor = (event_anchor), \
|
||||
(event).data.sequence_start.tag = (event_tag), \
|
||||
(event).data.sequence_start.implicit = (event_implicit), \
|
||||
(event).data.sequence_start.style = (event_style))
|
||||
|
||||
#define SEQUENCE_END_EVENT_INIT(event,start_mark,end_mark) \
|
||||
(EVENT_INIT((event),YAML_SEQUENCE_END_EVENT,(start_mark),(end_mark)))
|
||||
|
||||
#define MAPPING_START_EVENT_INIT(event,event_anchor,event_tag, \
|
||||
event_implicit,event_style,start_mark,end_mark) \
|
||||
(EVENT_INIT((event),YAML_MAPPING_START_EVENT,(start_mark),(end_mark)), \
|
||||
(event).data.mapping_start.anchor = (event_anchor), \
|
||||
(event).data.mapping_start.tag = (event_tag), \
|
||||
(event).data.mapping_start.implicit = (event_implicit), \
|
||||
(event).data.mapping_start.style = (event_style))
|
||||
|
||||
#define MAPPING_END_EVENT_INIT(event,start_mark,end_mark) \
|
||||
(EVENT_INIT((event),YAML_MAPPING_END_EVENT,(start_mark),(end_mark)))
|
||||
|
||||
/*
|
||||
* Document initializer.
|
||||
*/
|
||||
|
||||
#define DOCUMENT_INIT(document,document_nodes_start,document_nodes_end, \
|
||||
document_version_directive,document_tag_directives_start, \
|
||||
document_tag_directives_end,document_start_implicit, \
|
||||
document_end_implicit,document_start_mark,document_end_mark) \
|
||||
(memset(&(document), 0, sizeof(yaml_document_t)), \
|
||||
(document).nodes.start = (document_nodes_start), \
|
||||
(document).nodes.end = (document_nodes_end), \
|
||||
(document).nodes.top = (document_nodes_start), \
|
||||
(document).version_directive = (document_version_directive), \
|
||||
(document).tag_directives.start = (document_tag_directives_start), \
|
||||
(document).tag_directives.end = (document_tag_directives_end), \
|
||||
(document).start_implicit = (document_start_implicit), \
|
||||
(document).end_implicit = (document_end_implicit), \
|
||||
(document).start_mark = (document_start_mark), \
|
||||
(document).end_mark = (document_end_mark))
|
||||
|
||||
/*
|
||||
* Node initializers.
|
||||
*/
|
||||
|
||||
#define NODE_INIT(node,node_type,node_tag,node_start_mark,node_end_mark) \
|
||||
(memset(&(node), 0, sizeof(yaml_node_t)), \
|
||||
(node).type = (node_type), \
|
||||
(node).tag = (node_tag), \
|
||||
(node).start_mark = (node_start_mark), \
|
||||
(node).end_mark = (node_end_mark))
|
||||
|
||||
#define SCALAR_NODE_INIT(node,node_tag,node_value,node_length, \
|
||||
node_style,start_mark,end_mark) \
|
||||
(NODE_INIT((node),YAML_SCALAR_NODE,(node_tag),(start_mark),(end_mark)), \
|
||||
(node).data.scalar.value = (node_value), \
|
||||
(node).data.scalar.length = (node_length), \
|
||||
(node).data.scalar.style = (node_style))
|
||||
|
||||
#define SEQUENCE_NODE_INIT(node,node_tag,node_items_start,node_items_end, \
|
||||
node_style,start_mark,end_mark) \
|
||||
(NODE_INIT((node),YAML_SEQUENCE_NODE,(node_tag),(start_mark),(end_mark)), \
|
||||
(node).data.sequence.items.start = (node_items_start), \
|
||||
(node).data.sequence.items.end = (node_items_end), \
|
||||
(node).data.sequence.items.top = (node_items_start), \
|
||||
(node).data.sequence.style = (node_style))
|
||||
|
||||
#define MAPPING_NODE_INIT(node,node_tag,node_pairs_start,node_pairs_end, \
|
||||
node_style,start_mark,end_mark) \
|
||||
(NODE_INIT((node),YAML_MAPPING_NODE,(node_tag),(start_mark),(end_mark)), \
|
||||
(node).data.mapping.pairs.start = (node_pairs_start), \
|
||||
(node).data.mapping.pairs.end = (node_pairs_end), \
|
||||
(node).data.mapping.pairs.top = (node_pairs_start), \
|
||||
(node).data.mapping.style = (node_style))
|
||||
|
||||
|
|
@ -73,8 +73,6 @@ struct DNA
|
|||
struct Delete {};
|
||||
};
|
||||
|
||||
/* Concrete DNA types */
|
||||
|
||||
template <size_t sizeVar, Endian VE>
|
||||
struct Buffer : public DNA<VE>, public std::unique_ptr<atUint8[]>
|
||||
{
|
||||
|
|
@ -95,7 +93,7 @@ struct String : public DNA<VE>, public std::string
|
|||
{
|
||||
typename DNA<VE>::Delete expl;
|
||||
inline void read(IStreamReader& reader)
|
||||
{*this = reader.readString(sizeVar);}
|
||||
{this->assign(std::move(reader.readString(sizeVar)));}
|
||||
inline void write(IStreamWriter& writer) const
|
||||
{writer.writeString(*this, sizeVar);}
|
||||
inline std::string& operator=(const std::string& __str)
|
||||
|
|
@ -111,7 +109,7 @@ struct WString : public DNA<VE>, public std::wstring
|
|||
inline void read(IStreamReader& reader)
|
||||
{
|
||||
reader.setEndian(VE);
|
||||
*this = reader.readWString(sizeVar);
|
||||
this->assign(std::move(reader.readWString(sizeVar)));
|
||||
}
|
||||
inline void write(IStreamWriter& writer) const
|
||||
{
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,369 @@
|
|||
#include "Athena/DNAYaml.hpp"
|
||||
|
||||
namespace Athena
|
||||
{
|
||||
namespace io
|
||||
{
|
||||
|
||||
static const char* ErrorString(yaml_error_type_t errt)
|
||||
{
|
||||
switch (errt)
|
||||
{
|
||||
case YAML_NO_ERROR:
|
||||
return "No Error";
|
||||
case YAML_MEMORY_ERROR:
|
||||
return "Memory Error";
|
||||
case YAML_READER_ERROR:
|
||||
return "Reader Error";
|
||||
case YAML_SCANNER_ERROR:
|
||||
return "Scanner Error";
|
||||
case YAML_PARSER_ERROR:
|
||||
return "Parser Error";
|
||||
case YAML_COMPOSER_ERROR:
|
||||
return "Composer Error";
|
||||
case YAML_WRITER_ERROR:
|
||||
return "Writer Error";
|
||||
case YAML_EMITTER_ERROR:
|
||||
return "Emitter Error";
|
||||
}
|
||||
return "Unknown Error";
|
||||
}
|
||||
|
||||
void HandleYAMLParserError(yaml_parser_t* parser)
|
||||
{
|
||||
atError("YAML error: %s: %s", ErrorString(parser->error), parser->problem?parser->problem:"");
|
||||
}
|
||||
|
||||
void HandleYAMLEmitterError(yaml_emitter_t* emitter)
|
||||
{
|
||||
atError("YAML error: %s: %s", ErrorString(emitter->error), emitter->problem?emitter->problem:"");
|
||||
}
|
||||
|
||||
int YAMLStdStringReader(YAMLStdStringReaderState* reader,
|
||||
unsigned char* buffer, size_t size, size_t* size_read)
|
||||
{
|
||||
size_t diff = reader->end - reader->begin;
|
||||
if (!diff)
|
||||
{
|
||||
*size_read = 0;
|
||||
}
|
||||
else if (diff < size)
|
||||
{
|
||||
memcpy(buffer, &*reader->begin, diff);
|
||||
*size_read = diff;
|
||||
}
|
||||
else
|
||||
{
|
||||
memcpy(buffer, &*reader->begin, size);
|
||||
*size_read = size;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
int YAMLStdStringWriter(std::string* str, unsigned char *buffer, size_t size)
|
||||
{
|
||||
str->append((char*)buffer, size);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static inline void InsertNode(std::vector<YAMLNode*>& nodeStack,
|
||||
std::unique_ptr<YAMLNode>& mapKey,
|
||||
std::unique_ptr<YAMLNode>& retVal,
|
||||
std::unique_ptr<YAMLNode>&& newNode)
|
||||
{
|
||||
if (nodeStack.empty())
|
||||
{
|
||||
retVal = std::move(newNode);
|
||||
return;
|
||||
}
|
||||
YAMLNode* parent = nodeStack.back();
|
||||
if (parent->m_type == YAML_SEQUENCE_NODE)
|
||||
{
|
||||
parent->m_seqChildren.emplace_back(std::move(newNode));
|
||||
}
|
||||
else if (parent->m_type == YAML_MAPPING_NODE)
|
||||
{
|
||||
if (!mapKey)
|
||||
mapKey = std::move(newNode);
|
||||
else
|
||||
{
|
||||
parent->m_mapChildren.emplace_back(std::move(mapKey->m_scalarString), std::move(newNode));
|
||||
mapKey.reset(nullptr);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
std::unique_ptr<YAMLNode> YAMLDocReader::ParseEvents(yaml_parser_t* doc)
|
||||
{
|
||||
yaml_event_t event;
|
||||
if (!yaml_parser_parse(doc, &event))
|
||||
{
|
||||
HandleYAMLParserError(doc);
|
||||
return std::unique_ptr<YAMLNode>();
|
||||
}
|
||||
|
||||
std::vector<YAMLNode*> nodeStack;
|
||||
std::unique_ptr<YAMLNode> mapKey;
|
||||
std::unique_ptr<YAMLNode> retVal;
|
||||
int result;
|
||||
for (result = yaml_parser_parse(doc, &event);
|
||||
event.type != YAML_STREAM_END_EVENT;
|
||||
result = yaml_parser_parse(doc, &event))
|
||||
{
|
||||
if (!result)
|
||||
{
|
||||
HandleYAMLParserError(doc);
|
||||
return std::unique_ptr<YAMLNode>();
|
||||
}
|
||||
switch (event.type)
|
||||
{
|
||||
case YAML_SCALAR_EVENT:
|
||||
{
|
||||
if (nodeStack.empty())
|
||||
{
|
||||
atWarning("YAML parser stack empty; skipping scalar node");
|
||||
yaml_event_delete(&event);
|
||||
continue;
|
||||
}
|
||||
std::unique_ptr<YAMLNode> newScalar(new YAMLNode(YAML_SCALAR_NODE));
|
||||
newScalar->m_scalarString.assign((char*)event.data.scalar.value, event.data.scalar.length);
|
||||
if (nodeStack.empty())
|
||||
retVal = std::move(newScalar);
|
||||
else
|
||||
InsertNode(nodeStack, mapKey, retVal, std::move(newScalar));
|
||||
break;
|
||||
}
|
||||
case YAML_SEQUENCE_START_EVENT:
|
||||
{
|
||||
YAMLNode* newSeq = new YAMLNode(YAML_SEQUENCE_NODE);
|
||||
InsertNode(nodeStack, mapKey, retVal, std::unique_ptr<YAMLNode>(newSeq));
|
||||
nodeStack.emplace_back(newSeq);
|
||||
break;
|
||||
}
|
||||
case YAML_SEQUENCE_END_EVENT:
|
||||
{
|
||||
nodeStack.pop_back();
|
||||
break;
|
||||
}
|
||||
case YAML_MAPPING_START_EVENT:
|
||||
{
|
||||
YAMLNode* newMap = new YAMLNode(YAML_MAPPING_NODE);
|
||||
InsertNode(nodeStack, mapKey, retVal, std::unique_ptr<YAMLNode>(newMap));
|
||||
nodeStack.emplace_back(newMap);
|
||||
break;
|
||||
}
|
||||
case YAML_MAPPING_END_EVENT:
|
||||
{
|
||||
nodeStack.pop_back();
|
||||
break;
|
||||
}
|
||||
case YAML_DOCUMENT_END_EVENT:
|
||||
{
|
||||
yaml_event_delete(&event);
|
||||
return retVal;
|
||||
}
|
||||
default:
|
||||
break;
|
||||
}
|
||||
yaml_event_delete(&event);
|
||||
}
|
||||
return std::unique_ptr<YAMLNode>();
|
||||
}
|
||||
|
||||
static inline bool EmitKeyScalar(yaml_emitter_t* doc, const char* val)
|
||||
{
|
||||
yaml_event_t event;
|
||||
if (!yaml_scalar_event_initialize(&event, nullptr, nullptr, (yaml_char_t*)val,
|
||||
strlen(val), true, true, YAML_PLAIN_SCALAR_STYLE))
|
||||
return false;
|
||||
return yaml_emitter_emit(doc, &event);
|
||||
}
|
||||
|
||||
static inline yaml_scalar_style_t ScalarStyle(const YAMLNode& node)
|
||||
{
|
||||
for (const auto& ch : node.m_scalarString)
|
||||
if (ch == '\n')
|
||||
return YAML_LITERAL_SCALAR_STYLE;
|
||||
return YAML_ANY_SCALAR_STYLE;
|
||||
}
|
||||
|
||||
static inline yaml_sequence_style_t SequenceStyle(const YAMLNode& node)
|
||||
{
|
||||
size_t count = 0;
|
||||
for (const auto& item : node.m_seqChildren)
|
||||
{
|
||||
if (item->m_type != YAML_SCALAR_NODE)
|
||||
return YAML_BLOCK_SEQUENCE_STYLE;
|
||||
size_t strLen = item->m_scalarString.size();
|
||||
size_t thisCount = strLen / 10;
|
||||
if (!thisCount)
|
||||
thisCount = 1;
|
||||
count += thisCount;
|
||||
}
|
||||
return (count > 6) ? YAML_BLOCK_SEQUENCE_STYLE : YAML_FLOW_SEQUENCE_STYLE;
|
||||
}
|
||||
|
||||
static inline yaml_mapping_style_t MappingStyle(const YAMLNode& node)
|
||||
{
|
||||
size_t count = 0;
|
||||
for (const auto& item : node.m_mapChildren)
|
||||
{
|
||||
if (item.second->m_type != YAML_SCALAR_NODE)
|
||||
return YAML_BLOCK_MAPPING_STYLE;
|
||||
size_t strLen = item.second->m_scalarString.size();
|
||||
size_t thisCount = strLen / 10;
|
||||
if (!thisCount)
|
||||
thisCount = 1;
|
||||
count += thisCount;
|
||||
}
|
||||
return (count > 6) ? YAML_BLOCK_MAPPING_STYLE : YAML_FLOW_MAPPING_STYLE;
|
||||
}
|
||||
|
||||
bool YAMLDocWriter::RecursiveFinish(yaml_emitter_t* doc, const YAMLNode& node)
|
||||
{
|
||||
yaml_event_t event;
|
||||
if (node.m_type == YAML_SCALAR_NODE)
|
||||
{
|
||||
if (!yaml_scalar_event_initialize(&event, nullptr, nullptr, (yaml_char_t*)node.m_scalarString.c_str(),
|
||||
node.m_scalarString.length(), true, true, ScalarStyle(node)) ||
|
||||
!yaml_emitter_emit(doc, &event))
|
||||
goto err;
|
||||
}
|
||||
else if (node.m_type == YAML_SEQUENCE_NODE)
|
||||
{
|
||||
if (!yaml_sequence_start_event_initialize(&event, nullptr, nullptr, 1, SequenceStyle(node)) ||
|
||||
!yaml_emitter_emit(doc, &event))
|
||||
goto err;
|
||||
for (const auto& item : node.m_seqChildren)
|
||||
{
|
||||
if (!RecursiveFinish(doc, *item.get()))
|
||||
goto err;
|
||||
}
|
||||
if (!yaml_sequence_end_event_initialize(&event) ||
|
||||
!yaml_emitter_emit(doc, &event))
|
||||
goto err;
|
||||
}
|
||||
else if (node.m_type == YAML_MAPPING_NODE)
|
||||
{
|
||||
if (!yaml_mapping_start_event_initialize(&event, nullptr, nullptr, true, MappingStyle(node)) ||
|
||||
!yaml_emitter_emit(doc, &event))
|
||||
goto err;
|
||||
for (const auto& item : node.m_mapChildren)
|
||||
{
|
||||
if (!EmitKeyScalar(doc, item.first.c_str()))
|
||||
goto err;
|
||||
if (!RecursiveFinish(doc, *item.second.get()))
|
||||
goto err;
|
||||
}
|
||||
event.type = YAML_MAPPING_END_EVENT;
|
||||
if (!yaml_mapping_end_event_initialize(&event) ||
|
||||
!yaml_emitter_emit(doc, &event))
|
||||
goto err;
|
||||
|
||||
}
|
||||
return true;
|
||||
err:
|
||||
HandleYAMLEmitterError(doc);
|
||||
return false;
|
||||
}
|
||||
|
||||
static const std::string base64_chars =
|
||||
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
|
||||
"abcdefghijklmnopqrstuvwxyz"
|
||||
"0123456789+/";
|
||||
|
||||
|
||||
static inline bool is_base64(unsigned char c)
|
||||
{
|
||||
return (isalnum(c) || (c == '+') || (c == '/'));
|
||||
}
|
||||
|
||||
std::string base64_encode(const atUint8* bytes_to_encode, size_t in_len)
|
||||
{
|
||||
std::string ret;
|
||||
int i = 0;
|
||||
int j = 0;
|
||||
unsigned char char_array_3[3];
|
||||
unsigned char char_array_4[4];
|
||||
ret.reserve(in_len * 4 / 3);
|
||||
|
||||
while (in_len--) {
|
||||
char_array_3[i++] = *(bytes_to_encode++);
|
||||
if (i == 3) {
|
||||
char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
|
||||
char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
|
||||
char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
|
||||
char_array_4[3] = char_array_3[2] & 0x3f;
|
||||
|
||||
for(i = 0; (i <4) ; i++)
|
||||
ret += base64_chars[char_array_4[i]];
|
||||
i = 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (i)
|
||||
{
|
||||
for(j = i; j < 3; j++)
|
||||
char_array_3[j] = '\0';
|
||||
|
||||
char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
|
||||
char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
|
||||
char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
|
||||
char_array_4[3] = char_array_3[2] & 0x3f;
|
||||
|
||||
for (j = 0; (j < i + 1); j++)
|
||||
ret += base64_chars[char_array_4[j]];
|
||||
|
||||
while((i++ < 3))
|
||||
ret += '=';
|
||||
|
||||
}
|
||||
|
||||
return ret;
|
||||
|
||||
}
|
||||
std::unique_ptr<atUint8[]> base64_decode(const std::string& encoded_string)
|
||||
{
|
||||
int in_len = encoded_string.size();
|
||||
int i = 0;
|
||||
int j = 0;
|
||||
int in_ = 0;
|
||||
unsigned char char_array_4[4], char_array_3[3];
|
||||
std::unique_ptr<atUint8[]> ret(new atUint8[in_len * 3 / 4]);
|
||||
atUint8* retBuf = ret.get();
|
||||
|
||||
while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
|
||||
char_array_4[i++] = encoded_string[in_]; in_++;
|
||||
if (i ==4) {
|
||||
for (i = 0; i <4; i++)
|
||||
char_array_4[i] = base64_chars.find(char_array_4[i]);
|
||||
|
||||
char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
|
||||
char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
|
||||
char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
|
||||
|
||||
for (i = 0; (i < 3); i++)
|
||||
*retBuf++ = char_array_3[i];
|
||||
i = 0;
|
||||
}
|
||||
}
|
||||
|
||||
if (i) {
|
||||
for (j = i; j <4; j++)
|
||||
char_array_4[j] = 0;
|
||||
|
||||
for (j = 0; j <4; j++)
|
||||
char_array_4[j] = base64_chars.find(char_array_4[j]);
|
||||
|
||||
char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
|
||||
char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
|
||||
char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
|
||||
|
||||
for (j = 0; (j < i - 1); j++) *retBuf++ = char_array_3[j];
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue