diff --git a/cmake/link_vt.cmake b/cmake/link_vt.cmake index 1f7464d855..80d9574582 100644 --- a/cmake/link_vt.cmake +++ b/cmake/link_vt.cmake @@ -28,6 +28,7 @@ function(link_target_with_vt) LINK_FCONTEXT LINK_CHECKPOINT LINK_CLI11 + LINK_YAMLCPP LINK_DL LINK_ZOLTAN LINK_FORT @@ -41,7 +42,7 @@ function(link_target_with_vt) set(allKeywords ${noValOption} ${singleValArg} ${multiValueArg}) cmake_parse_arguments( - ARG "${noValOption}" "${singleValArg}" "${multiValueArgs}" ${ARGN} + ARG "${noValOption}" "${singleValArg}" "${multiValueArg}" ${ARGN} ) if (${ARG_DEBUG_LINK}) @@ -211,6 +212,15 @@ function(link_target_with_vt) ) endif() + if (NOT DEFINED ARG_LINK_YAMLCPP AND ${ARG_DEFAULT_LINK_SET} OR ARG_LINK_YAMLCPP) + if (${ARG_DEBUG_LINK}) + message(STATUS "link_target_with_vt: yamlcpp=${ARG_LINK_YAMLCPP}") + endif() + target_link_libraries( + ${ARG_TARGET} PUBLIC ${ARG_BUILD_TYPE} ${YAMLCPP_LIBRARY} + ) + endif() + if (${vt_mimalloc_enabled}) if (${ARG_DEBUG_LINK}) message(STATUS "link_target_with_vt: mimalloc=${vt_mimalloc_enabled}") diff --git a/cmake/load_bundled_libraries.cmake b/cmake/load_bundled_libraries.cmake index 65d1b1b8e0..0981547a6a 100644 --- a/cmake/load_bundled_libraries.cmake +++ b/cmake/load_bundled_libraries.cmake @@ -38,6 +38,10 @@ else() set_darma_compiler_flags(${FMT_LIBRARY}) endif() +# yaml-cpp always included in the build +set(YAMLCPP_LIBRARY yaml-cpp) +add_subdirectory(${PROJECT_LIB_DIR}/yaml-cpp) +set_darma_compiler_flags(${YAMLCPP_LIBRARY}) # EngFormat-Cpp always included in the build set(ENG_FORMAT_LIBRARY EngFormat-Cpp) diff --git a/cmake/test_vt.cmake b/cmake/test_vt.cmake index 37a9100a4d..87d4120d70 100644 --- a/cmake/test_vt.cmake +++ b/cmake/test_vt.cmake @@ -21,6 +21,7 @@ function(run_executable_with_mpi) TARGET_ARGS WRAPPER_ARGS ) + set(allKeywords ${noValOption} ${singleValArg} ${multiValueArg}) cmake_parse_arguments( ARG "${noValOption}" "${singleValArg}" "${multiValueArgs}" ${ARGN} diff --git a/cmake/trace_only_functions.cmake b/cmake/trace_only_functions.cmake index a1af29abbf..030d42966e 100644 --- a/cmake/trace_only_functions.cmake +++ b/cmake/trace_only_functions.cmake @@ -102,6 +102,18 @@ function(create_trace_only_target) DESTINATION "include/vt-trace/EngFormat-Cpp" ) + install( + DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/../lib/yaml-cpp/include/yaml-cpp/" + DESTINATION "include/vt-trace/yaml-cpp" + FILES_MATCHING PATTERN "*.h" + ) + + install( + DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/../lib/yaml-cpp/include/yaml-cpp/node" + DESTINATION "include/vt-trace/yaml-cpp/node" + FILES_MATCHING PATTERN "*.h" + ) + set(VT_TRACE_LIB vt-trace CACHE INTERNAL "" FORCE) add_library( ${VT_TRACE_LIB} @@ -118,6 +130,7 @@ function(create_trace_only_target) TARGET ${VT_TRACE_LIB} LINK_VT_LIB LINK_FMT 1 + LINK_YAMLCPP 1 LINK_ENG_FORMAT 1 LINK_ZLIB 1 LINK_MPI 1 diff --git a/lib/yaml-cpp/CMakeLists.txt b/lib/yaml-cpp/CMakeLists.txt new file mode 100644 index 0000000000..493ebadbdf --- /dev/null +++ b/lib/yaml-cpp/CMakeLists.txt @@ -0,0 +1,149 @@ +# 3.5 is actually available almost everywhere, but this a good minimum +cmake_minimum_required(VERSION 3.4) + +# enable MSVC_RUNTIME_LIBRARY target property +# see https://cmake.org/cmake/help/latest/policy/CMP0091.html +if(POLICY CMP0091) + cmake_policy(SET CMP0091 NEW) +endif() + +project(YAML_CPP VERSION 0.7.0 LANGUAGES CXX) + +include(CMakePackageConfigHelpers) +include(CMakeDependentOption) +include(CheckCXXCompilerFlag) +include(GNUInstallDirs) +include(CTest) + +find_program(YAML_CPP_CLANG_FORMAT_EXE NAMES clang-format) + +option(YAML_CPP_BUILD_CONTRIB "Enable yaml-cpp contrib in library" ON) +option(YAML_CPP_BUILD_TOOLS "Enable parse tools" ON) +option(YAML_BUILD_SHARED_LIBS "Build yaml-cpp shared library" ${BUILD_SHARED_LIBS}) + +cmake_dependent_option(YAML_CPP_BUILD_TESTS + "Enable yaml-cpp tests" ON + "BUILD_TESTING;CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR" OFF) +cmake_dependent_option(YAML_MSVC_SHARED_RT + "MSVC: Build yaml-cpp with shared runtime libs (/MD)" ON + "MSVC" OFF) + +set(yaml-cpp-type STATIC) +set(yaml-cpp-label-postfix "static") +if (YAML_BUILD_SHARED_LIBS) + set(yaml-cpp-type SHARED) + set(yaml-cpp-label-postfix "shared") +endif() + +set(build-shared $) +set(build-windows-dll $,${build-shared}>) +set(not-msvc $>) +set(msvc-shared_rt $) + +if (NOT DEFINED CMAKE_MSVC_RUNTIME_LIBRARY) + set(CMAKE_MSVC_RUNTIME_LIBRARY + MultiThreaded$<$:Debug>$<${msvc-shared_rt}:DLL>) +endif() + +set(contrib-pattern "src/contrib/*.cpp") +set(src-pattern "src/*.cpp") +if (CMAKE_VERSION VERSION_GREATER 3.12) + list(INSERT contrib-pattern 0 CONFIGURE_DEPENDS) + list(INSERT src-pattern 0 CONFIGURE_DEPENDS) +endif() + +file(GLOB yaml-cpp-contrib-sources ${contrib-pattern}) +file(GLOB yaml-cpp-sources ${src-pattern}) + +set(msvc-rt $) + +set(msvc-rt-mtd-static $) +set(msvc-rt-mt-static $) + +set(msvc-rt-mtd-dll $) +set(msvc-rt-mt-dll $) + +set(backport-msvc-runtime $) + +add_library(yaml-cpp ${yaml-cpp-type} "") +add_library(yaml-cpp::yaml-cpp ALIAS yaml-cpp) + +set_property(TARGET yaml-cpp + PROPERTY + MSVC_RUNTIME_LIBRARY ${CMAKE_MSVC_RUNTIME_LIBRARY}) +set_property(TARGET yaml-cpp + PROPERTY + CXX_STANDARD_REQUIRED ON) + +target_include_directories(yaml-cpp + SYSTEM PUBLIC + $ + $ + PRIVATE + $) + +if (NOT DEFINED CMAKE_CXX_STANDARD) + set_target_properties(yaml-cpp + PROPERTIES + CXX_STANDARD 11) +endif() + +target_compile_options(yaml-cpp + PRIVATE + $<${not-msvc}:-pedantic -pedantic-errors> + + $<$:-MTd> + $<$:-MT> + $<$:-MDd> + $<$:-MD>) + +target_compile_definitions(yaml-cpp + PRIVATE + $<${build-windows-dll}:${PROJECT_NAME}_DLL> + $<$>:YAML_CPP_NO_CONTRIB>) + +target_sources(yaml-cpp + PRIVATE + $<$:${yaml-cpp-contrib-sources}> + ${yaml-cpp-sources}) + +if (NOT DEFINED CMAKE_DEBUG_POSTFIX) + set(CMAKE_DEBUG_POSTFIX "d") +endif() + +set_target_properties(yaml-cpp PROPERTIES + VERSION "${PROJECT_VERSION}" + SOVERSION "${PROJECT_VERSION_MAJOR}.${PROJECT_VERSION_MINOR}" + PROJECT_LABEL "yaml-cpp ${yaml-cpp-label-postfix}" + DEBUG_POSTFIX "${CMAKE_DEBUG_POSTFIX}") + +configure_package_config_file( + "${PROJECT_SOURCE_DIR}/yaml-cpp-config.cmake.in" + "${PROJECT_BINARY_DIR}/yaml-cpp-config.cmake" + INSTALL_DESTINATION "${CMAKE_INSTALL_DATADIR}/cmake/yaml-cpp") + +write_basic_package_version_file( + "${PROJECT_BINARY_DIR}/yaml-cpp-config-version.cmake" + COMPATIBILITY AnyNewerVersion) + +configure_file(yaml-cpp.pc.in yaml-cpp.pc @ONLY) + +install(DIRECTORY ${PROJECT_SOURCE_DIR}/include/ + DESTINATION ${CMAKE_INSTALL_INCLUDEDIR} + FILES_MATCHING PATTERN "*.h") + +if(YAML_CPP_BUILD_TESTS) + add_subdirectory(test) +endif() + +if(YAML_CPP_BUILD_TOOLS) + add_subdirectory(util) +endif() + +if (YAML_CPP_CLANG_FORMAT_EXE) + add_custom_target(format + COMMAND clang-format --style=file -i $ + COMMAND_EXPAND_LISTS + COMMENT "Running clang-format" + VERBATIM) +endif() diff --git a/lib/yaml-cpp/LICENSE b/lib/yaml-cpp/LICENSE new file mode 100644 index 0000000000..991fdbbe7d --- /dev/null +++ b/lib/yaml-cpp/LICENSE @@ -0,0 +1,19 @@ +Copyright (c) 2008-2015 Jesse Beder. + +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. diff --git a/lib/yaml-cpp/README.md b/lib/yaml-cpp/README.md new file mode 100644 index 0000000000..627d44125d --- /dev/null +++ b/lib/yaml-cpp/README.md @@ -0,0 +1,61 @@ +# yaml-cpp [![Build Status](https://travis-ci.org/jbeder/yaml-cpp.svg?branch=master)](https://travis-ci.org/jbeder/yaml-cpp) [![Documentation](https://codedocs.xyz/jbeder/yaml-cpp.svg)](https://codedocs.xyz/jbeder/yaml-cpp/) + +yaml-cpp is a [YAML](http://www.yaml.org/) parser and emitter in C++ matching the [YAML 1.2 spec](http://www.yaml.org/spec/1.2/spec.html). + +To get a feel for how it can be used, see the [Tutorial](https://github.com/jbeder/yaml-cpp/wiki/Tutorial) or [How to Emit YAML](https://github.com/jbeder/yaml-cpp/wiki/How-To-Emit-YAML). For the old API (version < 0.5.0), see [How To Parse A Document](https://github.com/jbeder/yaml-cpp/wiki/How-To-Parse-A-Document-(Old-API)). + +# Problems? # + +If you find a bug, post an [issue](https://github.com/jbeder/yaml-cpp/issues)! If you have questions about how to use yaml-cpp, please post it on http://stackoverflow.com and tag it [`yaml-cpp`](http://stackoverflow.com/questions/tagged/yaml-cpp). + +# How to Build # + +yaml-cpp uses [CMake](http://www.cmake.org) to support cross-platform building. The basic steps to build are: + +1. Download and install [CMake](http://www.cmake.org) (Resources -> Download). + +**Note:** If you don't use the provided installer for your platform, make sure that you add CMake's bin folder to your path. + +2. Navigate into the source directory, and type: + +``` +mkdir build +cd build +``` + +3. Run CMake. The basic syntax is: + +``` +cmake [-G generator] [-DYAML_BUILD_SHARED_LIBS=ON|OFF] .. +``` + + * The `generator` is whatever type of build system you'd like to use. To see a full list of generators on your platform, just run `cmake` (with no arguments). For example: + * On Windows, you might use "Visual Studio 12 2013" to generate a Visual Studio 2013 solution or "Visual Studio 14 2015 Win64" to generate a 64-bit Visual Studio 2015 solution. + * On OS X, you might use "Xcode" to generate an Xcode project + * On a UNIX-y system, simply omit the option to generate a makefile + + * yaml-cpp defaults to building a static library, but you may build a shared library by specifying `-DYAML_BUILD_SHARED_LIBS=ON`. + + * For more options on customizing the build, see the [CMakeLists.txt](https://github.com/jbeder/yaml-cpp/blob/master/CMakeLists.txt) file. + +4. Build it! + +5. To clean up, just remove the `build` directory. + +# Recent Release # + +[yaml-cpp 0.6.0](https://github.com/jbeder/yaml-cpp/releases/tag/yaml-cpp-0.6.0) has been released! This release requires C++11, and no longer depends on Boost. + +[yaml-cpp 0.3.0](https://github.com/jbeder/yaml-cpp/releases/tag/release-0.3.0) is still available if you want the old API. + +**The old API will continue to be supported, and will still receive bugfixes!** The 0.3.x and 0.4.x versions will be old API releases, and 0.5.x and above will all be new API releases. + +# API Documentation + +The autogenerated API reference is hosted on [CodeDocs](https://codedocs.xyz/jbeder/yaml-cpp/index.html) + +# Third Party Integrations + +The following projects are not officially supported: + +- [Qt wrapper](https://gist.github.com/brcha/d392b2fe5f1e427cc8a6) diff --git a/lib/yaml-cpp/include/yaml-cpp/anchor.h b/lib/yaml-cpp/include/yaml-cpp/anchor.h new file mode 100644 index 0000000000..f46d1d79dd --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/anchor.h @@ -0,0 +1,17 @@ +#ifndef ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include + +namespace YAML { +using anchor_t = std::size_t; +const anchor_t NullAnchor = 0; +} + +#endif // ANCHOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/binary.h b/lib/yaml-cpp/include/yaml-cpp/binary.h new file mode 100644 index 0000000000..1050dae98c --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/binary.h @@ -0,0 +1,71 @@ +#ifndef BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include +#include + +#include "yaml-cpp/dll.h" + +namespace YAML { +YAML_CPP_API std::string EncodeBase64(const unsigned char *data, + std::size_t size); +YAML_CPP_API std::vector DecodeBase64(const std::string &input); + +class YAML_CPP_API Binary { + public: + Binary(const unsigned char *data_, std::size_t size_) + : m_data{}, m_unownedData(data_), m_unownedSize(size_) {} + Binary() : Binary(nullptr, 0) {} + Binary(const Binary &) = default; + Binary(Binary &&) = default; + Binary &operator=(const Binary &) = default; + Binary &operator=(Binary &&) = default; + + bool owned() const { return !m_unownedData; } + std::size_t size() const { return owned() ? m_data.size() : m_unownedSize; } + const unsigned char *data() const { + return owned() ? &m_data[0] : m_unownedData; + } + + void swap(std::vector &rhs) { + if (m_unownedData) { + m_data.swap(rhs); + rhs.clear(); + rhs.resize(m_unownedSize); + std::copy(m_unownedData, m_unownedData + m_unownedSize, rhs.begin()); + m_unownedData = nullptr; + m_unownedSize = 0; + } else { + m_data.swap(rhs); + } + } + + bool operator==(const Binary &rhs) const { + const std::size_t s = size(); + if (s != rhs.size()) + return false; + const unsigned char *d1 = data(); + const unsigned char *d2 = rhs.data(); + for (std::size_t i = 0; i < s; i++) { + if (*d1++ != *d2++) + return false; + } + return true; + } + + bool operator!=(const Binary &rhs) const { return !(*this == rhs); } + + private: + std::vector m_data; + const unsigned char *m_unownedData; + std::size_t m_unownedSize; +}; +} // namespace YAML + +#endif // BASE64_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/depthguard.h b/lib/yaml-cpp/include/yaml-cpp/depthguard.h new file mode 100644 index 0000000000..8ca61ac6cc --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/depthguard.h @@ -0,0 +1,77 @@ +#ifndef DEPTH_GUARD_H_00000000000000000000000000000000000000000000000000000000 +#define DEPTH_GUARD_H_00000000000000000000000000000000000000000000000000000000 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "exceptions.h" + +namespace YAML { + +/** + * @brief The DeepRecursion class + * An exception class which is thrown by DepthGuard. Ideally it should be + * a member of DepthGuard. However, DepthGuard is a templated class which means + * that any catch points would then need to know the template parameters. It is + * simpler for clients to not have to know at the catch point what was the + * maximum depth. + */ +class DeepRecursion : public ParserException { +public: + virtual ~DeepRecursion() = default; + + DeepRecursion(int depth, const Mark& mark_, const std::string& msg_); + + // Returns the recursion depth when the exception was thrown + int depth() const { + return m_depth; + } + +private: + int m_depth = 0; +}; + +/** + * @brief The DepthGuard class + * DepthGuard takes a reference to an integer. It increments the integer upon + * construction of DepthGuard and decrements the integer upon destruction. + * + * If the integer would be incremented past max_depth, then an exception is + * thrown. This is ideally geared toward guarding against deep recursion. + * + * @param max_depth + * compile-time configurable maximum depth. + */ +template +class DepthGuard final { +public: + DepthGuard(int & depth_, const Mark& mark_, const std::string& msg_) : m_depth(depth_) { + ++m_depth; + if ( max_depth <= m_depth ) { + throw DeepRecursion{m_depth, mark_, msg_}; + } + } + + DepthGuard(const DepthGuard & copy_ctor) = delete; + DepthGuard(DepthGuard && move_ctor) = delete; + DepthGuard & operator=(const DepthGuard & copy_assign) = delete; + DepthGuard & operator=(DepthGuard && move_assign) = delete; + + ~DepthGuard() { + --m_depth; + } + + int current_depth() const { + return m_depth; + } + +private: + int & m_depth; +}; + +} // namespace YAML + +#endif // DEPTH_GUARD_H_00000000000000000000000000000000000000000000000000000000 diff --git a/lib/yaml-cpp/include/yaml-cpp/dll.h b/lib/yaml-cpp/include/yaml-cpp/dll.h new file mode 100644 index 0000000000..a32c06b2e3 --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/dll.h @@ -0,0 +1,33 @@ +#ifndef DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +// The following ifdef block is the standard way of creating macros which make +// exporting from a DLL simpler. All files within this DLL are compiled with the +// yaml_cpp_EXPORTS symbol defined on the command line. This symbol should not +// be defined on any project that uses this DLL. This way any other project +// whose source files include this file see YAML_CPP_API functions as being +// imported from a DLL, whereas this DLL sees symbols defined with this macro as +// being exported. +#undef YAML_CPP_API + +#ifdef YAML_CPP_DLL // Using or Building YAML-CPP DLL (definition defined + // manually) +#ifdef yaml_cpp_EXPORTS // Building YAML-CPP DLL (definition created by CMake + // or defined manually) +// #pragma message( "Defining YAML_CPP_API for DLL export" ) +#define YAML_CPP_API __declspec(dllexport) +#else // yaml_cpp_EXPORTS +// #pragma message( "Defining YAML_CPP_API for DLL import" ) +#define YAML_CPP_API __declspec(dllimport) +#endif // yaml_cpp_EXPORTS +#else // YAML_CPP_DLL +#define YAML_CPP_API +#endif // YAML_CPP_DLL + +#endif // DLL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/emitfromevents.h b/lib/yaml-cpp/include/yaml-cpp/emitfromevents.h new file mode 100644 index 0000000000..a69cad3187 --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/emitfromevents.h @@ -0,0 +1,57 @@ +#ifndef EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include + +#include "yaml-cpp/anchor.h" +#include "yaml-cpp/emitterstyle.h" +#include "yaml-cpp/eventhandler.h" + +namespace YAML { +struct Mark; +} // namespace YAML + +namespace YAML { +class Emitter; + +class EmitFromEvents : public EventHandler { + public: + EmitFromEvents(Emitter& emitter); + + void OnDocumentStart(const Mark& mark) override; + void OnDocumentEnd() override; + + void OnNull(const Mark& mark, anchor_t anchor) override; + void OnAlias(const Mark& mark, anchor_t anchor) override; + void OnScalar(const Mark& mark, const std::string& tag, + anchor_t anchor, const std::string& value) override; + + void OnSequenceStart(const Mark& mark, const std::string& tag, + anchor_t anchor, EmitterStyle style) override; + void OnSequenceEnd() override; + + void OnMapStart(const Mark& mark, const std::string& tag, + anchor_t anchor, EmitterStyle style) override; + void OnMapEnd() override; + + private: + void BeginNode(); + void EmitProps(const std::string& tag, anchor_t anchor); + + private: + Emitter& m_emitter; + + struct State { + enum value { WaitingForSequenceEntry, WaitingForKey, WaitingForValue }; + }; + std::stack m_stateStack; +}; +} + +#endif // EMITFROMEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/emitter.h b/lib/yaml-cpp/include/yaml-cpp/emitter.h new file mode 100644 index 0000000000..e715fbd815 --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/emitter.h @@ -0,0 +1,281 @@ +#ifndef EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include +#include +#include +#include +#include +#include +#include + +#include "yaml-cpp/binary.h" +#include "yaml-cpp/dll.h" +#include "yaml-cpp/emitterdef.h" +#include "yaml-cpp/emittermanip.h" +#include "yaml-cpp/null.h" +#include "yaml-cpp/ostream_wrapper.h" + +namespace YAML { +class Binary; +struct _Null; +} // namespace YAML + +namespace YAML { +class EmitterState; + +class YAML_CPP_API Emitter { + public: + Emitter(); + explicit Emitter(std::ostream& stream); + Emitter(const Emitter&) = delete; + Emitter& operator=(const Emitter&) = delete; + ~Emitter(); + + // output + const char* c_str() const; + std::size_t size() const; + + // state checking + bool good() const; + const std::string GetLastError() const; + + // global setters + bool SetOutputCharset(EMITTER_MANIP value); + bool SetStringFormat(EMITTER_MANIP value); + bool SetBoolFormat(EMITTER_MANIP value); + bool SetNullFormat(EMITTER_MANIP value); + bool SetIntBase(EMITTER_MANIP value); + bool SetSeqFormat(EMITTER_MANIP value); + bool SetMapFormat(EMITTER_MANIP value); + bool SetIndent(std::size_t n); + bool SetPreCommentIndent(std::size_t n); + bool SetPostCommentIndent(std::size_t n); + bool SetFloatPrecision(std::size_t n); + bool SetDoublePrecision(std::size_t n); + void RestoreGlobalModifiedSettings(); + + // local setters + Emitter& SetLocalValue(EMITTER_MANIP value); + Emitter& SetLocalIndent(const _Indent& indent); + Emitter& SetLocalPrecision(const _Precision& precision); + + // overloads of write + Emitter& Write(const std::string& str); + Emitter& Write(bool b); + Emitter& Write(char ch); + Emitter& Write(const _Alias& alias); + Emitter& Write(const _Anchor& anchor); + Emitter& Write(const _Tag& tag); + Emitter& Write(const _Comment& comment); + Emitter& Write(const _Null& n); + Emitter& Write(const Binary& binary); + + template + Emitter& WriteIntegralType(T value); + + template + Emitter& WriteStreamable(T value); + + private: + template + void SetStreamablePrecision(std::stringstream&) {} + std::size_t GetFloatPrecision() const; + std::size_t GetDoublePrecision() const; + + void PrepareIntegralStream(std::stringstream& stream) const; + void StartedScalar(); + + private: + void EmitBeginDoc(); + void EmitEndDoc(); + void EmitBeginSeq(); + void EmitEndSeq(); + void EmitBeginMap(); + void EmitEndMap(); + void EmitNewline(); + void EmitKindTag(); + void EmitTag(bool verbatim, const _Tag& tag); + + void PrepareNode(EmitterNodeType::value child); + void PrepareTopNode(EmitterNodeType::value child); + void FlowSeqPrepareNode(EmitterNodeType::value child); + void BlockSeqPrepareNode(EmitterNodeType::value child); + + void FlowMapPrepareNode(EmitterNodeType::value child); + + void FlowMapPrepareLongKey(EmitterNodeType::value child); + void FlowMapPrepareLongKeyValue(EmitterNodeType::value child); + void FlowMapPrepareSimpleKey(EmitterNodeType::value child); + void FlowMapPrepareSimpleKeyValue(EmitterNodeType::value child); + + void BlockMapPrepareNode(EmitterNodeType::value child); + + void BlockMapPrepareLongKey(EmitterNodeType::value child); + void BlockMapPrepareLongKeyValue(EmitterNodeType::value child); + void BlockMapPrepareSimpleKey(EmitterNodeType::value child); + void BlockMapPrepareSimpleKeyValue(EmitterNodeType::value child); + + void SpaceOrIndentTo(bool requireSpace, std::size_t indent); + + const char* ComputeFullBoolName(bool b) const; + const char* ComputeNullName() const; + bool CanEmitNewline() const; + + private: + std::unique_ptr m_pState; + ostream_wrapper m_stream; +}; + +template +inline Emitter& Emitter::WriteIntegralType(T value) { + if (!good()) + return *this; + + PrepareNode(EmitterNodeType::value::Scalar); + + std::stringstream stream; + PrepareIntegralStream(stream); + stream << value; + m_stream << stream.str(); + + StartedScalar(); + + return *this; +} + +template +inline Emitter& Emitter::WriteStreamable(T value) { + if (!good()) + return *this; + + PrepareNode(EmitterNodeType::value::Scalar); + + std::stringstream stream; + SetStreamablePrecision(stream); + + bool special = false; + if (std::is_floating_point::value) { + if ((std::numeric_limits::has_quiet_NaN || + std::numeric_limits::has_signaling_NaN) && + std::isnan(value)) { + special = true; + stream << ".nan"; + } else if (std::numeric_limits::has_infinity && std::isinf(value)) { + special = true; + if (std::signbit(value)) { + stream << "-.inf"; + } else { + stream << ".inf"; + } + } + } + + if (!special) { + stream << value; + } + m_stream << stream.str(); + + StartedScalar(); + + return *this; +} + +template <> +inline void Emitter::SetStreamablePrecision(std::stringstream& stream) { + stream.precision(static_cast(GetFloatPrecision())); +} + +template <> +inline void Emitter::SetStreamablePrecision(std::stringstream& stream) { + stream.precision(static_cast(GetDoublePrecision())); +} + +// overloads of insertion +inline Emitter& operator<<(Emitter& emitter, const std::string& v) { + return emitter.Write(v); +} +inline Emitter& operator<<(Emitter& emitter, bool v) { + return emitter.Write(v); +} +inline Emitter& operator<<(Emitter& emitter, char v) { + return emitter.Write(v); +} +inline Emitter& operator<<(Emitter& emitter, unsigned char v) { + return emitter.Write(static_cast(v)); +} +inline Emitter& operator<<(Emitter& emitter, const _Alias& v) { + return emitter.Write(v); +} +inline Emitter& operator<<(Emitter& emitter, const _Anchor& v) { + return emitter.Write(v); +} +inline Emitter& operator<<(Emitter& emitter, const _Tag& v) { + return emitter.Write(v); +} +inline Emitter& operator<<(Emitter& emitter, const _Comment& v) { + return emitter.Write(v); +} +inline Emitter& operator<<(Emitter& emitter, const _Null& v) { + return emitter.Write(v); +} +inline Emitter& operator<<(Emitter& emitter, const Binary& b) { + return emitter.Write(b); +} + +inline Emitter& operator<<(Emitter& emitter, const char* v) { + return emitter.Write(std::string(v)); +} + +inline Emitter& operator<<(Emitter& emitter, int v) { + return emitter.WriteIntegralType(v); +} +inline Emitter& operator<<(Emitter& emitter, unsigned int v) { + return emitter.WriteIntegralType(v); +} +inline Emitter& operator<<(Emitter& emitter, short v) { + return emitter.WriteIntegralType(v); +} +inline Emitter& operator<<(Emitter& emitter, unsigned short v) { + return emitter.WriteIntegralType(v); +} +inline Emitter& operator<<(Emitter& emitter, long v) { + return emitter.WriteIntegralType(v); +} +inline Emitter& operator<<(Emitter& emitter, unsigned long v) { + return emitter.WriteIntegralType(v); +} +inline Emitter& operator<<(Emitter& emitter, long long v) { + return emitter.WriteIntegralType(v); +} +inline Emitter& operator<<(Emitter& emitter, unsigned long long v) { + return emitter.WriteIntegralType(v); +} + +inline Emitter& operator<<(Emitter& emitter, float v) { + return emitter.WriteStreamable(v); +} +inline Emitter& operator<<(Emitter& emitter, double v) { + return emitter.WriteStreamable(v); +} + +inline Emitter& operator<<(Emitter& emitter, EMITTER_MANIP value) { + return emitter.SetLocalValue(value); +} + +inline Emitter& operator<<(Emitter& emitter, _Indent indent) { + return emitter.SetLocalIndent(indent); +} + +inline Emitter& operator<<(Emitter& emitter, _Precision precision) { + return emitter.SetLocalPrecision(precision); +} +} // namespace YAML + +#endif // EMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/emitterdef.h b/lib/yaml-cpp/include/yaml-cpp/emitterdef.h new file mode 100644 index 0000000000..0b426957fa --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/emitterdef.h @@ -0,0 +1,16 @@ +#ifndef EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +namespace YAML { +struct EmitterNodeType { + enum value { NoType, Property, Scalar, FlowSeq, BlockSeq, FlowMap, BlockMap }; +}; +} + +#endif // EMITTERDEF_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/emittermanip.h b/lib/yaml-cpp/include/yaml-cpp/emittermanip.h new file mode 100644 index 0000000000..976d14950f --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/emittermanip.h @@ -0,0 +1,144 @@ +#ifndef EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include + +namespace YAML { +enum EMITTER_MANIP { + // general manipulators + Auto, + TagByKind, + Newline, + + // output character set + EmitNonAscii, + EscapeNonAscii, + EscapeAsJson, + + // string manipulators + // Auto, // duplicate + SingleQuoted, + DoubleQuoted, + Literal, + + // null manipulators + LowerNull, + UpperNull, + CamelNull, + TildeNull, + + // bool manipulators + YesNoBool, // yes, no + TrueFalseBool, // true, false + OnOffBool, // on, off + UpperCase, // TRUE, N + LowerCase, // f, yes + CamelCase, // No, Off + LongBool, // yes, On + ShortBool, // y, t + + // int manipulators + Dec, + Hex, + Oct, + + // document manipulators + BeginDoc, + EndDoc, + + // sequence manipulators + BeginSeq, + EndSeq, + Flow, + Block, + + // map manipulators + BeginMap, + EndMap, + Key, + Value, + // Flow, // duplicate + // Block, // duplicate + // Auto, // duplicate + LongKey +}; + +struct _Indent { + _Indent(int value_) : value(value_) {} + int value; +}; + +inline _Indent Indent(int value) { return _Indent(value); } + +struct _Alias { + _Alias(const std::string& content_) : content(content_) {} + std::string content; +}; + +inline _Alias Alias(const std::string& content) { return _Alias(content); } + +struct _Anchor { + _Anchor(const std::string& content_) : content(content_) {} + std::string content; +}; + +inline _Anchor Anchor(const std::string& content) { return _Anchor(content); } + +struct _Tag { + struct Type { + enum value { Verbatim, PrimaryHandle, NamedHandle }; + }; + + explicit _Tag(const std::string& prefix_, const std::string& content_, + Type::value type_) + : prefix(prefix_), content(content_), type(type_) {} + std::string prefix; + std::string content; + Type::value type; +}; + +inline _Tag VerbatimTag(const std::string& content) { + return _Tag("", content, _Tag::Type::Verbatim); +} + +inline _Tag LocalTag(const std::string& content) { + return _Tag("", content, _Tag::Type::PrimaryHandle); +} + +inline _Tag LocalTag(const std::string& prefix, const std::string content) { + return _Tag(prefix, content, _Tag::Type::NamedHandle); +} + +inline _Tag SecondaryTag(const std::string& content) { + return _Tag("", content, _Tag::Type::NamedHandle); +} + +struct _Comment { + _Comment(const std::string& content_) : content(content_) {} + std::string content; +}; + +inline _Comment Comment(const std::string& content) { return _Comment(content); } + +struct _Precision { + _Precision(int floatPrecision_, int doublePrecision_) + : floatPrecision(floatPrecision_), doublePrecision(doublePrecision_) {} + + int floatPrecision; + int doublePrecision; +}; + +inline _Precision FloatPrecision(int n) { return _Precision(n, -1); } + +inline _Precision DoublePrecision(int n) { return _Precision(-1, n); } + +inline _Precision Precision(int n) { return _Precision(n, n); } +} + +#endif // EMITTERMANIP_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/emitterstyle.h b/lib/yaml-cpp/include/yaml-cpp/emitterstyle.h new file mode 100644 index 0000000000..0ef7b0fd22 --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/emitterstyle.h @@ -0,0 +1,14 @@ +#ifndef EMITTERSTYLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define EMITTERSTYLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +namespace YAML { +enum class EmitterStyle { Default, Block, Flow }; +} + +#endif // EMITTERSTYLE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/eventhandler.h b/lib/yaml-cpp/include/yaml-cpp/eventhandler.h new file mode 100644 index 0000000000..df715e216a --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/eventhandler.h @@ -0,0 +1,45 @@ +#ifndef EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include + +#include "yaml-cpp/anchor.h" +#include "yaml-cpp/emitterstyle.h" + +namespace YAML { +struct Mark; + +class EventHandler { + public: + virtual ~EventHandler() = default; + + virtual void OnDocumentStart(const Mark& mark) = 0; + virtual void OnDocumentEnd() = 0; + + virtual void OnNull(const Mark& mark, anchor_t anchor) = 0; + virtual void OnAlias(const Mark& mark, anchor_t anchor) = 0; + virtual void OnScalar(const Mark& mark, const std::string& tag, + anchor_t anchor, const std::string& value) = 0; + + virtual void OnSequenceStart(const Mark& mark, const std::string& tag, + anchor_t anchor, EmitterStyle style) = 0; + virtual void OnSequenceEnd() = 0; + + virtual void OnMapStart(const Mark& mark, const std::string& tag, + anchor_t anchor, EmitterStyle style) = 0; + virtual void OnMapEnd() = 0; + + virtual void OnAnchor(const Mark& /*mark*/, + const std::string& /*anchor_name*/) { + // empty default implementation for compatibility + } +}; +} // namespace YAML + +#endif // EVENTHANDLER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/exceptions.h b/lib/yaml-cpp/include/yaml-cpp/exceptions.h new file mode 100644 index 0000000000..896a9d930f --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/exceptions.h @@ -0,0 +1,303 @@ +#ifndef EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "yaml-cpp/mark.h" +#include "yaml-cpp/noexcept.h" +#include "yaml-cpp/traits.h" +#include +#include +#include + +namespace YAML { +// error messages +namespace ErrorMsg { +const char* const YAML_DIRECTIVE_ARGS = + "YAML directives must have exactly one argument"; +const char* const YAML_VERSION = "bad YAML version: "; +const char* const YAML_MAJOR_VERSION = "YAML major version too large"; +const char* const REPEATED_YAML_DIRECTIVE = "repeated YAML directive"; +const char* const TAG_DIRECTIVE_ARGS = + "TAG directives must have exactly two arguments"; +const char* const REPEATED_TAG_DIRECTIVE = "repeated TAG directive"; +const char* const CHAR_IN_TAG_HANDLE = + "illegal character found while scanning tag handle"; +const char* const TAG_WITH_NO_SUFFIX = "tag handle with no suffix"; +const char* const END_OF_VERBATIM_TAG = "end of verbatim tag not found"; +const char* const END_OF_MAP = "end of map not found"; +const char* const END_OF_MAP_FLOW = "end of map flow not found"; +const char* const END_OF_SEQ = "end of sequence not found"; +const char* const END_OF_SEQ_FLOW = "end of sequence flow not found"; +const char* const MULTIPLE_TAGS = + "cannot assign multiple tags to the same node"; +const char* const MULTIPLE_ANCHORS = + "cannot assign multiple anchors to the same node"; +const char* const MULTIPLE_ALIASES = + "cannot assign multiple aliases to the same node"; +const char* const ALIAS_CONTENT = + "aliases can't have any content, *including* tags"; +const char* const INVALID_HEX = "bad character found while scanning hex number"; +const char* const INVALID_UNICODE = "invalid unicode: "; +const char* const INVALID_ESCAPE = "unknown escape character: "; +const char* const UNKNOWN_TOKEN = "unknown token"; +const char* const DOC_IN_SCALAR = "illegal document indicator in scalar"; +const char* const EOF_IN_SCALAR = "illegal EOF in scalar"; +const char* const CHAR_IN_SCALAR = "illegal character in scalar"; +const char* const TAB_IN_INDENTATION = + "illegal tab when looking for indentation"; +const char* const FLOW_END = "illegal flow end"; +const char* const BLOCK_ENTRY = "illegal block entry"; +const char* const MAP_KEY = "illegal map key"; +const char* const MAP_VALUE = "illegal map value"; +const char* const ALIAS_NOT_FOUND = "alias not found after *"; +const char* const ANCHOR_NOT_FOUND = "anchor not found after &"; +const char* const CHAR_IN_ALIAS = + "illegal character found while scanning alias"; +const char* const CHAR_IN_ANCHOR = + "illegal character found while scanning anchor"; +const char* const ZERO_INDENT_IN_BLOCK = + "cannot set zero indentation for a block scalar"; +const char* const CHAR_IN_BLOCK = "unexpected character in block scalar"; +const char* const AMBIGUOUS_ANCHOR = + "cannot assign the same alias to multiple nodes"; +const char* const UNKNOWN_ANCHOR = "the referenced anchor is not defined"; + +const char* const INVALID_NODE = + "invalid node; this may result from using a map iterator as a sequence " + "iterator, or vice-versa"; +const char* const INVALID_SCALAR = "invalid scalar"; +const char* const KEY_NOT_FOUND = "key not found"; +const char* const BAD_CONVERSION = "bad conversion"; +const char* const BAD_DEREFERENCE = "bad dereference"; +const char* const BAD_SUBSCRIPT = "operator[] call on a scalar"; +const char* const BAD_PUSHBACK = "appending to a non-sequence"; +const char* const BAD_INSERT = "inserting in a non-convertible-to-map"; + +const char* const UNMATCHED_GROUP_TAG = "unmatched group tag"; +const char* const UNEXPECTED_END_SEQ = "unexpected end sequence token"; +const char* const UNEXPECTED_END_MAP = "unexpected end map token"; +const char* const SINGLE_QUOTED_CHAR = + "invalid character in single-quoted string"; +const char* const INVALID_ANCHOR = "invalid anchor"; +const char* const INVALID_ALIAS = "invalid alias"; +const char* const INVALID_TAG = "invalid tag"; +const char* const BAD_FILE = "bad file"; + +template +inline const std::string KEY_NOT_FOUND_WITH_KEY( + const T&, typename disable_if>::type* = 0) { + return KEY_NOT_FOUND; +} + +inline const std::string KEY_NOT_FOUND_WITH_KEY(const std::string& key) { + std::stringstream stream; + stream << KEY_NOT_FOUND << ": " << key; + return stream.str(); +} + +inline const std::string KEY_NOT_FOUND_WITH_KEY(const char* key) { + std::stringstream stream; + stream << KEY_NOT_FOUND << ": " << key; + return stream.str(); +} + +template +inline const std::string KEY_NOT_FOUND_WITH_KEY( + const T& key, typename enable_if>::type* = 0) { + std::stringstream stream; + stream << KEY_NOT_FOUND << ": " << key; + return stream.str(); +} + +template +inline const std::string BAD_SUBSCRIPT_WITH_KEY( + const T&, typename disable_if>::type* = nullptr) { + return BAD_SUBSCRIPT; +} + +inline const std::string BAD_SUBSCRIPT_WITH_KEY(const std::string& key) { + std::stringstream stream; + stream << BAD_SUBSCRIPT << " (key: \"" << key << "\")"; + return stream.str(); +} + +inline const std::string BAD_SUBSCRIPT_WITH_KEY(const char* key) { + std::stringstream stream; + stream << BAD_SUBSCRIPT << " (key: \"" << key << "\")"; + return stream.str(); +} + +template +inline const std::string BAD_SUBSCRIPT_WITH_KEY( + const T& key, typename enable_if>::type* = nullptr) { + std::stringstream stream; + stream << BAD_SUBSCRIPT << " (key: \"" << key << "\")"; + return stream.str(); +} + +inline const std::string INVALID_NODE_WITH_KEY(const std::string& key) { + std::stringstream stream; + if (key.empty()) { + return INVALID_NODE; + } + stream << "invalid node; first invalid key: \"" << key << "\""; + return stream.str(); +} +} // namespace ErrorMsg + +class YAML_CPP_API Exception : public std::runtime_error { + public: + Exception(const Mark& mark_, const std::string& msg_) + : std::runtime_error(build_what(mark_, msg_)), mark(mark_), msg(msg_) {} + ~Exception() YAML_CPP_NOEXCEPT override; + + Exception(const Exception&) = default; + + Mark mark; + std::string msg; + + private: + static const std::string build_what(const Mark& mark_, + const std::string& msg_) { + if (mark_.is_null()) { + return msg_; + } + + std::stringstream output; + output << "yaml-cpp: error at line " << mark_.line + 1 << ", column " + << mark_.column + 1 << ": " << msg_; + return output.str(); + } +}; + +class YAML_CPP_API ParserException : public Exception { + public: + ParserException(const Mark& mark_, const std::string& msg_) + : Exception(mark_, msg_) {} + ParserException(const ParserException&) = default; + ~ParserException() YAML_CPP_NOEXCEPT override; +}; + +class YAML_CPP_API RepresentationException : public Exception { + public: + RepresentationException(const Mark& mark_, const std::string& msg_) + : Exception(mark_, msg_) {} + RepresentationException(const RepresentationException&) = default; + ~RepresentationException() YAML_CPP_NOEXCEPT override; +}; + +// representation exceptions +class YAML_CPP_API InvalidScalar : public RepresentationException { + public: + InvalidScalar(const Mark& mark_) + : RepresentationException(mark_, ErrorMsg::INVALID_SCALAR) {} + InvalidScalar(const InvalidScalar&) = default; + ~InvalidScalar() YAML_CPP_NOEXCEPT override; +}; + +class YAML_CPP_API KeyNotFound : public RepresentationException { + public: + template + KeyNotFound(const Mark& mark_, const T& key_) + : RepresentationException(mark_, ErrorMsg::KEY_NOT_FOUND_WITH_KEY(key_)) { + } + KeyNotFound(const KeyNotFound&) = default; + ~KeyNotFound() YAML_CPP_NOEXCEPT override; +}; + +template +class YAML_CPP_API TypedKeyNotFound : public KeyNotFound { + public: + TypedKeyNotFound(const Mark& mark_, const T& key_) + : KeyNotFound(mark_, key_), key(key_) {} + ~TypedKeyNotFound() YAML_CPP_NOEXCEPT override = default; + + T key; +}; + +template +inline TypedKeyNotFound MakeTypedKeyNotFound(const Mark& mark_, + const T& key_) { + return TypedKeyNotFound(mark_, key_); +} + +class YAML_CPP_API InvalidNode : public RepresentationException { + public: + InvalidNode(const std::string& key_) + : RepresentationException(Mark::null_mark(), + ErrorMsg::INVALID_NODE_WITH_KEY(key_)) {} + InvalidNode(const InvalidNode&) = default; + ~InvalidNode() YAML_CPP_NOEXCEPT override; +}; + +class YAML_CPP_API BadConversion : public RepresentationException { + public: + explicit BadConversion(const Mark& mark_) + : RepresentationException(mark_, ErrorMsg::BAD_CONVERSION) {} + BadConversion(const BadConversion&) = default; + ~BadConversion() YAML_CPP_NOEXCEPT override; +}; + +template +class TypedBadConversion : public BadConversion { + public: + explicit TypedBadConversion(const Mark& mark_) : BadConversion(mark_) {} +}; + +class YAML_CPP_API BadDereference : public RepresentationException { + public: + BadDereference() + : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_DEREFERENCE) {} + BadDereference(const BadDereference&) = default; + ~BadDereference() YAML_CPP_NOEXCEPT override; +}; + +class YAML_CPP_API BadSubscript : public RepresentationException { + public: + template + BadSubscript(const Mark& mark_, const Key& key_) + : RepresentationException(mark_, ErrorMsg::BAD_SUBSCRIPT_WITH_KEY(key_)) {} + BadSubscript(const BadSubscript&) = default; + ~BadSubscript() YAML_CPP_NOEXCEPT override; +}; + +class YAML_CPP_API BadPushback : public RepresentationException { + public: + BadPushback() + : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_PUSHBACK) {} + BadPushback(const BadPushback&) = default; + ~BadPushback() YAML_CPP_NOEXCEPT override; +}; + +class YAML_CPP_API BadInsert : public RepresentationException { + public: + BadInsert() + : RepresentationException(Mark::null_mark(), ErrorMsg::BAD_INSERT) {} + BadInsert(const BadInsert&) = default; + ~BadInsert() YAML_CPP_NOEXCEPT override; +}; + +class YAML_CPP_API EmitterException : public Exception { + public: + EmitterException(const std::string& msg_) + : Exception(Mark::null_mark(), msg_) {} + EmitterException(const EmitterException&) = default; + ~EmitterException() YAML_CPP_NOEXCEPT override; +}; + +class YAML_CPP_API BadFile : public Exception { + public: + explicit BadFile(const std::string& filename) + : Exception(Mark::null_mark(), + std::string(ErrorMsg::BAD_FILE) + ": " + filename) {} + BadFile(const BadFile&) = default; + ~BadFile() YAML_CPP_NOEXCEPT override; +}; +} // namespace YAML + +#endif // EXCEPTIONS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/mark.h b/lib/yaml-cpp/include/yaml-cpp/mark.h new file mode 100644 index 0000000000..bf94b4f41f --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/mark.h @@ -0,0 +1,29 @@ +#ifndef MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "yaml-cpp/dll.h" + +namespace YAML { +struct YAML_CPP_API Mark { + Mark() : pos(0), line(0), column(0) {} + + static const Mark null_mark() { return Mark(-1, -1, -1); } + + bool is_null() const { return pos == -1 && line == -1 && column == -1; } + + int pos; + int line, column; + + private: + Mark(int pos_, int line_, int column_) + : pos(pos_), line(line_), column(column_) {} +}; +} + +#endif // MARK_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/node/convert.h b/lib/yaml-cpp/include/yaml-cpp/node/convert.h new file mode 100644 index 0000000000..596898da60 --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/node/convert.h @@ -0,0 +1,392 @@ +#ifndef NODE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define NODE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "yaml-cpp/binary.h" +#include "yaml-cpp/node/impl.h" +#include "yaml-cpp/node/iterator.h" +#include "yaml-cpp/node/node.h" +#include "yaml-cpp/node/type.h" +#include "yaml-cpp/null.h" + + +namespace YAML { +class Binary; +struct _Null; +template +struct convert; +} // namespace YAML + +namespace YAML { +namespace conversion { +inline bool IsInfinity(const std::string& input) { + return input == ".inf" || input == ".Inf" || input == ".INF" || + input == "+.inf" || input == "+.Inf" || input == "+.INF"; +} + +inline bool IsNegativeInfinity(const std::string& input) { + return input == "-.inf" || input == "-.Inf" || input == "-.INF"; +} + +inline bool IsNaN(const std::string& input) { + return input == ".nan" || input == ".NaN" || input == ".NAN"; +} +} + +// Node +template <> +struct convert { + static Node encode(const Node& rhs) { return rhs; } + + static bool decode(const Node& node, Node& rhs) { + rhs.reset(node); + return true; + } +}; + +// std::string +template <> +struct convert { + static Node encode(const std::string& rhs) { return Node(rhs); } + + static bool decode(const Node& node, std::string& rhs) { + if (!node.IsScalar()) + return false; + rhs = node.Scalar(); + return true; + } +}; + +// C-strings can only be encoded +template <> +struct convert { + static Node encode(const char* rhs) { return Node(rhs); } +}; + +template <> +struct convert { + static Node encode(const char* rhs) { return Node(rhs); } +}; + +template +struct convert { + static Node encode(const char* rhs) { return Node(rhs); } +}; + +template <> +struct convert<_Null> { + static Node encode(const _Null& /* rhs */) { return Node(); } + + static bool decode(const Node& node, _Null& /* rhs */) { + return node.IsNull(); + } +}; + +namespace conversion { +template +typename std::enable_if< std::is_floating_point::value, void>::type +inner_encode(const T& rhs, std::stringstream& stream){ + if (std::isnan(rhs)) { + stream << ".nan"; + } else if (std::isinf(rhs)) { + if (std::signbit(rhs)) { + stream << "-.inf"; + } else { + stream << ".inf"; + } + } else { + stream << rhs; + } +} + +template +typename std::enable_if::value, void>::type +inner_encode(const T& rhs, std::stringstream& stream){ + stream << rhs; +} + +template +typename std::enable_if<(std::is_same::value || + std::is_same::value), bool>::type +ConvertStreamTo(std::stringstream& stream, T& rhs) { + int num; + if ((stream >> std::noskipws >> num) && (stream >> std::ws).eof()) { + if (num >= (std::numeric_limits::min)() && + num <= (std::numeric_limits::max)()) { + rhs = (T)num; + return true; + } + } + return false; +} + +template +typename std::enable_if::value || + std::is_same::value), bool>::type +ConvertStreamTo(std::stringstream& stream, T& rhs) { + if ((stream >> std::noskipws >> rhs) && (stream >> std::ws).eof()) { + return true; + } + return false; +} +} + +#define YAML_DEFINE_CONVERT_STREAMABLE(type, negative_op) \ + template <> \ + struct convert { \ + \ + static Node encode(const type& rhs) { \ + std::stringstream stream; \ + stream.precision(std::numeric_limits::max_digits10); \ + conversion::inner_encode(rhs, stream); \ + return Node(stream.str()); \ + } \ + \ + static bool decode(const Node& node, type& rhs) { \ + if (node.Type() != NodeType::Scalar) { \ + return false; \ + } \ + const std::string& input = node.Scalar(); \ + std::stringstream stream(input); \ + stream.unsetf(std::ios::dec); \ + if ((stream.peek() == '-') && std::is_unsigned::value) { \ + return false; \ + } \ + if (conversion::ConvertStreamTo(stream, rhs)) { \ + return true; \ + } \ + if (std::numeric_limits::has_infinity) { \ + if (conversion::IsInfinity(input)) { \ + rhs = std::numeric_limits::infinity(); \ + return true; \ + } else if (conversion::IsNegativeInfinity(input)) { \ + rhs = negative_op std::numeric_limits::infinity(); \ + return true; \ + } \ + } \ + \ + if (std::numeric_limits::has_quiet_NaN) { \ + if (conversion::IsNaN(input)) { \ + rhs = std::numeric_limits::quiet_NaN(); \ + return true; \ + } \ + } \ + \ + return false; \ + } \ + } + +#define YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(type) \ + YAML_DEFINE_CONVERT_STREAMABLE(type, -) + +#define YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(type) \ + YAML_DEFINE_CONVERT_STREAMABLE(type, +) + +YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(int); +YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(short); +YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(long); +YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(long long); +YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned); +YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned short); +YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned long); +YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned long long); + +YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(char); +YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(signed char); +YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED(unsigned char); + +YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(float); +YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(double); +YAML_DEFINE_CONVERT_STREAMABLE_SIGNED(long double); + +#undef YAML_DEFINE_CONVERT_STREAMABLE_SIGNED +#undef YAML_DEFINE_CONVERT_STREAMABLE_UNSIGNED +#undef YAML_DEFINE_CONVERT_STREAMABLE + +// bool +template <> +struct convert { + static Node encode(bool rhs) { return rhs ? Node("true") : Node("false"); } + + YAML_CPP_API static bool decode(const Node& node, bool& rhs); +}; + +// std::map +template +struct convert> { + static Node encode(const std::map& rhs) { + Node node(NodeType::Map); + for (const auto& element : rhs) + node.force_insert(element.first, element.second); + return node; + } + + static bool decode(const Node& node, std::map& rhs) { + if (!node.IsMap()) + return false; + + rhs.clear(); + for (const auto& element : node) +#if defined(__GNUC__) && __GNUC__ < 4 + // workaround for GCC 3: + rhs[element.first.template as()] = element.second.template as(); +#else + rhs[element.first.as()] = element.second.as(); +#endif + return true; + } +}; + +// std::vector +template +struct convert> { + static Node encode(const std::vector& rhs) { + Node node(NodeType::Sequence); + for (const auto& element : rhs) + node.push_back(element); + return node; + } + + static bool decode(const Node& node, std::vector& rhs) { + if (!node.IsSequence()) + return false; + + rhs.clear(); + for (const auto& element : node) +#if defined(__GNUC__) && __GNUC__ < 4 + // workaround for GCC 3: + rhs.push_back(element.template as()); +#else + rhs.push_back(element.as()); +#endif + return true; + } +}; + +// std::list +template +struct convert> { + static Node encode(const std::list& rhs) { + Node node(NodeType::Sequence); + for (const auto& element : rhs) + node.push_back(element); + return node; + } + + static bool decode(const Node& node, std::list& rhs) { + if (!node.IsSequence()) + return false; + + rhs.clear(); + for (const auto& element : node) +#if defined(__GNUC__) && __GNUC__ < 4 + // workaround for GCC 3: + rhs.push_back(element.template as()); +#else + rhs.push_back(element.as()); +#endif + return true; + } +}; + +// std::array +template +struct convert> { + static Node encode(const std::array& rhs) { + Node node(NodeType::Sequence); + for (const auto& element : rhs) { + node.push_back(element); + } + return node; + } + + static bool decode(const Node& node, std::array& rhs) { + if (!isNodeValid(node)) { + return false; + } + + for (auto i = 0u; i < node.size(); ++i) { +#if defined(__GNUC__) && __GNUC__ < 4 + // workaround for GCC 3: + rhs[i] = node[i].template as(); +#else + rhs[i] = node[i].as(); +#endif + } + return true; + } + + private: + static bool isNodeValid(const Node& node) { + return node.IsSequence() && node.size() == N; + } +}; + +// std::pair +template +struct convert> { + static Node encode(const std::pair& rhs) { + Node node(NodeType::Sequence); + node.push_back(rhs.first); + node.push_back(rhs.second); + return node; + } + + static bool decode(const Node& node, std::pair& rhs) { + if (!node.IsSequence()) + return false; + if (node.size() != 2) + return false; + +#if defined(__GNUC__) && __GNUC__ < 4 + // workaround for GCC 3: + rhs.first = node[0].template as(); +#else + rhs.first = node[0].as(); +#endif +#if defined(__GNUC__) && __GNUC__ < 4 + // workaround for GCC 3: + rhs.second = node[1].template as(); +#else + rhs.second = node[1].as(); +#endif + return true; + } +}; + +// binary +template <> +struct convert { + static Node encode(const Binary& rhs) { + return Node(EncodeBase64(rhs.data(), rhs.size())); + } + + static bool decode(const Node& node, Binary& rhs) { + if (!node.IsScalar()) + return false; + + std::vector data = DecodeBase64(node.Scalar()); + if (data.empty() && !node.Scalar().empty()) + return false; + + rhs.swap(data); + return true; + } +}; +} + +#endif // NODE_CONVERT_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/node/detail/impl.h b/lib/yaml-cpp/include/yaml-cpp/node/detail/impl.h new file mode 100644 index 0000000000..b38038dfd2 --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/node/detail/impl.h @@ -0,0 +1,235 @@ +#ifndef NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "yaml-cpp/node/detail/node.h" +#include "yaml-cpp/node/detail/node_data.h" + +#include +#include + +namespace YAML { +namespace detail { +template +struct get_idx { + static node* get(const std::vector& /* sequence */, + const Key& /* key */, shared_memory_holder /* pMemory */) { + return nullptr; + } +}; + +template +struct get_idx::value && + !std::is_same::value>::type> { + static node* get(const std::vector& sequence, const Key& key, + shared_memory_holder /* pMemory */) { + return key < sequence.size() ? sequence[key] : nullptr; + } + + static node* get(std::vector& sequence, const Key& key, + shared_memory_holder pMemory) { + if (key > sequence.size() || (key > 0 && !sequence[key - 1]->is_defined())) + return nullptr; + if (key == sequence.size()) + sequence.push_back(&pMemory->create_node()); + return sequence[key]; + } +}; + +template +struct get_idx::value>::type> { + static node* get(const std::vector& sequence, const Key& key, + shared_memory_holder pMemory) { + return key >= 0 ? get_idx::get( + sequence, static_cast(key), pMemory) + : nullptr; + } + static node* get(std::vector& sequence, const Key& key, + shared_memory_holder pMemory) { + return key >= 0 ? get_idx::get( + sequence, static_cast(key), pMemory) + : nullptr; + } +}; + +template +struct remove_idx { + static bool remove(std::vector&, const Key&, std::size_t&) { + return false; + } +}; + +template +struct remove_idx< + Key, typename std::enable_if::value && + !std::is_same::value>::type> { + + static bool remove(std::vector& sequence, const Key& key, + std::size_t& seqSize) { + if (key >= sequence.size()) { + return false; + } else { + sequence.erase(sequence.begin() + key); + if (seqSize > key) { + --seqSize; + } + return true; + } + } +}; + +template +struct remove_idx::value>::type> { + + static bool remove(std::vector& sequence, const Key& key, + std::size_t& seqSize) { + return key >= 0 ? remove_idx::remove( + sequence, static_cast(key), seqSize) + : false; + } +}; + +template +inline bool node::equals(const T& rhs, shared_memory_holder pMemory) { + T lhs; + if (convert::decode(Node(*this, pMemory), lhs)) { + return lhs == rhs; + } + return false; +} + +inline bool node::equals(const char* rhs, shared_memory_holder pMemory) { + std::string lhs; + if (convert::decode(Node(*this, std::move(pMemory)), lhs)) { + return lhs == rhs; + } + return false; +} + +// indexing +template +inline node* node_data::get(const Key& key, + shared_memory_holder pMemory) const { + switch (m_type) { + case NodeType::Map: + break; + case NodeType::Undefined: + case NodeType::Null: + return nullptr; + case NodeType::Sequence: + if (node* pNode = get_idx::get(m_sequence, key, pMemory)) + return pNode; + return nullptr; + case NodeType::Scalar: + throw BadSubscript(m_mark, key); + } + + auto it = std::find_if(m_map.begin(), m_map.end(), [&](const kv_pair m) { + return m.first->equals(key, pMemory); + }); + + return it != m_map.end() ? it->second : nullptr; +} + +template +inline node& node_data::get(const Key& key, shared_memory_holder pMemory) { + switch (m_type) { + case NodeType::Map: + break; + case NodeType::Undefined: + case NodeType::Null: + case NodeType::Sequence: + if (node* pNode = get_idx::get(m_sequence, key, pMemory)) { + m_type = NodeType::Sequence; + return *pNode; + } + + convert_to_map(pMemory); + break; + case NodeType::Scalar: + throw BadSubscript(m_mark, key); + } + + auto it = std::find_if(m_map.begin(), m_map.end(), [&](const kv_pair m) { + return m.first->equals(key, pMemory); + }); + + if (it != m_map.end()) { + return *it->second; + } + + node& k = convert_to_node(key, pMemory); + node& v = pMemory->create_node(); + insert_map_pair(k, v); + return v; +} + +template +inline bool node_data::remove(const Key& key, shared_memory_holder pMemory) { + if (m_type == NodeType::Sequence) { + return remove_idx::remove(m_sequence, key, m_seqSize); + } + + if (m_type == NodeType::Map) { + kv_pairs::iterator it = m_undefinedPairs.begin(); + while (it != m_undefinedPairs.end()) { + kv_pairs::iterator jt = std::next(it); + if (it->first->equals(key, pMemory)) { + m_undefinedPairs.erase(it); + } + it = jt; + } + + auto iter = std::find_if(m_map.begin(), m_map.end(), [&](const kv_pair m) { + return m.first->equals(key, pMemory); + }); + + if (iter != m_map.end()) { + m_map.erase(iter); + return true; + } + } + + return false; +} + +// map +template +inline void node_data::force_insert(const Key& key, const Value& value, + shared_memory_holder pMemory) { + switch (m_type) { + case NodeType::Map: + break; + case NodeType::Undefined: + case NodeType::Null: + case NodeType::Sequence: + convert_to_map(pMemory); + break; + case NodeType::Scalar: + throw BadInsert(); + } + + node& k = convert_to_node(key, pMemory); + node& v = convert_to_node(value, pMemory); + insert_map_pair(k, v); +} + +template +inline node& node_data::convert_to_node(const T& rhs, + shared_memory_holder pMemory) { + Node value = convert::encode(rhs); + value.EnsureNodeExists(); + pMemory->merge(*value.m_pMemory); + return *value.m_pNode; +} +} +} + +#endif // NODE_DETAIL_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/node/detail/iterator.h b/lib/yaml-cpp/include/yaml-cpp/node/detail/iterator.h new file mode 100644 index 0000000000..997c69a14c --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/node/detail/iterator.h @@ -0,0 +1,96 @@ +#ifndef VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "yaml-cpp/dll.h" +#include "yaml-cpp/node/detail/node_iterator.h" +#include "yaml-cpp/node/node.h" +#include "yaml-cpp/node/ptr.h" +#include +#include + + +namespace YAML { +namespace detail { +struct iterator_value; + +template +class iterator_base { + + private: + template + friend class iterator_base; + struct enabler {}; + using base_type = node_iterator; + + struct proxy { + explicit proxy(const V& x) : m_ref(x) {} + V* operator->() { return std::addressof(m_ref); } + operator V*() { return std::addressof(m_ref); } + + V m_ref; + }; + + public: + using iterator_category = std::forward_iterator_tag; + using value_type = V; + using difference_type = std::ptrdiff_t; + using pointer = V*; + using reference = V; + + public: + iterator_base() : m_iterator(), m_pMemory() {} + explicit iterator_base(base_type rhs, shared_memory_holder pMemory) + : m_iterator(rhs), m_pMemory(pMemory) {} + + template + iterator_base(const iterator_base& rhs, + typename std::enable_if::value, + enabler>::type = enabler()) + : m_iterator(rhs.m_iterator), m_pMemory(rhs.m_pMemory) {} + + iterator_base& operator++() { + ++m_iterator; + return *this; + } + + iterator_base operator++(int) { + iterator_base iterator_pre(*this); + ++(*this); + return iterator_pre; + } + + template + bool operator==(const iterator_base& rhs) const { + return m_iterator == rhs.m_iterator; + } + + template + bool operator!=(const iterator_base& rhs) const { + return m_iterator != rhs.m_iterator; + } + + value_type operator*() const { + const typename base_type::value_type& v = *m_iterator; + if (v.pNode) + return value_type(Node(*v, m_pMemory)); + if (v.first && v.second) + return value_type(Node(*v.first, m_pMemory), Node(*v.second, m_pMemory)); + return value_type(); + } + + proxy operator->() const { return proxy(**this); } + + private: + base_type m_iterator; + shared_memory_holder m_pMemory; +}; +} // namespace detail +} // namespace YAML + +#endif // VALUE_DETAIL_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/node/detail/iterator_fwd.h b/lib/yaml-cpp/include/yaml-cpp/node/detail/iterator_fwd.h new file mode 100644 index 0000000000..75c9de086c --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/node/detail/iterator_fwd.h @@ -0,0 +1,27 @@ +#ifndef VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "yaml-cpp/dll.h" +#include +#include +#include + +namespace YAML { + +namespace detail { +struct iterator_value; +template +class iterator_base; +} + +using iterator = detail::iterator_base; +using const_iterator = detail::iterator_base; +} + +#endif // VALUE_DETAIL_ITERATOR_FWD_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/node/detail/memory.h b/lib/yaml-cpp/include/yaml-cpp/node/detail/memory.h new file mode 100644 index 0000000000..e881545bf2 --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/node/detail/memory.h @@ -0,0 +1,47 @@ +#ifndef VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include + +#include "yaml-cpp/dll.h" +#include "yaml-cpp/node/ptr.h" + +namespace YAML { +namespace detail { +class node; +} // namespace detail +} // namespace YAML + +namespace YAML { +namespace detail { +class YAML_CPP_API memory { + public: + memory() : m_nodes{} {} + node& create_node(); + void merge(const memory& rhs); + + private: + using Nodes = std::set; + Nodes m_nodes; +}; + +class YAML_CPP_API memory_holder { + public: + memory_holder() : m_pMemory(new memory) {} + + node& create_node() { return m_pMemory->create_node(); } + void merge(memory_holder& rhs); + + private: + shared_memory m_pMemory; +}; +} // namespace detail +} // namespace YAML + +#endif // VALUE_DETAIL_MEMORY_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/node/detail/node.h b/lib/yaml-cpp/include/yaml-cpp/node/detail/node.h new file mode 100644 index 0000000000..44bc827be6 --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/node/detail/node.h @@ -0,0 +1,177 @@ +#ifndef NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "yaml-cpp/dll.h" +#include "yaml-cpp/emitterstyle.h" +#include "yaml-cpp/node/detail/node_ref.h" +#include "yaml-cpp/node/ptr.h" +#include "yaml-cpp/node/type.h" +#include +#include + +namespace YAML { +namespace detail { +class node { + private: + struct less { + bool operator ()(const node* l, const node* r) const {return l->m_index < r->m_index;} + }; + + public: + node() : m_pRef(new node_ref), m_dependencies{}, m_index{} {} + node(const node&) = delete; + node& operator=(const node&) = delete; + + bool is(const node& rhs) const { return m_pRef == rhs.m_pRef; } + const node_ref* ref() const { return m_pRef.get(); } + + bool is_defined() const { return m_pRef->is_defined(); } + const Mark& mark() const { return m_pRef->mark(); } + NodeType type() const { return m_pRef->type(); } + + const std::string& scalar() const { return m_pRef->scalar(); } + const std::string& tag() const { return m_pRef->tag(); } + EmitterStyle style() const { return m_pRef->style(); } + + template + bool equals(const T& rhs, shared_memory_holder pMemory); + bool equals(const char* rhs, shared_memory_holder pMemory); + + void mark_defined() { + if (is_defined()) + return; + + m_pRef->mark_defined(); + for (node* dependency : m_dependencies) + dependency->mark_defined(); + m_dependencies.clear(); + } + + void add_dependency(node& rhs) { + if (is_defined()) + rhs.mark_defined(); + else + m_dependencies.insert(&rhs); + } + + void set_ref(const node& rhs) { + if (rhs.is_defined()) + mark_defined(); + m_pRef = rhs.m_pRef; + } + void set_data(const node& rhs) { + if (rhs.is_defined()) + mark_defined(); + m_pRef->set_data(*rhs.m_pRef); + } + + void set_mark(const Mark& mark) { m_pRef->set_mark(mark); } + + void set_type(NodeType type) { + if (type != NodeType::Undefined) + mark_defined(); + m_pRef->set_type(type); + } + void set_null() { + mark_defined(); + m_pRef->set_null(); + } + void set_scalar(const std::string& scalar) { + mark_defined(); + m_pRef->set_scalar(scalar); + } + void set_tag(const std::string& tag) { + mark_defined(); + m_pRef->set_tag(tag); + } + + // style + void set_style(EmitterStyle style) { + mark_defined(); + m_pRef->set_style(style); + } + + // size/iterator + std::size_t size() const { return m_pRef->size(); } + + const_node_iterator begin() const { + return static_cast(*m_pRef).begin(); + } + node_iterator begin() { return m_pRef->begin(); } + + const_node_iterator end() const { + return static_cast(*m_pRef).end(); + } + node_iterator end() { return m_pRef->end(); } + + // sequence + void push_back(node& input, shared_memory_holder pMemory) { + m_pRef->push_back(input, pMemory); + input.add_dependency(*this); + m_index = m_amount.fetch_add(1); + } + void insert(node& key, node& value, shared_memory_holder pMemory) { + m_pRef->insert(key, value, pMemory); + key.add_dependency(*this); + value.add_dependency(*this); + } + + // indexing + template + node* get(const Key& key, shared_memory_holder pMemory) const { + // NOTE: this returns a non-const node so that the top-level Node can wrap + // it, and returns a pointer so that it can be nullptr (if there is no such + // key). + return static_cast(*m_pRef).get(key, pMemory); + } + template + node& get(const Key& key, shared_memory_holder pMemory) { + node& value = m_pRef->get(key, pMemory); + value.add_dependency(*this); + return value; + } + template + bool remove(const Key& key, shared_memory_holder pMemory) { + return m_pRef->remove(key, pMemory); + } + + node* get(node& key, shared_memory_holder pMemory) const { + // NOTE: this returns a non-const node so that the top-level Node can wrap + // it, and returns a pointer so that it can be nullptr (if there is no such + // key). + return static_cast(*m_pRef).get(key, pMemory); + } + node& get(node& key, shared_memory_holder pMemory) { + node& value = m_pRef->get(key, pMemory); + key.add_dependency(*this); + value.add_dependency(*this); + return value; + } + bool remove(node& key, shared_memory_holder pMemory) { + return m_pRef->remove(key, pMemory); + } + + // map + template + void force_insert(const Key& key, const Value& value, + shared_memory_holder pMemory) { + m_pRef->force_insert(key, value, pMemory); + } + + private: + shared_node_ref m_pRef; + using nodes = std::set; + nodes m_dependencies; + size_t m_index; + static std::atomic m_amount; +}; +} // namespace detail +} // namespace YAML + +#endif // NODE_DETAIL_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/node/detail/node_data.h b/lib/yaml-cpp/include/yaml-cpp/node/detail/node_data.h new file mode 100644 index 0000000000..647e10e139 --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/node/detail/node_data.h @@ -0,0 +1,127 @@ +#ifndef VALUE_DETAIL_NODE_DATA_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define VALUE_DETAIL_NODE_DATA_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include +#include +#include +#include +#include + +#include "yaml-cpp/dll.h" +#include "yaml-cpp/node/detail/node_iterator.h" +#include "yaml-cpp/node/iterator.h" +#include "yaml-cpp/node/ptr.h" +#include "yaml-cpp/node/type.h" + +namespace YAML { +namespace detail { +class node; +} // namespace detail +} // namespace YAML + +namespace YAML { +namespace detail { +class YAML_CPP_API node_data { + public: + node_data(); + node_data(const node_data&) = delete; + node_data& operator=(const node_data&) = delete; + + void mark_defined(); + void set_mark(const Mark& mark); + void set_type(NodeType type); + void set_tag(const std::string& tag); + void set_null(); + void set_scalar(const std::string& scalar); + void set_style(EmitterStyle style); + + bool is_defined() const { return m_isDefined; } + const Mark& mark() const { return m_mark; } + NodeType type() const { + return m_isDefined ? m_type : NodeType::Undefined; + } + const std::string& scalar() const { return m_scalar; } + const std::string& tag() const { return m_tag; } + EmitterStyle style() const { return m_style; } + + // size/iterator + std::size_t size() const; + + const_node_iterator begin() const; + node_iterator begin(); + + const_node_iterator end() const; + node_iterator end(); + + // sequence + void push_back(node& node, const shared_memory_holder& pMemory); + void insert(node& key, node& value, const shared_memory_holder& pMemory); + + // indexing + template + node* get(const Key& key, shared_memory_holder pMemory) const; + template + node& get(const Key& key, shared_memory_holder pMemory); + template + bool remove(const Key& key, shared_memory_holder pMemory); + + node* get(node& key, const shared_memory_holder& pMemory) const; + node& get(node& key, const shared_memory_holder& pMemory); + bool remove(node& key, const shared_memory_holder& pMemory); + + // map + template + void force_insert(const Key& key, const Value& value, + shared_memory_holder pMemory); + + public: + static const std::string& empty_scalar(); + + private: + void compute_seq_size() const; + void compute_map_size() const; + + void reset_sequence(); + void reset_map(); + + void insert_map_pair(node& key, node& value); + void convert_to_map(const shared_memory_holder& pMemory); + void convert_sequence_to_map(const shared_memory_holder& pMemory); + + template + static node& convert_to_node(const T& rhs, shared_memory_holder pMemory); + + private: + bool m_isDefined; + Mark m_mark; + NodeType m_type; + std::string m_tag; + EmitterStyle m_style; + + // scalar + std::string m_scalar; + + // sequence + using node_seq = std::vector; + node_seq m_sequence; + + mutable std::size_t m_seqSize; + + // map + using node_map = std::vector>; + node_map m_map; + + using kv_pair = std::pair; + using kv_pairs = std::list; + mutable kv_pairs m_undefinedPairs; +}; +} +} + +#endif // VALUE_DETAIL_NODE_DATA_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/node/detail/node_iterator.h b/lib/yaml-cpp/include/yaml-cpp/node/detail/node_iterator.h new file mode 100644 index 0000000000..49dcf958db --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/node/detail/node_iterator.h @@ -0,0 +1,181 @@ +#ifndef VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "yaml-cpp/dll.h" +#include "yaml-cpp/node/ptr.h" +#include +#include +#include +#include +#include +#include + +namespace YAML { +namespace detail { +struct iterator_type { + enum value { NoneType, Sequence, Map }; +}; + +template +struct node_iterator_value : public std::pair { + using kv = std::pair; + + node_iterator_value() : kv(), pNode(nullptr) {} + explicit node_iterator_value(V& rhs) : kv(), pNode(&rhs) {} + explicit node_iterator_value(V& key, V& value) : kv(&key, &value), pNode(nullptr) {} + + V& operator*() const { return *pNode; } + V& operator->() const { return *pNode; } + + V* pNode; +}; + +using node_seq = std::vector; +using node_map = std::vector>; + +template +struct node_iterator_type { + using seq = node_seq::iterator; + using map = node_map::iterator; +}; + +template +struct node_iterator_type { + using seq = node_seq::const_iterator; + using map = node_map::const_iterator; +}; + +template +class node_iterator_base { + private: + struct enabler {}; + + struct proxy { + explicit proxy(const node_iterator_value& x) : m_ref(x) {} + node_iterator_value* operator->() { return std::addressof(m_ref); } + operator node_iterator_value*() { return std::addressof(m_ref); } + + node_iterator_value m_ref; + }; + + public: + using iterator_category = std::forward_iterator_tag; + using value_type = node_iterator_value; + using difference_type = std::ptrdiff_t; + using pointer = node_iterator_value*; + using reference = node_iterator_value; + using SeqIter = typename node_iterator_type::seq; + using MapIter = typename node_iterator_type::map; + + node_iterator_base() + : m_type(iterator_type::NoneType), m_seqIt(), m_mapIt(), m_mapEnd() {} + explicit node_iterator_base(SeqIter seqIt) + : m_type(iterator_type::Sequence), + m_seqIt(seqIt), + m_mapIt(), + m_mapEnd() {} + explicit node_iterator_base(MapIter mapIt, MapIter mapEnd) + : m_type(iterator_type::Map), + m_seqIt(), + m_mapIt(mapIt), + m_mapEnd(mapEnd) { + m_mapIt = increment_until_defined(m_mapIt); + } + + template + node_iterator_base(const node_iterator_base& rhs, + typename std::enable_if::value, + enabler>::type = enabler()) + : m_type(rhs.m_type), + m_seqIt(rhs.m_seqIt), + m_mapIt(rhs.m_mapIt), + m_mapEnd(rhs.m_mapEnd) {} + + template + friend class node_iterator_base; + + template + bool operator==(const node_iterator_base& rhs) const { + if (m_type != rhs.m_type) + return false; + + switch (m_type) { + case iterator_type::NoneType: + return true; + case iterator_type::Sequence: + return m_seqIt == rhs.m_seqIt; + case iterator_type::Map: + return m_mapIt == rhs.m_mapIt; + } + return true; + } + + template + bool operator!=(const node_iterator_base& rhs) const { + return !(*this == rhs); + } + + node_iterator_base& operator++() { + switch (m_type) { + case iterator_type::NoneType: + break; + case iterator_type::Sequence: + ++m_seqIt; + break; + case iterator_type::Map: + ++m_mapIt; + m_mapIt = increment_until_defined(m_mapIt); + break; + } + return *this; + } + + node_iterator_base operator++(int) { + node_iterator_base iterator_pre(*this); + ++(*this); + return iterator_pre; + } + + value_type operator*() const { + switch (m_type) { + case iterator_type::NoneType: + return value_type(); + case iterator_type::Sequence: + return value_type(**m_seqIt); + case iterator_type::Map: + return value_type(*m_mapIt->first, *m_mapIt->second); + } + return value_type(); + } + + proxy operator->() const { return proxy(**this); } + + MapIter increment_until_defined(MapIter it) { + while (it != m_mapEnd && !is_defined(it)) + ++it; + return it; + } + + bool is_defined(MapIter it) const { + return it->first->is_defined() && it->second->is_defined(); + } + + private: + typename iterator_type::value m_type; + + SeqIter m_seqIt; + MapIter m_mapIt, m_mapEnd; +}; + +using node_iterator = node_iterator_base; +using const_node_iterator = node_iterator_base; +} +} + +#endif // VALUE_DETAIL_NODE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/node/detail/node_ref.h b/lib/yaml-cpp/include/yaml-cpp/node/detail/node_ref.h new file mode 100644 index 0000000000..57f6ab49d5 --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/node/detail/node_ref.h @@ -0,0 +1,98 @@ +#ifndef VALUE_DETAIL_NODE_REF_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define VALUE_DETAIL_NODE_REF_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "yaml-cpp/dll.h" +#include "yaml-cpp/node/type.h" +#include "yaml-cpp/node/ptr.h" +#include "yaml-cpp/node/detail/node_data.h" + +namespace YAML { +namespace detail { +class node_ref { + public: + node_ref() : m_pData(new node_data) {} + node_ref(const node_ref&) = delete; + node_ref& operator=(const node_ref&) = delete; + + bool is_defined() const { return m_pData->is_defined(); } + const Mark& mark() const { return m_pData->mark(); } + NodeType type() const { return m_pData->type(); } + const std::string& scalar() const { return m_pData->scalar(); } + const std::string& tag() const { return m_pData->tag(); } + EmitterStyle style() const { return m_pData->style(); } + + void mark_defined() { m_pData->mark_defined(); } + void set_data(const node_ref& rhs) { m_pData = rhs.m_pData; } + + void set_mark(const Mark& mark) { m_pData->set_mark(mark); } + void set_type(NodeType type) { m_pData->set_type(type); } + void set_tag(const std::string& tag) { m_pData->set_tag(tag); } + void set_null() { m_pData->set_null(); } + void set_scalar(const std::string& scalar) { m_pData->set_scalar(scalar); } + void set_style(EmitterStyle style) { m_pData->set_style(style); } + + // size/iterator + std::size_t size() const { return m_pData->size(); } + + const_node_iterator begin() const { + return static_cast(*m_pData).begin(); + } + node_iterator begin() { return m_pData->begin(); } + + const_node_iterator end() const { + return static_cast(*m_pData).end(); + } + node_iterator end() { return m_pData->end(); } + + // sequence + void push_back(node& node, shared_memory_holder pMemory) { + m_pData->push_back(node, pMemory); + } + void insert(node& key, node& value, shared_memory_holder pMemory) { + m_pData->insert(key, value, pMemory); + } + + // indexing + template + node* get(const Key& key, shared_memory_holder pMemory) const { + return static_cast(*m_pData).get(key, pMemory); + } + template + node& get(const Key& key, shared_memory_holder pMemory) { + return m_pData->get(key, pMemory); + } + template + bool remove(const Key& key, shared_memory_holder pMemory) { + return m_pData->remove(key, pMemory); + } + + node* get(node& key, shared_memory_holder pMemory) const { + return static_cast(*m_pData).get(key, pMemory); + } + node& get(node& key, shared_memory_holder pMemory) { + return m_pData->get(key, pMemory); + } + bool remove(node& key, shared_memory_holder pMemory) { + return m_pData->remove(key, pMemory); + } + + // map + template + void force_insert(const Key& key, const Value& value, + shared_memory_holder pMemory) { + m_pData->force_insert(key, value, pMemory); + } + + private: + shared_node_data m_pData; +}; +} +} + +#endif // VALUE_DETAIL_NODE_REF_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/node/emit.h b/lib/yaml-cpp/include/yaml-cpp/node/emit.h new file mode 100644 index 0000000000..032268c5d0 --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/node/emit.h @@ -0,0 +1,32 @@ +#ifndef NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include +#include + +#include "yaml-cpp/dll.h" + +namespace YAML { +class Emitter; +class Node; + +/** + * Emits the node to the given {@link Emitter}. If there is an error in writing, + * {@link Emitter#good} will return false. + */ +YAML_CPP_API Emitter& operator<<(Emitter& out, const Node& node); + +/** Emits the node to the given output stream. */ +YAML_CPP_API std::ostream& operator<<(std::ostream& out, const Node& node); + +/** Converts the node to a YAML string. */ +YAML_CPP_API std::string Dump(const Node& node); +} // namespace YAML + +#endif // NODE_EMIT_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/node/impl.h b/lib/yaml-cpp/include/yaml-cpp/node/impl.h new file mode 100644 index 0000000000..c4e49c8603 --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/node/impl.h @@ -0,0 +1,385 @@ +#ifndef NODE_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define NODE_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "yaml-cpp/exceptions.h" +#include "yaml-cpp/node/detail/memory.h" +#include "yaml-cpp/node/detail/node.h" +#include "yaml-cpp/node/iterator.h" +#include "yaml-cpp/node/node.h" +#include +#include + +namespace YAML { +inline Node::Node() + : m_isValid(true), m_invalidKey{}, m_pMemory(nullptr), m_pNode(nullptr) {} + +inline Node::Node(NodeType type) + : m_isValid(true), + m_invalidKey{}, + m_pMemory(new detail::memory_holder), + m_pNode(&m_pMemory->create_node()) { + m_pNode->set_type(type); +} + +template +inline Node::Node(const T& rhs) + : m_isValid(true), + m_invalidKey{}, + m_pMemory(new detail::memory_holder), + m_pNode(&m_pMemory->create_node()) { + Assign(rhs); +} + +inline Node::Node(const detail::iterator_value& rhs) + : m_isValid(rhs.m_isValid), + m_invalidKey(rhs.m_invalidKey), + m_pMemory(rhs.m_pMemory), + m_pNode(rhs.m_pNode) {} + +inline Node::Node(const Node& rhs) = default; + +inline Node::Node(Zombie) + : m_isValid(false), m_invalidKey{}, m_pMemory{}, m_pNode(nullptr) {} + +inline Node::Node(Zombie, const std::string& key) + : m_isValid(false), m_invalidKey(key), m_pMemory{}, m_pNode(nullptr) {} + +inline Node::Node(detail::node& node, detail::shared_memory_holder pMemory) + : m_isValid(true), m_invalidKey{}, m_pMemory(pMemory), m_pNode(&node) {} + +inline Node::~Node() = default; + +inline void Node::EnsureNodeExists() const { + if (!m_isValid) + throw InvalidNode(m_invalidKey); + if (!m_pNode) { + m_pMemory.reset(new detail::memory_holder); + m_pNode = &m_pMemory->create_node(); + m_pNode->set_null(); + } +} + +inline bool Node::IsDefined() const { + if (!m_isValid) { + return false; + } + return m_pNode ? m_pNode->is_defined() : true; +} + +inline Mark Node::Mark() const { + if (!m_isValid) { + throw InvalidNode(m_invalidKey); + } + return m_pNode ? m_pNode->mark() : Mark::null_mark(); +} + +inline NodeType Node::Type() const { + if (!m_isValid) + throw InvalidNode(m_invalidKey); + return m_pNode ? m_pNode->type() : NodeType::Null; +} + +// access + +// template helpers +template +struct as_if { + explicit as_if(const Node& node_) : node(node_) {} + const Node& node; + + T operator()(const S& fallback) const { + if (!node.m_pNode) + return fallback; + + T t; + if (convert::decode(node, t)) + return t; + return fallback; + } +}; + +template +struct as_if { + explicit as_if(const Node& node_) : node(node_) {} + const Node& node; + + std::string operator()(const S& fallback) const { + if (node.Type() == NodeType::Null) + return "null"; + if (node.Type() != NodeType::Scalar) + return fallback; + return node.Scalar(); + } +}; + +template +struct as_if { + explicit as_if(const Node& node_) : node(node_) {} + const Node& node; + + T operator()() const { + if (!node.m_pNode) + throw TypedBadConversion(node.Mark()); + + T t; + if (convert::decode(node, t)) + return t; + throw TypedBadConversion(node.Mark()); + } +}; + +template <> +struct as_if { + explicit as_if(const Node& node_) : node(node_) {} + const Node& node; + + std::string operator()() const { + if (node.Type() == NodeType::Null) + return "null"; + if (node.Type() != NodeType::Scalar) + throw TypedBadConversion(node.Mark()); + return node.Scalar(); + } +}; + +// access functions +template +inline T Node::as() const { + if (!m_isValid) + throw InvalidNode(m_invalidKey); + return as_if(*this)(); +} + +template +inline T Node::as(const S& fallback) const { + if (!m_isValid) + return fallback; + return as_if(*this)(fallback); +} + +inline const std::string& Node::Scalar() const { + if (!m_isValid) + throw InvalidNode(m_invalidKey); + return m_pNode ? m_pNode->scalar() : detail::node_data::empty_scalar(); +} + +inline const std::string& Node::Tag() const { + if (!m_isValid) + throw InvalidNode(m_invalidKey); + return m_pNode ? m_pNode->tag() : detail::node_data::empty_scalar(); +} + +inline void Node::SetTag(const std::string& tag) { + EnsureNodeExists(); + m_pNode->set_tag(tag); +} + +inline EmitterStyle Node::Style() const { + if (!m_isValid) + throw InvalidNode(m_invalidKey); + return m_pNode ? m_pNode->style() : EmitterStyle::Default; +} + +inline void Node::SetStyle(EmitterStyle style) { + EnsureNodeExists(); + m_pNode->set_style(style); +} + +// assignment +inline bool Node::is(const Node& rhs) const { + if (!m_isValid || !rhs.m_isValid) + throw InvalidNode(m_invalidKey); + if (!m_pNode || !rhs.m_pNode) + return false; + return m_pNode->is(*rhs.m_pNode); +} + +template +inline Node& Node::operator=(const T& rhs) { + Assign(rhs); + return *this; +} + +inline Node& Node::operator=(const Node& rhs) { + if (is(rhs)) + return *this; + AssignNode(rhs); + return *this; +} + +inline void Node::reset(const YAML::Node& rhs) { + if (!m_isValid || !rhs.m_isValid) + throw InvalidNode(m_invalidKey); + m_pMemory = rhs.m_pMemory; + m_pNode = rhs.m_pNode; +} + +template +inline void Node::Assign(const T& rhs) { + if (!m_isValid) + throw InvalidNode(m_invalidKey); + AssignData(convert::encode(rhs)); +} + +template <> +inline void Node::Assign(const std::string& rhs) { + EnsureNodeExists(); + m_pNode->set_scalar(rhs); +} + +inline void Node::Assign(const char* rhs) { + EnsureNodeExists(); + m_pNode->set_scalar(rhs); +} + +inline void Node::Assign(char* rhs) { + EnsureNodeExists(); + m_pNode->set_scalar(rhs); +} + +inline void Node::AssignData(const Node& rhs) { + EnsureNodeExists(); + rhs.EnsureNodeExists(); + + m_pNode->set_data(*rhs.m_pNode); + m_pMemory->merge(*rhs.m_pMemory); +} + +inline void Node::AssignNode(const Node& rhs) { + if (!m_isValid) + throw InvalidNode(m_invalidKey); + rhs.EnsureNodeExists(); + + if (!m_pNode) { + m_pNode = rhs.m_pNode; + m_pMemory = rhs.m_pMemory; + return; + } + + m_pNode->set_ref(*rhs.m_pNode); + m_pMemory->merge(*rhs.m_pMemory); + m_pNode = rhs.m_pNode; +} + +// size/iterator +inline std::size_t Node::size() const { + if (!m_isValid) + throw InvalidNode(m_invalidKey); + return m_pNode ? m_pNode->size() : 0; +} + +inline const_iterator Node::begin() const { + if (!m_isValid) + return const_iterator(); + return m_pNode ? const_iterator(m_pNode->begin(), m_pMemory) + : const_iterator(); +} + +inline iterator Node::begin() { + if (!m_isValid) + return iterator(); + return m_pNode ? iterator(m_pNode->begin(), m_pMemory) : iterator(); +} + +inline const_iterator Node::end() const { + if (!m_isValid) + return const_iterator(); + return m_pNode ? const_iterator(m_pNode->end(), m_pMemory) : const_iterator(); +} + +inline iterator Node::end() { + if (!m_isValid) + return iterator(); + return m_pNode ? iterator(m_pNode->end(), m_pMemory) : iterator(); +} + +// sequence +template +inline void Node::push_back(const T& rhs) { + if (!m_isValid) + throw InvalidNode(m_invalidKey); + push_back(Node(rhs)); +} + +inline void Node::push_back(const Node& rhs) { + EnsureNodeExists(); + rhs.EnsureNodeExists(); + + m_pNode->push_back(*rhs.m_pNode, m_pMemory); + m_pMemory->merge(*rhs.m_pMemory); +} + +template +std::string key_to_string(const Key& key) { + return streamable_to_string::value>().impl(key); +} + +// indexing +template +inline const Node Node::operator[](const Key& key) const { + EnsureNodeExists(); + detail::node* value = + static_cast(*m_pNode).get(key, m_pMemory); + if (!value) { + return Node(ZombieNode, key_to_string(key)); + } + return Node(*value, m_pMemory); +} + +template +inline Node Node::operator[](const Key& key) { + EnsureNodeExists(); + detail::node& value = m_pNode->get(key, m_pMemory); + return Node(value, m_pMemory); +} + +template +inline bool Node::remove(const Key& key) { + EnsureNodeExists(); + return m_pNode->remove(key, m_pMemory); +} + +inline const Node Node::operator[](const Node& key) const { + EnsureNodeExists(); + key.EnsureNodeExists(); + m_pMemory->merge(*key.m_pMemory); + detail::node* value = + static_cast(*m_pNode).get(*key.m_pNode, m_pMemory); + if (!value) { + return Node(ZombieNode, key_to_string(key)); + } + return Node(*value, m_pMemory); +} + +inline Node Node::operator[](const Node& key) { + EnsureNodeExists(); + key.EnsureNodeExists(); + m_pMemory->merge(*key.m_pMemory); + detail::node& value = m_pNode->get(*key.m_pNode, m_pMemory); + return Node(value, m_pMemory); +} + +inline bool Node::remove(const Node& key) { + EnsureNodeExists(); + key.EnsureNodeExists(); + return m_pNode->remove(*key.m_pNode, m_pMemory); +} + +// map +template +inline void Node::force_insert(const Key& key, const Value& value) { + EnsureNodeExists(); + m_pNode->force_insert(key, value, m_pMemory); +} + +// free functions +inline bool operator==(const Node& lhs, const Node& rhs) { return lhs.is(rhs); } +} // namespace YAML + +#endif // NODE_IMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/node/iterator.h b/lib/yaml-cpp/include/yaml-cpp/node/iterator.h new file mode 100644 index 0000000000..b447238179 --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/node/iterator.h @@ -0,0 +1,31 @@ +#ifndef VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "yaml-cpp/dll.h" +#include "yaml-cpp/node/node.h" +#include "yaml-cpp/node/detail/iterator_fwd.h" +#include "yaml-cpp/node/detail/iterator.h" +#include +#include +#include + +namespace YAML { +namespace detail { +struct iterator_value : public Node, std::pair { + iterator_value() = default; + explicit iterator_value(const Node& rhs) + : Node(rhs), + std::pair(Node(Node::ZombieNode), Node(Node::ZombieNode)) {} + explicit iterator_value(const Node& key, const Node& value) + : Node(Node::ZombieNode), std::pair(key, value) {} +}; +} +} + +#endif // VALUE_ITERATOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/node/node.h b/lib/yaml-cpp/include/yaml-cpp/node/node.h new file mode 100644 index 0000000000..9c1e80179d --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/node/node.h @@ -0,0 +1,148 @@ +#ifndef NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include +#include + +#include "yaml-cpp/dll.h" +#include "yaml-cpp/emitterstyle.h" +#include "yaml-cpp/mark.h" +#include "yaml-cpp/node/detail/iterator_fwd.h" +#include "yaml-cpp/node/ptr.h" +#include "yaml-cpp/node/type.h" + +namespace YAML { +namespace detail { +class node; +class node_data; +struct iterator_value; +} // namespace detail +} // namespace YAML + +namespace YAML { +class YAML_CPP_API Node { + public: + friend class NodeBuilder; + friend class NodeEvents; + friend struct detail::iterator_value; + friend class detail::node; + friend class detail::node_data; + template + friend class detail::iterator_base; + template + friend struct as_if; + + using iterator = YAML::iterator; + using const_iterator = YAML::const_iterator; + + Node(); + explicit Node(NodeType type); + template + explicit Node(const T& rhs); + explicit Node(const detail::iterator_value& rhs); + Node(const Node& rhs); + ~Node(); + + YAML::Mark Mark() const; + NodeType Type() const; + bool IsDefined() const; + bool IsNull() const { return Type() == NodeType::Null; } + bool IsScalar() const { return Type() == NodeType::Scalar; } + bool IsSequence() const { return Type() == NodeType::Sequence; } + bool IsMap() const { return Type() == NodeType::Map; } + + // bool conversions + explicit operator bool() const { return IsDefined(); } + bool operator!() const { return !IsDefined(); } + + // access + template + T as() const; + template + T as(const S& fallback) const; + const std::string& Scalar() const; + + const std::string& Tag() const; + void SetTag(const std::string& tag); + + // style + // WARNING: This API might change in future releases. + EmitterStyle Style() const; + void SetStyle(EmitterStyle style); + + // assignment + bool is(const Node& rhs) const; + template + Node& operator=(const T& rhs); + Node& operator=(const Node& rhs); + void reset(const Node& rhs = Node()); + + // size/iterator + std::size_t size() const; + + const_iterator begin() const; + iterator begin(); + + const_iterator end() const; + iterator end(); + + // sequence + template + void push_back(const T& rhs); + void push_back(const Node& rhs); + + // indexing + template + const Node operator[](const Key& key) const; + template + Node operator[](const Key& key); + template + bool remove(const Key& key); + + const Node operator[](const Node& key) const; + Node operator[](const Node& key); + bool remove(const Node& key); + + // map + template + void force_insert(const Key& key, const Value& value); + + private: + enum Zombie { ZombieNode }; + explicit Node(Zombie); + explicit Node(Zombie, const std::string&); + explicit Node(detail::node& node, detail::shared_memory_holder pMemory); + + void EnsureNodeExists() const; + + template + void Assign(const T& rhs); + void Assign(const char* rhs); + void Assign(char* rhs); + + void AssignData(const Node& rhs); + void AssignNode(const Node& rhs); + + private: + bool m_isValid; + // String representation of invalid key, if the node is invalid. + std::string m_invalidKey; + mutable detail::shared_memory_holder m_pMemory; + mutable detail::node* m_pNode; +}; + +YAML_CPP_API bool operator==(const Node& lhs, const Node& rhs); + +YAML_CPP_API Node Clone(const Node& node); + +template +struct convert; +} + +#endif // NODE_NODE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/node/parse.h b/lib/yaml-cpp/include/yaml-cpp/node/parse.h new file mode 100644 index 0000000000..7745fd7245 --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/node/parse.h @@ -0,0 +1,78 @@ +#ifndef VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include +#include +#include + +#include "yaml-cpp/dll.h" + +namespace YAML { +class Node; + +/** + * Loads the input string as a single YAML document. + * + * @throws {@link ParserException} if it is malformed. + */ +YAML_CPP_API Node Load(const std::string& input); + +/** + * Loads the input string as a single YAML document. + * + * @throws {@link ParserException} if it is malformed. + */ +YAML_CPP_API Node Load(const char* input); + +/** + * Loads the input stream as a single YAML document. + * + * @throws {@link ParserException} if it is malformed. + */ +YAML_CPP_API Node Load(std::istream& input); + +/** + * Loads the input file as a single YAML document. + * + * @throws {@link ParserException} if it is malformed. + * @throws {@link BadFile} if the file cannot be loaded. + */ +YAML_CPP_API Node LoadFile(const std::string& filename); + +/** + * Loads the input string as a list of YAML documents. + * + * @throws {@link ParserException} if it is malformed. + */ +YAML_CPP_API std::vector LoadAll(const std::string& input); + +/** + * Loads the input string as a list of YAML documents. + * + * @throws {@link ParserException} if it is malformed. + */ +YAML_CPP_API std::vector LoadAll(const char* input); + +/** + * Loads the input stream as a list of YAML documents. + * + * @throws {@link ParserException} if it is malformed. + */ +YAML_CPP_API std::vector LoadAll(std::istream& input); + +/** + * Loads the input file as a list of YAML documents. + * + * @throws {@link ParserException} if it is malformed. + * @throws {@link BadFile} if the file cannot be loaded. + */ +YAML_CPP_API std::vector LoadAllFromFile(const std::string& filename); +} // namespace YAML + +#endif // VALUE_PARSE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/node/ptr.h b/lib/yaml-cpp/include/yaml-cpp/node/ptr.h new file mode 100644 index 0000000000..062d77ea0f --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/node/ptr.h @@ -0,0 +1,29 @@ +#ifndef VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "yaml-cpp/dll.h" +#include + +namespace YAML { +namespace detail { +class node; +class node_ref; +class node_data; +class memory; +class memory_holder; + +using shared_node = std::shared_ptr; +using shared_node_ref = std::shared_ptr; +using shared_node_data = std::shared_ptr; +using shared_memory_holder = std::shared_ptr; +using shared_memory = std::shared_ptr; +} +} + +#endif // VALUE_PTR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/node/type.h b/lib/yaml-cpp/include/yaml-cpp/node/type.h new file mode 100644 index 0000000000..a14276a500 --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/node/type.h @@ -0,0 +1,14 @@ +#ifndef VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +namespace YAML { +enum class NodeType { Undefined, Null, Scalar, Sequence, Map }; +} + +#endif // VALUE_TYPE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/noexcept.h b/lib/yaml-cpp/include/yaml-cpp/noexcept.h new file mode 100644 index 0000000000..6aac63516f --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/noexcept.h @@ -0,0 +1,18 @@ +#ifndef NOEXCEPT_H_768872DA_476C_11EA_88B8_90B11C0C0FF8 +#define NOEXCEPT_H_768872DA_476C_11EA_88B8_90B11C0C0FF8 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +// This is here for compatibility with older versions of Visual Studio +// which don't support noexcept. +#if defined(_MSC_VER) && _MSC_VER < 1900 + #define YAML_CPP_NOEXCEPT _NOEXCEPT +#else + #define YAML_CPP_NOEXCEPT noexcept +#endif + +#endif diff --git a/lib/yaml-cpp/include/yaml-cpp/null.h b/lib/yaml-cpp/include/yaml-cpp/null.h new file mode 100644 index 0000000000..ab565a4b40 --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/null.h @@ -0,0 +1,26 @@ +#ifndef NULL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define NULL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "yaml-cpp/dll.h" +#include + +namespace YAML { +class Node; + +struct YAML_CPP_API _Null {}; +inline bool operator==(const _Null&, const _Null&) { return true; } +inline bool operator!=(const _Null&, const _Null&) { return false; } + +YAML_CPP_API bool IsNull(const Node& node); // old API only +YAML_CPP_API bool IsNullString(const std::string& str); + +extern YAML_CPP_API _Null BaseNull; +} + +#endif // NULL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/ostream_wrapper.h b/lib/yaml-cpp/include/yaml-cpp/ostream_wrapper.h new file mode 100644 index 0000000000..cf89741d09 --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/ostream_wrapper.h @@ -0,0 +1,76 @@ +#ifndef OSTREAM_WRAPPER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define OSTREAM_WRAPPER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include +#include + +#include "yaml-cpp/dll.h" + +namespace YAML { +class YAML_CPP_API ostream_wrapper { + public: + ostream_wrapper(); + explicit ostream_wrapper(std::ostream& stream); + ostream_wrapper(const ostream_wrapper&) = delete; + ostream_wrapper(ostream_wrapper&&) = delete; + ostream_wrapper& operator=(const ostream_wrapper&) = delete; + ostream_wrapper& operator=(ostream_wrapper&&) = delete; + ~ostream_wrapper(); + + void write(const std::string& str); + void write(const char* str, std::size_t size); + + void set_comment() { m_comment = true; } + + const char* str() const { + if (m_pStream) { + return nullptr; + } else { + m_buffer[m_pos] = '\0'; + return &m_buffer[0]; + } + } + + std::size_t row() const { return m_row; } + std::size_t col() const { return m_col; } + std::size_t pos() const { return m_pos; } + bool comment() const { return m_comment; } + + private: + void update_pos(char ch); + + private: + mutable std::vector m_buffer; + std::ostream* const m_pStream; + + std::size_t m_pos; + std::size_t m_row, m_col; + bool m_comment; +}; + +template +inline ostream_wrapper& operator<<(ostream_wrapper& stream, + const char (&str)[N]) { + stream.write(str, N - 1); + return stream; +} + +inline ostream_wrapper& operator<<(ostream_wrapper& stream, + const std::string& str) { + stream.write(str); + return stream; +} + +inline ostream_wrapper& operator<<(ostream_wrapper& stream, char ch) { + stream.write(&ch, 1); + return stream; +} +} // namespace YAML + +#endif // OSTREAM_WRAPPER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/parser.h b/lib/yaml-cpp/include/yaml-cpp/parser.h new file mode 100644 index 0000000000..2f403c3504 --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/parser.h @@ -0,0 +1,90 @@ +#ifndef PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include +#include + +#include "yaml-cpp/dll.h" + +namespace YAML { +class EventHandler; +class Node; +class Scanner; +struct Directives; +struct Token; + +/** + * A parser turns a stream of bytes into one stream of "events" per YAML + * document in the input stream. + */ +class YAML_CPP_API Parser { + public: + /** Constructs an empty parser (with no input. */ + Parser(); + + Parser(const Parser&) = delete; + Parser(Parser&&) = delete; + Parser& operator=(const Parser&) = delete; + Parser& operator=(Parser&&) = delete; + + /** + * Constructs a parser from the given input stream. The input stream must + * live as long as the parser. + */ + explicit Parser(std::istream& in); + + ~Parser(); + + /** Evaluates to true if the parser has some valid input to be read. */ + explicit operator bool() const; + + /** + * Resets the parser with the given input stream. Any existing state is + * erased. + */ + void Load(std::istream& in); + + /** + * Handles the next document by calling events on the {@code eventHandler}. + * + * @throw a ParserException on error. + * @return false if there are no more documents + */ + bool HandleNextDocument(EventHandler& eventHandler); + + void PrintTokens(std::ostream& out); + + private: + /** + * Reads any directives that are next in the queue, setting the internal + * {@code m_pDirectives} state. + */ + void ParseDirectives(); + + void HandleDirective(const Token& token); + + /** + * Handles a "YAML" directive, which should be of the form 'major.minor' (like + * a version number). + */ + void HandleYamlDirective(const Token& token); + + /** + * Handles a "TAG" directive, which should be of the form 'handle prefix', + * where 'handle' is converted to 'prefix' in the file. + */ + void HandleTagDirective(const Token& token); + + private: + std::unique_ptr m_pScanner; + std::unique_ptr m_pDirectives; +}; +} // namespace YAML + +#endif // PARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/stlemitter.h b/lib/yaml-cpp/include/yaml-cpp/stlemitter.h new file mode 100644 index 0000000000..210a2f64e6 --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/stlemitter.h @@ -0,0 +1,50 @@ +#ifndef STLEMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define STLEMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include +#include +#include +#include + +namespace YAML { +template +inline Emitter& EmitSeq(Emitter& emitter, const Seq& seq) { + emitter << BeginSeq; + for (const auto& v : seq) + emitter << v; + emitter << EndSeq; + return emitter; +} + +template +inline Emitter& operator<<(Emitter& emitter, const std::vector& v) { + return EmitSeq(emitter, v); +} + +template +inline Emitter& operator<<(Emitter& emitter, const std::list& v) { + return EmitSeq(emitter, v); +} + +template +inline Emitter& operator<<(Emitter& emitter, const std::set& v) { + return EmitSeq(emitter, v); +} + +template +inline Emitter& operator<<(Emitter& emitter, const std::map& m) { + emitter << BeginMap; + for (const auto& v : m) + emitter << Key << v.first << Value << v.second; + emitter << EndMap; + return emitter; +} +} + +#endif // STLEMITTER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/traits.h b/lib/yaml-cpp/include/yaml-cpp/traits.h new file mode 100644 index 0000000000..9a62db257a --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/traits.h @@ -0,0 +1,135 @@ +#ifndef TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include +#include +#include +#include + +namespace YAML { +template +struct is_numeric { + enum { value = false }; +}; + +template <> +struct is_numeric { + enum { value = true }; +}; +template <> +struct is_numeric { + enum { value = true }; +}; +template <> +struct is_numeric { + enum { value = true }; +}; +template <> +struct is_numeric { + enum { value = true }; +}; +template <> +struct is_numeric { + enum { value = true }; +}; +template <> +struct is_numeric { + enum { value = true }; +}; +template <> +struct is_numeric { + enum { value = true }; +}; +template <> +struct is_numeric { + enum { value = true }; +}; +#if defined(_MSC_VER) && (_MSC_VER < 1310) +template <> +struct is_numeric<__int64> { + enum { value = true }; +}; +template <> +struct is_numeric { + enum { value = true }; +}; +#else +template <> +struct is_numeric { + enum { value = true }; +}; +template <> +struct is_numeric { + enum { value = true }; +}; +#endif +template <> +struct is_numeric { + enum { value = true }; +}; +template <> +struct is_numeric { + enum { value = true }; +}; +template <> +struct is_numeric { + enum { value = true }; +}; + +template +struct enable_if_c { + using type = T; +}; + +template +struct enable_if_c {}; + +template +struct enable_if : public enable_if_c {}; + +template +struct disable_if_c { + using type = T; +}; + +template +struct disable_if_c {}; + +template +struct disable_if : public disable_if_c {}; +} + +template +struct is_streamable { + template + static auto test(int) + -> decltype(std::declval() << std::declval(), std::true_type()); + + template + static auto test(...) -> std::false_type; + + static const bool value = decltype(test(0))::value; +}; + +template +struct streamable_to_string { + static std::string impl(const Key& key) { + std::stringstream ss; + ss << key; + return ss.str(); + } +}; + +template +struct streamable_to_string { + static std::string impl(const Key&) { + return ""; + } +}; +#endif // TRAITS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/include/yaml-cpp/yaml.h b/lib/yaml-cpp/include/yaml-cpp/yaml.h new file mode 100644 index 0000000000..7f515efb96 --- /dev/null +++ b/lib/yaml-cpp/include/yaml-cpp/yaml.h @@ -0,0 +1,24 @@ +#ifndef YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "yaml-cpp/parser.h" +#include "yaml-cpp/emitter.h" +#include "yaml-cpp/emitterstyle.h" +#include "yaml-cpp/stlemitter.h" +#include "yaml-cpp/exceptions.h" + +#include "yaml-cpp/node/node.h" +#include "yaml-cpp/node/impl.h" +#include "yaml-cpp/node/convert.h" +#include "yaml-cpp/node/iterator.h" +#include "yaml-cpp/node/detail/impl.h" +#include "yaml-cpp/node/parse.h" +#include "yaml-cpp/node/emit.h" + +#endif // YAML_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/src/binary.cpp b/lib/yaml-cpp/src/binary.cpp new file mode 100644 index 0000000000..4311a2d063 --- /dev/null +++ b/lib/yaml-cpp/src/binary.cpp @@ -0,0 +1,100 @@ +#include "yaml-cpp/binary.h" + +#include + +namespace YAML { +static const char encoding[] = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + +std::string EncodeBase64(const unsigned char *data, std::size_t size) { + const char PAD = '='; + + std::string ret; + ret.resize(4 * size / 3 + 3); + char *out = &ret[0]; + + std::size_t chunks = size / 3; + std::size_t remainder = size % 3; + + for (std::size_t i = 0; i < chunks; i++, data += 3) { + *out++ = encoding[data[0] >> 2]; + *out++ = encoding[((data[0] & 0x3) << 4) | (data[1] >> 4)]; + *out++ = encoding[((data[1] & 0xf) << 2) | (data[2] >> 6)]; + *out++ = encoding[data[2] & 0x3f]; + } + + switch (remainder) { + case 0: + break; + case 1: + *out++ = encoding[data[0] >> 2]; + *out++ = encoding[((data[0] & 0x3) << 4)]; + *out++ = PAD; + *out++ = PAD; + break; + case 2: + *out++ = encoding[data[0] >> 2]; + *out++ = encoding[((data[0] & 0x3) << 4) | (data[1] >> 4)]; + *out++ = encoding[((data[1] & 0xf) << 2)]; + *out++ = PAD; + break; + } + + ret.resize(out - &ret[0]); + return ret; +} + +static const unsigned char decoding[] = { + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 62, 255, + 255, 255, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 255, 255, + 255, 0, 255, 255, 255, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, + 25, 255, 255, 255, 255, 255, 255, 26, 27, 28, 29, 30, 31, 32, 33, + 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, + 255, +}; + +std::vector DecodeBase64(const std::string &input) { + using ret_type = std::vector; + if (input.empty()) + return ret_type(); + + ret_type ret(3 * input.size() / 4 + 1); + unsigned char *out = &ret[0]; + + unsigned value = 0; + for (std::size_t i = 0, cnt = 0; i < input.size(); i++) { + if (std::isspace(input[i])) { + // skip newlines + continue; + } + unsigned char d = decoding[static_cast(input[i])]; + if (d == 255) + return ret_type(); + + value = (value << 6) | d; + if (cnt % 4 == 3) { + *out++ = value >> 16; + if (i > 0 && input[i - 1] != '=') + *out++ = value >> 8; + if (input[i] != '=') + *out++ = value; + } + ++cnt; + } + + ret.resize(out - &ret[0]); + return ret; +} +} // namespace YAML diff --git a/lib/yaml-cpp/src/collectionstack.h b/lib/yaml-cpp/src/collectionstack.h new file mode 100644 index 0000000000..9feba96795 --- /dev/null +++ b/lib/yaml-cpp/src/collectionstack.h @@ -0,0 +1,41 @@ +#ifndef COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include +#include + +namespace YAML { +struct CollectionType { + enum value { NoCollection, BlockMap, BlockSeq, FlowMap, FlowSeq, CompactMap }; +}; + +class CollectionStack { + public: + CollectionStack() : collectionStack{} {} + CollectionType::value GetCurCollectionType() const { + if (collectionStack.empty()) + return CollectionType::NoCollection; + return collectionStack.top(); + } + + void PushCollectionType(CollectionType::value type) { + collectionStack.push(type); + } + void PopCollectionType(CollectionType::value type) { + assert(type == GetCurCollectionType()); + (void)type; + collectionStack.pop(); + } + + private: + std::stack collectionStack; +}; +} // namespace YAML + +#endif // COLLECTIONSTACK_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/src/convert.cpp b/lib/yaml-cpp/src/convert.cpp new file mode 100644 index 0000000000..9658b36035 --- /dev/null +++ b/lib/yaml-cpp/src/convert.cpp @@ -0,0 +1,74 @@ +#include + +#include "yaml-cpp/node/convert.h" + +namespace { +// we're not gonna mess with the mess that is all the isupper/etc. functions +bool IsLower(char ch) { return 'a' <= ch && ch <= 'z'; } +bool IsUpper(char ch) { return 'A' <= ch && ch <= 'Z'; } +char ToLower(char ch) { return IsUpper(ch) ? ch + 'a' - 'A' : ch; } + +std::string tolower(const std::string& str) { + std::string s(str); + std::transform(s.begin(), s.end(), s.begin(), ToLower); + return s; +} + +template +bool IsEntirely(const std::string& str, T func) { + return std::all_of(str.begin(), str.end(), [=](char ch) { return func(ch); }); +} + +// IsFlexibleCase +// . Returns true if 'str' is: +// . UPPERCASE +// . lowercase +// . Capitalized +bool IsFlexibleCase(const std::string& str) { + if (str.empty()) + return true; + + if (IsEntirely(str, IsLower)) + return true; + + bool firstcaps = IsUpper(str[0]); + std::string rest = str.substr(1); + return firstcaps && (IsEntirely(rest, IsLower) || IsEntirely(rest, IsUpper)); +} +} // namespace + +namespace YAML { +bool convert::decode(const Node& node, bool& rhs) { + if (!node.IsScalar()) + return false; + + // we can't use iostream bool extraction operators as they don't + // recognize all possible values in the table below (taken from + // http://yaml.org/type/bool.html) + static const struct { + std::string truename, falsename; + } names[] = { + {"y", "n"}, + {"yes", "no"}, + {"true", "false"}, + {"on", "off"}, + }; + + if (!IsFlexibleCase(node.Scalar())) + return false; + + for (const auto& name : names) { + if (name.truename == tolower(node.Scalar())) { + rhs = true; + return true; + } + + if (name.falsename == tolower(node.Scalar())) { + rhs = false; + return true; + } + } + + return false; +} +} // namespace YAML diff --git a/lib/yaml-cpp/src/depthguard.cpp b/lib/yaml-cpp/src/depthguard.cpp new file mode 100644 index 0000000000..5bf6cdf03b --- /dev/null +++ b/lib/yaml-cpp/src/depthguard.cpp @@ -0,0 +1,9 @@ +#include "yaml-cpp/depthguard.h" + +namespace YAML { + +DeepRecursion::DeepRecursion(int depth, const Mark& mark_, + const std::string& msg_) + : ParserException(mark_, msg_), m_depth(depth) {} + +} // namespace YAML diff --git a/lib/yaml-cpp/src/directives.cpp b/lib/yaml-cpp/src/directives.cpp new file mode 100644 index 0000000000..f6e9587c6e --- /dev/null +++ b/lib/yaml-cpp/src/directives.cpp @@ -0,0 +1,17 @@ +#include "directives.h" + +namespace YAML { +Directives::Directives() : version{true, 1, 2}, tags{} {} + +const std::string Directives::TranslateTagHandle( + const std::string& handle) const { + auto it = tags.find(handle); + if (it == tags.end()) { + if (handle == "!!") + return "tag:yaml.org,2002:"; + return handle; + } + + return it->second; +} +} // namespace YAML diff --git a/lib/yaml-cpp/src/directives.h b/lib/yaml-cpp/src/directives.h new file mode 100644 index 0000000000..333af26e37 --- /dev/null +++ b/lib/yaml-cpp/src/directives.h @@ -0,0 +1,29 @@ +#ifndef DIRECTIVES_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define DIRECTIVES_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include +#include + +namespace YAML { +struct Version { + bool isDefault; + int major, minor; +}; + +struct Directives { + Directives(); + + const std::string TranslateTagHandle(const std::string& handle) const; + + Version version; + std::map tags; +}; +} + +#endif // DIRECTIVES_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/src/emit.cpp b/lib/yaml-cpp/src/emit.cpp new file mode 100644 index 0000000000..b0efb8401c --- /dev/null +++ b/lib/yaml-cpp/src/emit.cpp @@ -0,0 +1,25 @@ +#include "yaml-cpp/node/emit.h" +#include "nodeevents.h" +#include "yaml-cpp/emitfromevents.h" +#include "yaml-cpp/emitter.h" + +namespace YAML { +Emitter& operator<<(Emitter& out, const Node& node) { + EmitFromEvents emitFromEvents(out); + NodeEvents events(node); + events.Emit(emitFromEvents); + return out; +} + +std::ostream& operator<<(std::ostream& out, const Node& node) { + Emitter emitter(out); + emitter << node; + return out; +} + +std::string Dump(const Node& node) { + Emitter emitter; + emitter << node; + return emitter.c_str(); +} +} // namespace YAML diff --git a/lib/yaml-cpp/src/emitfromevents.cpp b/lib/yaml-cpp/src/emitfromevents.cpp new file mode 100644 index 0000000000..433f13fbf2 --- /dev/null +++ b/lib/yaml-cpp/src/emitfromevents.cpp @@ -0,0 +1,124 @@ +#include +#include + +#include "yaml-cpp/emitfromevents.h" +#include "yaml-cpp/emitter.h" +#include "yaml-cpp/emittermanip.h" +#include "yaml-cpp/null.h" + +namespace YAML { +struct Mark; +} // namespace YAML + +namespace { +std::string ToString(YAML::anchor_t anchor) { + std::stringstream stream; + stream << anchor; + return stream.str(); +} +} // namespace + +namespace YAML { +EmitFromEvents::EmitFromEvents(Emitter& emitter) + : m_emitter(emitter), m_stateStack{} {} + +void EmitFromEvents::OnDocumentStart(const Mark&) {} + +void EmitFromEvents::OnDocumentEnd() {} + +void EmitFromEvents::OnNull(const Mark&, anchor_t anchor) { + BeginNode(); + EmitProps("", anchor); + m_emitter << BaseNull; +} + +void EmitFromEvents::OnAlias(const Mark&, anchor_t anchor) { + BeginNode(); + m_emitter << Alias(ToString(anchor)); +} + +void EmitFromEvents::OnScalar(const Mark&, const std::string& tag, + anchor_t anchor, const std::string& value) { + BeginNode(); + EmitProps(tag, anchor); + m_emitter << value; +} + +void EmitFromEvents::OnSequenceStart(const Mark&, const std::string& tag, + anchor_t anchor, + EmitterStyle style) { + BeginNode(); + EmitProps(tag, anchor); + switch (style) { + case EmitterStyle::Block: + m_emitter << Block; + break; + case EmitterStyle::Flow: + m_emitter << Flow; + break; + default: + break; + } + // Restore the global settings to eliminate the override from node style + m_emitter.RestoreGlobalModifiedSettings(); + m_emitter << BeginSeq; + m_stateStack.push(State::WaitingForSequenceEntry); +} + +void EmitFromEvents::OnSequenceEnd() { + m_emitter << EndSeq; + assert(m_stateStack.top() == State::WaitingForSequenceEntry); + m_stateStack.pop(); +} + +void EmitFromEvents::OnMapStart(const Mark&, const std::string& tag, + anchor_t anchor, EmitterStyle style) { + BeginNode(); + EmitProps(tag, anchor); + switch (style) { + case EmitterStyle::Block: + m_emitter << Block; + break; + case EmitterStyle::Flow: + m_emitter << Flow; + break; + default: + break; + } + // Restore the global settings to eliminate the override from node style + m_emitter.RestoreGlobalModifiedSettings(); + m_emitter << BeginMap; + m_stateStack.push(State::WaitingForKey); +} + +void EmitFromEvents::OnMapEnd() { + m_emitter << EndMap; + assert(m_stateStack.top() == State::WaitingForKey); + m_stateStack.pop(); +} + +void EmitFromEvents::BeginNode() { + if (m_stateStack.empty()) + return; + + switch (m_stateStack.top()) { + case State::WaitingForKey: + m_emitter << Key; + m_stateStack.top() = State::WaitingForValue; + break; + case State::WaitingForValue: + m_emitter << Value; + m_stateStack.top() = State::WaitingForKey; + break; + default: + break; + } +} + +void EmitFromEvents::EmitProps(const std::string& tag, anchor_t anchor) { + if (!tag.empty() && tag != "?" && tag != "!") + m_emitter << VerbatimTag(tag); + if (anchor) + m_emitter << Anchor(ToString(anchor)); +} +} // namespace YAML diff --git a/lib/yaml-cpp/src/emitter.cpp b/lib/yaml-cpp/src/emitter.cpp new file mode 100644 index 0000000000..6924bea85f --- /dev/null +++ b/lib/yaml-cpp/src/emitter.cpp @@ -0,0 +1,971 @@ +#include + +#include "emitterutils.h" +#include "indentation.h" // IWYU pragma: keep +#include "yaml-cpp/emitter.h" +#include "yaml-cpp/emitterdef.h" +#include "yaml-cpp/emittermanip.h" +#include "yaml-cpp/exceptions.h" // IWYU pragma: keep + +namespace YAML { +class Binary; +struct _Null; + +Emitter::Emitter() : m_pState(new EmitterState), m_stream{} {} + +Emitter::Emitter(std::ostream& stream) + : m_pState(new EmitterState), m_stream(stream) {} + +Emitter::~Emitter() = default; + +const char* Emitter::c_str() const { return m_stream.str(); } + +std::size_t Emitter::size() const { return m_stream.pos(); } + +// state checking +bool Emitter::good() const { return m_pState->good(); } + +const std::string Emitter::GetLastError() const { + return m_pState->GetLastError(); +} + +// global setters +bool Emitter::SetOutputCharset(EMITTER_MANIP value) { + return m_pState->SetOutputCharset(value, FmtScope::Global); +} + +bool Emitter::SetStringFormat(EMITTER_MANIP value) { + return m_pState->SetStringFormat(value, FmtScope::Global); +} + +bool Emitter::SetBoolFormat(EMITTER_MANIP value) { + bool ok = false; + if (m_pState->SetBoolFormat(value, FmtScope::Global)) + ok = true; + if (m_pState->SetBoolCaseFormat(value, FmtScope::Global)) + ok = true; + if (m_pState->SetBoolLengthFormat(value, FmtScope::Global)) + ok = true; + return ok; +} + +bool Emitter::SetNullFormat(EMITTER_MANIP value) { + return m_pState->SetNullFormat(value, FmtScope::Global); +} + +bool Emitter::SetIntBase(EMITTER_MANIP value) { + return m_pState->SetIntFormat(value, FmtScope::Global); +} + +bool Emitter::SetSeqFormat(EMITTER_MANIP value) { + return m_pState->SetFlowType(GroupType::Seq, value, FmtScope::Global); +} + +bool Emitter::SetMapFormat(EMITTER_MANIP value) { + bool ok = false; + if (m_pState->SetFlowType(GroupType::Map, value, FmtScope::Global)) + ok = true; + if (m_pState->SetMapKeyFormat(value, FmtScope::Global)) + ok = true; + return ok; +} + +bool Emitter::SetIndent(std::size_t n) { + return m_pState->SetIndent(n, FmtScope::Global); +} + +bool Emitter::SetPreCommentIndent(std::size_t n) { + return m_pState->SetPreCommentIndent(n, FmtScope::Global); +} + +bool Emitter::SetPostCommentIndent(std::size_t n) { + return m_pState->SetPostCommentIndent(n, FmtScope::Global); +} + +bool Emitter::SetFloatPrecision(std::size_t n) { + return m_pState->SetFloatPrecision(n, FmtScope::Global); +} + +bool Emitter::SetDoublePrecision(std::size_t n) { + return m_pState->SetDoublePrecision(n, FmtScope::Global); +} + +void Emitter::RestoreGlobalModifiedSettings() { + m_pState->RestoreGlobalModifiedSettings(); +} + +// SetLocalValue +// . Either start/end a group, or set a modifier locally +Emitter& Emitter::SetLocalValue(EMITTER_MANIP value) { + if (!good()) + return *this; + + switch (value) { + case BeginDoc: + EmitBeginDoc(); + break; + case EndDoc: + EmitEndDoc(); + break; + case BeginSeq: + EmitBeginSeq(); + break; + case EndSeq: + EmitEndSeq(); + break; + case BeginMap: + EmitBeginMap(); + break; + case EndMap: + EmitEndMap(); + break; + case Key: + case Value: + // deprecated (these can be deduced by the parity of nodes in a map) + break; + case TagByKind: + EmitKindTag(); + break; + case Newline: + EmitNewline(); + break; + default: + m_pState->SetLocalValue(value); + break; + } + return *this; +} + +Emitter& Emitter::SetLocalIndent(const _Indent& indent) { + m_pState->SetIndent(indent.value, FmtScope::Local); + return *this; +} + +Emitter& Emitter::SetLocalPrecision(const _Precision& precision) { + if (precision.floatPrecision >= 0) + m_pState->SetFloatPrecision(precision.floatPrecision, FmtScope::Local); + if (precision.doublePrecision >= 0) + m_pState->SetDoublePrecision(precision.doublePrecision, FmtScope::Local); + return *this; +} + +// EmitBeginDoc +void Emitter::EmitBeginDoc() { + if (!good()) + return; + + if (m_pState->CurGroupType() != GroupType::NoType) { + m_pState->SetError("Unexpected begin document"); + return; + } + + if (m_pState->HasAnchor() || m_pState->HasTag()) { + m_pState->SetError("Unexpected begin document"); + return; + } + + if (m_stream.col() > 0) + m_stream << "\n"; + m_stream << "---\n"; + + m_pState->StartedDoc(); +} + +// EmitEndDoc +void Emitter::EmitEndDoc() { + if (!good()) + return; + + if (m_pState->CurGroupType() != GroupType::NoType) { + m_pState->SetError("Unexpected begin document"); + return; + } + + if (m_pState->HasAnchor() || m_pState->HasTag()) { + m_pState->SetError("Unexpected begin document"); + return; + } + + if (m_stream.col() > 0) + m_stream << "\n"; + m_stream << "...\n"; +} + +// EmitBeginSeq +void Emitter::EmitBeginSeq() { + if (!good()) + return; + + PrepareNode(m_pState->NextGroupType(GroupType::Seq)); + + m_pState->StartedGroup(GroupType::Seq); +} + +// EmitEndSeq +void Emitter::EmitEndSeq() { + if (!good()) + return; + FlowType originalType = m_pState->CurGroupFlowType(); + + if (m_pState->CurGroupChildCount() == 0) + m_pState->ForceFlow(); + + if (m_pState->CurGroupFlowType() == FlowType::Flow) { + if (m_stream.comment()) + m_stream << "\n"; + m_stream << IndentTo(m_pState->CurIndent()); + if (originalType == FlowType::Block) { + m_stream << "["; + } else { + if (m_pState->CurGroupChildCount() == 0 && !m_pState->HasBegunNode()) + m_stream << "["; + } + m_stream << "]"; + } + + m_pState->EndedGroup(GroupType::Seq); +} + +// EmitBeginMap +void Emitter::EmitBeginMap() { + if (!good()) + return; + + PrepareNode(m_pState->NextGroupType(GroupType::Map)); + + m_pState->StartedGroup(GroupType::Map); +} + +// EmitEndMap +void Emitter::EmitEndMap() { + if (!good()) + return; + FlowType originalType = m_pState->CurGroupFlowType(); + + if (m_pState->CurGroupChildCount() == 0) + m_pState->ForceFlow(); + + if (m_pState->CurGroupFlowType() == FlowType::Flow) { + if (m_stream.comment()) + m_stream << "\n"; + m_stream << IndentTo(m_pState->CurIndent()); + if (originalType == FlowType::Block) { + m_stream << "{"; + } else { + if (m_pState->CurGroupChildCount() == 0 && !m_pState->HasBegunNode()) + m_stream << "{"; + } + m_stream << "}"; + } + + m_pState->EndedGroup(GroupType::Map); +} + +// EmitNewline +void Emitter::EmitNewline() { + if (!good()) + return; + + PrepareNode(EmitterNodeType::NoType); + m_stream << "\n"; + m_pState->SetNonContent(); +} + +bool Emitter::CanEmitNewline() const { return true; } + +// Put the stream in a state so we can simply write the next node +// E.g., if we're in a sequence, write the "- " +void Emitter::PrepareNode(EmitterNodeType::value child) { + switch (m_pState->CurGroupNodeType()) { + case EmitterNodeType::NoType: + PrepareTopNode(child); + break; + case EmitterNodeType::FlowSeq: + FlowSeqPrepareNode(child); + break; + case EmitterNodeType::BlockSeq: + BlockSeqPrepareNode(child); + break; + case EmitterNodeType::FlowMap: + FlowMapPrepareNode(child); + break; + case EmitterNodeType::BlockMap: + BlockMapPrepareNode(child); + break; + case EmitterNodeType::Property: + case EmitterNodeType::Scalar: + assert(false); + break; + } +} + +void Emitter::PrepareTopNode(EmitterNodeType::value child) { + if (child == EmitterNodeType::NoType) + return; + + if (m_pState->CurGroupChildCount() > 0 && m_stream.col() > 0) + EmitBeginDoc(); + + switch (child) { + case EmitterNodeType::NoType: + break; + case EmitterNodeType::Property: + case EmitterNodeType::Scalar: + case EmitterNodeType::FlowSeq: + case EmitterNodeType::FlowMap: + // TODO: if we were writing null, and + // we wanted it blank, we wouldn't want a space + SpaceOrIndentTo(m_pState->HasBegunContent(), 0); + break; + case EmitterNodeType::BlockSeq: + case EmitterNodeType::BlockMap: + if (m_pState->HasBegunNode()) + m_stream << "\n"; + break; + } +} + +void Emitter::FlowSeqPrepareNode(EmitterNodeType::value child) { + const std::size_t lastIndent = m_pState->LastIndent(); + + if (!m_pState->HasBegunNode()) { + if (m_stream.comment()) + m_stream << "\n"; + m_stream << IndentTo(lastIndent); + if (m_pState->CurGroupChildCount() == 0) + m_stream << "["; + else + m_stream << ","; + } + + switch (child) { + case EmitterNodeType::NoType: + break; + case EmitterNodeType::Property: + case EmitterNodeType::Scalar: + case EmitterNodeType::FlowSeq: + case EmitterNodeType::FlowMap: + SpaceOrIndentTo( + m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0, + lastIndent); + break; + case EmitterNodeType::BlockSeq: + case EmitterNodeType::BlockMap: + assert(false); + break; + } +} + +void Emitter::BlockSeqPrepareNode(EmitterNodeType::value child) { + const std::size_t curIndent = m_pState->CurIndent(); + const std::size_t nextIndent = curIndent + m_pState->CurGroupIndent(); + + if (child == EmitterNodeType::NoType) + return; + + if (!m_pState->HasBegunContent()) { + if (m_pState->CurGroupChildCount() > 0 || m_stream.comment()) { + m_stream << "\n"; + } + m_stream << IndentTo(curIndent); + m_stream << "-"; + } + + switch (child) { + case EmitterNodeType::NoType: + break; + case EmitterNodeType::Property: + case EmitterNodeType::Scalar: + case EmitterNodeType::FlowSeq: + case EmitterNodeType::FlowMap: + SpaceOrIndentTo(m_pState->HasBegunContent(), nextIndent); + break; + case EmitterNodeType::BlockSeq: + m_stream << "\n"; + break; + case EmitterNodeType::BlockMap: + if (m_pState->HasBegunContent() || m_stream.comment()) + m_stream << "\n"; + break; + } +} + +void Emitter::FlowMapPrepareNode(EmitterNodeType::value child) { + if (m_pState->CurGroupChildCount() % 2 == 0) { + if (m_pState->GetMapKeyFormat() == LongKey) + m_pState->SetLongKey(); + + if (m_pState->CurGroupLongKey()) + FlowMapPrepareLongKey(child); + else + FlowMapPrepareSimpleKey(child); + } else { + if (m_pState->CurGroupLongKey()) + FlowMapPrepareLongKeyValue(child); + else + FlowMapPrepareSimpleKeyValue(child); + } +} + +void Emitter::FlowMapPrepareLongKey(EmitterNodeType::value child) { + const std::size_t lastIndent = m_pState->LastIndent(); + + if (!m_pState->HasBegunNode()) { + if (m_stream.comment()) + m_stream << "\n"; + m_stream << IndentTo(lastIndent); + if (m_pState->CurGroupChildCount() == 0) + m_stream << "{ ?"; + else + m_stream << ", ?"; + } + + switch (child) { + case EmitterNodeType::NoType: + break; + case EmitterNodeType::Property: + case EmitterNodeType::Scalar: + case EmitterNodeType::FlowSeq: + case EmitterNodeType::FlowMap: + SpaceOrIndentTo( + m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0, + lastIndent); + break; + case EmitterNodeType::BlockSeq: + case EmitterNodeType::BlockMap: + assert(false); + break; + } +} + +void Emitter::FlowMapPrepareLongKeyValue(EmitterNodeType::value child) { + const std::size_t lastIndent = m_pState->LastIndent(); + + if (!m_pState->HasBegunNode()) { + if (m_stream.comment()) + m_stream << "\n"; + m_stream << IndentTo(lastIndent); + m_stream << ":"; + } + + switch (child) { + case EmitterNodeType::NoType: + break; + case EmitterNodeType::Property: + case EmitterNodeType::Scalar: + case EmitterNodeType::FlowSeq: + case EmitterNodeType::FlowMap: + SpaceOrIndentTo( + m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0, + lastIndent); + break; + case EmitterNodeType::BlockSeq: + case EmitterNodeType::BlockMap: + assert(false); + break; + } +} + +void Emitter::FlowMapPrepareSimpleKey(EmitterNodeType::value child) { + const std::size_t lastIndent = m_pState->LastIndent(); + + if (!m_pState->HasBegunNode()) { + if (m_stream.comment()) + m_stream << "\n"; + m_stream << IndentTo(lastIndent); + if (m_pState->CurGroupChildCount() == 0) + m_stream << "{"; + else + m_stream << ","; + } + + switch (child) { + case EmitterNodeType::NoType: + break; + case EmitterNodeType::Property: + case EmitterNodeType::Scalar: + case EmitterNodeType::FlowSeq: + case EmitterNodeType::FlowMap: + SpaceOrIndentTo( + m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0, + lastIndent); + break; + case EmitterNodeType::BlockSeq: + case EmitterNodeType::BlockMap: + assert(false); + break; + } +} + +void Emitter::FlowMapPrepareSimpleKeyValue(EmitterNodeType::value child) { + const std::size_t lastIndent = m_pState->LastIndent(); + + if (!m_pState->HasBegunNode()) { + if (m_stream.comment()) + m_stream << "\n"; + m_stream << IndentTo(lastIndent); + if (m_pState->HasAlias()) { + m_stream << " "; + } + m_stream << ":"; + } + + switch (child) { + case EmitterNodeType::NoType: + break; + case EmitterNodeType::Property: + case EmitterNodeType::Scalar: + case EmitterNodeType::FlowSeq: + case EmitterNodeType::FlowMap: + SpaceOrIndentTo( + m_pState->HasBegunContent() || m_pState->CurGroupChildCount() > 0, + lastIndent); + break; + case EmitterNodeType::BlockSeq: + case EmitterNodeType::BlockMap: + assert(false); + break; + } +} + +void Emitter::BlockMapPrepareNode(EmitterNodeType::value child) { + if (m_pState->CurGroupChildCount() % 2 == 0) { + if (m_pState->GetMapKeyFormat() == LongKey) + m_pState->SetLongKey(); + if (child == EmitterNodeType::BlockSeq || + child == EmitterNodeType::BlockMap) + m_pState->SetLongKey(); + + if (m_pState->CurGroupLongKey()) + BlockMapPrepareLongKey(child); + else + BlockMapPrepareSimpleKey(child); + } else { + if (m_pState->CurGroupLongKey()) + BlockMapPrepareLongKeyValue(child); + else + BlockMapPrepareSimpleKeyValue(child); + } +} + +void Emitter::BlockMapPrepareLongKey(EmitterNodeType::value child) { + const std::size_t curIndent = m_pState->CurIndent(); + const std::size_t childCount = m_pState->CurGroupChildCount(); + + if (child == EmitterNodeType::NoType) + return; + + if (!m_pState->HasBegunContent()) { + if (childCount > 0) { + m_stream << "\n"; + } + if (m_stream.comment()) { + m_stream << "\n"; + } + m_stream << IndentTo(curIndent); + m_stream << "?"; + } + + switch (child) { + case EmitterNodeType::NoType: + break; + case EmitterNodeType::Property: + case EmitterNodeType::Scalar: + case EmitterNodeType::FlowSeq: + case EmitterNodeType::FlowMap: + SpaceOrIndentTo(true, curIndent + 1); + break; + case EmitterNodeType::BlockSeq: + case EmitterNodeType::BlockMap: + if (m_pState->HasBegunContent()) + m_stream << "\n"; + break; + } +} + +void Emitter::BlockMapPrepareLongKeyValue(EmitterNodeType::value child) { + const std::size_t curIndent = m_pState->CurIndent(); + + if (child == EmitterNodeType::NoType) + return; + + if (!m_pState->HasBegunContent()) { + m_stream << "\n"; + m_stream << IndentTo(curIndent); + m_stream << ":"; + } + + switch (child) { + case EmitterNodeType::NoType: + break; + case EmitterNodeType::Property: + case EmitterNodeType::Scalar: + case EmitterNodeType::FlowSeq: + case EmitterNodeType::FlowMap: + SpaceOrIndentTo(true, curIndent + 1); + break; + case EmitterNodeType::BlockSeq: + case EmitterNodeType::BlockMap: + if (m_pState->HasBegunContent()) + m_stream << "\n"; + SpaceOrIndentTo(true, curIndent + 1); + break; + } +} + +void Emitter::BlockMapPrepareSimpleKey(EmitterNodeType::value child) { + const std::size_t curIndent = m_pState->CurIndent(); + const std::size_t childCount = m_pState->CurGroupChildCount(); + + if (child == EmitterNodeType::NoType) + return; + + if (!m_pState->HasBegunNode()) { + if (childCount > 0) { + m_stream << "\n"; + } + } + + switch (child) { + case EmitterNodeType::NoType: + break; + case EmitterNodeType::Property: + case EmitterNodeType::Scalar: + case EmitterNodeType::FlowSeq: + case EmitterNodeType::FlowMap: + SpaceOrIndentTo(m_pState->HasBegunContent(), curIndent); + break; + case EmitterNodeType::BlockSeq: + case EmitterNodeType::BlockMap: + break; + } +} + +void Emitter::BlockMapPrepareSimpleKeyValue(EmitterNodeType::value child) { + const std::size_t curIndent = m_pState->CurIndent(); + const std::size_t nextIndent = curIndent + m_pState->CurGroupIndent(); + + if (!m_pState->HasBegunNode()) { + if (m_pState->HasAlias()) { + m_stream << " "; + } + m_stream << ":"; + } + + switch (child) { + case EmitterNodeType::NoType: + break; + case EmitterNodeType::Property: + case EmitterNodeType::Scalar: + case EmitterNodeType::FlowSeq: + case EmitterNodeType::FlowMap: + SpaceOrIndentTo(true, nextIndent); + break; + case EmitterNodeType::BlockSeq: + case EmitterNodeType::BlockMap: + m_stream << "\n"; + break; + } +} + +// SpaceOrIndentTo +// . Prepares for some more content by proper spacing +void Emitter::SpaceOrIndentTo(bool requireSpace, std::size_t indent) { + if (m_stream.comment()) + m_stream << "\n"; + if (m_stream.col() > 0 && requireSpace) + m_stream << " "; + m_stream << IndentTo(indent); +} + +void Emitter::PrepareIntegralStream(std::stringstream& stream) const { + + switch (m_pState->GetIntFormat()) { + case Dec: + stream << std::dec; + break; + case Hex: + stream << "0x"; + stream << std::hex; + break; + case Oct: + stream << "0"; + stream << std::oct; + break; + default: + assert(false); + } +} + +void Emitter::StartedScalar() { m_pState->StartedScalar(); } + +// ******************************************************************************************* +// overloads of Write + +StringEscaping GetStringEscapingStyle(const EMITTER_MANIP emitterManip) { + switch (emitterManip) { + case EscapeNonAscii: + return StringEscaping::NonAscii; + case EscapeAsJson: + return StringEscaping::JSON; + default: + return StringEscaping::None; + break; + } +} + +Emitter& Emitter::Write(const std::string& str) { + if (!good()) + return *this; + + StringEscaping stringEscaping = GetStringEscapingStyle(m_pState->GetOutputCharset()); + + const StringFormat strFormat = + Utils::ComputeStringFormat(str, m_pState->GetStringFormat(), + m_pState->CurGroupFlowType(), stringEscaping == StringEscaping::NonAscii); + + if (strFormat == StringFormat::Literal || str.size() > 1024) + m_pState->SetMapKeyFormat(YAML::LongKey, FmtScope::Local); + + PrepareNode(EmitterNodeType::Scalar); + + switch (strFormat) { + case StringFormat::Plain: + m_stream << str; + break; + case StringFormat::SingleQuoted: + Utils::WriteSingleQuotedString(m_stream, str); + break; + case StringFormat::DoubleQuoted: + Utils::WriteDoubleQuotedString(m_stream, str, stringEscaping); + break; + case StringFormat::Literal: + Utils::WriteLiteralString(m_stream, str, + m_pState->CurIndent() + m_pState->GetIndent()); + break; + } + + StartedScalar(); + + return *this; +} + +std::size_t Emitter::GetFloatPrecision() const { + return m_pState->GetFloatPrecision(); +} + +std::size_t Emitter::GetDoublePrecision() const { + return m_pState->GetDoublePrecision(); +} + +const char* Emitter::ComputeFullBoolName(bool b) const { + const EMITTER_MANIP mainFmt = (m_pState->GetBoolLengthFormat() == ShortBool + ? YesNoBool + : m_pState->GetBoolFormat()); + const EMITTER_MANIP caseFmt = m_pState->GetBoolCaseFormat(); + switch (mainFmt) { + case YesNoBool: + switch (caseFmt) { + case UpperCase: + return b ? "YES" : "NO"; + case CamelCase: + return b ? "Yes" : "No"; + case LowerCase: + return b ? "yes" : "no"; + default: + break; + } + break; + case OnOffBool: + switch (caseFmt) { + case UpperCase: + return b ? "ON" : "OFF"; + case CamelCase: + return b ? "On" : "Off"; + case LowerCase: + return b ? "on" : "off"; + default: + break; + } + break; + case TrueFalseBool: + switch (caseFmt) { + case UpperCase: + return b ? "TRUE" : "FALSE"; + case CamelCase: + return b ? "True" : "False"; + case LowerCase: + return b ? "true" : "false"; + default: + break; + } + break; + default: + break; + } + return b ? "y" : "n"; // should never get here, but it can't hurt to give + // these answers +} + +const char* Emitter::ComputeNullName() const { + switch (m_pState->GetNullFormat()) { + case LowerNull: + return "null"; + case UpperNull: + return "NULL"; + case CamelNull: + return "Null"; + case TildeNull: + // fallthrough + default: + return "~"; + } +} + +Emitter& Emitter::Write(bool b) { + if (!good()) + return *this; + + PrepareNode(EmitterNodeType::Scalar); + + const char* name = ComputeFullBoolName(b); + if (m_pState->GetBoolLengthFormat() == ShortBool) + m_stream << name[0]; + else + m_stream << name; + + StartedScalar(); + + return *this; +} + +Emitter& Emitter::Write(char ch) { + if (!good()) + return *this; + + + + PrepareNode(EmitterNodeType::Scalar); + Utils::WriteChar(m_stream, ch, GetStringEscapingStyle(m_pState->GetOutputCharset())); + StartedScalar(); + + return *this; +} + +Emitter& Emitter::Write(const _Alias& alias) { + if (!good()) + return *this; + + if (m_pState->HasAnchor() || m_pState->HasTag()) { + m_pState->SetError(ErrorMsg::INVALID_ALIAS); + return *this; + } + + PrepareNode(EmitterNodeType::Scalar); + + if (!Utils::WriteAlias(m_stream, alias.content)) { + m_pState->SetError(ErrorMsg::INVALID_ALIAS); + return *this; + } + + StartedScalar(); + + m_pState->SetAlias(); + + return *this; +} + +Emitter& Emitter::Write(const _Anchor& anchor) { + if (!good()) + return *this; + + if (m_pState->HasAnchor()) { + m_pState->SetError(ErrorMsg::INVALID_ANCHOR); + return *this; + } + + PrepareNode(EmitterNodeType::Property); + + if (!Utils::WriteAnchor(m_stream, anchor.content)) { + m_pState->SetError(ErrorMsg::INVALID_ANCHOR); + return *this; + } + + m_pState->SetAnchor(); + + return *this; +} + +Emitter& Emitter::Write(const _Tag& tag) { + if (!good()) + return *this; + + if (m_pState->HasTag()) { + m_pState->SetError(ErrorMsg::INVALID_TAG); + return *this; + } + + PrepareNode(EmitterNodeType::Property); + + bool success = false; + if (tag.type == _Tag::Type::Verbatim) + success = Utils::WriteTag(m_stream, tag.content, true); + else if (tag.type == _Tag::Type::PrimaryHandle) + success = Utils::WriteTag(m_stream, tag.content, false); + else + success = Utils::WriteTagWithPrefix(m_stream, tag.prefix, tag.content); + + if (!success) { + m_pState->SetError(ErrorMsg::INVALID_TAG); + return *this; + } + + m_pState->SetTag(); + + return *this; +} + +void Emitter::EmitKindTag() { Write(LocalTag("")); } + +Emitter& Emitter::Write(const _Comment& comment) { + if (!good()) + return *this; + + PrepareNode(EmitterNodeType::NoType); + + if (m_stream.col() > 0) + m_stream << Indentation(m_pState->GetPreCommentIndent()); + Utils::WriteComment(m_stream, comment.content, + m_pState->GetPostCommentIndent()); + + m_pState->SetNonContent(); + + return *this; +} + +Emitter& Emitter::Write(const _Null& /*null*/) { + if (!good()) + return *this; + + PrepareNode(EmitterNodeType::Scalar); + + m_stream << ComputeNullName(); + + StartedScalar(); + + return *this; +} + +Emitter& Emitter::Write(const Binary& binary) { + Write(SecondaryTag("binary")); + + if (!good()) + return *this; + + PrepareNode(EmitterNodeType::Scalar); + Utils::WriteBinary(m_stream, binary); + StartedScalar(); + + return *this; +} +} // namespace YAML diff --git a/lib/yaml-cpp/src/emitterstate.cpp b/lib/yaml-cpp/src/emitterstate.cpp new file mode 100644 index 0000000000..3b81d014b7 --- /dev/null +++ b/lib/yaml-cpp/src/emitterstate.cpp @@ -0,0 +1,392 @@ +#include + +#include "emitterstate.h" +#include "yaml-cpp/exceptions.h" // IWYU pragma: keep + +namespace YAML { +EmitterState::EmitterState() + : m_isGood(true), + m_lastError{}, + // default global manipulators + m_charset(EmitNonAscii), + m_strFmt(Auto), + m_boolFmt(TrueFalseBool), + m_boolLengthFmt(LongBool), + m_boolCaseFmt(LowerCase), + m_nullFmt(TildeNull), + m_intFmt(Dec), + m_indent(2), + m_preCommentIndent(2), + m_postCommentIndent(1), + m_seqFmt(Block), + m_mapFmt(Block), + m_mapKeyFmt(Auto), + m_floatPrecision(std::numeric_limits::max_digits10), + m_doublePrecision(std::numeric_limits::max_digits10), + // + m_modifiedSettings{}, + m_globalModifiedSettings{}, + m_groups{}, + m_curIndent(0), + m_hasAnchor(false), + m_hasAlias(false), + m_hasTag(false), + m_hasNonContent(false), + m_docCount(0) {} + +EmitterState::~EmitterState() = default; + +// SetLocalValue +// . We blindly tries to set all possible formatters to this value +// . Only the ones that make sense will be accepted +void EmitterState::SetLocalValue(EMITTER_MANIP value) { + SetOutputCharset(value, FmtScope::Local); + SetStringFormat(value, FmtScope::Local); + SetBoolFormat(value, FmtScope::Local); + SetBoolCaseFormat(value, FmtScope::Local); + SetBoolLengthFormat(value, FmtScope::Local); + SetNullFormat(value, FmtScope::Local); + SetIntFormat(value, FmtScope::Local); + SetFlowType(GroupType::Seq, value, FmtScope::Local); + SetFlowType(GroupType::Map, value, FmtScope::Local); + SetMapKeyFormat(value, FmtScope::Local); +} + +void EmitterState::SetAnchor() { m_hasAnchor = true; } + +void EmitterState::SetAlias() { m_hasAlias = true; } + +void EmitterState::SetTag() { m_hasTag = true; } + +void EmitterState::SetNonContent() { m_hasNonContent = true; } + +void EmitterState::SetLongKey() { + assert(!m_groups.empty()); + if (m_groups.empty()) { + return; + } + + assert(m_groups.back()->type == GroupType::Map); + m_groups.back()->longKey = true; +} + +void EmitterState::ForceFlow() { + assert(!m_groups.empty()); + if (m_groups.empty()) { + return; + } + + m_groups.back()->flowType = FlowType::Flow; +} + +void EmitterState::StartedNode() { + if (m_groups.empty()) { + m_docCount++; + } else { + m_groups.back()->childCount++; + if (m_groups.back()->childCount % 2 == 0) { + m_groups.back()->longKey = false; + } + } + + m_hasAnchor = false; + m_hasAlias = false; + m_hasTag = false; + m_hasNonContent = false; +} + +EmitterNodeType::value EmitterState::NextGroupType(GroupType type) const { + if (type == GroupType::Seq) { + if (GetFlowType(type) == Block) + return EmitterNodeType::BlockSeq; + return EmitterNodeType::FlowSeq; + } + + if (GetFlowType(type) == Block) + return EmitterNodeType::BlockMap; + return EmitterNodeType::FlowMap; + + // can't happen + assert(false); + return EmitterNodeType::NoType; +} + +void EmitterState::StartedDoc() { + m_hasAnchor = false; + m_hasTag = false; + m_hasNonContent = false; +} + +void EmitterState::EndedDoc() { + m_hasAnchor = false; + m_hasTag = false; + m_hasNonContent = false; +} + +void EmitterState::StartedScalar() { + StartedNode(); + ClearModifiedSettings(); +} + +void EmitterState::StartedGroup(GroupType type) { + StartedNode(); + + const std::size_t lastGroupIndent = + (m_groups.empty() ? 0 : m_groups.back()->indent); + m_curIndent += lastGroupIndent; + + // TODO: Create move constructors for settings types to simplify transfer + std::unique_ptr pGroup(new Group(type)); + + // transfer settings (which last until this group is done) + // + // NB: if pGroup->modifiedSettings == m_modifiedSettings, + // m_modifiedSettings is not changed! + pGroup->modifiedSettings = std::move(m_modifiedSettings); + + // set up group + if (GetFlowType(type) == Block) { + pGroup->flowType = FlowType::Block; + } else { + pGroup->flowType = FlowType::Flow; + } + pGroup->indent = GetIndent(); + + m_groups.push_back(std::move(pGroup)); +} + +void EmitterState::EndedGroup(GroupType type) { + if (m_groups.empty()) { + if (type == GroupType::Seq) { + return SetError(ErrorMsg::UNEXPECTED_END_SEQ); + } + return SetError(ErrorMsg::UNEXPECTED_END_MAP); + } + + if (m_hasTag) { + SetError(ErrorMsg::INVALID_TAG); + } + if (m_hasAnchor) { + SetError(ErrorMsg::INVALID_ANCHOR); + } + + // get rid of the current group + { + std::unique_ptr pFinishedGroup = std::move(m_groups.back()); + m_groups.pop_back(); + if (pFinishedGroup->type != type) { + return SetError(ErrorMsg::UNMATCHED_GROUP_TAG); + } + } + + // reset old settings + std::size_t lastIndent = (m_groups.empty() ? 0 : m_groups.back()->indent); + assert(m_curIndent >= lastIndent); + m_curIndent -= lastIndent; + + // some global settings that we changed may have been overridden + // by a local setting we just popped, so we need to restore them + m_globalModifiedSettings.restore(); + + ClearModifiedSettings(); + m_hasAnchor = false; + m_hasTag = false; + m_hasNonContent = false; +} + +EmitterNodeType::value EmitterState::CurGroupNodeType() const { + if (m_groups.empty()) { + return EmitterNodeType::NoType; + } + + return m_groups.back()->NodeType(); +} + +GroupType EmitterState::CurGroupType() const { + return m_groups.empty() ? GroupType::NoType : m_groups.back()->type; +} + +FlowType EmitterState::CurGroupFlowType() const { + return m_groups.empty() ? FlowType::NoType : m_groups.back()->flowType; +} + +std::size_t EmitterState::CurGroupIndent() const { + return m_groups.empty() ? 0 : m_groups.back()->indent; +} + +std::size_t EmitterState::CurGroupChildCount() const { + return m_groups.empty() ? m_docCount : m_groups.back()->childCount; +} + +bool EmitterState::CurGroupLongKey() const { + return m_groups.empty() ? false : m_groups.back()->longKey; +} + +std::size_t EmitterState::LastIndent() const { + if (m_groups.size() <= 1) { + return 0; + } + + return m_curIndent - m_groups[m_groups.size() - 2]->indent; +} + +void EmitterState::ClearModifiedSettings() { m_modifiedSettings.clear(); } + +void EmitterState::RestoreGlobalModifiedSettings() { + m_globalModifiedSettings.restore(); +} + +bool EmitterState::SetOutputCharset(EMITTER_MANIP value, FmtScope scope) { + switch (value) { + case EmitNonAscii: + case EscapeNonAscii: + case EscapeAsJson: + _Set(m_charset, value, scope); + return true; + default: + return false; + } +} + +bool EmitterState::SetStringFormat(EMITTER_MANIP value, FmtScope scope) { + switch (value) { + case Auto: + case SingleQuoted: + case DoubleQuoted: + case Literal: + _Set(m_strFmt, value, scope); + return true; + default: + return false; + } +} + +bool EmitterState::SetBoolFormat(EMITTER_MANIP value, FmtScope scope) { + switch (value) { + case OnOffBool: + case TrueFalseBool: + case YesNoBool: + _Set(m_boolFmt, value, scope); + return true; + default: + return false; + } +} + +bool EmitterState::SetBoolLengthFormat(EMITTER_MANIP value, FmtScope scope) { + switch (value) { + case LongBool: + case ShortBool: + _Set(m_boolLengthFmt, value, scope); + return true; + default: + return false; + } +} + +bool EmitterState::SetBoolCaseFormat(EMITTER_MANIP value, FmtScope scope) { + switch (value) { + case UpperCase: + case LowerCase: + case CamelCase: + _Set(m_boolCaseFmt, value, scope); + return true; + default: + return false; + } +} + +bool EmitterState::SetNullFormat(EMITTER_MANIP value, FmtScope scope) { + switch (value) { + case LowerNull: + case UpperNull: + case CamelNull: + case TildeNull: + _Set(m_nullFmt, value, scope); + return true; + default: + return false; + } +} + +bool EmitterState::SetIntFormat(EMITTER_MANIP value, FmtScope scope) { + switch (value) { + case Dec: + case Hex: + case Oct: + _Set(m_intFmt, value, scope); + return true; + default: + return false; + } +} + +bool EmitterState::SetIndent(std::size_t value, FmtScope scope) { + if (value <= 1) + return false; + + _Set(m_indent, value, scope); + return true; +} + +bool EmitterState::SetPreCommentIndent(std::size_t value, FmtScope scope) { + if (value == 0) + return false; + + _Set(m_preCommentIndent, value, scope); + return true; +} + +bool EmitterState::SetPostCommentIndent(std::size_t value, FmtScope scope) { + if (value == 0) + return false; + + _Set(m_postCommentIndent, value, scope); + return true; +} + +bool EmitterState::SetFlowType(GroupType groupType, EMITTER_MANIP value, FmtScope scope) { + switch (value) { + case Block: + case Flow: + _Set(groupType == GroupType::Seq ? m_seqFmt : m_mapFmt, value, scope); + return true; + default: + return false; + } +} + +EMITTER_MANIP EmitterState::GetFlowType(GroupType groupType) const { + // force flow style if we're currently in a flow + if (CurGroupFlowType() == FlowType::Flow) + return Flow; + + // otherwise, go with what's asked of us + return (groupType == GroupType::Seq ? m_seqFmt.get() : m_mapFmt.get()); +} + +bool EmitterState::SetMapKeyFormat(EMITTER_MANIP value, FmtScope scope) { + switch (value) { + case Auto: + case LongKey: + _Set(m_mapKeyFmt, value, scope); + return true; + default: + return false; + } +} + +bool EmitterState::SetFloatPrecision(std::size_t value, FmtScope scope) { + if (value > std::numeric_limits::max_digits10) + return false; + _Set(m_floatPrecision, value, scope); + return true; +} + +bool EmitterState::SetDoublePrecision(std::size_t value, FmtScope scope) { + if (value > std::numeric_limits::max_digits10) + return false; + _Set(m_doublePrecision, value, scope); + return true; +} +} // namespace YAML diff --git a/lib/yaml-cpp/src/emitterstate.h b/lib/yaml-cpp/src/emitterstate.h new file mode 100644 index 0000000000..bac0479ea1 --- /dev/null +++ b/lib/yaml-cpp/src/emitterstate.h @@ -0,0 +1,211 @@ +#ifndef EMITTERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define EMITTERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "setting.h" +#include "yaml-cpp/emitterdef.h" +#include "yaml-cpp/emittermanip.h" + +#include +#include +#include +#include +#include + +namespace YAML { + +enum class FmtScope { Local, Global }; +enum class GroupType { NoType, Seq, Map }; +enum class FlowType { NoType, Flow, Block }; + +class EmitterState { + public: + EmitterState(); + ~EmitterState(); + + // basic state checking + bool good() const { return m_isGood; } + const std::string GetLastError() const { return m_lastError; } + void SetError(const std::string& error) { + m_isGood = false; + m_lastError = error; + } + + // node handling + void SetAnchor(); + void SetAlias(); + void SetTag(); + void SetNonContent(); + void SetLongKey(); + void ForceFlow(); + void StartedDoc(); + void EndedDoc(); + void StartedScalar(); + void StartedGroup(GroupType type); + void EndedGroup(GroupType type); + + EmitterNodeType::value NextGroupType(GroupType type) const; + EmitterNodeType::value CurGroupNodeType() const; + + GroupType CurGroupType() const; + FlowType CurGroupFlowType() const; + std::size_t CurGroupIndent() const; + std::size_t CurGroupChildCount() const; + bool CurGroupLongKey() const; + + std::size_t LastIndent() const; + std::size_t CurIndent() const { return m_curIndent; } + bool HasAnchor() const { return m_hasAnchor; } + bool HasAlias() const { return m_hasAlias; } + bool HasTag() const { return m_hasTag; } + bool HasBegunNode() const { + return m_hasAnchor || m_hasTag || m_hasNonContent; + } + bool HasBegunContent() const { return m_hasAnchor || m_hasTag; } + + void ClearModifiedSettings(); + void RestoreGlobalModifiedSettings(); + + // formatters + void SetLocalValue(EMITTER_MANIP value); + + bool SetOutputCharset(EMITTER_MANIP value, FmtScope scope); + EMITTER_MANIP GetOutputCharset() const { return m_charset.get(); } + + bool SetStringFormat(EMITTER_MANIP value, FmtScope scope); + EMITTER_MANIP GetStringFormat() const { return m_strFmt.get(); } + + bool SetBoolFormat(EMITTER_MANIP value, FmtScope scope); + EMITTER_MANIP GetBoolFormat() const { return m_boolFmt.get(); } + + bool SetBoolLengthFormat(EMITTER_MANIP value, FmtScope scope); + EMITTER_MANIP GetBoolLengthFormat() const { return m_boolLengthFmt.get(); } + + bool SetBoolCaseFormat(EMITTER_MANIP value, FmtScope scope); + EMITTER_MANIP GetBoolCaseFormat() const { return m_boolCaseFmt.get(); } + + bool SetNullFormat(EMITTER_MANIP value, FmtScope scope); + EMITTER_MANIP GetNullFormat() const { return m_nullFmt.get(); } + + bool SetIntFormat(EMITTER_MANIP value, FmtScope scope); + EMITTER_MANIP GetIntFormat() const { return m_intFmt.get(); } + + bool SetIndent(std::size_t value, FmtScope scope); + std::size_t GetIndent() const { return m_indent.get(); } + + bool SetPreCommentIndent(std::size_t value, FmtScope scope); + std::size_t GetPreCommentIndent() const { return m_preCommentIndent.get(); } + bool SetPostCommentIndent(std::size_t value, FmtScope scope); + std::size_t GetPostCommentIndent() const { return m_postCommentIndent.get(); } + + bool SetFlowType(GroupType groupType, EMITTER_MANIP value, + FmtScope scope); + EMITTER_MANIP GetFlowType(GroupType groupType) const; + + bool SetMapKeyFormat(EMITTER_MANIP value, FmtScope scope); + EMITTER_MANIP GetMapKeyFormat() const { return m_mapKeyFmt.get(); } + + bool SetFloatPrecision(std::size_t value, FmtScope scope); + std::size_t GetFloatPrecision() const { return m_floatPrecision.get(); } + bool SetDoublePrecision(std::size_t value, FmtScope scope); + std::size_t GetDoublePrecision() const { return m_doublePrecision.get(); } + + private: + template + void _Set(Setting& fmt, T value, FmtScope scope); + + void StartedNode(); + + private: + // basic state ok? + bool m_isGood; + std::string m_lastError; + + // other state + Setting m_charset; + Setting m_strFmt; + Setting m_boolFmt; + Setting m_boolLengthFmt; + Setting m_boolCaseFmt; + Setting m_nullFmt; + Setting m_intFmt; + Setting m_indent; + Setting m_preCommentIndent, m_postCommentIndent; + Setting m_seqFmt; + Setting m_mapFmt; + Setting m_mapKeyFmt; + Setting m_floatPrecision; + Setting m_doublePrecision; + + SettingChanges m_modifiedSettings; + SettingChanges m_globalModifiedSettings; + + struct Group { + explicit Group(GroupType type_) + : type(type_), + flowType{}, + indent(0), + childCount(0), + longKey(false), + modifiedSettings{} {} + + GroupType type; + FlowType flowType; + std::size_t indent; + std::size_t childCount; + bool longKey; + + SettingChanges modifiedSettings; + + EmitterNodeType::value NodeType() const { + if (type == GroupType::Seq) { + if (flowType == FlowType::Flow) + return EmitterNodeType::FlowSeq; + else + return EmitterNodeType::BlockSeq; + } else { + if (flowType == FlowType::Flow) + return EmitterNodeType::FlowMap; + else + return EmitterNodeType::BlockMap; + } + + // can't get here + assert(false); + return EmitterNodeType::NoType; + } + }; + + std::vector> m_groups; + std::size_t m_curIndent; + bool m_hasAnchor; + bool m_hasAlias; + bool m_hasTag; + bool m_hasNonContent; + std::size_t m_docCount; +}; + +template +void EmitterState::_Set(Setting& fmt, T value, FmtScope scope) { + switch (scope) { + case FmtScope::Local: + m_modifiedSettings.push(fmt.set(value)); + break; + case FmtScope::Global: + fmt.set(value); + m_globalModifiedSettings.push( + fmt.set(value)); // this pushes an identity set, so when we restore, + // it restores to the value here, and not the previous one + break; + default: + assert(false); + } +} +} // namespace YAML + +#endif // EMITTERSTATE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/src/emitterutils.cpp b/lib/yaml-cpp/src/emitterutils.cpp new file mode 100644 index 0000000000..1006a007dc --- /dev/null +++ b/lib/yaml-cpp/src/emitterutils.cpp @@ -0,0 +1,497 @@ +#include +#include +#include + +#include "emitterutils.h" +#include "exp.h" +#include "indentation.h" +#include "regex_yaml.h" +#include "regeximpl.h" +#include "stringsource.h" +#include "yaml-cpp/binary.h" // IWYU pragma: keep +#include "yaml-cpp/null.h" +#include "yaml-cpp/ostream_wrapper.h" + +namespace YAML { +namespace Utils { +namespace { +enum { REPLACEMENT_CHARACTER = 0xFFFD }; + +bool IsAnchorChar(int ch) { // test for ns-anchor-char + switch (ch) { + case ',': + case '[': + case ']': + case '{': + case '}': // c-flow-indicator + case ' ': + case '\t': // s-white + case 0xFEFF: // c-byte-order-mark + case 0xA: + case 0xD: // b-char + return false; + case 0x85: + return true; + } + + if (ch < 0x20) { + return false; + } + + if (ch < 0x7E) { + return true; + } + + if (ch < 0xA0) { + return false; + } + if (ch >= 0xD800 && ch <= 0xDFFF) { + return false; + } + if ((ch & 0xFFFE) == 0xFFFE) { + return false; + } + if ((ch >= 0xFDD0) && (ch <= 0xFDEF)) { + return false; + } + if (ch > 0x10FFFF) { + return false; + } + + return true; +} + +int Utf8BytesIndicated(char ch) { + int byteVal = static_cast(ch); + switch (byteVal >> 4) { + case 0: + case 1: + case 2: + case 3: + case 4: + case 5: + case 6: + case 7: + return 1; + case 12: + case 13: + return 2; + case 14: + return 3; + case 15: + return 4; + default: + return -1; + } +} + +bool IsTrailingByte(char ch) { return (ch & 0xC0) == 0x80; } + +bool GetNextCodePointAndAdvance(int& codePoint, + std::string::const_iterator& first, + std::string::const_iterator last) { + if (first == last) + return false; + + int nBytes = Utf8BytesIndicated(*first); + if (nBytes < 1) { + // Bad lead byte + ++first; + codePoint = REPLACEMENT_CHARACTER; + return true; + } + + if (nBytes == 1) { + codePoint = *first++; + return true; + } + + // Gather bits from trailing bytes + codePoint = static_cast(*first) & ~(0xFF << (7 - nBytes)); + ++first; + --nBytes; + for (; nBytes > 0; ++first, --nBytes) { + if ((first == last) || !IsTrailingByte(*first)) { + codePoint = REPLACEMENT_CHARACTER; + break; + } + codePoint <<= 6; + codePoint |= *first & 0x3F; + } + + // Check for illegal code points + if (codePoint > 0x10FFFF) + codePoint = REPLACEMENT_CHARACTER; + else if (codePoint >= 0xD800 && codePoint <= 0xDFFF) + codePoint = REPLACEMENT_CHARACTER; + else if ((codePoint & 0xFFFE) == 0xFFFE) + codePoint = REPLACEMENT_CHARACTER; + else if (codePoint >= 0xFDD0 && codePoint <= 0xFDEF) + codePoint = REPLACEMENT_CHARACTER; + return true; +} + +void WriteCodePoint(ostream_wrapper& out, int codePoint) { + if (codePoint < 0 || codePoint > 0x10FFFF) { + codePoint = REPLACEMENT_CHARACTER; + } + if (codePoint <= 0x7F) { + out << static_cast(codePoint); + } else if (codePoint <= 0x7FF) { + out << static_cast(0xC0 | (codePoint >> 6)) + << static_cast(0x80 | (codePoint & 0x3F)); + } else if (codePoint <= 0xFFFF) { + out << static_cast(0xE0 | (codePoint >> 12)) + << static_cast(0x80 | ((codePoint >> 6) & 0x3F)) + << static_cast(0x80 | (codePoint & 0x3F)); + } else { + out << static_cast(0xF0 | (codePoint >> 18)) + << static_cast(0x80 | ((codePoint >> 12) & 0x3F)) + << static_cast(0x80 | ((codePoint >> 6) & 0x3F)) + << static_cast(0x80 | (codePoint & 0x3F)); + } +} + +bool IsValidPlainScalar(const std::string& str, FlowType flowType, + bool allowOnlyAscii) { + // check against null + if (IsNullString(str)) { + return false; + } + + // check the start + const RegEx& start = (flowType == FlowType::Flow ? Exp::PlainScalarInFlow() + : Exp::PlainScalar()); + if (!start.Matches(str)) { + return false; + } + + // and check the end for plain whitespace (which can't be faithfully kept in a + // plain scalar) + if (!str.empty() && *str.rbegin() == ' ') { + return false; + } + + // then check until something is disallowed + static const RegEx& disallowed_flow = + Exp::EndScalarInFlow() | (Exp::BlankOrBreak() + Exp::Comment()) | + Exp::NotPrintable() | Exp::Utf8_ByteOrderMark() | Exp::Break() | + Exp::Tab(); + static const RegEx& disallowed_block = + Exp::EndScalar() | (Exp::BlankOrBreak() + Exp::Comment()) | + Exp::NotPrintable() | Exp::Utf8_ByteOrderMark() | Exp::Break() | + Exp::Tab(); + const RegEx& disallowed = + flowType == FlowType::Flow ? disallowed_flow : disallowed_block; + + StringCharSource buffer(str.c_str(), str.size()); + while (buffer) { + if (disallowed.Matches(buffer)) { + return false; + } + if (allowOnlyAscii && (0x80 <= static_cast(buffer[0]))) { + return false; + } + ++buffer; + } + + return true; +} + +bool IsValidSingleQuotedScalar(const std::string& str, bool escapeNonAscii) { + // TODO: check for non-printable characters? + return std::none_of(str.begin(), str.end(), [=](char ch) { + return (escapeNonAscii && (0x80 <= static_cast(ch))) || + (ch == '\n'); + }); +} + +bool IsValidLiteralScalar(const std::string& str, FlowType flowType, + bool escapeNonAscii) { + if (flowType == FlowType::Flow) { + return false; + } + + // TODO: check for non-printable characters? + return std::none_of(str.begin(), str.end(), [=](char ch) { + return (escapeNonAscii && (0x80 <= static_cast(ch))); + }); +} + +std::pair EncodeUTF16SurrogatePair(int codePoint) { + const uint32_t leadOffset = 0xD800 - (0x10000 >> 10); + + return { + leadOffset | (codePoint >> 10), + 0xDC00 | (codePoint & 0x3FF), + }; +} + +void WriteDoubleQuoteEscapeSequence(ostream_wrapper& out, int codePoint, StringEscaping stringEscapingStyle) { + static const char hexDigits[] = "0123456789abcdef"; + + out << "\\"; + int digits = 8; + if (codePoint < 0xFF && stringEscapingStyle != StringEscaping::JSON) { + out << "x"; + digits = 2; + } else if (codePoint < 0xFFFF) { + out << "u"; + digits = 4; + } else if (stringEscapingStyle != StringEscaping::JSON) { + out << "U"; + digits = 8; + } else { + auto surrogatePair = EncodeUTF16SurrogatePair(codePoint); + WriteDoubleQuoteEscapeSequence(out, surrogatePair.first, stringEscapingStyle); + WriteDoubleQuoteEscapeSequence(out, surrogatePair.second, stringEscapingStyle); + return; + } + + // Write digits into the escape sequence + for (; digits > 0; --digits) + out << hexDigits[(codePoint >> (4 * (digits - 1))) & 0xF]; +} + +bool WriteAliasName(ostream_wrapper& out, const std::string& str) { + int codePoint; + for (std::string::const_iterator i = str.begin(); + GetNextCodePointAndAdvance(codePoint, i, str.end());) { + if (!IsAnchorChar(codePoint)) { + return false; + } + + WriteCodePoint(out, codePoint); + } + return true; +} +} // namespace + +StringFormat ComputeStringFormat(const std::string& str, + EMITTER_MANIP strFormat, + FlowType flowType, + bool escapeNonAscii) { + switch (strFormat) { + case Auto: + if (IsValidPlainScalar(str, flowType, escapeNonAscii)) { + return StringFormat::Plain; + } + return StringFormat::DoubleQuoted; + case SingleQuoted: + if (IsValidSingleQuotedScalar(str, escapeNonAscii)) { + return StringFormat::SingleQuoted; + } + return StringFormat::DoubleQuoted; + case DoubleQuoted: + return StringFormat::DoubleQuoted; + case Literal: + if (IsValidLiteralScalar(str, flowType, escapeNonAscii)) { + return StringFormat::Literal; + } + return StringFormat::DoubleQuoted; + default: + break; + } + + return StringFormat::DoubleQuoted; +} + +bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str) { + out << "'"; + int codePoint; + for (std::string::const_iterator i = str.begin(); + GetNextCodePointAndAdvance(codePoint, i, str.end());) { + if (codePoint == '\n') { + return false; // We can't handle a new line and the attendant indentation + // yet + } + + if (codePoint == '\'') { + out << "''"; + } else { + WriteCodePoint(out, codePoint); + } + } + out << "'"; + return true; +} + +bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str, + StringEscaping stringEscaping) { + out << "\""; + int codePoint; + for (std::string::const_iterator i = str.begin(); + GetNextCodePointAndAdvance(codePoint, i, str.end());) { + switch (codePoint) { + case '\"': + out << "\\\""; + break; + case '\\': + out << "\\\\"; + break; + case '\n': + out << "\\n"; + break; + case '\t': + out << "\\t"; + break; + case '\r': + out << "\\r"; + break; + case '\b': + out << "\\b"; + break; + case '\f': + out << "\\f"; + break; + default: + if (codePoint < 0x20 || + (codePoint >= 0x80 && + codePoint <= 0xA0)) { // Control characters and non-breaking space + WriteDoubleQuoteEscapeSequence(out, codePoint, stringEscaping); + } else if (codePoint == 0xFEFF) { // Byte order marks (ZWNS) should be + // escaped (YAML 1.2, sec. 5.2) + WriteDoubleQuoteEscapeSequence(out, codePoint, stringEscaping); + } else if (stringEscaping == StringEscaping::NonAscii && codePoint > 0x7E) { + WriteDoubleQuoteEscapeSequence(out, codePoint, stringEscaping); + } else { + WriteCodePoint(out, codePoint); + } + } + } + out << "\""; + return true; +} + +bool WriteLiteralString(ostream_wrapper& out, const std::string& str, + std::size_t indent) { + out << "|\n"; + int codePoint; + for (std::string::const_iterator i = str.begin(); + GetNextCodePointAndAdvance(codePoint, i, str.end());) { + if (codePoint == '\n') { + out << "\n"; + } else { + out<< IndentTo(indent); + WriteCodePoint(out, codePoint); + } + } + return true; +} + +bool WriteChar(ostream_wrapper& out, char ch, StringEscaping stringEscapingStyle) { + if (('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z')) { + out << ch; + } else if (ch == '\"') { + out << R"("\"")"; + } else if (ch == '\t') { + out << R"("\t")"; + } else if (ch == '\n') { + out << R"("\n")"; + } else if (ch == '\b') { + out << R"("\b")"; + } else if (ch == '\r') { + out << R"("\r")"; + } else if (ch == '\f') { + out << R"("\f")"; + } else if (ch == '\\') { + out << R"("\\")"; + } else if (0x20 <= ch && ch <= 0x7e) { + out << "\"" << ch << "\""; + } else { + out << "\""; + WriteDoubleQuoteEscapeSequence(out, ch, stringEscapingStyle); + out << "\""; + } + return true; +} + +bool WriteComment(ostream_wrapper& out, const std::string& str, + std::size_t postCommentIndent) { + const std::size_t curIndent = out.col(); + out << "#" << Indentation(postCommentIndent); + out.set_comment(); + int codePoint; + for (std::string::const_iterator i = str.begin(); + GetNextCodePointAndAdvance(codePoint, i, str.end());) { + if (codePoint == '\n') { + out << "\n" + << IndentTo(curIndent) << "#" << Indentation(postCommentIndent); + out.set_comment(); + } else { + WriteCodePoint(out, codePoint); + } + } + return true; +} + +bool WriteAlias(ostream_wrapper& out, const std::string& str) { + out << "*"; + return WriteAliasName(out, str); +} + +bool WriteAnchor(ostream_wrapper& out, const std::string& str) { + out << "&"; + return WriteAliasName(out, str); +} + +bool WriteTag(ostream_wrapper& out, const std::string& str, bool verbatim) { + out << (verbatim ? "!<" : "!"); + StringCharSource buffer(str.c_str(), str.size()); + const RegEx& reValid = verbatim ? Exp::URI() : Exp::Tag(); + while (buffer) { + int n = reValid.Match(buffer); + if (n <= 0) { + return false; + } + + while (--n >= 0) { + out << buffer[0]; + ++buffer; + } + } + if (verbatim) { + out << ">"; + } + return true; +} + +bool WriteTagWithPrefix(ostream_wrapper& out, const std::string& prefix, + const std::string& tag) { + out << "!"; + StringCharSource prefixBuffer(prefix.c_str(), prefix.size()); + while (prefixBuffer) { + int n = Exp::URI().Match(prefixBuffer); + if (n <= 0) { + return false; + } + + while (--n >= 0) { + out << prefixBuffer[0]; + ++prefixBuffer; + } + } + + out << "!"; + StringCharSource tagBuffer(tag.c_str(), tag.size()); + while (tagBuffer) { + int n = Exp::Tag().Match(tagBuffer); + if (n <= 0) { + return false; + } + + while (--n >= 0) { + out << tagBuffer[0]; + ++tagBuffer; + } + } + return true; +} + +bool WriteBinary(ostream_wrapper& out, const Binary& binary) { + WriteDoubleQuotedString(out, EncodeBase64(binary.data(), binary.size()), + StringEscaping::None); + return true; +} +} // namespace Utils +} // namespace YAML diff --git a/lib/yaml-cpp/src/emitterutils.h b/lib/yaml-cpp/src/emitterutils.h new file mode 100644 index 0000000000..113ab46ff1 --- /dev/null +++ b/lib/yaml-cpp/src/emitterutils.h @@ -0,0 +1,50 @@ +#ifndef EMITTERUTILS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define EMITTERUTILS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include + +#include "emitterstate.h" +#include "yaml-cpp/emittermanip.h" +#include "yaml-cpp/ostream_wrapper.h" + +namespace YAML { +class ostream_wrapper; +} // namespace YAML + +namespace YAML { +class Binary; + +enum class StringFormat { Plain, SingleQuoted, DoubleQuoted, Literal }; +enum class StringEscaping { None, NonAscii, JSON }; + +namespace Utils { +StringFormat ComputeStringFormat(const std::string& str, + EMITTER_MANIP strFormat, + FlowType flowType, + bool escapeNonAscii); + +bool WriteSingleQuotedString(ostream_wrapper& out, const std::string& str); +bool WriteDoubleQuotedString(ostream_wrapper& out, const std::string& str, + StringEscaping stringEscaping); +bool WriteLiteralString(ostream_wrapper& out, const std::string& str, + std::size_t indent); +bool WriteChar(ostream_wrapper& out, char ch, + StringEscaping stringEscapingStyle); +bool WriteComment(ostream_wrapper& out, const std::string& str, + std::size_t postCommentIndent); +bool WriteAlias(ostream_wrapper& out, const std::string& str); +bool WriteAnchor(ostream_wrapper& out, const std::string& str); +bool WriteTag(ostream_wrapper& out, const std::string& str, bool verbatim); +bool WriteTagWithPrefix(ostream_wrapper& out, const std::string& prefix, + const std::string& tag); +bool WriteBinary(ostream_wrapper& out, const Binary& binary); +} +} + +#endif // EMITTERUTILS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/src/exceptions.cpp b/lib/yaml-cpp/src/exceptions.cpp new file mode 100644 index 0000000000..43a7976e90 --- /dev/null +++ b/lib/yaml-cpp/src/exceptions.cpp @@ -0,0 +1,20 @@ +#include "yaml-cpp/exceptions.h" +#include "yaml-cpp/noexcept.h" + +namespace YAML { + +// These destructors are defined out-of-line so the vtable is only emitted once. +Exception::~Exception() YAML_CPP_NOEXCEPT = default; +ParserException::~ParserException() YAML_CPP_NOEXCEPT = default; +RepresentationException::~RepresentationException() YAML_CPP_NOEXCEPT = default; +InvalidScalar::~InvalidScalar() YAML_CPP_NOEXCEPT = default; +KeyNotFound::~KeyNotFound() YAML_CPP_NOEXCEPT = default; +InvalidNode::~InvalidNode() YAML_CPP_NOEXCEPT = default; +BadConversion::~BadConversion() YAML_CPP_NOEXCEPT = default; +BadDereference::~BadDereference() YAML_CPP_NOEXCEPT = default; +BadSubscript::~BadSubscript() YAML_CPP_NOEXCEPT = default; +BadPushback::~BadPushback() YAML_CPP_NOEXCEPT = default; +BadInsert::~BadInsert() YAML_CPP_NOEXCEPT = default; +EmitterException::~EmitterException() YAML_CPP_NOEXCEPT = default; +BadFile::~BadFile() YAML_CPP_NOEXCEPT = default; +} // namespace YAML diff --git a/lib/yaml-cpp/src/exp.cpp b/lib/yaml-cpp/src/exp.cpp new file mode 100644 index 0000000000..992620ff94 --- /dev/null +++ b/lib/yaml-cpp/src/exp.cpp @@ -0,0 +1,137 @@ +#include + +#include "exp.h" +#include "stream.h" +#include "yaml-cpp/exceptions.h" // IWYU pragma: keep + +namespace YAML { +struct Mark; +} // namespace YAML + +namespace YAML { +namespace Exp { +unsigned ParseHex(const std::string& str, const Mark& mark) { + unsigned value = 0; + for (char ch : str) { + int digit = 0; + if ('a' <= ch && ch <= 'f') + digit = ch - 'a' + 10; + else if ('A' <= ch && ch <= 'F') + digit = ch - 'A' + 10; + else if ('0' <= ch && ch <= '9') + digit = ch - '0'; + else + throw ParserException(mark, ErrorMsg::INVALID_HEX); + + value = (value << 4) + digit; + } + + return value; +} + +std::string Str(unsigned ch) { return std::string(1, static_cast(ch)); } + +// Escape +// . Translates the next 'codeLength' characters into a hex number and returns +// the result. +// . Throws if it's not actually hex. +std::string Escape(Stream& in, int codeLength) { + // grab string + std::string str; + for (int i = 0; i < codeLength; i++) + str += in.get(); + + // get the value + unsigned value = ParseHex(str, in.mark()); + + // legal unicode? + if ((value >= 0xD800 && value <= 0xDFFF) || value > 0x10FFFF) { + std::stringstream msg; + msg << ErrorMsg::INVALID_UNICODE << value; + throw ParserException(in.mark(), msg.str()); + } + + // now break it up into chars + if (value <= 0x7F) + return Str(value); + + if (value <= 0x7FF) + return Str(0xC0 + (value >> 6)) + Str(0x80 + (value & 0x3F)); + + if (value <= 0xFFFF) + return Str(0xE0 + (value >> 12)) + Str(0x80 + ((value >> 6) & 0x3F)) + + Str(0x80 + (value & 0x3F)); + + return Str(0xF0 + (value >> 18)) + Str(0x80 + ((value >> 12) & 0x3F)) + + Str(0x80 + ((value >> 6) & 0x3F)) + Str(0x80 + (value & 0x3F)); +} + +// Escape +// . Escapes the sequence starting 'in' (it must begin with a '\' or single +// quote) +// and returns the result. +// . Throws if it's an unknown escape character. +std::string Escape(Stream& in) { + // eat slash + char escape = in.get(); + + // switch on escape character + char ch = in.get(); + + // first do single quote, since it's easier + if (escape == '\'' && ch == '\'') + return "\'"; + + // now do the slash (we're not gonna check if it's a slash - you better pass + // one!) + switch (ch) { + case '0': + return std::string(1, '\x00'); + case 'a': + return "\x07"; + case 'b': + return "\x08"; + case 't': + case '\t': + return "\x09"; + case 'n': + return "\x0A"; + case 'v': + return "\x0B"; + case 'f': + return "\x0C"; + case 'r': + return "\x0D"; + case 'e': + return "\x1B"; + case ' ': + return R"( )"; + case '\"': + return "\""; + case '\'': + return "\'"; + case '\\': + return "\\"; + case '/': + return "/"; + case 'N': + return "\x85"; + case '_': + return "\xA0"; + case 'L': + return "\xE2\x80\xA8"; // LS (#x2028) + case 'P': + return "\xE2\x80\xA9"; // PS (#x2029) + case 'x': + return Escape(in, 2); + case 'u': + return Escape(in, 4); + case 'U': + return Escape(in, 8); + } + + std::stringstream msg; + throw ParserException(in.mark(), std::string(ErrorMsg::INVALID_ESCAPE) + ch); +} +} // namespace Exp +} // namespace YAML diff --git a/lib/yaml-cpp/src/exp.h b/lib/yaml-cpp/src/exp.h new file mode 100644 index 0000000000..301449e8f8 --- /dev/null +++ b/lib/yaml-cpp/src/exp.h @@ -0,0 +1,222 @@ +#ifndef EXP_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define EXP_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include +#include + +#include "regex_yaml.h" +#include "stream.h" + +namespace YAML { +//////////////////////////////////////////////////////////////////////////////// +// Here we store a bunch of expressions for matching different parts of the +// file. + +namespace Exp { +// misc +inline const RegEx& Empty() { + static const RegEx e; + return e; +} +inline const RegEx& Space() { + static const RegEx e = RegEx(' '); + return e; +} +inline const RegEx& Tab() { + static const RegEx e = RegEx('\t'); + return e; +} +inline const RegEx& Blank() { + static const RegEx e = Space() | Tab(); + return e; +} +inline const RegEx& Break() { + static const RegEx e = RegEx('\n') | RegEx("\r\n"); + return e; +} +inline const RegEx& BlankOrBreak() { + static const RegEx e = Blank() | Break(); + return e; +} +inline const RegEx& Digit() { + static const RegEx e = RegEx('0', '9'); + return e; +} +inline const RegEx& Alpha() { + static const RegEx e = RegEx('a', 'z') | RegEx('A', 'Z'); + return e; +} +inline const RegEx& AlphaNumeric() { + static const RegEx e = Alpha() | Digit(); + return e; +} +inline const RegEx& Word() { + static const RegEx e = AlphaNumeric() | RegEx('-'); + return e; +} +inline const RegEx& Hex() { + static const RegEx e = Digit() | RegEx('A', 'F') | RegEx('a', 'f'); + return e; +} +// Valid Unicode code points that are not part of c-printable (YAML 1.2, sec. +// 5.1) +inline const RegEx& NotPrintable() { + static const RegEx e = + RegEx(0) | + RegEx("\x01\x02\x03\x04\x05\x06\x07\x08\x0B\x0C\x7F", REGEX_OR) | + RegEx(0x0E, 0x1F) | + (RegEx('\xC2') + (RegEx('\x80', '\x84') | RegEx('\x86', '\x9F'))); + return e; +} +inline const RegEx& Utf8_ByteOrderMark() { + static const RegEx e = RegEx("\xEF\xBB\xBF"); + return e; +} + +// actual tags + +inline const RegEx& DocStart() { + static const RegEx e = RegEx("---") + (BlankOrBreak() | RegEx()); + return e; +} +inline const RegEx& DocEnd() { + static const RegEx e = RegEx("...") + (BlankOrBreak() | RegEx()); + return e; +} +inline const RegEx& DocIndicator() { + static const RegEx e = DocStart() | DocEnd(); + return e; +} +inline const RegEx& BlockEntry() { + static const RegEx e = RegEx('-') + (BlankOrBreak() | RegEx()); + return e; +} +inline const RegEx& Key() { + static const RegEx e = RegEx('?') + BlankOrBreak(); + return e; +} +inline const RegEx& KeyInFlow() { + static const RegEx e = RegEx('?') + BlankOrBreak(); + return e; +} +inline const RegEx& Value() { + static const RegEx e = RegEx(':') + (BlankOrBreak() | RegEx()); + return e; +} +inline const RegEx& ValueInFlow() { + static const RegEx e = RegEx(':') + (BlankOrBreak() | RegEx(",]}", REGEX_OR)); + return e; +} +inline const RegEx& ValueInJSONFlow() { + static const RegEx e = RegEx(':'); + return e; +} +inline const RegEx Comment() { + static const RegEx e = RegEx('#'); + return e; +} +inline const RegEx& Anchor() { + static const RegEx e = !(RegEx("[]{},", REGEX_OR) | BlankOrBreak()); + return e; +} +inline const RegEx& AnchorEnd() { + static const RegEx e = RegEx("?:,]}%@`", REGEX_OR) | BlankOrBreak(); + return e; +} +inline const RegEx& URI() { + static const RegEx e = Word() | RegEx("#;/?:@&=+$,_.!~*'()[]", REGEX_OR) | + (RegEx('%') + Hex() + Hex()); + return e; +} +inline const RegEx& Tag() { + static const RegEx e = Word() | RegEx("#;/?:@&=+$_.~*'()", REGEX_OR) | + (RegEx('%') + Hex() + Hex()); + return e; +} + +// Plain scalar rules: +// . Cannot start with a blank. +// . Can never start with any of , [ ] { } # & * ! | > \' \" % @ ` +// . In the block context - ? : must be not be followed with a space. +// . In the flow context ? is illegal and : and - must not be followed with a +// space. +inline const RegEx& PlainScalar() { + static const RegEx e = + !(BlankOrBreak() | RegEx(",[]{}#&*!|>\'\"%@`", REGEX_OR) | + (RegEx("-?:", REGEX_OR) + (BlankOrBreak() | RegEx()))); + return e; +} +inline const RegEx& PlainScalarInFlow() { + static const RegEx e = + !(BlankOrBreak() | RegEx("?,[]{}#&*!|>\'\"%@`", REGEX_OR) | + (RegEx("-:", REGEX_OR) + (Blank() | RegEx()))); + return e; +} +inline const RegEx& EndScalar() { + static const RegEx e = RegEx(':') + (BlankOrBreak() | RegEx()); + return e; +} +inline const RegEx& EndScalarInFlow() { + static const RegEx e = + (RegEx(':') + (BlankOrBreak() | RegEx() | RegEx(",]}", REGEX_OR))) | + RegEx(",?[]{}", REGEX_OR); + return e; +} + +inline const RegEx& ScanScalarEndInFlow() { + static const RegEx e = (EndScalarInFlow() | (BlankOrBreak() + Comment())); + return e; +} + +inline const RegEx& ScanScalarEnd() { + static const RegEx e = EndScalar() | (BlankOrBreak() + Comment()); + return e; +} +inline const RegEx& EscSingleQuote() { + static const RegEx e = RegEx("\'\'"); + return e; +} +inline const RegEx& EscBreak() { + static const RegEx e = RegEx('\\') + Break(); + return e; +} + +inline const RegEx& ChompIndicator() { + static const RegEx e = RegEx("+-", REGEX_OR); + return e; +} +inline const RegEx& Chomp() { + static const RegEx e = (ChompIndicator() + Digit()) | + (Digit() + ChompIndicator()) | ChompIndicator() | + Digit(); + return e; +} + +// and some functions +std::string Escape(Stream& in); +} // namespace Exp + +namespace Keys { +const char Directive = '%'; +const char FlowSeqStart = '['; +const char FlowSeqEnd = ']'; +const char FlowMapStart = '{'; +const char FlowMapEnd = '}'; +const char FlowEntry = ','; +const char Alias = '*'; +const char Anchor = '&'; +const char Tag = '!'; +const char LiteralScalar = '|'; +const char FoldedScalar = '>'; +const char VerbatimTagStart = '<'; +const char VerbatimTagEnd = '>'; +} // namespace Keys +} // namespace YAML + +#endif // EXP_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/src/indentation.h b/lib/yaml-cpp/src/indentation.h new file mode 100644 index 0000000000..1a2ccaea2e --- /dev/null +++ b/lib/yaml-cpp/src/indentation.h @@ -0,0 +1,41 @@ +#ifndef INDENTATION_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define INDENTATION_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include +#include + +#include "yaml-cpp/ostream_wrapper.h" + +namespace YAML { +struct Indentation { + Indentation(std::size_t n_) : n(n_) {} + std::size_t n; +}; + +inline ostream_wrapper& operator<<(ostream_wrapper& out, + const Indentation& indent) { + for (std::size_t i = 0; i < indent.n; i++) + out << ' '; + return out; +} + +struct IndentTo { + IndentTo(std::size_t n_) : n(n_) {} + std::size_t n; +}; + +inline ostream_wrapper& operator<<(ostream_wrapper& out, + const IndentTo& indent) { + while (out.col() < indent.n) + out << ' '; + return out; +} +} + +#endif // INDENTATION_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/src/memory.cpp b/lib/yaml-cpp/src/memory.cpp new file mode 100644 index 0000000000..676e4c7f15 --- /dev/null +++ b/lib/yaml-cpp/src/memory.cpp @@ -0,0 +1,26 @@ +#include "yaml-cpp/node/detail/memory.h" +#include "yaml-cpp/node/detail/node.h" // IWYU pragma: keep +#include "yaml-cpp/node/ptr.h" + +namespace YAML { +namespace detail { + +void memory_holder::merge(memory_holder& rhs) { + if (m_pMemory == rhs.m_pMemory) + return; + + m_pMemory->merge(*rhs.m_pMemory); + rhs.m_pMemory = m_pMemory; +} + +node& memory::create_node() { + shared_node pNode(new node); + m_nodes.insert(pNode); + return *pNode; +} + +void memory::merge(const memory& rhs) { + m_nodes.insert(rhs.m_nodes.begin(), rhs.m_nodes.end()); +} +} // namespace detail +} // namespace YAML diff --git a/lib/yaml-cpp/src/node.cpp b/lib/yaml-cpp/src/node.cpp new file mode 100644 index 0000000000..badc3110ec --- /dev/null +++ b/lib/yaml-cpp/src/node.cpp @@ -0,0 +1,12 @@ +#include "yaml-cpp/node/node.h" +#include "nodebuilder.h" +#include "nodeevents.h" + +namespace YAML { +Node Clone(const Node& node) { + NodeEvents events(node); + NodeBuilder builder; + events.Emit(builder); + return builder.Root(); +} +} // namespace YAML diff --git a/lib/yaml-cpp/src/node_data.cpp b/lib/yaml-cpp/src/node_data.cpp new file mode 100644 index 0000000000..3bdc3c5a0a --- /dev/null +++ b/lib/yaml-cpp/src/node_data.cpp @@ -0,0 +1,324 @@ +#include +#include +#include +#include + +#include "yaml-cpp/exceptions.h" +#include "yaml-cpp/node/detail/memory.h" +#include "yaml-cpp/node/detail/node.h" // IWYU pragma: keep +#include "yaml-cpp/node/detail/node_data.h" +#include "yaml-cpp/node/detail/node_iterator.h" +#include "yaml-cpp/node/ptr.h" +#include "yaml-cpp/node/type.h" + +namespace YAML { +namespace detail { +std::atomic node::m_amount{0}; + +const std::string& node_data::empty_scalar() { + static const std::string svalue; + return svalue; +} + +node_data::node_data() + : m_isDefined(false), + m_mark(Mark::null_mark()), + m_type(NodeType::Null), + m_tag{}, + m_style(EmitterStyle::Default), + m_scalar{}, + m_sequence{}, + m_seqSize(0), + m_map{}, + m_undefinedPairs{} {} + +void node_data::mark_defined() { + if (m_type == NodeType::Undefined) + m_type = NodeType::Null; + m_isDefined = true; +} + +void node_data::set_mark(const Mark& mark) { m_mark = mark; } + +void node_data::set_type(NodeType type) { + if (type == NodeType::Undefined) { + m_type = type; + m_isDefined = false; + return; + } + + m_isDefined = true; + if (type == m_type) + return; + + m_type = type; + + switch (m_type) { + case NodeType::Null: + break; + case NodeType::Scalar: + m_scalar.clear(); + break; + case NodeType::Sequence: + reset_sequence(); + break; + case NodeType::Map: + reset_map(); + break; + case NodeType::Undefined: + assert(false); + break; + } +} + +void node_data::set_tag(const std::string& tag) { m_tag = tag; } + +void node_data::set_style(EmitterStyle style) { m_style = style; } + +void node_data::set_null() { + m_isDefined = true; + m_type = NodeType::Null; +} + +void node_data::set_scalar(const std::string& scalar) { + m_isDefined = true; + m_type = NodeType::Scalar; + m_scalar = scalar; +} + +// size/iterator +std::size_t node_data::size() const { + if (!m_isDefined) + return 0; + + switch (m_type) { + case NodeType::Sequence: + compute_seq_size(); + return m_seqSize; + case NodeType::Map: + compute_map_size(); + return m_map.size() - m_undefinedPairs.size(); + default: + return 0; + } + return 0; +} + +void node_data::compute_seq_size() const { + while (m_seqSize < m_sequence.size() && m_sequence[m_seqSize]->is_defined()) + m_seqSize++; +} + +void node_data::compute_map_size() const { + auto it = m_undefinedPairs.begin(); + while (it != m_undefinedPairs.end()) { + auto jt = std::next(it); + if (it->first->is_defined() && it->second->is_defined()) + m_undefinedPairs.erase(it); + it = jt; + } +} + +const_node_iterator node_data::begin() const { + if (!m_isDefined) + return {}; + + switch (m_type) { + case NodeType::Sequence: + return const_node_iterator(m_sequence.begin()); + case NodeType::Map: + return const_node_iterator(m_map.begin(), m_map.end()); + default: + return {}; + } +} + +node_iterator node_data::begin() { + if (!m_isDefined) + return {}; + + switch (m_type) { + case NodeType::Sequence: + return node_iterator(m_sequence.begin()); + case NodeType::Map: + return node_iterator(m_map.begin(), m_map.end()); + default: + return {}; + } +} + +const_node_iterator node_data::end() const { + if (!m_isDefined) + return {}; + + switch (m_type) { + case NodeType::Sequence: + return const_node_iterator(m_sequence.end()); + case NodeType::Map: + return const_node_iterator(m_map.end(), m_map.end()); + default: + return {}; + } +} + +node_iterator node_data::end() { + if (!m_isDefined) + return {}; + + switch (m_type) { + case NodeType::Sequence: + return node_iterator(m_sequence.end()); + case NodeType::Map: + return node_iterator(m_map.end(), m_map.end()); + default: + return {}; + } +} + +// sequence +void node_data::push_back(node& node, + const shared_memory_holder& /* pMemory */) { + if (m_type == NodeType::Undefined || m_type == NodeType::Null) { + m_type = NodeType::Sequence; + reset_sequence(); + } + + if (m_type != NodeType::Sequence) + throw BadPushback(); + + m_sequence.push_back(&node); +} + +void node_data::insert(node& key, node& value, + const shared_memory_holder& pMemory) { + switch (m_type) { + case NodeType::Map: + break; + case NodeType::Undefined: + case NodeType::Null: + case NodeType::Sequence: + convert_to_map(pMemory); + break; + case NodeType::Scalar: + throw BadSubscript(m_mark, key); + } + + insert_map_pair(key, value); +} + +// indexing +node* node_data::get(node& key, + const shared_memory_holder& /* pMemory */) const { + if (m_type != NodeType::Map) { + return nullptr; + } + + for (const auto& it : m_map) { + if (it.first->is(key)) + return it.second; + } + + return nullptr; +} + +node& node_data::get(node& key, const shared_memory_holder& pMemory) { + switch (m_type) { + case NodeType::Map: + break; + case NodeType::Undefined: + case NodeType::Null: + case NodeType::Sequence: + convert_to_map(pMemory); + break; + case NodeType::Scalar: + throw BadSubscript(m_mark, key); + } + + for (const auto& it : m_map) { + if (it.first->is(key)) + return *it.second; + } + + node& value = pMemory->create_node(); + insert_map_pair(key, value); + return value; +} + +bool node_data::remove(node& key, const shared_memory_holder& /* pMemory */) { + if (m_type != NodeType::Map) + return false; + + for (auto it = m_undefinedPairs.begin(); it != m_undefinedPairs.end();) { + auto jt = std::next(it); + if (it->first->is(key)) + m_undefinedPairs.erase(it); + it = jt; + } + + auto it = + std::find_if(m_map.begin(), m_map.end(), + [&](std::pair j) { + return (j.first->is(key)); + }); + + if (it != m_map.end()) { + m_map.erase(it); + return true; + } + + return false; +} + +void node_data::reset_sequence() { + m_sequence.clear(); + m_seqSize = 0; +} + +void node_data::reset_map() { + m_map.clear(); + m_undefinedPairs.clear(); +} + +void node_data::insert_map_pair(node& key, node& value) { + m_map.emplace_back(&key, &value); + + if (!key.is_defined() || !value.is_defined()) + m_undefinedPairs.emplace_back(&key, &value); +} + +void node_data::convert_to_map(const shared_memory_holder& pMemory) { + switch (m_type) { + case NodeType::Undefined: + case NodeType::Null: + reset_map(); + m_type = NodeType::Map; + break; + case NodeType::Sequence: + convert_sequence_to_map(pMemory); + break; + case NodeType::Map: + break; + case NodeType::Scalar: + assert(false); + break; + } +} + +void node_data::convert_sequence_to_map(const shared_memory_holder& pMemory) { + assert(m_type == NodeType::Sequence); + + reset_map(); + for (std::size_t i = 0; i < m_sequence.size(); i++) { + std::stringstream stream; + stream << i; + + node& key = pMemory->create_node(); + key.set_scalar(stream.str()); + insert_map_pair(key, *m_sequence[i]); + } + + reset_sequence(); + m_type = NodeType::Map; +} +} // namespace detail +} // namespace YAML diff --git a/lib/yaml-cpp/src/nodebuilder.cpp b/lib/yaml-cpp/src/nodebuilder.cpp new file mode 100644 index 0000000000..f468dd44f8 --- /dev/null +++ b/lib/yaml-cpp/src/nodebuilder.cpp @@ -0,0 +1,134 @@ +#include + +#include "nodebuilder.h" +#include "yaml-cpp/node/detail/node.h" +#include "yaml-cpp/node/impl.h" +#include "yaml-cpp/node/node.h" +#include "yaml-cpp/node/type.h" + +namespace YAML { +struct Mark; + +NodeBuilder::NodeBuilder() + : m_pMemory(new detail::memory_holder), + m_pRoot(nullptr), + m_stack{}, + m_anchors{}, + m_keys{}, + m_mapDepth(0) { + m_anchors.push_back(nullptr); // since the anchors start at 1 +} + +NodeBuilder::~NodeBuilder() = default; + +Node NodeBuilder::Root() { + if (!m_pRoot) + return Node(); + + return Node(*m_pRoot, m_pMemory); +} + +void NodeBuilder::OnDocumentStart(const Mark&) {} + +void NodeBuilder::OnDocumentEnd() {} + +void NodeBuilder::OnNull(const Mark& mark, anchor_t anchor) { + detail::node& node = Push(mark, anchor); + node.set_null(); + Pop(); +} + +void NodeBuilder::OnAlias(const Mark& /* mark */, anchor_t anchor) { + detail::node& node = *m_anchors[anchor]; + Push(node); + Pop(); +} + +void NodeBuilder::OnScalar(const Mark& mark, const std::string& tag, + anchor_t anchor, const std::string& value) { + detail::node& node = Push(mark, anchor); + node.set_scalar(value); + node.set_tag(tag); + Pop(); +} + +void NodeBuilder::OnSequenceStart(const Mark& mark, const std::string& tag, + anchor_t anchor, EmitterStyle style) { + detail::node& node = Push(mark, anchor); + node.set_tag(tag); + node.set_type(NodeType::Sequence); + node.set_style(style); +} + +void NodeBuilder::OnSequenceEnd() { Pop(); } + +void NodeBuilder::OnMapStart(const Mark& mark, const std::string& tag, + anchor_t anchor, EmitterStyle style) { + detail::node& node = Push(mark, anchor); + node.set_type(NodeType::Map); + node.set_tag(tag); + node.set_style(style); + m_mapDepth++; +} + +void NodeBuilder::OnMapEnd() { + assert(m_mapDepth > 0); + m_mapDepth--; + Pop(); +} + +detail::node& NodeBuilder::Push(const Mark& mark, anchor_t anchor) { + detail::node& node = m_pMemory->create_node(); + node.set_mark(mark); + RegisterAnchor(anchor, node); + Push(node); + return node; +} + +void NodeBuilder::Push(detail::node& node) { + const bool needsKey = + (!m_stack.empty() && m_stack.back()->type() == NodeType::Map && + m_keys.size() < m_mapDepth); + + m_stack.push_back(&node); + if (needsKey) + m_keys.emplace_back(&node, false); +} + +void NodeBuilder::Pop() { + assert(!m_stack.empty()); + if (m_stack.size() == 1) { + m_pRoot = m_stack[0]; + m_stack.pop_back(); + return; + } + + detail::node& node = *m_stack.back(); + m_stack.pop_back(); + + detail::node& collection = *m_stack.back(); + + if (collection.type() == NodeType::Sequence) { + collection.push_back(node, m_pMemory); + } else if (collection.type() == NodeType::Map) { + assert(!m_keys.empty()); + PushedKey& key = m_keys.back(); + if (key.second) { + collection.insert(*key.first, node, m_pMemory); + m_keys.pop_back(); + } else { + key.second = true; + } + } else { + assert(false); + m_stack.clear(); + } +} + +void NodeBuilder::RegisterAnchor(anchor_t anchor, detail::node& node) { + if (anchor) { + assert(anchor == m_anchors.size()); + m_anchors.push_back(&node); + } +} +} // namespace YAML diff --git a/lib/yaml-cpp/src/nodebuilder.h b/lib/yaml-cpp/src/nodebuilder.h new file mode 100644 index 0000000000..ac88a6d1cf --- /dev/null +++ b/lib/yaml-cpp/src/nodebuilder.h @@ -0,0 +1,74 @@ +#ifndef NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include + +#include "yaml-cpp/anchor.h" +#include "yaml-cpp/emitterstyle.h" +#include "yaml-cpp/eventhandler.h" +#include "yaml-cpp/node/ptr.h" + +namespace YAML { +namespace detail { +class node; +} // namespace detail +struct Mark; +} // namespace YAML + +namespace YAML { +class Node; + +class NodeBuilder : public EventHandler { + public: + NodeBuilder(); + NodeBuilder(const NodeBuilder&) = delete; + NodeBuilder(NodeBuilder&&) = delete; + NodeBuilder& operator=(const NodeBuilder&) = delete; + NodeBuilder& operator=(NodeBuilder&&) = delete; + ~NodeBuilder() override; + + Node Root(); + + void OnDocumentStart(const Mark& mark) override; + void OnDocumentEnd() override; + + void OnNull(const Mark& mark, anchor_t anchor) override; + void OnAlias(const Mark& mark, anchor_t anchor) override; + void OnScalar(const Mark& mark, const std::string& tag, + anchor_t anchor, const std::string& value) override; + + void OnSequenceStart(const Mark& mark, const std::string& tag, + anchor_t anchor, EmitterStyle style) override; + void OnSequenceEnd() override; + + void OnMapStart(const Mark& mark, const std::string& tag, + anchor_t anchor, EmitterStyle style) override; + void OnMapEnd() override; + + private: + detail::node& Push(const Mark& mark, anchor_t anchor); + void Push(detail::node& node); + void Pop(); + void RegisterAnchor(anchor_t anchor, detail::node& node); + + private: + detail::shared_memory_holder m_pMemory; + detail::node* m_pRoot; + + using Nodes = std::vector; + Nodes m_stack; + Nodes m_anchors; + + using PushedKey = std::pair; + std::vector m_keys; + std::size_t m_mapDepth; +}; +} // namespace YAML + +#endif // NODE_NODEBUILDER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/src/nodeevents.cpp b/lib/yaml-cpp/src/nodeevents.cpp new file mode 100644 index 0000000000..b1774fef3e --- /dev/null +++ b/lib/yaml-cpp/src/nodeevents.cpp @@ -0,0 +1,98 @@ +#include "nodeevents.h" +#include "yaml-cpp/eventhandler.h" +#include "yaml-cpp/mark.h" +#include "yaml-cpp/node/detail/node.h" +#include "yaml-cpp/node/detail/node_iterator.h" +#include "yaml-cpp/node/node.h" +#include "yaml-cpp/node/type.h" + +namespace YAML { +void NodeEvents::AliasManager::RegisterReference(const detail::node& node) { + m_anchorByIdentity.insert(std::make_pair(node.ref(), _CreateNewAnchor())); +} + +anchor_t NodeEvents::AliasManager::LookupAnchor( + const detail::node& node) const { + auto it = m_anchorByIdentity.find(node.ref()); + if (it == m_anchorByIdentity.end()) + return 0; + return it->second; +} + +NodeEvents::NodeEvents(const Node& node) + : m_pMemory(node.m_pMemory), m_root(node.m_pNode), m_refCount{} { + if (m_root) + Setup(*m_root); +} + +void NodeEvents::Setup(const detail::node& node) { + int& refCount = m_refCount[node.ref()]; + refCount++; + if (refCount > 1) + return; + + if (node.type() == NodeType::Sequence) { + for (auto element : node) + Setup(*element); + } else if (node.type() == NodeType::Map) { + for (auto element : node) { + Setup(*element.first); + Setup(*element.second); + } + } +} + +void NodeEvents::Emit(EventHandler& handler) { + AliasManager am; + + handler.OnDocumentStart(Mark()); + if (m_root) + Emit(*m_root, handler, am); + handler.OnDocumentEnd(); +} + +void NodeEvents::Emit(const detail::node& node, EventHandler& handler, + AliasManager& am) const { + anchor_t anchor = NullAnchor; + if (IsAliased(node)) { + anchor = am.LookupAnchor(node); + if (anchor) { + handler.OnAlias(Mark(), anchor); + return; + } + + am.RegisterReference(node); + anchor = am.LookupAnchor(node); + } + + switch (node.type()) { + case NodeType::Undefined: + break; + case NodeType::Null: + handler.OnNull(Mark(), anchor); + break; + case NodeType::Scalar: + handler.OnScalar(Mark(), node.tag(), anchor, node.scalar()); + break; + case NodeType::Sequence: + handler.OnSequenceStart(Mark(), node.tag(), anchor, node.style()); + for (auto element : node) + Emit(*element, handler, am); + handler.OnSequenceEnd(); + break; + case NodeType::Map: + handler.OnMapStart(Mark(), node.tag(), anchor, node.style()); + for (auto element : node) { + Emit(*element.first, handler, am); + Emit(*element.second, handler, am); + } + handler.OnMapEnd(); + break; + } +} + +bool NodeEvents::IsAliased(const detail::node& node) const { + auto it = m_refCount.find(node.ref()); + return it != m_refCount.end() && it->second > 1; +} +} // namespace YAML diff --git a/lib/yaml-cpp/src/nodeevents.h b/lib/yaml-cpp/src/nodeevents.h new file mode 100644 index 0000000000..efca9149ed --- /dev/null +++ b/lib/yaml-cpp/src/nodeevents.h @@ -0,0 +1,68 @@ +#ifndef NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include +#include + +#include "yaml-cpp/anchor.h" +#include "yaml-cpp/node/ptr.h" + +namespace YAML { +namespace detail { +class node; +} // namespace detail +} // namespace YAML + +namespace YAML { +class EventHandler; +class Node; + +class NodeEvents { + public: + explicit NodeEvents(const Node& node); + NodeEvents(const NodeEvents&) = delete; + NodeEvents(NodeEvents&&) = delete; + NodeEvents& operator=(const NodeEvents&) = delete; + NodeEvents& operator=(NodeEvents&&) = delete; + + void Emit(EventHandler& handler); + + private: + class AliasManager { + public: + AliasManager() : m_anchorByIdentity{}, m_curAnchor(0) {} + + void RegisterReference(const detail::node& node); + anchor_t LookupAnchor(const detail::node& node) const; + + private: + anchor_t _CreateNewAnchor() { return ++m_curAnchor; } + + private: + using AnchorByIdentity = std::map; + AnchorByIdentity m_anchorByIdentity; + + anchor_t m_curAnchor; + }; + + void Setup(const detail::node& node); + void Emit(const detail::node& node, EventHandler& handler, + AliasManager& am) const; + bool IsAliased(const detail::node& node) const; + + private: + detail::shared_memory_holder m_pMemory; + detail::node* m_root; + + using RefCount = std::map; + RefCount m_refCount; +}; +} // namespace YAML + +#endif // NODE_NODEEVENTS_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/src/null.cpp b/lib/yaml-cpp/src/null.cpp new file mode 100644 index 0000000000..9ad36c7681 --- /dev/null +++ b/lib/yaml-cpp/src/null.cpp @@ -0,0 +1,10 @@ +#include "yaml-cpp/null.h" + +namespace YAML { +_Null BaseNull; + +bool IsNullString(const std::string& str) { + return str.empty() || str == "~" || str == "null" || str == "Null" || + str == "NULL"; +} +} // namespace YAML diff --git a/lib/yaml-cpp/src/ostream_wrapper.cpp b/lib/yaml-cpp/src/ostream_wrapper.cpp new file mode 100644 index 0000000000..047a9f7c8e --- /dev/null +++ b/lib/yaml-cpp/src/ostream_wrapper.cpp @@ -0,0 +1,62 @@ +#include "yaml-cpp/ostream_wrapper.h" + +#include +#include +#include + +namespace YAML { +ostream_wrapper::ostream_wrapper() + : m_buffer(1, '\0'), + m_pStream(nullptr), + m_pos(0), + m_row(0), + m_col(0), + m_comment(false) {} + +ostream_wrapper::ostream_wrapper(std::ostream& stream) + : m_buffer{}, + m_pStream(&stream), + m_pos(0), + m_row(0), + m_col(0), + m_comment(false) {} + +ostream_wrapper::~ostream_wrapper() = default; + +void ostream_wrapper::write(const std::string& str) { + if (m_pStream) { + m_pStream->write(str.c_str(), str.size()); + } else { + m_buffer.resize(std::max(m_buffer.size(), m_pos + str.size() + 1)); + std::copy(str.begin(), str.end(), m_buffer.begin() + m_pos); + } + + for (char ch : str) { + update_pos(ch); + } +} + +void ostream_wrapper::write(const char* str, std::size_t size) { + if (m_pStream) { + m_pStream->write(str, size); + } else { + m_buffer.resize(std::max(m_buffer.size(), m_pos + size + 1)); + std::copy(str, str + size, m_buffer.begin() + m_pos); + } + + for (std::size_t i = 0; i < size; i++) { + update_pos(str[i]); + } +} + +void ostream_wrapper::update_pos(char ch) { + m_pos++; + m_col++; + + if (ch == '\n') { + m_row++; + m_col = 0; + m_comment = false; + } +} +} // namespace YAML diff --git a/lib/yaml-cpp/src/parse.cpp b/lib/yaml-cpp/src/parse.cpp new file mode 100644 index 0000000000..262536b85a --- /dev/null +++ b/lib/yaml-cpp/src/parse.cpp @@ -0,0 +1,72 @@ +#include "yaml-cpp/node/parse.h" + +#include +#include + +#include "nodebuilder.h" +#include "yaml-cpp/node/impl.h" +#include "yaml-cpp/node/node.h" +#include "yaml-cpp/parser.h" + +namespace YAML { +Node Load(const std::string& input) { + std::stringstream stream(input); + return Load(stream); +} + +Node Load(const char* input) { + std::stringstream stream(input); + return Load(stream); +} + +Node Load(std::istream& input) { + Parser parser(input); + NodeBuilder builder; + if (!parser.HandleNextDocument(builder)) { + return Node(); + } + + return builder.Root(); +} + +Node LoadFile(const std::string& filename) { + std::ifstream fin(filename); + if (!fin) { + throw BadFile(filename); + } + return Load(fin); +} + +std::vector LoadAll(const std::string& input) { + std::stringstream stream(input); + return LoadAll(stream); +} + +std::vector LoadAll(const char* input) { + std::stringstream stream(input); + return LoadAll(stream); +} + +std::vector LoadAll(std::istream& input) { + std::vector docs; + + Parser parser(input); + while (true) { + NodeBuilder builder; + if (!parser.HandleNextDocument(builder)) { + break; + } + docs.push_back(builder.Root()); + } + + return docs; +} + +std::vector LoadAllFromFile(const std::string& filename) { + std::ifstream fin(filename); + if (!fin) { + throw BadFile(filename); + } + return LoadAll(fin); +} +} // namespace YAML diff --git a/lib/yaml-cpp/src/parser.cpp b/lib/yaml-cpp/src/parser.cpp new file mode 100644 index 0000000000..b8b78ebabc --- /dev/null +++ b/lib/yaml-cpp/src/parser.cpp @@ -0,0 +1,119 @@ +#include +#include + +#include "directives.h" // IWYU pragma: keep +#include "scanner.h" // IWYU pragma: keep +#include "singledocparser.h" +#include "token.h" +#include "yaml-cpp/exceptions.h" // IWYU pragma: keep +#include "yaml-cpp/parser.h" + +namespace YAML { +class EventHandler; + +Parser::Parser() : m_pScanner{}, m_pDirectives{} {} + +Parser::Parser(std::istream& in) : Parser() { Load(in); } + +Parser::~Parser() = default; + +Parser::operator bool() const { return m_pScanner && !m_pScanner->empty(); } + +void Parser::Load(std::istream& in) { + m_pScanner.reset(new Scanner(in)); + m_pDirectives.reset(new Directives); +} + +bool Parser::HandleNextDocument(EventHandler& eventHandler) { + if (!m_pScanner) + return false; + + ParseDirectives(); + if (m_pScanner->empty()) { + return false; + } + + SingleDocParser sdp(*m_pScanner, *m_pDirectives); + sdp.HandleDocument(eventHandler); + return true; +} + +void Parser::ParseDirectives() { + bool readDirective = false; + + while (!m_pScanner->empty()) { + Token& token = m_pScanner->peek(); + if (token.type != Token::DIRECTIVE) { + break; + } + + // we keep the directives from the last document if none are specified; + // but if any directives are specific, then we reset them + if (!readDirective) { + m_pDirectives.reset(new Directives); + } + + readDirective = true; + HandleDirective(token); + m_pScanner->pop(); + } +} + +void Parser::HandleDirective(const Token& token) { + if (token.value == "YAML") { + HandleYamlDirective(token); + } else if (token.value == "TAG") { + HandleTagDirective(token); + } +} + +void Parser::HandleYamlDirective(const Token& token) { + if (token.params.size() != 1) { + throw ParserException(token.mark, ErrorMsg::YAML_DIRECTIVE_ARGS); + } + + if (!m_pDirectives->version.isDefault) { + throw ParserException(token.mark, ErrorMsg::REPEATED_YAML_DIRECTIVE); + } + + std::stringstream str(token.params[0]); + str >> m_pDirectives->version.major; + str.get(); + str >> m_pDirectives->version.minor; + if (!str || str.peek() != EOF) { + throw ParserException( + token.mark, std::string(ErrorMsg::YAML_VERSION) + token.params[0]); + } + + if (m_pDirectives->version.major > 1) { + throw ParserException(token.mark, ErrorMsg::YAML_MAJOR_VERSION); + } + + m_pDirectives->version.isDefault = false; + // TODO: warning on major == 1, minor > 2? +} + +void Parser::HandleTagDirective(const Token& token) { + if (token.params.size() != 2) + throw ParserException(token.mark, ErrorMsg::TAG_DIRECTIVE_ARGS); + + const std::string& handle = token.params[0]; + const std::string& prefix = token.params[1]; + if (m_pDirectives->tags.find(handle) != m_pDirectives->tags.end()) { + throw ParserException(token.mark, ErrorMsg::REPEATED_TAG_DIRECTIVE); + } + + m_pDirectives->tags[handle] = prefix; +} + +void Parser::PrintTokens(std::ostream& out) { + if (!m_pScanner) { + return; + } + + while (!m_pScanner->empty()) { + out << m_pScanner->peek() << "\n"; + m_pScanner->pop(); + } +} +} // namespace YAML diff --git a/lib/yaml-cpp/src/ptr_vector.h b/lib/yaml-cpp/src/ptr_vector.h new file mode 100644 index 0000000000..d58de04cb6 --- /dev/null +++ b/lib/yaml-cpp/src/ptr_vector.h @@ -0,0 +1,45 @@ +#ifndef PTR_VECTOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define PTR_VECTOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include +#include +#include +#include + +namespace YAML { + +// TODO: This class is no longer needed +template +class ptr_vector { + public: + ptr_vector() : m_data{} {} + ptr_vector(const ptr_vector&) = delete; + ptr_vector(ptr_vector&&) = default; + ptr_vector& operator=(const ptr_vector&) = delete; + ptr_vector& operator=(ptr_vector&&) = default; + + void clear() { m_data.clear(); } + + std::size_t size() const { return m_data.size(); } + bool empty() const { return m_data.empty(); } + + void push_back(std::unique_ptr&& t) { m_data.push_back(std::move(t)); } + T& operator[](std::size_t i) { return *m_data[i]; } + const T& operator[](std::size_t i) const { return *m_data[i]; } + + T& back() { return *(m_data.back().get()); } + + const T& back() const { return *(m_data.back().get()); } + + private: + std::vector> m_data; +}; +} // namespace YAML + +#endif // PTR_VECTOR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/src/regex_yaml.cpp b/lib/yaml-cpp/src/regex_yaml.cpp new file mode 100644 index 0000000000..bf1784b41d --- /dev/null +++ b/lib/yaml-cpp/src/regex_yaml.cpp @@ -0,0 +1,43 @@ +#include "regex_yaml.h" + +namespace YAML { +// constructors + +RegEx::RegEx(REGEX_OP op) : m_op(op), m_a(0), m_z(0), m_params{} {} +RegEx::RegEx() : RegEx(REGEX_EMPTY) {} + +RegEx::RegEx(char ch) : m_op(REGEX_MATCH), m_a(ch), m_z(0), m_params{} {} + +RegEx::RegEx(char a, char z) : m_op(REGEX_RANGE), m_a(a), m_z(z), m_params{} {} + +RegEx::RegEx(const std::string& str, REGEX_OP op) + : m_op(op), m_a(0), m_z(0), m_params(str.begin(), str.end()) {} + +// combination constructors +RegEx operator!(const RegEx& ex) { + RegEx ret(REGEX_NOT); + ret.m_params.push_back(ex); + return ret; +} + +RegEx operator|(const RegEx& ex1, const RegEx& ex2) { + RegEx ret(REGEX_OR); + ret.m_params.push_back(ex1); + ret.m_params.push_back(ex2); + return ret; +} + +RegEx operator&(const RegEx& ex1, const RegEx& ex2) { + RegEx ret(REGEX_AND); + ret.m_params.push_back(ex1); + ret.m_params.push_back(ex2); + return ret; +} + +RegEx operator+(const RegEx& ex1, const RegEx& ex2) { + RegEx ret(REGEX_SEQ); + ret.m_params.push_back(ex1); + ret.m_params.push_back(ex2); + return ret; +} +} // namespace YAML diff --git a/lib/yaml-cpp/src/regex_yaml.h b/lib/yaml-cpp/src/regex_yaml.h new file mode 100644 index 0000000000..c70ab60dcc --- /dev/null +++ b/lib/yaml-cpp/src/regex_yaml.h @@ -0,0 +1,88 @@ +#ifndef REGEX_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define REGEX_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include +#include + +#include "yaml-cpp/dll.h" + +namespace YAML { +class Stream; + +enum REGEX_OP { + REGEX_EMPTY, + REGEX_MATCH, + REGEX_RANGE, + REGEX_OR, + REGEX_AND, + REGEX_NOT, + REGEX_SEQ +}; + +// simplified regular expressions +// . Only straightforward matches (no repeated characters) +// . Only matches from start of string +class YAML_CPP_API RegEx { + public: + RegEx(); + explicit RegEx(char ch); + RegEx(char a, char z); + RegEx(const std::string& str, REGEX_OP op = REGEX_SEQ); + ~RegEx() = default; + + friend YAML_CPP_API RegEx operator!(const RegEx& ex); + friend YAML_CPP_API RegEx operator|(const RegEx& ex1, const RegEx& ex2); + friend YAML_CPP_API RegEx operator&(const RegEx& ex1, const RegEx& ex2); + friend YAML_CPP_API RegEx operator+(const RegEx& ex1, const RegEx& ex2); + + bool Matches(char ch) const; + bool Matches(const std::string& str) const; + bool Matches(const Stream& in) const; + template + bool Matches(const Source& source) const; + + int Match(const std::string& str) const; + int Match(const Stream& in) const; + template + int Match(const Source& source) const; + + private: + explicit RegEx(REGEX_OP op); + + template + bool IsValidSource(const Source& source) const; + template + int MatchUnchecked(const Source& source) const; + + template + int MatchOpEmpty(const Source& source) const; + template + int MatchOpMatch(const Source& source) const; + template + int MatchOpRange(const Source& source) const; + template + int MatchOpOr(const Source& source) const; + template + int MatchOpAnd(const Source& source) const; + template + int MatchOpNot(const Source& source) const; + template + int MatchOpSeq(const Source& source) const; + + private: + REGEX_OP m_op; + char m_a{}; + char m_z{}; + std::vector m_params; +}; +} // namespace YAML + +#include "regeximpl.h" + +#endif // REGEX_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/src/regeximpl.h b/lib/yaml-cpp/src/regeximpl.h new file mode 100644 index 0000000000..a742cdc305 --- /dev/null +++ b/lib/yaml-cpp/src/regeximpl.h @@ -0,0 +1,185 @@ +#ifndef REGEXIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define REGEXIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "stream.h" +#include "streamcharsource.h" +#include "stringsource.h" + +namespace YAML { +// query matches +inline bool RegEx::Matches(char ch) const { + std::string str; + str += ch; + return Matches(str); +} + +inline bool RegEx::Matches(const std::string& str) const { + return Match(str) >= 0; +} + +inline bool RegEx::Matches(const Stream& in) const { return Match(in) >= 0; } + +template +inline bool RegEx::Matches(const Source& source) const { + return Match(source) >= 0; +} + +// Match +// . Matches the given string against this regular expression. +// . Returns the number of characters matched. +// . Returns -1 if no characters were matched (the reason for +// not returning zero is that we may have an empty regex +// which is ALWAYS successful at matching zero characters). +// . REMEMBER that we only match from the start of the buffer! +inline int RegEx::Match(const std::string& str) const { + StringCharSource source(str.c_str(), str.size()); + return Match(source); +} + +inline int RegEx::Match(const Stream& in) const { + StreamCharSource source(in); + return Match(source); +} + +template +inline bool RegEx::IsValidSource(const Source& source) const { + return source; +} + +template <> +inline bool RegEx::IsValidSource( + const StringCharSource& source) const { + switch (m_op) { + case REGEX_MATCH: + case REGEX_RANGE: + return source; + default: + return true; + } +} + +template +inline int RegEx::Match(const Source& source) const { + return IsValidSource(source) ? MatchUnchecked(source) : -1; +} + +template +inline int RegEx::MatchUnchecked(const Source& source) const { + switch (m_op) { + case REGEX_EMPTY: + return MatchOpEmpty(source); + case REGEX_MATCH: + return MatchOpMatch(source); + case REGEX_RANGE: + return MatchOpRange(source); + case REGEX_OR: + return MatchOpOr(source); + case REGEX_AND: + return MatchOpAnd(source); + case REGEX_NOT: + return MatchOpNot(source); + case REGEX_SEQ: + return MatchOpSeq(source); + } + + return -1; +} + +////////////////////////////////////////////////////////////////////////////// +// Operators +// Note: the convention MatchOp* is that we can assume +// IsSourceValid(source). +// So we do all our checks *before* we call these functions + +// EmptyOperator +template +inline int RegEx::MatchOpEmpty(const Source& source) const { + return source[0] == Stream::eof() ? 0 : -1; +} + +template <> +inline int RegEx::MatchOpEmpty( + const StringCharSource& source) const { + return !source ? 0 : -1; // the empty regex only is successful on the empty + // string +} + +// MatchOperator +template +inline int RegEx::MatchOpMatch(const Source& source) const { + if (source[0] != m_a) + return -1; + return 1; +} + +// RangeOperator +template +inline int RegEx::MatchOpRange(const Source& source) const { + if (m_a > source[0] || m_z < source[0]) + return -1; + return 1; +} + +// OrOperator +template +inline int RegEx::MatchOpOr(const Source& source) const { + for (const RegEx& param : m_params) { + int n = param.MatchUnchecked(source); + if (n >= 0) + return n; + } + return -1; +} + +// AndOperator +// Note: 'AND' is a little funny, since we may be required to match things +// of different lengths. If we find a match, we return the length of +// the FIRST entry on the list. +template +inline int RegEx::MatchOpAnd(const Source& source) const { + int first = -1; + for (std::size_t i = 0; i < m_params.size(); i++) { + int n = m_params[i].MatchUnchecked(source); + if (n == -1) + return -1; + if (i == 0) + first = n; + } + return first; +} + +// NotOperator +template +inline int RegEx::MatchOpNot(const Source& source) const { + if (m_params.empty()) + return -1; + if (m_params[0].MatchUnchecked(source) >= 0) + return -1; + return 1; +} + +// SeqOperator +template +inline int RegEx::MatchOpSeq(const Source& source) const { + int offset = 0; + for (const RegEx& param : m_params) { + int n = param.Match(source + offset); // note Match, not + // MatchUnchecked because we + // need to check validity after + // the offset + if (n == -1) + return -1; + offset += n; + } + + return offset; +} +} // namespace YAML + +#endif // REGEXIMPL_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/src/scanner.cpp b/lib/yaml-cpp/src/scanner.cpp new file mode 100644 index 0000000000..ea5511a114 --- /dev/null +++ b/lib/yaml-cpp/src/scanner.cpp @@ -0,0 +1,391 @@ +#include +#include + +#include "exp.h" +#include "scanner.h" +#include "token.h" +#include "yaml-cpp/exceptions.h" // IWYU pragma: keep + +namespace YAML { +Scanner::Scanner(std::istream& in) + : INPUT(in), + m_tokens{}, + m_startedStream(false), + m_endedStream(false), + m_simpleKeyAllowed(false), + m_canBeJSONFlow(false), + m_simpleKeys{}, + m_indents{}, + m_indentRefs{}, + m_flows{} {} + +Scanner::~Scanner() = default; + +bool Scanner::empty() { + EnsureTokensInQueue(); + return m_tokens.empty(); +} + +void Scanner::pop() { + EnsureTokensInQueue(); + if (!m_tokens.empty()) + m_tokens.pop(); +} + +Token& Scanner::peek() { + EnsureTokensInQueue(); + assert(!m_tokens.empty()); // should we be asserting here? I mean, we really + // just be checking + // if it's empty before peeking. + +#if 0 + static Token *pLast = 0; + if(pLast != &m_tokens.front()) + std::cerr << "peek: " << m_tokens.front() << "\n"; + pLast = &m_tokens.front(); +#endif + + return m_tokens.front(); +} + +Mark Scanner::mark() const { return INPUT.mark(); } + +void Scanner::EnsureTokensInQueue() { + while (true) { + if (!m_tokens.empty()) { + Token& token = m_tokens.front(); + + // if this guy's valid, then we're done + if (token.status == Token::VALID) { + return; + } + + // here's where we clean up the impossible tokens + if (token.status == Token::INVALID) { + m_tokens.pop(); + continue; + } + + // note: what's left are the unverified tokens + } + + // no token? maybe we've actually finished + if (m_endedStream) { + return; + } + + // no? then scan... + ScanNextToken(); + } +} + +void Scanner::ScanNextToken() { + if (m_endedStream) { + return; + } + + if (!m_startedStream) { + return StartStream(); + } + + // get rid of whitespace, etc. (in between tokens it should be irrelevant) + ScanToNextToken(); + + // maybe need to end some blocks + PopIndentToHere(); + + // ***** + // And now branch based on the next few characters! + // ***** + + // end of stream + if (!INPUT) { + return EndStream(); + } + + if (INPUT.column() == 0 && INPUT.peek() == Keys::Directive) { + return ScanDirective(); + } + + // document token + if (INPUT.column() == 0 && Exp::DocStart().Matches(INPUT)) { + return ScanDocStart(); + } + + if (INPUT.column() == 0 && Exp::DocEnd().Matches(INPUT)) { + return ScanDocEnd(); + } + + // flow start/end/entry + if (INPUT.peek() == Keys::FlowSeqStart || + INPUT.peek() == Keys::FlowMapStart) { + return ScanFlowStart(); + } + + if (INPUT.peek() == Keys::FlowSeqEnd || INPUT.peek() == Keys::FlowMapEnd) { + return ScanFlowEnd(); + } + + if (INPUT.peek() == Keys::FlowEntry) { + return ScanFlowEntry(); + } + + // block/map stuff + if (Exp::BlockEntry().Matches(INPUT)) { + return ScanBlockEntry(); + } + + if ((InBlockContext() ? Exp::Key() : Exp::KeyInFlow()).Matches(INPUT)) { + return ScanKey(); + } + + if (GetValueRegex().Matches(INPUT)) { + return ScanValue(); + } + + // alias/anchor + if (INPUT.peek() == Keys::Alias || INPUT.peek() == Keys::Anchor) { + return ScanAnchorOrAlias(); + } + + // tag + if (INPUT.peek() == Keys::Tag) { + return ScanTag(); + } + + // special scalars + if (InBlockContext() && (INPUT.peek() == Keys::LiteralScalar || + INPUT.peek() == Keys::FoldedScalar)) { + return ScanBlockScalar(); + } + + if (INPUT.peek() == '\'' || INPUT.peek() == '\"') { + return ScanQuotedScalar(); + } + + // plain scalars + if ((InBlockContext() ? Exp::PlainScalar() : Exp::PlainScalarInFlow()) + .Matches(INPUT)) { + return ScanPlainScalar(); + } + + // don't know what it is! + throw ParserException(INPUT.mark(), ErrorMsg::UNKNOWN_TOKEN); +} + +void Scanner::ScanToNextToken() { + while (true) { + // first eat whitespace + while (INPUT && IsWhitespaceToBeEaten(INPUT.peek())) { + if (InBlockContext() && Exp::Tab().Matches(INPUT)) { + m_simpleKeyAllowed = false; + } + INPUT.eat(1); + } + + // then eat a comment + if (Exp::Comment().Matches(INPUT)) { + // eat until line break + while (INPUT && !Exp::Break().Matches(INPUT)) { + INPUT.eat(1); + } + } + + // if it's NOT a line break, then we're done! + if (!Exp::Break().Matches(INPUT)) { + break; + } + + // otherwise, let's eat the line break and keep going + int n = Exp::Break().Match(INPUT); + INPUT.eat(n); + + // oh yeah, and let's get rid of that simple key + InvalidateSimpleKey(); + + // new line - we may be able to accept a simple key now + if (InBlockContext()) { + m_simpleKeyAllowed = true; + } + } +} + +/////////////////////////////////////////////////////////////////////// +// Misc. helpers + +// IsWhitespaceToBeEaten +// . We can eat whitespace if it's a space or tab +// . Note: originally tabs in block context couldn't be eaten +// "where a simple key could be allowed +// (i.e., not at the beginning of a line, or following '-', '?', or +// ':')" +// I think this is wrong, since tabs can be non-content whitespace; it's just +// that they can't contribute to indentation, so once you've seen a tab in a +// line, you can't start a simple key +bool Scanner::IsWhitespaceToBeEaten(char ch) { + if (ch == ' ') { + return true; + } + + if (ch == '\t') { + return true; + } + + return false; +} + +const RegEx& Scanner::GetValueRegex() const { + if (InBlockContext()) { + return Exp::Value(); + } + + return m_canBeJSONFlow ? Exp::ValueInJSONFlow() : Exp::ValueInFlow(); +} + +void Scanner::StartStream() { + m_startedStream = true; + m_simpleKeyAllowed = true; + std::unique_ptr pIndent( + new IndentMarker(-1, IndentMarker::NONE)); + m_indentRefs.push_back(std::move(pIndent)); + m_indents.push(&m_indentRefs.back()); +} + +void Scanner::EndStream() { + // force newline + if (INPUT.column() > 0) { + INPUT.ResetColumn(); + } + + PopAllIndents(); + PopAllSimpleKeys(); + + m_simpleKeyAllowed = false; + m_endedStream = true; +} + +Token* Scanner::PushToken(Token::TYPE type) { + m_tokens.push(Token(type, INPUT.mark())); + return &m_tokens.back(); +} + +Token::TYPE Scanner::GetStartTokenFor(IndentMarker::INDENT_TYPE type) const { + switch (type) { + case IndentMarker::SEQ: + return Token::BLOCK_SEQ_START; + case IndentMarker::MAP: + return Token::BLOCK_MAP_START; + case IndentMarker::NONE: + assert(false); + break; + } + assert(false); + throw std::runtime_error("yaml-cpp: internal error, invalid indent type"); +} + +Scanner::IndentMarker* Scanner::PushIndentTo(int column, + IndentMarker::INDENT_TYPE type) { + // are we in flow? + if (InFlowContext()) { + return nullptr; + } + + std::unique_ptr pIndent(new IndentMarker(column, type)); + IndentMarker& indent = *pIndent; + const IndentMarker& lastIndent = *m_indents.top(); + + // is this actually an indentation? + if (indent.column < lastIndent.column) { + return nullptr; + } + if (indent.column == lastIndent.column && + !(indent.type == IndentMarker::SEQ && + lastIndent.type == IndentMarker::MAP)) { + return nullptr; + } + + // push a start token + indent.pStartToken = PushToken(GetStartTokenFor(type)); + + // and then the indent + m_indents.push(&indent); + m_indentRefs.push_back(std::move(pIndent)); + return &m_indentRefs.back(); +} + +void Scanner::PopIndentToHere() { + // are we in flow? + if (InFlowContext()) { + return; + } + + // now pop away + while (!m_indents.empty()) { + const IndentMarker& indent = *m_indents.top(); + if (indent.column < INPUT.column()) { + break; + } + if (indent.column == INPUT.column() && + !(indent.type == IndentMarker::SEQ && + !Exp::BlockEntry().Matches(INPUT))) { + break; + } + + PopIndent(); + } + + while (!m_indents.empty() && + m_indents.top()->status == IndentMarker::INVALID) { + PopIndent(); + } +} + +void Scanner::PopAllIndents() { + // are we in flow? + if (InFlowContext()) { + return; + } + + // now pop away + while (!m_indents.empty()) { + const IndentMarker& indent = *m_indents.top(); + if (indent.type == IndentMarker::NONE) { + break; + } + + PopIndent(); + } +} + +void Scanner::PopIndent() { + const IndentMarker& indent = *m_indents.top(); + m_indents.pop(); + + if (indent.status != IndentMarker::VALID) { + InvalidateSimpleKey(); + return; + } + + if (indent.type == IndentMarker::SEQ) { + m_tokens.push(Token(Token::BLOCK_SEQ_END, INPUT.mark())); + } else if (indent.type == IndentMarker::MAP) { + m_tokens.push(Token(Token::BLOCK_MAP_END, INPUT.mark())); + } +} + +int Scanner::GetTopIndent() const { + if (m_indents.empty()) { + return 0; + } + return m_indents.top()->column; +} + +void Scanner::ThrowParserException(const std::string& msg) const { + Mark mark = Mark::null_mark(); + if (!m_tokens.empty()) { + const Token& token = m_tokens.front(); + mark = token.mark; + } + throw ParserException(mark, msg); +} +} // namespace YAML diff --git a/lib/yaml-cpp/src/scanner.h b/lib/yaml-cpp/src/scanner.h new file mode 100644 index 0000000000..c653ac69ff --- /dev/null +++ b/lib/yaml-cpp/src/scanner.h @@ -0,0 +1,190 @@ +#ifndef SCANNER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define SCANNER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include +#include +#include +#include +#include +#include +#include + +#include "ptr_vector.h" +#include "stream.h" +#include "token.h" +#include "yaml-cpp/mark.h" + +namespace YAML { +class Node; +class RegEx; + +/** + * A scanner transforms a stream of characters into a stream of tokens. + */ +class Scanner { + public: + explicit Scanner(std::istream &in); + ~Scanner(); + + /** Returns true if there are no more tokens to be read. */ + bool empty(); + + /** Removes the next token in the queue. */ + void pop(); + + /** Returns, but does not remove, the next token in the queue. */ + Token &peek(); + + /** Returns the current mark in the input stream. */ + Mark mark() const; + + private: + struct IndentMarker { + enum INDENT_TYPE { MAP, SEQ, NONE }; + enum STATUS { VALID, INVALID, UNKNOWN }; + IndentMarker(int column_, INDENT_TYPE type_) + : column(column_), type(type_), status(VALID), pStartToken(nullptr) {} + + int column; + INDENT_TYPE type; + STATUS status; + Token *pStartToken; + }; + + enum FLOW_MARKER { FLOW_MAP, FLOW_SEQ }; + + private: + // scanning + + /** + * Scans until there's a valid token at the front of the queue, or the queue + * is empty. The state can be checked by {@link #empty}, and the next token + * retrieved by {@link #peek}. + */ + void EnsureTokensInQueue(); + + /** + * The main scanning function; this method branches out to scan whatever the + * next token should be. + */ + void ScanNextToken(); + + /** Eats the input stream until it reaches the next token-like thing. */ + void ScanToNextToken(); + + /** Sets the initial conditions for starting a stream. */ + void StartStream(); + + /** Closes out the stream, finish up, etc. */ + void EndStream(); + + Token *PushToken(Token::TYPE type); + + bool InFlowContext() const { return !m_flows.empty(); } + bool InBlockContext() const { return m_flows.empty(); } + std::size_t GetFlowLevel() const { return m_flows.size(); } + + Token::TYPE GetStartTokenFor(IndentMarker::INDENT_TYPE type) const; + + /** + * Pushes an indentation onto the stack, and enqueues the proper token + * (sequence start or mapping start). + * + * @return the indent marker it generates (if any). + */ + IndentMarker *PushIndentTo(int column, IndentMarker::INDENT_TYPE type); + + /** + * Pops indentations off the stack until it reaches the current indentation + * level, and enqueues the proper token each time. Then pops all invalid + * indentations off. + */ + void PopIndentToHere(); + + /** + * Pops all indentations (except for the base empty one) off the stack, and + * enqueues the proper token each time. + */ + void PopAllIndents(); + + /** Pops a single indent, pushing the proper token. */ + void PopIndent(); + int GetTopIndent() const; + + // checking input + bool CanInsertPotentialSimpleKey() const; + bool ExistsActiveSimpleKey() const; + void InsertPotentialSimpleKey(); + void InvalidateSimpleKey(); + bool VerifySimpleKey(); + void PopAllSimpleKeys(); + + /** + * Throws a ParserException with the current token location (if available), + * and does not parse any more tokens. + */ + void ThrowParserException(const std::string &msg) const; + + bool IsWhitespaceToBeEaten(char ch); + + /** + * Returns the appropriate regex to check if the next token is a value token. + */ + const RegEx &GetValueRegex() const; + + struct SimpleKey { + SimpleKey(const Mark &mark_, std::size_t flowLevel_); + + void Validate(); + void Invalidate(); + + Mark mark; + std::size_t flowLevel; + IndentMarker *pIndent; + Token *pMapStart, *pKey; + }; + + // and the tokens + void ScanDirective(); + void ScanDocStart(); + void ScanDocEnd(); + void ScanBlockSeqStart(); + void ScanBlockMapSTart(); + void ScanBlockEnd(); + void ScanBlockEntry(); + void ScanFlowStart(); + void ScanFlowEnd(); + void ScanFlowEntry(); + void ScanKey(); + void ScanValue(); + void ScanAnchorOrAlias(); + void ScanTag(); + void ScanPlainScalar(); + void ScanQuotedScalar(); + void ScanBlockScalar(); + + private: + // the stream + Stream INPUT; + + // the output (tokens) + std::queue m_tokens; + + // state info + bool m_startedStream, m_endedStream; + bool m_simpleKeyAllowed; + bool m_canBeJSONFlow; + std::stack m_simpleKeys; + std::stack m_indents; + ptr_vector m_indentRefs; // for "garbage collection" + std::stack m_flows; +}; +} + +#endif // SCANNER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/src/scanscalar.cpp b/lib/yaml-cpp/src/scanscalar.cpp new file mode 100644 index 0000000000..be57b1cd5d --- /dev/null +++ b/lib/yaml-cpp/src/scanscalar.cpp @@ -0,0 +1,251 @@ +#include "scanscalar.h" + +#include + +#include "exp.h" +#include "regeximpl.h" +#include "stream.h" +#include "yaml-cpp/exceptions.h" // IWYU pragma: keep + +namespace YAML { +// ScanScalar +// . This is where the scalar magic happens. +// +// . We do the scanning in three phases: +// 1. Scan until newline +// 2. Eat newline +// 3. Scan leading blanks. +// +// . Depending on the parameters given, we store or stop +// and different places in the above flow. +std::string ScanScalar(Stream& INPUT, ScanScalarParams& params) { + bool foundNonEmptyLine = false; + bool pastOpeningBreak = (params.fold == FOLD_FLOW); + bool emptyLine = false, moreIndented = false; + int foldedNewlineCount = 0; + bool foldedNewlineStartedMoreIndented = false; + std::size_t lastEscapedChar = std::string::npos; + std::string scalar; + params.leadingSpaces = false; + + if (!params.end) { + params.end = &Exp::Empty(); + } + + while (INPUT) { + // ******************************** + // Phase #1: scan until line ending + + std::size_t lastNonWhitespaceChar = scalar.size(); + bool escapedNewline = false; + while (!params.end->Matches(INPUT) && !Exp::Break().Matches(INPUT)) { + if (!INPUT) { + break; + } + + // document indicator? + if (INPUT.column() == 0 && Exp::DocIndicator().Matches(INPUT)) { + if (params.onDocIndicator == BREAK) { + break; + } + if (params.onDocIndicator == THROW) { + throw ParserException(INPUT.mark(), ErrorMsg::DOC_IN_SCALAR); + } + } + + foundNonEmptyLine = true; + pastOpeningBreak = true; + + // escaped newline? (only if we're escaping on slash) + if (params.escape == '\\' && Exp::EscBreak().Matches(INPUT)) { + // eat escape character and get out (but preserve trailing whitespace!) + INPUT.get(); + lastNonWhitespaceChar = scalar.size(); + lastEscapedChar = scalar.size(); + escapedNewline = true; + break; + } + + // escape this? + if (INPUT.peek() == params.escape) { + scalar += Exp::Escape(INPUT); + lastNonWhitespaceChar = scalar.size(); + lastEscapedChar = scalar.size(); + continue; + } + + // otherwise, just add the damn character + char ch = INPUT.get(); + scalar += ch; + if (ch != ' ' && ch != '\t') { + lastNonWhitespaceChar = scalar.size(); + } + } + + // eof? if we're looking to eat something, then we throw + if (!INPUT) { + if (params.eatEnd) { + throw ParserException(INPUT.mark(), ErrorMsg::EOF_IN_SCALAR); + } + break; + } + + // doc indicator? + if (params.onDocIndicator == BREAK && INPUT.column() == 0 && + Exp::DocIndicator().Matches(INPUT)) { + break; + } + + // are we done via character match? + int n = params.end->Match(INPUT); + if (n >= 0) { + if (params.eatEnd) { + INPUT.eat(n); + } + break; + } + + // do we remove trailing whitespace? + if (params.fold == FOLD_FLOW) + scalar.erase(lastNonWhitespaceChar); + + // ******************************** + // Phase #2: eat line ending + n = Exp::Break().Match(INPUT); + INPUT.eat(n); + + // ******************************** + // Phase #3: scan initial spaces + + // first the required indentation + while (INPUT.peek() == ' ' && + (INPUT.column() < params.indent || + (params.detectIndent && !foundNonEmptyLine)) && + !params.end->Matches(INPUT)) { + INPUT.eat(1); + } + + // update indent if we're auto-detecting + if (params.detectIndent && !foundNonEmptyLine) { + params.indent = std::max(params.indent, INPUT.column()); + } + + // and then the rest of the whitespace + while (Exp::Blank().Matches(INPUT)) { + // we check for tabs that masquerade as indentation + if (INPUT.peek() == '\t' && INPUT.column() < params.indent && + params.onTabInIndentation == THROW) { + throw ParserException(INPUT.mark(), ErrorMsg::TAB_IN_INDENTATION); + } + + if (!params.eatLeadingWhitespace) { + break; + } + + if (params.end->Matches(INPUT)) { + break; + } + + INPUT.eat(1); + } + + // was this an empty line? + bool nextEmptyLine = Exp::Break().Matches(INPUT); + bool nextMoreIndented = Exp::Blank().Matches(INPUT); + if (params.fold == FOLD_BLOCK && foldedNewlineCount == 0 && nextEmptyLine) + foldedNewlineStartedMoreIndented = moreIndented; + + // for block scalars, we always start with a newline, so we should ignore it + // (not fold or keep) + if (pastOpeningBreak) { + switch (params.fold) { + case DONT_FOLD: + scalar += "\n"; + break; + case FOLD_BLOCK: + if (!emptyLine && !nextEmptyLine && !moreIndented && + !nextMoreIndented && INPUT.column() >= params.indent) { + scalar += " "; + } else if (nextEmptyLine) { + foldedNewlineCount++; + } else { + scalar += "\n"; + } + + if (!nextEmptyLine && foldedNewlineCount > 0) { + scalar += std::string(foldedNewlineCount - 1, '\n'); + if (foldedNewlineStartedMoreIndented || + nextMoreIndented | !foundNonEmptyLine) { + scalar += "\n"; + } + foldedNewlineCount = 0; + } + break; + case FOLD_FLOW: + if (nextEmptyLine) { + scalar += "\n"; + } else if (!emptyLine && !escapedNewline) { + scalar += " "; + } + break; + } + } + + emptyLine = nextEmptyLine; + moreIndented = nextMoreIndented; + pastOpeningBreak = true; + + // are we done via indentation? + if (!emptyLine && INPUT.column() < params.indent) { + params.leadingSpaces = true; + break; + } + } + + // post-processing + if (params.trimTrailingSpaces) { + std::size_t pos = scalar.find_last_not_of(" \t"); + if (lastEscapedChar != std::string::npos) { + if (pos < lastEscapedChar || pos == std::string::npos) { + pos = lastEscapedChar; + } + } + if (pos < scalar.size()) { + scalar.erase(pos + 1); + } + } + + switch (params.chomp) { + case CLIP: { + std::size_t pos = scalar.find_last_not_of('\n'); + if (lastEscapedChar != std::string::npos) { + if (pos < lastEscapedChar || pos == std::string::npos) { + pos = lastEscapedChar; + } + } + if (pos == std::string::npos) { + scalar.erase(); + } else if (pos + 1 < scalar.size()) { + scalar.erase(pos + 2); + } + } break; + case STRIP: { + std::size_t pos = scalar.find_last_not_of('\n'); + if (lastEscapedChar != std::string::npos) { + if (pos < lastEscapedChar || pos == std::string::npos) { + pos = lastEscapedChar; + } + } + if (pos == std::string::npos) { + scalar.erase(); + } else if (pos < scalar.size()) { + scalar.erase(pos + 1); + } + } break; + default: + break; + } + + return scalar; +} +} // namespace YAML diff --git a/lib/yaml-cpp/src/scanscalar.h b/lib/yaml-cpp/src/scanscalar.h new file mode 100644 index 0000000000..296b885a51 --- /dev/null +++ b/lib/yaml-cpp/src/scanscalar.h @@ -0,0 +1,63 @@ +#ifndef SCANSCALAR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define SCANSCALAR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include + +#include "regex_yaml.h" +#include "stream.h" + +namespace YAML { +enum CHOMP { STRIP = -1, CLIP, KEEP }; +enum ACTION { NONE, BREAK, THROW }; +enum FOLD { DONT_FOLD, FOLD_BLOCK, FOLD_FLOW }; + +struct ScanScalarParams { + ScanScalarParams() + : end(nullptr), + eatEnd(false), + indent(0), + detectIndent(false), + eatLeadingWhitespace(0), + escape(0), + fold(DONT_FOLD), + trimTrailingSpaces(0), + chomp(CLIP), + onDocIndicator(NONE), + onTabInIndentation(NONE), + leadingSpaces(false) {} + + // input: + const RegEx* end; // what condition ends this scalar? + // unowned. + bool eatEnd; // should we eat that condition when we see it? + int indent; // what level of indentation should be eaten and ignored? + bool detectIndent; // should we try to autodetect the indent? + bool eatLeadingWhitespace; // should we continue eating this delicious + // indentation after 'indent' spaces? + char escape; // what character do we escape on (i.e., slash or single quote) + // (0 for none) + FOLD fold; // how do we fold line ends? + bool trimTrailingSpaces; // do we remove all trailing spaces (at the very + // end) + CHOMP chomp; // do we strip, clip, or keep trailing newlines (at the very + // end) + // Note: strip means kill all, clip means keep at most one, keep means keep + // all + ACTION onDocIndicator; // what do we do if we see a document indicator? + ACTION onTabInIndentation; // what do we do if we see a tab where we should + // be seeing indentation spaces + + // output: + bool leadingSpaces; +}; + +std::string ScanScalar(Stream& INPUT, ScanScalarParams& params); +} + +#endif // SCANSCALAR_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/src/scantag.cpp b/lib/yaml-cpp/src/scantag.cpp new file mode 100644 index 0000000000..176cc5c711 --- /dev/null +++ b/lib/yaml-cpp/src/scantag.cpp @@ -0,0 +1,81 @@ +#include "exp.h" +#include "regex_yaml.h" +#include "regeximpl.h" +#include "stream.h" +#include "yaml-cpp/exceptions.h" // IWYU pragma: keep +#include "yaml-cpp/mark.h" + +namespace YAML { +const std::string ScanVerbatimTag(Stream& INPUT) { + std::string tag; + + // eat the start character + INPUT.get(); + + while (INPUT) { + if (INPUT.peek() == Keys::VerbatimTagEnd) { + // eat the end character + INPUT.get(); + return tag; + } + + int n = Exp::URI().Match(INPUT); + if (n <= 0) + break; + + tag += INPUT.get(n); + } + + throw ParserException(INPUT.mark(), ErrorMsg::END_OF_VERBATIM_TAG); +} + +const std::string ScanTagHandle(Stream& INPUT, bool& canBeHandle) { + std::string tag; + canBeHandle = true; + Mark firstNonWordChar; + + while (INPUT) { + if (INPUT.peek() == Keys::Tag) { + if (!canBeHandle) + throw ParserException(firstNonWordChar, ErrorMsg::CHAR_IN_TAG_HANDLE); + break; + } + + int n = 0; + if (canBeHandle) { + n = Exp::Word().Match(INPUT); + if (n <= 0) { + canBeHandle = false; + firstNonWordChar = INPUT.mark(); + } + } + + if (!canBeHandle) + n = Exp::Tag().Match(INPUT); + + if (n <= 0) + break; + + tag += INPUT.get(n); + } + + return tag; +} + +const std::string ScanTagSuffix(Stream& INPUT) { + std::string tag; + + while (INPUT) { + int n = Exp::Tag().Match(INPUT); + if (n <= 0) + break; + + tag += INPUT.get(n); + } + + if (tag.empty()) + throw ParserException(INPUT.mark(), ErrorMsg::TAG_WITH_NO_SUFFIX); + + return tag; +} +} // namespace YAML diff --git a/lib/yaml-cpp/src/scantag.h b/lib/yaml-cpp/src/scantag.h new file mode 100644 index 0000000000..522ba5495e --- /dev/null +++ b/lib/yaml-cpp/src/scantag.h @@ -0,0 +1,19 @@ +#ifndef SCANTAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define SCANTAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include +#include "stream.h" + +namespace YAML { +const std::string ScanVerbatimTag(Stream& INPUT); +const std::string ScanTagHandle(Stream& INPUT, bool& canBeHandle); +const std::string ScanTagSuffix(Stream& INPUT); +} + +#endif // SCANTAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/src/scantoken.cpp b/lib/yaml-cpp/src/scantoken.cpp new file mode 100644 index 0000000000..1a94ab1d7d --- /dev/null +++ b/lib/yaml-cpp/src/scantoken.cpp @@ -0,0 +1,437 @@ +#include + +#include "exp.h" +#include "regex_yaml.h" +#include "regeximpl.h" +#include "scanner.h" +#include "scanscalar.h" +#include "scantag.h" // IWYU pragma: keep +#include "tag.h" // IWYU pragma: keep +#include "token.h" +#include "yaml-cpp/exceptions.h" // IWYU pragma: keep +#include "yaml-cpp/mark.h" + +namespace YAML { +/////////////////////////////////////////////////////////////////////// +// Specialization for scanning specific tokens + +// Directive +// . Note: no semantic checking is done here (that's for the parser to do) +void Scanner::ScanDirective() { + std::string name; + std::vector params; + + // pop indents and simple keys + PopAllIndents(); + PopAllSimpleKeys(); + + m_simpleKeyAllowed = false; + m_canBeJSONFlow = false; + + // store pos and eat indicator + Token token(Token::DIRECTIVE, INPUT.mark()); + INPUT.eat(1); + + // read name + while (INPUT && !Exp::BlankOrBreak().Matches(INPUT)) + token.value += INPUT.get(); + + // read parameters + while (true) { + // first get rid of whitespace + while (Exp::Blank().Matches(INPUT)) + INPUT.eat(1); + + // break on newline or comment + if (!INPUT || Exp::Break().Matches(INPUT) || Exp::Comment().Matches(INPUT)) + break; + + // now read parameter + std::string param; + while (INPUT && !Exp::BlankOrBreak().Matches(INPUT)) + param += INPUT.get(); + + token.params.push_back(param); + } + + m_tokens.push(token); +} + +// DocStart +void Scanner::ScanDocStart() { + PopAllIndents(); + PopAllSimpleKeys(); + m_simpleKeyAllowed = false; + m_canBeJSONFlow = false; + + // eat + Mark mark = INPUT.mark(); + INPUT.eat(3); + m_tokens.push(Token(Token::DOC_START, mark)); +} + +// DocEnd +void Scanner::ScanDocEnd() { + PopAllIndents(); + PopAllSimpleKeys(); + m_simpleKeyAllowed = false; + m_canBeJSONFlow = false; + + // eat + Mark mark = INPUT.mark(); + INPUT.eat(3); + m_tokens.push(Token(Token::DOC_END, mark)); +} + +// FlowStart +void Scanner::ScanFlowStart() { + // flows can be simple keys + InsertPotentialSimpleKey(); + m_simpleKeyAllowed = true; + m_canBeJSONFlow = false; + + // eat + Mark mark = INPUT.mark(); + char ch = INPUT.get(); + FLOW_MARKER flowType = (ch == Keys::FlowSeqStart ? FLOW_SEQ : FLOW_MAP); + m_flows.push(flowType); + Token::TYPE type = + (flowType == FLOW_SEQ ? Token::FLOW_SEQ_START : Token::FLOW_MAP_START); + m_tokens.push(Token(type, mark)); +} + +// FlowEnd +void Scanner::ScanFlowEnd() { + if (InBlockContext()) + throw ParserException(INPUT.mark(), ErrorMsg::FLOW_END); + + // we might have a solo entry in the flow context + if (InFlowContext()) { + if (m_flows.top() == FLOW_MAP && VerifySimpleKey()) + m_tokens.push(Token(Token::VALUE, INPUT.mark())); + else if (m_flows.top() == FLOW_SEQ) + InvalidateSimpleKey(); + } + + m_simpleKeyAllowed = false; + m_canBeJSONFlow = true; + + // eat + Mark mark = INPUT.mark(); + char ch = INPUT.get(); + + // check that it matches the start + FLOW_MARKER flowType = (ch == Keys::FlowSeqEnd ? FLOW_SEQ : FLOW_MAP); + if (m_flows.top() != flowType) + throw ParserException(mark, ErrorMsg::FLOW_END); + m_flows.pop(); + + Token::TYPE type = (flowType ? Token::FLOW_SEQ_END : Token::FLOW_MAP_END); + m_tokens.push(Token(type, mark)); +} + +// FlowEntry +void Scanner::ScanFlowEntry() { + // we might have a solo entry in the flow context + if (InFlowContext()) { + if (m_flows.top() == FLOW_MAP && VerifySimpleKey()) + m_tokens.push(Token(Token::VALUE, INPUT.mark())); + else if (m_flows.top() == FLOW_SEQ) + InvalidateSimpleKey(); + } + + m_simpleKeyAllowed = true; + m_canBeJSONFlow = false; + + // eat + Mark mark = INPUT.mark(); + INPUT.eat(1); + m_tokens.push(Token(Token::FLOW_ENTRY, mark)); +} + +// BlockEntry +void Scanner::ScanBlockEntry() { + // we better be in the block context! + if (InFlowContext()) + throw ParserException(INPUT.mark(), ErrorMsg::BLOCK_ENTRY); + + // can we put it here? + if (!m_simpleKeyAllowed) + throw ParserException(INPUT.mark(), ErrorMsg::BLOCK_ENTRY); + + PushIndentTo(INPUT.column(), IndentMarker::SEQ); + m_simpleKeyAllowed = true; + m_canBeJSONFlow = false; + + // eat + Mark mark = INPUT.mark(); + INPUT.eat(1); + m_tokens.push(Token(Token::BLOCK_ENTRY, mark)); +} + +// Key +void Scanner::ScanKey() { + // handle keys differently in the block context (and manage indents) + if (InBlockContext()) { + if (!m_simpleKeyAllowed) + throw ParserException(INPUT.mark(), ErrorMsg::MAP_KEY); + + PushIndentTo(INPUT.column(), IndentMarker::MAP); + } + + // can only put a simple key here if we're in block context + m_simpleKeyAllowed = InBlockContext(); + + // eat + Mark mark = INPUT.mark(); + INPUT.eat(1); + m_tokens.push(Token(Token::KEY, mark)); +} + +// Value +void Scanner::ScanValue() { + // and check that simple key + bool isSimpleKey = VerifySimpleKey(); + m_canBeJSONFlow = false; + + if (isSimpleKey) { + // can't follow a simple key with another simple key (dunno why, though - it + // seems fine) + m_simpleKeyAllowed = false; + } else { + // handle values differently in the block context (and manage indents) + if (InBlockContext()) { + if (!m_simpleKeyAllowed) + throw ParserException(INPUT.mark(), ErrorMsg::MAP_VALUE); + + PushIndentTo(INPUT.column(), IndentMarker::MAP); + } + + // can only put a simple key here if we're in block context + m_simpleKeyAllowed = InBlockContext(); + } + + // eat + Mark mark = INPUT.mark(); + INPUT.eat(1); + m_tokens.push(Token(Token::VALUE, mark)); +} + +// AnchorOrAlias +void Scanner::ScanAnchorOrAlias() { + bool alias; + std::string name; + + // insert a potential simple key + InsertPotentialSimpleKey(); + m_simpleKeyAllowed = false; + m_canBeJSONFlow = false; + + // eat the indicator + Mark mark = INPUT.mark(); + char indicator = INPUT.get(); + alias = (indicator == Keys::Alias); + + // now eat the content + while (INPUT && Exp::Anchor().Matches(INPUT)) + name += INPUT.get(); + + // we need to have read SOMETHING! + if (name.empty()) + throw ParserException(INPUT.mark(), alias ? ErrorMsg::ALIAS_NOT_FOUND + : ErrorMsg::ANCHOR_NOT_FOUND); + + // and needs to end correctly + if (INPUT && !Exp::AnchorEnd().Matches(INPUT)) + throw ParserException(INPUT.mark(), alias ? ErrorMsg::CHAR_IN_ALIAS + : ErrorMsg::CHAR_IN_ANCHOR); + + // and we're done + Token token(alias ? Token::ALIAS : Token::ANCHOR, mark); + token.value = name; + m_tokens.push(token); +} + +// Tag +void Scanner::ScanTag() { + // insert a potential simple key + InsertPotentialSimpleKey(); + m_simpleKeyAllowed = false; + m_canBeJSONFlow = false; + + Token token(Token::TAG, INPUT.mark()); + + // eat the indicator + INPUT.get(); + + if (INPUT && INPUT.peek() == Keys::VerbatimTagStart) { + std::string tag = ScanVerbatimTag(INPUT); + + token.value = tag; + token.data = Tag::VERBATIM; + } else { + bool canBeHandle; + token.value = ScanTagHandle(INPUT, canBeHandle); + if (!canBeHandle && token.value.empty()) + token.data = Tag::NON_SPECIFIC; + else if (token.value.empty()) + token.data = Tag::SECONDARY_HANDLE; + else + token.data = Tag::PRIMARY_HANDLE; + + // is there a suffix? + if (canBeHandle && INPUT.peek() == Keys::Tag) { + // eat the indicator + INPUT.get(); + token.params.push_back(ScanTagSuffix(INPUT)); + token.data = Tag::NAMED_HANDLE; + } + } + + m_tokens.push(token); +} + +// PlainScalar +void Scanner::ScanPlainScalar() { + std::string scalar; + + // set up the scanning parameters + ScanScalarParams params; + params.end = + (InFlowContext() ? &Exp::ScanScalarEndInFlow() : &Exp::ScanScalarEnd()); + params.eatEnd = false; + params.indent = (InFlowContext() ? 0 : GetTopIndent() + 1); + params.fold = FOLD_FLOW; + params.eatLeadingWhitespace = true; + params.trimTrailingSpaces = true; + params.chomp = STRIP; + params.onDocIndicator = BREAK; + params.onTabInIndentation = THROW; + + // insert a potential simple key + InsertPotentialSimpleKey(); + + Mark mark = INPUT.mark(); + scalar = ScanScalar(INPUT, params); + + // can have a simple key only if we ended the scalar by starting a new line + m_simpleKeyAllowed = params.leadingSpaces; + m_canBeJSONFlow = false; + + // finally, check and see if we ended on an illegal character + // if(Exp::IllegalCharInScalar.Matches(INPUT)) + // throw ParserException(INPUT.mark(), ErrorMsg::CHAR_IN_SCALAR); + + Token token(Token::PLAIN_SCALAR, mark); + token.value = scalar; + m_tokens.push(token); +} + +// QuotedScalar +void Scanner::ScanQuotedScalar() { + std::string scalar; + + // peek at single or double quote (don't eat because we need to preserve (for + // the time being) the input position) + char quote = INPUT.peek(); + bool single = (quote == '\''); + + // setup the scanning parameters + ScanScalarParams params; + RegEx end = (single ? RegEx(quote) & !Exp::EscSingleQuote() : RegEx(quote)); + params.end = &end; + params.eatEnd = true; + params.escape = (single ? '\'' : '\\'); + params.indent = 0; + params.fold = FOLD_FLOW; + params.eatLeadingWhitespace = true; + params.trimTrailingSpaces = false; + params.chomp = CLIP; + params.onDocIndicator = THROW; + + // insert a potential simple key + InsertPotentialSimpleKey(); + + Mark mark = INPUT.mark(); + + // now eat that opening quote + INPUT.get(); + + // and scan + scalar = ScanScalar(INPUT, params); + m_simpleKeyAllowed = false; + m_canBeJSONFlow = true; + + Token token(Token::NON_PLAIN_SCALAR, mark); + token.value = scalar; + m_tokens.push(token); +} + +// BlockScalarToken +// . These need a little extra processing beforehand. +// . We need to scan the line where the indicator is (this doesn't count as part +// of the scalar), +// and then we need to figure out what level of indentation we'll be using. +void Scanner::ScanBlockScalar() { + std::string scalar; + + ScanScalarParams params; + params.indent = 1; + params.detectIndent = true; + + // eat block indicator ('|' or '>') + Mark mark = INPUT.mark(); + char indicator = INPUT.get(); + params.fold = (indicator == Keys::FoldedScalar ? FOLD_BLOCK : DONT_FOLD); + + // eat chomping/indentation indicators + params.chomp = CLIP; + int n = Exp::Chomp().Match(INPUT); + for (int i = 0; i < n; i++) { + char ch = INPUT.get(); + if (ch == '+') + params.chomp = KEEP; + else if (ch == '-') + params.chomp = STRIP; + else if (Exp::Digit().Matches(ch)) { + if (ch == '0') + throw ParserException(INPUT.mark(), ErrorMsg::ZERO_INDENT_IN_BLOCK); + + params.indent = ch - '0'; + params.detectIndent = false; + } + } + + // now eat whitespace + while (Exp::Blank().Matches(INPUT)) + INPUT.eat(1); + + // and comments to the end of the line + if (Exp::Comment().Matches(INPUT)) + while (INPUT && !Exp::Break().Matches(INPUT)) + INPUT.eat(1); + + // if it's not a line break, then we ran into a bad character inline + if (INPUT && !Exp::Break().Matches(INPUT)) + throw ParserException(INPUT.mark(), ErrorMsg::CHAR_IN_BLOCK); + + // set the initial indentation + if (GetTopIndent() >= 0) + params.indent += GetTopIndent(); + + params.eatLeadingWhitespace = false; + params.trimTrailingSpaces = false; + params.onTabInIndentation = THROW; + + scalar = ScanScalar(INPUT, params); + + // simple keys always ok after block scalars (since we're gonna start a new + // line anyways) + m_simpleKeyAllowed = true; + m_canBeJSONFlow = false; + + Token token(Token::NON_PLAIN_SCALAR, mark); + token.value = scalar; + m_tokens.push(token); +} +} // namespace YAML diff --git a/lib/yaml-cpp/src/setting.h b/lib/yaml-cpp/src/setting.h new file mode 100644 index 0000000000..4960bbf75c --- /dev/null +++ b/lib/yaml-cpp/src/setting.h @@ -0,0 +1,100 @@ +#ifndef SETTING_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define SETTING_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "yaml-cpp/noexcept.h" +#include +#include +#include + +namespace YAML { + +class SettingChangeBase { + public: + virtual ~SettingChangeBase() = default; + virtual void pop() = 0; +}; + +template +class Setting { + public: + Setting() : m_value() {} + Setting(const T& value) : m_value() { set(value); } + + const T get() const { return m_value; } + std::unique_ptr set(const T& value); + void restore(const Setting& oldSetting) { m_value = oldSetting.get(); } + + private: + T m_value; +}; + +template +class SettingChange : public SettingChangeBase { + public: + SettingChange(Setting* pSetting) + : m_pCurSetting(pSetting), + m_oldSetting(*pSetting) // copy old setting to save its state + {} + SettingChange(const SettingChange&) = delete; + SettingChange(SettingChange&&) = delete; + SettingChange& operator=(const SettingChange&) = delete; + SettingChange& operator=(SettingChange&&) = delete; + + void pop() override { m_pCurSetting->restore(m_oldSetting); } + + private: + Setting* m_pCurSetting; + Setting m_oldSetting; +}; + +template +inline std::unique_ptr Setting::set(const T& value) { + std::unique_ptr pChange(new SettingChange(this)); + m_value = value; + return pChange; +} + +class SettingChanges { + public: + SettingChanges() : m_settingChanges{} {} + SettingChanges(const SettingChanges&) = delete; + SettingChanges(SettingChanges&&) YAML_CPP_NOEXCEPT = default; + SettingChanges& operator=(const SettingChanges&) = delete; + SettingChanges& operator=(SettingChanges&& rhs) YAML_CPP_NOEXCEPT { + if (this == &rhs) + return *this; + + clear(); + std::swap(m_settingChanges, rhs.m_settingChanges); + + return *this; + } + ~SettingChanges() { clear(); } + + void clear() YAML_CPP_NOEXCEPT { + restore(); + m_settingChanges.clear(); + } + + void restore() YAML_CPP_NOEXCEPT { + for (const auto& setting : m_settingChanges) + setting->pop(); + } + + void push(std::unique_ptr pSettingChange) { + m_settingChanges.push_back(std::move(pSettingChange)); + } + + private: + using setting_changes = std::vector>; + setting_changes m_settingChanges; +}; +} // namespace YAML + +#endif // SETTING_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/src/simplekey.cpp b/lib/yaml-cpp/src/simplekey.cpp new file mode 100644 index 0000000000..67c2d712ef --- /dev/null +++ b/lib/yaml-cpp/src/simplekey.cpp @@ -0,0 +1,132 @@ +#include "scanner.h" +#include "token.h" + +namespace YAML { +struct Mark; + +Scanner::SimpleKey::SimpleKey(const Mark& mark_, std::size_t flowLevel_) + : mark(mark_), + flowLevel(flowLevel_), + pIndent(nullptr), + pMapStart(nullptr), + pKey(nullptr) {} + +void Scanner::SimpleKey::Validate() { + // Note: pIndent will *not* be garbage here; + // we "garbage collect" them so we can + // always refer to them + if (pIndent) + pIndent->status = IndentMarker::VALID; + if (pMapStart) + pMapStart->status = Token::VALID; + if (pKey) + pKey->status = Token::VALID; +} + +void Scanner::SimpleKey::Invalidate() { + if (pIndent) + pIndent->status = IndentMarker::INVALID; + if (pMapStart) + pMapStart->status = Token::INVALID; + if (pKey) + pKey->status = Token::INVALID; +} + +// CanInsertPotentialSimpleKey +bool Scanner::CanInsertPotentialSimpleKey() const { + if (!m_simpleKeyAllowed) + return false; + + return !ExistsActiveSimpleKey(); +} + +// ExistsActiveSimpleKey +// . Returns true if there's a potential simple key at our flow level +// (there's allowed at most one per flow level, i.e., at the start of the flow +// start token) +bool Scanner::ExistsActiveSimpleKey() const { + if (m_simpleKeys.empty()) + return false; + + const SimpleKey& key = m_simpleKeys.top(); + return key.flowLevel == GetFlowLevel(); +} + +// InsertPotentialSimpleKey +// . If we can, add a potential simple key to the queue, +// and save it on a stack. +void Scanner::InsertPotentialSimpleKey() { + if (!CanInsertPotentialSimpleKey()) + return; + + SimpleKey key(INPUT.mark(), GetFlowLevel()); + + // first add a map start, if necessary + if (InBlockContext()) { + key.pIndent = PushIndentTo(INPUT.column(), IndentMarker::MAP); + if (key.pIndent) { + key.pIndent->status = IndentMarker::UNKNOWN; + key.pMapStart = key.pIndent->pStartToken; + key.pMapStart->status = Token::UNVERIFIED; + } + } + + // then add the (now unverified) key + m_tokens.push(Token(Token::KEY, INPUT.mark())); + key.pKey = &m_tokens.back(); + key.pKey->status = Token::UNVERIFIED; + + m_simpleKeys.push(key); +} + +// InvalidateSimpleKey +// . Automatically invalidate the simple key in our flow level +void Scanner::InvalidateSimpleKey() { + if (m_simpleKeys.empty()) + return; + + // grab top key + SimpleKey& key = m_simpleKeys.top(); + if (key.flowLevel != GetFlowLevel()) + return; + + key.Invalidate(); + m_simpleKeys.pop(); +} + +// VerifySimpleKey +// . Determines whether the latest simple key to be added is valid, +// and if so, makes it valid. +bool Scanner::VerifySimpleKey() { + if (m_simpleKeys.empty()) + return false; + + // grab top key + SimpleKey key = m_simpleKeys.top(); + + // only validate if we're in the correct flow level + if (key.flowLevel != GetFlowLevel()) + return false; + + m_simpleKeys.pop(); + + bool isValid = true; + + // needs to be less than 1024 characters and inline + if (INPUT.line() != key.mark.line || INPUT.pos() - key.mark.pos > 1024) + isValid = false; + + // invalidate key + if (isValid) + key.Validate(); + else + key.Invalidate(); + + return isValid; +} + +void Scanner::PopAllSimpleKeys() { + while (!m_simpleKeys.empty()) + m_simpleKeys.pop(); +} +} // namespace YAML diff --git a/lib/yaml-cpp/src/singledocparser.cpp b/lib/yaml-cpp/src/singledocparser.cpp new file mode 100644 index 0000000000..6bad448d90 --- /dev/null +++ b/lib/yaml-cpp/src/singledocparser.cpp @@ -0,0 +1,432 @@ +#include +#include +#include + +#include "collectionstack.h" // IWYU pragma: keep +#include "scanner.h" +#include "singledocparser.h" +#include "tag.h" +#include "token.h" +#include "yaml-cpp/depthguard.h" +#include "yaml-cpp/emitterstyle.h" +#include "yaml-cpp/eventhandler.h" +#include "yaml-cpp/exceptions.h" // IWYU pragma: keep +#include "yaml-cpp/mark.h" +#include "yaml-cpp/null.h" + +namespace YAML { +SingleDocParser::SingleDocParser(Scanner& scanner, const Directives& directives) + : m_scanner(scanner), + m_directives(directives), + m_pCollectionStack(new CollectionStack), + m_anchors{}, + m_curAnchor(0) {} + +SingleDocParser::~SingleDocParser() = default; + +// HandleDocument +// . Handles the next document +// . Throws a ParserException on error. +void SingleDocParser::HandleDocument(EventHandler& eventHandler) { + assert(!m_scanner.empty()); // guaranteed that there are tokens + assert(!m_curAnchor); + + eventHandler.OnDocumentStart(m_scanner.peek().mark); + + // eat doc start + if (m_scanner.peek().type == Token::DOC_START) + m_scanner.pop(); + + // recurse! + HandleNode(eventHandler); + + eventHandler.OnDocumentEnd(); + + // and finally eat any doc ends we see + while (!m_scanner.empty() && m_scanner.peek().type == Token::DOC_END) + m_scanner.pop(); +} + +void SingleDocParser::HandleNode(EventHandler& eventHandler) { + DepthGuard<500> depthguard(depth, m_scanner.mark(), ErrorMsg::BAD_FILE); + + // an empty node *is* a possibility + if (m_scanner.empty()) { + eventHandler.OnNull(m_scanner.mark(), NullAnchor); + return; + } + + // save location + Mark mark = m_scanner.peek().mark; + + // special case: a value node by itself must be a map, with no header + if (m_scanner.peek().type == Token::VALUE) { + eventHandler.OnMapStart(mark, "?", NullAnchor, EmitterStyle::Default); + HandleMap(eventHandler); + eventHandler.OnMapEnd(); + return; + } + + // special case: an alias node + if (m_scanner.peek().type == Token::ALIAS) { + eventHandler.OnAlias(mark, LookupAnchor(mark, m_scanner.peek().value)); + m_scanner.pop(); + return; + } + + std::string tag; + std::string anchor_name; + anchor_t anchor; + ParseProperties(tag, anchor, anchor_name); + + if (!anchor_name.empty()) + eventHandler.OnAnchor(mark, anchor_name); + + // after parsing properties, an empty node is again a possibility + if (m_scanner.empty()) { + eventHandler.OnNull(mark, anchor); + return; + } + + const Token& token = m_scanner.peek(); + + // add non-specific tags + if (tag.empty()) + tag = (token.type == Token::NON_PLAIN_SCALAR ? "!" : "?"); + + if (token.type == Token::PLAIN_SCALAR + && tag.compare("?") == 0 && IsNullString(token.value)) { + eventHandler.OnNull(mark, anchor); + m_scanner.pop(); + return; + } + + // now split based on what kind of node we should be + switch (token.type) { + case Token::PLAIN_SCALAR: + case Token::NON_PLAIN_SCALAR: + eventHandler.OnScalar(mark, tag, anchor, token.value); + m_scanner.pop(); + return; + case Token::FLOW_SEQ_START: + eventHandler.OnSequenceStart(mark, tag, anchor, EmitterStyle::Flow); + HandleSequence(eventHandler); + eventHandler.OnSequenceEnd(); + return; + case Token::BLOCK_SEQ_START: + eventHandler.OnSequenceStart(mark, tag, anchor, EmitterStyle::Block); + HandleSequence(eventHandler); + eventHandler.OnSequenceEnd(); + return; + case Token::FLOW_MAP_START: + eventHandler.OnMapStart(mark, tag, anchor, EmitterStyle::Flow); + HandleMap(eventHandler); + eventHandler.OnMapEnd(); + return; + case Token::BLOCK_MAP_START: + eventHandler.OnMapStart(mark, tag, anchor, EmitterStyle::Block); + HandleMap(eventHandler); + eventHandler.OnMapEnd(); + return; + case Token::KEY: + // compact maps can only go in a flow sequence + if (m_pCollectionStack->GetCurCollectionType() == + CollectionType::FlowSeq) { + eventHandler.OnMapStart(mark, tag, anchor, EmitterStyle::Flow); + HandleMap(eventHandler); + eventHandler.OnMapEnd(); + return; + } + break; + default: + break; + } + + if (tag == "?") + eventHandler.OnNull(mark, anchor); + else + eventHandler.OnScalar(mark, tag, anchor, ""); +} + +void SingleDocParser::HandleSequence(EventHandler& eventHandler) { + // split based on start token + switch (m_scanner.peek().type) { + case Token::BLOCK_SEQ_START: + HandleBlockSequence(eventHandler); + break; + case Token::FLOW_SEQ_START: + HandleFlowSequence(eventHandler); + break; + default: + break; + } +} + +void SingleDocParser::HandleBlockSequence(EventHandler& eventHandler) { + // eat start token + m_scanner.pop(); + m_pCollectionStack->PushCollectionType(CollectionType::BlockSeq); + + while (true) { + if (m_scanner.empty()) + throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_SEQ); + + Token token = m_scanner.peek(); + if (token.type != Token::BLOCK_ENTRY && token.type != Token::BLOCK_SEQ_END) + throw ParserException(token.mark, ErrorMsg::END_OF_SEQ); + + m_scanner.pop(); + if (token.type == Token::BLOCK_SEQ_END) + break; + + // check for null + if (!m_scanner.empty()) { + const Token& nextToken = m_scanner.peek(); + if (nextToken.type == Token::BLOCK_ENTRY || + nextToken.type == Token::BLOCK_SEQ_END) { + eventHandler.OnNull(nextToken.mark, NullAnchor); + continue; + } + } + + HandleNode(eventHandler); + } + + m_pCollectionStack->PopCollectionType(CollectionType::BlockSeq); +} + +void SingleDocParser::HandleFlowSequence(EventHandler& eventHandler) { + // eat start token + m_scanner.pop(); + m_pCollectionStack->PushCollectionType(CollectionType::FlowSeq); + + while (true) { + if (m_scanner.empty()) + throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_SEQ_FLOW); + + // first check for end + if (m_scanner.peek().type == Token::FLOW_SEQ_END) { + m_scanner.pop(); + break; + } + + // then read the node + HandleNode(eventHandler); + + if (m_scanner.empty()) + throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_SEQ_FLOW); + + // now eat the separator (or could be a sequence end, which we ignore - but + // if it's neither, then it's a bad node) + Token& token = m_scanner.peek(); + if (token.type == Token::FLOW_ENTRY) + m_scanner.pop(); + else if (token.type != Token::FLOW_SEQ_END) + throw ParserException(token.mark, ErrorMsg::END_OF_SEQ_FLOW); + } + + m_pCollectionStack->PopCollectionType(CollectionType::FlowSeq); +} + +void SingleDocParser::HandleMap(EventHandler& eventHandler) { + // split based on start token + switch (m_scanner.peek().type) { + case Token::BLOCK_MAP_START: + HandleBlockMap(eventHandler); + break; + case Token::FLOW_MAP_START: + HandleFlowMap(eventHandler); + break; + case Token::KEY: + HandleCompactMap(eventHandler); + break; + case Token::VALUE: + HandleCompactMapWithNoKey(eventHandler); + break; + default: + break; + } +} + +void SingleDocParser::HandleBlockMap(EventHandler& eventHandler) { + // eat start token + m_scanner.pop(); + m_pCollectionStack->PushCollectionType(CollectionType::BlockMap); + + while (true) { + if (m_scanner.empty()) + throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_MAP); + + Token token = m_scanner.peek(); + if (token.type != Token::KEY && token.type != Token::VALUE && + token.type != Token::BLOCK_MAP_END) + throw ParserException(token.mark, ErrorMsg::END_OF_MAP); + + if (token.type == Token::BLOCK_MAP_END) { + m_scanner.pop(); + break; + } + + // grab key (if non-null) + if (token.type == Token::KEY) { + m_scanner.pop(); + HandleNode(eventHandler); + } else { + eventHandler.OnNull(token.mark, NullAnchor); + } + + // now grab value (optional) + if (!m_scanner.empty() && m_scanner.peek().type == Token::VALUE) { + m_scanner.pop(); + HandleNode(eventHandler); + } else { + eventHandler.OnNull(token.mark, NullAnchor); + } + } + + m_pCollectionStack->PopCollectionType(CollectionType::BlockMap); +} + +void SingleDocParser::HandleFlowMap(EventHandler& eventHandler) { + // eat start token + m_scanner.pop(); + m_pCollectionStack->PushCollectionType(CollectionType::FlowMap); + + while (true) { + if (m_scanner.empty()) + throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_MAP_FLOW); + + Token& token = m_scanner.peek(); + const Mark mark = token.mark; + // first check for end + if (token.type == Token::FLOW_MAP_END) { + m_scanner.pop(); + break; + } + + // grab key (if non-null) + if (token.type == Token::KEY) { + m_scanner.pop(); + HandleNode(eventHandler); + } else { + eventHandler.OnNull(mark, NullAnchor); + } + + // now grab value (optional) + if (!m_scanner.empty() && m_scanner.peek().type == Token::VALUE) { + m_scanner.pop(); + HandleNode(eventHandler); + } else { + eventHandler.OnNull(mark, NullAnchor); + } + + if (m_scanner.empty()) + throw ParserException(m_scanner.mark(), ErrorMsg::END_OF_MAP_FLOW); + + // now eat the separator (or could be a map end, which we ignore - but if + // it's neither, then it's a bad node) + Token& nextToken = m_scanner.peek(); + if (nextToken.type == Token::FLOW_ENTRY) + m_scanner.pop(); + else if (nextToken.type != Token::FLOW_MAP_END) + throw ParserException(nextToken.mark, ErrorMsg::END_OF_MAP_FLOW); + } + + m_pCollectionStack->PopCollectionType(CollectionType::FlowMap); +} + +// . Single "key: value" pair in a flow sequence +void SingleDocParser::HandleCompactMap(EventHandler& eventHandler) { + m_pCollectionStack->PushCollectionType(CollectionType::CompactMap); + + // grab key + Mark mark = m_scanner.peek().mark; + m_scanner.pop(); + HandleNode(eventHandler); + + // now grab value (optional) + if (!m_scanner.empty() && m_scanner.peek().type == Token::VALUE) { + m_scanner.pop(); + HandleNode(eventHandler); + } else { + eventHandler.OnNull(mark, NullAnchor); + } + + m_pCollectionStack->PopCollectionType(CollectionType::CompactMap); +} + +// . Single ": value" pair in a flow sequence +void SingleDocParser::HandleCompactMapWithNoKey(EventHandler& eventHandler) { + m_pCollectionStack->PushCollectionType(CollectionType::CompactMap); + + // null key + eventHandler.OnNull(m_scanner.peek().mark, NullAnchor); + + // grab value + m_scanner.pop(); + HandleNode(eventHandler); + + m_pCollectionStack->PopCollectionType(CollectionType::CompactMap); +} + +// ParseProperties +// . Grabs any tag or anchor tokens and deals with them. +void SingleDocParser::ParseProperties(std::string& tag, anchor_t& anchor, + std::string& anchor_name) { + tag.clear(); + anchor_name.clear(); + anchor = NullAnchor; + + while (true) { + if (m_scanner.empty()) + return; + + switch (m_scanner.peek().type) { + case Token::TAG: + ParseTag(tag); + break; + case Token::ANCHOR: + ParseAnchor(anchor, anchor_name); + break; + default: + return; + } + } +} + +void SingleDocParser::ParseTag(std::string& tag) { + Token& token = m_scanner.peek(); + if (!tag.empty()) + throw ParserException(token.mark, ErrorMsg::MULTIPLE_TAGS); + + Tag tagInfo(token); + tag = tagInfo.Translate(m_directives); + m_scanner.pop(); +} + +void SingleDocParser::ParseAnchor(anchor_t& anchor, std::string& anchor_name) { + Token& token = m_scanner.peek(); + if (anchor) + throw ParserException(token.mark, ErrorMsg::MULTIPLE_ANCHORS); + + anchor_name = token.value; + anchor = RegisterAnchor(token.value); + m_scanner.pop(); +} + +anchor_t SingleDocParser::RegisterAnchor(const std::string& name) { + if (name.empty()) + return NullAnchor; + + return m_anchors[name] = ++m_curAnchor; +} + +anchor_t SingleDocParser::LookupAnchor(const Mark& mark, + const std::string& name) const { + auto it = m_anchors.find(name); + if (it == m_anchors.end()) + throw ParserException(mark, ErrorMsg::UNKNOWN_ANCHOR); + + return it->second; +} +} // namespace YAML diff --git a/lib/yaml-cpp/src/singledocparser.h b/lib/yaml-cpp/src/singledocparser.h new file mode 100644 index 0000000000..f484eb1f95 --- /dev/null +++ b/lib/yaml-cpp/src/singledocparser.h @@ -0,0 +1,71 @@ +#ifndef SINGLEDOCPARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define SINGLEDOCPARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include +#include +#include + +#include "yaml-cpp/anchor.h" + +namespace YAML { +class CollectionStack; +template class DepthGuard; // depthguard.h +class EventHandler; +class Node; +class Scanner; +struct Directives; +struct Mark; +struct Token; + +class SingleDocParser { + public: + SingleDocParser(Scanner& scanner, const Directives& directives); + SingleDocParser(const SingleDocParser&) = delete; + SingleDocParser(SingleDocParser&&) = delete; + SingleDocParser& operator=(const SingleDocParser&) = delete; + SingleDocParser& operator=(SingleDocParser&&) = delete; + ~SingleDocParser(); + + void HandleDocument(EventHandler& eventHandler); + + private: + void HandleNode(EventHandler& eventHandler); + + void HandleSequence(EventHandler& eventHandler); + void HandleBlockSequence(EventHandler& eventHandler); + void HandleFlowSequence(EventHandler& eventHandler); + + void HandleMap(EventHandler& eventHandler); + void HandleBlockMap(EventHandler& eventHandler); + void HandleFlowMap(EventHandler& eventHandler); + void HandleCompactMap(EventHandler& eventHandler); + void HandleCompactMapWithNoKey(EventHandler& eventHandler); + + void ParseProperties(std::string& tag, anchor_t& anchor, + std::string& anchor_name); + void ParseTag(std::string& tag); + void ParseAnchor(anchor_t& anchor, std::string& anchor_name); + + anchor_t RegisterAnchor(const std::string& name); + anchor_t LookupAnchor(const Mark& mark, const std::string& name) const; + + private: + int depth = 0; + Scanner& m_scanner; + const Directives& m_directives; + std::unique_ptr m_pCollectionStack; + + using Anchors = std::map; + Anchors m_anchors; + + anchor_t m_curAnchor; +}; +} // namespace YAML + +#endif // SINGLEDOCPARSER_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/src/stream.cpp b/lib/yaml-cpp/src/stream.cpp new file mode 100644 index 0000000000..b1aa092f69 --- /dev/null +++ b/lib/yaml-cpp/src/stream.cpp @@ -0,0 +1,446 @@ +#include + +#include "stream.h" + +#ifndef YAML_PREFETCH_SIZE +#define YAML_PREFETCH_SIZE 2048 +#endif + +#define S_ARRAY_SIZE(A) (sizeof(A) / sizeof(*(A))) +#define S_ARRAY_END(A) ((A) + S_ARRAY_SIZE(A)) + +#define CP_REPLACEMENT_CHARACTER (0xFFFD) + +namespace YAML { +enum UtfIntroState { + uis_start, + uis_utfbe_b1, + uis_utf32be_b2, + uis_utf32be_bom3, + uis_utf32be, + uis_utf16be, + uis_utf16be_bom1, + uis_utfle_bom1, + uis_utf16le_bom2, + uis_utf32le_bom3, + uis_utf16le, + uis_utf32le, + uis_utf8_imp, + uis_utf16le_imp, + uis_utf32le_imp3, + uis_utf8_bom1, + uis_utf8_bom2, + uis_utf8, + uis_error +}; + +enum UtfIntroCharType { + uict00, + uictBB, + uictBF, + uictEF, + uictFE, + uictFF, + uictAscii, + uictOther, + uictMax +}; + +static bool s_introFinalState[] = { + false, // uis_start + false, // uis_utfbe_b1 + false, // uis_utf32be_b2 + false, // uis_utf32be_bom3 + true, // uis_utf32be + true, // uis_utf16be + false, // uis_utf16be_bom1 + false, // uis_utfle_bom1 + false, // uis_utf16le_bom2 + false, // uis_utf32le_bom3 + true, // uis_utf16le + true, // uis_utf32le + false, // uis_utf8_imp + false, // uis_utf16le_imp + false, // uis_utf32le_imp3 + false, // uis_utf8_bom1 + false, // uis_utf8_bom2 + true, // uis_utf8 + true, // uis_error +}; + +static UtfIntroState s_introTransitions[][uictMax] = { + // uict00, uictBB, uictBF, uictEF, + // uictFE, uictFF, uictAscii, uictOther + {uis_utfbe_b1, uis_utf8, uis_utf8, uis_utf8_bom1, uis_utf16be_bom1, + uis_utfle_bom1, uis_utf8_imp, uis_utf8}, + {uis_utf32be_b2, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, + uis_utf16be, uis_utf8}, + {uis_utf32be, uis_utf8, uis_utf8, uis_utf8, uis_utf32be_bom3, uis_utf8, + uis_utf8, uis_utf8}, + {uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf32be, uis_utf8, + uis_utf8}, + {uis_utf32be, uis_utf32be, uis_utf32be, uis_utf32be, uis_utf32be, + uis_utf32be, uis_utf32be, uis_utf32be}, + {uis_utf16be, uis_utf16be, uis_utf16be, uis_utf16be, uis_utf16be, + uis_utf16be, uis_utf16be, uis_utf16be}, + {uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf16be, uis_utf8, + uis_utf8}, + {uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf16le_bom2, uis_utf8, + uis_utf8, uis_utf8}, + {uis_utf32le_bom3, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, + uis_utf16le, uis_utf16le, uis_utf16le}, + {uis_utf32le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, + uis_utf16le, uis_utf16le, uis_utf16le}, + {uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, + uis_utf16le, uis_utf16le, uis_utf16le}, + {uis_utf32le, uis_utf32le, uis_utf32le, uis_utf32le, uis_utf32le, + uis_utf32le, uis_utf32le, uis_utf32le}, + {uis_utf16le_imp, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, + uis_utf8, uis_utf8}, + {uis_utf32le_imp3, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, + uis_utf16le, uis_utf16le, uis_utf16le}, + {uis_utf32le, uis_utf16le, uis_utf16le, uis_utf16le, uis_utf16le, + uis_utf16le, uis_utf16le, uis_utf16le}, + {uis_utf8, uis_utf8_bom2, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, + uis_utf8}, + {uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, + uis_utf8}, + {uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, uis_utf8, + uis_utf8}, +}; + +static char s_introUngetCount[][uictMax] = { + // uict00, uictBB, uictBF, uictEF, uictFE, uictFF, uictAscii, uictOther + {0, 1, 1, 0, 0, 0, 0, 1}, {0, 2, 2, 2, 2, 2, 2, 2}, + {3, 3, 3, 3, 0, 3, 3, 3}, {4, 4, 4, 4, 4, 0, 4, 4}, + {1, 1, 1, 1, 1, 1, 1, 1}, {1, 1, 1, 1, 1, 1, 1, 1}, + {2, 2, 2, 2, 2, 0, 2, 2}, {2, 2, 2, 2, 0, 2, 2, 2}, + {0, 1, 1, 1, 1, 1, 1, 1}, {0, 2, 2, 2, 2, 2, 2, 2}, + {1, 1, 1, 1, 1, 1, 1, 1}, {1, 1, 1, 1, 1, 1, 1, 1}, + {0, 2, 2, 2, 2, 2, 2, 2}, {0, 3, 3, 3, 3, 3, 3, 3}, + {4, 4, 4, 4, 4, 4, 4, 4}, {2, 0, 2, 2, 2, 2, 2, 2}, + {3, 3, 0, 3, 3, 3, 3, 3}, {1, 1, 1, 1, 1, 1, 1, 1}, +}; + +inline UtfIntroCharType IntroCharTypeOf(std::istream::int_type ch) { + if (std::istream::traits_type::eof() == ch) { + return uictOther; + } + + switch (ch) { + case 0: + return uict00; + case 0xBB: + return uictBB; + case 0xBF: + return uictBF; + case 0xEF: + return uictEF; + case 0xFE: + return uictFE; + case 0xFF: + return uictFF; + } + + if ((ch > 0) && (ch < 0xFF)) { + return uictAscii; + } + + return uictOther; +} + +inline char Utf8Adjust(unsigned long ch, unsigned char lead_bits, + unsigned char rshift) { + const unsigned char header = + static_cast(((1 << lead_bits) - 1) << (8 - lead_bits)); + const unsigned char mask = (0xFF >> (lead_bits + 1)); + return static_cast( + static_cast(header | ((ch >> rshift) & mask))); +} + +inline void QueueUnicodeCodepoint(std::deque& q, unsigned long ch) { + // We are not allowed to queue the Stream::eof() codepoint, so + // replace it with CP_REPLACEMENT_CHARACTER + if (static_cast(Stream::eof()) == ch) { + ch = CP_REPLACEMENT_CHARACTER; + } + + if (ch < 0x80) { + q.push_back(Utf8Adjust(ch, 0, 0)); + } else if (ch < 0x800) { + q.push_back(Utf8Adjust(ch, 2, 6)); + q.push_back(Utf8Adjust(ch, 1, 0)); + } else if (ch < 0x10000) { + q.push_back(Utf8Adjust(ch, 3, 12)); + q.push_back(Utf8Adjust(ch, 1, 6)); + q.push_back(Utf8Adjust(ch, 1, 0)); + } else { + q.push_back(Utf8Adjust(ch, 4, 18)); + q.push_back(Utf8Adjust(ch, 1, 12)); + q.push_back(Utf8Adjust(ch, 1, 6)); + q.push_back(Utf8Adjust(ch, 1, 0)); + } +} + +Stream::Stream(std::istream& input) + : m_input(input), + m_mark{}, + m_charSet{}, + m_readahead{}, + m_pPrefetched(new unsigned char[YAML_PREFETCH_SIZE]), + m_nPrefetchedAvailable(0), + m_nPrefetchedUsed(0) { + using char_traits = std::istream::traits_type; + + if (!input) + return; + + // Determine (or guess) the character-set by reading the BOM, if any. See + // the YAML specification for the determination algorithm. + char_traits::int_type intro[4]{}; + int nIntroUsed = 0; + UtfIntroState state = uis_start; + for (; !s_introFinalState[state];) { + std::istream::int_type ch = input.get(); + intro[nIntroUsed++] = ch; + UtfIntroCharType charType = IntroCharTypeOf(ch); + UtfIntroState newState = s_introTransitions[state][charType]; + int nUngets = s_introUngetCount[state][charType]; + if (nUngets > 0) { + input.clear(); + for (; nUngets > 0; --nUngets) { + if (char_traits::eof() != intro[--nIntroUsed]) + input.putback(char_traits::to_char_type(intro[nIntroUsed])); + } + } + state = newState; + } + + switch (state) { + case uis_utf8: + m_charSet = utf8; + break; + case uis_utf16le: + m_charSet = utf16le; + break; + case uis_utf16be: + m_charSet = utf16be; + break; + case uis_utf32le: + m_charSet = utf32le; + break; + case uis_utf32be: + m_charSet = utf32be; + break; + default: + m_charSet = utf8; + break; + } + + ReadAheadTo(0); +} + +Stream::~Stream() { delete[] m_pPrefetched; } + +char Stream::peek() const { + if (m_readahead.empty()) { + return Stream::eof(); + } + + return m_readahead[0]; +} + +Stream::operator bool() const { + return m_input.good() || + (!m_readahead.empty() && m_readahead[0] != Stream::eof()); +} + +// get +// . Extracts a character from the stream and updates our position +char Stream::get() { + char ch = peek(); + AdvanceCurrent(); + m_mark.column++; + + if (ch == '\n') { + m_mark.column = 0; + m_mark.line++; + } + + return ch; +} + +// get +// . Extracts 'n' characters from the stream and updates our position +std::string Stream::get(int n) { + std::string ret; + if (n > 0) { + ret.reserve(static_cast(n)); + for (int i = 0; i < n; i++) + ret += get(); + } + return ret; +} + +// eat +// . Eats 'n' characters and updates our position. +void Stream::eat(int n) { + for (int i = 0; i < n; i++) + get(); +} + +void Stream::AdvanceCurrent() { + if (!m_readahead.empty()) { + m_readahead.pop_front(); + m_mark.pos++; + } + + ReadAheadTo(0); +} + +bool Stream::_ReadAheadTo(size_t i) const { + while (m_input.good() && (m_readahead.size() <= i)) { + switch (m_charSet) { + case utf8: + StreamInUtf8(); + break; + case utf16le: + StreamInUtf16(); + break; + case utf16be: + StreamInUtf16(); + break; + case utf32le: + StreamInUtf32(); + break; + case utf32be: + StreamInUtf32(); + break; + } + } + + // signal end of stream + if (!m_input.good()) + m_readahead.push_back(Stream::eof()); + + return m_readahead.size() > i; +} + +void Stream::StreamInUtf8() const { + unsigned char b = GetNextByte(); + if (m_input.good()) { + m_readahead.push_back(static_cast(b)); + } +} + +void Stream::StreamInUtf16() const { + unsigned long ch = 0; + unsigned char bytes[2]; + int nBigEnd = (m_charSet == utf16be) ? 0 : 1; + + bytes[0] = GetNextByte(); + bytes[1] = GetNextByte(); + if (!m_input.good()) { + return; + } + ch = (static_cast(bytes[nBigEnd]) << 8) | + static_cast(bytes[1 ^ nBigEnd]); + + if (ch >= 0xDC00 && ch < 0xE000) { + // Trailing (low) surrogate...ugh, wrong order + QueueUnicodeCodepoint(m_readahead, CP_REPLACEMENT_CHARACTER); + return; + } + + if (ch >= 0xD800 && ch < 0xDC00) { + // ch is a leading (high) surrogate + + // Four byte UTF-8 code point + + // Read the trailing (low) surrogate + for (;;) { + bytes[0] = GetNextByte(); + bytes[1] = GetNextByte(); + if (!m_input.good()) { + QueueUnicodeCodepoint(m_readahead, CP_REPLACEMENT_CHARACTER); + return; + } + unsigned long chLow = (static_cast(bytes[nBigEnd]) << 8) | + static_cast(bytes[1 ^ nBigEnd]); + if (chLow < 0xDC00 || chLow >= 0xE000) { + // Trouble...not a low surrogate. Dump a REPLACEMENT CHARACTER into the + // stream. + QueueUnicodeCodepoint(m_readahead, CP_REPLACEMENT_CHARACTER); + + // Deal with the next UTF-16 unit + if (chLow < 0xD800 || chLow >= 0xE000) { + // Easiest case: queue the codepoint and return + QueueUnicodeCodepoint(m_readahead, ch); + return; + } + // Start the loop over with the new high surrogate + ch = chLow; + continue; + } + + // Select the payload bits from the high surrogate + ch &= 0x3FF; + ch <<= 10; + + // Include bits from low surrogate + ch |= (chLow & 0x3FF); + + // Add the surrogacy offset + ch += 0x10000; + break; + } + } + + QueueUnicodeCodepoint(m_readahead, ch); +} + +inline char* ReadBuffer(unsigned char* pBuffer) { + return reinterpret_cast(pBuffer); +} + +unsigned char Stream::GetNextByte() const { + if (m_nPrefetchedUsed >= m_nPrefetchedAvailable) { + std::streambuf* pBuf = m_input.rdbuf(); + m_nPrefetchedAvailable = static_cast( + pBuf->sgetn(ReadBuffer(m_pPrefetched), YAML_PREFETCH_SIZE)); + m_nPrefetchedUsed = 0; + if (!m_nPrefetchedAvailable) { + m_input.setstate(std::ios_base::eofbit); + } + + if (0 == m_nPrefetchedAvailable) { + return 0; + } + } + + return m_pPrefetched[m_nPrefetchedUsed++]; +} + +void Stream::StreamInUtf32() const { + static int indexes[2][4] = {{3, 2, 1, 0}, {0, 1, 2, 3}}; + + unsigned long ch = 0; + unsigned char bytes[4]; + int* pIndexes = (m_charSet == utf32be) ? indexes[1] : indexes[0]; + + bytes[0] = GetNextByte(); + bytes[1] = GetNextByte(); + bytes[2] = GetNextByte(); + bytes[3] = GetNextByte(); + if (!m_input.good()) { + return; + } + + for (int i = 0; i < 4; ++i) { + ch <<= 8; + ch |= bytes[pIndexes[i]]; + } + + QueueUnicodeCodepoint(m_readahead, ch); +} +} // namespace YAML diff --git a/lib/yaml-cpp/src/stream.h b/lib/yaml-cpp/src/stream.h new file mode 100644 index 0000000000..2bc7a15216 --- /dev/null +++ b/lib/yaml-cpp/src/stream.h @@ -0,0 +1,82 @@ +#ifndef STREAM_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define STREAM_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "yaml-cpp/mark.h" +#include +#include +#include +#include +#include +#include + +namespace YAML { + +class StreamCharSource; + +class Stream { + public: + friend class StreamCharSource; + + Stream(std::istream& input); + Stream(const Stream&) = delete; + Stream(Stream&&) = delete; + Stream& operator=(const Stream&) = delete; + Stream& operator=(Stream&&) = delete; + ~Stream(); + + operator bool() const; + bool operator!() const { return !static_cast(*this); } + + char peek() const; + char get(); + std::string get(int n); + void eat(int n = 1); + + static char eof() { return 0x04; } + + const Mark mark() const { return m_mark; } + int pos() const { return m_mark.pos; } + int line() const { return m_mark.line; } + int column() const { return m_mark.column; } + void ResetColumn() { m_mark.column = 0; } + + private: + enum CharacterSet { utf8, utf16le, utf16be, utf32le, utf32be }; + + std::istream& m_input; + Mark m_mark; + + CharacterSet m_charSet; + mutable std::deque m_readahead; + unsigned char* const m_pPrefetched; + mutable size_t m_nPrefetchedAvailable; + mutable size_t m_nPrefetchedUsed; + + void AdvanceCurrent(); + char CharAt(size_t i) const; + bool ReadAheadTo(size_t i) const; + bool _ReadAheadTo(size_t i) const; + void StreamInUtf8() const; + void StreamInUtf16() const; + void StreamInUtf32() const; + unsigned char GetNextByte() const; +}; + +// CharAt +// . Unchecked access +inline char Stream::CharAt(size_t i) const { return m_readahead[i]; } + +inline bool Stream::ReadAheadTo(size_t i) const { + if (m_readahead.size() > i) + return true; + return _ReadAheadTo(i); +} +} // namespace YAML + +#endif // STREAM_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/src/streamcharsource.h b/lib/yaml-cpp/src/streamcharsource.h new file mode 100644 index 0000000000..826ba5347e --- /dev/null +++ b/lib/yaml-cpp/src/streamcharsource.h @@ -0,0 +1,50 @@ +#ifndef STREAMCHARSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define STREAMCHARSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "yaml-cpp/noexcept.h" +#include "stream.h" +#include + +namespace YAML { + +class StreamCharSource { + public: + StreamCharSource(const Stream& stream) : m_offset(0), m_stream(stream) {} + StreamCharSource(const StreamCharSource& source) = default; + StreamCharSource(StreamCharSource&&) YAML_CPP_NOEXCEPT = default; + StreamCharSource& operator=(const StreamCharSource&) = delete; + StreamCharSource& operator=(StreamCharSource&&) = delete; + ~StreamCharSource() = default; + + operator bool() const; + char operator[](std::size_t i) const { return m_stream.CharAt(m_offset + i); } + bool operator!() const { return !static_cast(*this); } + + const StreamCharSource operator+(int i) const; + + private: + std::size_t m_offset; + const Stream& m_stream; +}; + +inline StreamCharSource::operator bool() const { + return m_stream.ReadAheadTo(m_offset); +} + +inline const StreamCharSource StreamCharSource::operator+(int i) const { + StreamCharSource source(*this); + if (static_cast(source.m_offset) + i >= 0) + source.m_offset += static_cast(i); + else + source.m_offset = 0; + return source; +} +} // namespace YAML + +#endif // STREAMCHARSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/src/stringsource.h b/lib/yaml-cpp/src/stringsource.h new file mode 100644 index 0000000000..6fee44bb28 --- /dev/null +++ b/lib/yaml-cpp/src/stringsource.h @@ -0,0 +1,48 @@ +#ifndef STRINGSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define STRINGSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include + +namespace YAML { +class StringCharSource { + public: + StringCharSource(const char* str, std::size_t size) + : m_str(str), m_size(size), m_offset(0) {} + + operator bool() const { return m_offset < m_size; } + char operator[](std::size_t i) const { return m_str[m_offset + i]; } + bool operator!() const { return !static_cast(*this); } + + const StringCharSource operator+(int i) const { + StringCharSource source(*this); + if (static_cast(source.m_offset) + i >= 0) + source.m_offset += i; + else + source.m_offset = 0; + return source; + } + + StringCharSource& operator++() { + ++m_offset; + return *this; + } + + StringCharSource& operator+=(std::size_t offset) { + m_offset += offset; + return *this; + } + + private: + const char* m_str; + std::size_t m_size; + std::size_t m_offset; +}; +} + +#endif // STRINGSOURCE_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/src/tag.cpp b/lib/yaml-cpp/src/tag.cpp new file mode 100644 index 0000000000..df8a2cf461 --- /dev/null +++ b/lib/yaml-cpp/src/tag.cpp @@ -0,0 +1,50 @@ +#include +#include + +#include "directives.h" // IWYU pragma: keep +#include "tag.h" +#include "token.h" + +namespace YAML { +Tag::Tag(const Token& token) + : type(static_cast(token.data)), handle{}, value{} { + switch (type) { + case VERBATIM: + value = token.value; + break; + case PRIMARY_HANDLE: + value = token.value; + break; + case SECONDARY_HANDLE: + value = token.value; + break; + case NAMED_HANDLE: + handle = token.value; + value = token.params[0]; + break; + case NON_SPECIFIC: + break; + default: + assert(false); + } +} + +const std::string Tag::Translate(const Directives& directives) { + switch (type) { + case VERBATIM: + return value; + case PRIMARY_HANDLE: + return directives.TranslateTagHandle("!") + value; + case SECONDARY_HANDLE: + return directives.TranslateTagHandle("!!") + value; + case NAMED_HANDLE: + return directives.TranslateTagHandle("!" + handle + "!") + value; + case NON_SPECIFIC: + // TODO: + return "!"; + default: + assert(false); + } + throw std::runtime_error("yaml-cpp: internal error, bad tag type"); +} +} // namespace YAML diff --git a/lib/yaml-cpp/src/tag.h b/lib/yaml-cpp/src/tag.h new file mode 100644 index 0000000000..ac30673b9e --- /dev/null +++ b/lib/yaml-cpp/src/tag.h @@ -0,0 +1,33 @@ +#ifndef TAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define TAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include + +namespace YAML { +struct Directives; +struct Token; + +struct Tag { + enum TYPE { + VERBATIM, + PRIMARY_HANDLE, + SECONDARY_HANDLE, + NAMED_HANDLE, + NON_SPECIFIC + }; + + Tag(const Token& token); + const std::string Translate(const Directives& directives); + + TYPE type; + std::string handle, value; +}; +} + +#endif // TAG_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/src/token.h b/lib/yaml-cpp/src/token.h new file mode 100644 index 0000000000..9c9a5b7798 --- /dev/null +++ b/lib/yaml-cpp/src/token.h @@ -0,0 +1,70 @@ +#ifndef TOKEN_H_62B23520_7C8E_11DE_8A39_0800200C9A66 +#define TOKEN_H_62B23520_7C8E_11DE_8A39_0800200C9A66 + +#if defined(_MSC_VER) || \ + (defined(__GNUC__) && (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) || \ + (__GNUC__ >= 4)) // GCC supports "pragma once" correctly since 3.4 +#pragma once +#endif + +#include "yaml-cpp/mark.h" +#include +#include +#include + +namespace YAML { +const std::string TokenNames[] = { + "DIRECTIVE", "DOC_START", "DOC_END", "BLOCK_SEQ_START", + "BLOCK_MAP_START", "BLOCK_SEQ_END", "BLOCK_MAP_END", "BLOCK_ENTRY", + "FLOW_SEQ_START", "FLOW_MAP_START", "FLOW_SEQ_END", "FLOW_MAP_END", + "FLOW_MAP_COMPACT", "FLOW_ENTRY", "KEY", "VALUE", + "ANCHOR", "ALIAS", "TAG", "SCALAR"}; + +struct Token { + // enums + enum STATUS { VALID, INVALID, UNVERIFIED }; + enum TYPE { + DIRECTIVE, + DOC_START, + DOC_END, + BLOCK_SEQ_START, + BLOCK_MAP_START, + BLOCK_SEQ_END, + BLOCK_MAP_END, + BLOCK_ENTRY, + FLOW_SEQ_START, + FLOW_MAP_START, + FLOW_SEQ_END, + FLOW_MAP_END, + FLOW_MAP_COMPACT, + FLOW_ENTRY, + KEY, + VALUE, + ANCHOR, + ALIAS, + TAG, + PLAIN_SCALAR, + NON_PLAIN_SCALAR + }; + + // data + Token(TYPE type_, const Mark& mark_) + : status(VALID), type(type_), mark(mark_), value{}, params{}, data(0) {} + + friend std::ostream& operator<<(std::ostream& out, const Token& token) { + out << TokenNames[token.type] << std::string(": ") << token.value; + for (const std::string& param : token.params) + out << std::string(" ") << param; + return out; + } + + STATUS status; + TYPE type; + Mark mark; + std::string value; + std::vector params; + int data; +}; +} // namespace YAML + +#endif // TOKEN_H_62B23520_7C8E_11DE_8A39_0800200C9A66 diff --git a/lib/yaml-cpp/util/CMakeLists.txt b/lib/yaml-cpp/util/CMakeLists.txt new file mode 100644 index 0000000000..87ea4f91ee --- /dev/null +++ b/lib/yaml-cpp/util/CMakeLists.txt @@ -0,0 +1,32 @@ +add_executable(yaml-cpp-sandbox sandbox.cpp) +add_executable(yaml-cpp-parse parse.cpp) +add_executable(yaml-cpp-read read.cpp) + +target_link_libraries(yaml-cpp-sandbox PRIVATE yaml-cpp) +target_link_libraries(yaml-cpp-parse PRIVATE yaml-cpp) +target_link_libraries(yaml-cpp-read PRIVATE yaml-cpp) + +set_property(TARGET yaml-cpp-sandbox PROPERTY OUTPUT_NAME sandbox) +set_property(TARGET yaml-cpp-parse PROPERTY OUTPUT_NAME parse) +set_property(TARGET yaml-cpp-read PROPERTY OUTPUT_NAME read) + +set_target_properties(yaml-cpp-sandbox + PROPERTIES + CXX_STANDARD_REQUIRED ON + OUTPUT_NAME sandbox) + +set_target_properties(yaml-cpp-parse + PROPERTIES + CXX_STANDARD_REQUIRED ON + OUTPUT_NAME parse) + +set_target_properties(yaml-cpp-read + PROPERTIES + CXX_STANDARD_REQUIRED ON + OUTPUT_NAME read) + +if (NOT DEFINED CMAKE_CXX_STANDARD) + set_target_properties(yaml-cpp-sandbox yaml-cpp-parse yaml-cpp-read + PROPERTIES + CXX_STANDARD 11) +endif() diff --git a/lib/yaml-cpp/util/api.cpp b/lib/yaml-cpp/util/api.cpp new file mode 100644 index 0000000000..8ae5ff2978 --- /dev/null +++ b/lib/yaml-cpp/util/api.cpp @@ -0,0 +1,137 @@ +// a sketch of what the new API might look like + +#include "yaml-cpp/yaml.h" +#include + +int main() { + { + // test.yaml + // - foo + // - primes: [2, 3, 5, 7, 11] + // odds: [1, 3, 5, 7, 9, 11] + // - [x, y] + + // move-like semantics + YAML::Value root = YAML::Parse("test.yaml"); + + std::cout << root[0].as(); // "foo" + std::cout << str(root[0]); // "foo", shorthand? + std::cout << root[1]["primes"][3].as(); // "7" + std::cout << root[1]["odds"][6].as(); // throws? + + root[2].push_back(5); + root[3] = "Hello, World"; + root[0].reset(); + root[0]["key"] = "value"; + + std::cout << root; + // # not sure about formatting + // - {key: value} + // - primes: [2, 3, 5, 7, 11] + // odds: [1, 3, 5, 7, 9, 11] + // - [x, y, 5] + // - Hello, World + } + + { + // for all copy-like commands, think of python's "name/value" semantics + YAML::Value root = "Hello"; // Hello + root = YAML::Sequence(); // [] + root[0] = 0; // [0] + root[2] = "two"; // [0, ~, two] # forces root[1] to be initialized to null + + YAML::Value other = root; // both point to the same thing + other[0] = 5; // now root[0] is 0 also + other.push_back(root); // &1 [5, ~, two, *1] + other[3][0] = 0; // &1 [0, ~, two, *1] # since it's a true alias + other.push_back(Copy(root)); // &1 [0, ~, two, *1, &2 [0, ~, two, *2]] + other[4][0] = 5; // &1 [0, ~, two, *1, &2 [5, ~, two, *2]] # they're + // really different + } + + { + YAML::Value node; // ~ + node[0] = 1; // [1] # auto-construct a sequence + node["key"] = 5; // {0: 1, key: 5} # auto-turn it into a map + node.push_back(10); // error, can't turn a map into a sequence + node.erase("key"); // {0: 1} # still a map, even if we remove the key that + // caused the problem + node = "Hello"; // Hello # assignment overwrites everything, so it's now + // just a plain scalar + } + + { + YAML::Value map; // ~ + map[3] = 1; // {3: 1} # auto-constructs a map, *not* a sequence + + YAML::Value seq; // ~ + seq = YAML::Sequence(); // [] + seq[3] = 1; // [~, ~, ~, 1] + } + + { + YAML::Value node; // ~ + node[0] = node; // &1 [*1] # fun stuff + } + + { + YAML::Value node; + YAML::Value subnode = + node["key"]; // 'subnode' is not instantiated ('node' is still null) + subnode = "value"; // {key: value} # now it is + YAML::Value subnode2 = node["key2"]; + node["key3"] = subnode2; // subnode2 is still not instantiated, but + // node["key3"] is "pseudo" aliased to it + subnode2 = "monkey"; // {key: value, key2: &1 monkey, key3: *1} # bam! it + // instantiates both + } + + { + YAML::Value seq = YAML::Sequence(); + seq[0] = "zero"; // [zero] + seq[1] = seq[0]; // [&1 zero, *1] + seq[0] = seq[1]; // [&1 zero, *1] # no-op (they both alias the same thing, + // so setting them equal is nothing) + Is(seq[0], seq[1]); // true + seq[1] = "one"; // [&1 one, *1] + UnAlias(seq[1]); // [one, one] + Is(seq[0], seq[1]); // false + } + + { + YAML::Value root; + root.push_back("zero"); + root.push_back("one"); + root.push_back("two"); + YAML::Value two = root[2]; + root = "scalar"; // 'two' is still "two", even though 'root' is "scalar" + // (the sequence effectively no longer exists) + + // Note: in all likelihood, the memory for nodes "zero" and "one" is still + // allocated. How can it go away? Weak pointers? + } + + { + YAML::Value root; // ~ + root[0] = root; // &1 [*1] + root[0] = 5; // [5] + } + + { + YAML::Value root; + YAML::Value key; + key["key"] = "value"; + root[key] = key; // &1 {key: value}: *1 + } + + { + YAML::Value root; + root[0] = "hi"; + root[1][0] = "bye"; + root[1][1] = root; // &1 [hi, [bye, *1]] # root + YAML::Value sub = root[1]; // &1 [bye, [hi, *1]] # sub + root = "gone"; // [bye, gone] # sub + } + + return 0; +} diff --git a/lib/yaml-cpp/util/parse.cpp b/lib/yaml-cpp/util/parse.cpp new file mode 100644 index 0000000000..403ee8a64d --- /dev/null +++ b/lib/yaml-cpp/util/parse.cpp @@ -0,0 +1,61 @@ +#include +#include +#include + +#include "yaml-cpp/eventhandler.h" +#include "yaml-cpp/yaml.h" // IWYU pragma: keep + +struct Params { + bool hasFile; + std::string fileName; +}; + +Params ParseArgs(int argc, char** argv) { + Params p; + + std::vector args(argv + 1, argv + argc); + + return p; +} + +class NullEventHandler : public YAML::EventHandler { + public: + void OnDocumentStart(const YAML::Mark&) override {} + void OnDocumentEnd() override {} + + void OnNull(const YAML::Mark&, YAML::anchor_t) override {} + void OnAlias(const YAML::Mark&, YAML::anchor_t) override {} + void OnScalar(const YAML::Mark&, const std::string&, YAML::anchor_t, + const std::string&) override {} + + void OnSequenceStart(const YAML::Mark&, const std::string&, YAML::anchor_t, + YAML::EmitterStyle) override {} + void OnSequenceEnd() override {} + + void OnMapStart(const YAML::Mark&, const std::string&, YAML::anchor_t, + YAML::EmitterStyle) override {} + void OnMapEnd() override {} +}; + +void parse(std::istream& input) { + try { + YAML::Node doc = YAML::Load(input); + std::cout << doc << "\n"; + } catch (const YAML::Exception& e) { + std::cerr << e.what() << "\n"; + } +} + +int main(int argc, char** argv) { + Params p = ParseArgs(argc, argv); + + if (argc > 1) { + std::ifstream fin; + fin.open(argv[1]); + parse(fin); + } else { + parse(std::cin); + } + + return 0; +} diff --git a/lib/yaml-cpp/util/read.cpp b/lib/yaml-cpp/util/read.cpp new file mode 100644 index 0000000000..f7c52b05fa --- /dev/null +++ b/lib/yaml-cpp/util/read.cpp @@ -0,0 +1,103 @@ +#include "yaml-cpp/emitterstyle.h" +#include "yaml-cpp/eventhandler.h" +#include "yaml-cpp/yaml.h" // IWYU pragma: keep + +#include +#include +#include + +class NullEventHandler : public YAML::EventHandler { + public: + using Mark = YAML::Mark; + using anchor_t = YAML::anchor_t; + + NullEventHandler() = default; + + void OnDocumentStart(const Mark&) override {} + void OnDocumentEnd() override {} + void OnNull(const Mark&, anchor_t) override {} + void OnAlias(const Mark&, anchor_t) override {} + void OnScalar(const Mark&, const std::string&, anchor_t, + const std::string&) override {} + void OnSequenceStart(const Mark&, const std::string&, anchor_t, + YAML::EmitterStyle style) override {} + void OnSequenceEnd() override {} + void OnMapStart(const Mark&, const std::string&, anchor_t, + YAML::EmitterStyle style) override {} + void OnMapEnd() override {} +}; + +void run(std::istream& in) { + YAML::Parser parser(in); + NullEventHandler handler; + parser.HandleNextDocument(handler); +} + +void usage() { std::cerr << "Usage: read [-n N] [-c, --cache] [filename]\n"; } + +std::string read_stream(std::istream& in) { + return std::string((std::istreambuf_iterator(in)), + std::istreambuf_iterator()); +} + +int main(int argc, char** argv) { + int N = 1; + bool cache = false; + std::string filename; + for (int i = 1; i < argc; i++) { + std::string arg = argv[i]; + if (arg == "-n") { + i++; + if (i >= argc) { + usage(); + return -1; + } + N = std::atoi(argv[i]); + if (N <= 0) { + usage(); + return -1; + } + } else if (arg == "-c" || arg == "--cache") { + cache = true; + } else { + filename = argv[i]; + if (i + 1 != argc) { + usage(); + return -1; + } + } + } + + if (N > 1 && !cache && filename.empty()) { + usage(); + return -1; + } + + if (cache) { + std::string input; + if (!filename.empty()) { + std::ifstream in(filename); + input = read_stream(in); + } else { + input = read_stream(std::cin); + } + std::istringstream in(input); + for (int i = 0; i < N; i++) { + in.seekg(std::ios_base::beg); + run(in); + } + } else { + if (!filename.empty()) { + std::ifstream in(filename); + for (int i = 0; i < N; i++) { + in.seekg(std::ios_base::beg); + run(in); + } + } else { + for (int i = 0; i < N; i++) { + run(std::cin); + } + } + } + return 0; +} diff --git a/lib/yaml-cpp/util/sandbox.cpp b/lib/yaml-cpp/util/sandbox.cpp new file mode 100644 index 0000000000..bb215b6b10 --- /dev/null +++ b/lib/yaml-cpp/util/sandbox.cpp @@ -0,0 +1,36 @@ +#include + +#include "yaml-cpp/emitterstyle.h" +#include "yaml-cpp/eventhandler.h" +#include "yaml-cpp/yaml.h" // IWYU pragma: keep + +class NullEventHandler : public YAML::EventHandler { + public: + using Mark = YAML::Mark; + using anchor_t = YAML::anchor_t; + + NullEventHandler() = default; + + void OnDocumentStart(const Mark&) override {} + void OnDocumentEnd() override {} + void OnNull(const Mark&, anchor_t) override {} + void OnAlias(const Mark&, anchor_t) override {} + void OnScalar(const Mark&, const std::string&, anchor_t, + const std::string&) override {} + void OnSequenceStart(const Mark&, const std::string&, anchor_t, + YAML::EmitterStyle style) override {} + void OnSequenceEnd() override {} + void OnMapStart(const Mark&, const std::string&, anchor_t, + YAML::EmitterStyle style) override {} + void OnMapEnd() override {} +}; + +int main() { + YAML::Node root; + + for (;;) { + YAML::Node node; + root = node; + } + return 0; +} diff --git a/lib/yaml-cpp/yaml-cpp-config.cmake.in b/lib/yaml-cpp/yaml-cpp-config.cmake.in new file mode 100644 index 0000000000..7b41e3f30c --- /dev/null +++ b/lib/yaml-cpp/yaml-cpp-config.cmake.in @@ -0,0 +1,14 @@ +# - Config file for the yaml-cpp package +# It defines the following variables +# YAML_CPP_INCLUDE_DIR - include directory +# YAML_CPP_LIBRARIES - libraries to link against + +# Compute paths +get_filename_component(YAML_CPP_CMAKE_DIR "${CMAKE_CURRENT_LIST_FILE}" PATH) +set(YAML_CPP_INCLUDE_DIR "@CONFIG_INCLUDE_DIRS@") + +# Our library dependencies (contains definitions for IMPORTED targets) +include("${YAML_CPP_CMAKE_DIR}/yaml-cpp-targets.cmake") + +# These are IMPORTED targets created by yaml-cpp-targets.cmake +set(YAML_CPP_LIBRARIES "@EXPORT_TARGETS@") diff --git a/lib/yaml-cpp/yaml-cpp.pc.in b/lib/yaml-cpp/yaml-cpp.pc.in new file mode 100644 index 0000000000..f713de636a --- /dev/null +++ b/lib/yaml-cpp/yaml-cpp.pc.in @@ -0,0 +1,11 @@ +prefix=@CMAKE_INSTALL_PREFIX@ +exec_prefix=${prefix} +includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@ +libdir=${exec_prefix}/@CMAKE_INSTALL_LIBDIR@ + +Name: Yaml-cpp +Description: A YAML parser and emitter for C++ +Version: @YAML_CPP_VERSION@ +Requires: +Libs: -L${libdir} -lyaml-cpp +Cflags: -I${includedir} diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 39c3b57a64..250f6ec119 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -294,6 +294,7 @@ install( install(TARGETS ${BROTLI_LIBRARY} EXPORT ${VIRTUAL_TRANSPORT_LIBRARY}) install(TARGETS ${ENG_FORMAT_LIBRARY} EXPORT ${VIRTUAL_TRANSPORT_LIBRARY}) install(TARGETS ${FMT_LIBRARY} EXPORT ${VIRTUAL_TRANSPORT_LIBRARY}) +install(TARGETS ${YAMLCPP_LIBRARY} EXPORT ${VIRTUAL_TRANSPORT_LIBRARY}) install(TARGETS ${JSON_LIBRARY} EXPORT ${VIRTUAL_TRANSPORT_LIBRARY}) if (vt_libfort_enabled) @@ -307,6 +308,7 @@ export( ${MIMALLOC_LIBRARY} ${FORT_LIBRARY} ${FMT_LIBRARY} + ${YAMLCPP_LIBRARY} ${ENG_FORMAT_LIBRARY} ${JSON_LIBRARY} ${BROTLI_LIBRARY} diff --git a/src/vt/configs/arguments/app_config.h b/src/vt/configs/arguments/app_config.h index bdabfed535..aa83d05588 100644 --- a/src/vt/configs/arguments/app_config.h +++ b/src/vt/configs/arguments/app_config.h @@ -77,6 +77,8 @@ struct AppConfig { return vt_debug_print_flush; } + std::string vt_input_config_yaml = ""; + bool vt_color = true; #ifdef VT_NO_COLOR_ENABLED bool vt_no_color = true; diff --git a/src/vt/configs/arguments/args.cc b/src/vt/configs/arguments/args.cc index ae2f7f84ef..ee3e6f8c25 100644 --- a/src/vt/configs/arguments/args.cc +++ b/src/vt/configs/arguments/args.cc @@ -44,6 +44,7 @@ #include "vt/config.h" #include "vt/configs/arguments/args.h" #include "vt/context/context.h" +#include "vt/utils/demangle/demangle.h" #include #include @@ -52,12 +53,171 @@ #include #include "CLI/CLI11.hpp" +#include "yaml-cpp/yaml.h" namespace vt { namespace arguments { // Temporary variables used only for parsing artifacts. namespace { +// Set the YAML labels for all CLI args + +// Output Control +static const std::string vt_color_label = "Color"; +static const std::string vt_no_color_label = "No Color"; +static const std::string vt_quiet_label = "Quiet"; + +// Signal Handling +static const std::string vt_no_sigint_label = "Disable SIGINT"; +static const std::string vt_no_sigsegv_label = "Disable SIGSEGV"; +static const std::string vt_no_sigbus_label = "Disable SIGBUS"; +static const std::string vt_no_terminate_label = "Disable Terminate Signal"; + +// Memory Usage Reporting +static const std::string vt_memory_reporters_label = "Memory Reporters"; +static const std::string vt_print_memory_each_phase_label = "Print Memory Each Phase"; +static const std::string vt_print_memory_node_label = "Print Memory On Node"; +static const std::string vt_allow_memory_report_with_ps_label = "Allow Memory Report With ps"; +static const std::string vt_print_memory_threshold_label = "Print Memory Threshold"; +static const std::string vt_print_memory_sched_poll_label = "Print Memory Scheduler Poll"; +static const std::string vt_print_memory_footprint_label = "Print Memory Footprint"; + +// Dump Stack Backtrace +static const std::string vt_no_warn_stack_label = "Enable Stack Output on Warning"; +static const std::string vt_no_assert_stack_label = "Enable Stack Output on Assert"; +static const std::string vt_no_abort_stack_label = "Enable Stack Output on Abort"; +static const std::string vt_no_stack_label = "Enable Stack Output"; +static const std::string vt_stack_file_label = "File"; +static const std::string vt_stack_dir_label = "Directory"; +static const std::string vt_stack_mod_label = "Output Rank Mod"; + +// Tracing Configuration +static const std::string vt_trace_label = "Enabled"; +static const std::string vt_trace_mpi_label = "MPI Type Events"; +static const std::string vt_trace_pmpi_label = "MPI Type Events"; +static const std::string vt_trace_file_label = "File"; +static const std::string vt_trace_dir_label = "Directory"; +static const std::string vt_trace_mod_label = "Output Rank Mod"; +static const std::string vt_trace_flush_size_label = "Flush Size"; +static const std::string vt_trace_gzip_finish_flush_label = "GZip Finish Flush"; +static const std::string vt_trace_sys_all_label = "Include All System Events"; +static const std::string vt_trace_sys_term_label = "Include Termination Events"; +static const std::string vt_trace_sys_location_label = "Include Location Events"; +static const std::string vt_trace_sys_collection_label = "Include Collection Events"; +static const std::string vt_trace_sys_serial_msg_label = "Include Message Serialization Events"; +static const std::string vt_trace_spec_label = "Specification Enabled"; +static const std::string vt_trace_spec_file_label = "Spec File"; +static const std::string vt_trace_memory_usage_label = "Memory Usage"; +static const std::string vt_trace_event_polling_label = "Event Polling"; +static const std::string vt_trace_irecv_polling_label = "IRecv Polling"; + +// Debug Print Configuration +static const std::string vt_debug_level_label = "Level"; +static const std::string vt_debug_all_label = "Enable All"; +static const std::string vt_debug_none_label = "Disable All"; +static const std::string vt_debug_print_flush_label = "Debug Print Flush"; +static const std::string vt_debug_replay_label = "Debug Replay"; +static const std::string vt_debug_gen_label = "gen"; +static const std::string vt_debug_runtime_label = "runtime"; +static const std::string vt_debug_active_label = "active"; +static const std::string vt_debug_term_label = "term"; +static const std::string vt_debug_termds_label = "termds"; +static const std::string vt_debug_barrier_label = "barrier"; +static const std::string vt_debug_event_label = "event"; +static const std::string vt_debug_pipe_label = "pipe"; +static const std::string vt_debug_pool_label = "pool"; +static const std::string vt_debug_reduce_label = "reduce"; +static const std::string vt_debug_rdma_label = "rdma"; +static const std::string vt_debug_rdma_channel_label = "rdma_channel"; +static const std::string vt_debug_rdma_state_label = "rdma_state"; +static const std::string vt_debug_handler_label = "handler"; +static const std::string vt_debug_hierlb_label = "hierlb"; +static const std::string vt_debug_temperedlb_label = "temperedlb"; +static const std::string vt_debug_temperedwmin_label = "temperedwmin"; +static const std::string vt_debug_scatter_label = "scatter"; +static const std::string vt_debug_serial_msg_label = "serial_msg"; +static const std::string vt_debug_trace_label = "trace"; +static const std::string vt_debug_location_label = "location"; +static const std::string vt_debug_lb_label = "lb"; +static const std::string vt_debug_vrt_label = "vrt"; +static const std::string vt_debug_vrt_coll_label = "vrt_coll"; +static const std::string vt_debug_worker_label = "worker"; +static const std::string vt_debug_group_label = "group"; +static const std::string vt_debug_broadcast_label = "broadcast"; +static const std::string vt_debug_objgroup_label = "objgroup"; +static const std::string vt_debug_phase_label = "phase"; +static const std::string vt_debug_context_label = "context"; +static const std::string vt_debug_epoch_label = "epoch"; + +// Load Balancing +static const std::string vt_lb_label = "Enabled"; +static const std::string vt_lb_quiet_label = "Quiet"; +static const std::string vt_lb_file_name_label = "File"; +static const std::string vt_lb_show_config_label = "Show Configuration"; +static const std::string vt_lb_name_label = "Name"; +static const std::string vt_lb_args_label = "Arguments"; +static const std::string vt_lb_interval_label = "Interval"; +static const std::string vt_lb_keep_last_elm_label = "Keep Last Element"; +static const std::string vt_lb_data_label = "Enabled"; +static const std::string vt_lb_data_dir_label = "Directory"; +static const std::string vt_lb_data_file_label = "File"; +static const std::string vt_lb_data_in_label = "Enabled"; +static const std::string vt_lb_data_compress_label = "Enable Compression"; +static const std::string vt_lb_data_dir_in_label = "Directory"; +static const std::string vt_lb_data_file_in_label = "File"; +static const std::string vt_lb_statistics_label = "Enabled"; +static const std::string vt_lb_statistics_compress_label = "Enable Compression"; +static const std::string vt_lb_statistics_file_label = "File"; +static const std::string vt_lb_statistics_dir_label = "Directory"; +static const std::string vt_lb_self_migration_label = "Enable Self Migration"; +static const std::string vt_lb_spec_label = "Enable Specification"; +static const std::string vt_lb_spec_file_label = "Specification File"; + +// Diagnostics +static const std::string vt_diag_enable_label = "Enabled"; +static const std::string vt_diag_print_summary_label = "Enable Print Summary"; +static const std::string vt_diag_summary_file_label = "Summary File"; +static const std::string vt_diag_summary_csv_file_label = "Summary CSV File"; +static const std::string vt_diag_csv_base_units_label = "Use CSV Base Units"; + +// Termination +static const std::string vt_no_detect_hang_label = "No Detect Hangs"; +static const std::string vt_term_rooted_use_ds_label = "Use DS for Rooted"; +static const std::string vt_term_rooted_use_wave_label = "Use Wave for Rooted"; +static const std::string vt_epoch_graph_on_hang_label = "Output Epoch Graph on Hang"; +static const std::string vt_epoch_graph_terse_label = "Terse Epoch Graph Output"; +static const std::string vt_print_no_progress_label = "Print No Progress"; +static const std::string vt_hang_freq_label = "Hang Check Frequency"; + +// Debugging/Launch +static const std::string vt_pause_label = "Pause"; + +// Scheduler Configuration +static const std::string vt_sched_num_progress_label = "Num Progress Times"; +static const std::string vt_sched_progress_han_label = "Progress Handlers"; +static const std::string vt_sched_progress_sec_label = "Progress Seconds"; + +// Configuration File +static const std::string vt_output_config_label = "Enable Output Config"; +static const std::string vt_output_config_file_label = "File"; + +// Runtime +static const std::string vt_max_mpi_send_size_label = "Max MPI Send Size"; +static const std::string vt_no_assert_fail_label = "Disable Assert Failure"; +static const std::string vt_throw_on_abort_label = "Throw on Abort"; + +std::unordered_map user_args_labels = { + {"vt_user_1", "unused_user_param"}, + {"vt_user_2", "unused_user_param"}, + {"vt_user_3", "unused_user_param"}, + {"vt_user_int_1", "unused_user_param"}, + {"vt_user_int_2", "unused_user_param"}, + {"vt_user_int_3", "unused_user_param"}, + {"vt_user_str_1", "unused_user_param"}, + {"vt_user_str_2", "unused_user_param"}, + {"vt_user_str_3", "unused_user_param"} +}; + std::vector arg_trace_mpi; /** @@ -87,6 +247,9 @@ void postParseTransform(AppConfig& appConfig) { } } +void parseYaml(AppConfig& appConfig, std::string const& inputFile); +void convertConfigToString(CLI::App& app, AppConfig& appConfig); + std::tuple parseArguments( CLI::App& app, int& argc, char**& argv, AppConfig& appConfig ) { @@ -118,34 +281,46 @@ std::tuple parseArguments( app.allow_extras(false); // Build string-vector and reverse order to parse (CLI quirk) - std::vector args_to_parse; + std::vector args_to_parse, yaml_input_arg; for (auto it = vt_args.crbegin(); it != vt_args.crend(); ++it) { - args_to_parse.push_back(*it); + if (util::demangle::DemanglerUtils::splitString(*it,'=')[0] == "--vt_input_config_yaml") { + yaml_input_arg.push_back(*it); + } else { + args_to_parse.push_back(*it); + } } - // Allow a input config file - app.set_config( - "--vt_input_config", - "", // no default file name - "Read in an ini config file for VT", - false // not required - ); + // Identify input YAML file first, if present + if (!yaml_input_arg.empty()) { + try { + app.parse(yaml_input_arg); + } catch (CLI::Error &ex) { + // Return exit code and message, delaying logic processing of such. + // The default exit code for 'help' is 0. + std::stringstream yaml_message_stream; + int yaml_result = app.exit(ex, yaml_message_stream, yaml_message_stream); + return std::make_tuple(yaml_result, yaml_message_stream.str()); + } + } + + // Parse the YAML parameters + if (appConfig.vt_input_config_yaml != "") { + parseYaml(appConfig, appConfig.vt_input_config_yaml); + } + // Then parse the remaining arguments try { app.parse(args_to_parse); } catch (CLI::Error &ex) { - // Return exit code and message, delaying logic processing of such. - // The default exit code for 'help' is 0. std::stringstream message_stream; int result = app.exit(ex, message_stream, message_stream); - return std::make_tuple(result, message_stream.str()); } // If the user specified to output the full configuration, save it in a string // so node 0 can output in the runtime once MPI is init'ed if (appConfig.vt_output_config) { - appConfig.vt_output_config_str = app.config_to_str(true, true); + convertConfigToString(app, appConfig); } // Get the clean prog name; don't allow path bleed in usages. @@ -186,6 +361,262 @@ std::tuple parseArguments( return std::make_tuple(-1, std::string{}); } +void addYamlArgs(CLI::App& app, AppConfig& appConfig) { + auto yaml_description = "Read in a YAML config file for VT"; + app.add_option("--vt_input_config_yaml", appConfig.vt_input_config_yaml, yaml_description); +} + +void addUserOptionsFromYaml(YAML::Node& inputYaml, AppConfig& appConfig) { + YAML::Node user_options = inputYaml["User Options"]; + int bool_iter = 1, int_iter = 1, str_iter = 1; + bool too_many_user_args = false; + for (YAML::const_iterator it = user_options.begin(); it != user_options.end(); ++it) { + std::string const& key = it->first.as(); + try { + bool user_input = user_options[key].as(); + if (bool_iter == 1) + appConfig.vt_user_1 = user_input; + else if (bool_iter == 2) + appConfig.vt_user_2 = user_input; + else if (bool_iter == 3) + appConfig.vt_user_3 = user_input; + else too_many_user_args = true; + user_args_labels["vt_user_" + std::to_string(bool_iter)] = key; + bool_iter++; + } catch (const YAML::RepresentationException&) { + try { + int user_input = user_options[key].as(); + if (int_iter == 1) + appConfig.vt_user_int_1 = user_input; + else if (int_iter == 2) + appConfig.vt_user_int_2 = user_input; + else if (int_iter == 3) + appConfig.vt_user_int_3 = user_input; + else + too_many_user_args = true; + user_args_labels["vt_user_int_" + std::to_string(int_iter)] = key; + int_iter++; + } catch (const YAML::RepresentationException&) { + std::string user_input = user_options[key].as(); + if (str_iter == 1) + appConfig.vt_user_str_1 = user_input; + else if (str_iter == 2) + appConfig.vt_user_str_2 = user_input; + else if (str_iter == 3) + appConfig.vt_user_str_3 = user_input; + else too_many_user_args = true; + user_args_labels["vt_user_str_" + std::to_string(str_iter)] = key; + str_iter++; + } + } + } + vtAbortIf(too_many_user_args, "Only three user-defined arguments of each type (bool, int, or string) are supported."); +} + +void parseYaml(AppConfig& appConfig, std::string const& inputFile) { + // Read the config value from YAML using default (current) value as fallback + auto update_config = []( + auto& config_entry, std::string const& label, YAML::Node const& node + ) { + using config_type = std::remove_reference_t; + config_entry = node[label].as(config_entry); + }; + + // Read in the YAML configuration file + auto yaml_input = YAML::LoadFile(inputFile); + + // Output control + YAML::Node output_control = yaml_input["Output Control"]; + update_config(appConfig.vt_color, vt_color_label, output_control); + update_config(appConfig.vt_no_color, vt_no_color_label, output_control); + update_config(appConfig.vt_quiet, vt_quiet_label, output_control); + + // Signal handling + YAML::Node signal_handling = yaml_input["Signal Handling"]; + update_config(appConfig.vt_no_sigint, vt_no_sigint_label, signal_handling); + update_config(appConfig.vt_no_sigsegv, vt_no_sigsegv_label, signal_handling); + update_config(appConfig.vt_no_sigbus, vt_no_sigbus_label, signal_handling); + update_config(appConfig.vt_no_terminate, vt_no_terminate_label, signal_handling); + + // Memory Usage Reporting + YAML::Node memory_usage_reporting = yaml_input["Memory Usage Reporting"]; + std::string default_vt_memory_reporters = + #if (vt_feature_mimalloc != 0) + "mimalloc," + #endif + "mstats,machinfo,selfstat,selfstatm,sbrk,mallinfo,getrusage,ps"; + update_config(appConfig.vt_memory_reporters, vt_memory_reporters_label, memory_usage_reporting); + update_config(appConfig.vt_print_memory_each_phase, vt_print_memory_each_phase_label, memory_usage_reporting); + update_config(appConfig.vt_print_memory_node, vt_print_memory_node_label, memory_usage_reporting); + update_config(appConfig.vt_allow_memory_report_with_ps, vt_allow_memory_report_with_ps_label, memory_usage_reporting); + if (memory_usage_reporting[vt_print_memory_threshold_label]) { + appConfig.vt_print_memory_at_threshold = true; + update_config(appConfig.vt_print_memory_threshold, vt_print_memory_threshold_label, memory_usage_reporting); + } else { + appConfig.vt_print_memory_at_threshold = false; + } + update_config(appConfig.vt_print_memory_sched_poll, vt_print_memory_sched_poll_label, memory_usage_reporting); + update_config(appConfig.vt_print_memory_footprint, vt_print_memory_footprint_label, memory_usage_reporting); + + // Dump Stack Backtrace + YAML::Node dump_stack_backtrace = yaml_input["Dump Stack Backtrace"]; + update_config(appConfig.vt_no_warn_stack, vt_no_warn_stack_label, dump_stack_backtrace); + update_config(appConfig.vt_no_assert_stack, vt_no_assert_stack_label, dump_stack_backtrace); + update_config(appConfig.vt_no_abort_stack, vt_no_abort_stack_label, dump_stack_backtrace); + update_config(appConfig.vt_no_stack, vt_no_stack_label, dump_stack_backtrace); + update_config(appConfig.vt_stack_file, vt_stack_file_label, dump_stack_backtrace); + update_config(appConfig.vt_stack_dir, vt_stack_dir_label, dump_stack_backtrace); + update_config(appConfig.vt_stack_mod, vt_stack_mod_label, dump_stack_backtrace); + + // Tracing Configuration + YAML::Node tracing_configuration = yaml_input["Tracing Configuration"]; + update_config(appConfig.vt_trace, vt_trace_label, tracing_configuration); + + appConfig.vt_trace_mpi = tracing_configuration[vt_trace_mpi_label].as("").find("internal") != std::string::npos; + appConfig.vt_trace_pmpi = tracing_configuration[vt_trace_pmpi_label].as("").find("external") != std::string::npos; + + update_config(appConfig.vt_trace_file, vt_trace_file_label, tracing_configuration); + update_config(appConfig.vt_trace_dir, vt_trace_dir_label, tracing_configuration); + update_config(appConfig.vt_trace_mod, vt_trace_mod_label, tracing_configuration); + update_config(appConfig.vt_trace_flush_size, vt_trace_flush_size_label, tracing_configuration); + update_config(appConfig.vt_trace_gzip_finish_flush, vt_trace_gzip_finish_flush_label, tracing_configuration); + update_config(appConfig.vt_trace_sys_all, vt_trace_sys_all_label, tracing_configuration); + update_config(appConfig.vt_trace_sys_term, vt_trace_sys_term_label, tracing_configuration); + update_config(appConfig.vt_trace_sys_location, vt_trace_sys_location_label, tracing_configuration); + update_config(appConfig.vt_trace_sys_collection, vt_trace_sys_collection_label, tracing_configuration); + update_config(appConfig.vt_trace_sys_serial_msg, vt_trace_sys_serial_msg_label, tracing_configuration); + update_config(appConfig.vt_trace_spec, vt_trace_spec_label, tracing_configuration); + update_config(appConfig.vt_trace_spec_file, vt_trace_spec_file_label, tracing_configuration); + update_config(appConfig.vt_trace_memory_usage, vt_trace_memory_usage_label, tracing_configuration); + update_config(appConfig.vt_trace_event_polling, vt_trace_event_polling_label, tracing_configuration); + update_config(appConfig.vt_trace_irecv_polling, vt_trace_irecv_polling_label, tracing_configuration); + + // Debug Print Configuration + YAML::Node debug_print_configuration = yaml_input["Debug Print Configuration"]; + update_config(appConfig.vt_debug_level, vt_debug_level_label, debug_print_configuration); + update_config(appConfig.vt_debug_all, vt_debug_all_label, debug_print_configuration); + update_config(appConfig.vt_debug_none, vt_debug_none_label, debug_print_configuration); + + std::vector debug_enables; + if (debug_print_configuration["Enable"]) { + debug_enables = debug_print_configuration["Enable"].as>(); + } + + // All vt_debug_ categories are false by default (no need to check current value) + auto is_debug_enabled = [&debug_enables]( std::string const& debug_type) { + return std::find(debug_enables.begin(), debug_enables.end(), debug_type) != debug_enables.end(); + }; + + appConfig.vt_debug_gen = is_debug_enabled(vt_debug_gen_label); + appConfig.vt_debug_runtime = is_debug_enabled(vt_debug_runtime_label); + appConfig.vt_debug_active = is_debug_enabled(vt_debug_active_label); + appConfig.vt_debug_term = is_debug_enabled(vt_debug_term_label); + appConfig.vt_debug_termds = is_debug_enabled(vt_debug_termds_label); + appConfig.vt_debug_barrier = is_debug_enabled(vt_debug_barrier_label); + appConfig.vt_debug_event = is_debug_enabled(vt_debug_event_label); + appConfig.vt_debug_pipe = is_debug_enabled(vt_debug_pipe_label); + appConfig.vt_debug_pool = is_debug_enabled(vt_debug_pool_label); + appConfig.vt_debug_reduce = is_debug_enabled(vt_debug_reduce_label); + appConfig.vt_debug_rdma = is_debug_enabled(vt_debug_rdma_label); + appConfig.vt_debug_rdma_channel = is_debug_enabled(vt_debug_rdma_channel_label); + appConfig.vt_debug_rdma_state = is_debug_enabled(vt_debug_rdma_state_label); + appConfig.vt_debug_handler = is_debug_enabled(vt_debug_handler_label); + appConfig.vt_debug_hierlb = is_debug_enabled(vt_debug_hierlb_label); + appConfig.vt_debug_temperedlb = is_debug_enabled(vt_debug_temperedlb_label); + appConfig.vt_debug_temperedwmin = is_debug_enabled(vt_debug_temperedwmin_label); + appConfig.vt_debug_scatter = is_debug_enabled(vt_debug_scatter_label); + appConfig.vt_debug_serial_msg = is_debug_enabled(vt_debug_serial_msg_label); + appConfig.vt_debug_trace = is_debug_enabled(vt_debug_trace_label); + appConfig.vt_debug_location = is_debug_enabled(vt_debug_location_label); + appConfig.vt_debug_lb = is_debug_enabled(vt_debug_lb_label); + appConfig.vt_debug_vrt = is_debug_enabled(vt_debug_vrt_label); + appConfig.vt_debug_vrt_coll = is_debug_enabled(vt_debug_vrt_coll_label); + appConfig.vt_debug_worker = is_debug_enabled(vt_debug_worker_label); + appConfig.vt_debug_group = is_debug_enabled(vt_debug_group_label); + appConfig.vt_debug_broadcast = is_debug_enabled(vt_debug_broadcast_label); + appConfig.vt_debug_objgroup = is_debug_enabled(vt_debug_objgroup_label); + appConfig.vt_debug_phase = is_debug_enabled(vt_debug_phase_label); + appConfig.vt_debug_context = is_debug_enabled(vt_debug_context_label); + appConfig.vt_debug_epoch = is_debug_enabled(vt_debug_epoch_label); + + update_config(appConfig.vt_debug_print_flush, vt_debug_print_flush_label, debug_print_configuration); + update_config(appConfig.vt_debug_replay, vt_debug_replay_label, debug_print_configuration); + + // Load Balancing + YAML::Node load_balancing = yaml_input["Load Balancing"]; + update_config(appConfig.vt_lb, vt_lb_label, load_balancing); + update_config(appConfig.vt_lb_quiet, vt_lb_quiet_label, load_balancing); + update_config(appConfig.vt_lb_file_name, vt_lb_file_name_label, load_balancing); + update_config(appConfig.vt_lb_show_config, vt_lb_show_config_label, load_balancing); + update_config(appConfig.vt_lb_name, vt_lb_name_label, load_balancing); + update_config(appConfig.vt_lb_args, vt_lb_args_label, load_balancing); + update_config(appConfig.vt_lb_interval, vt_lb_interval_label, load_balancing); + update_config(appConfig.vt_lb_keep_last_elm, vt_lb_keep_last_elm_label, load_balancing); + update_config(appConfig.vt_lb_self_migration, vt_lb_self_migration_label, load_balancing); + update_config(appConfig.vt_lb_spec, vt_lb_spec_label, load_balancing); + update_config(appConfig.vt_lb_spec_file, vt_lb_spec_file_label, load_balancing); + + + YAML::Node lb_output = load_balancing["LB Data Output"]; + update_config(appConfig.vt_lb_data, vt_lb_data_label, lb_output); + update_config(appConfig.vt_lb_data_dir, vt_lb_data_dir_label, lb_output); + update_config(appConfig.vt_lb_data_file, vt_lb_data_file_label, lb_output); + + YAML::Node lb_input = load_balancing["LB Data Input"]; + update_config(appConfig.vt_lb_data_in, vt_lb_data_in_label, lb_input); + update_config(appConfig.vt_lb_data_compress, vt_lb_data_compress_label, lb_input); + update_config(appConfig.vt_lb_data_dir_in, vt_lb_data_dir_in_label, lb_input); + update_config(appConfig.vt_lb_data_file_in, vt_lb_data_file_in_label, lb_input); + + YAML::Node lb_stats = load_balancing["LB Statistics"]; + update_config(appConfig.vt_lb_statistics, vt_lb_statistics_label, lb_stats); + update_config(appConfig.vt_lb_statistics_compress, vt_lb_statistics_compress_label, lb_stats); + update_config(appConfig.vt_lb_statistics_file, vt_lb_statistics_file_label, lb_stats); + update_config(appConfig.vt_lb_statistics_dir, vt_lb_statistics_dir_label, lb_stats); + + // Diagnostics + YAML::Node diagnostics = yaml_input["Diagnostics"]; + update_config(appConfig.vt_diag_enable, vt_diag_enable_label, diagnostics); + update_config(appConfig.vt_diag_print_summary, vt_diag_print_summary_label, diagnostics); + update_config(appConfig.vt_diag_summary_file, vt_diag_summary_file_label, diagnostics); + update_config(appConfig.vt_diag_summary_csv_file, vt_diag_summary_csv_file_label, diagnostics); + update_config(appConfig.vt_diag_csv_base_units, vt_diag_csv_base_units_label, diagnostics); + + // Termination + YAML::Node termination = yaml_input["Termination"]; + update_config(appConfig.vt_no_detect_hang, vt_no_detect_hang_label, termination); + update_config(appConfig.vt_term_rooted_use_ds, vt_term_rooted_use_ds_label, termination); + update_config(appConfig.vt_term_rooted_use_wave, vt_term_rooted_use_wave_label, termination); + update_config(appConfig.vt_epoch_graph_on_hang, vt_epoch_graph_on_hang_label, termination); + update_config(appConfig.vt_epoch_graph_terse, vt_epoch_graph_terse_label, termination); + update_config(appConfig.vt_print_no_progress, vt_print_no_progress_label, termination); + update_config(appConfig.vt_hang_freq, vt_hang_freq_label, termination); + + // Debugging/Launch + YAML::Node launch = yaml_input["Launch"]; + update_config(appConfig.vt_pause, vt_pause_label, launch); + + // User Options + addUserOptionsFromYaml(yaml_input, appConfig); + + // Scheduler Configuration + YAML::Node scheduler_configuration = yaml_input["Scheduler Configuration"]; + update_config(appConfig.vt_sched_num_progress, vt_sched_num_progress_label, scheduler_configuration); + update_config(appConfig.vt_sched_progress_han, vt_sched_progress_han_label, scheduler_configuration); + update_config(appConfig.vt_sched_progress_sec, vt_sched_progress_sec_label, scheduler_configuration); + + // Configuration File + YAML::Node configuration_file = yaml_input["Configuration File"]; + update_config(appConfig.vt_output_config, vt_output_config_label, configuration_file); + update_config(appConfig.vt_output_config_file, vt_output_config_file_label, configuration_file); + + // Runtime + YAML::Node runtime = yaml_input["Runtime"]; + update_config(appConfig.vt_max_mpi_send_size, vt_max_mpi_send_size_label, runtime); + update_config(appConfig.vt_no_assert_fail, vt_no_assert_fail_label, runtime); + update_config(appConfig.vt_throw_on_abort, vt_throw_on_abort_label, runtime); +} + void addColorArgs(CLI::App& app, AppConfig& appConfig) { auto quiet = "Quiet the output from vt (only errors, warnings)"; auto always = "Colorize output (default)"; @@ -696,6 +1127,232 @@ void addThreadingArgs( #endif } +using variantArg_t = std::variant; + +void addVariantToNode(YAML::Node& node, std::string& key, variantArg_t& variant_val) { + // Get the yaml_val from the variant + if (std::holds_alternative(variant_val)) { + node[key] = std::get(variant_val); + } else if (std::holds_alternative(variant_val)) { + node[key] = std::get(variant_val); + } else if (std::holds_alternative(variant_val)) { + node[key] = std::get(variant_val); + } else if (std::holds_alternative(variant_val)) { + node[key] = std::get(variant_val); + } else if (std::holds_alternative(variant_val)) { + node[key] = std::get(variant_val); + } else if (std::holds_alternative(variant_val)) { + node[key] = std::get(variant_val); + } else { + throw std::runtime_error("Argument type not recognized."); + } +} + +std::string convertConfigToYamlString(AppConfig& appConfig) { + // First, create a converter vector of tuples {Node(s), Key, Value} + std::vector> cli_to_yaml_args = { + // Output Control + {"Output Control", vt_color_label, static_cast(appConfig.vt_color)}, + {"Output Control", vt_no_color_label, static_cast(not appConfig.vt_no_color)}, + {"Output Control", vt_quiet_label, static_cast(appConfig.vt_quiet)}, + + // Signal Handling + {"Signal Handling", vt_no_sigint_label, static_cast(appConfig.vt_no_sigint)}, + {"Signal Handling", vt_no_sigsegv_label, static_cast(appConfig.vt_no_sigsegv)}, + {"Signal Handling", vt_no_sigbus_label, static_cast(appConfig.vt_no_sigbus)}, + {"Signal Handling", vt_no_terminate_label, static_cast(appConfig.vt_no_terminate)}, + + // Memory Usage Reporting + {"Memory Usage Reporting", vt_memory_reporters_label, static_cast(appConfig.vt_memory_reporters)}, + {"Memory Usage Reporting", vt_print_memory_each_phase_label, static_cast(appConfig.vt_print_memory_each_phase)}, + {"Memory Usage Reporting", vt_print_memory_node_label, static_cast(appConfig.vt_print_memory_node)}, + {"Memory Usage Reporting", vt_allow_memory_report_with_ps_label, static_cast(appConfig.vt_allow_memory_report_with_ps)}, + {"Memory Usage Reporting", vt_print_memory_threshold_label, static_cast(appConfig.vt_print_memory_threshold)}, + {"Memory Usage Reporting", vt_print_memory_sched_poll_label, static_cast(appConfig.vt_print_memory_sched_poll)}, + {"Memory Usage Reporting", vt_print_memory_footprint_label, static_cast(appConfig.vt_print_memory_footprint)}, + + // Dump Stack Backtrace + {"Dump Stack Backtrace", vt_no_warn_stack_label, static_cast(appConfig.vt_no_warn_stack)}, + {"Dump Stack Backtrace", vt_no_assert_stack_label, static_cast(appConfig.vt_no_assert_stack)}, + {"Dump Stack Backtrace", vt_no_abort_stack_label, static_cast(appConfig.vt_no_abort_stack)}, + {"Dump Stack Backtrace", vt_no_stack_label, static_cast(appConfig.vt_no_stack)}, + {"Dump Stack Backtrace", vt_stack_file_label, static_cast(appConfig.vt_stack_file)}, + {"Dump Stack Backtrace", vt_stack_dir_label, static_cast(appConfig.vt_stack_dir)}, + {"Dump Stack Backtrace", vt_stack_mod_label, static_cast(appConfig.vt_stack_mod)}, + + // Tracing Configuration + {"Tracing Configuration", vt_trace_label, static_cast(appConfig.vt_trace)}, + {"Tracing Configuration", vt_trace_mpi_label, static_cast(appConfig.vt_trace_mpi)}, + {"Tracing Configuration", vt_trace_pmpi_label, static_cast(appConfig.vt_trace_pmpi)}, + {"Tracing Configuration", vt_trace_file_label, static_cast(appConfig.vt_trace_file)}, + {"Tracing Configuration", vt_trace_dir_label, static_cast(appConfig.vt_trace_dir)}, + {"Tracing Configuration", vt_trace_mod_label, static_cast(appConfig.vt_trace_mod)}, + {"Tracing Configuration", vt_trace_flush_size_label, static_cast(appConfig.vt_trace_flush_size)}, + {"Tracing Configuration", vt_trace_gzip_finish_flush_label, static_cast(appConfig.vt_trace_gzip_finish_flush)}, + {"Tracing Configuration", vt_trace_sys_all_label, static_cast(appConfig.vt_trace_sys_all)}, + {"Tracing Configuration", vt_trace_sys_term_label, static_cast(appConfig.vt_trace_sys_term)}, + {"Tracing Configuration", vt_trace_sys_location_label, static_cast(appConfig.vt_trace_sys_location)}, + {"Tracing Configuration", vt_trace_sys_collection_label, static_cast(appConfig.vt_trace_sys_collection)}, + {"Tracing Configuration", vt_trace_sys_serial_msg_label, static_cast(appConfig.vt_trace_sys_serial_msg)}, + {"Tracing Configuration", vt_trace_spec_label, static_cast(appConfig.vt_trace_spec)}, + {"Tracing Configuration", vt_trace_spec_file_label, static_cast(appConfig.vt_trace_spec_file)}, + {"Tracing Configuration", vt_trace_memory_usage_label, static_cast(appConfig.vt_trace_memory_usage)}, + {"Tracing Configuration", vt_trace_event_polling_label, static_cast(appConfig.vt_trace_event_polling)}, + {"Tracing Configuration", vt_trace_irecv_polling_label, static_cast(appConfig.vt_trace_irecv_polling)}, + + // Debug Print Configuration + {"Debug Print Configuration", vt_debug_level_label, static_cast(appConfig.vt_debug_level)}, + {"Debug Print Configuration", vt_debug_all_label, static_cast(appConfig.vt_debug_all)}, + {"Debug Print Configuration", vt_debug_none_label, static_cast(appConfig.vt_debug_none)}, + {"Debug Print Configuration", vt_debug_print_flush_label, static_cast(appConfig.vt_debug_print_flush)}, + {"Debug Print Configuration/Enable", vt_debug_gen_label, static_cast(appConfig.vt_debug_gen)}, + {"Debug Print Configuration/Enable", vt_debug_runtime_label, static_cast(appConfig.vt_debug_runtime)}, + {"Debug Print Configuration/Enable", vt_debug_active_label, static_cast(appConfig.vt_debug_active)}, + {"Debug Print Configuration/Enable", vt_debug_term_label, static_cast(appConfig.vt_debug_term)}, + {"Debug Print Configuration/Enable", vt_debug_termds_label, static_cast(appConfig.vt_debug_termds)}, + {"Debug Print Configuration/Enable", vt_debug_barrier_label, static_cast(appConfig.vt_debug_barrier)}, + {"Debug Print Configuration/Enable", vt_debug_event_label, static_cast(appConfig.vt_debug_event)}, + {"Debug Print Configuration/Enable", vt_debug_pipe_label, static_cast(appConfig.vt_debug_pipe)}, + {"Debug Print Configuration/Enable", vt_debug_pool_label, static_cast(appConfig.vt_debug_pool)}, + {"Debug Print Configuration/Enable", vt_debug_reduce_label, static_cast(appConfig.vt_debug_reduce)}, + {"Debug Print Configuration/Enable", vt_debug_rdma_label, static_cast(appConfig.vt_debug_rdma)}, + {"Debug Print Configuration/Enable", vt_debug_rdma_channel_label, static_cast(appConfig.vt_debug_rdma_channel)}, + {"Debug Print Configuration/Enable", vt_debug_rdma_state_label, static_cast(appConfig.vt_debug_rdma_state)}, + {"Debug Print Configuration/Enable", vt_debug_handler_label, static_cast(appConfig.vt_debug_handler)}, + {"Debug Print Configuration/Enable", vt_debug_hierlb_label, static_cast(appConfig.vt_debug_hierlb)}, + {"Debug Print Configuration/Enable", vt_debug_temperedlb_label, static_cast(appConfig.vt_debug_temperedlb)}, + {"Debug Print Configuration/Enable", vt_debug_temperedwmin_label, static_cast(appConfig.vt_debug_temperedwmin)}, + {"Debug Print Configuration/Enable", vt_debug_scatter_label, static_cast(appConfig.vt_debug_scatter)}, + {"Debug Print Configuration/Enable", vt_debug_serial_msg_label, static_cast(appConfig.vt_debug_serial_msg)}, + {"Debug Print Configuration/Enable", vt_debug_trace_label, static_cast(appConfig.vt_debug_trace)}, + {"Debug Print Configuration/Enable", vt_debug_location_label, static_cast(appConfig.vt_debug_location)}, + {"Debug Print Configuration/Enable", vt_debug_lb_label, static_cast(appConfig.vt_debug_lb)}, + {"Debug Print Configuration/Enable", vt_debug_vrt_label, static_cast(appConfig.vt_debug_vrt)}, + {"Debug Print Configuration/Enable", vt_debug_vrt_coll_label, static_cast(appConfig.vt_debug_vrt_coll)}, + {"Debug Print Configuration/Enable", vt_debug_worker_label, static_cast(appConfig.vt_debug_worker)}, + {"Debug Print Configuration/Enable", vt_debug_group_label, static_cast(appConfig.vt_debug_group)}, + {"Debug Print Configuration/Enable", vt_debug_broadcast_label, static_cast(appConfig.vt_debug_broadcast)}, + {"Debug Print Configuration/Enable", vt_debug_objgroup_label, static_cast(appConfig.vt_debug_objgroup)}, + {"Debug Print Configuration/Enable", vt_debug_phase_label, static_cast(appConfig.vt_debug_phase)}, + {"Debug Print Configuration/Enable", vt_debug_context_label, static_cast(appConfig.vt_debug_context)}, + {"Debug Print Configuration/Enable", vt_debug_epoch_label, static_cast(appConfig.vt_debug_epoch)}, + + // Load Balancing + {"Load Balancing", vt_lb_label, static_cast(appConfig.vt_lb)}, + {"Load Balancing", vt_lb_quiet_label, static_cast(appConfig.vt_lb_quiet)}, + {"Load Balancing", vt_lb_file_name_label, static_cast(appConfig.vt_lb_file_name)}, + {"Load Balancing", vt_lb_show_config_label, static_cast(appConfig.vt_lb_show_config)}, + {"Load Balancing", vt_lb_name_label, static_cast(appConfig.vt_lb_name)}, + {"Load Balancing", vt_lb_args_label, static_cast(appConfig.vt_lb_args)}, + {"Load Balancing", vt_lb_interval_label, static_cast(appConfig.vt_lb_interval)}, + {"Load Balancing", vt_lb_keep_last_elm_label, static_cast(appConfig.vt_lb_keep_last_elm)}, + {"Load Balancing/LB Data Output", vt_lb_data_label, static_cast(appConfig.vt_lb_data)}, + {"Load Balancing/LB Data Output", vt_lb_data_dir_label, static_cast(appConfig.vt_lb_data_dir)}, + {"Load Balancing/LB Data Output", vt_lb_data_file_label, static_cast(appConfig.vt_lb_data_file)}, + {"Load Balancing/LB Data Input", vt_lb_data_in_label, static_cast(appConfig.vt_lb_data_in)}, + {"Load Balancing/LB Data Input", vt_lb_data_compress_label, static_cast(appConfig.vt_lb_data_compress)}, + {"Load Balancing/LB Data Input", vt_lb_data_dir_in_label, static_cast(appConfig.vt_lb_data_dir_in)}, + {"Load Balancing/LB Data Input", vt_lb_data_file_in_label, static_cast(appConfig.vt_lb_data_file_in)}, + {"Load Balancing/LB Statistics", vt_lb_statistics_label, static_cast(appConfig.vt_lb_statistics)}, + {"Load Balancing/LB Statistics", vt_lb_statistics_compress_label, static_cast(appConfig.vt_lb_statistics_compress)}, + {"Load Balancing/LB Statistics", vt_lb_statistics_file_label, static_cast(appConfig.vt_lb_statistics_file)}, + {"Load Balancing/LB Statistics", vt_lb_statistics_dir_label, static_cast(appConfig.vt_lb_statistics_dir)}, + {"Load Balancing", vt_lb_self_migration_label, static_cast(appConfig.vt_lb_self_migration)}, + {"Load Balancing", vt_lb_spec_label, static_cast(appConfig.vt_lb_spec)}, + {"Load Balancing", vt_lb_spec_file_label, static_cast(appConfig.vt_lb_spec_file)}, + + // Diagnostics + {"Diagnostics", vt_diag_enable_label, static_cast(appConfig.vt_diag_enable)}, + {"Diagnostics", vt_diag_print_summary_label, static_cast(appConfig.vt_diag_print_summary)}, + {"Diagnostics", vt_diag_summary_file_label, static_cast(appConfig.vt_diag_summary_file)}, + {"Diagnostics", vt_diag_summary_csv_file_label, static_cast(appConfig.vt_diag_summary_csv_file)}, + {"Diagnostics", vt_diag_csv_base_units_label, static_cast(appConfig.vt_diag_csv_base_units)}, + + // Termination + {"Termination", vt_no_detect_hang_label, static_cast(appConfig.vt_no_detect_hang)}, + {"Termination", vt_term_rooted_use_ds_label, static_cast(appConfig.vt_term_rooted_use_ds)}, + {"Termination", vt_term_rooted_use_wave_label, static_cast(appConfig.vt_term_rooted_use_wave)}, + {"Termination", vt_epoch_graph_on_hang_label, static_cast(appConfig.vt_epoch_graph_on_hang)}, + {"Termination", vt_epoch_graph_terse_label, static_cast(appConfig.vt_epoch_graph_terse)}, + {"Termination", vt_print_no_progress_label, static_cast(appConfig.vt_print_no_progress)}, + {"Termination", vt_hang_freq_label, static_cast(appConfig.vt_hang_freq)}, + + // Debugging/Launch + {"Launch", vt_pause_label, static_cast(appConfig.vt_pause)}, + + // User Options + {"User Options", user_args_labels["vt_user_1"], static_cast(appConfig.vt_user_1)}, + {"User Options", user_args_labels["vt_user_2"], static_cast(appConfig.vt_user_2)}, + {"User Options", user_args_labels["vt_user_3"], static_cast(appConfig.vt_user_3)}, + {"User Options", user_args_labels["vt_user_int_1"], static_cast(appConfig.vt_user_int_1)}, + {"User Options", user_args_labels["vt_user_int_2"], static_cast(appConfig.vt_user_int_2)}, + {"User Options", user_args_labels["vt_user_int_3"], static_cast(appConfig.vt_user_int_3)}, + {"User Options", user_args_labels["vt_user_str_1"], static_cast(appConfig.vt_user_str_1)}, + {"User Options", user_args_labels["vt_user_str_2"], static_cast(appConfig.vt_user_str_2)}, + {"User Options", user_args_labels["vt_user_str_3"], static_cast(appConfig.vt_user_str_3)}, + + // Scheduler Configuration + {"Scheduler Configuration", vt_sched_num_progress_label, static_cast(appConfig.vt_sched_num_progress)}, + {"Scheduler Configuration", vt_sched_progress_han_label, static_cast(appConfig.vt_sched_progress_han)}, + {"Scheduler Configuration", vt_sched_progress_sec_label, static_cast(appConfig.vt_sched_progress_sec)}, + + // Configuration File + {"Configuration File", vt_output_config_label, static_cast(appConfig.vt_output_config)}, + {"Configuration File", vt_output_config_file_label, static_cast(appConfig.vt_output_config_file)}, + + // Runtime + {"Runtime", vt_max_mpi_send_size_label, static_cast(appConfig.vt_max_mpi_send_size)}, + {"Runtime", vt_no_assert_fail_label, static_cast(appConfig.vt_no_assert_fail)}, + {"Runtime", vt_throw_on_abort_label, static_cast(appConfig.vt_throw_on_abort)} + }; + + // Create an empty node that we will populate + YAML::Node output_config_yaml; + + // Then convert to YAML + for (const auto& yaml_data : cli_to_yaml_args) { + + // Unpack the yaml data + auto [yaml_node, yaml_key, yaml_val] = yaml_data; + + // First, explicitly handle the Debug Print Configuration list + if (yaml_node == "Debug Print Configuration/Enable") { + if (std::get(yaml_val)) { + output_config_yaml["Debug Print Configuration"]["Enable"].push_back(yaml_key); + } + } + // Then handle the User Defined parameters + else if (yaml_node == "User Options" and yaml_key != "unused_user_param") { + auto current_node = output_config_yaml["User Options"]; + addVariantToNode(current_node, yaml_key, yaml_val); + } + // Then handle any nested nodes (with "/" in them) + else if (yaml_node.find("/") != yaml_node.npos) { + auto nodes = util::demangle::DemanglerUtils::splitString(yaml_node, '/'); + auto current_node = output_config_yaml[nodes[0]][nodes[1]]; + addVariantToNode(current_node, yaml_key, yaml_val); + } + // The rest are straightforward + else { + auto current_node = output_config_yaml[yaml_node]; + addVariantToNode(current_node, yaml_key, yaml_val); + } + } + std::ostringstream yaml_stream; + yaml_stream << output_config_yaml; + return yaml_stream.str(); +} + +void convertConfigToString(CLI::App& app, AppConfig& appConfig) { + auto output_file = appConfig.vt_output_config_file; + auto config_file_ending = output_file.substr(output_file.size()-4); + if (config_file_ending == ".yml" || config_file_ending == "yaml") { + appConfig.vt_output_config_str = convertConfigToYamlString(appConfig); + } else { + appConfig.vt_output_config_str = app.config_to_str(true, true); + } +} + } /* end anon namespace */ /*static*/ std::unique_ptr @@ -727,6 +1384,11 @@ class VtFormatter : public CLI::Formatter { "It is an error if an unexpected argument is encountered in VT argument mode.\n" "The currently recognized VT arguments are listed below; availability varies\n" "based on build and compilation settings.\n" +"\n" +"VT arguments can also be provided via configuration file. Pass a TOML or ini config\n" +"file with --vt_input_config, or a YAML config file with --vt_input_config_yaml.\n" +"Command line arguments will overwrite any configuration file (and a TOML or ini\n" +"file will overwrite a YAML configuration).\n" << "\n"; return u.str(); } @@ -763,6 +1425,16 @@ std::tuple ArgConfig::parseToConfig( app.set_help_flag("--vt_help", "Display help"); + // Allow a input config file + app.set_config( + "--vt_input_config", + "", // no default file name + "Read in an ini or toml config file for VT", + false // not required + ); + + // Set up CLI parsing + addYamlArgs(app, appConfig); addColorArgs(app, appConfig); addSignalArgs(app, appConfig); addMemUsageArgs(app, appConfig); diff --git a/tests/unit/runtime/test_initialization.cc b/tests/unit/runtime/test_initialization.cc index 00309635f1..7f2a923da4 100644 --- a/tests/unit/runtime/test_initialization.cc +++ b/tests/unit/runtime/test_initialization.cc @@ -51,6 +51,8 @@ #include #include +#include + #include #include @@ -168,7 +170,7 @@ TEST_F(TestInitialization, test_initialize_with_args_and_appconfig) { EXPECT_EQ(custom_argv[2], nullptr); } -TEST_F(TestInitialization, test_initialize_with_file_and_args) { +TEST_F(TestInitialization, test_initialize_with_toml_file_and_args) { MPI_Comm comm = MPI_COMM_WORLD; static char prog_name[]{"vt_program"}; @@ -214,7 +216,7 @@ TEST_F(TestInitialization, test_initialize_with_file_and_args) { EXPECT_EQ(custom_argv[2], nullptr); } -TEST_F(TestInitialization, test_initialize_with_file_args_and_appconfig) { +TEST_F(TestInitialization, test_initialize_with_toml_file_args_and_appconfig) { MPI_Comm comm = MPI_COMM_WORLD; static char prog_name[]{"vt_program"}; @@ -263,65 +265,244 @@ TEST_F(TestInitialization, test_initialize_with_file_args_and_appconfig) { EXPECT_EQ(custom_argv[2], nullptr); } -TEST_F(TestInitialization, test_preconfigure_and_initialization) { +TEST_F(TestInitialization, test_initialize_with_yaml) { MPI_Comm comm = MPI_COMM_WORLD; static char prog_name[]{"vt_program"}; - static char cli_argument[]{"--cli_argument=100"}; - static char vt_no_terminate[]{"--vt_no_terminate"}; - static char vt_lb_name[]{"--vt_lb_name=RotateLB"}; - std::string config_file(getUniqueFilenameWithRanks(".toml")); - std::string config_flag("--vt_input_config="); + std::string config_file(getUniqueFilenameWithRanks(".yaml")); + std::string config_flag("--vt_input_config_yaml="); std::string vt_input_config = config_flag + config_file; std::vector custom_args; custom_args.emplace_back(prog_name); - custom_args.emplace_back(cli_argument); - custom_args.emplace_back(vt_no_terminate); custom_args.emplace_back(strdup(vt_input_config.c_str())); - custom_args.emplace_back(vt_lb_name); custom_args.emplace_back(nullptr); int custom_argc = custom_args.size() - 1; char** custom_argv = custom_args.data(); - EXPECT_EQ(custom_argc, 5); - - arguments::AppConfig appConfig{}; - appConfig.vt_lb_name = "GreedyLB"; + EXPECT_EQ(custom_argc, 2); int this_rank; MPI_Comm_rank(comm, &this_rank); if (this_rank == 0) { std::ofstream cfg_file_{config_file.c_str(), std::ofstream::out | std::ofstream::trunc}; - cfg_file_ << "vt_lb_name = RandomLB\n"; + cfg_file_ << R"( + Output Control: + Color: False + Quiet: True + Signal Handling: + Disable SIGINT: True + Disable SIGSEGV: True + Disable SIGBUS: True + Disable Terminate Signal: True + Memory Usage Reporting: + Print Memory Each Phase: True + Print Memory On Node: '1' + Allow Memory Report With ps: True + Tracing Configuration: + Enabled: False + Debug Print Configuration: + Level: normal + Enable: + - gen + - term + - pool + - group + Load Balancing: + Enabled: False + LB Data Output: + Enabled: False + LB Data Input: + Enabled: False + LB Statistics: + Enabled: False + Diagnostics: + Enabled: True + Enable Print Summary: True + Termination: + No Detect Hangs: True + Terse Epoch Graph Output: True + Launch: + Pause: False + User Options: + Test bool: True + Test int: 45 + Test string: test_string + Scheduler Configuration: + Num Progress Times: 3 + Runtime: + Throw on Abort: True + Configuration File: + Enable Output Config: True + File: test_config.yaml + )"; cfg_file_.close(); } - MPI_Barrier(comm); - - auto vtConfig = vt::preconfigure(custom_argc, custom_argv); - EXPECT_EQ(custom_argc, 2); - EXPECT_STREQ(custom_argv[0], "vt_program"); - EXPECT_STREQ(custom_argv[1], "--cli_argument=100"); - EXPECT_EQ(custom_argv[2], nullptr); + MPI_Barrier(comm); - vt::initializePreconfigured(&comm, &appConfig); + vt::initialize(custom_argc, custom_argv, &comm); - EXPECT_EQ(theConfig()->prog_name, "vt_unknown"); - EXPECT_EQ(theConfig()->vt_no_terminate, false); - EXPECT_EQ(theConfig()->vt_lb_name, "GreedyLB"); + // TEST THAT THE CONFIGURATION FILE WAS READ IN CORRECTLY + EXPECT_EQ(theConfig()->prog_name, "vt_program"); - vt::finalize(); - vt::initializePreconfigured(&comm, &appConfig, vtConfig.get()); + // Output Control + EXPECT_EQ(theConfig()->vt_color, false); +#ifdef VT_NO_COLOR_ENABLED + EXPECT_EQ(theConfig()->vt_no_color, true); +#else + EXPECT_EQ(theConfig()->vt_no_color, false); +#endif + EXPECT_EQ(theConfig()->vt_quiet, true); - EXPECT_EQ(theConfig()->prog_name, "vt_program"); + // Signal Handling + EXPECT_EQ(theConfig()->vt_no_sigint, true); + EXPECT_EQ(theConfig()->vt_no_sigsegv, true); + EXPECT_EQ(theConfig()->vt_no_sigbus, true); EXPECT_EQ(theConfig()->vt_no_terminate, true); - EXPECT_EQ(theConfig()->vt_lb_name, "RotateLB"); - vt::finalize(); - vt::initializePreconfigured(&comm, &appConfig, vtConfig.get()); + // Memory Usage Reporting + EXPECT_EQ(theConfig()->vt_print_memory_each_phase, true); + EXPECT_EQ(theConfig()->vt_print_memory_node, "1"); + EXPECT_EQ(theConfig()->vt_allow_memory_report_with_ps, true); + EXPECT_EQ(theConfig()->vt_print_memory_threshold, "1 GiB"); + EXPECT_EQ(theConfig()->vt_print_memory_sched_poll, 100); + EXPECT_EQ(theConfig()->vt_print_memory_footprint, false); + + // Dump Stack Backtrace + EXPECT_EQ(theConfig()->vt_no_warn_stack, false); + EXPECT_EQ(theConfig()->vt_no_assert_stack, false); + EXPECT_EQ(theConfig()->vt_no_abort_stack, false); + EXPECT_EQ(theConfig()->vt_no_stack, false); + EXPECT_EQ(theConfig()->vt_stack_file, ""); + EXPECT_EQ(theConfig()->vt_stack_dir, ""); + EXPECT_EQ(theConfig()->vt_stack_mod, 0); + + // Tracing Configuration + EXPECT_EQ(theConfig()->vt_trace, false); + EXPECT_EQ(theConfig()->vt_trace_mpi, false); + EXPECT_EQ(theConfig()->vt_trace_pmpi, false); + EXPECT_EQ(theConfig()->vt_trace_mod, 0); + EXPECT_EQ(theConfig()->vt_trace_flush_size, 0); + EXPECT_EQ(theConfig()->vt_trace_gzip_finish_flush, false); + EXPECT_EQ(theConfig()->vt_trace_sys_all, false); + EXPECT_EQ(theConfig()->vt_trace_sys_term, false); + EXPECT_EQ(theConfig()->vt_trace_sys_location, false); + EXPECT_EQ(theConfig()->vt_trace_sys_collection, false); + EXPECT_EQ(theConfig()->vt_trace_sys_serial_msg, false); + EXPECT_EQ(theConfig()->vt_trace_spec, false); + EXPECT_EQ(theConfig()->vt_trace_spec_file, ""); + EXPECT_EQ(theConfig()->vt_trace_memory_usage, false); + EXPECT_EQ(theConfig()->vt_trace_event_polling, false); + EXPECT_EQ(theConfig()->vt_trace_irecv_polling, false); + + + EXPECT_EQ(theConfig()->vt_debug_level, "normal"); + EXPECT_EQ(theConfig()->vt_debug_all, false); + EXPECT_EQ(theConfig()->vt_debug_none, false); + EXPECT_EQ(theConfig()->vt_debug_print_flush, false); + EXPECT_EQ(theConfig()->vt_debug_gen, true); + EXPECT_EQ(theConfig()->vt_debug_runtime, false); + EXPECT_EQ(theConfig()->vt_debug_active, false); + EXPECT_EQ(theConfig()->vt_debug_term, true); + EXPECT_EQ(theConfig()->vt_debug_termds, false); + EXPECT_EQ(theConfig()->vt_debug_barrier, false); + EXPECT_EQ(theConfig()->vt_debug_event, false); + EXPECT_EQ(theConfig()->vt_debug_pipe, false); + EXPECT_EQ(theConfig()->vt_debug_pool, true); + EXPECT_EQ(theConfig()->vt_debug_reduce, false); + EXPECT_EQ(theConfig()->vt_debug_rdma, false); + EXPECT_EQ(theConfig()->vt_debug_rdma_channel, false); + EXPECT_EQ(theConfig()->vt_debug_rdma_state, false); + EXPECT_EQ(theConfig()->vt_debug_handler, false); + EXPECT_EQ(theConfig()->vt_debug_hierlb, false); + EXPECT_EQ(theConfig()->vt_debug_temperedlb, false); + EXPECT_EQ(theConfig()->vt_debug_temperedwmin, false); + EXPECT_EQ(theConfig()->vt_debug_scatter, false); + EXPECT_EQ(theConfig()->vt_debug_serial_msg, false); + EXPECT_EQ(theConfig()->vt_debug_trace, false); + EXPECT_EQ(theConfig()->vt_debug_location, false); + EXPECT_EQ(theConfig()->vt_debug_lb, false); + EXPECT_EQ(theConfig()->vt_debug_vrt, false); + EXPECT_EQ(theConfig()->vt_debug_vrt_coll, false); + EXPECT_EQ(theConfig()->vt_debug_worker, false); + EXPECT_EQ(theConfig()->vt_debug_group, true); + EXPECT_EQ(theConfig()->vt_debug_broadcast, false); + EXPECT_EQ(theConfig()->vt_debug_objgroup, false); + EXPECT_EQ(theConfig()->vt_debug_phase, false); + EXPECT_EQ(theConfig()->vt_debug_context, false); + EXPECT_EQ(theConfig()->vt_debug_epoch, false); + + // Load Balancing + EXPECT_EQ(theConfig()->vt_lb, false); + EXPECT_EQ(theConfig()->vt_lb_quiet, false); + EXPECT_EQ(theConfig()->vt_lb_file_name, ""); + EXPECT_EQ(theConfig()->vt_lb_show_config, false); + EXPECT_EQ(theConfig()->vt_lb_name, "NoLB"); + EXPECT_EQ(theConfig()->vt_lb_args, ""); + EXPECT_EQ(theConfig()->vt_lb_interval, 1); + EXPECT_EQ(theConfig()->vt_lb_keep_last_elm, false); + EXPECT_EQ(theConfig()->vt_lb_data, false); + EXPECT_EQ(theConfig()->vt_lb_data_dir, "vt_lb_data"); + EXPECT_EQ(theConfig()->vt_lb_data_file, "data.%p.json"); + EXPECT_EQ(theConfig()->vt_lb_data_in, false); + EXPECT_EQ(theConfig()->vt_lb_data_compress, true); + EXPECT_EQ(theConfig()->vt_lb_data_dir_in, "vt_lb_data_in"); + EXPECT_EQ(theConfig()->vt_lb_data_file_in, "data.%p.json"); + EXPECT_EQ(theConfig()->vt_lb_statistics, false); + EXPECT_EQ(theConfig()->vt_lb_statistics_compress, true); + EXPECT_EQ(theConfig()->vt_lb_statistics_file, "vt_lb_statistics.%t.json"); + EXPECT_EQ(theConfig()->vt_lb_statistics_dir, ""); + EXPECT_EQ(theConfig()->vt_lb_self_migration, false); + EXPECT_EQ(theConfig()->vt_lb_spec, false); + EXPECT_EQ(theConfig()->vt_lb_spec_file, ""); + + // Diagnostics + EXPECT_EQ(theConfig()->vt_diag_enable, true); + EXPECT_EQ(theConfig()->vt_diag_print_summary, true); + EXPECT_EQ(theConfig()->vt_diag_summary_file, "vtdiag.txt"); + EXPECT_EQ(theConfig()->vt_diag_summary_csv_file, ""); + EXPECT_EQ(theConfig()->vt_diag_csv_base_units, false); + + // Termination + EXPECT_EQ(theConfig()->vt_no_detect_hang, true); + EXPECT_EQ(theConfig()->vt_term_rooted_use_ds, false); + EXPECT_EQ(theConfig()->vt_term_rooted_use_wave, false); + EXPECT_EQ(theConfig()->vt_epoch_graph_on_hang, true); + EXPECT_EQ(theConfig()->vt_epoch_graph_terse, true); + EXPECT_EQ(theConfig()->vt_print_no_progress, true); + EXPECT_EQ(theConfig()->vt_hang_freq, 1024); + + // Debugging/Launch + EXPECT_EQ(theConfig()->vt_pause, false); + + // User Options + EXPECT_EQ(theConfig()->vt_user_1, true); + EXPECT_EQ(theConfig()->vt_user_2, false); + EXPECT_EQ(theConfig()->vt_user_3, false); + EXPECT_EQ(theConfig()->vt_user_int_1, 45); + EXPECT_EQ(theConfig()->vt_user_int_2, 0); + EXPECT_EQ(theConfig()->vt_user_int_3, 0); + EXPECT_EQ(theConfig()->vt_user_str_1, "test_string"); + EXPECT_EQ(theConfig()->vt_user_str_2, ""); + EXPECT_EQ(theConfig()->vt_user_str_3, ""); + + // Scheduler Configuration + EXPECT_EQ(theConfig()->vt_sched_num_progress, 3); + EXPECT_EQ(theConfig()->vt_sched_progress_han, 0); + EXPECT_EQ(theConfig()->vt_sched_progress_sec, 0); + + // Runtime + EXPECT_EQ(theConfig()->vt_max_mpi_send_size, 1ull << 30); + EXPECT_EQ(theConfig()->vt_no_assert_fail, false); + EXPECT_EQ(theConfig()->vt_throw_on_abort, true); + + // TEST THAT THE CONFIGURATION FILE WAS WRITTEN OUT CORRECTLY + YAML::Node input_config = YAML::LoadFile(config_file); + YAML::Node output_config = YAML::Load(theConfig()->vt_output_config_str); + assertYamlNodesHaveIdenticalEntries(input_config, output_config); } void prepareLBDataFiles(const std::string file_name_without_ext) { @@ -409,7 +590,7 @@ TEST_F(TestInitialization, test_initialize_without_restart_reader) { TEST_F(TestInitialization, test_initialize_with_lb_data_in) { MPI_Comm comm = MPI_COMM_WORLD; - // Preapre data files + // Prepare data files auto prefix = getUniqueFilenameWithRanks(); prepareLBDataFiles(prefix); @@ -442,11 +623,11 @@ TEST_F(TestInitialization, test_initialize_with_lb_data_in) { TEST_F(TestInitialization, test_initialize_with_lb_data_and_config_offline_lb) { MPI_Comm comm = MPI_COMM_WORLD; - // Preapre data files + // Prepare data files auto prefix = getUniqueFilenameWithRanks(); prepareLBDataFiles(prefix); - // Preapre configuration file + // Prepare configuration file std::string file_name = getUniqueFilenameWithRanks(".txt"); std::ofstream out(file_name); out << "0 OfflineLB\n"; @@ -483,11 +664,11 @@ TEST_F(TestInitialization, test_initialize_with_lb_data_and_config_offline_lb) { TEST_F(TestInitialization, test_initialize_with_lb_data_and_no_lb) { MPI_Comm comm = MPI_COMM_WORLD; - // Preapre data files + // Prepare data files auto prefix = getUniqueFilenameWithRanks(); prepareLBDataFiles(prefix); - // Preapre configuration file + // Prepare configuration file std::string file_name = getUniqueFilenameWithRanks(".txt"); std::ofstream out(file_name); out << "0 NoLB\n"; @@ -524,7 +705,7 @@ TEST_F(TestInitialization, test_initialize_with_lb_data_and_no_lb) { TEST_F(TestInitialization, test_initialize_with_lb_data_and_offline_lb) { MPI_Comm comm = MPI_COMM_WORLD; - // Preapre data files + // Prepare data files auto prefix = getUniqueFilenameWithRanks(); prepareLBDataFiles(prefix); @@ -560,11 +741,11 @@ TEST_F(TestInitialization, test_initialize_with_lb_data_and_offline_lb) { TEST_F(TestInitialization, test_initialize_with_lb_data_and_config_no_lb) { MPI_Comm comm = MPI_COMM_WORLD; - // Preapre data files + // Prepare data files auto prefix = getUniqueFilenameWithRanks(); prepareLBDataFiles(prefix); - // Preapre configuration file + // Prepare configuration file std::string file_name = getUniqueFilenameWithRanks(".txt"); std::ofstream out(file_name); out << "0 NoLB\n"; @@ -598,4 +779,68 @@ TEST_F(TestInitialization, test_initialize_with_lb_data_and_config_no_lb) { EXPECT_TRUE(theLBDataReader() == nullptr); } +TEST_F(TestInitialization, test_initialize_with_yaml_toml_and_args) { + MPI_Comm comm = MPI_COMM_WORLD; + + // Set command line arguments + static char prog_name[]{"vt_program"}; + static char vt_debug_level[]{"--vt_debug_level=verbose"}; + + std::vector custom_args; + custom_args.emplace_back(prog_name); + custom_args.emplace_back(vt_debug_level); + + // Set TOML config file + std::string toml_config_file(getUniqueFilenameWithRanks(".toml")); + std::string toml_config_flag("--vt_input_config="); + std::string vt_input_config_toml = toml_config_flag + toml_config_file; + + custom_args.emplace_back(strdup(vt_input_config_toml.c_str())); + + int this_rank; + MPI_Comm_rank(comm, &this_rank); + + if (this_rank == 0) { + std::ofstream toml_cfg_file_{toml_config_file.c_str(), std::ofstream::out | std::ofstream::trunc}; + toml_cfg_file_ << "vt_debug_level = terse\n" + << "vt_color = False"; + toml_cfg_file_.close(); + } + MPI_Barrier(comm); + + // Set YAML config file + std::string yaml_config_file(getUniqueFilenameWithRanks(".yaml")); + std::string yaml_config_flag("--vt_input_config_yaml="); + std::string vt_input_config_yaml = yaml_config_flag + yaml_config_file; + + custom_args.emplace_back(strdup(vt_input_config_yaml.c_str())); + custom_args.emplace_back(nullptr); + + int custom_argc = custom_args.size() - 1; + char** custom_argv = custom_args.data(); + + if (this_rank == 0) { + std::ofstream yaml_cfg_file_{yaml_config_file.c_str(), std::ofstream::out | std::ofstream::trunc}; + yaml_cfg_file_ << R"( + Output Control: + Color: True + Quiet: True + Debug Print Configuration: + Level: normal + )"; + yaml_cfg_file_.close(); + } + + MPI_Barrier(comm); + + vt::initialize(custom_argc, custom_argv, &comm); + + // Test that everything was read in correctly + EXPECT_EQ(theConfig()->prog_name, "vt_program"); + + EXPECT_EQ(theConfig()->vt_quiet, true); // yaml + EXPECT_EQ(theConfig()->vt_color, false); // toml overwrites yaml + EXPECT_EQ(theConfig()->vt_debug_level, "verbose"); // args overwrite everything +} + }}} // end namespace vt::tests::unit diff --git a/tests/unit/test_helpers.h b/tests/unit/test_helpers.h index 71ab2d994f..88d882a90f 100644 --- a/tests/unit/test_helpers.h +++ b/tests/unit/test_helpers.h @@ -46,6 +46,7 @@ #include "vt/context/context.h" #include +#include #include #include @@ -101,6 +102,48 @@ inline std::string getUniqueFilenameWithRanks(const std::string& ext = "") { return ss.str(); } +/** + * Compare two YAML::Nodes and assert that they are either identical or that + * yaml_1 is a subset of yaml_2 (all entries of yaml_1 exist in yaml_2). + */ +inline void assertYamlNodesHaveIdenticalEntries(const YAML::Node& yaml_1, const YAML::Node& yaml_2) { + EXPECT_TRUE(yaml_2.IsMap() and yaml_1.IsMap()); + + for (YAML::const_iterator it = yaml_1.begin(); it != yaml_1.end(); ++it) { + const std::string& key = it->first.as(); + + EXPECT_TRUE(yaml_2[key].IsDefined()); + + auto yaml_1_val = yaml_1[key]; + auto yaml_2_val = yaml_2[key]; + + EXPECT_EQ(yaml_1_val.Type(), yaml_2_val.Type()); + + if (yaml_1_val.IsMap()) { + assertYamlNodesHaveIdenticalEntries(yaml_1_val, yaml_2_val); + } + else if (yaml_1_val.IsSequence()) { + for (std::size_t i = 0; i < yaml_1_val.size(); i++) { + EXPECT_EQ(yaml_1_val[i].as(), yaml_2_val[i].as()); + } + } + else if (yaml_1_val.IsScalar()) { + try { + EXPECT_EQ(yaml_1_val.as(), yaml_2_val.as()); + } catch (const YAML::RepresentationException&) { + try { + EXPECT_EQ(yaml_1_val.as(), yaml_2_val.as()); + } catch (const YAML::RepresentationException&) { + EXPECT_EQ(yaml_1_val.as(), yaml_2_val.as()); + } + } + } + else { + vtAbort("YAML::Node type not recognized (must be Map, Sequence, or Scalar)"); + } + } +} + /** * The following helper macros (these have to be macros, because GTEST_SKIP * won't work from nested call) are meant to ensure that the test will be