From 57e691e28eb773467ccaa0ffdb4c73261cea4d23 Mon Sep 17 00:00:00 2001 From: Kim Kulling Date: Sun, 25 Oct 2020 10:34:43 +0100 Subject: [PATCH] openddl: latest greatest. --- code/AssetLib/Blender/BlenderDNA.cpp | 1 - code/AssetLib/Blender/BlenderDNA.h | 13 +- code/AssetLib/Blender/BlenderLoader.h | 43 +- code/AssetLib/Blender/BlenderScene.h | 7 +- code/Common/Version.cpp | 6 +- contrib/CMakeLists.txt | 169 +++ contrib/openddlparser/CMakeLists.txt | 24 +- contrib/openddlparser/code/DDLNode.cpp | 144 +-- contrib/openddlparser/code/OpenDDLCommon.cpp | 144 ++- contrib/openddlparser/code/OpenDDLExport.cpp | 340 +++--- contrib/openddlparser/code/OpenDDLParser.cpp | 986 +++++++++--------- contrib/openddlparser/code/OpenDDLStream.cpp | 30 +- contrib/openddlparser/code/Value.cpp | 390 ++++--- .../include/openddlparser/DDLNode.h | 38 +- .../include/openddlparser/OpenDDLCommon.h | 149 ++- .../include/openddlparser/OpenDDLExport.h | 26 +- .../include/openddlparser/OpenDDLParser.h | 106 +- .../openddlparser/OpenDDLParserUtils.h | 450 ++++++-- .../include/openddlparser/OpenDDLStream.h | 8 +- .../include/openddlparser/TPoolAllocator.h | 226 ++++ .../include/openddlparser/Value.h | 4 +- 21 files changed, 1940 insertions(+), 1364 deletions(-) create mode 100644 contrib/openddlparser/include/openddlparser/TPoolAllocator.h diff --git a/code/AssetLib/Blender/BlenderDNA.cpp b/code/AssetLib/Blender/BlenderDNA.cpp index ad0760914..cd9bce66f 100644 --- a/code/AssetLib/Blender/BlenderDNA.cpp +++ b/code/AssetLib/Blender/BlenderDNA.cpp @@ -139,7 +139,6 @@ void DNAParser::Parse() { dna.structures.push_back(Structure()); Structure &s = dna.structures.back(); s.name = types[n].name; - //s.index = dna.structures.size()-1; n = stream.GetI2(); s.fields.reserve(n); diff --git a/code/AssetLib/Blender/BlenderDNA.h b/code/AssetLib/Blender/BlenderDNA.h index a084dbdbd..25322a374 100644 --- a/code/AssetLib/Blender/BlenderDNA.h +++ b/code/AssetLib/Blender/BlenderDNA.h @@ -83,10 +83,9 @@ class ObjectCache; * ancestry. */ // ------------------------------------------------------------------------------- struct Error : DeadlyImportError { - template - explicit Error(T&&... args) - : DeadlyImportError(args...) - { + template + explicit Error(T &&...args) : + DeadlyImportError(args...) { } }; @@ -187,7 +186,7 @@ struct Field { }; // ------------------------------------------------------------------------------- -/** Range of possible behaviours for fields absend in the input file. Some are +/** Range of possible behaviors for fields absence in the input file. Some are * mission critical so we need them, while others can silently be default * initialized and no animations are harmed. */ // ------------------------------------------------------------------------------- @@ -395,7 +394,7 @@ private: // -------------------------------------------------------- template <> -struct Structure ::_defaultInitializer { +struct Structure::_defaultInitializer { template void operator()(T &out, const char *reason = "") { @@ -407,7 +406,7 @@ struct Structure ::_defaultInitializer { }; template <> -struct Structure ::_defaultInitializer { +struct Structure::_defaultInitializer { template void operator()(T & /*out*/, const char * = "") { diff --git a/code/AssetLib/Blender/BlenderLoader.h b/code/AssetLib/Blender/BlenderLoader.h index 8110ac946..15a7ea6f0 100644 --- a/code/AssetLib/Blender/BlenderLoader.h +++ b/code/AssetLib/Blender/BlenderLoader.h @@ -106,51 +106,18 @@ class BlenderImporter : public BaseImporter, public LogFunctions& app); - - // -------------------- void SetupProperties(const Importer* pImp); - - // -------------------- - void InternReadFile( const std::string& pFile, - aiScene* pScene, - IOSystem* pIOHandler - ); - - // -------------------- - void ParseBlendFile(Blender::FileDatabase& out, - std::shared_ptr stream - ); - - // -------------------- - void ExtractScene(Blender::Scene& out, - const Blender::FileDatabase& file - ); - - // -------------------- - void ConvertBlendFile(aiScene* out, - const Blender::Scene& in, - const Blender::FileDatabase& file - ); + void InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler); + void ParseBlendFile(Blender::FileDatabase& out, std::shared_ptr stream); + void ExtractScene(Blender::Scene& out, const Blender::FileDatabase& file); + void ConvertBlendFile(aiScene* out, const Blender::Scene& in, const Blender::FileDatabase& file); private: - - // -------------------- aiNode* ConvertNode(const Blender::Scene& in, const Blender::Object* obj, Blender::ConversionData& conv_info, diff --git a/code/AssetLib/Blender/BlenderScene.h b/code/AssetLib/Blender/BlenderScene.h index 980dde6e0..19d19ed01 100644 --- a/code/AssetLib/Blender/BlenderScene.h +++ b/code/AssetLib/Blender/BlenderScene.h @@ -155,7 +155,7 @@ struct World : ElemBase { // ------------------------------------------------------------------------------- struct MVert : ElemBase { float co[3] FAIL; - float no[3] FAIL; // readed as short and divided through / 32767.f + float no[3] FAIL; // read as short and divided through / 32767.f char flag; int mat_nr WARN; int bweight; @@ -228,7 +228,10 @@ struct TFace : ElemBase { // ------------------------------------------------------------------------------- struct MTFace : ElemBase { MTFace() : - flag(0), mode(0), tile(0), unwrap(0) { + flag(0), + mode(0), + tile(0), + unwrap(0) { } float uv[4][2] FAIL; diff --git a/code/Common/Version.cpp b/code/Common/Version.cpp index b040ab729..439e9aac7 100644 --- a/code/Common/Version.cpp +++ b/code/Common/Version.cpp @@ -40,7 +40,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --------------------------------------------------------------------------- */ -// Actually just a dummy, used by the compiler to build the precompiled header. +// Actually just a dummy, used by the compiler to build the pre-compiled header. #include "ScenePrivate.h" #include @@ -51,13 +51,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // -------------------------------------------------------------------------------- // Legal information string - don't remove this. static const char *LEGAL_INFORMATION = - "Open Asset Import Library (Assimp).\n" "A free C/C++ library to import various 3D file formats into applications\n\n" - "(c) 2006-2020, assimp team\n" "License under the terms and conditions of the 3-clause BSD license\n" - "http://assimp.org\n"; + "https://www.assimp.org\n"; // ------------------------------------------------------------------------------------------------ // Get legal string diff --git a/contrib/CMakeLists.txt b/contrib/CMakeLists.txt index 8b1378917..6a38acf5f 100644 --- a/contrib/CMakeLists.txt +++ b/contrib/CMakeLists.txt @@ -1 +1,170 @@ +CMAKE_MINIMUM_REQUIRED( VERSION 2.6 ) +PROJECT( OpenDDL-Parser ) +SET ( OPENDDL_PARSER_VERSION_MAJOR 0 ) +SET ( OPENDDL_PARSER_VERSION_MINOR 1 ) +SET ( OPENDDL_PARSER_VERSION_PATCH 0 ) +SET ( OPENDDL_PARSER_VERSION ${OPENDDL_PARSER_VERSION_MAJOR}.${OPENDDL_PARSER_VERSION_MINOR}.${OPENDDL_PARSER_VERSION_PATCH} ) +SET ( PROJECT_VERSION "${OPENDDL_PARSER_VERSION}" ) +option( DDL_DEBUG_OUTPUT "Set to ON to use output debug texts" OFF ) +option( DDL_STATIC_LIBRARY "Set to ON to build static libary of OpenDDL Parser." ON ) +option( COVERALLS "Generate coveralls data" OFF ) + +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD_REQUIRED ON) + +if( CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX ) + find_package(Threads) +else() + add_definitions( -D_CRT_SECURE_NO_WARNINGS ) +endif() + +if ( DDL_STATIC_LIBRARY ) + add_definitions( -DOPENDDL_STATIC_LIBARY ) +endif() + +if (MSVC) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /D_SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING") + add_definitions(-DGTEST_HAS_TR1_TUPLE=0) +endif() + +add_definitions( -DOPENDDLPARSER_BUILD ) +add_definitions( -D_VARIADIC_MAX=10 ) +add_definitions( -DGTEST_HAS_PTHREAD=0 ) +if ( DDL_DEBUG_OUTPUT ) + add_definitions( -DDDL_DEBUG_HEADER_NAME) +endif() + +INCLUDE_DIRECTORIES( + ./ + include/ + contrib/gtest-1.7.0/include + contrib/gtest-1.7.0/ +) + +link_directories( + ${CMAKE_HOME_DIRECTORY}/lib +) + +SET( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/cmake ) +SET( CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_HOME_DIRECTORY}/lib ) +SET( CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_HOME_DIRECTORY}/lib ) +SET( CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_HOME_DIRECTORY}/bin ) + +if( WIN32 AND NOT CYGWIN ) + set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc" ) # Force to always compile with W4 + if( CMAKE_CXX_FLAGS MATCHES "/W[0-4]" ) + string( REGEX REPLACE "/W[0-4]" "/W4" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" ) + else() + set( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4" ) + endif() +elseif( CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX ) + # Update if necessary + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-long-long -pedantic ${OPENDDL_CXXFLAGS}") +elseif ( "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" ) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -Wno-long-long -pedantic ${OPENDDL_CXXFLAGS} -Wwrite-strings") +endif() + +if (COVERALLS) + include(Coveralls) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -O0 -fprofile-arcs -ftest-coverage") + set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -O0 -fprofile-arcs -ftest-coverage") +endif() + +# Include the doc component. +FIND_PACKAGE( doxygen ) +IF ( DOXYGEN_FOUND ) + CONFIGURE_FILE( doc/openddlparser_doc.in doc/doxygenfile @ONLY ) + ADD_CUSTOM_TARGET( doc ALL ${DOXYGEN_EXECUTABLE} doc/doxygenfile + WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR} + COMMENT "Generating API documentation with Doxygen" VERBATIM ) +ENDIF ( DOXYGEN_FOUND ) + +SET ( openddl_parser_src + code/OpenDDLCommon.cpp + code/OpenDDLExport.cpp + code/OpenDDLParser.cpp + code/OpenDDLStream.cpp + code/DDLNode.cpp + code/Value.cpp + include/openddlparser/OpenDDLCommon.h + include/openddlparser/OpenDDLExport.h + include/openddlparser/OpenDDLParser.h + include/openddlparser/OpenDDLParserUtils.h + include/openddlparser/OpenDDLStream.h + include/openddlparser/DDLNode.h + include/openddlparser/Value.h + include/openddlparser/TPoolAllocator.h + README.md +) + +SOURCE_GROUP( code FILES ${openddl_parser_src} ) + +if ( DDL_STATIC_LIBRARY ) + ADD_LIBRARY( openddl_parser STATIC + ${openddl_parser_src} + ) +else() + ADD_LIBRARY( openddl_parser SHARED + ${openddl_parser_src} + ) +endif() + +SET ( GTEST_PATH contrib/gtest-1.7.0 ) + +SET ( gtest_src + ${GTEST_PATH}/src/gtest-death-test.cc + ${GTEST_PATH}/src/gtest-filepath.cc + ${GTEST_PATH}/src/gtest-internal-inl.h + ${GTEST_PATH}/src/gtest-port.cc + ${GTEST_PATH}/src/gtest-printers.cc + ${GTEST_PATH}/src/gtest-test-part.cc + ${GTEST_PATH}/src/gtest-typed-test.cc + ${GTEST_PATH}/src/gtest.cc +) + +SET( openddl_parser_unittest_src + test/UnitTestCommon.h + test/DDLNodeTest.cpp + test/OpenDDLCommonTest.cpp + test/OpenDDLExportTest.cpp + test/OpenDDLParserTest.cpp + test/OpenDDLParserUtilsTest.cpp + test/OpenDDLStreamTest.cpp + test/OpenDDLIntegrationTest.cpp + test/ValueTest.cpp + test/OpenDDLDefectsTest.cpp + test/OssFuzzTest.cpp + test/main.cpp +) +add_definitions(-DOPENDDL_TEST_DATA="${CMAKE_CURRENT_LIST_DIR}/test/TestData") + +SOURCE_GROUP( code FILES ${openddl_parser_unittest_src} ) +SOURCE_GROUP( gtest FILES ${gtest_src} ) + +ADD_EXECUTABLE( openddl_parser_unittest + ${gtest_src} + ${openddl_parser_unittest_src} +) + +target_link_libraries( openddl_parser_unittest openddl_parser ${CMAKE_THREAD_LIBS_INIT} ) + +SET( openddl_parser_demo_src + demo/main.cpp +) + +if (COVERALLS) + set(COVERAGE_SRCS ${gtest_src} ${openddl_parser_unittest_src} ) + + # Create the coveralls target. + coveralls_setup( + "${COVERAGE_SRCS}" # The source files. + ON # If we should upload. + "${PROJECT_SOURCE_DIR}/cmake/") # (Optional) Alternate project cmake module path. +endif() + +ADD_EXECUTABLE( openddl_parser_demo + ${openddl_parser_demo_src} +) + +target_link_libraries( openddl_parser_demo openddl_parser ) diff --git a/contrib/openddlparser/CMakeLists.txt b/contrib/openddlparser/CMakeLists.txt index 9e903ca3f..6a38acf5f 100644 --- a/contrib/openddlparser/CMakeLists.txt +++ b/contrib/openddlparser/CMakeLists.txt @@ -6,20 +6,12 @@ SET ( OPENDDL_PARSER_VERSION_PATCH 0 ) SET ( OPENDDL_PARSER_VERSION ${OPENDDL_PARSER_VERSION_MAJOR}.${OPENDDL_PARSER_VERSION_MINOR}.${OPENDDL_PARSER_VERSION_PATCH} ) SET ( PROJECT_VERSION "${OPENDDL_PARSER_VERSION}" ) -option( DDL_USE_CPP11 "Set to ON to use C++11 features ( always on on windows )." ON ) option( DDL_DEBUG_OUTPUT "Set to ON to use output debug texts" OFF ) option( DDL_STATIC_LIBRARY "Set to ON to build static libary of OpenDDL Parser." ON ) option( COVERALLS "Generate coveralls data" OFF ) -if ( DDL_USE_CPP11 ) - if( CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX ) - set( OPENDDL_CXXFLAGS -std=c++0x ) - elseif("${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") - set( OPENDDL_CXXFLAGS --std=c++11 ) - endif() -else( DDL_USE_CPP11 ) - add_definitions( -DOPENDDL_NO_USE_CPP11 ) -endif( DDL_USE_CPP11) +set(CMAKE_CXX_STANDARD 11) +set(CMAKE_CXX_STANDARD_REQUIRED ON) if( CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX ) find_package(Threads) @@ -31,6 +23,11 @@ if ( DDL_STATIC_LIBRARY ) add_definitions( -DOPENDDL_STATIC_LIBARY ) endif() +if (MSVC) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /D_SILENCE_TR1_NAMESPACE_DEPRECATION_WARNING") + add_definitions(-DGTEST_HAS_TR1_TUPLE=0) +endif() + add_definitions( -DOPENDDLPARSER_BUILD ) add_definitions( -D_VARIADIC_MAX=10 ) add_definitions( -DGTEST_HAS_PTHREAD=0 ) @@ -49,7 +46,7 @@ link_directories( ${CMAKE_HOME_DIRECTORY}/lib ) -set( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/cmake ) +SET( CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/cmake ) SET( CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_HOME_DIRECTORY}/lib ) SET( CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_HOME_DIRECTORY}/lib ) SET( CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_HOME_DIRECTORY}/bin ) @@ -97,6 +94,7 @@ SET ( openddl_parser_src include/openddlparser/OpenDDLStream.h include/openddlparser/DDLNode.h include/openddlparser/Value.h + include/openddlparser/TPoolAllocator.h README.md ) @@ -123,7 +121,6 @@ SET ( gtest_src ${GTEST_PATH}/src/gtest-test-part.cc ${GTEST_PATH}/src/gtest-typed-test.cc ${GTEST_PATH}/src/gtest.cc - ${GTEST_PATH}/src/gtest_main.cc ) SET( openddl_parser_unittest_src @@ -137,7 +134,10 @@ SET( openddl_parser_unittest_src test/OpenDDLIntegrationTest.cpp test/ValueTest.cpp test/OpenDDLDefectsTest.cpp + test/OssFuzzTest.cpp + test/main.cpp ) +add_definitions(-DOPENDDL_TEST_DATA="${CMAKE_CURRENT_LIST_DIR}/test/TestData") SOURCE_GROUP( code FILES ${openddl_parser_unittest_src} ) SOURCE_GROUP( gtest FILES ${gtest_src} ) diff --git a/contrib/openddlparser/code/DDLNode.cpp b/contrib/openddlparser/code/DDLNode.cpp index a7c557fc5..724c5d67b 100644 --- a/contrib/openddlparser/code/DDLNode.cpp +++ b/contrib/openddlparser/code/DDLNode.cpp @@ -1,7 +1,7 @@ /*----------------------------------------------------------------------------------------------- The MIT License (MIT) -Copyright (c) 2014-2015 Kim Kulling +Copyright (c) 2014-2020 Kim Kulling 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 @@ -22,6 +22,7 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -----------------------------------------------------------------------------------------------*/ #include #include +#include #include @@ -29,77 +30,76 @@ BEGIN_ODDLPARSER_NS DDLNode::DllNodeList DDLNode::s_allocatedNodes; -template -inline -static void releaseDataType( T *ptr ) { - if( ddl_nullptr == ptr ) { +template +inline static void releaseDataType(T *ptr) { + if (nullptr == ptr) { return; } - T *current( ddl_nullptr ); - while( ptr ) { + T *current(nullptr); + while (ptr) { current = ptr; ptr = ptr->m_next; delete current; } } -static void releaseReferencedNames( Reference *ref ) { - if( ddl_nullptr == ref ) { +static void releaseReferencedNames(Reference *ref) { + if (nullptr == ref) { return; } delete ref; } -DDLNode::DDLNode( const std::string &type, const std::string &name, size_t idx, DDLNode *parent ) -: m_type( type ) -, m_name( name ) -, m_parent( parent ) -, m_children() -, m_properties( ddl_nullptr ) -, m_value( ddl_nullptr ) -, m_dtArrayList( ddl_nullptr ) -, m_references( ddl_nullptr ) -, m_idx( idx ) { - if( m_parent ) { - m_parent->m_children.push_back( this ); +DDLNode::DDLNode(const std::string &type, const std::string &name, size_t idx, DDLNode *parent) : + m_type(type), + m_name(name), + m_parent(parent), + m_children(), + m_properties(nullptr), + m_value(nullptr), + m_dtArrayList(nullptr), + m_references(nullptr), + m_idx(idx) { + if (m_parent) { + m_parent->m_children.push_back(this); } } DDLNode::~DDLNode() { delete m_properties; delete m_value; - releaseReferencedNames( m_references ); + releaseReferencedNames(m_references); delete m_dtArrayList; - m_dtArrayList = ddl_nullptr; - if( s_allocatedNodes[ m_idx ] == this ) { - s_allocatedNodes[ m_idx ] = ddl_nullptr; + m_dtArrayList = nullptr; + if (s_allocatedNodes[m_idx] == this) { + s_allocatedNodes[m_idx] = nullptr; } - for ( size_t i = 0; im_children.push_back( this ); + if (nullptr != m_parent) { + m_parent->m_children.push_back(this); } } void DDLNode::detachParent() { - if( ddl_nullptr != m_parent ) { - DDLNodeIt it = std::find( m_parent->m_children.begin(), m_parent->m_children.end(), this ); - if( m_parent->m_children.end() != it ) { - m_parent->m_children.erase( it ); + if (nullptr != m_parent) { + DDLNodeIt it = std::find(m_parent->m_children.begin(), m_parent->m_children.end(), this); + if (m_parent->m_children.end() != it) { + m_parent->m_children.erase(it); } - m_parent = ddl_nullptr; + m_parent = nullptr; } } @@ -111,7 +111,7 @@ const DDLNode::DllNodeList &DDLNode::getChildNodeList() const { return m_children; } -void DDLNode::setType( const std::string &type ) { +void DDLNode::setType(const std::string &type) { m_type = type; } @@ -119,7 +119,7 @@ const std::string &DDLNode::getType() const { return m_type; } -void DDLNode::setName( const std::string &name ) { +void DDLNode::setName(const std::string &name) { m_name = name; } @@ -127,8 +127,8 @@ const std::string &DDLNode::getName() const { return m_name; } -void DDLNode::setProperties( Property *prop ) { - if(m_properties!=ddl_nullptr) +void DDLNode::setProperties(Property *prop) { + if (m_properties != nullptr) delete m_properties; m_properties = prop; } @@ -137,37 +137,37 @@ Property *DDLNode::getProperties() const { return m_properties; } -bool DDLNode::hasProperty( const std::string &name ) { - const Property *prop( findPropertyByName( name ) ); - return ( ddl_nullptr != prop ); +bool DDLNode::hasProperty(const std::string &name) { + const Property *prop(findPropertyByName(name)); + return (nullptr != prop); } bool DDLNode::hasProperties() const { - return( ddl_nullptr != m_properties ); + return (nullptr != m_properties); } -Property *DDLNode::findPropertyByName( const std::string &name ) { - if( name.empty() ) { - return ddl_nullptr; +Property *DDLNode::findPropertyByName(const std::string &name) { + if (name.empty()) { + return nullptr; } - if( ddl_nullptr == m_properties ) { - return ddl_nullptr; + if (nullptr == m_properties) { + return nullptr; } - Property *current( m_properties ); - while( ddl_nullptr != current ) { - int res = strncmp( current->m_key->m_buffer, name.c_str(), name.size() ); - if( 0 == res ) { + Property *current(m_properties); + while (nullptr != current) { + int res = strncmp(current->m_key->m_buffer, name.c_str(), name.size()); + if (0 == res) { return current; } current = current->m_next; } - return ddl_nullptr; + return nullptr; } -void DDLNode::setValue( Value *val ) { +void DDLNode::setValue(Value *val) { m_value = val; } @@ -175,7 +175,7 @@ Value *DDLNode::getValue() const { return m_value; } -void DDLNode::setDataArrayList( DataArrayList *dtArrayList ) { +void DDLNode::setDataArrayList(DataArrayList *dtArrayList) { m_dtArrayList = dtArrayList; } @@ -183,7 +183,7 @@ DataArrayList *DDLNode::getDataArrayList() const { return m_dtArrayList; } -void DDLNode::setReferences( Reference *refs ) { +void DDLNode::setReferences(Reference *refs) { m_references = refs; } @@ -191,22 +191,32 @@ Reference *DDLNode::getReferences() const { return m_references; } -void DDLNode::dump(IOStreamBase &/*stream*/) { - // Todo! +void DDLNode::dump(IOStreamBase &stream) { + if (!stream.isOpen()) { + return; + } + + const std::string &type = this->getType(); + stream.write("type = " + type); + Value::Iterator it(getValue()); + while (it.hasNext()) { + Value *v = it.getNext(); + v->dump(stream); + } } -DDLNode *DDLNode::create( const std::string &type, const std::string &name, DDLNode *parent ) { - const size_t idx( s_allocatedNodes.size() ); - DDLNode *node = new DDLNode( type, name, idx, parent ); - s_allocatedNodes.push_back( node ); - +DDLNode *DDLNode::create(const std::string &type, const std::string &name, DDLNode *parent) { + const size_t idx(s_allocatedNodes.size()); + DDLNode *node = new DDLNode(type, name, idx, parent); + s_allocatedNodes.push_back(node); + return node; } void DDLNode::releaseNodes() { - if( s_allocatedNodes.size() > 0 ) { - for( DDLNodeIt it = s_allocatedNodes.begin(); it != s_allocatedNodes.end(); it++ ) { - if( *it ) { + if (s_allocatedNodes.size() > 0) { + for (DDLNodeIt it = s_allocatedNodes.begin(); it != s_allocatedNodes.end(); it++) { + if (*it) { delete *it; } } diff --git a/contrib/openddlparser/code/OpenDDLCommon.cpp b/contrib/openddlparser/code/OpenDDLCommon.cpp index 5c341a780..d853efae8 100644 --- a/contrib/openddlparser/code/OpenDDLCommon.cpp +++ b/contrib/openddlparser/code/OpenDDLCommon.cpp @@ -1,7 +1,7 @@ /*----------------------------------------------------------------------------------------------- The MIT License (MIT) -Copyright (c) 2014-2015 Kim Kulling +Copyright (c) 2014-2020 Kim Kulling 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 @@ -20,17 +20,17 @@ 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. -----------------------------------------------------------------------------------------------*/ -#include #include +#include #include BEGIN_ODDLPARSER_NS -Text::Text( const char *buffer, size_t numChars ) -: m_capacity( 0 ) -, m_len( 0 ) -, m_buffer( ddl_nullptr ) { - set( buffer, numChars ); +Text::Text(const char *buffer, size_t numChars) : + m_capacity(0), + m_len(0), + m_buffer(nullptr) { + set(buffer, numChars); } Text::~Text() { @@ -39,103 +39,98 @@ Text::~Text() { void Text::clear() { delete[] m_buffer; - m_buffer = ddl_nullptr; + m_buffer = nullptr; m_capacity = 0; m_len = 0; } -void Text::set( const char *buffer, size_t numChars ) { +void Text::set(const char *buffer, size_t numChars) { clear(); - if( numChars > 0 ) { + if (numChars > 0) { m_len = numChars; m_capacity = m_len + 1; - m_buffer = new char[ m_capacity ]; - strncpy( m_buffer, buffer, numChars ); - m_buffer[ numChars ] = '\0'; + m_buffer = new char[m_capacity]; + strncpy(m_buffer, buffer, numChars); + m_buffer[numChars] = '\0'; } } -bool Text::operator == ( const std::string &name ) const { - if( m_len != name.size() ) { +bool Text::operator==(const std::string &name) const { + if (m_len != name.size()) { return false; } - const int res( strncmp( m_buffer, name.c_str(), name.size() ) ); + const int res(strncmp(m_buffer, name.c_str(), name.size())); - return ( 0 == res ); + return (0 == res); } -bool Text::operator == ( const Text &rhs ) const { - if( m_len != rhs.m_len ) { +bool Text::operator==(const Text &rhs) const { + if (m_len != rhs.m_len) { return false; } - const int res( strncmp( m_buffer, rhs.m_buffer, m_len ) ); + const int res(strncmp(m_buffer, rhs.m_buffer, m_len)); - return ( 0 == res ); + return (0 == res); } -Name::Name( NameType type, Text *id ) -: m_type( type ) -, m_id( id ) { +Name::Name(NameType type, Text *id) : + m_type(type), m_id(id) { // empty } Name::~Name() { delete m_id; - m_id = ddl_nullptr; + m_id = nullptr; } -Name::Name( const Name &name ){ - m_type=name.m_type; - m_id=new Text(name.m_id->m_buffer,name.m_id->m_len); +Name::Name(const Name &name) { + m_type = name.m_type; + m_id = new Text(name.m_id->m_buffer, name.m_id->m_len); } - - - Reference::Reference() -: m_numRefs( 0 ) -, m_referencedName( ddl_nullptr ) { +Reference::Reference() : + m_numRefs(0), m_referencedName(nullptr) { // empty } -Reference::Reference( size_t numrefs, Name **names ) -: m_numRefs( numrefs ) -, m_referencedName( ddl_nullptr ) { - if ( numrefs > 0 ) { - m_referencedName = new Name *[ numrefs ]; - for ( size_t i = 0; i < numrefs; i++ ) { - m_referencedName[ i ] = names[i]; +Reference::Reference(size_t numrefs, Name **names) : + m_numRefs(numrefs), m_referencedName(nullptr) { + if (numrefs > 0) { + m_referencedName = new Name *[numrefs]; + for (size_t i = 0; i < numrefs; i++) { + m_referencedName[i] = names[i]; } } } Reference::Reference(const Reference &ref) { - m_numRefs=ref.m_numRefs; - if(m_numRefs!=0){ - m_referencedName = new Name*[m_numRefs]; - for ( size_t i = 0; i < m_numRefs; i++ ) { + m_numRefs = ref.m_numRefs; + if (m_numRefs != 0) { + m_referencedName = new Name *[m_numRefs]; + for (size_t i = 0; i < m_numRefs; i++) { m_referencedName[i] = new Name(*ref.m_referencedName[i]); } } } Reference::~Reference() { - for( size_t i = 0; i < m_numRefs; i++ ) { - delete m_referencedName[ i ]; + for (size_t i = 0; i < m_numRefs; i++) { + delete m_referencedName[i]; } m_numRefs = 0; - delete [] m_referencedName; - m_referencedName = ddl_nullptr; + delete[] m_referencedName; + m_referencedName = nullptr; } size_t Reference::sizeInBytes() { - if ( 0 == m_numRefs ) { + if (0 == m_numRefs) { return 0; } - size_t size( 0 ); - for ( size_t i = 0; i < m_numRefs; i++ ) { - Name *name( m_referencedName[ i ] ); - if ( ddl_nullptr != name ) { + size_t size(0); + for (size_t i = 0; i < m_numRefs; i++) { + Name *name(m_referencedName[i]); + if (nullptr != name) { size += name->m_id->m_len; } } @@ -143,60 +138,53 @@ size_t Reference::sizeInBytes() { return size; } -Property::Property( Text *id ) -: m_key( id ) -, m_value( ddl_nullptr ) -, m_ref( ddl_nullptr ) -, m_next( ddl_nullptr ) { +Property::Property(Text *id) : + m_key(id), m_value(nullptr), m_ref(nullptr), m_next(nullptr) { // empty } Property::~Property() { delete m_key; - if(m_value!=ddl_nullptr) + if (m_value != nullptr) delete m_value; - if(m_ref!=ddl_nullptr) - delete(m_ref); - if(m_next!=ddl_nullptr) + if (m_ref != nullptr) + delete (m_ref); + if (m_next != nullptr) delete m_next; } -DataArrayList::DataArrayList() -: m_numItems( 0 ) -, m_dataList( ddl_nullptr ) -, m_next( ddl_nullptr ) -, m_refs(ddl_nullptr) -, m_numRefs(0){ +DataArrayList::DataArrayList() : + m_numItems(0), m_dataList(nullptr), m_next(nullptr), m_refs(nullptr), m_numRefs(0) { // empty } DataArrayList::~DataArrayList() { delete m_dataList; - if(m_next!=ddl_nullptr) + if (m_next != nullptr) delete m_next; - if(m_refs!=ddl_nullptr) + if (m_refs != nullptr) delete m_refs; } size_t DataArrayList::size() { - size_t result( 0 ); - if ( ddl_nullptr == m_next ) { - if ( m_dataList != ddl_nullptr ) { + size_t result(0); + if (nullptr == m_next) { + if (m_dataList != nullptr) { result = 1; } return result; } - DataArrayList *n( m_next ); - while( ddl_nullptr != n ) { + DataArrayList *n(m_next); + while (nullptr != n) { result++; n = n->m_next; } return result; } -Context::Context() -: m_root( ddl_nullptr ) { +Context::Context() : + m_root(nullptr) { // empty } @@ -206,7 +194,7 @@ Context::~Context() { void Context::clear() { delete m_root; - m_root = ddl_nullptr; + m_root = nullptr; } END_ODDLPARSER_NS diff --git a/contrib/openddlparser/code/OpenDDLExport.cpp b/contrib/openddlparser/code/OpenDDLExport.cpp index e45fb041a..6d6f2458d 100644 --- a/contrib/openddlparser/code/OpenDDLExport.cpp +++ b/contrib/openddlparser/code/OpenDDLExport.cpp @@ -1,7 +1,7 @@ /*----------------------------------------------------------------------------------------------- The MIT License (MIT) -Copyright (c) 2014-2015 Kim Kulling +Copyright (c) 2014-2020 Kim Kulling 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 @@ -20,10 +20,10 @@ 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. -----------------------------------------------------------------------------------------------*/ -#include #include -#include +#include #include +#include #include @@ -33,9 +33,8 @@ struct DDLNodeIterator { const DDLNode::DllNodeList &m_childs; size_t m_idx; - DDLNodeIterator( const DDLNode::DllNodeList &childs ) - : m_childs( childs ) - , m_idx( 0 ) { + DDLNodeIterator(const DDLNode::DllNodeList &childs) : + m_childs(childs), m_idx(0) { // empty } @@ -43,10 +42,10 @@ struct DDLNodeIterator { // empty } - bool getNext( DDLNode **node ) { - if( m_childs.size() > (m_idx+1) ) { + bool getNext(DDLNode **node) { + if (m_childs.size() > (m_idx + 1)) { m_idx++; - *node = m_childs[ m_idx ]; + *node = m_childs[m_idx]; return true; } @@ -55,65 +54,65 @@ struct DDLNodeIterator { private: DDLNodeIterator() ddl_no_copy; - DDLNodeIterator &operator = ( const DDLNodeIterator & ) ddl_no_copy; + DDLNodeIterator &operator=(const DDLNodeIterator &) ddl_no_copy; }; -static void writeLineEnd( std::string &statement ) { +static void writeLineEnd(std::string &statement) { statement += "\n"; } -OpenDDLExport::OpenDDLExport( IOStreamBase *stream ) -: m_stream( stream ) { - if (ddl_nullptr == m_stream) { +OpenDDLExport::OpenDDLExport(IOStreamBase *stream) : + m_stream(stream) { + if (nullptr == m_stream) { m_stream = new IOStreamBase(); } } OpenDDLExport::~OpenDDLExport() { - if (ddl_nullptr != m_stream) { + if (nullptr != m_stream) { m_stream->close(); } delete m_stream; } -bool OpenDDLExport::exportContext( Context *ctx, const std::string &filename ) { - if( ddl_nullptr == ctx ) { +bool OpenDDLExport::exportContext(Context *ctx, const std::string &filename) { + if (nullptr == ctx) { return false; } - DDLNode *root( ctx->m_root ); - if ( ddl_nullptr == root ) { + DDLNode *root(ctx->m_root); + if (nullptr == root) { return true; } if (!filename.empty()) { - if (!m_stream->open( filename )) { + if (!m_stream->open(filename)) { return false; } } - const bool retValue( handleNode( root ) ); - + const bool retValue(handleNode(root)); + return retValue; } -bool OpenDDLExport::handleNode( DDLNode *node ) { - if( ddl_nullptr == node ) { +bool OpenDDLExport::handleNode(DDLNode *node) { + if (nullptr == node) { return true; } const DDLNode::DllNodeList &childs = node->getChildNodeList(); - if( childs.empty() ) { + if (childs.empty()) { return true; } - DDLNode *current( ddl_nullptr ); - DDLNodeIterator it( childs ); + DDLNode *current(nullptr); + DDLNodeIterator it(childs); std::string statement; - bool success( true ); - while( it.getNext( ¤t ) ) { - if( ddl_nullptr != current ) { - success |= writeNode( current, statement ); - if( !handleNode( current ) ) { + bool success(true); + while (it.getNext(¤t)) { + if (nullptr != current) { + success |= writeNode(current, statement); + if (!handleNode(current)) { success = false; } } @@ -122,56 +121,57 @@ bool OpenDDLExport::handleNode( DDLNode *node ) { return success; } -bool OpenDDLExport::writeToStream( const std::string &statement ) { - if (ddl_nullptr == m_stream ) { +bool OpenDDLExport::writeToStream(const std::string &statement) { + if (nullptr == m_stream) { return false; } - if ( !statement.empty()) { - m_stream->write( statement ); + if (!statement.empty()) { + m_stream->write(statement); } return true; } -bool OpenDDLExport::writeNode( DDLNode *node, std::string &statement ) { - writeNodeHeader( node, statement ); +bool OpenDDLExport::writeNode(DDLNode *node, std::string &statement) { + bool success(true); + writeNodeHeader(node, statement); if (node->hasProperties()) { - writeProperties( node, statement ); + success |= writeProperties(node, statement); } - writeLineEnd( statement ); + writeLineEnd(statement); statement = "}"; - DataArrayList *al( node->getDataArrayList() ); - if ( ddl_nullptr != al ) { - writeValueType( al->m_dataList->m_type, al->m_numItems, statement ); - writeValueArray( al, statement ); + DataArrayList *al(node->getDataArrayList()); + if (nullptr != al) { + writeValueType(al->m_dataList->m_type, al->m_numItems, statement); + writeValueArray(al, statement); } - Value *v( node->getValue() ); - if (ddl_nullptr != v ) { - writeValueType( v->m_type, 1, statement ); + Value *v(node->getValue()); + if (nullptr != v) { + writeValueType(v->m_type, 1, statement); statement = "{"; - writeLineEnd( statement ); - writeValue( v, statement ); + writeLineEnd(statement); + writeValue(v, statement); statement = "}"; - writeLineEnd( statement ); + writeLineEnd(statement); } statement = "}"; - writeLineEnd( statement ); + writeLineEnd(statement); - writeToStream( statement ); + writeToStream(statement); return true; } -bool OpenDDLExport::writeNodeHeader( DDLNode *node, std::string &statement ) { - if (ddl_nullptr == node) { +bool OpenDDLExport::writeNodeHeader(DDLNode *node, std::string &statement) { + if (nullptr == node) { return false; } statement += node->getType(); - const std::string &name( node->getName() ); - if ( !name.empty() ) { + const std::string &name(node->getName()); + if (!name.empty()) { statement += " "; statement += "$"; statement += name; @@ -180,30 +180,30 @@ bool OpenDDLExport::writeNodeHeader( DDLNode *node, std::string &statement ) { return true; } -bool OpenDDLExport::writeProperties( DDLNode *node, std::string &statement ) { - if ( ddl_nullptr == node ) { +bool OpenDDLExport::writeProperties(DDLNode *node, std::string &statement) { + if (nullptr == node) { return false; } - Property *prop( node->getProperties() ); + Property *prop(node->getProperties()); // if no properties are there, return - if ( ddl_nullptr == prop ) { + if (nullptr == prop) { return true; } - if ( ddl_nullptr != prop ) { + if (nullptr != prop) { // for instance (attrib = "position", bla=2) statement += "("; - bool first( true ); - while ( ddl_nullptr != prop ) { + bool first(true); + while (nullptr != prop) { if (!first) { statement += ", "; } else { first = false; } - statement += std::string( prop->m_key->m_buffer ); + statement += std::string(prop->m_key->m_buffer); statement += " = "; - writeValue( prop->m_value, statement ); + writeValue(prop->m_value, statement); prop = prop->m_next; } @@ -213,19 +213,19 @@ bool OpenDDLExport::writeProperties( DDLNode *node, std::string &statement ) { return true; } -bool OpenDDLExport::writeValueType( Value::ValueType type, size_t numItems, std::string &statement ) { - if ( Value::ddl_types_max == type) { +bool OpenDDLExport::writeValueType(Value::ValueType type, size_t numItems, std::string &statement) { + if (Value::ValueType::ddl_types_max == type) { return false; } - const std::string typeStr( getTypeToken( type ) ); + const std::string typeStr(getTypeToken(type)); statement += typeStr; // if we have an array to write - if ( numItems > 1 ) { + if (numItems > 1) { statement += "["; - char buffer[ 256 ]; - ::memset( buffer, '\0', 256 * sizeof( char ) ); - sprintf( buffer, "%d", static_cast( numItems ) ); + char buffer[256]; + ::memset(buffer, '\0', 256 * sizeof(char)); + sprintf(buffer, "%d", static_cast(numItems)); statement += buffer; statement += "]"; } @@ -233,115 +233,93 @@ bool OpenDDLExport::writeValueType( Value::ValueType type, size_t numItems, std: return true; } -bool OpenDDLExport::writeValue( Value *val, std::string &statement ) { - if (ddl_nullptr == val) { +bool OpenDDLExport::writeValue(Value *val, std::string &statement) { + if (nullptr == val) { return false; } - switch ( val->m_type ) { - case Value::ddl_bool: - if ( true == val->getBool() ) { + switch (val->m_type) { + case Value::ValueType::ddl_bool: + if (true == val->getBool()) { statement += "true"; } else { statement += "false"; } break; - case Value::ddl_int8: - { - std::stringstream stream; - const int i = static_cast( val->getInt8() ); - stream << i; - statement += stream.str(); - } + case Value::ValueType::ddl_int8 : { + std::stringstream stream; + const int i = static_cast(val->getInt8()); + stream << i; + statement += stream.str(); + } break; + case Value::ValueType::ddl_int16: { + std::stringstream stream; + char buffer[256]; + ::memset(buffer, '\0', 256 * sizeof(char)); + sprintf(buffer, "%d", val->getInt16()); + statement += buffer; + } break; + case Value::ValueType::ddl_int32: { + std::stringstream stream; + char buffer[256]; + ::memset(buffer, '\0', 256 * sizeof(char)); + const int i = static_cast(val->getInt32()); + sprintf(buffer, "%d", i); + statement += buffer; + } break; + case Value::ValueType::ddl_int64: { + std::stringstream stream; + const int i = static_cast(val->getInt64()); + stream << i; + statement += stream.str(); + } break; + case Value::ValueType::ddl_unsigned_int8: { + std::stringstream stream; + const int i = static_cast(val->getUnsignedInt8()); + stream << i; + statement += stream.str(); + } break; + case Value::ValueType::ddl_unsigned_int16: { + std::stringstream stream; + const int i = static_cast(val->getUnsignedInt16()); + stream << i; + statement += stream.str(); + } break; + case Value::ValueType::ddl_unsigned_int32: { + std::stringstream stream; + const int i = static_cast(val->getUnsignedInt32()); + stream << i; + statement += stream.str(); + } break; + case Value::ValueType::ddl_unsigned_int64: { + std::stringstream stream; + const int i = static_cast(val->getUnsignedInt64()); + stream << i; + statement += stream.str(); + } break; + case Value::ValueType::ddl_half: break; - case Value::ddl_int16: - { - std::stringstream stream; - char buffer[ 256 ]; - ::memset( buffer, '\0', 256 * sizeof( char ) ); - sprintf( buffer, "%d", val->getInt16() ); - statement += buffer; - } + case Value::ValueType::ddl_float: { + std::stringstream stream; + stream << val->getFloat(); + statement += stream.str(); + } break; + case Value::ValueType::ddl_double: { + std::stringstream stream; + stream << val->getDouble(); + statement += stream.str(); + } break; + case Value::ValueType::ddl_string: { + std::stringstream stream; + stream << val->getString(); + statement += "\""; + statement += stream.str(); + statement += "\""; + } break; + case Value::ValueType::ddl_ref: break; - case Value::ddl_int32: - { - std::stringstream stream; - char buffer[ 256 ]; - ::memset( buffer, '\0', 256 * sizeof( char ) ); - const int i = static_cast< int >( val->getInt32() ); - sprintf( buffer, "%d", i ); - statement += buffer; - } - break; - case Value::ddl_int64: - { - std::stringstream stream; - const int i = static_cast< int >( val->getInt64() ); - stream << i; - statement += stream.str(); - } - break; - case Value::ddl_unsigned_int8: - { - std::stringstream stream; - const int i = static_cast< unsigned int >( val->getUnsignedInt8() ); - stream << i; - statement += stream.str(); - } - break; - case Value::ddl_unsigned_int16: - { - std::stringstream stream; - const int i = static_cast< unsigned int >( val->getUnsignedInt16() ); - stream << i; - statement += stream.str(); - } - break; - case Value::ddl_unsigned_int32: - { - std::stringstream stream; - const int i = static_cast< unsigned int >( val->getUnsignedInt32() ); - stream << i; - statement += stream.str(); - } - break; - case Value::ddl_unsigned_int64: - { - std::stringstream stream; - const int i = static_cast< unsigned int >( val->getUnsignedInt64() ); - stream << i; - statement += stream.str(); - } - break; - case Value::ddl_half: - break; - case Value::ddl_float: - { - std::stringstream stream; - stream << val->getFloat(); - statement += stream.str(); - } - break; - case Value::ddl_double: - { - std::stringstream stream; - stream << val->getDouble(); - statement += stream.str(); - } - break; - case Value::ddl_string: - { - std::stringstream stream; - stream << val->getString(); - statement += "\""; - statement += stream.str(); - statement += "\""; - } - break; - case Value::ddl_ref: - break; - case Value::ddl_none: - case Value::ddl_types_max: + case Value::ValueType::ddl_none: + case Value::ValueType::ddl_types_max: default: break; } @@ -349,8 +327,8 @@ bool OpenDDLExport::writeValue( Value *val, std::string &statement ) { return true; } -bool OpenDDLExport::writeValueArray( DataArrayList *al, std::string &statement ) { - if (ddl_nullptr == al) { +bool OpenDDLExport::writeValueArray(DataArrayList *al, std::string &statement) { + if (nullptr == al) { return false; } @@ -358,17 +336,18 @@ bool OpenDDLExport::writeValueArray( DataArrayList *al, std::string &statement ) return true; } - DataArrayList *nextDataArrayList = al ; - while (ddl_nullptr != nextDataArrayList) { - if (ddl_nullptr != nextDataArrayList) { + DataArrayList *nextDataArrayList = al; + Value *nextValue(nextDataArrayList->m_dataList); + while (nullptr != nextDataArrayList) { + if (nullptr != nextDataArrayList) { statement += "{ "; - Value *nextValue( nextDataArrayList->m_dataList ); - size_t idx( 0 ); - while (ddl_nullptr != nextValue) { + nextValue = nextDataArrayList->m_dataList; + size_t idx(0); + while (nullptr != nextValue) { if (idx > 0) { statement += ", "; } - writeValue( nextValue, statement ); + writeValue(nextValue, statement); nextValue = nextValue->m_next; idx++; } @@ -381,4 +360,3 @@ bool OpenDDLExport::writeValueArray( DataArrayList *al, std::string &statement ) } END_ODDLPARSER_NS - diff --git a/contrib/openddlparser/code/OpenDDLParser.cpp b/contrib/openddlparser/code/OpenDDLParser.cpp index 91831ba27..e6f4d7f39 100644 --- a/contrib/openddlparser/code/OpenDDLParser.cpp +++ b/contrib/openddlparser/code/OpenDDLParser.cpp @@ -1,7 +1,7 @@ /*----------------------------------------------------------------------------------------------- The MIT License (MIT) -Copyright (c) 2014-2015 Kim Kulling +Copyright (c) 2014-2020 Kim Kulling 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 @@ -20,112 +20,106 @@ 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. -----------------------------------------------------------------------------------------------*/ -#include #include +#include +#include +#include #include #include #include -#include -#include -#include #ifdef _WIN32 -# include +#include #endif // _WIN32 - BEGIN_ODDLPARSER_NS static const char *Version = "0.4.0"; namespace Grammar { - static const char *OpenBracketToken = "{"; - static const char *CloseBracketToken = "}"; - static const char *OpenPropertyToken = "("; - static const char *ClosePropertyToken = ")"; - static const char *OpenArrayToken = "["; - static const char *CloseArrayToken = "]"; - static const char *BoolTrue = "true"; - static const char *BoolFalse = "false"; - static const char *CommaSeparator = ","; - static const char *PrimitiveTypeToken[ Value::ddl_types_max ] = { - "bool", - "int8", - "int16", - "int32", - "int64", - "unsigned_int8", - "unsigned_int16", - "unsigned_int32", - "unsigned_int64", - "half", - "float", - "double", - "string", - "ref" - }; +static const char *OpenBracketToken = "{"; +static const char *CloseBracketToken = "}"; +static const char *OpenPropertyToken = "("; +static const char *ClosePropertyToken = ")"; +static const char *OpenArrayToken = "["; +static const char *CloseArrayToken = "]"; +static const char *BoolTrue = "true"; +static const char *BoolFalse = "false"; +static const char *CommaSeparator = ","; + +static const char *PrimitiveTypeToken[(size_t)Value::ValueType::ddl_types_max] = { + "bool", + "int8", + "int16", + "int32", + "int64", + "unsigned_int8", + "unsigned_int16", + "unsigned_int32", + "unsigned_int64", + "half", + "float", + "double", + "string", + "ref" +}; } // Namespace Grammar -const char *getTypeToken( Value::ValueType type ) { - return Grammar::PrimitiveTypeToken[ type ]; +const char *getTypeToken(Value::ValueType type) { + return Grammar::PrimitiveTypeToken[(size_t)type]; } -static void logInvalidTokenError( char *in, const std::string &exp, OpenDDLParser::logCallback callback ) { +static void logInvalidTokenError(char *in, const std::string &exp, OpenDDLParser::logCallback callback) { std::stringstream stream; - stream << "Invalid token \"" << *in << "\"" << " expected \"" << exp << "\"" << std::endl; - std::string full( in ); - std::string part( full.substr( 0, 50 ) ); + stream << "Invalid token \"" << *in << "\"" + << " expected \"" << exp << "\"" << std::endl; + std::string full(in); + std::string part(full.substr(0, 50)); stream << part; - callback( ddl_error_msg, stream.str() ); + callback(ddl_error_msg, stream.str()); } -static bool isIntegerType( Value::ValueType integerType ) { - if( integerType != Value::ddl_int8 && integerType != Value::ddl_int16 && - integerType != Value::ddl_int32 && integerType != Value::ddl_int64 ) { - return false; - } - - return true; -} - -static bool isUnsignedIntegerType( Value::ValueType integerType ) { - if( integerType != Value::ddl_unsigned_int8 && integerType != Value::ddl_unsigned_int16 && - integerType != Value::ddl_unsigned_int32 && integerType != Value::ddl_unsigned_int64 ) { +static bool isIntegerType(Value::ValueType integerType) { + if (integerType != Value::ValueType::ddl_int8 && integerType != Value::ValueType::ddl_int16 && + integerType != Value::ValueType::ddl_int32 && integerType != Value::ValueType::ddl_int64) { return false; } return true; } -static DDLNode *createDDLNode( Text *id, OpenDDLParser *parser ) { - // Basic checks - if( ddl_nullptr == id || ddl_nullptr == parser ) { - return ddl_nullptr; - } - - // If the buffer is empty ( an empty node ) return nullptr - if ( ddl_nullptr == id->m_buffer ) { - return ddl_nullptr; +static bool isUnsignedIntegerType(Value::ValueType integerType) { + if (integerType != Value::ValueType::ddl_unsigned_int8 && integerType != Value::ValueType::ddl_unsigned_int16 && + integerType != Value::ValueType::ddl_unsigned_int32 && integerType != Value::ValueType::ddl_unsigned_int64) { + return false; } - const std::string type( id->m_buffer ); - DDLNode *parent( parser->top() ); - DDLNode *node = DDLNode::create( type, "", parent ); - + return true; +} + +static DDLNode *createDDLNode(Text *id, OpenDDLParser *parser) { + if (nullptr == id || nullptr == parser) { + return nullptr; + } + + const std::string type(id->m_buffer); + DDLNode *parent(parser->top()); + DDLNode *node = DDLNode::create(type, "", parent); + return node; } -static void logMessage( LogSeverity severity, const std::string &msg ) { +static void logMessage(LogSeverity severity, const std::string &msg) { std::string log; - if( ddl_debug_msg == severity ) { + if (ddl_debug_msg == severity) { log += "Debug:"; - } else if( ddl_info_msg == severity ) { + } else if (ddl_info_msg == severity) { log += "Info :"; - } else if( ddl_warn_msg == severity ) { + } else if (ddl_warn_msg == severity) { log += "Warn :"; - } else if( ddl_error_msg == severity ) { + } else if (ddl_error_msg == severity) { log += "Error:"; } else { log += "None :"; @@ -135,20 +129,18 @@ static void logMessage( LogSeverity severity, const std::string &msg ) { std::cout << log; } -OpenDDLParser::OpenDDLParser() -: m_logCallback( logMessage ) -, m_buffer() -, m_stack() -, m_context( ddl_nullptr ) { +OpenDDLParser::OpenDDLParser() : + m_logCallback(logMessage), + m_buffer(), + m_stack(), + m_context(nullptr) { // empty } -OpenDDLParser::OpenDDLParser( const char *buffer, size_t len ) -: m_logCallback( &logMessage ) -, m_buffer() -, m_context( ddl_nullptr ) { - if( 0 != len ) { - setBuffer( buffer, len ); +OpenDDLParser::OpenDDLParser(const char *buffer, size_t len) : + m_logCallback(&logMessage), m_buffer(), m_context(nullptr) { + if (0 != len) { + setBuffer(buffer, len); } } @@ -156,8 +148,8 @@ OpenDDLParser::~OpenDDLParser() { clear(); } -void OpenDDLParser::setLogCallback( logCallback callback ) { - if( ddl_nullptr != callback ) { +void OpenDDLParser::setLogCallback(logCallback callback) { + if (nullptr != callback) { // install user-specific log callback m_logCallback = callback; } else { @@ -170,28 +162,28 @@ OpenDDLParser::logCallback OpenDDLParser::getLogCallback() const { return m_logCallback; } -void OpenDDLParser::setBuffer( const char *buffer, size_t len ) { +void OpenDDLParser::setBuffer(const char *buffer, size_t len) { clear(); - if( 0 == len ) { + if (0 == len) { return; } - m_buffer.resize( len ); - ::memcpy(&m_buffer[ 0 ], buffer, len ); + m_buffer.resize(len); + ::memcpy(&m_buffer[0], buffer, len); } -void OpenDDLParser::setBuffer( const std::vector &buffer ) { +void OpenDDLParser::setBuffer(const std::vector &buffer) { clear(); - m_buffer.resize( buffer.size() ); - std::copy( buffer.begin(), buffer.end(), m_buffer.begin() ); + m_buffer.resize(buffer.size()); + std::copy(buffer.begin(), buffer.end(), m_buffer.begin()); } const char *OpenDDLParser::getBuffer() const { - if( m_buffer.empty() ) { - return ddl_nullptr; + if (m_buffer.empty()) { + return nullptr; } - return &m_buffer[ 0 ]; + return &m_buffer[0]; } size_t OpenDDLParser::getBufferSize() const { @@ -199,266 +191,279 @@ size_t OpenDDLParser::getBufferSize() const { } void OpenDDLParser::clear() { - m_buffer.resize( 0 ); - if( ddl_nullptr != m_context ) { + m_buffer.resize(0); + if (nullptr != m_context) { delete m_context; - m_context=ddl_nullptr; + m_context = nullptr; } -// DDLNode::releaseNodes(); + // DDLNode::releaseNodes(); } -bool OpenDDLParser::parse() { - if( m_buffer.empty() ) { +bool OpenDDLParser::validate() { + if (m_buffer.empty()) { + return true; + } + + if (!isCharacter(m_buffer[0]) && !isNumeric(m_buffer[0])) { return false; } - normalizeBuffer( m_buffer ); + return true; +} + +bool OpenDDLParser::parse() { + if (m_buffer.empty()) { + return false; + } + + normalizeBuffer(m_buffer); + if (!validate()) { + return false; + } m_context = new Context; - m_context->m_root = DDLNode::create( "root", "", ddl_nullptr ); - pushNode( m_context->m_root ); + m_context->m_root = DDLNode::create("root", "", nullptr); + pushNode(m_context->m_root); // do the main parsing - char *current( &m_buffer[ 0 ] ); - char *end( &m_buffer[m_buffer.size() - 1 ] + 1 ); - size_t pos( current - &m_buffer[ 0 ] ); - while( pos < m_buffer.size() ) { - current = parseNextNode( current, end ); - if ( current == ddl_nullptr ) { + char *current(&m_buffer[0]); + char *end(&m_buffer[m_buffer.size() - 1] + 1); + size_t pos(current - &m_buffer[0]); + while (pos < m_buffer.size()) { + current = parseNextNode(current, end); + if (current == nullptr) { return false; } - pos = current - &m_buffer[ 0 ]; + pos = current - &m_buffer[0]; } return true; } -bool OpenDDLParser::exportContext( Context *ctx, const std::string &filename ) { - if( ddl_nullptr == ctx ) { +bool OpenDDLParser::exportContext(Context *ctx, const std::string &filename) { + if (nullptr == ctx) { return false; } OpenDDLExport myExporter; - return myExporter.exportContext( ctx, filename ); + return myExporter.exportContext(ctx, filename); } -char *OpenDDLParser::parseNextNode( char *in, char *end ) { - in = parseHeader( in, end ); - in = parseStructure( in, end ); +char *OpenDDLParser::parseNextNode(char *in, char *end) { + in = parseHeader(in, end); + in = parseStructure(in, end); return in; } #ifdef DEBUG_HEADER_NAME -static void dumpId( Identifier *id ) { - if( ddl_nullptr != id ) { - if ( ddl_nullptr != id->m_text.m_buffer ) { +static void dumpId(Identifier *id) { + if (nullptr != id) { + if (nullptr != id->m_text.m_buffer) { std::cout << id->m_text.m_buffer << std::endl; - } + } } } #endif -char *OpenDDLParser::parseHeader( char *in, char *end ) { - if( ddl_nullptr == in || in == end ) { +char *OpenDDLParser::parseHeader(char *in, char *end) { + if (nullptr == in || in == end) { return in; } - Text *id( ddl_nullptr ); - in = OpenDDLParser::parseIdentifier( in, end, &id ); + Text *id(nullptr); + in = OpenDDLParser::parseIdentifier(in, end, &id); #ifdef DEBUG_HEADER_NAME - dumpId( id ); + dumpId(id); #endif // DEBUG_HEADER_NAME - in = lookForNextToken( in, end ); - if( ddl_nullptr != id ) { + in = lookForNextToken(in, end); + if (nullptr != id) { // store the node - DDLNode *node( createDDLNode( id, this ) ); - if( ddl_nullptr != node ) { - pushNode( node ); + DDLNode *node(createDDLNode(id, this)); + if (nullptr != node) { + pushNode(node); } else { std::cerr << "nullptr returned by creating DDLNode." << std::endl; } delete id; - Name *name_(ddl_nullptr); - in = OpenDDLParser::parseName(in, end, &name_); - std::unique_ptr name(name_); - if( ddl_nullptr != name && ddl_nullptr != node ) { - const std::string nodeName( name->m_id->m_buffer ); - node->setName( nodeName ); + Name *name(nullptr); + in = OpenDDLParser::parseName(in, end, &name); + if (nullptr != name && nullptr != node && nullptr != name->m_id->m_buffer) { + const std::string nodeName(name->m_id->m_buffer); + node->setName(nodeName); + delete name; } + Property *first(nullptr); + in = lookForNextToken(in, end); + if (*in == Grammar::OpenPropertyToken[0]) { + in++; + Property *prop(nullptr), *prev(nullptr); + while (*in != Grammar::ClosePropertyToken[0] && in != end) { + in = OpenDDLParser::parseProperty(in, end, &prop); + in = lookForNextToken(in, end); - std::unique_ptr first; - in = lookForNextToken(in, end); - if (*in == Grammar::OpenPropertyToken[0]) { - in++; - std::unique_ptr prop, prev; - while (*in != Grammar::ClosePropertyToken[0] && in != end) { - Property *prop_(ddl_nullptr); - in = OpenDDLParser::parseProperty(in, end, &prop_); - prop.reset(prop_); - in = lookForNextToken(in, end); + if (*in != Grammar::CommaSeparator[0] && *in != Grammar::ClosePropertyToken[0]) { + logInvalidTokenError(in, Grammar::ClosePropertyToken, m_logCallback); + return nullptr; + } - if (*in != Grammar::CommaSeparator[0] && *in != Grammar::ClosePropertyToken[0]) { - logInvalidTokenError(in, Grammar::ClosePropertyToken, m_logCallback); - return ddl_nullptr; - } + if (nullptr != prop && *in != Grammar::CommaSeparator[0]) { + if (nullptr == first) { + first = prop; + } + if (nullptr != prev) { + prev->m_next = prop; + } + prev = prop; + } + } + ++in; + } - if (ddl_nullptr != prop && *in != Grammar::CommaSeparator[0]) { - if (ddl_nullptr == first) { - first = std::move(prop); - } - if (ddl_nullptr != prev) { - prev->m_next = prop.release(); - } - prev = std::move(prop); - } - } - ++in; - } - - // set the properties - if (first && ddl_nullptr != node) { - node->setProperties(first.release()); - } + // set the properties + if (nullptr != first && nullptr != node) { + node->setProperties(first); + } } return in; } -char *OpenDDLParser::parseStructure( char *in, char *end ) { - if( ddl_nullptr == in || in == end ) { +char *OpenDDLParser::parseStructure(char *in, char *end) { + if (nullptr == in || in == end) { return in; } - bool error( false ); - in = lookForNextToken( in, end ); - if( *in == *Grammar::OpenBracketToken) { + bool error(false); + in = lookForNextToken(in, end); + if (*in == *Grammar::OpenBracketToken) { // loop over all children ( data and nodes ) do { - in = parseStructureBody( in, end, error ); - if(in == ddl_nullptr){ - return ddl_nullptr; + in = parseStructureBody(in, end, error); + if (in == nullptr) { + return nullptr; } - } while ( *in != *Grammar::CloseBracketToken); + } while (*in != *Grammar::CloseBracketToken); ++in; } else { ++in; - logInvalidTokenError( in, std::string( Grammar::OpenBracketToken ), m_logCallback ); - return ddl_nullptr; + logInvalidTokenError(in, std::string(Grammar::OpenBracketToken), m_logCallback); + error = true; + return nullptr; } - in = lookForNextToken( in, end ); + in = lookForNextToken(in, end); // pop node from stack after successful parsing - if( !error ) { + if (!error) { popNode(); } return in; } -static void setNodeValues( DDLNode *currentNode, Value *values ) { - if( ddl_nullptr != values ){ - if( ddl_nullptr != currentNode ) { - currentNode->setValue( values ); +static void setNodeValues(DDLNode *currentNode, Value *values) { + if (nullptr != values) { + if (nullptr != currentNode) { + currentNode->setValue(values); } } } -static void setNodeReferences( DDLNode *currentNode, Reference *refs ) { - if( ddl_nullptr != refs ) { - if( ddl_nullptr != currentNode ) { - currentNode->setReferences( refs ); +static void setNodeReferences(DDLNode *currentNode, Reference *refs) { + if (nullptr != refs) { + if (nullptr != currentNode) { + currentNode->setReferences(refs); } } } -static void setNodeDataArrayList( DDLNode *currentNode, DataArrayList *dtArrayList ) { - if( ddl_nullptr != dtArrayList ) { - if( ddl_nullptr != currentNode ) { - currentNode->setDataArrayList( dtArrayList ); +static void setNodeDataArrayList(DDLNode *currentNode, DataArrayList *dtArrayList) { + if (nullptr != dtArrayList) { + if (nullptr != currentNode) { + currentNode->setDataArrayList(dtArrayList); } } } -char *OpenDDLParser::parseStructureBody( char *in, char *end, bool &error ) { - if( !isNumeric( *in ) && !isCharacter( *in ) ) { +char *OpenDDLParser::parseStructureBody(char *in, char *end, bool &error) { + if (!isNumeric(*in) && !isCharacter(*in)) { ++in; } - in = lookForNextToken( in, end ); - Value::ValueType type( Value::ddl_none ); - size_t arrayLen( 0 ); - in = OpenDDLParser::parsePrimitiveDataType( in, end, type, arrayLen ); - if( Value::ddl_none != type ) { + in = lookForNextToken(in, end); + Value::ValueType type(Value::ValueType::ddl_none); + size_t arrayLen(0); + in = OpenDDLParser::parsePrimitiveDataType(in, end, type, arrayLen); + if (Value::ValueType::ddl_none != type) { // parse a primitive data type - in = lookForNextToken( in, end ); - if( *in == Grammar::OpenBracketToken[ 0 ] ) { - Reference *refs( ddl_nullptr ); - DataArrayList *dtArrayList( ddl_nullptr ); - Value *values( ddl_nullptr ); - if( 1 == arrayLen ) { - size_t numRefs( 0 ), numValues( 0 ); - in = parseDataList( in, end, type, &values, numValues, &refs, numRefs ); - setNodeValues( top(), values ); - setNodeReferences( top(), refs ); - } else if( arrayLen > 1 ) { - in = parseDataArrayList( in, end, type, &dtArrayList ); - setNodeDataArrayList( top(), dtArrayList ); + in = lookForNextToken(in, end); + if (*in == Grammar::OpenBracketToken[0]) { + Reference *refs(nullptr); + DataArrayList *dtArrayList(nullptr); + Value *values(nullptr); + if (1 == arrayLen) { + size_t numRefs(0), numValues(0); + in = parseDataList(in, end, type, &values, numValues, &refs, numRefs); + setNodeValues(top(), values); + setNodeReferences(top(), refs); + } else if (arrayLen > 1) { + in = parseDataArrayList(in, end, type, &dtArrayList); + setNodeDataArrayList(top(), dtArrayList); } else { std::cerr << "0 for array is invalid." << std::endl; error = true; } } - in = lookForNextToken( in, end ); - if( *in != '}' ) { - logInvalidTokenError( in, std::string( Grammar::CloseBracketToken ), m_logCallback ); - return ddl_nullptr; + in = lookForNextToken(in, end); + if (*in != '}') { + logInvalidTokenError(in, std::string(Grammar::CloseBracketToken), m_logCallback); + return nullptr; } else { //in++; } } else { // parse a complex data type - in = parseNextNode( in, end ); + in = parseNextNode(in, end); } return in; } -void OpenDDLParser::pushNode( DDLNode *node ) { - if( ddl_nullptr == node ) { +void OpenDDLParser::pushNode(DDLNode *node) { + if (nullptr == node) { return; } - m_stack.push_back( node ); + m_stack.push_back(node); } DDLNode *OpenDDLParser::popNode() { - if( m_stack.empty() ) { - return ddl_nullptr; + if (m_stack.empty()) { + return nullptr; } - DDLNode *topNode( top() ); + DDLNode *topNode(top()); m_stack.pop_back(); return topNode; } DDLNode *OpenDDLParser::top() { - if( m_stack.empty() ) { - return ddl_nullptr; + if (m_stack.empty()) { + return nullptr; } - DDLNode *top( m_stack.back() ); + DDLNode *top(m_stack.back()); return top; } DDLNode *OpenDDLParser::getRoot() const { - if( ddl_nullptr == m_context ) { - return ddl_nullptr; + if (nullptr == m_context) { + return nullptr; } return m_context->m_root; @@ -468,16 +473,16 @@ Context *OpenDDLParser::getContext() const { return m_context; } -void OpenDDLParser::normalizeBuffer( std::vector &buffer) { - if( buffer.empty() ) { +void OpenDDLParser::normalizeBuffer(std::vector &buffer) { + if (buffer.empty()) { return; } std::vector newBuffer; - const size_t len( buffer.size() ); - char *end( &buffer[ len-1 ] + 1 ); - for( size_t readIdx = 0; readIdx &buffer) { ++readIdx; } ++readIdx; - ++readIdx; - } else if( !isComment( c, end ) && !isNewLine( *c ) ) { - newBuffer.push_back( buffer[ readIdx ] ); + } else if (!isComment(c, end) && !isNewLine(*c)) { + newBuffer.push_back(buffer[readIdx]); } else { - if( isComment( c, end ) ) { + if (isComment(c, end)) { ++readIdx; // skip the comment and the rest of the line - while( !isEndofLine( buffer[ readIdx ] ) ) { + while (!isEndofLine(buffer[readIdx])) { ++readIdx; } } @@ -501,29 +505,29 @@ void OpenDDLParser::normalizeBuffer( std::vector &buffer) { buffer = newBuffer; } -char *OpenDDLParser::parseName( char *in, char *end, Name **name ) { - *name = ddl_nullptr; - if( ddl_nullptr == in || in == end ) { +char *OpenDDLParser::parseName(char *in, char *end, Name **name) { + *name = nullptr; + if (nullptr == in || in == end) { return in; } // ignore blanks - in = lookForNextToken( in, end ); - if( *in != '$' && *in != '%' ) { + in = lookForNextToken(in, end); + if (*in != '$' && *in != '%') { return in; } - NameType ntype( GlobalName ); - if( *in == '%' ) { + NameType ntype(GlobalName); + if (*in == '%') { ntype = LocalName; } in++; - Name *currentName( ddl_nullptr ); - Text *id( ddl_nullptr ); - in = parseIdentifier( in, end, &id ); - if( id ) { - currentName = new Name( ntype, id ); - if( currentName ) { + Name *currentName(nullptr); + Text *id(nullptr); + in = parseIdentifier(in, end, &id); + if (id) { + currentName = new Name(ntype, id); + if (currentName) { *name = currentName; } } @@ -531,70 +535,70 @@ char *OpenDDLParser::parseName( char *in, char *end, Name **name ) { return in; } -char *OpenDDLParser::parseIdentifier( char *in, char *end, Text **id ) { - *id = ddl_nullptr; - if( ddl_nullptr == in || in == end ) { +char *OpenDDLParser::parseIdentifier(char *in, char *end, Text **id) { + *id = nullptr; + if (nullptr == in || in == end) { return in; } // ignore blanks - in = lookForNextToken( in, end ); + in = lookForNextToken(in, end); // staring with a number is forbidden - if( isNumeric( *in ) ) { + if (isNumeric(*in)) { return in; } // get size of id - size_t idLen( 0 ); - char *start( in ); - while( !isSeparator( *in ) && - !isNewLine( *in ) && ( in != end ) && - *in != Grammar::OpenPropertyToken[ 0 ] && - *in != Grammar::ClosePropertyToken[ 0 ] && - *in != '$' ) { + size_t idLen(0); + char *start(in); + while (!isSeparator(*in) && + !isNewLine(*in) && (in != end) && + *in != Grammar::OpenPropertyToken[0] && + *in != Grammar::ClosePropertyToken[0] && + *in != '$') { ++in; ++idLen; } - const size_t len( idLen ); - *id = new Text( start, len ); + const size_t len(idLen); + *id = new Text(start, len); return in; } -char *OpenDDLParser::parsePrimitiveDataType( char *in, char *end, Value::ValueType &type, size_t &len ) { - type = Value::ddl_none; +char *OpenDDLParser::parsePrimitiveDataType(char *in, char *end, Value::ValueType &type, size_t &len) { + type = Value::ValueType::ddl_none; len = 0; - if( ddl_nullptr == in || in == end ) { + if (nullptr == in || in == end) { return in; } - size_t prim_len( 0 ); - for( unsigned int i = 0; i < Value::ddl_types_max; i++ ) { - prim_len = strlen( Grammar::PrimitiveTypeToken[ i ] ); - if( 0 == strncmp( in, Grammar::PrimitiveTypeToken[ i ], prim_len ) ) { - type = static_cast( i ); + size_t prim_len(0); + for (size_t i = 0; i < (size_t) Value::ValueType::ddl_types_max; i++) { + prim_len = strlen(Grammar::PrimitiveTypeToken[i]); + if (0 == strncmp(in, Grammar::PrimitiveTypeToken[i], prim_len)) { + type = static_cast(i); break; } } - if( Value::ddl_none == type ) { - in = lookForNextToken( in, end ); + if (Value::ValueType::ddl_none == type) { + in = lookForNextToken(in, end); return in; } else { in += prim_len; } - bool ok( true ); - if( *in == Grammar::OpenArrayToken[ 0 ] ) { + bool ok(true); + if (*in == Grammar::OpenArrayToken[0]) { ok = false; ++in; - char *start( in ); - while ( in != end ) { + char *start(in); + while (in != end) { ++in; - if( *in == Grammar::CloseArrayToken[ 0 ] ) { - len = ::atoi( start ); + if (*in == Grammar::CloseArrayToken[0]) { + len = ::atoi(start); ok = true; ++in; break; @@ -603,29 +607,29 @@ char *OpenDDLParser::parsePrimitiveDataType( char *in, char *end, Value::ValueTy } else { len = 1; } - if( !ok ) { - type = Value::ddl_none; + if (!ok) { + type = Value::ValueType::ddl_none; } return in; } -char *OpenDDLParser::parseReference( char *in, char *end, std::vector &names ) { - if( ddl_nullptr == in || in == end ) { +char *OpenDDLParser::parseReference(char *in, char *end, std::vector &names) { + if (nullptr == in || in == end) { return in; } - Name *nextName( ddl_nullptr ); - in = parseName( in, end, &nextName ); - if( nextName ) { - names.push_back( nextName ); + Name *nextName(nullptr); + in = parseName(in, end, &nextName); + if (nextName) { + names.push_back(nextName); } - while( Grammar::CommaSeparator[ 0 ] == *in ) { - in = getNextSeparator( in, end ); - if( Grammar::CommaSeparator[ 0 ] == *in ) { - in = parseName( in, end, &nextName ); - if( nextName ) { - names.push_back( nextName ); + while (Grammar::CommaSeparator[0] == *in) { + in = getNextSeparator(in, end); + if (Grammar::CommaSeparator[0] == *in) { + in = parseName(in, end, &nextName); + if (nextName) { + names.push_back(nextName); } } else { break; @@ -635,86 +639,86 @@ char *OpenDDLParser::parseReference( char *in, char *end, std::vector &na return in; } -char *OpenDDLParser::parseBooleanLiteral( char *in, char *end, Value **boolean ) { - *boolean = ddl_nullptr; - if( ddl_nullptr == in || in == end ) { +char *OpenDDLParser::parseBooleanLiteral(char *in, char *end, Value **boolean) { + *boolean = nullptr; + if (nullptr == in || in == end) { return in; } - in = lookForNextToken( in, end ); - char *start( in ); - size_t len( 0 ); - while( !isSeparator( *in ) && in != end ) { + in = lookForNextToken(in, end); + char *start(in); + size_t len(0); + while (!isSeparator(*in) && in != end) { ++in; ++len; } ++len; - int res = ::strncmp( Grammar::BoolTrue, start, strlen( Grammar::BoolTrue ) ); - if( 0 != res ) { - res = ::strncmp( Grammar::BoolFalse, start, strlen( Grammar::BoolFalse ) ); - if( 0 != res ) { - *boolean = ddl_nullptr; + int res = ::strncmp(Grammar::BoolTrue, start, strlen(Grammar::BoolTrue)); + if (0 != res) { + res = ::strncmp(Grammar::BoolFalse, start, strlen(Grammar::BoolFalse)); + if (0 != res) { + *boolean = nullptr; return in; } - *boolean = ValueAllocator::allocPrimData( Value::ddl_bool ); - (*boolean)->setBool( false ); + *boolean = ValueAllocator::allocPrimData(Value::ValueType::ddl_bool); + (*boolean)->setBool(false); } else { - *boolean = ValueAllocator::allocPrimData( Value::ddl_bool ); - (*boolean)->setBool( true ); + *boolean = ValueAllocator::allocPrimData(Value::ValueType::ddl_bool); + (*boolean)->setBool(true); } return in; } -char *OpenDDLParser::parseIntegerLiteral( char *in, char *end, Value **integer, Value::ValueType integerType ) { - *integer = ddl_nullptr; - if( ddl_nullptr == in || in == end ) { +char *OpenDDLParser::parseIntegerLiteral(char *in, char *end, Value **integer, Value::ValueType integerType) { + *integer = nullptr; + if (nullptr == in || in == end) { return in; } - if( !(isIntegerType( integerType ) || isUnsignedIntegerType(integerType)) ) { + if (!(isIntegerType(integerType) || isUnsignedIntegerType(integerType))) { return in; } - in = lookForNextToken( in, end ); - char *start( in ); - while( !isSeparator( *in ) && in != end ) { + in = lookForNextToken(in, end); + char *start(in); + while (!isSeparator(*in) && in != end) { ++in; } - if( isNumeric( *start ) ) { + if (isNumeric(*start)) { #ifdef OPENDDL_NO_USE_CPP11 - const int64 value( atol( start ) ); // maybe not really 64bit as atoll is but exists without c++11 - const uint64 uvalue( strtoul( start,ddl_nullptr,10 ) ); + const int64 value(atol(start)); // maybe not really 64bit as atoll is but exists without c++11 + const uint64 uvalue(strtoul(start, nullptr, 10)); #else - const int64 value( atoll( start ) ); - const uint64 uvalue( strtoull( start,ddl_nullptr,10 ) ); + const int64 value(atoll(start)); + const uint64 uvalue(strtoull(start, nullptr, 10)); #endif - *integer = ValueAllocator::allocPrimData( integerType ); - switch( integerType ) { - case Value::ddl_int8: - ( *integer )->setInt8( (int8) value ); + *integer = ValueAllocator::allocPrimData(integerType); + switch (integerType) { + case Value::ValueType::ddl_int8: + (*integer)->setInt8((int8)value); break; - case Value::ddl_int16: - ( *integer )->setInt16( ( int16 ) value ); + case Value::ValueType::ddl_int16: + (*integer)->setInt16((int16)value); break; - case Value::ddl_int32: - ( *integer )->setInt32( ( int32 ) value ); + case Value::ValueType::ddl_int32: + (*integer)->setInt32((int32)value); break; - case Value::ddl_int64: - ( *integer )->setInt64( ( int64 ) value ); + case Value::ValueType::ddl_int64: + (*integer)->setInt64((int64)value); break; - case Value::ddl_unsigned_int8: - ( *integer )->setUnsignedInt8( (uint8) uvalue ); + case Value::ValueType::ddl_unsigned_int8: + (*integer)->setUnsignedInt8((uint8)uvalue); break; - case Value::ddl_unsigned_int16: - ( *integer )->setUnsignedInt16( ( uint16 ) uvalue ); + case Value::ValueType::ddl_unsigned_int16: + (*integer)->setUnsignedInt16((uint16)uvalue); break; - case Value::ddl_unsigned_int32: - ( *integer )->setUnsignedInt32( ( uint32 ) uvalue ); + case Value::ValueType::ddl_unsigned_int32: + (*integer)->setUnsignedInt32((uint32)uvalue); break; - case Value::ddl_unsigned_int64: - ( *integer )->setUnsignedInt64( ( uint64 ) uvalue ); + case Value::ValueType::ddl_unsigned_int64: + (*integer)->setUnsignedInt64((uint64)uvalue); break; default: break; @@ -724,105 +728,105 @@ char *OpenDDLParser::parseIntegerLiteral( char *in, char *end, Value **integer, return in; } -char *OpenDDLParser::parseFloatingLiteral( char *in, char *end, Value **floating, Value::ValueType floatType) { - *floating = ddl_nullptr; - if( ddl_nullptr == in || in == end ) { +char *OpenDDLParser::parseFloatingLiteral(char *in, char *end, Value **floating, Value::ValueType floatType) { + *floating = nullptr; + if (nullptr == in || in == end) { return in; } - in = lookForNextToken( in, end ); - char *start( in ); - while( !isSeparator( *in ) && in != end ) { + in = lookForNextToken(in, end); + char *start(in); + while (!isSeparator(*in) && in != end) { ++in; } // parse the float value - bool ok( false ); - if ( isHexLiteral( start, end ) ) { - parseHexaLiteral( start, end, floating ); + bool ok(false); + if (isHexLiteral(start, end)) { + parseHexaLiteral(start, end, floating); return in; } - if( isNumeric( *start ) ) { + if (isNumeric(*start)) { ok = true; } else { - if( *start == '-' ) { - if( isNumeric( *(start+1) ) ) { + if (*start == '-') { + if (isNumeric(*(start + 1))) { ok = true; } } } - if( ok ) { - if ( floatType == Value::ddl_double ) { - const double value( atof( start ) ); - *floating = ValueAllocator::allocPrimData( Value::ddl_double ); - ( *floating )->setDouble( value ); + if (ok) { + if (floatType == Value::ValueType::ddl_double) { + const double value(atof(start)); + *floating = ValueAllocator::allocPrimData(Value::ValueType::ddl_double); + (*floating)->setDouble(value); } else { - const float value( ( float ) atof( start ) ); - *floating = ValueAllocator::allocPrimData( Value::ddl_float ); - ( *floating )->setFloat( value ); + const float value((float)atof(start)); + *floating = ValueAllocator::allocPrimData(Value::ValueType::ddl_float); + (*floating)->setFloat(value); } } return in; } -char *OpenDDLParser::parseStringLiteral( char *in, char *end, Value **stringData ) { - *stringData = ddl_nullptr; - if( ddl_nullptr == in || in == end ) { +char *OpenDDLParser::parseStringLiteral(char *in, char *end, Value **stringData) { + *stringData = nullptr; + if (nullptr == in || in == end) { return in; } - in = lookForNextToken( in, end ); - size_t len( 0 ); - char *start( in ); - if( *start == '\"' ) { + in = lookForNextToken(in, end); + size_t len(0); + char *start(in); + if (*start == '\"') { ++start; ++in; - while( *in != '\"' && in != end ) { + while (*in != '\"' && in != end) { ++in; ++len; } - *stringData = ValueAllocator::allocPrimData( Value::ddl_string, len ); - ::strncpy( ( char* ) ( *stringData )->m_data, start, len ); - ( *stringData )->m_data[len] = '\0'; + *stringData = ValueAllocator::allocPrimData(Value::ValueType::ddl_string, len); + ::strncpy((char *)(*stringData)->m_data, start, len); + (*stringData)->m_data[len] = '\0'; ++in; } return in; } -static void createPropertyWithData( Text *id, Value *primData, Property **prop ) { - if( ddl_nullptr != primData ) { - ( *prop ) = new Property( id ); - ( *prop )->m_value = primData; +static void createPropertyWithData(Text *id, Value *primData, Property **prop) { + if (nullptr != primData) { + (*prop) = new Property(id); + (*prop)->m_value = primData; } } -char *OpenDDLParser::parseHexaLiteral( char *in, char *end, Value **data ) { - *data = ddl_nullptr; - if( ddl_nullptr == in || in == end ) { +char *OpenDDLParser::parseHexaLiteral(char *in, char *end, Value **data) { + *data = nullptr; + if (nullptr == in || in == end) { return in; } - in = lookForNextToken( in, end ); - if( *in != '0' ) { + in = lookForNextToken(in, end); + if (*in != '0') { return in; } ++in; - if( *in != 'x' && *in != 'X' ) { + if (*in != 'x' && *in != 'X') { return in; } ++in; - bool ok( true ); - char *start( in ); - int pos( 0 ); - while( !isSeparator( *in ) && in != end ) { - if( ( *in < '0' && *in > '9' ) || ( *in < 'a' && *in > 'f' ) || ( *in < 'A' && *in > 'F' ) ) { + bool ok(true); + char *start(in); + int pos(0); + while (!isSeparator(*in) && in != end) { + if ((*in < '0' && *in > '9') || (*in < 'a' && *in > 'f') || (*in < 'A' && *in > 'F')) { ok = false; break; } @@ -830,57 +834,57 @@ char *OpenDDLParser::parseHexaLiteral( char *in, char *end, Value **data ) { ++in; } - if( !ok ) { + if (!ok) { return in; } - int value( 0 ); - while( pos > 0 ) { - int v = hex2Decimal( *start ); + int value(0); + while (pos > 0) { + int v = hex2Decimal(*start); --pos; - value = ( value << 4 ) | v; + value = (value << 4) | v; ++start; } - *data = ValueAllocator::allocPrimData( Value::ddl_unsigned_int64 ); - if( ddl_nullptr != *data ) { - ( *data )->setUnsignedInt64( value ); + *data = ValueAllocator::allocPrimData(Value::ValueType::ddl_unsigned_int64); + if (nullptr != *data) { + (*data)->setUnsignedInt64(value); } return in; } -char *OpenDDLParser::parseProperty( char *in, char *end, Property **prop ) { - *prop = ddl_nullptr; - if( ddl_nullptr == in || in == end ) { +char *OpenDDLParser::parseProperty(char *in, char *end, Property **prop) { + *prop = nullptr; + if (nullptr == in || in == end) { return in; } - in = lookForNextToken( in, end ); - Text *id( ddl_nullptr ); - in = parseIdentifier( in, end, &id ); - if( ddl_nullptr != id ) { - in = lookForNextToken( in, end ); - if( *in == '=' ) { + in = lookForNextToken(in, end); + Text *id(nullptr); + in = parseIdentifier(in, end, &id); + if (nullptr != id) { + in = lookForNextToken(in, end); + if (*in == '=') { ++in; - in = getNextToken( in, end ); - Value *primData( ddl_nullptr ); - if( isInteger( in, end ) ) { - in = parseIntegerLiteral( in, end, &primData ); - createPropertyWithData( id, primData, prop ); - } else if( isFloat( in, end ) ) { - in = parseFloatingLiteral( in, end, &primData ); - createPropertyWithData( id, primData, prop ); - } else if( isStringLiteral( *in ) ) { // string data - in = parseStringLiteral( in, end, &primData ); - createPropertyWithData( id, primData, prop ); - } else { // reference data - std::vector names; - in = parseReference( in, end, names ); - if( !names.empty() ) { - Reference *ref = new Reference( names.size(), &names[ 0 ] ); - ( *prop ) = new Property( id ); - ( *prop )->m_ref = ref; + in = getNextToken(in, end); + Value *primData(nullptr); + if (isInteger(in, end)) { + in = parseIntegerLiteral(in, end, &primData); + createPropertyWithData(id, primData, prop); + } else if (isFloat(in, end)) { + in = parseFloatingLiteral(in, end, &primData); + createPropertyWithData(id, primData, prop); + } else if (isStringLiteral(*in)) { // string data + in = parseStringLiteral(in, end, &primData); + createPropertyWithData(id, primData, prop); + } else { // reference data + std::vector names; + in = parseReference(in, end, names); + if (!names.empty()) { + Reference *ref = new Reference(names.size(), &names[0]); + (*prop) = new Property(id); + (*prop)->m_ref = ref; } } } else { @@ -891,77 +895,77 @@ char *OpenDDLParser::parseProperty( char *in, char *end, Property **prop ) { return in; } -char *OpenDDLParser::parseDataList( char *in, char *end, Value::ValueType type, Value **data, - size_t &numValues, Reference **refs, size_t &numRefs ) { - *data = ddl_nullptr; +char *OpenDDLParser::parseDataList(char *in, char *end, Value::ValueType type, Value **data, + size_t &numValues, Reference **refs, size_t &numRefs) { + *data = nullptr; numValues = numRefs = 0; - if( ddl_nullptr == in || in == end ) { + if (nullptr == in || in == end) { return in; } - in = lookForNextToken( in, end ); - if( *in == '{' ) { + in = lookForNextToken(in, end); + if (*in == '{') { ++in; - Value *current( ddl_nullptr ), *prev( ddl_nullptr ); - while( '}' != *in ) { - current = ddl_nullptr; - in = lookForNextToken( in, end ); - if ( Value::ddl_ref == type ) { - std::vector names; - in = parseReference( in, end, names ); - if ( !names.empty() ) { - Reference *ref = new Reference( names.size(), &names[ 0 ] ); + Value *current(nullptr), *prev(nullptr); + while ('}' != *in) { + current = nullptr; + in = lookForNextToken(in, end); + if (Value::ValueType::ddl_ref == type) { + std::vector names; + in = parseReference(in, end, names); + if (!names.empty()) { + Reference *ref = new Reference(names.size(), &names[0]); *refs = ref; numRefs = names.size(); } - } else if ( Value::ddl_none == type ) { - if (isInteger( in, end )) { - in = parseIntegerLiteral( in, end, ¤t ); - } else if (isFloat( in, end )) { - in = parseFloatingLiteral( in, end, ¤t ); - } else if (isStringLiteral( *in )) { - in = parseStringLiteral( in, end, ¤t ); - } else if (isHexLiteral( in, end )) { - in = parseHexaLiteral( in, end, ¤t ); + } else if (Value::ValueType::ddl_none == type) { + if (isInteger(in, end)) { + in = parseIntegerLiteral(in, end, ¤t); + } else if (isFloat(in, end)) { + in = parseFloatingLiteral(in, end, ¤t); + } else if (isStringLiteral(*in)) { + in = parseStringLiteral(in, end, ¤t); + } else if (isHexLiteral(in, end)) { + in = parseHexaLiteral(in, end, ¤t); } } else { - switch(type){ - case Value::ddl_int8: - case Value::ddl_int16: - case Value::ddl_int32: - case Value::ddl_int64: - case Value::ddl_unsigned_int8: - case Value::ddl_unsigned_int16: - case Value::ddl_unsigned_int32: - case Value::ddl_unsigned_int64: - in = parseIntegerLiteral( in, end, ¤t, type); + switch (type) { + case Value::ValueType::ddl_int8: + case Value::ValueType::ddl_int16: + case Value::ValueType::ddl_int32: + case Value::ValueType::ddl_int64: + case Value::ValueType::ddl_unsigned_int8: + case Value::ValueType::ddl_unsigned_int16: + case Value::ValueType::ddl_unsigned_int32: + case Value::ValueType::ddl_unsigned_int64: + in = parseIntegerLiteral(in, end, ¤t, type); break; - case Value::ddl_half: - case Value::ddl_float: - case Value::ddl_double: - in = parseFloatingLiteral( in, end, ¤t, type); + case Value::ValueType::ddl_half: + case Value::ValueType::ddl_float: + case Value::ValueType::ddl_double: + in = parseFloatingLiteral(in, end, ¤t, type); break; - case Value::ddl_string: - in = parseStringLiteral( in, end, ¤t ); + case Value::ValueType::ddl_string: + in = parseStringLiteral(in, end, ¤t); break; default: break; } } - if( ddl_nullptr != current ) { - if( ddl_nullptr == *data ) { + if (nullptr != current) { + if (nullptr == *data) { *data = current; prev = current; } else { - prev->setNext( current ); + prev->setNext(current); prev = current; } ++numValues; } - in = getNextSeparator( in, end ); - if( ',' != *in && Grammar::CloseBracketToken[ 0 ] != *in && !isSpace( *in ) ) { + in = getNextSeparator(in, end); + if (',' != *in && Grammar::CloseBracketToken[0] != *in && !isSpace(*in)) { break; } } @@ -971,53 +975,53 @@ char *OpenDDLParser::parseDataList( char *in, char *end, Value::ValueType type, return in; } -static DataArrayList *createDataArrayList( Value *currentValue, size_t numValues, - Reference *refs, size_t numRefs ) { - DataArrayList *dataList( new DataArrayList ); +static DataArrayList *createDataArrayList(Value *currentValue, size_t numValues, + Reference *refs, size_t numRefs) { + DataArrayList *dataList(new DataArrayList); dataList->m_dataList = currentValue; dataList->m_numItems = numValues; - dataList->m_refs = refs; - dataList->m_numRefs = numRefs; + dataList->m_refs = refs; + dataList->m_numRefs = numRefs; return dataList; } -char *OpenDDLParser::parseDataArrayList( char *in, char *end,Value::ValueType type, - DataArrayList **dataArrayList ) { - if ( ddl_nullptr == dataArrayList ) { +char *OpenDDLParser::parseDataArrayList(char *in, char *end, Value::ValueType type, + DataArrayList **dataArrayList) { + if (nullptr == dataArrayList) { return in; } - *dataArrayList = ddl_nullptr; - if( ddl_nullptr == in || in == end ) { + *dataArrayList = nullptr; + if (nullptr == in || in == end) { return in; } - in = lookForNextToken( in, end ); - if( *in == Grammar::OpenBracketToken[ 0 ] ) { + in = lookForNextToken(in, end); + if (*in == Grammar::OpenBracketToken[0]) { ++in; - Value *currentValue( ddl_nullptr ); - Reference *refs( ddl_nullptr ); - DataArrayList *prev( ddl_nullptr ), *currentDataList( ddl_nullptr ); + Value *currentValue(nullptr); + Reference *refs(nullptr); + DataArrayList *prev(nullptr), *currentDataList(nullptr); do { - size_t numRefs( 0 ), numValues( 0 ); - currentValue = ddl_nullptr; + size_t numRefs(0), numValues(0); + currentValue = nullptr; - in = parseDataList( in, end, type, ¤tValue, numValues, &refs, numRefs ); - if( ddl_nullptr != currentValue || 0 != numRefs ) { - if( ddl_nullptr == prev ) { - *dataArrayList = createDataArrayList( currentValue, numValues, refs, numRefs ); + in = parseDataList(in, end, type, ¤tValue, numValues, &refs, numRefs); + if (nullptr != currentValue || 0 != numRefs) { + if (nullptr == prev) { + *dataArrayList = createDataArrayList(currentValue, numValues, refs, numRefs); prev = *dataArrayList; } else { - currentDataList = createDataArrayList( currentValue, numValues, refs, numRefs ); - if( ddl_nullptr != prev ) { + currentDataList = createDataArrayList(currentValue, numValues, refs, numRefs); + if (nullptr != prev) { prev->m_next = currentDataList; prev = currentDataList; } } } - } while( Grammar::CommaSeparator[ 0 ] == *in && in != end ); - in = lookForNextToken( in, end ); + } while (Grammar::CommaSeparator[0] == *in && in != end); + in = lookForNextToken(in, end); ++in; } diff --git a/contrib/openddlparser/code/OpenDDLStream.cpp b/contrib/openddlparser/code/OpenDDLStream.cpp index 7ea8331bd..1a38dfa27 100644 --- a/contrib/openddlparser/code/OpenDDLStream.cpp +++ b/contrib/openddlparser/code/OpenDDLStream.cpp @@ -1,7 +1,7 @@ /*----------------------------------------------------------------------------------------------- The MIT License (MIT) -Copyright (c) 2014-2015 Kim Kulling +Copyright (c) 2014-2020 Kim Kulling 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 @@ -37,22 +37,22 @@ std::string StreamFormatterBase::format(const std::string &statement) { return tmp; } -IOStreamBase::IOStreamBase(StreamFormatterBase *formatter) - : m_formatter(formatter) - , m_file(ddl_nullptr) { - if (ddl_nullptr == m_formatter) { +IOStreamBase::IOStreamBase(StreamFormatterBase *formatter) : + m_formatter(formatter), + m_file(nullptr) { + if (nullptr == m_formatter) { m_formatter = new StreamFormatterBase; } } IOStreamBase::~IOStreamBase() { delete m_formatter; - m_formatter = ddl_nullptr; + m_formatter = nullptr; } bool IOStreamBase::open(const std::string &name) { m_file = ::fopen(name.c_str(), "a"); - if (m_file == ddl_nullptr) { + if (m_file == nullptr) { return false; } @@ -60,33 +60,33 @@ bool IOStreamBase::open(const std::string &name) { } bool IOStreamBase::close() { - if (ddl_nullptr == m_file) { + if (nullptr == m_file) { return false; } ::fclose(m_file); - m_file = ddl_nullptr; + m_file = nullptr; return true; } bool IOStreamBase::isOpen() const { - return ( ddl_nullptr != m_file ); + return (nullptr != m_file); } -size_t IOStreamBase::read( size_t sizeToRead, std::string &statement ) { - if (ddl_nullptr == m_file) { +size_t IOStreamBase::read(size_t sizeToRead, std::string &statement) { + if (nullptr == m_file) { return 0; } - + statement.resize(sizeToRead); - const size_t readBytes = ::fread( &statement[0], 1, sizeToRead, m_file ); + const size_t readBytes = ::fread(&statement[0], 1, sizeToRead, m_file); return readBytes; } size_t IOStreamBase::write(const std::string &statement) { - if (ddl_nullptr == m_file) { + if (nullptr == m_file) { return 0; } std::string formatStatement = m_formatter->format(statement); diff --git a/contrib/openddlparser/code/Value.cpp b/contrib/openddlparser/code/Value.cpp index b5a35e722..708a6878f 100644 --- a/contrib/openddlparser/code/Value.cpp +++ b/contrib/openddlparser/code/Value.cpp @@ -1,7 +1,7 @@ /*----------------------------------------------------------------------------------------------- The MIT License (MIT) -Copyright (c) 2014-2015 Kim Kulling +Copyright (c) 2014-2020 Kim Kulling 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 @@ -20,30 +20,30 @@ 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. -----------------------------------------------------------------------------------------------*/ +#include #include -#include #include BEGIN_ODDLPARSER_NS -static Value::Iterator end( ddl_nullptr ); +static Value::Iterator end(nullptr); -Value::Iterator::Iterator() -: m_start( ddl_nullptr ) -, m_current( ddl_nullptr ) { +Value::Iterator::Iterator() : + m_start(nullptr), + m_current(nullptr) { // empty } -Value::Iterator::Iterator( Value *start ) -: m_start( start ) -, m_current( start ) { +Value::Iterator::Iterator(Value *start) : + m_start(start), + m_current(start) { // empty } -Value::Iterator::Iterator( const Iterator &rhs ) -: m_start( rhs.m_start ) -, m_current( rhs.m_current ) { +Value::Iterator::Iterator(const Iterator &rhs) : + m_start(rhs.m_start), + m_current(rhs.m_current) { // empty } @@ -52,36 +52,36 @@ Value::Iterator::~Iterator() { } bool Value::Iterator::hasNext() const { - if( ddl_nullptr == m_current ) { + if (nullptr == m_current) { return false; } - return ( ddl_nullptr != m_current->getNext() ); + return (nullptr != m_current->getNext()); } Value *Value::Iterator::getNext() { - if( !hasNext() ) { - return ddl_nullptr; + if (!hasNext()) { + return nullptr; } - Value *v( m_current->getNext() ); + Value *v(m_current->getNext()); m_current = v; return v; } -const Value::Iterator Value::Iterator::operator++( int ) { - if( ddl_nullptr == m_current ) { +const Value::Iterator Value::Iterator::operator++(int) { + if (nullptr == m_current) { return end; } m_current = m_current->getNext(); - Iterator inst( m_current ); + Iterator inst(m_current); return inst; } -Value::Iterator &Value::Iterator::operator++( ) { - if( ddl_nullptr == m_current ) { +Value::Iterator &Value::Iterator::operator++() { + if (nullptr == m_current) { return end; } @@ -90,263 +90,261 @@ Value::Iterator &Value::Iterator::operator++( ) { return *this; } -bool Value::Iterator::operator == ( const Iterator &rhs ) const { - return ( m_current == rhs.m_current ); +bool Value::Iterator::operator==(const Iterator &rhs) const { + return (m_current == rhs.m_current); } -Value *Value::Iterator::operator->( ) const { - if(ddl_nullptr == m_current ) { - return ddl_nullptr; +Value *Value::Iterator::operator->() const { + if (nullptr == m_current) { + return nullptr; } return m_current; } -Value::Value( ValueType type ) -: m_type( type ) -, m_size( 0 ) -, m_data( ddl_nullptr ) -, m_next( ddl_nullptr ) { +Value::Value(ValueType type) : + m_type(type), + m_size(0), + m_data(nullptr), + m_next(nullptr) { // empty } Value::~Value() { - if(m_data!=ddl_nullptr) { - if (m_type == ddl_ref ) { - Reference *tmp = (Reference *) m_data; - if (tmp != ddl_nullptr) + if (m_data != nullptr) { + if (m_type == ValueType::ddl_ref) { + Reference *tmp = (Reference *)m_data; + if (tmp != nullptr) delete tmp; - }else + } else delete[] m_data; - } - if(m_next!=ddl_nullptr) + if (m_next != nullptr) delete m_next; } -void Value::setBool( bool value ) { - assert( ddl_bool == m_type ); - ::memcpy( m_data, &value, m_size ); +void Value::setBool(bool value) { + assert(ValueType::ddl_bool == m_type); + ::memcpy(m_data, &value, m_size); } bool Value::getBool() { - assert( ddl_bool == m_type ); - return ( *m_data == 1 ); + assert(ValueType::ddl_bool == m_type); + return (*m_data == 1); } -void Value::setInt8( int8 value ) { - assert( ddl_int8 == m_type ); - ::memcpy( m_data, &value, m_size ); +void Value::setInt8(int8 value) { + assert(ValueType::ddl_int8 == m_type); + ::memcpy(m_data, &value, m_size); } int8 Value::getInt8() { - assert( ddl_int8 == m_type ); - return ( int8 ) ( *m_data ); + assert(ValueType::ddl_int8 == m_type); + return (int8)(*m_data); } -void Value::setInt16( int16 value ) { - assert( ddl_int16 == m_type ); - ::memcpy( m_data, &value, m_size ); +void Value::setInt16(int16 value) { + assert(ValueType::ddl_int16 == m_type); + ::memcpy(m_data, &value, m_size); } int16 Value::getInt16() { - assert( ddl_int16 == m_type ); + assert(ValueType::ddl_int16 == m_type); int16 i; - ::memcpy( &i, m_data, m_size ); + ::memcpy(&i, m_data, m_size); return i; } -void Value::setInt32( int32 value ) { - assert( ddl_int32 == m_type ); - ::memcpy( m_data, &value, m_size ); +void Value::setInt32(int32 value) { + assert(ValueType::ddl_int32 == m_type); + ::memcpy(m_data, &value, m_size); } int32 Value::getInt32() { - assert( ddl_int32 == m_type ); + assert(ValueType::ddl_int32 == m_type); int32 i; - ::memcpy( &i, m_data, m_size ); + ::memcpy(&i, m_data, m_size); return i; } -void Value::setInt64( int64 value ) { - assert( ddl_int64 == m_type ); - ::memcpy( m_data, &value, m_size ); +void Value::setInt64(int64 value) { + assert(ValueType::ddl_int64 == m_type); + ::memcpy(m_data, &value, m_size); } int64 Value::getInt64() { - assert( ddl_int64 == m_type ); + assert(ValueType::ddl_int64 == m_type); int64 i; - ::memcpy( &i, m_data, m_size ); + ::memcpy(&i, m_data, m_size); return i; } -void Value::setUnsignedInt8( uint8 value ) { - assert( ddl_unsigned_int8 == m_type ); - ::memcpy( m_data, &value, m_size ); +void Value::setUnsignedInt8(uint8 value) { + assert(ValueType::ddl_unsigned_int8 == m_type); + ::memcpy(m_data, &value, m_size); } uint8 Value::getUnsignedInt8() const { - assert( ddl_unsigned_int8 == m_type ); + assert(ValueType::ddl_unsigned_int8 == m_type); uint8 i; - ::memcpy( &i, m_data, m_size ); + ::memcpy(&i, m_data, m_size); return i; } -void Value::setUnsignedInt16( uint16 value ) { - assert( ddl_unsigned_int16 == m_type ); - ::memcpy( m_data, &value, m_size ); +void Value::setUnsignedInt16(uint16 value) { + assert(ValueType::ddl_unsigned_int16 == m_type); + ::memcpy(m_data, &value, m_size); } uint16 Value::getUnsignedInt16() const { - assert( ddl_unsigned_int16 == m_type ); + assert(ValueType::ddl_unsigned_int16 == m_type); uint16 i; - ::memcpy( &i, m_data, m_size ); + ::memcpy(&i, m_data, m_size); return i; } -void Value::setUnsignedInt32( uint32 value ) { - assert( ddl_unsigned_int32 == m_type ); - ::memcpy( m_data, &value, m_size ); +void Value::setUnsignedInt32(uint32 value) { + assert(ValueType::ddl_unsigned_int32 == m_type); + ::memcpy(m_data, &value, m_size); } uint32 Value::getUnsignedInt32() const { - assert( ddl_unsigned_int32 == m_type ); + assert(ValueType::ddl_unsigned_int32 == m_type); uint32 i; - ::memcpy( &i, m_data, m_size ); + ::memcpy(&i, m_data, m_size); return i; } -void Value::setUnsignedInt64( uint64 value ) { - assert( ddl_unsigned_int64 == m_type ); - ::memcpy( m_data, &value, m_size ); +void Value::setUnsignedInt64(uint64 value) { + assert(ValueType::ddl_unsigned_int64 == m_type); + ::memcpy(m_data, &value, m_size); } uint64 Value::getUnsignedInt64() const { - assert( ddl_unsigned_int64 == m_type ); + assert(ValueType::ddl_unsigned_int64 == m_type); uint64 i; - ::memcpy( &i, m_data, m_size ); + ::memcpy(&i, m_data, m_size); return i; } -void Value::setFloat( float value ) { - assert( ddl_float == m_type ); - ::memcpy( m_data, &value, m_size ); +void Value::setFloat(float value) { + assert(ValueType::ddl_float == m_type); + ::memcpy(m_data, &value, m_size); } float Value::getFloat() const { - if( m_type == ddl_float ) { + if (m_type == ValueType::ddl_float) { float v; - ::memcpy( &v, m_data, m_size ); - return ( float ) v; + ::memcpy(&v, m_data, m_size); + return (float)v; } else { float tmp; - ::memcpy( &tmp, m_data, 4 ); - return ( float ) tmp; + ::memcpy(&tmp, m_data, 4); + return (float)tmp; } } -void Value::setDouble( double value ) { - assert( ddl_double == m_type ); - ::memcpy( m_data, &value, m_size ); +void Value::setDouble(double value) { + assert(ValueType::ddl_double == m_type); + ::memcpy(m_data, &value, m_size); } double Value::getDouble() const { - if ( m_type == ddl_double ) { + if (m_type == ValueType::ddl_double) { double v; - ::memcpy( &v, m_data, m_size ); - return ( float ) v; - } - else { + ::memcpy(&v, m_data, m_size); + return (float)v; + } else { double tmp; - ::memcpy( &tmp, m_data, 4 ); - return ( double ) tmp; + ::memcpy(&tmp, m_data, 4); + return (double)tmp; } } -void Value::setString( const std::string &str ) { - assert( ddl_string == m_type ); - ::memcpy( m_data, str.c_str(), str.size() ); - m_data[ str.size() ] = '\0'; +void Value::setString(const std::string &str) { + assert(ValueType::ddl_string == m_type); + ::memcpy(m_data, str.c_str(), str.size()); + m_data[str.size()] = '\0'; } const char *Value::getString() const { - assert( ddl_string == m_type ); - return (const char*) m_data; + assert(ValueType::ddl_string == m_type); + return (const char *)m_data; } -void Value::setRef( Reference *ref ) { - assert( ddl_ref == m_type ); +void Value::setRef(Reference *ref) { + assert(ValueType::ddl_ref == m_type); - if ( ddl_nullptr != ref ) { - const size_t sizeInBytes( ref->sizeInBytes() ); - if ( sizeInBytes > 0 ) { - if ( ddl_nullptr != m_data ) { - delete [] m_data; + if (nullptr != ref) { + const size_t sizeInBytes(ref->sizeInBytes()); + if (sizeInBytes > 0) { + if (nullptr != m_data) { + delete[] m_data; } - m_data = (unsigned char*) new Reference(*ref); + m_data = (unsigned char *)new Reference(*ref); } } } Reference *Value::getRef() const { - assert( ddl_ref == m_type ); + assert(ValueType::ddl_ref == m_type); - return (Reference*) m_data; + return (Reference *)m_data; } -void Value::dump( IOStreamBase &/*stream*/ ) { - switch( m_type ) { - case ddl_none: - std::cout << "None" << std::endl; +void Value::dump(IOStreamBase &stream) { + switch (m_type) { + case ValueType::ddl_none: + stream.write("None\n"); break; - case ddl_bool: - std::cout << getBool() << std::endl; + case ValueType::ddl_bool: + stream.write(std::to_string(getBool()) + "\n"); break; - case ddl_int8: - std::cout << getInt8() << std::endl; + case ValueType::ddl_int8: + stream.write(std::to_string(getInt8()) + "\n"); break; - case ddl_int16: - std::cout << getInt16() << std::endl; + case ValueType::ddl_int16: + stream.write(std::to_string(getInt16()) + "\n"); break; - case ddl_int32: - std::cout << getInt32() << std::endl; + case ValueType::ddl_int32: + stream.write(std::to_string(getInt32()) + "\n"); break; - case ddl_int64: - std::cout << getInt64() << std::endl; + case ValueType::ddl_int64: + stream.write(std::to_string(getInt64()) + "\n"); break; - case ddl_unsigned_int8: - std::cout << "Not supported" << std::endl; + case ValueType::ddl_unsigned_int8: + stream.write("Not supported\n"); break; - case ddl_unsigned_int16: - std::cout << "Not supported" << std::endl; + case ValueType::ddl_unsigned_int16: + stream.write("Not supported\n"); break; - case ddl_unsigned_int32: - std::cout << "Not supported" << std::endl; + case ValueType::ddl_unsigned_int32: + stream.write("Not supported\n"); break; - case ddl_unsigned_int64: - std::cout << "Not supported" << std::endl; + case ValueType::ddl_unsigned_int64: + stream.write("Not supported\n"); break; - case ddl_half: - std::cout << "Not supported" << std::endl; + case ValueType::ddl_half: + stream.write("Not supported\n"); break; - case ddl_float: - std::cout << getFloat() << std::endl; + case ValueType::ddl_float: + stream.write(std::to_string(getFloat()) + "\n"); break; - case ddl_double: - std::cout << getDouble() << std::endl; + case ValueType::ddl_double: + stream.write(std::to_string(getDouble()) + "\n"); break; - case ddl_string: - std::cout << getString() << std::endl; + case ValueType::ddl_string: + stream.write(std::string(getString()) + "\n"); break; - case ddl_ref: - std::cout << "Not supported" << std::endl; + case ValueType::ddl_ref: + stream.write("Not supported\n"); break; default: break; } } -void Value::setNext( Value *next ) { +void Value::setNext(Value *next) { m_next = next; } @@ -354,86 +352,86 @@ Value *Value::getNext() const { return m_next; } -size_t Value::size() const{ - size_t result=1; - Value *n=m_next; - while( n!=ddl_nullptr) { +size_t Value::size() const { + size_t result = 1; + Value *n = m_next; + while (n != nullptr) { result++; - n=n->m_next; + n = n->m_next; } return result; } -Value *ValueAllocator::allocPrimData( Value::ValueType type, size_t len ) { - if( type == Value::ddl_none || Value::ddl_types_max == type ) { - return ddl_nullptr; +Value *ValueAllocator::allocPrimData(Value::ValueType type, size_t len) { + if (type == Value::ValueType::ddl_none || Value::ValueType::ddl_types_max == type) { + return nullptr; } - Value *data = new Value( type ); - switch( type ) { - case Value::ddl_bool: - data->m_size = sizeof( bool ); + Value *data = new Value(type); + switch (type) { + case Value::ValueType::ddl_bool: + data->m_size = sizeof(bool); break; - case Value::ddl_int8: - data->m_size = sizeof( int8 ); + case Value::ValueType::ddl_int8: + data->m_size = sizeof(int8); break; - case Value::ddl_int16: - data->m_size = sizeof( int16 ); + case Value::ValueType::ddl_int16: + data->m_size = sizeof(int16); break; - case Value::ddl_int32: - data->m_size = sizeof( int32 ); + case Value::ValueType::ddl_int32: + data->m_size = sizeof(int32); break; - case Value::ddl_int64: - data->m_size = sizeof( int64 ); + case Value::ValueType::ddl_int64: + data->m_size = sizeof(int64); break; - case Value::ddl_unsigned_int8: - data->m_size = sizeof( uint8 ); + case Value::ValueType::ddl_unsigned_int8: + data->m_size = sizeof(uint8); break; - case Value::ddl_unsigned_int16: - data->m_size = sizeof( uint16 ); + case Value::ValueType::ddl_unsigned_int16: + data->m_size = sizeof(uint16); break; - case Value::ddl_unsigned_int32: - data->m_size = sizeof( uint32 ); + case Value::ValueType::ddl_unsigned_int32: + data->m_size = sizeof(uint32); break; - case Value::ddl_unsigned_int64: - data->m_size = sizeof( uint64 ); + case Value::ValueType::ddl_unsigned_int64: + data->m_size = sizeof(uint64); break; - case Value::ddl_half: - data->m_size = sizeof( short ); + case Value::ValueType::ddl_half: + data->m_size = sizeof(short); break; - case Value::ddl_float: - data->m_size = sizeof( float ); + case Value::ValueType::ddl_float: + data->m_size = sizeof(float); break; - case Value::ddl_double: - data->m_size = sizeof( double ); + case Value::ValueType::ddl_double: + data->m_size = sizeof(double); break; - case Value::ddl_string: - data->m_size = sizeof( char )*(len+1); + case Value::ValueType::ddl_string: + data->m_size = sizeof(char) * (len + 1); break; - case Value::ddl_ref: + case Value::ValueType::ddl_ref: data->m_size = 0; break; - case Value::ddl_none: - case Value::ddl_types_max: + case Value::ValueType::ddl_none: + case Value::ValueType::ddl_types_max: default: break; } - if( data->m_size ) { - data->m_data = new unsigned char[ data->m_size ]; - ::memset(data->m_data,0,data->m_size); + if (data->m_size) { + data->m_data = new unsigned char[data->m_size]; + ::memset(data->m_data, 0, data->m_size); } return data; } -void ValueAllocator::releasePrimData( Value **data ) { - if( !data ) { +void ValueAllocator::releasePrimData(Value **data) { + if (!data) { return; } delete *data; - *data = ddl_nullptr; + *data = nullptr; } END_ODDLPARSER_NS diff --git a/contrib/openddlparser/include/openddlparser/DDLNode.h b/contrib/openddlparser/include/openddlparser/DDLNode.h index 915bd3041..593a5f145 100644 --- a/contrib/openddlparser/include/openddlparser/DDLNode.h +++ b/contrib/openddlparser/include/openddlparser/DDLNode.h @@ -1,7 +1,7 @@ /*----------------------------------------------------------------------------------------------- The MIT License (MIT) -Copyright (c) 2014-2015 Kim Kulling +Copyright (c) 2014-2020 Kim Kulling 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 @@ -24,8 +24,8 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include -#include #include +#include BEGIN_ODDLPARSER_NS @@ -53,10 +53,10 @@ public: friend class OpenDDLParser; /// @brief The child-node-list type. - typedef std::vector DllNodeList; + typedef std::vector DllNodeList; /// @brief The child-node-list iterator. - typedef std::vector::iterator DDLNodeIt; + typedef std::vector::iterator DDLNodeIt; public: /// @brief The class destructor. @@ -64,7 +64,7 @@ public: /// @brief Will attach a parent node instance, an older one will be released. /// @param parent [in] The parent node instance. - void attachParent( DDLNode *parent ); + void attachParent(DDLNode *parent); /// @brief Will try to detach a parent node instance, if there is any. void detachParent(); @@ -79,7 +79,7 @@ public: /// Set the type of the DDLNode instance. /// @param type [in] The type. - void setType( const std::string &type ); + void setType(const std::string &type); /// @brief Returns the type of the DDLNode instance. /// @return The type of the DDLNode instance. @@ -87,7 +87,7 @@ public: /// Set the name of the DDLNode instance. /// @param name [in] The name. - void setName( const std::string &name ); + void setName(const std::string &name); /// @brief Returns the name of the DDLNode instance. /// @return The name of the DDLNode instance. @@ -95,7 +95,7 @@ public: /// @brief Set a new property set. /// @param prop [in] The first element of the property set. - void setProperties( Property *prop ); + void setProperties(Property *prop); /// @brief Returns the first element of the assigned property set. /// @return The first property of the assigned property set. @@ -104,7 +104,7 @@ public: /// @brief Looks for a given property. /// @param name [in] The name for the property to look for. /// @return true, if a corresponding property is assigned to the node, false if not. - bool hasProperty( const std::string &name ); + bool hasProperty(const std::string &name); /// @brief Will return true, if any properties are assigned to the node instance. /// @return True, if properties are assigned. @@ -113,11 +113,11 @@ public: /// @brief Search for a given property and returns it. Will return ddl_nullptr if no property was found. /// @param name [in] The name for the property to look for. /// @return The property or ddl_nullptr if no property was found. - Property *findPropertyByName( const std::string &name ); - + Property *findPropertyByName(const std::string &name); + /// @brief Set a new value set. /// @param val [in] The first value instance of the value set. - void setValue( Value *val ); + void setValue(Value *val); /// @brief Returns the first element of the assigned value set. /// @return The first property of the assigned value set. @@ -125,7 +125,7 @@ public: /// @brief Set a new DataArrayList. /// @param dtArrayList [in] The DataArrayList instance. - void setDataArrayList( DataArrayList *dtArrayList ); + void setDataArrayList(DataArrayList *dtArrayList); /// @brief Returns the DataArrayList. /// @return The DataArrayList. @@ -133,7 +133,7 @@ public: /// @brief Set a new Reference set. /// @param refs [in] The first value instance of the Reference set. - void setReferences( Reference *refs ); + void setReferences(Reference *refs); /// @brief Returns the first element of the assigned Reference set. /// @return The first property of the assigned Reference set. @@ -148,20 +148,20 @@ public: /// @param name [in] The name for the new DDLNode instance. /// @param parent [in] The parent node instance or ddl_nullptr if no parent node is there. /// @return The new created node instance. - static DDLNode *create( const std::string &type, const std::string &name, DDLNode *parent = ddl_nullptr ); + static DDLNode *create(const std::string &type, const std::string &name, DDLNode *parent = nullptr); private: - DDLNode( const std::string &type, const std::string &name, size_t idx, DDLNode *parent = ddl_nullptr ); + DDLNode(const std::string &type, const std::string &name, size_t idx, DDLNode *parent = nullptr); DDLNode(); - DDLNode( const DDLNode & ) ddl_no_copy; - DDLNode &operator = ( const DDLNode & ) ddl_no_copy; + DDLNode(const DDLNode &) ddl_no_copy; + DDLNode &operator=(const DDLNode &) ddl_no_copy; static void releaseNodes(); private: std::string m_type; std::string m_name; DDLNode *m_parent; - std::vector m_children; + std::vector m_children; Property *m_properties; Value *m_value; DataArrayList *m_dtArrayList; diff --git a/contrib/openddlparser/include/openddlparser/OpenDDLCommon.h b/contrib/openddlparser/include/openddlparser/OpenDDLCommon.h index bec62cc9d..6ccc83b88 100644 --- a/contrib/openddlparser/include/openddlparser/OpenDDLCommon.h +++ b/contrib/openddlparser/include/openddlparser/OpenDDLCommon.h @@ -1,7 +1,7 @@ /*----------------------------------------------------------------------------------------------- The MIT License (MIT) -Copyright (c) 2014-2015 Kim Kulling +Copyright (c) 2014-2020 Kim Kulling 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 @@ -23,49 +23,49 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #pragma once #include -#include #include +#include #include #include #ifndef _WIN32 -# include +#include #endif -#if defined(_MSC_VER) && !defined( OPENDDL_STATIC_LIBARY ) +#if defined(_MSC_VER) && !defined(OPENDDL_STATIC_LIBARY) -# define TAG_DLL_EXPORT __declspec(dllexport) -# define TAG_DLL_IMPORT __declspec(dllimport ) -# ifdef OPENDDLPARSER_BUILD -# define DLL_ODDLPARSER_EXPORT TAG_DLL_EXPORT -# else -# define DLL_ODDLPARSER_EXPORT TAG_DLL_IMPORT -# endif // OPENDDLPARSER_BUILD -# pragma warning( disable : 4251 ) +#define TAG_DLL_EXPORT __declspec(dllexport) +#define TAG_DLL_IMPORT __declspec(dllimport) +#ifdef OPENDDLPARSER_BUILD +#define DLL_ODDLPARSER_EXPORT TAG_DLL_EXPORT #else -# define DLL_ODDLPARSER_EXPORT +#define DLL_ODDLPARSER_EXPORT TAG_DLL_IMPORT +#endif // OPENDDLPARSER_BUILD +#pragma warning(disable : 4251) +#else +#define DLL_ODDLPARSER_EXPORT #endif // _WIN32 // Namespace declarations, override this to avoid any conflicts #define BEGIN_ODDLPARSER_NS namespace ODDLParser { -#define END_ODDLPARSER_NS } // namespace ODDLParser -#define USE_ODDLPARSER_NS using namespace ODDLParser; +#define END_ODDLPARSER_NS } // namespace ODDLParser +#define USE_ODDLPARSER_NS using namespace ODDLParser; BEGIN_ODDLPARSER_NS // We will use C++11 optional #ifndef OPENDDL_NO_USE_CPP11 - // All C++11 constructs -# define ddl_nullptr nullptr -# define ddl_override override -# define ddl_final final -# define ddl_no_copy = delete +// All C++11 constructs +#define nullptr nullptr +#define ddl_override override +#define ddl_final final +#define ddl_no_copy = delete #else - // Fall-back for older compilers -# define ddl_nullptr NULL -# define ddl_override -# define ddl_final -# define ddl_no_copy +// Fall-back for older compilers +#define nullptr NULL +#define ddl_override +#define ddl_final +#define ddl_no_copy #endif // OPENDDL_NO_USE_CPP11 // Forward declarations @@ -80,36 +80,36 @@ struct DataArrayList; // Platform-specific typedefs #ifdef _WIN32 -typedef signed __int64 int64_impl; -typedef unsigned __int64 uint64_impl; +typedef signed __int64 int64_impl; +typedef unsigned __int64 uint64_impl; #else -typedef int64_t int64_impl; -typedef uint64_t uint64_impl; +typedef int64_t int64_impl; +typedef uint64_t uint64_impl; #endif // OpenDDL-specific data typedefs -typedef signed char int8; ///< Signed integer, 1 byte -typedef signed short int16; ///< Signed integer, 2 byte -typedef signed int int32; ///< Signed integer, 4 byte -typedef int64_impl int64; ///< Signed integer, 8 byte -typedef unsigned char uint8; ///< Unsigned integer, 1 byte -typedef unsigned short uint16; ///< Unsigned integer, 2 byte -typedef unsigned int uint32; ///< Unsigned integer, 4 byte -typedef uint64_impl uint64; ///< Unsigned integer, 8 byte +using int8 = signed char; ///< Signed integer, 1 byte +using int16 = signed short; ///< Signed integer, 2 byte +using int32 = signed int; ///< Signed integer, 4 byte +using int64 = int64_impl; ///< Signed integer, 8 byte +using uint8 = unsigned char; ///< Unsigned integer, 1 byte +using uint16 = unsigned short ; ///< Unsigned integer, 2 byte +using uint32 = unsigned int; ///< Unsigned integer, 4 byte +using uint64 = uint64_impl ; ///< Unsigned integer, 8 byte /// @brief Stores a text. /// /// A text is stored in a simple character buffer. Texts buffer can be /// greater than the number of stored characters in them. struct DLL_ODDLPARSER_EXPORT Text { - size_t m_capacity; ///< The capacity of the text. - size_t m_len; ///< The length of the text. - char *m_buffer; ///< The buffer with the text. + size_t m_capacity; ///< The capacity of the text. + size_t m_len; ///< The length of the text. + char *m_buffer; ///< The buffer with the text. /// @brief The constructor with a given text buffer. /// @param buffer [in] The buffer. /// @param numChars [in] The number of characters in the buffer. - Text( const char *buffer, size_t numChars ); + Text(const char *buffer, size_t numChars); /// @brief The destructor. ~Text(); @@ -120,55 +120,54 @@ struct DLL_ODDLPARSER_EXPORT Text { /// @brief Set a new text. /// @param buffer [in] The buffer. /// @param numChars [in] The number of characters in the buffer. - void set( const char *buffer, size_t numChars ); + void set(const char *buffer, size_t numChars); /// @brief The compare operator for std::strings. - bool operator == ( const std::string &name ) const; + bool operator==(const std::string &name) const; /// @brief The compare operator for Texts. - bool operator == ( const Text &rhs ) const; + bool operator==(const Text &rhs) const; private: - Text( const Text & ) ddl_no_copy; - Text &operator = ( const Text & ) ddl_no_copy; + Text(const Text &) ddl_no_copy; + Text &operator=(const Text &) ddl_no_copy; }; /// @brief Description of the type of a name. enum NameType { GlobalName, ///< Name is global. - LocalName ///< Name is local. + LocalName ///< Name is local. }; /// @brief Stores an OpenDDL-specific name struct DLL_ODDLPARSER_EXPORT Name { - NameType m_type; ///< The type of the name ( @see NameType ). - Text *m_id; ///< The id. + NameType m_type; ///< The type of the name ( @see NameType ). + Text *m_id; ///< The id. /// @brief The constructor with the type and the id. /// @param type [in] The name type. /// @param id [in] The id. - Name( NameType type, Text *id ); - Name( const Name &name ); + Name(NameType type, Text *id); + Name(const Name &name); /// @brief The destructor. ~Name(); private: - - Name &operator = ( const Name& ) ddl_no_copy; + Name &operator=(const Name &) ddl_no_copy; }; /// @brief Stores a bundle of references. struct DLL_ODDLPARSER_EXPORT Reference { - size_t m_numRefs; ///< The number of stored references. - Name **m_referencedName; ///< The reference names. + size_t m_numRefs; ///< The number of stored references. + Name **m_referencedName; ///< The reference names. /// @brief The default constructor. Reference(); - Reference( const Reference &ref ); + Reference(const Reference &ref); /// @brief The constructor with an array of ref names. /// @param numrefs [in] The number of ref names. /// @param names [in] The ref names. - Reference( size_t numrefs, Name **names ); + Reference(size_t numrefs, Name **names); /// @brief The destructor. ~Reference(); @@ -178,38 +177,38 @@ struct DLL_ODDLPARSER_EXPORT Reference { size_t sizeInBytes(); private: - Reference &operator = ( const Reference & ) ddl_no_copy; + Reference &operator=(const Reference &) ddl_no_copy; }; /// @brief Stores a property list. struct DLL_ODDLPARSER_EXPORT Property { - Text *m_key; ///< The identifier / key of the property. - Value *m_value; ///< The value assigned to its key / id ( ddl_nullptr if none ). - Reference *m_ref; ///< References assigned to its key / id ( ddl_nullptr if none ). - Property *m_next; ///< The next property ( ddl_nullptr if none ). + Text *m_key; ///< The identifier / key of the property. + Value *m_value; ///< The value assigned to its key / id ( ddl_nullptr if none ). + Reference *m_ref; ///< References assigned to its key / id ( ddl_nullptr if none ). + Property *m_next; ///< The next property ( ddl_nullptr if none ). /// @brief The default constructor. Property(); /// @brief The constructor for initialization. /// @param id [in] The identifier - Property( Text *id ); + Property(Text *id); /// @brief The destructor. ~Property(); private: - Property( const Property & ) ddl_no_copy; - Property &operator = ( const Property & ) ddl_no_copy; + Property(const Property &) ddl_no_copy; + Property &operator=(const Property &) ddl_no_copy; }; /// @brief Stores a data array list. struct DLL_ODDLPARSER_EXPORT DataArrayList { - size_t m_numItems; ///< The number of items in the list. - Value *m_dataList; ///< The data list ( a Value ). - DataArrayList *m_next; ///< The next data array list ( ddl_nullptr if last ). - Reference *m_refs; - size_t m_numRefs; + size_t m_numItems; ///< The number of items in the list. + Value *m_dataList; ///< The data list ( a Value ). + DataArrayList *m_next; ///< The next data array list ( ddl_nullptr if last ). + Reference *m_refs; + size_t m_numRefs; /// @brief The default constructor for initialization. DataArrayList(); @@ -221,13 +220,13 @@ struct DLL_ODDLPARSER_EXPORT DataArrayList { size_t size(); private: - DataArrayList( const DataArrayList & ) ddl_no_copy; - DataArrayList &operator = ( const DataArrayList & ) ddl_no_copy; + DataArrayList(const DataArrayList &) ddl_no_copy; + DataArrayList &operator=(const DataArrayList &) ddl_no_copy; }; /// @brief Stores the context of a parsed OpenDDL declaration. struct DLL_ODDLPARSER_EXPORT Context { - DDLNode *m_root; ///< The root node of the OpenDDL node tree. + DDLNode *m_root; ///< The root node of the OpenDDL node tree. /// @brief Constructor for initialization. Context(); @@ -239,8 +238,8 @@ struct DLL_ODDLPARSER_EXPORT Context { void clear(); private: - Context( const Context & ) ddl_no_copy; - Context &operator = ( const Context & ) ddl_no_copy; + Context(const Context &) ddl_no_copy; + Context &operator=(const Context &) ddl_no_copy; }; END_ODDLPARSER_NS diff --git a/contrib/openddlparser/include/openddlparser/OpenDDLExport.h b/contrib/openddlparser/include/openddlparser/OpenDDLExport.h index 020d662a0..945253594 100644 --- a/contrib/openddlparser/include/openddlparser/OpenDDLExport.h +++ b/contrib/openddlparser/include/openddlparser/OpenDDLExport.h @@ -1,7 +1,7 @@ /*----------------------------------------------------------------------------------------------- The MIT License (MIT) -Copyright (c) 2014-2015 Kim Kulling +Copyright (c) 2014-2020 Kim Kulling 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 @@ -40,7 +40,7 @@ class IOStreamBase; class DLL_ODDLPARSER_EXPORT OpenDDLExport { public: /// @brief The class constructor - OpenDDLExport( IOStreamBase *stream = ddl_nullptr ); + OpenDDLExport(IOStreamBase *stream = nullptr); /// @brief The class destructor. ~OpenDDLExport(); @@ -49,29 +49,29 @@ public: /// @param ctx [in] Pointer to the context. /// @param filename [in] The filename for the export. /// @return True in case of success, false in case of an error. - bool exportContext( Context *ctx, const std::string &filename ); + bool exportContext(Context *ctx, const std::string &filename); /// @brief Handles a node export. /// @param node [in] The node to handle with. /// @return True in case of success, false in case of an error. - bool handleNode( DDLNode *node ); + bool handleNode(DDLNode *node); /// @brief Writes the statement to the stream. /// @param statement [in] The content to write. /// @return True in case of success, false in case of an error. - bool writeToStream( const std::string &statement ); + bool writeToStream(const std::string &statement); protected: - bool writeNode( DDLNode *node, std::string &statement ); - bool writeNodeHeader( DDLNode *node, std::string &statement ); - bool writeProperties( DDLNode *node, std::string &statement ); - bool writeValueType( Value::ValueType type, size_t numItems, std::string &statement ); - bool writeValue( Value *val, std::string &statement ); - bool writeValueArray( DataArrayList *al, std::string &statement ); + bool writeNode(DDLNode *node, std::string &statement); + bool writeNodeHeader(DDLNode *node, std::string &statement); + bool writeProperties(DDLNode *node, std::string &statement); + bool writeValueType(Value::ValueType type, size_t numItems, std::string &statement); + bool writeValue(Value *val, std::string &statement); + bool writeValueArray(DataArrayList *al, std::string &statement); private: - OpenDDLExport( const OpenDDLExport & ) ddl_no_copy; - OpenDDLExport &operator = ( const OpenDDLExport & ) ddl_no_copy; + OpenDDLExport(const OpenDDLExport &) ddl_no_copy; + OpenDDLExport &operator=(const OpenDDLExport &) ddl_no_copy; private: IOStreamBase *m_stream; diff --git a/contrib/openddlparser/include/openddlparser/OpenDDLParser.h b/contrib/openddlparser/include/openddlparser/OpenDDLParser.h index ef7f3a72e..5794add90 100644 --- a/contrib/openddlparser/include/openddlparser/OpenDDLParser.h +++ b/contrib/openddlparser/include/openddlparser/OpenDDLParser.h @@ -1,7 +1,7 @@ /*----------------------------------------------------------------------------------------------- The MIT License (MIT) -Copyright (c) 2014-2015 Kim Kulling +Copyright (c) 2014-2020 Kim Kulling 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 @@ -22,13 +22,13 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -----------------------------------------------------------------------------------------------*/ #pragma once -#include #include +#include #include #include -#include #include +#include BEGIN_ODDLPARSER_NS @@ -39,14 +39,9 @@ struct Identifier; struct Reference; struct Property; -template -inline -bool isEmbeddedCommentOpenTag( T *in, T *end ) { - if ( in == end ) { - return false; - } - - if ( in == '/' && in+1 == '*' ) { +template +inline bool isEmbeddedCommentOpenTag(T *in, T *end) { + if (in == '/' && in + 1 == '*') { return true; } @@ -58,11 +53,10 @@ bool isEmbeddedCommentOpenTag( T *in, T *end ) { /// @param end [in] The end position in the buffer. /// @return Pointer showing to the next token or the end of the buffer. /// @detail Will not increase buffer when already a valid buffer was found. -template -inline -T *lookForNextToken( T *in, T *end ) { - while( ( in != end ) && ( isSpace( *in ) || isNewLine( *in ) || ',' == *in ) ) { - in++; +template +inline T *lookForNextToken(T *in, T *end) { + while ((in != end) && (isSpace(*in) || isNewLine(*in) || ',' == *in)) { + ++in; } return in; } @@ -72,26 +66,25 @@ T *lookForNextToken( T *in, T *end ) { /// @param end [in] The end position in the buffer. /// @return Pointer showing to the next token or the end of the buffer. /// @detail Will increase buffer by a minimum of one. -template -inline -T *getNextToken( T *in, T *end ) { - T *tmp( in ); - in = lookForNextToken( in, end ); - if( tmp == in ) { - in++; +template +inline T *getNextToken(T *in, T *end) { + T *tmp(in); + in = lookForNextToken(in, end); + if (tmp == in) { + ++in; } return in; } /// @brief Defines the log severity. enum LogSeverity { - ddl_debug_msg = 0, ///< Debug message, for debugging - ddl_info_msg, ///< Info messages, normal mode - ddl_warn_msg, ///< Parser warnings - ddl_error_msg ///< Parser errors + ddl_debug_msg = 0, ///< Debug message, for debugging + ddl_info_msg, ///< Info messages, normal mode + ddl_warn_msg, ///< Parser warnings + ddl_error_msg ///< Parser errors }; -DLL_ODDLPARSER_EXPORT const char *getTypeToken( Value::ValueType type ); +DLL_ODDLPARSER_EXPORT const char *getTypeToken(Value::ValueType type); //------------------------------------------------------------------------------------------------- /// @class OpenDDLParser @@ -105,7 +98,7 @@ DLL_ODDLPARSER_EXPORT const char *getTypeToken( Value::ValueType type ); class DLL_ODDLPARSER_EXPORT OpenDDLParser { public: /// @brief The log callback function pointer. - typedef void( *logCallback )( LogSeverity severity, const std::string &msg ); + typedef void (*logCallback)(LogSeverity severity, const std::string &msg); public: /// @brief The default class constructor. @@ -114,14 +107,14 @@ public: /// @brief The class constructor. /// @param buffer [in] The buffer /// @param len [in] Size of the buffer - OpenDDLParser( const char *buffer, size_t len ); + OpenDDLParser(const char *buffer, size_t len); /// @brief The class destructor. ~OpenDDLParser(); /// @brief Setter for an own log callback function. /// @param callback [in] The own callback. - void setLogCallback( logCallback callback ); + void setLogCallback(logCallback callback); /// @brief Getter for the log callback. /// @return The current log callback. @@ -130,11 +123,11 @@ public: /// @brief Assigns a new buffer to parse. /// @param buffer [in] The buffer /// @param len [in] Size of the buffer - void setBuffer( const char *buffer, size_t len ); + void setBuffer(const char *buffer, size_t len); /// @brief Assigns a new buffer to parse. /// @param buffer [in] The buffer as a std::vector. - void setBuffer( const std::vector &buffer ); + void setBuffer(const std::vector &buffer); /// @brief Returns the buffer pointer. /// @return The buffer pointer. @@ -147,12 +140,15 @@ public: /// @brief Clears all parser data, including buffer and active context. void clear(); + bool validate(); + /// @brief Starts the parsing of the OpenDDL-file. /// @return True in case of success, false in case of an error. /// @remark In case of errors check log. bool parse(); - bool exportContext( Context *ctx, const std::string &filename ); + + bool exportContext(Context *ctx, const std::string &filename); /// @brief Returns the root node. /// @return The root node. @@ -163,37 +159,37 @@ public: Context *getContext() const; public: // parser helpers - char *parseNextNode( char *current, char *end ); - char *parseHeader( char *in, char *end ); - char *parseStructure( char *in, char *end ); - char *parseStructureBody( char *in, char *end, bool &error ); - void pushNode( DDLNode *node ); + char *parseNextNode(char *current, char *end); + char *parseHeader(char *in, char *end); + char *parseStructure(char *in, char *end); + char *parseStructureBody(char *in, char *end, bool &error); + void pushNode(DDLNode *node); DDLNode *popNode(); DDLNode *top(); - static void normalizeBuffer( std::vector &buffer ); - static char *parseName( char *in, char *end, Name **name ); - static char *parseIdentifier( char *in, char *end, Text **id ); - static char *parsePrimitiveDataType( char *in, char *end, Value::ValueType &type, size_t &len ); - static char *parseReference( char *in, char *end, std::vector &names ); - static char *parseBooleanLiteral( char *in, char *end, Value **boolean ); - static char *parseIntegerLiteral( char *in, char *end, Value **integer, Value::ValueType integerType = Value::ddl_int32 ); - static char *parseFloatingLiteral( char *in, char *end, Value **floating, Value::ValueType floatType= Value::ddl_float ); - static char *parseStringLiteral( char *in, char *end, Value **stringData ); - static char *parseHexaLiteral( char *in, char *end, Value **data ); - static char *parseProperty( char *in, char *end, Property **prop ); - static char *parseDataList( char *in, char *end, Value::ValueType type, Value **data, size_t &numValues, Reference **refs, size_t &numRefs ); - static char *parseDataArrayList( char *in, char *end, Value::ValueType type, DataArrayList **dataList ); + static void normalizeBuffer(std::vector &buffer); + static char *parseName(char *in, char *end, Name **name); + static char *parseIdentifier(char *in, char *end, Text **id); + static char *parsePrimitiveDataType(char *in, char *end, Value::ValueType &type, size_t &len); + static char *parseReference(char *in, char *end, std::vector &names); + static char *parseBooleanLiteral(char *in, char *end, Value **boolean); + static char *parseIntegerLiteral(char *in, char *end, Value **integer, Value::ValueType integerType = Value::ValueType::ddl_int32); + static char *parseFloatingLiteral(char *in, char *end, Value **floating, Value::ValueType floatType = Value::ValueType::ddl_float); + static char *parseStringLiteral(char *in, char *end, Value **stringData); + static char *parseHexaLiteral(char *in, char *end, Value **data); + static char *parseProperty(char *in, char *end, Property **prop); + static char *parseDataList(char *in, char *end, Value::ValueType type, Value **data, size_t &numValues, Reference **refs, size_t &numRefs); + static char *parseDataArrayList(char *in, char *end, Value::ValueType type, DataArrayList **dataList); static const char *getVersion(); private: - OpenDDLParser( const OpenDDLParser & ) ddl_no_copy; - OpenDDLParser &operator = ( const OpenDDLParser & ) ddl_no_copy; + OpenDDLParser(const OpenDDLParser &) ddl_no_copy; + OpenDDLParser &operator=(const OpenDDLParser &) ddl_no_copy; private: logCallback m_logCallback; std::vector m_buffer; - typedef std::vector DDLNodeStack; + typedef std::vector DDLNodeStack; DDLNodeStack m_stack; Context *m_context; }; diff --git a/contrib/openddlparser/include/openddlparser/OpenDDLParserUtils.h b/contrib/openddlparser/include/openddlparser/OpenDDLParserUtils.h index f0762ac67..5f177f252 100644 --- a/contrib/openddlparser/include/openddlparser/OpenDDLParserUtils.h +++ b/contrib/openddlparser/include/openddlparser/OpenDDLParserUtils.h @@ -1,7 +1,7 @@ /*----------------------------------------------------------------------------------------------- The MIT License (MIT) -Copyright (c) 2014-2015 Kim Kulling +Copyright (c) 2014-2020 Kim Kulling 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 @@ -26,64 +26,318 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. BEGIN_ODDLPARSER_NS -template -inline -bool isUpperCase( T in ) { - return ( in >= 'A' && in <= 'Z' ); +template +inline bool isUpperCase(T in) { + return (in >= 'A' && in <= 'Z'); } -template -inline -bool isLowerCase( T in ) { - return ( in >= 'a' && in <= 'z' ); +template +inline bool isLowerCase(T in) { + return (in >= 'a' && in <= 'z'); } -template -inline -bool isSpace( const T in ) { - return ( ' ' == in || '\t' == in ); +template +inline bool isSpace(const T in) { + return (' ' == in || '\t' == in); } -template -inline -bool isNewLine( const T in ) { - return ( '\n' == in || ( '\r' == in ) ); +template +inline bool isNewLine(const T in) { + return ('\n' == in || ('\r' == in)); } -template -inline -bool isSeparator( T in ) { - if( isSpace( in ) || ',' == in || '{' == in || '}' == in || '[' == in || '(' == in || ')' == in ) { +template +inline bool isSeparator(T in) { + if (isSpace(in) || ',' == in || '{' == in || '}' == in || '[' == in || '(' == in || ')' == in) { return true; } return false; } -template -inline -bool isNumeric( const T in ) { - return ( in >= '0' && in <= '9' ); +static const unsigned char chartype_table[256] = { + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, // 0-15 + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, // 16-31 + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, // 32-47 + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 1, + 0, + 0, + 0, + 0, + 0, // 48-63 + + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, // 64-79 + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, // 80-95 + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, // 96-111 + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, // 112-127 + + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, // > 127 + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, +}; + +template +inline bool isNumeric(const T in) { + return (chartype_table[static_cast(in)] == 1); } -template -inline -bool isNotEndOfToken( T *in, T *end ) { - return ( '}' != *in && ',' != *in && !isSpace( *in ) && ')' != *in && in != end ); +template +inline bool isNotEndOfToken(T *in, T *end) { + return ('}' != *in && ',' != *in && !isSpace(*in) && ')' != *in && in != end); } -template -inline -bool isInteger( T *in, T *end ) { - if( in != end ) { - if( *in == '-' ) { +template +inline bool isInteger(T *in, T *end) { + if (in != end) { + if (*in == '-') { ++in; } } - bool result( false ); - while( isNotEndOfToken( in, end ) ) { - result = isNumeric( *in ); - if( !result ) { + bool result(false); + while (isNotEndOfToken(in, end)) { + result = isNumeric(*in); + if (!result) { break; } ++in; @@ -92,40 +346,39 @@ bool isInteger( T *in, T *end ) { return result; } -template -inline -bool isFloat( T *in, T *end ) { - if( in != end ) { - if( *in == '-' ) { +template +inline bool isFloat(T *in, T *end) { + if (in != end) { + if (*in == '-') { ++in; } } // check for <1>.0f - bool result( false ); - while( isNotEndOfToken( in, end ) ) { - if( *in == '.' ) { + bool result(false); + while (isNotEndOfToken(in, end)) { + if (*in == '.') { result = true; break; } - result = isNumeric( *in ); - if( !result ) { + result = isNumeric(*in); + if (!result) { return false; } ++in; } // check for 1<.>0f - if( *in == '.' ) { + if (*in == '.') { ++in; } else { return false; } // check for 1.<0>f - while( isNotEndOfToken( in, end ) ) { - result = isNumeric( *in ); - if( !result ) { + while (isNotEndOfToken(in, end)) { + result = isNumeric(*in); + if (!result) { return false; } ++in; @@ -134,24 +387,21 @@ bool isFloat( T *in, T *end ) { return result; } -template -inline -bool isCharacter( const T in ) { - return ( ( in >= 'a' && in <= 'z' ) || ( in >= 'A' && in <= 'Z' ) ); +template +inline bool isCharacter(const T in) { + return ((in >= 'a' && in <= 'z') || (in >= 'A' && in <= 'Z')); } -template -inline -bool isStringLiteral( const T in ) { - return ( in == '\"' ); +template +inline bool isStringLiteral(const T in) { + return (in == '\"'); } -template -inline -bool isHexLiteral( T *in, T *end ) { - if( *in == '0' ) { - if( in + 1 != end ) { - if( *( in + 1 ) == 'x' || *( in + 1 ) == 'X' ) { +template +inline bool isHexLiteral(T *in, T *end) { + if (*in == '0') { + if (in + 1 != end) { + if (*(in + 1) == 'x' || *(in + 1) == 'X') { return true; } } @@ -160,13 +410,12 @@ bool isHexLiteral( T *in, T *end ) { return false; } -template -inline -bool isReference( T *in, T *end ) { - if( *in == 'r' ) { - if( *(in+1) == 'e' ) { - if( *(in+2) == 'f' ) { - if( ( in + 2 ) != end ) { +template +inline bool isReference(T *in, T *end) { + if (*in == 'r') { + if (*(in + 1) == 'e') { + if (*(in + 2) == 'f') { + if ((in + 2) != end) { return true; } } @@ -176,16 +425,14 @@ bool isReference( T *in, T *end ) { return false; } -template -inline -bool isEndofLine( const T in ) { - return ( '\n' == in ); +template +inline bool isEndofLine(const T in) { + return ('\n' == in); } -template -inline -static T *getNextSeparator( T *in, T *end ) { - while( !isSeparator( *in ) || in == end ) { +template +inline static T *getNextSeparator(T *in, T *end) { + while (!isSeparator(*in) || in == end) { ++in; } return in; @@ -193,30 +440,28 @@ static T *getNextSeparator( T *in, T *end ) { static const int ErrorHex2Decimal = 9999999; -inline -int hex2Decimal( char in ) { - if( isNumeric( in ) ) { - return ( in - 48 ); +inline int hex2Decimal(char in) { + if (isNumeric(in)) { + return (in - 48); } - char hexCodeLower( 'a' ), hexCodeUpper( 'A' ); - for( int i = 0; i<16; i++ ) { - if( in == hexCodeLower + i || in == hexCodeUpper + i ) { - return ( i+10 ); + char hexCodeLower('a'), hexCodeUpper('A'); + for (int i = 0; i < 16; i++) { + if (in == hexCodeLower + i || in == hexCodeUpper + i) { + return (i + 10); } } return ErrorHex2Decimal; } -template -inline -bool isComment( T *in, T *end ) { - if ( *in=='/' ) { - if ( in+1!=end ) { - if ( *( in+1 )=='/' ) { - char *drive( ( in+2 ) ); - if ( (isUpperCase( *drive )||isLowerCase( *drive ))&&*( drive+1 )=='/' ) { +template +inline bool isComment(T *in, T *end) { + if (*in == '/') { + if (in + 1 != end) { + if (*(in + 1) == '/') { + char *drive((in + 2)); + if ((isUpperCase(*drive) || isLowerCase(*drive)) && *(drive + 1) == '/') { return false; } else { return true; @@ -228,9 +473,8 @@ bool isComment( T *in, T *end ) { return false; } -template -inline -bool isCommentOpenTag(T *in, T *end ) { +template +inline bool isCommentOpenTag(T *in, T *end) { if (*in == '/') { if (in + 1 != end) { if (*(in + 1) == '*') { @@ -242,9 +486,8 @@ bool isCommentOpenTag(T *in, T *end ) { return false; } -template -inline -bool isCommentCloseTag(T *in, T *end) { +template +inline bool isCommentCloseTag(T *in, T *end) { if (*in == '*') { if (in + 1 != end) { if (*(in + 1) == '/') { @@ -257,4 +500,3 @@ bool isCommentCloseTag(T *in, T *end) { } END_ODDLPARSER_NS - diff --git a/contrib/openddlparser/include/openddlparser/OpenDDLStream.h b/contrib/openddlparser/include/openddlparser/OpenDDLStream.h index 93370da03..93bde5f7c 100644 --- a/contrib/openddlparser/include/openddlparser/OpenDDLStream.h +++ b/contrib/openddlparser/include/openddlparser/OpenDDLStream.h @@ -1,7 +1,7 @@ /*----------------------------------------------------------------------------------------------- The MIT License (MIT) -Copyright (c) 2014-2015 Kim Kulling +Copyright (c) 2014-2020 Kim Kulling 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 @@ -38,7 +38,7 @@ public: /// @brief The class destructor, virtual. virtual ~StreamFormatterBase(); - /// @brief Will format the sring and return the new formatted result. + /// @brief Will format the string and return the new formatted result. /// @param statement [in] The string to reformat. /// @return The reformatted result. virtual std::string format(const std::string &statement); @@ -52,7 +52,7 @@ class DLL_ODDLPARSER_EXPORT IOStreamBase { public: /// @brief The class constructor with the formatter. /// @param formatter [in] The formatter to use. - explicit IOStreamBase(StreamFormatterBase *formatter = ddl_nullptr); + explicit IOStreamBase(StreamFormatterBase *formatter = nullptr); /// @brief The class destructor, virtual. virtual ~IOStreamBase(); @@ -74,7 +74,7 @@ public: /// @param sizeToRead [in] The size to read in bytes. /// @param statement [out] The read statements. /// @return The bytes read from the stream. - virtual size_t read( size_t sizeToRead, std::string &statement ); + virtual size_t read(size_t sizeToRead, std::string &statement); /// @brief Will write a string into the stream. /// @param statement [in] The string to write. diff --git a/contrib/openddlparser/include/openddlparser/TPoolAllocator.h b/contrib/openddlparser/include/openddlparser/TPoolAllocator.h new file mode 100644 index 000000000..6076c7324 --- /dev/null +++ b/contrib/openddlparser/include/openddlparser/TPoolAllocator.h @@ -0,0 +1,226 @@ +/*----------------------------------------------------------------------------------------------- +The MIT License (MIT) + +Copyright (c) 2014-2019 Kim Kulling + +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. +-----------------------------------------------------------------------------------------------*/ +#pragma once + +#include +#include + +BEGIN_ODDLPARSER_NS + +//------------------------------------------------------------------------------------------------- +/// @class TPoolAllocator +/// @ingroup CPPCore +/// +/// @brief This class implements a simple pool-based allocation scheme. +/// Initially you have to define its size. Each allocation will be done from this initially created +/// pool. You have to release all pooled instances after the usage. +/// This allocation scheme is fast and does no call any new-calls during the lifetime of the +/// allocator. +//------------------------------------------------------------------------------------------------- +template +class TPoolAllocator { +public: + TPoolAllocator(); + TPoolAllocator(size_t numItems); + ~TPoolAllocator(); + T *alloc(); + void release(); + void reserve(size_t size); + void clear(); + size_t capacity() const; + size_t reservedMem() const; + size_t freeMem() const; + void dumpAllocations(std::string &allocs); + void resize(size_t growSize); + + CPPCORE_NONE_COPYING(TPoolAllocator) + +private: + struct Pool { + size_t m_poolsize; + T *m_pool; + size_t m_currentIdx; + Pool *m_next; + + Pool() : + m_poolsize(0u), m_pool(nullptr), m_currentIdx(0u), m_next(nullptr) { + // empty + } + + Pool(size_t numItems, Pool *prev) : + m_poolsize(numItems), m_pool(nullptr), m_currentIdx(0u), m_next(prev) { + m_pool = new T[m_poolsize]; + } + + ~Pool() { + delete[] m_pool; + m_pool = nullptr; + } + + CPPCORE_NONE_COPYING(Pool) + }; + + Pool *getFreePool() { + Pool *current(m_freeList); + if (nullptr != m_freeList) { + m_freeList = m_freeList->m_next; + } + return current; + } + + Pool *m_first; + Pool *m_current; + Pool *m_freeList; + size_t m_capacity; +}; + +template +inline TPoolAllocator::TPoolAllocator() : + m_first(nullptr), m_current(nullptr), m_freeList(nullptr), m_capacity(0L) { + // empty +} + +template +inline TPoolAllocator::TPoolAllocator(size_t numItems) : + m_first(nullptr), m_current(nullptr), m_freeList(nullptr), m_capacity(0L) { + m_first = new Pool(numItems); + m_capacity += numItems; + m_current = m_first; +} + +template +inline TPoolAllocator::~TPoolAllocator() { + clear(); +} + +template +inline T *TPoolAllocator::alloc() { + if (nullptr == m_current) { + return nullptr; + } + + if (m_current->m_currentIdx == m_current->m_poolsize) { + resize(m_current->m_poolsize); + } + + T *ptr(&m_current->m_pool[m_current->m_currentIdx]); + m_current->m_currentIdx++; + + return ptr; +} + +template +inline void TPoolAllocator::release() { + if (nullptr == m_current) { + return; + } + + Pool *current(m_first); + while (nullptr != current) { + current->m_currentIdx = 0; + current = current->m_next; + } + m_freeList = m_first->m_next; + m_current = m_first; +} + +template +inline void TPoolAllocator::reserve(size_t size) { + clear(); + + m_first = new Pool(size, nullptr); + m_current = m_first; + + m_current->m_pool = new T[size]; + m_current->m_poolsize = size; + + m_capacity = size; +} + +template +inline void TPoolAllocator::clear() { + if (nullptr == m_current) { + return; + } + + Pool *next(m_first); + while (nullptr != next) { + Pool *current = next; + next = current->m_next; + delete current; + } + m_current = nullptr; + m_freeList = nullptr; +} + +template +inline size_t TPoolAllocator::capacity() const { + return m_capacity; +} + +template +inline size_t TPoolAllocator::reservedMem() const { + return m_capacity * sizeof(T); +} + +template +inline size_t TPoolAllocator::freeMem() const { + if (nullptr == m_current) { + return 0L; + } + + return (m_current->m_poolsize - m_current->m_currentIdx); +} + +template +inline void TPoolAllocator::dumpAllocations(std::string &allocs) { + allocs.clear(); + allocs += "Number allocations = "; + allocs += std::to_string(m_current->m_currentIdx); + allocs += "\n"; +} + +template +inline void TPoolAllocator::resize(size_t growSize) { + if (nullptr != m_current) { + if (growSize < m_current->m_poolsize) { + return; + } + } + + if (nullptr == m_first) { + m_first = new Pool(growSize, nullptr); + m_current = m_first; + m_capacity += m_current->m_poolsize; + } else { + Pool *pool = getFreePool(); + if (nullptr == pool) { + pool = new Pool(growSize, nullptr); + m_capacity += growSize; + } + m_current->m_next = pool; + m_current = m_current->m_next; + } +} + +END_ODDLPARSER_NS \ No newline at end of file diff --git a/contrib/openddlparser/include/openddlparser/Value.h b/contrib/openddlparser/include/openddlparser/Value.h index 77c6da06b..75af7816b 100644 --- a/contrib/openddlparser/include/openddlparser/Value.h +++ b/contrib/openddlparser/include/openddlparser/Value.h @@ -1,7 +1,7 @@ /*----------------------------------------------------------------------------------------------- The MIT License (MIT) -Copyright (c) 2014-2015 Kim Kulling +Copyright (c) 2014-2020 Kim Kulling 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 @@ -101,7 +101,7 @@ public: }; /// @brief This enum describes the data type stored in the value. - enum ValueType { + enum class ValueType { ddl_none = -1, ///< Nothing specified ddl_bool = 0, ///< A boolean type ddl_int8, ///< Integer type, 8 bytes