switch to tinyobj and nanovg from assimp and cairo

6 files changed, 0 insertions, 2357 deletions

diff --git a/libs/assimp/contrib/openddlparser/code/DDLNode.cpp b/libs/assimp/contrib/openddlparser/code/DDLNode.cpp
deleted file mode 100644
index 724c5d6..0000000
--- a/libs/assimp/contrib/openddlparser/code/DDLNode.cpp
+++ /dev/null
@@ -1,227 +0,0 @@
-/*-----------------------------------------------------------------------------------------------
-The MIT License (MIT)
-
-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
-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.
------------------------------------------------------------------------------------------------*/
-#include <openddlparser/DDLNode.h>
-#include <openddlparser/OpenDDLParser.h>
-#include <openddlparser/OpenDDLStream.h>
-
-#include <algorithm>
-
-BEGIN_ODDLPARSER_NS
-
-DDLNode::DllNodeList DDLNode::s_allocatedNodes;
-
-template <class T>
-inline static void releaseDataType(T *ptr) {
-    if (nullptr == ptr) {
-        return;
-    }
-
-    T *current(nullptr);
-    while (ptr) {
-        current = ptr;
-        ptr = ptr->m_next;
-        delete current;
-    }
-}
-
-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(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);
-
-    delete m_dtArrayList;
-    m_dtArrayList = nullptr;
-    if (s_allocatedNodes[m_idx] == this) {
-        s_allocatedNodes[m_idx] = nullptr;
-    }
-    for (size_t i = 0; i < m_children.size(); i++) {
-        delete m_children[i];
-    }
-}
-
-void DDLNode::attachParent(DDLNode *parent) {
-    if (m_parent == parent) {
-        return;
-    }
-
-    m_parent = parent;
-    if (nullptr != m_parent) {
-        m_parent->m_children.push_back(this);
-    }
-}
-
-void DDLNode::detachParent() {
-    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 = nullptr;
-    }
-}
-
-DDLNode *DDLNode::getParent() const {
-    return m_parent;
-}
-
-const DDLNode::DllNodeList &DDLNode::getChildNodeList() const {
-    return m_children;
-}
-
-void DDLNode::setType(const std::string &type) {
-    m_type = type;
-}
-
-const std::string &DDLNode::getType() const {
-    return m_type;
-}
-
-void DDLNode::setName(const std::string &name) {
-    m_name = name;
-}
-
-const std::string &DDLNode::getName() const {
-    return m_name;
-}
-
-void DDLNode::setProperties(Property *prop) {
-    if (m_properties != nullptr)
-        delete m_properties;
-    m_properties = prop;
-}
-
-Property *DDLNode::getProperties() const {
-    return m_properties;
-}
-
-bool DDLNode::hasProperty(const std::string &name) {
-    const Property *prop(findPropertyByName(name));
-    return (nullptr != prop);
-}
-
-bool DDLNode::hasProperties() const {
-    return (nullptr != m_properties);
-}
-
-Property *DDLNode::findPropertyByName(const std::string &name) {
-    if (name.empty()) {
-        return nullptr;
-    }
-
-    if (nullptr == m_properties) {
-        return nullptr;
-    }
-
-    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 nullptr;
-}
-
-void DDLNode::setValue(Value *val) {
-    m_value = val;
-}
-
-Value *DDLNode::getValue() const {
-    return m_value;
-}
-
-void DDLNode::setDataArrayList(DataArrayList *dtArrayList) {
-    m_dtArrayList = dtArrayList;
-}
-
-DataArrayList *DDLNode::getDataArrayList() const {
-    return m_dtArrayList;
-}
-
-void DDLNode::setReferences(Reference *refs) {
-    m_references = refs;
-}
-
-Reference *DDLNode::getReferences() const {
-    return m_references;
-}
-
-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);
-
-    return node;
-}
-
-void DDLNode::releaseNodes() {
-    if (s_allocatedNodes.size() > 0) {
-        for (DDLNodeIt it = s_allocatedNodes.begin(); it != s_allocatedNodes.end(); it++) {
-            if (*it) {
-                delete *it;
-            }
-        }
-        s_allocatedNodes.clear();
-    }
-}
-
-END_ODDLPARSER_NS
diff --git a/libs/assimp/contrib/openddlparser/code/OpenDDLCommon.cpp b/libs/assimp/contrib/openddlparser/code/OpenDDLCommon.cpp
deleted file mode 100644
index d853efa..0000000
--- a/libs/assimp/contrib/openddlparser/code/OpenDDLCommon.cpp
+++ /dev/null
@@ -1,200 +0,0 @@
-/*-----------------------------------------------------------------------------------------------
-The MIT License (MIT)
-
-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
-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.
------------------------------------------------------------------------------------------------*/
-#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(nullptr) {
-    set(buffer, numChars);
-}
-
-Text::~Text() {
-    clear();
-}
-
-void Text::clear() {
-    delete[] m_buffer;
-    m_buffer = nullptr;
-    m_capacity = 0;
-    m_len = 0;
-}
-
-void Text::set(const char *buffer, size_t numChars) {
-    clear();
-    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';
-    }
-}
-
-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()));
-
-    return (0 == res);
-}
-
-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));
-
-    return (0 == res);
-}
-
-Name::Name(NameType type, Text *id) :
-        m_type(type), m_id(id) {
-    // empty
-}
-
-Name::~Name() {
-    delete m_id;
-    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);
-}
-
-Reference::Reference() :
-        m_numRefs(0), m_referencedName(nullptr) {
-    // empty
-}
-
-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_referencedName[i] = new Name(*ref.m_referencedName[i]);
-        }
-    }
-}
-
-Reference::~Reference() {
-    for (size_t i = 0; i < m_numRefs; i++) {
-        delete m_referencedName[i];
-    }
-    m_numRefs = 0;
-    delete[] m_referencedName;
-    m_referencedName = nullptr;
-}
-
-size_t Reference::sizeInBytes() {
-    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 (nullptr != name) {
-            size += name->m_id->m_len;
-        }
-    }
-
-    return size;
-}
-
-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 != nullptr)
-        delete m_value;
-    if (m_ref != nullptr)
-        delete (m_ref);
-    if (m_next != nullptr)
-        delete m_next;
-}
-
-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 != nullptr)
-        delete m_next;
-    if (m_refs != nullptr)
-        delete m_refs;
-}
-
-size_t DataArrayList::size() {
-    size_t result(0);
-    if (nullptr == m_next) {
-        if (m_dataList != nullptr) {
-            result = 1;
-        }
-        return result;
-    }
-
-    DataArrayList *n(m_next);
-    while (nullptr != n) {
-        result++;
-        n = n->m_next;
-    }
-    return result;
-}
-
-Context::Context() :
-        m_root(nullptr) {
-    // empty
-}
-
-Context::~Context() {
-    clear();
-}
-
-void Context::clear() {
-    delete m_root;
-    m_root = nullptr;
-}
-
-END_ODDLPARSER_NS
diff --git a/libs/assimp/contrib/openddlparser/code/OpenDDLExport.cpp b/libs/assimp/contrib/openddlparser/code/OpenDDLExport.cpp
deleted file mode 100644
index d235b55..0000000
--- a/libs/assimp/contrib/openddlparser/code/OpenDDLExport.cpp
+++ /dev/null
@@ -1,361 +0,0 @@
-/*-----------------------------------------------------------------------------------------------
-The MIT License (MIT)
-
-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
-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.
------------------------------------------------------------------------------------------------*/
-#include <openddlparser/DDLNode.h>
-#include <openddlparser/OpenDDLExport.h>
-#include <openddlparser/OpenDDLParser.h>
-#include <openddlparser/Value.h>
-
-#include <sstream>
-
-BEGIN_ODDLPARSER_NS
-
-struct DDLNodeIterator {
-    const DDLNode::DllNodeList &m_childs;
-    size_t m_idx;
-
-    DDLNodeIterator(const DDLNode::DllNodeList &childs) :
-            m_childs(childs), m_idx(0) {
-        // empty
-    }
-
-    ~DDLNodeIterator() {
-        // empty
-    }
-
-    bool getNext(DDLNode **node) {
-        if (m_childs.size() > (m_idx + 1)) {
-            m_idx++;
-            *node = m_childs[m_idx];
-            return true;
-        }
-
-        return false;
-    }
-
-private:
-    DDLNodeIterator() ddl_no_copy;
-    DDLNodeIterator &operator=(const DDLNodeIterator &) ddl_no_copy;
-};
-
-static void writeLineEnd(std::string &statement) {
-    statement += "\n";
-}
-
-OpenDDLExport::OpenDDLExport(IOStreamBase *stream) :
-        m_stream(stream) {
-    if (nullptr == m_stream) {
-        m_stream = new IOStreamBase();
-    }
-}
-
-OpenDDLExport::~OpenDDLExport() {
-    if (nullptr != m_stream) {
-        m_stream->close();
-    }
-    delete m_stream;
-}
-
-bool OpenDDLExport::exportContext(Context *ctx, const std::string &filename) {
-    if (nullptr == ctx) {
-        return false;
-    }
-
-    DDLNode *root(ctx->m_root);
-    if (nullptr == root) {
-        return true;
-    }
-
-    if (!filename.empty()) {
-        if (!m_stream->open(filename)) {
-            return false;
-        }
-    }
-
-    const bool retValue(handleNode(root));
-
-    return retValue;
-}
-
-bool OpenDDLExport::handleNode(DDLNode *node) {
-    if (nullptr == node) {
-        return true;
-    }
-
-    const DDLNode::DllNodeList &childs = node->getChildNodeList();
-    if (childs.empty()) {
-        return true;
-    }
-    DDLNode *current(nullptr);
-    DDLNodeIterator it(childs);
-    std::string statement;
-    bool success(true);
-    while (it.getNext(&current)) {
-        if (nullptr != current) {
-            success |= writeNode(current, statement);
-            if (!handleNode(current)) {
-                success = false;
-            }
-        }
-    }
-
-    return success;
-}
-
-bool OpenDDLExport::writeToStream(const std::string &statement) {
-    if (nullptr == m_stream) {
-        return false;
-    }
-
-    if (!statement.empty()) {
-        m_stream->write(statement);
-    }
-
-    return true;
-}
-
-bool OpenDDLExport::writeNode(DDLNode *node, std::string &statement) {
-    writeNodeHeader(node, statement);
-    if (node->hasProperties()) {
-        writeProperties(node, statement);
-    }
-    writeLineEnd(statement);
-
-    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 (nullptr != v) {
-        writeValueType(v->m_type, 1, statement);
-        statement = "{";
-        writeLineEnd(statement);
-        writeValue(v, statement);
-        statement = "}";
-        writeLineEnd(statement);
-    }
-    statement = "}";
-    writeLineEnd(statement);
-
-    writeToStream(statement);
-
-    return true;
-}
-
-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()) {
-        statement += " ";
-        statement += "$";
-        statement += name;
-    }
-
-    return true;
-}
-
-bool OpenDDLExport::writeProperties(DDLNode *node, std::string &statement) {
-    if (nullptr == node) {
-        return false;
-    }
-
-    Property *prop(node->getProperties());
-    // if no properties are there, return
-    if (nullptr == prop) {
-        return true;
-    }
-
-    if (nullptr != prop) {
-        // for instance (attrib = "position", bla=2)
-        statement += "(";
-        bool first(true);
-        while (nullptr != prop) {
-            if (!first) {
-                statement += ", ";
-            } else {
-                first = false;
-            }
-            statement += std::string(prop->m_key->m_buffer);
-            statement += " = ";
-            writeValue(prop->m_value, statement);
-            prop = prop->m_next;
-        }
-
-        statement += ")";
-    }
-
-    return true;
-}
-
-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));
-    statement += typeStr;
-    // if we have an array to write
-    if (numItems > 1) {
-        statement += "[";
-        char buffer[256];
-        ::memset(buffer, '\0', 256 * sizeof(char));
-        sprintf(buffer, "%d", static_cast<int>(numItems));
-        statement += buffer;
-        statement += "]";
-    }
-
-    return true;
-}
-
-bool OpenDDLExport::writeValue(Value *val, std::string &statement) {
-    if (nullptr == val) {
-        return false;
-    }
-
-    switch (val->m_type) {
-        case Value::ValueType::ddl_bool:
-            if (true == val->getBool()) {
-                statement += "true";
-            } else {
-                statement += "false";
-            }
-            break;
-        case Value::ValueType::ddl_int8 : {
-            std::stringstream stream;
-            const int i = static_cast<int>(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<int>(val->getInt32());
-            sprintf(buffer, "%d", i);
-            statement += buffer;
-        } 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::ValueType::ddl_unsigned_int8: {
-            std::stringstream stream;
-            const int i = static_cast<unsigned int>(val->getUnsignedInt8());
-            stream << i;
-            statement += stream.str();
-        } 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::ValueType::ddl_unsigned_int32: {
-            std::stringstream stream;
-            const int i = static_cast<unsigned int>(val->getUnsignedInt32());
-            stream << i;
-            statement += stream.str();
-        } 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::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::ValueType::ddl_none:
-        case Value::ValueType::ddl_types_max:
-        default:
-            break;
-    }
-
-    return true;
-}
-
-bool OpenDDLExport::writeValueArray(DataArrayList *al, std::string &statement) {
-    if (nullptr == al) {
-        return false;
-    }
-
-    if (0 == al->m_numItems) {
-        return true;
-    }
-
-    DataArrayList *nextDataArrayList = al;
-    Value *nextValue(nextDataArrayList->m_dataList);
-    while (nullptr != nextDataArrayList) {
-        if (nullptr != nextDataArrayList) {
-            statement += "{ ";
-            nextValue = nextDataArrayList->m_dataList;
-            size_t idx(0);
-            while (nullptr != nextValue) {
-                if (idx > 0) {
-                    statement += ", ";
-                }
-                writeValue(nextValue, statement);
-                nextValue = nextValue->m_next;
-                idx++;
-            }
-            statement += " }";
-        }
-        nextDataArrayList = nextDataArrayList->m_next;
-    }
-
-    return true;
-}
-
-END_ODDLPARSER_NS
diff --git a/libs/assimp/contrib/openddlparser/code/OpenDDLParser.cpp b/libs/assimp/contrib/openddlparser/code/OpenDDLParser.cpp
deleted file mode 100644
index e2bef97..0000000
--- a/libs/assimp/contrib/openddlparser/code/OpenDDLParser.cpp
+++ /dev/null
@@ -1,1035 +0,0 @@
-/*-----------------------------------------------------------------------------------------------
-The MIT License (MIT)
-
-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
-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.
------------------------------------------------------------------------------------------------*/
-#include <openddlparser/OpenDDLExport.h>
-#include <openddlparser/OpenDDLParser.h>
-
-#include <math.h>
-#include <algorithm>
-#include <cassert>
-#include <iostream>
-#include <sstream>
-
-#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 = "(";
-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[(size_t)type];
-}
-
-static void logInvalidTokenError(char *in, const std::string &exp, OpenDDLParser::logCallback callback) {
-    if (callback) {
-        std::string full(in);
-        std::string part(full.substr(0, 50));
-        std::stringstream stream;
-        stream << "Invalid token \"" << *in << "\" "
-               << "(expected \"" << exp << "\") "
-               << "in: \"" << part << "\"";
-        callback(ddl_error_msg, stream.str());
-    }
-}
-
-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 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;
-    }
-
-    return true;
-}
-
-static DDLNode *createDDLNode(Text *id, OpenDDLParser *parser) {
-    if (nullptr == id || nullptr == parser || id->m_buffer == nullptr) {
-        return nullptr;
-    }
-
-    const std::string type(id->m_buffer);
-    DDLNode *parent(parser->top());
-    DDLNode *node = DDLNode::create(type, "", parent);
-
-    return node;
-}
-
-OpenDDLParser::OpenDDLParser() :
-        m_logCallback(nullptr),
-        m_buffer(),
-        m_stack(),
-        m_context(nullptr) {
-    // empty
-}
-
-OpenDDLParser::OpenDDLParser(const char *buffer, size_t len) :
-        m_logCallback(nullptr), m_buffer(), m_context(nullptr) {
-    if (0 != len) {
-        setBuffer(buffer, len);
-    }
-}
-
-OpenDDLParser::~OpenDDLParser() {
-    clear();
-}
-
-void OpenDDLParser::logToStream(FILE *f, LogSeverity severity, const std::string &message) {
-    if (f) {
-        const char *tag = "none";
-        switch (severity) {
-        case ddl_debug_msg: tag = "debug"; break;
-        case ddl_info_msg:  tag = "info";  break;
-        case ddl_warn_msg:  tag = "warn";  break;
-        case ddl_error_msg: tag = "error"; break;
-        }
-        fprintf(f, "OpenDDLParser: (%5s) %s\n", tag, message.c_str());
-    }
-}
-
-OpenDDLParser::logCallback OpenDDLParser::StdLogCallback (FILE *destination) {
-    using namespace std::placeholders;
-    return std::bind(logToStream, destination ? destination : stderr, _1, _2);
-}
-
-void OpenDDLParser::setLogCallback(logCallback callback) {
-    // install user-specific log callback; null = no log callback
-    m_logCallback = callback;
-}
-
-OpenDDLParser::logCallback OpenDDLParser::getLogCallback() const {
-    return m_logCallback;
-}
-
-void OpenDDLParser::setBuffer(const char *buffer, size_t len) {
-    clear();
-    if (0 == len) {
-        return;
-    }
-
-    m_buffer.resize(len);
-    ::memcpy(&m_buffer[0], buffer, len);
-}
-
-void OpenDDLParser::setBuffer(const std::vector<char> &buffer) {
-    clear();
-    m_buffer.resize(buffer.size());
-    std::copy(buffer.begin(), buffer.end(), m_buffer.begin());
-}
-
-const char *OpenDDLParser::getBuffer() const {
-    if (m_buffer.empty()) {
-        return nullptr;
-    }
-
-    return &m_buffer[0];
-}
-
-size_t OpenDDLParser::getBufferSize() const {
-    return m_buffer.size();
-}
-
-void OpenDDLParser::clear() {
-    m_buffer.resize(0);
-    delete m_context;
-    m_context = nullptr;
-}
-
-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", "", 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 == nullptr) {
-            return false;
-        }
-        pos = current - &m_buffer[0];
-    }
-    return true;
-}
-
-bool OpenDDLParser::exportContext(Context *ctx, const std::string &filename) {
-    if (nullptr == ctx) {
-        return false;
-    }
-
-    OpenDDLExport myExporter;
-    return myExporter.exportContext(ctx, filename);
-}
-
-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 (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 (nullptr == in || in == end) {
-        return in;
-    }
-
-    Text *id(nullptr);
-    in = OpenDDLParser::parseIdentifier(in, end, &id);
-
-#ifdef DEBUG_HEADER_NAME
-    dumpId(id);
-#endif // DEBUG_HEADER_NAME
-
-    in = lookForNextToken(in, end);
-    if (nullptr != id) {
-        // store the 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(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 != end && *in == Grammar::OpenPropertyToken[0]) {
-            in++;
-            Property *prop(nullptr), *prev(nullptr);
-            while (in != end && *in != Grammar::ClosePropertyToken[0]) {
-                in = OpenDDLParser::parseProperty(in, end, &prop);
-                in = lookForNextToken(in, end);
-                if(in == end) {
-                    break;
-                }
-
-                if (*in != Grammar::CommaSeparator[0] && *in != Grammar::ClosePropertyToken[0]) {
-                    logInvalidTokenError(in, Grammar::ClosePropertyToken, m_logCallback);
-                    return nullptr;
-                }
-
-                if (nullptr != prop && *in != Grammar::CommaSeparator[0]) {
-                    if (nullptr == first) {
-                        first = prop;
-                    }
-                    if (nullptr != prev) {
-                        prev->m_next = prop;
-                    }
-                    prev = prop;
-                }
-            }
-            if(in != end) {
-                ++in;
-            }
-        }
-
-        // set the properties
-        if (nullptr != first && nullptr != node) {
-            node->setProperties(first);
-        }
-    }
-
-    return in;
-}
-
-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) {
-        // loop over all children ( data and nodes )
-        do {
-            in = parseStructureBody(in, end, error);
-            if (in == nullptr) {
-                return nullptr;
-            }
-        } while (*in != *Grammar::CloseBracketToken);
-        ++in;
-    } else {
-        ++in;
-        logInvalidTokenError(in, std::string(Grammar::OpenBracketToken), m_logCallback);
-        error = true;
-        return nullptr;
-    }
-    in = lookForNextToken(in, end);
-
-    // pop node from stack after successful parsing
-    if (!error) {
-        popNode();
-    }
-
-    return in;
-}
-
-static void setNodeValues(DDLNode *currentNode, Value *values) {
-    if (nullptr != values) {
-        if (nullptr != currentNode) {
-            currentNode->setValue(values);
-        }
-    }
-}
-
-static void setNodeReferences(DDLNode *currentNode, Reference *refs) {
-    if (nullptr != refs) {
-        if (nullptr != currentNode) {
-            currentNode->setReferences(refs);
-        }
-    }
-}
-
-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)) {
-        ++in;
-    }
-
-    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(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 nullptr;
-        } else {
-            //in++;
-        }
-    } else {
-        // parse a complex data type
-        in = parseNextNode(in, end);
-    }
-
-    return in;
-}
-
-void OpenDDLParser::pushNode(DDLNode *node) {
-    if (nullptr == node) {
-        return;
-    }
-
-    m_stack.push_back(node);
-}
-
-DDLNode *OpenDDLParser::popNode() {
-    if (m_stack.empty()) {
-        return nullptr;
-    }
-
-    DDLNode *topNode(top());
-    m_stack.pop_back();
-    return topNode;
-}
-
-DDLNode *OpenDDLParser::top() {
-    if (m_stack.empty()) {
-        return nullptr;
-    }
-
-    DDLNode *top(m_stack.back());
-    return top;
-}
-
-DDLNode *OpenDDLParser::getRoot() const {
-    if (nullptr == m_context) {
-        return nullptr;
-    }
-
-    return m_context->m_root;
-}
-
-Context *OpenDDLParser::getContext() const {
-    return m_context;
-}
-
-void OpenDDLParser::normalizeBuffer(std::vector<char> &buffer) {
-    if (buffer.empty()) {
-        return;
-    }
-
-    std::vector<char> newBuffer;
-    const size_t len(buffer.size());
-    char *end(&buffer[len - 1] + 1);
-    for (size_t readIdx = 0; readIdx < len; ++readIdx) {
-        char *c(&buffer[readIdx]);
-        // check for a comment
-        if (isCommentOpenTag(c, end)) {
-            ++readIdx;
-            while (readIdx < len && !isCommentCloseTag(&buffer[readIdx], end)) {
-                ++readIdx;
-            }
-            ++readIdx;
-        } else if (!isComment<char>(c, end) && !isNewLine(*c)) {
-            newBuffer.push_back(buffer[readIdx]);
-        } else {
-            if (isComment<char>(c, end)) {
-                ++readIdx;
-                // skip the comment and the rest of the line
-                while (readIdx < len && !isEndofLine(buffer[readIdx])) {
-                    ++readIdx;
-                }
-            }
-        }
-    }
-    buffer = newBuffer;
-}
-
-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 != '%') {
-        return in;
-    }
-
-    NameType ntype(GlobalName);
-    if (*in == '%') {
-        ntype = LocalName;
-    }
-    in++;
-    Name *currentName(nullptr);
-    Text *id(nullptr);
-    in = parseIdentifier(in, end, &id);
-    if (id) {
-        currentName = new Name(ntype, id);
-        if (currentName) {
-            *name = currentName;
-        }
-    }
-
-    return in;
-}
-
-char *OpenDDLParser::parseIdentifier(char *in, char *end, Text **id) {
-    *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)) {
-        return in;
-    }
-
-    // get size of id
-    size_t idLen(0);
-    char *start(in);
-    while ((in != end) && !isSeparator(*in) && !isNewLine(*in) &&
-            *in != Grammar::OpenPropertyToken[0] &&
-            *in != Grammar::ClosePropertyToken[0] &&
-            *in != '$') {
-        ++in;
-        ++idLen;
-    }
-
-    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::ValueType::ddl_none;
-    len = 0;
-    if (nullptr == in || in == end) {
-        return in;
-    }
-
-    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<Value::ValueType>(i);
-            break;
-        }
-    }
-
-    if (Value::ValueType::ddl_none == type) {
-        in = lookForNextToken(in, end);
-        return in;
-    } else {
-        in += prim_len;
-    }
-
-    bool ok(true);
-    if (*in == Grammar::OpenArrayToken[0]) {
-        ok = false;
-        ++in;
-        char *start(in);
-        while (in != end) {
-            ++in;
-            if (*in == Grammar::CloseArrayToken[0]) {
-                len = ::atoi(start);
-                ok = true;
-                ++in;
-                break;
-            }
-        }
-    } else {
-        len = 1;
-    }
-    if (!ok) {
-        type = Value::ValueType::ddl_none;
-    }
-
-    return in;
-}
-
-char *OpenDDLParser::parseReference(char *in, char *end, std::vector<Name *> &names) {
-    if (nullptr == in || in == end) {
-        return in;
-    }
-
-    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);
-            }
-        } else {
-            break;
-        }
-    }
-
-    return in;
-}
-
-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;
-        ++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 = nullptr;
-            return in;
-        }
-        *boolean = ValueAllocator::allocPrimData(Value::ValueType::ddl_bool);
-        (*boolean)->setBool(false);
-    } else {
-        *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 = nullptr;
-    if (nullptr == in || in == end) {
-        return in;
-    }
-
-    if (!(isIntegerType(integerType) || isUnsignedIntegerType(integerType))) {
-        return in;
-    }
-
-    in = lookForNextToken(in, end);
-    char *start(in);
-    while (!isSeparator(*in) && in != end) {
-        ++in;
-    }
-
-    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, nullptr, 10));
-#else
-        const int64 value(atoll(start));
-        const uint64 uvalue(strtoull(start, nullptr, 10));
-#endif
-        *integer = ValueAllocator::allocPrimData(integerType);
-        switch (integerType) {
-            case Value::ValueType::ddl_int8:
-                (*integer)->setInt8((int8)value);
-                break;
-            case Value::ValueType::ddl_int16:
-                (*integer)->setInt16((int16)value);
-                break;
-            case Value::ValueType::ddl_int32:
-                (*integer)->setInt32((int32)value);
-                break;
-            case Value::ValueType::ddl_int64:
-                (*integer)->setInt64((int64)value);
-                break;
-            case Value::ValueType::ddl_unsigned_int8:
-                (*integer)->setUnsignedInt8((uint8)uvalue);
-                break;
-            case Value::ValueType::ddl_unsigned_int16:
-                (*integer)->setUnsignedInt16((uint16)uvalue);
-                break;
-            case Value::ValueType::ddl_unsigned_int32:
-                (*integer)->setUnsignedInt32((uint32)uvalue);
-                break;
-            case Value::ValueType::ddl_unsigned_int64:
-                (*integer)->setUnsignedInt64((uint64)uvalue);
-                break;
-            default:
-                break;
-        }
-    }
-
-    return in;
-}
-
-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;
-    }
-
-    // parse the float value
-    bool ok(false);
-    if (isHexLiteral(start, end)) {
-        parseHexaLiteral(start, end, floating);
-        return in;
-    }
-
-    if (isNumeric(*start)) {
-        ok = true;
-    } else {
-        if (*start == '-') {
-            if (isNumeric(*(start + 1))) {
-                ok = true;
-            }
-        }
-    }
-
-    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::ValueType::ddl_float);
-            (*floating)->setFloat(value);
-        }
-    }
-
-    return in;
-}
-
-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 == '\"') {
-        ++start;
-        ++in;
-        while (*in != '\"' && in != end) {
-            ++in;
-            ++len;
-        }
-
-        *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 (nullptr != primData) {
-        (*prop) = new Property(id);
-        (*prop)->m_value = primData;
-    }
-}
-
-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') {
-        return in;
-    }
-
-    ++in;
-    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')) {
-            ok = false;
-            break;
-        }
-        ++pos;
-        ++in;
-    }
-
-    if (!ok) {
-        return in;
-    }
-
-    int value(0);
-    while (pos > 0) {
-        int v = hex2Decimal(*start);
-        --pos;
-        value = (value << 4) | v;
-        ++start;
-    }
-
-    *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 = nullptr;
-    if (nullptr == in || in == end) {
-        return in;
-    }
-
-    in = lookForNextToken(in, end);
-    Text *id = nullptr;
-    in = parseIdentifier(in, end, &id);
-    if (nullptr != id) {
-        in = lookForNextToken(in, end);
-        if (in != end && *in == '=') {
-            ++in;
-            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<Name *> 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 {
-            delete id;
-        }
-    }
-
-    return in;
-}
-
-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 (nullptr == in || in == end) {
-        return in;
-    }
-
-    in = lookForNextToken(in, end);
-    if (*in == '{') {
-        ++in;
-        Value *current(nullptr), *prev(nullptr);
-        while ('}' != *in) {
-            current = nullptr;
-            in = lookForNextToken(in, end);
-            if (Value::ValueType::ddl_ref == type) {
-                std::vector<Name *> 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::ValueType::ddl_none == type) {
-                if (isInteger(in, end)) {
-                    in = parseIntegerLiteral(in, end, &current);
-                } else if (isFloat(in, end)) {
-                    in = parseFloatingLiteral(in, end, &current);
-                } else if (isStringLiteral(*in)) {
-                    in = parseStringLiteral(in, end, &current);
-                } else if (isHexLiteral(in, end)) {
-                    in = parseHexaLiteral(in, end, &current);
-                }
-            } else {
-                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, &current, type);
-                        break;
-                    case Value::ValueType::ddl_half:
-                    case Value::ValueType::ddl_float:
-                    case Value::ValueType::ddl_double:
-                        in = parseFloatingLiteral(in, end, &current, type);
-                        break;
-                    case Value::ValueType::ddl_string:
-                        in = parseStringLiteral(in, end, &current);
-                        break;
-                    default:
-                        break;
-                }
-            }
-
-            if (nullptr != current) {
-                if (nullptr == *data) {
-                    *data = current;
-                    prev = current;
-                } else {
-                    prev->setNext(current);
-                    prev = current;
-                }
-                ++numValues;
-            }
-
-            in = getNextSeparator(in, end);
-            if (',' != *in && Grammar::CloseBracketToken[0] != *in && !isSpace(*in)) {
-                break;
-            }
-        }
-        ++in;
-    }
-
-    return in;
-}
-
-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;
-
-    return dataList;
-}
-
-char *OpenDDLParser::parseDataArrayList(char *in, char *end, Value::ValueType type,
-        DataArrayList **dataArrayList) {
-    if (nullptr == dataArrayList) {
-        return in;
-    }
-
-    *dataArrayList = nullptr;
-    if (nullptr == in || in == end) {
-        return in;
-    }
-
-    in = lookForNextToken(in, end);
-    if (*in == Grammar::OpenBracketToken[0]) {
-        ++in;
-        Value *currentValue(nullptr);
-        Reference *refs(nullptr);
-        DataArrayList *prev(nullptr), *currentDataList(nullptr);
-        do {
-            size_t numRefs(0), numValues(0);
-            currentValue = nullptr;
-
-            in = parseDataList(in, end, type, &currentValue, 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 (nullptr != prev) {
-                        prev->m_next = currentDataList;
-                        prev = currentDataList;
-                    }
-                }
-            }
-        } while (Grammar::CommaSeparator[0] == *in && in != end);
-        in = lookForNextToken(in, end);
-        ++in;
-    }
-
-    return in;
-}
-
-const char *OpenDDLParser::getVersion() {
-    return Version;
-}
-
-END_ODDLPARSER_NS
diff --git a/libs/assimp/contrib/openddlparser/code/OpenDDLStream.cpp b/libs/assimp/contrib/openddlparser/code/OpenDDLStream.cpp
deleted file mode 100644
index 1a38dfa..0000000
--- a/libs/assimp/contrib/openddlparser/code/OpenDDLStream.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-/*-----------------------------------------------------------------------------------------------
-The MIT License (MIT)
-
-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
-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.
------------------------------------------------------------------------------------------------*/
-#include <openddlparser/OpenDDLStream.h>
-
-BEGIN_ODDLPARSER_NS
-
-StreamFormatterBase::StreamFormatterBase() {
-    // empty
-}
-
-StreamFormatterBase::~StreamFormatterBase() {
-    // empty
-}
-
-std::string StreamFormatterBase::format(const std::string &statement) {
-    std::string tmp(statement);
-    return tmp;
-}
-
-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 = nullptr;
-}
-
-bool IOStreamBase::open(const std::string &name) {
-    m_file = ::fopen(name.c_str(), "a");
-    if (m_file == nullptr) {
-        return false;
-    }
-
-    return true;
-}
-
-bool IOStreamBase::close() {
-    if (nullptr == m_file) {
-        return false;
-    }
-
-    ::fclose(m_file);
-    m_file = nullptr;
-
-    return true;
-}
-
-bool IOStreamBase::isOpen() const {
-    return (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);
-
-    return readBytes;
-}
-
-size_t IOStreamBase::write(const std::string &statement) {
-    if (nullptr == m_file) {
-        return 0;
-    }
-    std::string formatStatement = m_formatter->format(statement);
-    return ::fwrite(formatStatement.c_str(), sizeof(char), formatStatement.size(), m_file);
-}
-
-END_ODDLPARSER_NS
diff --git a/libs/assimp/contrib/openddlparser/code/Value.cpp b/libs/assimp/contrib/openddlparser/code/Value.cpp
deleted file mode 100644
index 5a8aa39..0000000
--- a/libs/assimp/contrib/openddlparser/code/Value.cpp
+++ /dev/null
@@ -1,438 +0,0 @@
-/*-----------------------------------------------------------------------------------------------
-The MIT License (MIT)
-
-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
-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.
------------------------------------------------------------------------------------------------*/
-#include <openddlparser/OpenDDLStream.h>
-#include <openddlparser/Value.h>
-
-#include <cassert>
-
-BEGIN_ODDLPARSER_NS
-
-static Value::Iterator end(nullptr);
-
-Value::Iterator::Iterator() :
-        m_start(nullptr),
-        m_current(nullptr) {
-    // empty
-}
-
-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) {
-    // empty
-}
-
-Value::Iterator::~Iterator() {
-    // empty
-}
-
-bool Value::Iterator::hasNext() const {
-    if (nullptr == m_current) {
-        return false;
-    }
-    return (nullptr != m_current->getNext());
-}
-
-Value *Value::Iterator::getNext() {
-    if (!hasNext()) {
-        return nullptr;
-    }
-
-    Value *v(m_current->getNext());
-    m_current = v;
-
-    return v;
-}
-
-const Value::Iterator Value::Iterator::operator++(int) {
-    if (nullptr == m_current) {
-        return end;
-    }
-
-    m_current = m_current->getNext();
-    Iterator inst(m_current);
-
-    return inst;
-}
-
-Value::Iterator &Value::Iterator::operator++() {
-    if (nullptr == m_current) {
-        return end;
-    }
-
-    m_current = m_current->getNext();
-
-    return *this;
-}
-
-bool Value::Iterator::operator==(const Iterator &rhs) const {
-    return (m_current == rhs.m_current);
-}
-
-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(nullptr),
-        m_next(nullptr) {
-    // empty
-}
-
-Value::~Value() {
-    if (m_data != nullptr) {
-        if (m_type == ValueType::ddl_ref) {
-            Reference *tmp = (Reference *)m_data;
-            if (tmp != nullptr) {
-                delete tmp;
-            }
-        } else {
-            delete[] m_data;
-        }
-    }
-    delete m_next;
-}
-
-void Value::setBool(bool value) {
-    assert(ValueType::ddl_bool == m_type);
-    ::memcpy(m_data, &value, m_size);
-}
-
-bool Value::getBool() {
-    assert(ValueType::ddl_bool == m_type);
-    return (*m_data == 1);
-}
-
-void Value::setInt8(int8 value) {
-    assert(ValueType::ddl_int8 == m_type);
-    ::memcpy(m_data, &value, m_size);
-}
-
-int8 Value::getInt8() {
-    assert(ValueType::ddl_int8 == m_type);
-    return (int8)(*m_data);
-}
-
-void Value::setInt16(int16 value) {
-    assert(ValueType::ddl_int16 == m_type);
-    ::memcpy(m_data, &value, m_size);
-}
-
-int16 Value::getInt16() {
-    assert(ValueType::ddl_int16 == m_type);
-    int16 i;
-    ::memcpy(&i, m_data, m_size);
-    return i;
-}
-
-void Value::setInt32(int32 value) {
-    assert(ValueType::ddl_int32 == m_type);
-    ::memcpy(m_data, &value, m_size);
-}
-
-int32 Value::getInt32() {
-    assert(ValueType::ddl_int32 == m_type);
-    int32 i;
-    ::memcpy(&i, m_data, m_size);
-    return i;
-}
-
-void Value::setInt64(int64 value) {
-    assert(ValueType::ddl_int64 == m_type);
-    ::memcpy(m_data, &value, m_size);
-}
-
-int64 Value::getInt64() {
-    assert(ValueType::ddl_int64 == m_type);
-    int64 i;
-    ::memcpy(&i, m_data, m_size);
-    return i;
-}
-
-void Value::setUnsignedInt8(uint8 value) {
-    assert(ValueType::ddl_unsigned_int8 == m_type);
-    ::memcpy(m_data, &value, m_size);
-}
-
-uint8 Value::getUnsignedInt8() const {
-    assert(ValueType::ddl_unsigned_int8 == m_type);
-    uint8 i;
-    ::memcpy(&i, m_data, m_size);
-    return i;
-}
-
-void Value::setUnsignedInt16(uint16 value) {
-    assert(ValueType::ddl_unsigned_int16 == m_type);
-    ::memcpy(m_data, &value, m_size);
-}
-
-uint16 Value::getUnsignedInt16() const {
-    assert(ValueType::ddl_unsigned_int16 == m_type);
-    uint16 i;
-    ::memcpy(&i, m_data, m_size);
-    return i;
-}
-
-void Value::setUnsignedInt32(uint32 value) {
-    assert(ValueType::ddl_unsigned_int32 == m_type);
-    ::memcpy(m_data, &value, m_size);
-}
-
-uint32 Value::getUnsignedInt32() const {
-    assert(ValueType::ddl_unsigned_int32 == m_type);
-    uint32 i;
-    ::memcpy(&i, m_data, m_size);
-    return i;
-}
-
-void Value::setUnsignedInt64(uint64 value) {
-    assert(ValueType::ddl_unsigned_int64 == m_type);
-    ::memcpy(m_data, &value, m_size);
-}
-
-uint64 Value::getUnsignedInt64() const {
-    assert(ValueType::ddl_unsigned_int64 == m_type);
-    uint64 i;
-    ::memcpy(&i, m_data, m_size);
-    return i;
-}
-
-void Value::setFloat(float value) {
-    assert(ValueType::ddl_float == m_type);
-    ::memcpy(m_data, &value, m_size);
-}
-
-float Value::getFloat() const {
-    if (m_type == ValueType::ddl_float) {
-        float v;
-        ::memcpy(&v, m_data, m_size);
-        return (float)v;
-    } else {
-        float tmp;
-        ::memcpy(&tmp, m_data, 4);
-        return (float)tmp;
-    }
-}
-
-void Value::setDouble(double value) {
-    assert(ValueType::ddl_double == m_type);
-    ::memcpy(m_data, &value, m_size);
-}
-
-double Value::getDouble() const {
-    if (m_type == ValueType::ddl_double) {
-        double v;
-        ::memcpy(&v, m_data, m_size);
-        return (float)v;
-    } else {
-        double tmp;
-        ::memcpy(&tmp, m_data, 4);
-        return (double)tmp;
-    }
-}
-
-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(ValueType::ddl_string == m_type);
-    return (const char *)m_data;
-}
-
-void Value::setRef(Reference *ref) {
-    assert(ValueType::ddl_ref == m_type);
-
-    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);
-        }
-    }
-}
-
-Reference *Value::getRef() const {
-    assert(ValueType::ddl_ref == m_type);
-
-    return (Reference *)m_data;
-}
-
-void Value::dump(IOStreamBase &stream) {
-    switch (m_type) {
-        case ValueType::ddl_none:
-            stream.write("None\n");
-            break;
-        case ValueType::ddl_bool:
-            stream.write(std::to_string(getBool()) + "\n");
-            break;
-        case ValueType::ddl_int8:
-            stream.write(std::to_string(getInt8()) + "\n");
-            break;
-        case ValueType::ddl_int16:
-            stream.write(std::to_string(getInt16()) + "\n");
-            break;
-        case ValueType::ddl_int32:
-            stream.write(std::to_string(getInt32()) + "\n");
-            break;
-        case ValueType::ddl_int64:
-            stream.write(std::to_string(getInt64()) + "\n");
-            break;
-        case ValueType::ddl_unsigned_int8:
-            stream.write("Not supported\n");
-            break;
-        case ValueType::ddl_unsigned_int16:
-            stream.write("Not supported\n");
-            break;
-        case ValueType::ddl_unsigned_int32:
-            stream.write("Not supported\n");
-            break;
-        case ValueType::ddl_unsigned_int64:
-            stream.write("Not supported\n");
-            break;
-        case ValueType::ddl_half:
-            stream.write("Not supported\n");
-            break;
-        case ValueType::ddl_float:
-            stream.write(std::to_string(getFloat()) + "\n");
-            break;
-        case ValueType::ddl_double:
-            stream.write(std::to_string(getDouble()) + "\n");
-            break;
-        case ValueType::ddl_string:
-            stream.write(std::string(getString()) + "\n");
-            break;
-        case ValueType::ddl_ref:
-            stream.write("Not supported\n");
-            break;
-        default:
-            break;
-    }
-}
-
-void Value::setNext(Value *next) {
-    m_next = next;
-}
-
-Value *Value::getNext() const {
-    return m_next;
-}
-
-size_t Value::size() const {
-    size_t result = 1;
-    Value *n = m_next;
-    while (n != nullptr) {
-        result++;
-        n = n->m_next;
-    }
-    return result;
-}
-
-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::ValueType::ddl_bool:
-            data->m_size = sizeof(bool);
-            break;
-        case Value::ValueType::ddl_int8:
-            data->m_size = sizeof(int8);
-            break;
-        case Value::ValueType::ddl_int16:
-            data->m_size = sizeof(int16);
-            break;
-        case Value::ValueType::ddl_int32:
-            data->m_size = sizeof(int32);
-            break;
-        case Value::ValueType::ddl_int64:
-            data->m_size = sizeof(int64);
-            break;
-        case Value::ValueType::ddl_unsigned_int8:
-            data->m_size = sizeof(uint8);
-            break;
-        case Value::ValueType::ddl_unsigned_int16:
-            data->m_size = sizeof(uint16);
-            break;
-        case Value::ValueType::ddl_unsigned_int32:
-            data->m_size = sizeof(uint32);
-            break;
-        case Value::ValueType::ddl_unsigned_int64:
-            data->m_size = sizeof(uint64);
-            break;
-        case Value::ValueType::ddl_half:
-            data->m_size = sizeof(short);
-            break;
-        case Value::ValueType::ddl_float:
-            data->m_size = sizeof(float);
-            break;
-        case Value::ValueType::ddl_double:
-            data->m_size = sizeof(double);
-            break;
-        case Value::ValueType::ddl_string:
-            data->m_size = sizeof(char) * (len + 1);
-            break;
-        case Value::ValueType::ddl_ref:
-            data->m_size = 0;
-            break;
-        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);
-    }
-
-    return data;
-}
-
-void ValueAllocator::releasePrimData(Value **data) {
-    if (!data) {
-        return;
-    }
-
-    delete *data;
-    *data = nullptr;
-}
-
-END_ODDLPARSER_NS