v4games
/
assimp
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #3478 from assimp/new_openddl 

openddl: latest greatest.
pull/3471/head^2
Kim Kulling 2020-10-27 10:03:50 +01:00 committed by GitHub
parent 831af12974 43f7224d0c
commit 753503ad83
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
24 changed files with 2390 additions and 1990 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

@ -578,10 +578,6 @@ ELSE ()
ADD_DEFINITIONS( -DASSIMP_BUILD_NO_C4D_IMPORTER )
ENDIF ()
#IF(NOT ASSIMP_HUNTER_ENABLED)
ADD_SUBDIRECTORY(contrib)
#ENDIF()
ADD_SUBDIRECTORY( code/ )
IF ( ASSIMP_BUILD_ASSIMP_TOOLS )
# The viewer for windows only

1
code/AssetLib/Blender/BlenderDNA.cpp
View File

@ -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);

7
code/AssetLib/Blender/BlenderDNA.h
View File

@ -84,9 +84,8 @@ class ObjectCache;
// -------------------------------------------------------------------------------
struct Error : DeadlyImportError {
template <typename... T>
explicit Error(T&&... args)
: DeadlyImportError(args...)
{
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. */
// -------------------------------------------------------------------------------

43
code/AssetLib/Blender/BlenderLoader.h
View File

@ -106,51 +106,18 @@ class BlenderImporter : public BaseImporter, public LogFunctions<BlenderImporter
public:
BlenderImporter();
~BlenderImporter();
public:
// --------------------
bool CanRead( const std::string& pFile,
IOSystem* pIOHandler,
bool checkSig
) const;
bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const;
protected:
// --------------------
const aiImporterDesc* GetInfo () const;
// --------------------
void GetExtensionList(std::set<std::string>& app);
// --------------------
void SetupProperties(const Importer* pImp);
// --------------------
void InternReadFile( const std::string& pFile,
aiScene* pScene,
IOSystem* pIOHandler
);
// --------------------
void ParseBlendFile(Blender::FileDatabase& out,
std::shared_ptr<IOStream> 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<IOStream> 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,

7
code/AssetLib/Blender/BlenderScene.h
View File

@ -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;

77
code/AssetLib/OpenGEX/OpenGEXImporter.cpp
View File

@ -4,7 +4,6 @@ Open Asset Import Library (assimp)
Copyright (c) 2006-2020, assimp team
All rights reserved.
Redistribution and use of this software in source and binary forms,
@ -45,13 +44,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "PostProcessing/MakeVerboseFormat.h"
#include <assimp/DefaultIOSystem.h>
#include <assimp/DefaultLogger.hpp>
#include <assimp/StringComparison.h>
#include <assimp/DefaultLogger.hpp>
#include <openddlparser/OpenDDLParser.h>
#include <assimp/scene.h>
#include <assimp/ai_assert.h>
#include <assimp/importerdesc.h>
#include <assimp/scene.h>
#include <openddlparser/OpenDDLParser.h>
#include <vector>
@ -218,18 +217,15 @@ static void propId2StdString( Property *prop, std::string &name, std::string &ke
#else
name = prop->m_key->m_buffer;
#endif
if ( Value::ddl_string == prop->m_value->m_type ) {
if (Value::ValueType::ddl_string == prop->m_value->m_type) {
key = prop->m_value->getString();
}
}
}
//------------------------------------------------------------------------------------------------
OpenGEXImporter::VertexContainer::VertexContainer()
: m_numColors( 0 )
, m_colors( nullptr )
, m_numUVComps()
, m_textureCoords() {
OpenGEXImporter::VertexContainer::VertexContainer() :
m_numColors(0), m_colors(nullptr), m_numUVComps(), m_textureCoords() {
// empty
}
@ -243,10 +239,10 @@ OpenGEXImporter::VertexContainer::~VertexContainer() {
}
//------------------------------------------------------------------------------------------------
OpenGEXImporter::RefInfo::RefInfo( aiNode *node, Type type, std::vector<std::string> &names )
: m_node( node )
, m_type( type )
, m_Names( names ) {
OpenGEXImporter::RefInfo::RefInfo(aiNode *node, Type type, std::vector<std::string> &names) :
m_node(node),
m_type(type),
m_Names(names) {
// empty
}
@ -256,26 +252,26 @@ OpenGEXImporter::RefInfo::~RefInfo() {
}
//------------------------------------------------------------------------------------------------
OpenGEXImporter::OpenGEXImporter()
: m_root( nullptr )
, m_nodeChildMap()
, m_meshCache()
, m_mesh2refMap()
, m_material2refMap()
, m_ctx( nullptr )
, m_metrics()
, m_currentNode( nullptr )
, m_currentVertices()
, m_currentMesh( nullptr )
, m_currentMaterial( nullptr )
, m_currentLight( nullptr )
, m_currentCamera( nullptr )
, m_tokenType( Grammar::NoneType )
, m_materialCache()
, m_cameraCache()
, m_lightCache()
, m_nodeStack()
, m_unresolvedRefStack() {
OpenGEXImporter::OpenGEXImporter() :
m_root(nullptr),
m_nodeChildMap(),
m_meshCache(),
m_mesh2refMap(),
m_material2refMap(),
m_ctx(nullptr),
m_metrics(),
m_currentNode(nullptr),
m_currentVertices(),
m_currentMesh(nullptr),
m_currentMaterial(nullptr),
m_currentLight(nullptr),
m_currentCamera(nullptr),
m_tokenType(Grammar::NoneType),
m_materialCache(),
m_cameraCache(),
m_lightCache(),
m_nodeStack(),
m_unresolvedRefStack() {
// empty
}
@ -443,17 +439,17 @@ void OpenGEXImporter::handleMetricNode( DDLNode *node, aiScene * /*pScene*/ ) {
Property *prop(node->getProperties());
while (nullptr != prop) {
if (nullptr != prop->m_key) {
if( Value::ddl_string == prop->m_value->m_type ) {
if (Value::ValueType::ddl_string == prop->m_value->m_type) {
std::string valName((char *)prop->m_value->m_data);
int type(Grammar::isValidMetricType(valName.c_str()));
if (Grammar::NoneType != type) {
Value *val(node->getValue());
if (nullptr != val) {
if( Value::ddl_float == val->m_type ) {
if (Value::ValueType::ddl_float == val->m_type) {
m_metrics[type].m_floatValue = val->getFloat();
} else if( Value::ddl_int32 == val->m_type ) {
} else if (Value::ValueType::ddl_int32 == val->m_type) {
m_metrics[type].m_intValue = val->getInt32();
} else if( Value::ddl_string == val->m_type ) {
} else if (Value::ValueType::ddl_string == val->m_type) {
m_metrics[type].m_stringValue = std::string(val->getString());
} else {
throw DeadlyImportError("OpenGEX: invalid data type for Metric node.");
@ -475,14 +471,13 @@ void OpenGEXImporter::handleNameNode( DDLNode *node, aiScene * /*pScene*/ ) {
Value *val(node->getValue());
if (nullptr != val) {
if( Value::ddl_string != val->m_type ) {
if (Value::ValueType::ddl_string != val->m_type) {
throw DeadlyImportError("OpenGEX: invalid data type for value in node name.");
return;
}
const std::string name(val->getString());
if( m_tokenType == Grammar::GeometryNodeToken || m_tokenType == Grammar::LightNodeToken
|| m_tokenType == Grammar::CameraNodeToken ) {
if (m_tokenType == Grammar::GeometryNodeToken || m_tokenType == Grammar::LightNodeToken || m_tokenType == Grammar::CameraNodeToken) {
m_currentNode->mName.Set(name.c_str());
} else if (m_tokenType == Grammar::MaterialToken) {
aiString aiName;

6
code/Common/Version.cpp
View File

@ -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 <assimp/scene.h>
@ -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

1
contrib/CMakeLists.txt
View File

@ -1 +0,0 @@

24
contrib/openddlparser/CMakeLists.txt
View File

@ -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} )

72
contrib/openddlparser/code/DDLNode.cpp
View File

@ -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 <openddlparser/DDLNode.h>
#include <openddlparser/OpenDDLParser.h>
#include <openddlparser/OpenDDLStream.h>
#include <algorithm>
@ -30,13 +31,12 @@ BEGIN_ODDLPARSER_NS
DDLNode::DllNodeList DDLNode::s_allocatedNodes;
template <class T>
inline
static void releaseDataType( T *ptr ) {
if( ddl_nullptr == ptr ) {
inline static void releaseDataType(T *ptr) {
if (nullptr == ptr) {
return;
}
T *current( ddl_nullptr );
T *current(nullptr);
while (ptr) {
current = ptr;
ptr = ptr->m_next;
@ -45,23 +45,23 @@ static void releaseDataType( T *ptr ) {
}
static void releaseReferencedNames(Reference *ref) {
if( ddl_nullptr == 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 ) {
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);
}
@ -73,9 +73,9 @@ DDLNode::~DDLNode() {
releaseReferencedNames(m_references);
delete m_dtArrayList;
m_dtArrayList = ddl_nullptr;
m_dtArrayList = nullptr;
if (s_allocatedNodes[m_idx] == this) {
s_allocatedNodes[ m_idx ] = ddl_nullptr;
s_allocatedNodes[m_idx] = nullptr;
}
for (size_t i = 0; i < m_children.size(); i++) {
delete m_children[i];
@ -88,18 +88,18 @@ void DDLNode::attachParent( DDLNode *parent ) {
}
m_parent = parent;
if( ddl_nullptr != m_parent ) {
if (nullptr != m_parent) {
m_parent->m_children.push_back(this);
}
}
void DDLNode::detachParent() {
if( ddl_nullptr != m_parent ) {
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;
}
}
@ -128,7 +128,7 @@ const std::string &DDLNode::getName() const {
}
void DDLNode::setProperties(Property *prop) {
if(m_properties!=ddl_nullptr)
if (m_properties != nullptr)
delete m_properties;
m_properties = prop;
}
@ -139,24 +139,24 @@ Property *DDLNode::getProperties() const {
bool DDLNode::hasProperty(const std::string &name) {
const Property *prop(findPropertyByName(name));
return ( ddl_nullptr != prop );
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;
return nullptr;
}
if( ddl_nullptr == m_properties ) {
return ddl_nullptr;
if (nullptr == m_properties) {
return nullptr;
}
Property *current(m_properties);
while( ddl_nullptr != current ) {
while (nullptr != current) {
int res = strncmp(current->m_key->m_buffer, name.c_str(), name.size());
if (0 == res) {
return current;
@ -164,7 +164,7 @@ Property *DDLNode::findPropertyByName( const std::string &name ) {
current = current->m_next;
}
return ddl_nullptr;
return nullptr;
}
void DDLNode::setValue(Value *val) {
@ -191,8 +191,18 @@ 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) {

74
contrib/openddlparser/code/OpenDDLCommon.cpp
View File

@ -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,16 +20,16 @@ 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 <openddlparser/OpenDDLCommon.h>
#include <openddlparser/DDLNode.h>
#include <openddlparser/OpenDDLCommon.h>
#include <openddlparser/Value.h>
BEGIN_ODDLPARSER_NS
Text::Text( const char *buffer, size_t numChars )
: m_capacity( 0 )
, m_len( 0 )
, m_buffer( ddl_nullptr ) {
Text::Text(const char *buffer, size_t numChars) :
m_capacity(0),
m_len(0),
m_buffer(nullptr) {
set(buffer, numChars);
}
@ -39,7 +39,7 @@ Text::~Text() {
void Text::clear() {
delete[] m_buffer;
m_buffer = ddl_nullptr;
m_buffer = nullptr;
m_capacity = 0;
m_len = 0;
}
@ -74,15 +74,14 @@ bool Text::operator == ( const Text &rhs ) const {
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) {
@ -90,17 +89,13 @@ Name::Name( const Name &name ){
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 ) {
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++) {
@ -124,7 +119,7 @@ Reference::~Reference() {
}
m_numRefs = 0;
delete[] m_referencedName;
m_referencedName = ddl_nullptr;
m_referencedName = nullptr;
}
size_t Reference::sizeInBytes() {
@ -135,7 +130,7 @@ size_t Reference::sizeInBytes() {
size_t size(0);
for (size_t i = 0; i < m_numRefs; i++) {
Name *name(m_referencedName[i]);
if ( ddl_nullptr != name ) {
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)
if (m_ref != nullptr)
delete (m_ref);
if(m_next!=ddl_nullptr)
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 ) {
if (nullptr == m_next) {
if (m_dataList != nullptr) {
result = 1;
}
return result;
}
DataArrayList *n(m_next);
while( ddl_nullptr != n ) {
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

140
contrib/openddlparser/code/OpenDDLExport.cpp
View File

@ -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 <openddlparser/OpenDDLExport.h>
#include <openddlparser/DDLNode.h>
#include <openddlparser/Value.h>
#include <openddlparser/OpenDDLExport.h>
#include <openddlparser/OpenDDLParser.h>
#include <openddlparser/Value.h>
#include <sstream>
@ -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
}
@ -62,27 +61,27 @@ 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 ) {
if (nullptr == ctx) {
return false;
}
DDLNode *root(ctx->m_root);
if ( ddl_nullptr == root ) {
if (nullptr == root) {
return true;
}
@ -98,7 +97,7 @@ bool OpenDDLExport::exportContext( Context *ctx, const std::string &filename ) {
}
bool OpenDDLExport::handleNode(DDLNode *node) {
if( ddl_nullptr == node ) {
if (nullptr == node) {
return true;
}
@ -106,12 +105,12 @@ bool OpenDDLExport::handleNode( DDLNode *node ) {
if (childs.empty()) {
return true;
}
DDLNode *current( ddl_nullptr );
DDLNode *current(nullptr);
DDLNodeIterator it(childs);
std::string statement;
bool success(true);
while (it.getNext(&current)) {
if( ddl_nullptr != current ) {
if (nullptr != current) {
success |= writeNode(current, statement);
if (!handleNode(current)) {
success = false;
@ -123,7 +122,7 @@ bool OpenDDLExport::handleNode( DDLNode *node ) {
}
bool OpenDDLExport::writeToStream(const std::string &statement) {
if (ddl_nullptr == m_stream ) {
if (nullptr == m_stream) {
return false;
}
@ -135,20 +134,21 @@ bool OpenDDLExport::writeToStream( const std::string &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);
statement = "}";
DataArrayList *al(node->getDataArrayList());
if ( ddl_nullptr != al ) {
if (nullptr != al) {
writeValueType(al->m_dataList->m_type, al->m_numItems, statement);
writeValueArray(al, statement);
}
Value *v(node->getValue());
if (ddl_nullptr != v ) {
if (nullptr != v) {
writeValueType(v->m_type, 1, statement);
statement = "{";
writeLineEnd(statement);
@ -165,7 +165,7 @@ bool OpenDDLExport::writeNode( DDLNode *node, std::string &statement ) {
}
bool OpenDDLExport::writeNodeHeader(DDLNode *node, std::string &statement) {
if (ddl_nullptr == node) {
if (nullptr == node) {
return false;
}
@ -181,21 +181,21 @@ bool OpenDDLExport::writeNodeHeader( DDLNode *node, std::string &statement ) {
}
bool OpenDDLExport::writeProperties(DDLNode *node, std::string &statement) {
if ( ddl_nullptr == node ) {
if (nullptr == node) {
return false;
}
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 ) {
while (nullptr != prop) {
if (!first) {
statement += ", ";
} else {
@ -214,7 +214,7 @@ bool OpenDDLExport::writeProperties( DDLNode *node, std::string &statement ) {
}
bool OpenDDLExport::writeValueType(Value::ValueType type, size_t numItems, std::string &statement) {
if ( Value::ddl_types_max == type) {
if (Value::ValueType::ddl_types_max == type) {
return false;
}
@ -234,114 +234,92 @@ bool OpenDDLExport::writeValueType( Value::ValueType type, size_t numItems, std:
}
bool OpenDDLExport::writeValue(Value *val, std::string &statement) {
if (ddl_nullptr == val) {
if (nullptr == val) {
return false;
}
switch (val->m_type) {
case Value::ddl_bool:
case Value::ValueType::ddl_bool:
if (true == val->getBool()) {
statement += "true";
} else {
statement += "false";
}
break;
case Value::ddl_int8:
{
case Value::ValueType::ddl_int8 : {
std::stringstream stream;
const int i = static_cast<int>(val->getInt8());
stream << i;
statement += stream.str();
}
break;
case Value::ddl_int16:
{
} 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::ddl_int32:
{
} break;
case Value::ValueType::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:
{
} break;
case Value::ValueType::ddl_int64: {
std::stringstream stream;
const int i = static_cast<int>(val->getInt64());
stream << i;
statement += stream.str();
}
break;
case Value::ddl_unsigned_int8:
{
} break;
case Value::ValueType::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:
{
} break;
case Value::ValueType::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:
{
} break;
case Value::ValueType::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:
{
} break;
case Value::ValueType::ddl_unsigned_int64: {
std::stringstream stream;
const int i = static_cast<unsigned int>(val->getUnsignedInt64());
stream << i;
statement += stream.str();
}
} break;
case Value::ValueType::ddl_half:
break;
case Value::ddl_half:
break;
case Value::ddl_float:
{
case Value::ValueType::ddl_float: {
std::stringstream stream;
stream << val->getFloat();
statement += stream.str();
}
break;
case Value::ddl_double:
{
} break;
case Value::ValueType::ddl_double: {
std::stringstream stream;
stream << val->getDouble();
statement += stream.str();
}
break;
case Value::ddl_string:
{
} 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_ref:
break;
case Value::ddl_none:
case Value::ddl_types_max:
case Value::ValueType::ddl_none:
case Value::ValueType::ddl_types_max:
default:
break;
}
@ -350,7 +328,7 @@ bool OpenDDLExport::writeValue( Value *val, std::string &statement ) {
}
bool OpenDDLExport::writeValueArray(DataArrayList *al, std::string &statement) {
if (ddl_nullptr == al) {
if (nullptr == al) {
return false;
}
@ -359,12 +337,13 @@ bool OpenDDLExport::writeValueArray( DataArrayList *al, std::string &statement )
}
DataArrayList *nextDataArrayList = al;
while (ddl_nullptr != nextDataArrayList) {
if (ddl_nullptr != nextDataArrayList) {
statement += "{ ";
Value *nextValue(nextDataArrayList->m_dataList);
while (nullptr != nextDataArrayList) {
if (nullptr != nextDataArrayList) {
statement += "{ ";
nextValue = nextDataArrayList->m_dataList;
size_t idx(0);
while (ddl_nullptr != nextValue) {
while (nullptr != nextValue) {
if (idx > 0) {
statement += ", ";
}
@ -381,4 +360,3 @@ bool OpenDDLExport::writeValueArray( DataArrayList *al, std::string &statement )
}
END_ODDLPARSER_NS

331
contrib/openddlparser/code/OpenDDLParser.cpp
View File

@ -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,26 +20,25 @@ 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 <openddlparser/OpenDDLParser.h>
#include <openddlparser/OpenDDLExport.h>
#include <openddlparser/OpenDDLParser.h>
#include <math.h>
#include <algorithm>
#include <cassert>
#include <iostream>
#include <sstream>
#include <algorithm>
#include <memory>
#include <math.h>
#ifdef _WIN32
#include <windows.h>
#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 = "(";
@ -50,7 +49,7 @@ namespace Grammar {
static const char *BoolFalse = "false";
static const char *CommaSeparator = ",";
static const char *PrimitiveTypeToken[ Value::ddl_types_max ] = {
static const char *PrimitiveTypeToken[(size_t)Value::ValueType::ddl_types_max] = {
"bool",
"int8",
"int16",
@ -69,12 +68,13 @@ namespace Grammar {
} // Namespace Grammar
const char *getTypeToken(Value::ValueType type) {
return Grammar::PrimitiveTypeToken[ type ];
return Grammar::PrimitiveTypeToken[(size_t)type];
}
static void logInvalidTokenError(char *in, const std::string &exp, OpenDDLParser::logCallback callback) {
std::stringstream stream;
stream << "Invalid token \"" << *in << "\"" << " expected \"" << exp << "\"" << std::endl;
stream << "Invalid token \"" << *in << "\""
<< " expected \"" << exp << "\"" << std::endl;
std::string full(in);
std::string part(full.substr(0, 50));
stream << part;
@ -82,8 +82,8 @@ static void logInvalidTokenError( char *in, const std::string &exp, OpenDDLParse
}
static bool isIntegerType(Value::ValueType integerType) {
if( integerType != Value::ddl_int8 && integerType != Value::ddl_int16 &&
integerType != Value::ddl_int32 && integerType != Value::ddl_int64 ) {
if (integerType != Value::ValueType::ddl_int8 && integerType != Value::ValueType::ddl_int16 &&
integerType != Value::ValueType::ddl_int32 && integerType != Value::ValueType::ddl_int64) {
return false;
}
@ -91,8 +91,8 @@ static bool isIntegerType( Value::ValueType integerType ) {
}
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 ) {
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;
}
@ -100,14 +100,8 @@ static bool isUnsignedIntegerType( Value::ValueType integerType ) {
}
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;
if (nullptr == id || nullptr == parser || id->m_buffer == nullptr) {
return nullptr;
}
const std::string type(id->m_buffer);
@ -135,18 +129,16 @@ 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 ) {
OpenDDLParser::OpenDDLParser(const char *buffer, size_t len) :
m_logCallback(&logMessage), m_buffer(), m_context(nullptr) {
if (0 != len) {
setBuffer(buffer, len);
}
@ -157,7 +149,7 @@ OpenDDLParser::~OpenDDLParser() {
}
void OpenDDLParser::setLogCallback(logCallback callback) {
if( ddl_nullptr != callback ) {
if (nullptr != callback) {
// install user-specific log callback
m_logCallback = callback;
} else {
@ -188,7 +180,7 @@ void OpenDDLParser::setBuffer( const std::vector<char> &buffer ) {
const char *OpenDDLParser::getBuffer() const {
if (m_buffer.empty()) {
return ddl_nullptr;
return nullptr;
}
return &m_buffer[0];
@ -200,23 +192,38 @@ size_t OpenDDLParser::getBufferSize() const {
void OpenDDLParser::clear() {
m_buffer.resize(0);
if( ddl_nullptr != m_context ) {
if (nullptr != m_context) {
delete m_context;
m_context=ddl_nullptr;
m_context = nullptr;
}
// DDLNode::releaseNodes();
}
bool OpenDDLParser::validate() {
if (m_buffer.empty()) {
return true;
}
if (!isCharacter(m_buffer[0]) && !isNumeric(m_buffer[0])) {
return false;
}
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 );
m_context->m_root = DDLNode::create("root", "", nullptr);
pushNode(m_context->m_root);
// do the main parsing
@ -225,7 +232,7 @@ bool OpenDDLParser::parse() {
size_t pos(current - &m_buffer[0]);
while (pos < m_buffer.size()) {
current = parseNextNode(current, end);
if ( current == ddl_nullptr ) {
if (current == nullptr) {
return false;
}
pos = current - &m_buffer[0];
@ -234,7 +241,7 @@ bool OpenDDLParser::parse() {
}
bool OpenDDLParser::exportContext(Context *ctx, const std::string &filename) {
if( ddl_nullptr == ctx ) {
if (nullptr == ctx) {
return false;
}
@ -251,8 +258,8 @@ char *OpenDDLParser::parseNextNode( char *in, char *end ) {
#ifdef DEBUG_HEADER_NAME
static void dumpId(Identifier *id) {
if( ddl_nullptr != id ) {
if ( ddl_nullptr != id->m_text.m_buffer ) {
if (nullptr != id) {
if (nullptr != id->m_text.m_buffer) {
std::cout << id->m_text.m_buffer << std::endl;
}
}
@ -260,11 +267,11 @@ static void dumpId( Identifier *id ) {
#endif
char *OpenDDLParser::parseHeader(char *in, char *end) {
if( ddl_nullptr == in || in == end ) {
if (nullptr == in || in == end) {
return in;
}
Text *id( ddl_nullptr );
Text *id(nullptr);
in = OpenDDLParser::parseIdentifier(in, end, &id);
#ifdef DEBUG_HEADER_NAME
@ -272,57 +279,54 @@ char *OpenDDLParser::parseHeader( char *in, char *end ) {
#endif // DEBUG_HEADER_NAME
in = lookForNextToken(in, end);
if( ddl_nullptr != id ) {
if (nullptr != id) {
// store the node
DDLNode *node(createDDLNode(id, this));
if( ddl_nullptr != node ) {
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(name_);
if( ddl_nullptr != name && ddl_nullptr != node ) {
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;
}
std::unique_ptr<Property> first;
Property *first(nullptr);
in = lookForNextToken(in, end);
if (*in == Grammar::OpenPropertyToken[0]) {
in++;
std::unique_ptr<Property> prop, prev;
Property *prop(nullptr), *prev(nullptr);
while (*in != Grammar::ClosePropertyToken[0] && in != end) {
Property *prop_(ddl_nullptr);
in = OpenDDLParser::parseProperty(in, end, &prop_);
prop.reset(prop_);
in = OpenDDLParser::parseProperty(in, end, &prop);
in = lookForNextToken(in, end);
if (*in != Grammar::CommaSeparator[0] && *in != Grammar::ClosePropertyToken[0]) {
logInvalidTokenError(in, Grammar::ClosePropertyToken, m_logCallback);
return ddl_nullptr;
return nullptr;
}
if (ddl_nullptr != prop && *in != Grammar::CommaSeparator[0]) {
if (ddl_nullptr == first) {
first = std::move(prop);
if (nullptr != prop && *in != Grammar::CommaSeparator[0]) {
if (nullptr == first) {
first = prop;
}
if (ddl_nullptr != prev) {
prev->m_next = prop.release();
if (nullptr != prev) {
prev->m_next = prop;
}
prev = std::move(prop);
prev = prop;
}
}
++in;
}
// set the properties
if (first && ddl_nullptr != node) {
node->setProperties(first.release());
if (nullptr != first && nullptr != node) {
node->setProperties(first);
}
}
@ -330,7 +334,7 @@ char *OpenDDLParser::parseHeader( char *in, char *end ) {
}
char *OpenDDLParser::parseStructure(char *in, char *end) {
if( ddl_nullptr == in || in == end ) {
if (nullptr == in || in == end) {
return in;
}
@ -340,15 +344,16 @@ char *OpenDDLParser::parseStructure( char *in, char *end ) {
// loop over all children ( data and nodes )
do {
in = parseStructureBody(in, end, error);
if(in == ddl_nullptr){
return ddl_nullptr;
if (in == nullptr) {
return nullptr;
}
} while (*in != *Grammar::CloseBracketToken);
++in;
} else {
++in;
logInvalidTokenError(in, std::string(Grammar::OpenBracketToken), m_logCallback);
return ddl_nullptr;
error = true;
return nullptr;
}
in = lookForNextToken(in, end);
@ -361,24 +366,24 @@ char *OpenDDLParser::parseStructure( char *in, char *end ) {
}
static void setNodeValues(DDLNode *currentNode, Value *values) {
if( ddl_nullptr != values ){
if( ddl_nullptr != currentNode ) {
if (nullptr != values) {
if (nullptr != currentNode) {
currentNode->setValue(values);
}
}
}
static void setNodeReferences(DDLNode *currentNode, Reference *refs) {
if( ddl_nullptr != refs ) {
if( ddl_nullptr != currentNode ) {
if (nullptr != refs) {
if (nullptr != currentNode) {
currentNode->setReferences(refs);
}
}
}
static void setNodeDataArrayList(DDLNode *currentNode, DataArrayList *dtArrayList) {
if( ddl_nullptr != dtArrayList ) {
if( ddl_nullptr != currentNode ) {
if (nullptr != dtArrayList) {
if (nullptr != currentNode) {
currentNode->setDataArrayList(dtArrayList);
}
}
@ -390,16 +395,16 @@ char *OpenDDLParser::parseStructureBody( char *in, char *end, bool &error ) {
}
in = lookForNextToken(in, end);
Value::ValueType type( Value::ddl_none );
Value::ValueType type(Value::ValueType::ddl_none);
size_t arrayLen(0);
in = OpenDDLParser::parsePrimitiveDataType(in, end, type, arrayLen);
if( Value::ddl_none != type ) {
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 );
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);
@ -417,7 +422,7 @@ char *OpenDDLParser::parseStructureBody( char *in, char *end, bool &error ) {
in = lookForNextToken(in, end);
if (*in != '}') {
logInvalidTokenError(in, std::string(Grammar::CloseBracketToken), m_logCallback);
return ddl_nullptr;
return nullptr;
} else {
//in++;
}
@ -430,7 +435,7 @@ char *OpenDDLParser::parseStructureBody( char *in, char *end, bool &error ) {
}
void OpenDDLParser::pushNode(DDLNode *node) {
if( ddl_nullptr == node ) {
if (nullptr == node) {
return;
}
@ -439,7 +444,7 @@ void OpenDDLParser::pushNode( DDLNode *node ) {
DDLNode *OpenDDLParser::popNode() {
if (m_stack.empty()) {
return ddl_nullptr;
return nullptr;
}
DDLNode *topNode(top());
@ -449,7 +454,7 @@ DDLNode *OpenDDLParser::popNode() {
DDLNode *OpenDDLParser::top() {
if (m_stack.empty()) {
return ddl_nullptr;
return nullptr;
}
DDLNode *top(m_stack.back());
@ -457,8 +462,8 @@ DDLNode *OpenDDLParser::top() {
}
DDLNode *OpenDDLParser::getRoot() const {
if( ddl_nullptr == m_context ) {
return ddl_nullptr;
if (nullptr == m_context) {
return nullptr;
}
return m_context->m_root;
@ -485,7 +490,6 @@ void OpenDDLParser::normalizeBuffer( std::vector<char> &buffer) {
++readIdx;
}
++readIdx;
++readIdx;
} else if (!isComment<char>(c, end) && !isNewLine(*c)) {
newBuffer.push_back(buffer[readIdx]);
} else {
@ -502,8 +506,8 @@ void OpenDDLParser::normalizeBuffer( std::vector<char> &buffer) {
}
char *OpenDDLParser::parseName(char *in, char *end, Name **name) {
*name = ddl_nullptr;
if( ddl_nullptr == in || in == end ) {
*name = nullptr;
if (nullptr == in || in == end) {
return in;
}
@ -518,8 +522,8 @@ char *OpenDDLParser::parseName( char *in, char *end, Name **name ) {
ntype = LocalName;
}
in++;
Name *currentName( ddl_nullptr );
Text *id( ddl_nullptr );
Name *currentName(nullptr);
Text *id(nullptr);
in = parseIdentifier(in, end, &id);
if (id) {
currentName = new Name(ntype, id);
@ -532,13 +536,16 @@ char *OpenDDLParser::parseName( char *in, char *end, Name **name ) {
}
char *OpenDDLParser::parseIdentifier(char *in, char *end, Text **id) {
*id = ddl_nullptr;
if( ddl_nullptr == in || in == end ) {
*id = nullptr;
if (nullptr == in || in == end) {
return in;
}
// ignore blanks
in = lookForNextToken(in, end);
if (in == end) {
return in;
}
// staring with a number is forbidden
if (isNumeric<const char>(*in)) {
@ -564,14 +571,14 @@ char *OpenDDLParser::parseIdentifier( char *in, char *end, Text **id ) {
}
char *OpenDDLParser::parsePrimitiveDataType(char *in, char *end, Value::ValueType &type, size_t &len) {
type = Value::ddl_none;
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++ ) {
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<Value::ValueType>(i);
@ -579,7 +586,7 @@ char *OpenDDLParser::parsePrimitiveDataType( char *in, char *end, Value::ValueTy
}
}
if( Value::ddl_none == type ) {
if (Value::ValueType::ddl_none == type) {
in = lookForNextToken(in, end);
return in;
} else {
@ -604,18 +611,18 @@ char *OpenDDLParser::parsePrimitiveDataType( char *in, char *end, Value::ValueTy
len = 1;
}
if (!ok) {
type = Value::ddl_none;
type = Value::ValueType::ddl_none;
}
return in;
}
char *OpenDDLParser::parseReference(char *in, char *end, std::vector<Name *> &names) {
if( ddl_nullptr == in || in == end ) {
if (nullptr == in || in == end) {
return in;
}
Name *nextName( ddl_nullptr );
Name *nextName(nullptr);
in = parseName(in, end, &nextName);
if (nextName) {
names.push_back(nextName);
@ -636,8 +643,8 @@ char *OpenDDLParser::parseReference( char *in, char *end, std::vector<Name*> &na
}
char *OpenDDLParser::parseBooleanLiteral(char *in, char *end, Value **boolean) {
*boolean = ddl_nullptr;
if( ddl_nullptr == in || in == end ) {
*boolean = nullptr;
if (nullptr == in || in == end) {
return in;
}
@ -653,13 +660,13 @@ char *OpenDDLParser::parseBooleanLiteral( char *in, char *end, Value **boolean )
if (0 != res) {
res = ::strncmp(Grammar::BoolFalse, start, strlen(Grammar::BoolFalse));
if (0 != res) {
*boolean = ddl_nullptr;
*boolean = nullptr;
return in;
}
*boolean = ValueAllocator::allocPrimData( Value::ddl_bool );
*boolean = ValueAllocator::allocPrimData(Value::ValueType::ddl_bool);
(*boolean)->setBool(false);
} else {
*boolean = ValueAllocator::allocPrimData( Value::ddl_bool );
*boolean = ValueAllocator::allocPrimData(Value::ValueType::ddl_bool);
(*boolean)->setBool(true);
}
@ -667,8 +674,8 @@ char *OpenDDLParser::parseBooleanLiteral( char *in, char *end, Value **boolean )
}
char *OpenDDLParser::parseIntegerLiteral(char *in, char *end, Value **integer, Value::ValueType integerType) {
*integer = ddl_nullptr;
if( ddl_nullptr == in || in == end ) {
*integer = nullptr;
if (nullptr == in || in == end) {
return in;
}
@ -685,35 +692,35 @@ char *OpenDDLParser::parseIntegerLiteral( char *in, char *end, Value **integer,
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 uint64 uvalue(strtoul(start, nullptr, 10));
#else
const int64 value(atoll(start));
const uint64 uvalue( strtoull( start,ddl_nullptr,10 ) );
const uint64 uvalue(strtoull(start, nullptr, 10));
#endif
*integer = ValueAllocator::allocPrimData(integerType);
switch (integerType) {
case Value::ddl_int8:
case Value::ValueType::ddl_int8:
(*integer)->setInt8((int8)value);
break;
case Value::ddl_int16:
case Value::ValueType::ddl_int16:
(*integer)->setInt16((int16)value);
break;
case Value::ddl_int32:
case Value::ValueType::ddl_int32:
(*integer)->setInt32((int32)value);
break;
case Value::ddl_int64:
case Value::ValueType::ddl_int64:
(*integer)->setInt64((int64)value);
break;
case Value::ddl_unsigned_int8:
case Value::ValueType::ddl_unsigned_int8:
(*integer)->setUnsignedInt8((uint8)uvalue);
break;
case Value::ddl_unsigned_int16:
case Value::ValueType::ddl_unsigned_int16:
(*integer)->setUnsignedInt16((uint16)uvalue);
break;
case Value::ddl_unsigned_int32:
case Value::ValueType::ddl_unsigned_int32:
(*integer)->setUnsignedInt32((uint32)uvalue);
break;
case Value::ddl_unsigned_int64:
case Value::ValueType::ddl_unsigned_int64:
(*integer)->setUnsignedInt64((uint64)uvalue);
break;
default:
@ -725,8 +732,8 @@ char *OpenDDLParser::parseIntegerLiteral( char *in, char *end, Value **integer,
}
char *OpenDDLParser::parseFloatingLiteral(char *in, char *end, Value **floating, Value::ValueType floatType) {
*floating = ddl_nullptr;
if( ddl_nullptr == in || in == end ) {
*floating = nullptr;
if (nullptr == in || in == end) {
return in;
}
@ -754,13 +761,13 @@ char *OpenDDLParser::parseFloatingLiteral( char *in, char *end, Value **floating
}
if (ok) {
if ( floatType == Value::ddl_double ) {
if (floatType == Value::ValueType::ddl_double) {
const double value(atof(start));
*floating = ValueAllocator::allocPrimData( Value::ddl_double );
*floating = ValueAllocator::allocPrimData(Value::ValueType::ddl_double);
(*floating)->setDouble(value);
} else {
const float value((float)atof(start));
*floating = ValueAllocator::allocPrimData( Value::ddl_float );
*floating = ValueAllocator::allocPrimData(Value::ValueType::ddl_float);
(*floating)->setFloat(value);
}
}
@ -769,8 +776,8 @@ char *OpenDDLParser::parseFloatingLiteral( char *in, char *end, Value **floating
}
char *OpenDDLParser::parseStringLiteral(char *in, char *end, Value **stringData) {
*stringData = ddl_nullptr;
if( ddl_nullptr == in || in == end ) {
*stringData = nullptr;
if (nullptr == in || in == end) {
return in;
}
@ -785,7 +792,7 @@ char *OpenDDLParser::parseStringLiteral( char *in, char *end, Value **stringData
++len;
}
*stringData = ValueAllocator::allocPrimData( Value::ddl_string, len );
*stringData = ValueAllocator::allocPrimData(Value::ValueType::ddl_string, len);
::strncpy((char *)(*stringData)->m_data, start, len);
(*stringData)->m_data[len] = '\0';
++in;
@ -795,15 +802,15 @@ char *OpenDDLParser::parseStringLiteral( char *in, char *end, Value **stringData
}
static void createPropertyWithData(Text *id, Value *primData, Property **prop) {
if( ddl_nullptr != primData ) {
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 ) {
*data = nullptr;
if (nullptr == in || in == end) {
return in;
}
@ -842,8 +849,8 @@ char *OpenDDLParser::parseHexaLiteral( char *in, char *end, Value **data ) {
++start;
}
*data = ValueAllocator::allocPrimData( Value::ddl_unsigned_int64 );
if( ddl_nullptr != *data ) {
*data = ValueAllocator::allocPrimData(Value::ValueType::ddl_unsigned_int64);
if (nullptr != *data) {
(*data)->setUnsignedInt64(value);
}
@ -851,20 +858,20 @@ char *OpenDDLParser::parseHexaLiteral( char *in, char *end, Value **data ) {
}
char *OpenDDLParser::parseProperty(char *in, char *end, Property **prop) {
*prop = ddl_nullptr;
if( ddl_nullptr == in || in == end ) {
*prop = nullptr;
if (nullptr == in || in == end) {
return in;
}
in = lookForNextToken(in, end);
Text *id( ddl_nullptr );
Text *id = nullptr;
in = parseIdentifier(in, end, &id);
if( ddl_nullptr != id ) {
if (nullptr != id) {
in = lookForNextToken(in, end);
if (*in == '=') {
++in;
in = getNextToken(in, end);
Value *primData( ddl_nullptr );
Value *primData(nullptr);
if (isInteger(in, end)) {
in = parseIntegerLiteral(in, end, &primData);
createPropertyWithData(id, primData, prop);
@ -893,20 +900,20 @@ char *OpenDDLParser::parseProperty( char *in, char *end, Property **prop ) {
char *OpenDDLParser::parseDataList(char *in, char *end, Value::ValueType type, Value **data,
size_t &numValues, Reference **refs, size_t &numRefs) {
*data = ddl_nullptr;
*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;
Value *current( ddl_nullptr ), *prev( ddl_nullptr );
Value *current(nullptr), *prev(nullptr);
while ('}' != *in) {
current = ddl_nullptr;
current = nullptr;
in = lookForNextToken(in, end);
if ( Value::ddl_ref == type ) {
if (Value::ValueType::ddl_ref == type) {
std::vector<Name *> names;
in = parseReference(in, end, names);
if (!names.empty()) {
@ -914,7 +921,7 @@ char *OpenDDLParser::parseDataList( char *in, char *end, Value::ValueType type,
*refs = ref;
numRefs = names.size();
}
} else if ( Value::ddl_none == type ) {
} else if (Value::ValueType::ddl_none == type) {
if (isInteger(in, end)) {
in = parseIntegerLiteral(in, end, &current);
} else if (isFloat(in, end)) {
@ -926,22 +933,22 @@ char *OpenDDLParser::parseDataList( char *in, char *end, Value::ValueType type,
}
} 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:
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, &current, type);
break;
case Value::ddl_half:
case Value::ddl_float:
case Value::ddl_double:
case Value::ValueType::ddl_half:
case Value::ValueType::ddl_float:
case Value::ValueType::ddl_double:
in = parseFloatingLiteral(in, end, &current, type);
break;
case Value::ddl_string:
case Value::ValueType::ddl_string:
in = parseStringLiteral(in, end, &current);
break;
default:
@ -949,8 +956,8 @@ char *OpenDDLParser::parseDataList( char *in, char *end, Value::ValueType type,
}
}
if( ddl_nullptr != current ) {
if( ddl_nullptr == *data ) {
if (nullptr != current) {
if (nullptr == *data) {
*data = current;
prev = current;
} else {
@ -984,33 +991,33 @@ static DataArrayList *createDataArrayList( Value *currentValue, size_t numValues
char *OpenDDLParser::parseDataArrayList(char *in, char *end, Value::ValueType type,
DataArrayList **dataArrayList) {
if ( ddl_nullptr == 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;
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;
currentValue = nullptr;
in = parseDataList(in, end, type, &currentValue, numValues, &refs, numRefs);
if( ddl_nullptr != currentValue || 0 != numRefs ) {
if( ddl_nullptr == prev ) {
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 ) {
if (nullptr != prev) {
prev->m_next = currentDataList;
prev = currentDataList;
}

24
contrib/openddlparser/code/OpenDDLStream.cpp
View File

@ -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,22 +60,22 @@ 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) {
if (nullptr == m_file) {
return 0;
}
@ -86,7 +86,7 @@ size_t IOStreamBase::read( size_t sizeToRead, std::string &statement ) {
}
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);

218
contrib/openddlparser/code/Value.cpp
View File

@ -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 <openddlparser/OpenDDLStream.h>
#include <openddlparser/Value.h>
#include <iostream>
#include <cassert>
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,15 +52,15 @@ 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;
return nullptr;
}
Value *v(m_current->getNext());
@ -70,7 +70,7 @@ Value *Value::Iterator::getNext() {
}
const Value::Iterator Value::Iterator::operator++(int) {
if( ddl_nullptr == m_current ) {
if (nullptr == m_current) {
return end;
}
@ -81,7 +81,7 @@ const Value::Iterator Value::Iterator::operator++( int ) {
}
Value::Iterator &Value::Iterator::operator++() {
if( ddl_nullptr == m_current ) {
if (nullptr == m_current) {
return end;
}
@ -95,145 +95,144 @@ bool Value::Iterator::operator == ( const Iterator &rhs ) const {
}
Value *Value::Iterator::operator->() const {
if(ddl_nullptr == m_current ) {
return ddl_nullptr;
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 ) {
if (m_data != nullptr) {
if (m_type == ValueType::ddl_ref) {
Reference *tmp = (Reference *)m_data;
if (tmp != ddl_nullptr)
if (tmp != nullptr)
delete tmp;
} 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 );
assert(ValueType::ddl_bool == m_type);
::memcpy(m_data, &value, m_size);
}
bool Value::getBool() {
assert( ddl_bool == m_type );
assert(ValueType::ddl_bool == m_type);
return (*m_data == 1);
}
void Value::setInt8(int8 value) {
assert( ddl_int8 == m_type );
assert(ValueType::ddl_int8 == m_type);
::memcpy(m_data, &value, m_size);
}
int8 Value::getInt8() {
assert( ddl_int8 == m_type );
assert(ValueType::ddl_int8 == m_type);
return (int8)(*m_data);
}
void Value::setInt16(int16 value) {
assert( ddl_int16 == m_type );
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);
return i;
}
void Value::setInt32(int32 value) {
assert( ddl_int32 == m_type );
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);
return i;
}
void Value::setInt64(int64 value) {
assert( ddl_int64 == m_type );
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);
return i;
}
void Value::setUnsignedInt8(uint8 value) {
assert( ddl_unsigned_int8 == m_type );
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);
return i;
}
void Value::setUnsignedInt16(uint16 value) {
assert( ddl_unsigned_int16 == m_type );
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);
return i;
}
void Value::setUnsignedInt32(uint32 value) {
assert( ddl_unsigned_int32 == m_type );
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);
return i;
}
void Value::setUnsignedInt64(uint64 value) {
assert( ddl_unsigned_int64 == m_type );
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);
return i;
}
void Value::setFloat(float value) {
assert( ddl_float == m_type );
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;
@ -245,17 +244,16 @@ float Value::getFloat() const {
}
void Value::setDouble(double value) {
assert( ddl_double == m_type );
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 {
} else {
double tmp;
::memcpy(&tmp, m_data, 4);
return (double)tmp;
@ -263,23 +261,23 @@ double Value::getDouble() const {
}
void Value::setString(const std::string &str) {
assert( ddl_string == m_type );
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 );
assert(ValueType::ddl_string == m_type);
return (const char *)m_data;
}
void Value::setRef(Reference *ref) {
assert( ddl_ref == m_type );
assert(ValueType::ddl_ref == m_type);
if ( ddl_nullptr != ref ) {
if (nullptr != ref) {
const size_t sizeInBytes(ref->sizeInBytes());
if (sizeInBytes > 0) {
if ( ddl_nullptr != m_data ) {
if (nullptr != m_data) {
delete[] m_data;
}
@ -289,57 +287,57 @@ void Value::setRef( Reference *ref ) {
}
Reference *Value::getRef() const {
assert( ddl_ref == m_type );
assert(ValueType::ddl_ref == m_type);
return (Reference *)m_data;
}
void Value::dump( IOStreamBase &/*stream*/ ) {
void Value::dump(IOStreamBase &stream) {
switch (m_type) {
case ddl_none:
std::cout << "None" << std::endl;
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;
@ -357,7 +355,7 @@ Value *Value::getNext() const {
size_t Value::size() const {
size_t result = 1;
Value *n = m_next;
while( n!=ddl_nullptr) {
while (n != nullptr) {
result++;
n = n->m_next;
}
@ -365,56 +363,56 @@ size_t Value::size() const{
}
Value *ValueAllocator::allocPrimData(Value::ValueType type, size_t len) {
if( type == Value::ddl_none || Value::ddl_types_max == type ) {
return ddl_nullptr;
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:
case Value::ValueType::ddl_bool:
data->m_size = sizeof(bool);
break;
case Value::ddl_int8:
case Value::ValueType::ddl_int8:
data->m_size = sizeof(int8);
break;
case Value::ddl_int16:
case Value::ValueType::ddl_int16:
data->m_size = sizeof(int16);
break;
case Value::ddl_int32:
case Value::ValueType::ddl_int32:
data->m_size = sizeof(int32);
break;
case Value::ddl_int64:
case Value::ValueType::ddl_int64:
data->m_size = sizeof(int64);
break;
case Value::ddl_unsigned_int8:
case Value::ValueType::ddl_unsigned_int8:
data->m_size = sizeof(uint8);
break;
case Value::ddl_unsigned_int16:
case Value::ValueType::ddl_unsigned_int16:
data->m_size = sizeof(uint16);
break;
case Value::ddl_unsigned_int32:
case Value::ValueType::ddl_unsigned_int32:
data->m_size = sizeof(uint32);
break;
case Value::ddl_unsigned_int64:
case Value::ValueType::ddl_unsigned_int64:
data->m_size = sizeof(uint64);
break;
case Value::ddl_half:
case Value::ValueType::ddl_half:
data->m_size = sizeof(short);
break;
case Value::ddl_float:
case Value::ValueType::ddl_float:
data->m_size = sizeof(float);
break;
case Value::ddl_double:
case Value::ValueType::ddl_double:
data->m_size = sizeof(double);
break;
case Value::ddl_string:
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;
}
@ -433,7 +431,7 @@ void ValueAllocator::releasePrimData( Value **data ) {
}
delete *data;
*data = ddl_nullptr;
*data = nullptr;
}
END_ODDLPARSER_NS

8
contrib/openddlparser/include/openddlparser/DDLNode.h
View File

@ -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 <openddlparser/OpenDDLCommon.h>
#include <vector>
#include <string>
#include <vector>
BEGIN_ODDLPARSER_NS
@ -148,10 +148,10 @@ 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;

25
contrib/openddlparser/include/openddlparser/OpenDDLCommon.h
View File

@ -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,8 +23,8 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#pragma once
#include <cstddef>
#include <vector>
#include <string>
#include <vector>
#include <stdio.h>
#include <string.h>
@ -56,13 +56,13 @@ BEGIN_ODDLPARSER_NS
// We will use C++11 optional
#ifndef OPENDDL_NO_USE_CPP11
// All C++11 constructs
# define ddl_nullptr nullptr
#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 nullptr NULL
#define ddl_override
#define ddl_final
#define ddl_no_copy
@ -88,14 +88,14 @@ 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.
///
@ -153,7 +153,6 @@ struct DLL_ODDLPARSER_EXPORT Name {
~Name();
private:
Name &operator=(const Name &) ddl_no_copy;
};

4
contrib/openddlparser/include/openddlparser/OpenDDLExport.h
View File

@ -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();

30
contrib/openddlparser/include/openddlparser/OpenDDLParser.h
View File

@ -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 <openddlparser/OpenDDLCommon.h>
#include <openddlparser/DDLNode.h>
#include <openddlparser/OpenDDLCommon.h>
#include <openddlparser/OpenDDLParserUtils.h>
#include <openddlparser/Value.h>
#include <vector>
#include <string>
#include <vector>
BEGIN_ODDLPARSER_NS
@ -40,12 +40,7 @@ struct Reference;
struct Property;
template <class T>
inline
bool isEmbeddedCommentOpenTag( T *in, T *end ) {
if ( in == end ) {
return false;
}
inline bool isEmbeddedCommentOpenTag(T *in, T *end) {
if (in == '/' && in + 1 == '*') {
return true;
}
@ -59,10 +54,9 @@ bool isEmbeddedCommentOpenTag( T *in, T *end ) {
/// @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 <class T>
inline
T *lookForNextToken( T *in, T *end ) {
inline T *lookForNextToken(T *in, T *end) {
while ((in != end) && (isSpace(*in) || isNewLine(*in) || ',' == *in)) {
in++;
++in;
}
return in;
}
@ -73,12 +67,11 @@ T *lookForNextToken( T *in, T *end ) {
/// @return Pointer showing to the next token or the end of the buffer.
/// @detail Will increase buffer by a minimum of one.
template <class T>
inline
T *getNextToken( T *in, T *end ) {
inline T *getNextToken(T *in, T *end) {
T *tmp(in);
in = lookForNextToken(in, end);
if (tmp == in) {
in++;
++in;
}
return in;
}
@ -147,11 +140,14 @@ 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);
/// @brief Returns the root node.
@ -176,8 +172,8 @@ public: // parser helpers
static char *parsePrimitiveDataType(char *in, char *end, Value::ValueType &type, size_t &len);
static char *parseReference(char *in, char *end, std::vector<Name *> &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 *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);

324
contrib/openddlparser/include/openddlparser/OpenDDLParserUtils.h
View File

@ -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
@ -27,53 +27,307 @@ CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
BEGIN_ODDLPARSER_NS
template <class T>
inline
bool isUpperCase( T in ) {
inline bool isUpperCase(T in) {
return (in >= 'A' && in <= 'Z');
}
template <class T>
inline
bool isLowerCase( T in ) {
inline bool isLowerCase(T in) {
return (in >= 'a' && in <= 'z');
}
template <class T>
inline
bool isSpace( const T in ) {
inline bool isSpace(const T in) {
return (' ' == in || '\t' == in);
}
template <class T>
inline
bool isNewLine( const T in ) {
inline bool isNewLine(const T in) {
return ('\n' == in || ('\r' == in));
}
template <class T>
inline
bool isSeparator( T in ) {
inline bool isSeparator(T in) {
if (isSpace(in) || ',' == in || '{' == in || '}' == in || '[' == in || '(' == in || ')' == in) {
return true;
}
return false;
}
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 <class T>
inline
bool isNumeric( const T in ) {
return ( in >= '0' && in <= '9' );
inline bool isNumeric(const T in) {
return (chartype_table[static_cast<size_t>(in)] == 1);
}
template <class T>
inline
bool isNotEndOfToken( T *in, T *end ) {
inline bool isNotEndOfToken(T *in, T *end) {
return ('}' != *in && ',' != *in && !isSpace(*in) && ')' != *in && in != end);
}
template <class T>
inline
bool isInteger( T *in, T *end ) {
inline bool isInteger(T *in, T *end) {
if (in != end) {
if (*in == '-') {
++in;
@ -93,8 +347,7 @@ bool isInteger( T *in, T *end ) {
}
template <class T>
inline
bool isFloat( T *in, T *end ) {
inline bool isFloat(T *in, T *end) {
if (in != end) {
if (*in == '-') {
++in;
@ -135,20 +388,17 @@ bool isFloat( T *in, T *end ) {
}
template <class T>
inline
bool isCharacter( const T in ) {
inline bool isCharacter(const T in) {
return ((in >= 'a' && in <= 'z') || (in >= 'A' && in <= 'Z'));
}
template <class T>
inline
bool isStringLiteral( const T in ) {
inline bool isStringLiteral(const T in) {
return (in == '\"');
}
template <class T>
inline
bool isHexLiteral( T *in, T *end ) {
inline bool isHexLiteral(T *in, T *end) {
if (*in == '0') {
if (in + 1 != end) {
if (*(in + 1) == 'x' || *(in + 1) == 'X') {
@ -161,8 +411,7 @@ bool isHexLiteral( T *in, T *end ) {
}
template <class T>
inline
bool isReference( T *in, T *end ) {
inline bool isReference(T *in, T *end) {
if (*in == 'r') {
if (*(in + 1) == 'e') {
if (*(in + 2) == 'f') {
@ -177,14 +426,12 @@ bool isReference( T *in, T *end ) {
}
template <class T>
inline
bool isEndofLine( const T in ) {
inline bool isEndofLine(const T in) {
return ('\n' == in);
}
template <class T>
inline
static T *getNextSeparator( T *in, T *end ) {
inline static T *getNextSeparator(T *in, T *end) {
while (!isSeparator(*in) || in == end) {
++in;
}
@ -193,8 +440,7 @@ static T *getNextSeparator( T *in, T *end ) {
static const int ErrorHex2Decimal = 9999999;
inline
int hex2Decimal( char in ) {
inline int hex2Decimal(char in) {
if (isNumeric(in)) {
return (in - 48);
}
@ -210,8 +456,7 @@ int hex2Decimal( char in ) {
}
template <class T>
inline
bool isComment( T *in, T *end ) {
inline bool isComment(T *in, T *end) {
if (*in == '/') {
if (in + 1 != end) {
if (*(in + 1) == '/') {
@ -229,8 +474,7 @@ bool isComment( T *in, T *end ) {
}
template <class T>
inline
bool isCommentOpenTag(T *in, T *end ) {
inline bool isCommentOpenTag(T *in, T *end) {
if (*in == '/') {
if (in + 1 != end) {
if (*(in + 1) == '*') {
@ -243,8 +487,7 @@ bool isCommentOpenTag(T *in, T *end ) {
}
template <class T>
inline
bool isCommentCloseTag(T *in, T *end) {
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

6
contrib/openddlparser/include/openddlparser/OpenDDLStream.h
View File

@ -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();

226
contrib/openddlparser/include/openddlparser/TPoolAllocator.h 100644
View File

@ -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 <openddlparser/OpenDDLCommon.h>
#include <string>
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 T>
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 <class T>
inline TPoolAllocator<T>::TPoolAllocator() :
m_first(nullptr), m_current(nullptr), m_freeList(nullptr), m_capacity(0L) {
// empty
}
template <class T>
inline TPoolAllocator<T>::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 <class T>
inline TPoolAllocator<T>::~TPoolAllocator() {
clear();
}
template <class T>
inline T *TPoolAllocator<T>::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 <class T>
inline void TPoolAllocator<T>::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 <class T>
inline void TPoolAllocator<T>::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 <class T>
inline void TPoolAllocator<T>::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 <class T>
inline size_t TPoolAllocator<T>::capacity() const {
return m_capacity;
}
template <class T>
inline size_t TPoolAllocator<T>::reservedMem() const {
return m_capacity * sizeof(T);
}
template <class T>
inline size_t TPoolAllocator<T>::freeMem() const {
if (nullptr == m_current) {
return 0L;
}
return (m_current->m_poolsize - m_current->m_currentIdx);
}
template <class T>
inline void TPoolAllocator<T>::dumpAllocations(std::string &allocs) {
allocs.clear();
allocs += "Number allocations = ";
allocs += std::to_string(m_current->m_currentIdx);
allocs += "\n";
}
template <class T>
inline void TPoolAllocator<T>::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

4
contrib/openddlparser/include/openddlparser/Value.h
View File

@ -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

2
test/unit/utOpenGEXImportExport.cpp
View File

@ -48,7 +48,7 @@ using namespace Assimp;
class utOpenGEXImportExport : public AbstractImportExportBase {
public:
virtual bool importerTest() {
bool importerTest() override {
Assimp::Importer importer;
const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/OpenGEX/Example.ogex", 0);
return nullptr != scene;