Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

20 files changed, 6987 insertions, 0 deletions

diff --git a/cppu/source/uno/EnvDcp.cxx b/cppu/source/uno/EnvDcp.cxx
new file mode 100644
index 000000000..c5597dec4
--- /dev/null
+++ b/cppu/source/uno/EnvDcp.cxx
@@ -0,0 +1,43 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <uno/EnvDcp.h>
+
+
+void uno_EnvDcp_getTypeName(rtl_uString const * pEnvDcp, rtl_uString ** ppEnvTypeName)
+{
+    sal_Int32 colIdx = rtl_ustr_indexOfChar_WithLength(pEnvDcp->buffer, pEnvDcp->length, ':');
+    if (colIdx >= 0)
+        rtl_uString_newFromStr_WithLength(ppEnvTypeName, pEnvDcp->buffer, colIdx);
+
+    else
+        rtl_uString_newFromStr(ppEnvTypeName, pEnvDcp->buffer);
+}
+
+void uno_EnvDcp_getPurpose(rtl_uString const * pEnvDcp, rtl_uString ** ppEnvPurpose)
+{
+    sal_Int32 colIdx = rtl_ustr_indexOfChar_WithLength(pEnvDcp->buffer, pEnvDcp->length, ':');
+    if (colIdx >= 0)
+        rtl_uString_newFromStr_WithLength(ppEnvPurpose, pEnvDcp->buffer + colIdx, pEnvDcp->length - colIdx);
+
+    else
+        rtl_uString_new(ppEnvPurpose);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppu/source/uno/EnvStack.cxx b/cppu/source/uno/EnvStack.cxx
new file mode 100644
index 000000000..f6b11352c
--- /dev/null
+++ b/cppu/source/uno/EnvStack.cxx
@@ -0,0 +1,385 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <uno/environment.hxx>
+#include <uno/lbnames.h>
+
+#include <cppu/EnvDcp.hxx>
+#include <cppu/Enterable.hxx>
+
+#include <rtl/instance.hxx>
+
+#include <osl/thread.h>
+#include <osl/thread.hxx>
+#include <osl/mutex.hxx>
+
+#include <unordered_map>
+
+using namespace com::sun::star;
+
+namespace {
+
+struct oslThreadIdentifier_equal
+{
+    bool operator()(oslThreadIdentifier s1, oslThreadIdentifier s2) const;
+};
+
+}
+
+bool oslThreadIdentifier_equal::operator()(oslThreadIdentifier s1, oslThreadIdentifier s2) const
+{
+    bool result = s1 == s2;
+
+    return result;
+}
+
+namespace {
+
+struct oslThreadIdentifier_hash
+{
+    size_t operator()(oslThreadIdentifier s1) const;
+};
+
+}
+
+size_t oslThreadIdentifier_hash::operator()(oslThreadIdentifier s1) const
+{
+    return s1;
+}
+
+typedef std::unordered_map<oslThreadIdentifier,
+                        uno_Environment *,
+                        oslThreadIdentifier_hash,
+                        oslThreadIdentifier_equal>  ThreadMap;
+
+namespace
+{
+    struct s_threadMap_mutex : public rtl::Static< osl::Mutex, s_threadMap_mutex > {};
+    struct s_threadMap : public rtl::Static< ThreadMap, s_threadMap > {};
+}
+
+static void s_setCurrent(uno_Environment * pEnv)
+{
+    oslThreadIdentifier threadId = osl::Thread::getCurrentIdentifier();
+
+    osl::MutexGuard guard(s_threadMap_mutex::get());
+    ThreadMap &rThreadMap = s_threadMap::get();
+    if (pEnv)
+    {
+        rThreadMap[threadId] = pEnv;
+    }
+    else
+    {
+        ThreadMap::iterator iEnv = rThreadMap.find(threadId);
+        if( iEnv != rThreadMap.end())
+            rThreadMap.erase(iEnv);
+    }
+}
+
+static uno_Environment * s_getCurrent()
+{
+    uno_Environment * pEnv = nullptr;
+
+    oslThreadIdentifier threadId = osl::Thread::getCurrentIdentifier();
+
+    osl::MutexGuard guard(s_threadMap_mutex::get());
+    ThreadMap &rThreadMap = s_threadMap::get();
+    ThreadMap::iterator iEnv = rThreadMap.find(threadId);
+    if(iEnv != rThreadMap.end())
+        pEnv = iEnv->second;
+
+    return pEnv;
+}
+
+
+extern "C" void SAL_CALL uno_getCurrentEnvironment(uno_Environment ** ppEnv, rtl_uString * pTypeName)
+    SAL_THROW_EXTERN_C()
+{
+    if (*ppEnv)
+    {
+        (*ppEnv)->release(*ppEnv);
+        *ppEnv = nullptr;
+    }
+
+    OUString currPurpose;
+
+    uno_Environment * pCurrEnv = s_getCurrent();
+    if (pCurrEnv) // no environment means no purpose
+        currPurpose = cppu::EnvDcp::getPurpose(pCurrEnv->pTypeName);
+
+    if (pTypeName && rtl_uString_getLength(pTypeName))
+    {
+        OUString envDcp = OUString::unacquired(&pTypeName) + currPurpose;
+
+        uno_getEnvironment(ppEnv, envDcp.pData, nullptr);
+    }
+    else
+    {
+        if (pCurrEnv)
+        {
+            *ppEnv = pCurrEnv;
+            (*ppEnv)->acquire(*ppEnv);
+        }
+        else
+        {
+            OUString uno_envDcp(UNO_LB_UNO);
+            uno_getEnvironment(ppEnv, uno_envDcp.pData, nullptr);
+        }
+    }
+}
+
+static OUString s_getPrefix(OUString const & str1, OUString const & str2)
+{
+    sal_Int32 nIndex1 = 0;
+    sal_Int32 nIndex2 = 0;
+    sal_Int32 sim = 0;
+
+    OUString token1;
+    OUString token2;
+
+    do
+    {
+        token1 = str1.getToken(0, ':', nIndex1);
+        token2 = str2.getToken(0, ':', nIndex2);
+
+        if (token1 == token2)
+            sim += token1.getLength() + 1;
+    }
+    while(nIndex1 == nIndex2 && nIndex1 >= 0 && token1 == token2);
+
+    OUString result;
+
+    if (sim)
+        result = str1.copy(0, sim - 1);
+
+    return result;
+}
+
+static int s_getNextEnv(uno_Environment ** ppEnv, uno_Environment * pCurrEnv, uno_Environment * pTargetEnv)
+{
+    int res = 0;
+
+    OUString nextPurpose;
+
+    OUString currPurpose;
+    if (pCurrEnv)
+        currPurpose = cppu::EnvDcp::getPurpose(pCurrEnv->pTypeName);
+
+    OUString targetPurpose;
+    if (pTargetEnv)
+        targetPurpose = cppu::EnvDcp::getPurpose(pTargetEnv->pTypeName);
+
+    OUString intermPurpose(s_getPrefix(currPurpose, targetPurpose));
+    if (currPurpose.getLength() > intermPurpose.getLength())
+    {
+        sal_Int32 idx = currPurpose.lastIndexOf(':');
+        nextPurpose = currPurpose.copy(0, idx);
+
+        res = -1;
+    }
+    else if (intermPurpose.getLength() < targetPurpose.getLength())
+    {
+        sal_Int32 idx = targetPurpose.indexOf(':', intermPurpose.getLength() + 1);
+        if (idx == -1)
+            nextPurpose = targetPurpose;
+
+        else
+            nextPurpose = targetPurpose.copy(0, idx);
+
+        res = 1;
+    }
+
+    if (!nextPurpose.isEmpty())
+    {
+        OUString next_envDcp = UNO_LB_UNO + nextPurpose;
+        uno_getEnvironment(ppEnv, next_envDcp.pData, nullptr);
+    }
+    else
+    {
+        if (*ppEnv)
+            (*ppEnv)->release(*ppEnv);
+
+        *ppEnv = nullptr;
+    }
+
+    return res;
+}
+
+extern "C" { static void s_pull(va_list * pParam)
+{
+    uno_EnvCallee * pCallee = va_arg(*pParam, uno_EnvCallee *);
+    va_list       * pXparam = va_arg(*pParam, va_list *);
+
+    pCallee(pXparam);
+}}
+
+static void s_callInto_v(uno_Environment * pEnv, uno_EnvCallee * pCallee, va_list * pParam)
+{
+    cppu::Enterable * pEnterable = static_cast<cppu::Enterable *>(pEnv->pReserved);
+    if (pEnterable)
+        pEnterable->callInto(s_pull, pCallee, pParam);
+
+    else
+        pCallee(pParam);
+}
+
+static void s_callInto(uno_Environment * pEnv, uno_EnvCallee * pCallee, ...)
+{
+    va_list param;
+
+    va_start(param, pCallee);
+    s_callInto_v(pEnv, pCallee, &param);
+    va_end(param);
+}
+
+static void s_callOut_v(uno_Environment * pEnv, uno_EnvCallee * pCallee, va_list * pParam)
+{
+    cppu::Enterable * pEnterable = static_cast<cppu::Enterable *>(pEnv->pReserved);
+    if (pEnterable)
+        pEnterable->callOut_v(pCallee, pParam);
+
+    else
+        pCallee(pParam);
+}
+
+static void s_callOut(uno_Environment * pEnv, uno_EnvCallee * pCallee, ...)
+{
+    va_list param;
+
+    va_start(param, pCallee);
+    s_callOut_v(pEnv, pCallee, &param);
+    va_end(param);
+}
+
+static void s_environment_invoke_v(uno_Environment *, uno_Environment *, uno_EnvCallee *, va_list *);
+
+extern "C" { static void s_environment_invoke_vv(va_list * pParam)
+{
+    uno_Environment * pCurrEnv    = va_arg(*pParam, uno_Environment *);
+    uno_Environment * pTargetEnv  = va_arg(*pParam, uno_Environment *);
+    uno_EnvCallee   * pCallee     = va_arg(*pParam, uno_EnvCallee *);
+    va_list         * pXparam     = va_arg(*pParam, va_list *);
+
+    s_environment_invoke_v(pCurrEnv, pTargetEnv, pCallee, pXparam);
+}}
+
+static void s_environment_invoke_v(uno_Environment * pCurrEnv, uno_Environment * pTargetEnv, uno_EnvCallee * pCallee, va_list * pParam)
+{
+    uno_Environment * pNextEnv = nullptr;
+    switch(s_getNextEnv(&pNextEnv, pCurrEnv, pTargetEnv))
+    {
+    case -1:
+        s_setCurrent(pNextEnv);
+        s_callOut(pCurrEnv, s_environment_invoke_vv, pNextEnv, pTargetEnv, pCallee, pParam);
+        s_setCurrent(pCurrEnv);
+        break;
+
+    case 0: {
+        uno_Environment * hld = s_getCurrent();
+        s_setCurrent(pCurrEnv);
+        pCallee(pParam);
+        s_setCurrent(hld);
+    }
+        break;
+
+    case 1:
+        s_setCurrent(pNextEnv);
+        s_callInto(pNextEnv, s_environment_invoke_vv, pNextEnv, pTargetEnv, pCallee, pParam);
+        s_setCurrent(pCurrEnv);
+        break;
+    }
+
+    if (pNextEnv)
+        pNextEnv->release(pNextEnv);
+}
+
+extern "C" void SAL_CALL uno_Environment_invoke_v(uno_Environment * pTargetEnv, uno_EnvCallee * pCallee, va_list * pParam)
+    SAL_THROW_EXTERN_C()
+{
+    s_environment_invoke_v(s_getCurrent(), pTargetEnv, pCallee, pParam);
+}
+
+extern "C" void SAL_CALL uno_Environment_invoke(uno_Environment * pEnv, uno_EnvCallee * pCallee, ...)
+    SAL_THROW_EXTERN_C()
+{
+    va_list param;
+
+    va_start(param, pCallee);
+    uno_Environment_invoke_v(pEnv, pCallee, &param);
+    va_end(param);
+}
+
+extern "C" void SAL_CALL uno_Environment_enter(uno_Environment * pTargetEnv)
+    SAL_THROW_EXTERN_C()
+{
+    uno_Environment * pNextEnv = nullptr;
+    uno_Environment * pCurrEnv = s_getCurrent();
+
+    int res;
+    while ( (res = s_getNextEnv(&pNextEnv, pCurrEnv, pTargetEnv)) != 0)
+    {
+        cppu::Enterable * pEnterable;
+
+        switch(res)
+        {
+        case -1:
+            pEnterable = static_cast<cppu::Enterable *>(pCurrEnv->pReserved);
+            if (pEnterable)
+                pEnterable->leave();
+            pCurrEnv->release(pCurrEnv);
+            break;
+
+        case 1:
+            pNextEnv->acquire(pNextEnv);
+            pEnterable = static_cast<cppu::Enterable *>(pNextEnv->pReserved);
+            if (pEnterable)
+                pEnterable->enter();
+            break;
+        }
+
+        s_setCurrent(pNextEnv);
+        pCurrEnv = pNextEnv;
+    }
+}
+
+int SAL_CALL uno_Environment_isValid(uno_Environment * pEnv, rtl_uString ** pReason)
+    SAL_THROW_EXTERN_C()
+{
+    int result = 1;
+
+    OUString typeName(cppu::EnvDcp::getTypeName(pEnv->pTypeName));
+    if (typeName == UNO_LB_UNO)
+    {
+        cppu::Enterable * pEnterable = static_cast<cppu::Enterable *>(pEnv->pReserved);
+        if (pEnterable)
+            result = pEnterable->isValid(reinterpret_cast<OUString *>(pReason));
+    }
+    else
+    {
+        OUString envDcp = UNO_LB_UNO + cppu::EnvDcp::getPurpose(pEnv->pTypeName);
+
+        uno::Environment env(envDcp);
+
+        result = env.isValid(reinterpret_cast<OUString *>(pReason));
+    }
+
+    return result;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppu/source/uno/IdentityMapping.cxx b/cppu/source/uno/IdentityMapping.cxx
new file mode 100644
index 000000000..c6dab40ce
--- /dev/null
+++ b/cppu/source/uno/IdentityMapping.cxx
@@ -0,0 +1,104 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include "IdentityMapping.hxx"
+
+#include <typelib/typedescription.h>
+#include <uno/mapping.h>
+#include <uno/environment.hxx>
+
+#include <osl/interlck.h>
+
+
+using namespace ::com::sun::star;
+
+namespace {
+
+struct IdentityMapping : public uno_Mapping
+{
+    sal_Int32        m_nRef;
+    uno::Environment m_env;
+
+    explicit IdentityMapping(uno::Environment const & rEnv);
+};
+
+}
+
+extern "C"
+{
+
+static void s_free(uno_Mapping * pMapping)
+{
+    delete static_cast<IdentityMapping *>(pMapping);
+}
+
+static void s_acquire(uno_Mapping * pMapping)
+{
+    static OUString s_purpose;
+
+    if (1 == osl_atomic_increment(&static_cast<IdentityMapping *>(pMapping)->m_nRef))
+    {
+        uno_registerMapping(
+            &pMapping,
+            s_free,
+            static_cast<IdentityMapping *>(pMapping)->m_env.get(),
+            static_cast<IdentityMapping *>(pMapping)->m_env.get(),
+            s_purpose.pData);
+    }
+}
+
+static void s_release(uno_Mapping * pMapping)
+{
+    if (!osl_atomic_decrement(&static_cast<IdentityMapping *>(pMapping )->m_nRef))
+        uno_revokeMapping(pMapping);
+}
+
+static void s_mapInterface(uno_Mapping                       * pMapping,
+                                    void                             ** ppOut,
+                                    void                              * pInterface,
+                                    SAL_UNUSED_PARAMETER typelib_InterfaceTypeDescription * /*pInterfaceTypeDescr*/)
+{
+    *ppOut = pInterface;
+
+    if (pInterface)
+    {
+        IdentityMapping * that = static_cast<IdentityMapping *>(pMapping);
+
+        (that->m_env.get()->pExtEnv->acquireInterface)(that->m_env.get()->pExtEnv, pInterface);
+    }
+}
+}
+
+
+IdentityMapping::IdentityMapping(uno::Environment const & rEnv)
+    : m_nRef(0),
+      m_env(rEnv)
+{
+    uno_Mapping::acquire        = s_acquire;
+    uno_Mapping::release        = s_release;
+    uno_Mapping::mapInterface   = s_mapInterface;
+}
+
+
+uno_Mapping * createIdentityMapping(uno::Environment const & rEnv)
+{
+    return new IdentityMapping(rEnv);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppu/source/uno/IdentityMapping.hxx b/cppu/source/uno/IdentityMapping.hxx
new file mode 100644
index 000000000..fe2a64406
--- /dev/null
+++ b/cppu/source/uno/IdentityMapping.hxx
@@ -0,0 +1,31 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_CPPU_SOURCE_UNO_IDENTITYMAPPING_HXX
+#define INCLUDED_CPPU_SOURCE_UNO_IDENTITYMAPPING_HXX
+
+#include <uno/mapping.h>
+
+namespace com::sun::star::uno { class Environment; }
+
+uno_Mapping * createIdentityMapping(const css::uno::Environment & rEnv);
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppu/source/uno/any.cxx b/cppu/source/uno/any.cxx
new file mode 100644
index 000000000..e26b97286
--- /dev/null
+++ b/cppu/source/uno/any.cxx
@@ -0,0 +1,142 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+
+#include "copy.hxx"
+#include "destr.hxx"
+
+using namespace cppu;
+
+
+extern "C"
+{
+
+void SAL_CALL uno_type_any_assign(
+    uno_Any * pDest, void * pSource,
+    typelib_TypeDescriptionReference * pType,
+    uno_AcquireFunc acquire, uno_ReleaseFunc release )
+    SAL_THROW_EXTERN_C()
+{
+    _destructAny( pDest, release );
+    if (pType)
+    {
+        _copyConstructAny( pDest, pSource, pType, nullptr, acquire, nullptr );
+    }
+    else
+    {
+        CONSTRUCT_EMPTY_ANY( pDest );
+    }
+}
+
+void SAL_CALL uno_any_assign(
+    uno_Any * pDest, void * pSource,
+    typelib_TypeDescription * pTypeDescr,
+    uno_AcquireFunc acquire, uno_ReleaseFunc release )
+    SAL_THROW_EXTERN_C()
+{
+    _destructAny( pDest, release );
+    if (pTypeDescr)
+    {
+        _copyConstructAny( pDest, pSource, pTypeDescr->pWeakRef, pTypeDescr, acquire, nullptr );
+    }
+    else
+    {
+        CONSTRUCT_EMPTY_ANY( pDest );
+    }
+}
+
+void SAL_CALL uno_type_any_construct(
+    uno_Any * pDest, void * pSource,
+    typelib_TypeDescriptionReference * pType,
+    uno_AcquireFunc acquire )
+    SAL_THROW_EXTERN_C()
+{
+    if (pType)
+    {
+        _copyConstructAny( pDest, pSource, pType, nullptr, acquire, nullptr );
+    }
+    else
+    {
+        CONSTRUCT_EMPTY_ANY( pDest );
+    }
+}
+
+void SAL_CALL uno_any_construct(
+    uno_Any * pDest, void * pSource,
+    typelib_TypeDescription * pTypeDescr,
+    uno_AcquireFunc acquire )
+    SAL_THROW_EXTERN_C()
+{
+    if (pTypeDescr)
+    {
+        _copyConstructAny( pDest, pSource, pTypeDescr->pWeakRef, pTypeDescr, acquire, nullptr );
+    }
+    else
+    {
+        CONSTRUCT_EMPTY_ANY( pDest );
+    }
+}
+
+void SAL_CALL uno_type_any_constructAndConvert(
+    uno_Any * pDest, void * pSource,
+    typelib_TypeDescriptionReference * pType,
+    uno_Mapping * mapping )
+    SAL_THROW_EXTERN_C()
+{
+    if (pType)
+    {
+        _copyConstructAny( pDest, pSource, pType, nullptr, nullptr, mapping );
+    }
+    else
+    {
+        CONSTRUCT_EMPTY_ANY( pDest );
+    }
+}
+
+void SAL_CALL uno_any_constructAndConvert(
+    uno_Any * pDest, void * pSource,
+    typelib_TypeDescription * pTypeDescr,
+    uno_Mapping * mapping )
+    SAL_THROW_EXTERN_C()
+{
+    if (pTypeDescr)
+    {
+        _copyConstructAny( pDest, pSource, pTypeDescr->pWeakRef, pTypeDescr, nullptr, mapping );
+    }
+    else
+    {
+        CONSTRUCT_EMPTY_ANY( pDest );
+    }
+}
+
+void SAL_CALL uno_any_destruct( uno_Any * pValue, uno_ReleaseFunc release )
+    SAL_THROW_EXTERN_C()
+{
+    _destructAny( pValue, release );
+}
+
+void SAL_CALL uno_any_clear( uno_Any * pValue, uno_ReleaseFunc release )
+    SAL_THROW_EXTERN_C()
+{
+    _destructAny( pValue, release );
+    CONSTRUCT_EMPTY_ANY( pValue );
+}
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppu/source/uno/assign.hxx b/cppu/source/uno/assign.hxx
new file mode 100644
index 000000000..97ee9cd5b
--- /dev/null
+++ b/cppu/source/uno/assign.hxx
@@ -0,0 +1,455 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef INCLUDED_CPPU_SOURCE_UNO_ASSIGN_HXX
+#define INCLUDED_CPPU_SOURCE_UNO_ASSIGN_HXX
+
+#include "prim.hxx"
+#include "destr.hxx"
+#include "constr.hxx"
+#include "copy.hxx"
+
+
+namespace cppu
+{
+
+
+//#### assignment ##################################################################################
+
+
+inline void _assignInterface(
+    void ** ppDest, void * pSource,
+    uno_AcquireFunc acquire, uno_ReleaseFunc release )
+
+{
+    _acquire( pSource, acquire );
+    void * const pToBeReleased = *ppDest;
+    *ppDest = pSource;
+    _release( pToBeReleased, release );
+}
+
+inline void * _queryInterface(
+    void * pSource,
+    typelib_TypeDescriptionReference * pDestType,
+    uno_QueryInterfaceFunc queryInterface )
+{
+    if (pSource)
+    {
+        if (nullptr == queryInterface)
+            queryInterface = binuno_queryInterface;
+        pSource = (*queryInterface)( pSource, pDestType );
+    }
+    return pSource;
+}
+
+bool assignStruct(
+    void * pDest, void * pSource,
+    typelib_CompoundTypeDescription * pTypeDescr,
+    uno_QueryInterfaceFunc queryInterface, uno_AcquireFunc acquire, uno_ReleaseFunc release );
+
+inline bool _assignStruct(
+    void * pDest, void * pSource,
+    typelib_CompoundTypeDescription * pTypeDescr,
+    uno_QueryInterfaceFunc queryInterface, uno_AcquireFunc acquire, uno_ReleaseFunc release )
+{
+    if (pTypeDescr->pBaseTypeDescription)
+    {
+        // copy base value
+        if (! assignStruct( pDest, pSource, pTypeDescr->pBaseTypeDescription,
+                            queryInterface, acquire, release ))
+        {
+            return false;
+        }
+    }
+    // then copy members
+    typelib_TypeDescriptionReference ** ppTypeRefs = pTypeDescr->ppTypeRefs;
+    sal_Int32 * pMemberOffsets = pTypeDescr->pMemberOffsets;
+    sal_Int32 nDescr = pTypeDescr->nMembers;
+    while (nDescr--)
+    {
+        if (! ::uno_type_assignData( static_cast<char *>(pDest) + pMemberOffsets[nDescr],
+                                     ppTypeRefs[nDescr],
+                                     static_cast<char *>(pSource) + pMemberOffsets[nDescr],
+                                     ppTypeRefs[nDescr],
+                                     queryInterface, acquire, release ))
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+inline bool _assignData(
+    void * pDest,
+    typelib_TypeDescriptionReference * pDestType, typelib_TypeDescription * pDestTypeDescr,
+    void * pSource,
+    typelib_TypeDescriptionReference * pSourceType, typelib_TypeDescription * pSourceTypeDescr,
+    uno_QueryInterfaceFunc queryInterface, uno_AcquireFunc acquire, uno_ReleaseFunc release )
+{
+    if (pDest == pSource)
+        return _type_equals( pDestType, pSourceType );
+
+    if (! pSource)
+    {
+        _destructData( pDest, pDestType, pDestTypeDescr, release );
+        _defaultConstructData( pDest, pDestType, pDestTypeDescr );
+        return true;
+    }
+    while (typelib_TypeClass_ANY == pSourceType->eTypeClass)
+    {
+        pSourceTypeDescr = nullptr;
+        pSourceType = static_cast<uno_Any *>(pSource)->pType;
+        pSource = static_cast<uno_Any *>(pSource)->pData;
+        if (pDest == pSource)
+            return true;
+    }
+
+    switch (pDestType->eTypeClass)
+    {
+    case typelib_TypeClass_VOID:
+        return pSourceType->eTypeClass == typelib_TypeClass_VOID;
+    case typelib_TypeClass_CHAR:
+        switch (pSourceType->eTypeClass)
+        {
+        case typelib_TypeClass_CHAR:
+            *static_cast<sal_Unicode *>(pDest) = *static_cast<sal_Unicode *>(pSource);
+            return true;
+        default:
+            return false;
+        }
+    case typelib_TypeClass_BOOLEAN:
+        switch (pSourceType->eTypeClass)
+        {
+        case typelib_TypeClass_BOOLEAN:
+            *static_cast<sal_Bool *>(pDest) = bool(*static_cast<sal_Bool *>(pSource));
+            return true;
+        default:
+            return false;
+        }
+    case typelib_TypeClass_BYTE:
+        switch (pSourceType->eTypeClass)
+        {
+        case typelib_TypeClass_BYTE:
+            *static_cast<sal_Int8 *>(pDest) = *static_cast<sal_Int8 *>(pSource);
+            return true;
+        default:
+            return false;
+        }
+    case typelib_TypeClass_SHORT:
+        switch (pSourceType->eTypeClass)
+        {
+        case typelib_TypeClass_BYTE:
+            *static_cast<sal_Int16 *>(pDest) = *static_cast<sal_Int8 *>(pSource);
+            return true;
+        case typelib_TypeClass_SHORT:
+        case typelib_TypeClass_UNSIGNED_SHORT:
+            *static_cast<sal_Int16 *>(pDest) = *static_cast<sal_Int16 *>(pSource);
+            return true;
+        default:
+            return false;
+        }
+    case typelib_TypeClass_UNSIGNED_SHORT:
+        switch (pSourceType->eTypeClass)
+        {
+        case typelib_TypeClass_BYTE:
+            *static_cast<sal_uInt16 *>(pDest) = *static_cast<sal_Int8 *>(pSource);
+            return true;
+        case typelib_TypeClass_SHORT:
+        case typelib_TypeClass_UNSIGNED_SHORT:
+            *static_cast<sal_uInt16 *>(pDest) = *static_cast<sal_uInt16 *>(pSource);
+            return true;
+        default:
+            return false;
+        }
+    case typelib_TypeClass_LONG:
+        switch (pSourceType->eTypeClass)
+        {
+        case typelib_TypeClass_BYTE:
+            *static_cast<sal_Int32 *>(pDest) = *static_cast<sal_Int8 *>(pSource);
+            return true;
+        case typelib_TypeClass_SHORT:
+            *static_cast<sal_Int32 *>(pDest) = *static_cast<sal_Int16 *>(pSource);
+            return true;
+        case typelib_TypeClass_UNSIGNED_SHORT:
+            *static_cast<sal_Int32 *>(pDest) = *static_cast<sal_uInt16 *>(pSource);
+            return true;
+        case typelib_TypeClass_LONG:
+        case typelib_TypeClass_UNSIGNED_LONG:
+            *static_cast<sal_Int32 *>(pDest) = *static_cast<sal_Int32 *>(pSource);
+            return true;
+        default:
+            return false;
+        }
+    case typelib_TypeClass_UNSIGNED_LONG:
+        switch (pSourceType->eTypeClass)
+        {
+        case typelib_TypeClass_BYTE:
+            *static_cast<sal_uInt32 *>(pDest) = *static_cast<sal_Int8 *>(pSource);
+            return true;
+        case typelib_TypeClass_SHORT:
+            *static_cast<sal_uInt32 *>(pDest) = *static_cast<sal_Int16 *>(pSource);
+            return true;
+        case typelib_TypeClass_UNSIGNED_SHORT:
+            *static_cast<sal_uInt32 *>(pDest) = *static_cast<sal_uInt16 *>(pSource);
+            return true;
+        case typelib_TypeClass_LONG:
+        case typelib_TypeClass_UNSIGNED_LONG:
+            *static_cast<sal_uInt32 *>(pDest) = *static_cast<sal_uInt32 *>(pSource);
+            return true;
+        default:
+            return false;
+        }
+    case typelib_TypeClass_HYPER:
+        switch (pSourceType->eTypeClass)
+        {
+        case typelib_TypeClass_BYTE:
+            *static_cast<sal_Int64 *>(pDest) = *static_cast<sal_Int8 *>(pSource);
+            return true;
+        case typelib_TypeClass_SHORT:
+            *static_cast<sal_Int64 *>(pDest) = *static_cast<sal_Int16 *>(pSource);
+            return true;
+        case typelib_TypeClass_UNSIGNED_SHORT:
+            *static_cast<sal_Int64 *>(pDest) = *static_cast<sal_uInt16 *>(pSource);
+            return true;
+        case typelib_TypeClass_LONG:
+            *static_cast<sal_Int64 *>(pDest) = *static_cast<sal_Int32 *>(pSource);
+            return true;
+        case typelib_TypeClass_UNSIGNED_LONG:
+            *static_cast<sal_Int64 *>(pDest) = *static_cast<sal_uInt32 *>(pSource);
+            return true;
+        case typelib_TypeClass_HYPER:
+        case typelib_TypeClass_UNSIGNED_HYPER:
+            *static_cast<sal_Int64 *>(pDest) = *static_cast<sal_Int64 *>(pSource);
+            return true;
+        default:
+            return false;
+        }
+    case typelib_TypeClass_UNSIGNED_HYPER:
+        switch (pSourceType->eTypeClass)
+        {
+        case typelib_TypeClass_BYTE:
+            *static_cast<sal_uInt64 *>(pDest) = *static_cast<sal_Int8 *>(pSource);
+            return true;
+        case typelib_TypeClass_SHORT:
+            *static_cast<sal_uInt64 *>(pDest) = *static_cast<sal_Int16 *>(pSource);
+            return true;
+        case typelib_TypeClass_UNSIGNED_SHORT:
+            *static_cast<sal_uInt64 *>(pDest) = *static_cast<sal_uInt16 *>(pSource);
+            return true;
+        case typelib_TypeClass_LONG:
+            *static_cast<sal_uInt64 *>(pDest) = *static_cast<sal_Int32 *>(pSource);
+            return true;
+        case typelib_TypeClass_UNSIGNED_LONG:
+            *static_cast<sal_uInt64 *>(pDest) = *static_cast<sal_uInt32 *>(pSource);
+            return true;
+        case typelib_TypeClass_HYPER:
+        case typelib_TypeClass_UNSIGNED_HYPER:
+            *static_cast<sal_uInt64 *>(pDest) = *static_cast<sal_uInt64 *>(pSource);
+            return true;
+        default:
+            return false;
+        }
+    case typelib_TypeClass_FLOAT:
+        switch (pSourceType->eTypeClass)
+        {
+        case typelib_TypeClass_BYTE:
+            *static_cast<float *>(pDest) = *static_cast<sal_Int8 *>(pSource);
+            return true;
+        case typelib_TypeClass_SHORT:
+            *static_cast<float *>(pDest) = *static_cast<sal_Int16 *>(pSource);
+            return true;
+        case typelib_TypeClass_UNSIGNED_SHORT:
+            *static_cast<float *>(pDest) = *static_cast<sal_uInt16 *>(pSource);
+            return true;
+        case typelib_TypeClass_FLOAT:
+            *static_cast<float *>(pDest) = *static_cast<float *>(pSource);
+            return true;
+        default:
+            return false;
+        }
+    case typelib_TypeClass_DOUBLE:
+        switch (pSourceType->eTypeClass)
+        {
+        case typelib_TypeClass_BYTE:
+            *static_cast<double *>(pDest) = *static_cast<sal_Int8 *>(pSource);
+            return true;
+        case typelib_TypeClass_SHORT:
+            *static_cast<double *>(pDest) = *static_cast<sal_Int16 *>(pSource);
+            return true;
+        case typelib_TypeClass_UNSIGNED_SHORT:
+            *static_cast<double *>(pDest) = *static_cast<sal_uInt16 *>(pSource);
+            return true;
+        case typelib_TypeClass_LONG:
+            *static_cast<double *>(pDest) = *static_cast<sal_Int32 *>(pSource);
+            return true;
+        case typelib_TypeClass_UNSIGNED_LONG:
+            *static_cast<double *>(pDest) = *static_cast<sal_uInt32 *>(pSource);
+            return true;
+        case typelib_TypeClass_FLOAT:
+            *static_cast<double *>(pDest) = *static_cast<float *>(pSource);
+            return true;
+        case typelib_TypeClass_DOUBLE:
+            *static_cast<double *>(pDest) = *static_cast<double *>(pSource);
+            return true;
+        default:
+            return false;
+        }
+    case typelib_TypeClass_STRING:
+        switch (pSourceType->eTypeClass)
+        {
+        case typelib_TypeClass_STRING:
+            ::rtl_uString_assign( static_cast<rtl_uString **>(pDest), *static_cast<rtl_uString **>(pSource) );
+            return true;
+        default:
+            return false;
+        }
+    case typelib_TypeClass_TYPE:
+        switch (pSourceType->eTypeClass)
+        {
+        case typelib_TypeClass_TYPE:
+        {
+            typelib_TypeDescriptionReference ** pp = static_cast<typelib_TypeDescriptionReference **>(pDest);
+            ::typelib_typedescriptionreference_release( *pp );
+            *pp = *static_cast<typelib_TypeDescriptionReference **>(pSource);
+            TYPE_ACQUIRE( *pp );
+            return true;
+        }
+        default:
+            return false;
+        }
+    case typelib_TypeClass_ANY:
+        _destructAny( static_cast<uno_Any *>(pDest), release );
+        _copyConstructAny( static_cast<uno_Any *>(pDest), pSource, pSourceType, pSourceTypeDescr, acquire, nullptr );
+        return true;
+    case typelib_TypeClass_ENUM:
+        if (_type_equals( pDestType, pSourceType ))
+        {
+            *static_cast<sal_Int32 *>(pDest) = *static_cast<sal_Int32 *>(pSource);
+            return true;
+        }
+        return false;
+    case typelib_TypeClass_STRUCT:
+    case typelib_TypeClass_EXCEPTION:
+        if (typelib_TypeClass_STRUCT == pSourceType->eTypeClass ||
+            typelib_TypeClass_EXCEPTION == pSourceType->eTypeClass)
+        {
+            bool bRet = false;
+            if (pSourceTypeDescr)
+            {
+                typelib_CompoundTypeDescription * pTypeDescr =
+                    reinterpret_cast<typelib_CompoundTypeDescription *>(pSourceTypeDescr);
+                while (pTypeDescr &&
+                       !_type_equals(pTypeDescr->aBase.pWeakRef, pDestType))
+                {
+                    pTypeDescr = pTypeDescr->pBaseTypeDescription;
+                }
+                if (pTypeDescr)
+                {
+                    bRet = _assignStruct(
+                        pDest, pSource, pTypeDescr, queryInterface, acquire, release );
+                }
+            }
+            else
+            {
+                TYPELIB_DANGER_GET( &pSourceTypeDescr, pSourceType );
+                typelib_CompoundTypeDescription * pTypeDescr =
+                    reinterpret_cast<typelib_CompoundTypeDescription *>(pSourceTypeDescr);
+                while (pTypeDescr &&
+                       !_type_equals(pTypeDescr->aBase.pWeakRef, pDestType))
+                {
+                    pTypeDescr = pTypeDescr->pBaseTypeDescription;
+                }
+                if (pTypeDescr)
+                {
+                    bRet = _assignStruct(
+                        pDest, pSource, pTypeDescr, queryInterface, acquire, release );
+                }
+                TYPELIB_DANGER_RELEASE( pSourceTypeDescr );
+            }
+            return bRet;
+        }
+        return false;
+    case typelib_TypeClass_SEQUENCE:
+        if (typelib_TypeClass_SEQUENCE != pSourceType->eTypeClass)
+            return false;
+        // self assignment:
+        if (*static_cast<uno_Sequence **>(pSource) == *static_cast<uno_Sequence **>(pDest))
+            return true;
+        if (_type_equals( pDestType, pSourceType ))
+        {
+            osl_atomic_increment( &(*static_cast<uno_Sequence **>(pSource))->nRefCount );
+            idestructSequence(
+                *static_cast<uno_Sequence **>(pDest), pDestType, pDestTypeDescr, release );
+            *static_cast<uno_Sequence **>(pDest) = *static_cast<uno_Sequence **>(pSource);
+            return true;
+        }
+        return false;
+    case typelib_TypeClass_INTERFACE:
+        if (typelib_TypeClass_INTERFACE != pSourceType->eTypeClass)
+            return false;
+        if (_type_equals( pDestType, pSourceType ))
+        {
+            _assignInterface( static_cast<void **>(pDest), *static_cast<void **>(pSource), acquire, release );
+            return true;
+        }
+        else if (*static_cast< void ** >(pSource) == nullptr)
+        {
+            // A null reference of any interface type can be converted to a null
+            // reference of any other interface type:
+            void * const pToBeReleased = *static_cast< void ** >(pDest);
+            *static_cast< void ** >(pDest) = nullptr;
+            _release( pToBeReleased, release );
+            return true;
+        }
+        else
+        {
+            if (pSourceTypeDescr)
+            {
+                typelib_TypeDescription * pTD = pSourceTypeDescr;
+                while (pTD && !_type_equals( pTD->pWeakRef, pDestType ))
+                {
+                    pTD = &reinterpret_cast<typelib_InterfaceTypeDescription *>(pTD)->pBaseTypeDescription->aBase;
+                }
+                if (pTD) // is base of dest
+                {
+                    _assignInterface( static_cast<void **>(pDest), *static_cast<void **>(pSource), acquire, release );
+                    return true;
+                }
+            }
+
+            // query for interface:
+            void * pQueried = _queryInterface( *static_cast<void **>(pSource),
+                                               pDestType, queryInterface );
+            if (pQueried != nullptr) {
+                void * const pToBeReleased = *static_cast<void **>(pDest);
+                *static_cast<void **>(pDest) = pQueried;
+                _release( pToBeReleased, release );
+            }
+            return (pQueried != nullptr);
+        }
+    default:
+        OSL_ASSERT(false);
+        return false;
+    }
+}
+
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppu/source/uno/cascade_mapping.cxx b/cppu/source/uno/cascade_mapping.cxx
new file mode 100644
index 000000000..f57f7dc0a
--- /dev/null
+++ b/cppu/source/uno/cascade_mapping.cxx
@@ -0,0 +1,307 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <osl/interlck.h>
+#include <rtl/ustring.hxx>
+#include <uno/environment.hxx>
+#include <uno/lbnames.h>
+#include <uno/mapping.hxx>
+#include <uno/dispatcher.h>
+
+#include <cppu/EnvDcp.hxx>
+
+#include "cascade_mapping.hxx"
+
+using namespace com::sun::star;
+
+namespace {
+
+class MediatorMapping : public uno_Mapping
+{
+    oslInterlockedCount m_refCount;
+
+    uno::Mapping        m_from2uno;
+    uno::Mapping        m_uno2to;
+
+    uno::Environment    m_from;
+    uno::Environment    m_interm;
+    uno::Environment    m_to;
+
+public:
+    void acquire();
+    void release();
+
+    void mapInterface(void                            ** ppOut,
+                      void                             * pInterface,
+                      typelib_InterfaceTypeDescription * pInterfaceTypeDescr);
+    MediatorMapping(uno_Environment * pFrom,
+                    uno_Environment * pInterm,
+                    uno_Environment * pTo);
+};
+
+}
+
+extern "C" {
+static void s_acquire(uno_Mapping * mapping)
+{
+    MediatorMapping * pMediatorMapping = static_cast<MediatorMapping *>(mapping);
+    pMediatorMapping->acquire();
+}
+
+static void s_release(uno_Mapping * mapping)
+{
+    MediatorMapping * pMediatorMapping = static_cast<MediatorMapping *>(mapping);
+    pMediatorMapping->release();
+}
+
+static void s_mapInterface(
+    uno_Mapping                      * mapping,
+    void                            ** ppOut,
+    void                             * pInterface,
+    typelib_InterfaceTypeDescription * pInterfaceTypeDescr)
+{
+    MediatorMapping   * pMediatorMapping  = static_cast<MediatorMapping *>(mapping);
+    pMediatorMapping->mapInterface(ppOut, pInterface, pInterfaceTypeDescr);
+}
+}
+
+MediatorMapping::MediatorMapping(uno_Environment * pFrom,
+                                 uno_Environment * pInterm,
+                                 uno_Environment * pTo)
+    : m_refCount(0),
+      m_from2uno(pFrom, pInterm),
+      m_uno2to  (pInterm, pTo),
+      m_from    (pFrom),
+      m_interm  (pInterm),
+      m_to      (pTo)
+{
+    if (!m_from2uno.get() || !m_uno2to.get())
+        abort();
+
+    uno_Mapping::acquire      = s_acquire;
+    uno_Mapping::release      = s_release;
+    uno_Mapping::mapInterface = s_mapInterface;
+}
+
+void MediatorMapping::acquire()
+{
+    osl_atomic_increment(&m_refCount);
+}
+
+void MediatorMapping::release()
+{
+    if (osl_atomic_decrement(&m_refCount) == 0)
+    {
+        ::uno_revokeMapping(this);
+    }
+}
+
+extern "C" { static void s_mapInterface_v(va_list * pParam)
+{
+    void                            ** ppOut               = va_arg(*pParam, void **);
+    void                             * pInterface          = va_arg(*pParam, void *);
+    typelib_InterfaceTypeDescription * pInterfaceTypeDescr = va_arg(*pParam, typelib_InterfaceTypeDescription *);
+    uno_Mapping                      * pMapping            = va_arg(*pParam, uno_Mapping *);
+
+    pMapping->mapInterface(pMapping, ppOut, pInterface, pInterfaceTypeDescr);
+}}
+
+void MediatorMapping::mapInterface(
+    void                            ** ppOut,
+    void                             * pInterface,
+    typelib_InterfaceTypeDescription * pInterfaceTypeDescr)
+{
+    if (*ppOut != nullptr)
+    {
+        uno_ExtEnvironment * env = m_to.get()->pExtEnv;
+        OSL_ASSERT( env != nullptr );
+        env->releaseInterface( env, *ppOut );
+        *ppOut = nullptr;
+    }
+
+    void * ret = nullptr;
+    uno_Interface * pUnoI = nullptr;
+
+    m_from.invoke(s_mapInterface_v, &pUnoI, pInterface, pInterfaceTypeDescr, m_from2uno.get());
+
+    m_uno2to.mapInterface(&ret, pUnoI, pInterfaceTypeDescr);
+
+    if (pUnoI)
+        m_interm.get()->pExtEnv->releaseInterface(m_interm.get()->pExtEnv, pUnoI);
+
+    *ppOut = ret;
+}
+
+extern "C" { static void s_MediatorMapping_free(uno_Mapping * pMapping)
+    SAL_THROW_EXTERN_C()
+{
+    delete static_cast<MediatorMapping *>(pMapping);
+}}
+
+
+static OUString getPrefix(OUString const & str1, OUString const & str2)
+{
+    sal_Int32 nIndex1 = 0;
+    sal_Int32 nIndex2 = 0;
+    sal_Int32 sim = 0;
+
+    OUString token1;
+    OUString token2;
+
+    do
+    {
+        token1 = str1.getToken(0, ':', nIndex1);
+        token2 = str2.getToken(0, ':', nIndex2);
+
+        if (token1 == token2)
+            sim += token1.getLength() + 1;
+    }
+    while(nIndex1 == nIndex2 && nIndex1 >= 0 && token1 == token2);
+
+    OUString result;
+
+    if (sim)
+        result = str1.copy(0, sim - 1);
+
+    return result;
+}
+
+//  OUString str1("abc:def:ghi");
+//  OUString str2("abc:def");
+//  OUString str3("abc");
+//  OUString str4("");
+
+//  OUString pref;
+
+//  pref = getPrefix(str1, str1);
+//  pref = getPrefix(str1, str2);
+//  pref = getPrefix(str1, str3);
+//  pref = getPrefix(str1, str4);
+
+//  pref = getPrefix(str2, str1);
+//  pref = getPrefix(str3, str1);
+//  pref = getPrefix(str4, str1);
+
+
+void getCascadeMapping(uno_Mapping     ** ppMapping,
+                       uno_Environment  * pFrom,
+                       uno_Environment  * pTo,
+                       rtl_uString      * pAddPurpose)
+{
+    if (pAddPurpose && pAddPurpose->length)
+        return;
+
+    OUString uno_envType(UNO_LB_UNO);
+
+    OUString from_envType    = cppu::EnvDcp::getTypeName(pFrom->pTypeName);
+    OUString to_envType      = cppu::EnvDcp::getTypeName(pTo->pTypeName);
+    OUString from_envPurpose = cppu::EnvDcp::getPurpose(pFrom->pTypeName);
+    OUString to_envPurpose   = cppu::EnvDcp::getPurpose(pTo->pTypeName);
+
+#ifdef LOG_CALLING_named_purpose_getMapping
+    OString s_from_name = OUStringToOString(pFrom->pTypeName, RTL_TEXTENCODING_ASCII_US);
+    OString s_to_name   = OUStringToOString(pTo->pTypeName,   RTL_TEXTENCODING_ASCII_US);
+
+    std::cerr << __FUNCTION__ << " - creating mediation ";
+    std::cerr << "pFrom: " << s_from_name.getStr();
+    std::cerr <<" pTo: "   << s_to_name.getStr() << std::endl;
+#endif
+
+    if (from_envPurpose == to_envPurpose) // gcc:bla => uno:bla
+        return;
+
+    // reaching this point means, we need a mediated mapping!!!
+    // we generally mediate via uno[:free]
+    uno_Environment * pInterm = nullptr;
+
+    // chained uno -> uno
+    if (from_envType == uno_envType && to_envType == uno_envType)
+    {
+        OUString purpose = getPrefix(from_envPurpose, to_envPurpose);
+
+        OUString uno_envDcp = uno_envType + purpose;
+
+        // direct mapping possible?
+        // uno:bla-->uno:bla:blubb
+        if (from_envPurpose == purpose)
+        {
+            OUString rest = to_envPurpose.copy(purpose.getLength());
+
+            sal_Int32 index = rest.indexOf(':', 1);
+            if (index == -1)
+            {
+                uno_getMapping(ppMapping, pFrom, pTo, rest.copy(1).pData);
+                return;
+            }
+
+            uno_envDcp += rest.copy(0, index);
+        }
+        else if (to_envPurpose == purpose)
+        {
+            OUString rest = from_envPurpose.copy(purpose.getLength());
+
+            sal_Int32 index = rest.indexOf(':', 1);
+            if (index == -1)
+            {
+                uno_getMapping(ppMapping, pFrom, pTo, rest.copy(1).pData);
+                return;
+            }
+
+            uno_envDcp += rest.copy(0, index);
+        }
+
+        uno_getEnvironment(&pInterm, uno_envDcp.pData, nullptr);
+    }
+    else if (from_envType != uno_envType && to_envType == uno_envType) // <ANY> -> UNO ?
+        // mediate via uno:purpose(fromEnv)
+    {
+        OUString     envDcp = uno_envType + from_envPurpose;
+        uno_getEnvironment(&pInterm, envDcp.pData, nullptr);
+    }
+    else if (from_envType == uno_envType && to_envType != uno_envType) // UNO -> <ANY>?
+        // mediate via uno(context)
+    {
+        OUString     envDcp = uno_envType + to_envPurpose;
+        uno_getEnvironment(&pInterm, envDcp.pData, nullptr);
+    }
+    else // everything else
+        // mediate via uno:purpose
+    {
+        OUString purpose = getPrefix(from_envPurpose, to_envPurpose);
+
+        OUString uno_envDcp = uno_envType + purpose;
+
+        uno_getEnvironment(&pInterm, uno_envDcp.pData, nullptr);
+    }
+
+    uno_Mapping * pMapping = new MediatorMapping(pFrom, pInterm, pTo);
+    pInterm->release(pInterm);
+
+
+    pMapping->acquire(pMapping);
+
+    ::uno_registerMapping(&pMapping, s_MediatorMapping_free, pFrom, pTo, pAddPurpose);
+
+    if (*ppMapping)
+        (*ppMapping)->release(*ppMapping);
+
+    *ppMapping = pMapping;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppu/source/uno/cascade_mapping.hxx b/cppu/source/uno/cascade_mapping.hxx
new file mode 100644
index 000000000..37f0f1d5b
--- /dev/null
+++ b/cppu/source/uno/cascade_mapping.hxx
@@ -0,0 +1,35 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_CPPU_SOURCE_UNO_CASCADE_MAPPING_HXX
+#define INCLUDED_CPPU_SOURCE_UNO_CASCADE_MAPPING_HXX
+
+#include <uno/environment.h>
+#include <uno/mapping.h>
+#include <rtl/ustring.h>
+
+
+void getCascadeMapping(uno_Mapping     ** ppMapping,
+                       uno_Environment  * pFrom,
+                       uno_Environment  * pTo,
+                       rtl_uString      * pAddPurpose );
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppu/source/uno/check.cxx b/cppu/source/uno/check.cxx
new file mode 100644
index 000000000..3dc0fc5ac
--- /dev/null
+++ b/cppu/source/uno/check.cxx
@@ -0,0 +1,320 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/config.h>
+
+#include <cassert>
+
+#include <cppu/macros.hxx>
+#include <rtl/ustring.hxx>
+#include <sal/types.h>
+#include <uno/any2.h>
+
+
+namespace {
+
+#if defined( _WIN32)
+#pragma pack(push, 8)
+#endif
+
+struct C1
+{
+    sal_Int16 n1;
+};
+struct C2 : public C1
+{
+    sal_Int32 n2 CPPU_GCC3_ALIGN( C1 );
+};
+struct C3 : public C2
+{
+    double d3;
+    sal_Int32 n3;
+};
+struct C4 : public C3
+{
+    sal_Int32 n4 CPPU_GCC3_ALIGN( C3 );
+    double d4;
+};
+struct C5 : public C4
+{
+    sal_Int64 n5;
+    sal_Bool b5;
+};
+struct C6 : public C1
+{
+    C5 c6 CPPU_GCC3_ALIGN( C1 );
+    sal_Bool b6;
+};
+
+struct D
+{
+    sal_Int16 d;
+    sal_Int32 e;
+};
+struct E
+{
+    sal_Bool a;
+    sal_Bool b;
+    sal_Bool c;
+    sal_Int16 d;
+    sal_Int32 e;
+};
+
+struct M
+{
+    sal_Int32   n;
+    sal_Int16   o;
+};
+
+struct N : public M
+{
+    sal_Int16   p CPPU_GCC3_ALIGN( M );
+};
+struct N2
+{
+    M m;
+    sal_Int16   p;
+};
+
+struct O : public M
+{
+    double  p;
+    sal_Int16 q;
+};
+struct O2 : public O
+{
+    sal_Int16 p2 CPPU_GCC3_ALIGN( O );
+};
+
+struct P : public N
+{
+    double  p2;
+};
+
+struct empty
+{
+};
+struct second : public empty
+{
+    int a;
+};
+
+struct AlignSize_Impl
+{
+    sal_Int16   nInt16;
+    double      dDouble;
+};
+
+struct Char1
+{
+    char c1;
+};
+struct Char2 : public Char1
+{
+    char c2 CPPU_GCC3_ALIGN( Char1 );
+};
+struct Char3 : public Char2
+{
+    char c3 CPPU_GCC3_ALIGN( Char2 );
+};
+struct Char4
+{
+    Char3 chars;
+    char c;
+};
+enum Enum
+{
+    v = SAL_MAX_ENUM
+};
+
+#ifdef _WIN32
+#   pragma pack(pop)
+#endif
+
+static_assert( static_cast<sal_Bool>(true) == sal_True,
+               "must be binary compatible" );
+static_assert( static_cast<sal_Bool>(false) == sal_False,
+               "must be binary compatible" );
+#if SAL_TYPES_ALIGNMENT8 == 2
+static_assert(offsetof(AlignSize_Impl, dDouble) == 2, "offsetof(AlignSize_Impl, dDouble) != 2");
+static_assert(sizeof(AlignSize_Impl) == 10, "sizeof(AlignSize_Impl) != 10");
+#elif SAL_TYPES_ALIGNMENT8 == 4
+static_assert(offsetof(AlignSize_Impl, dDouble) == 4, "offsetof(AlignSize_Impl, dDouble) != 4");
+static_assert(sizeof(AlignSize_Impl) == 12, "sizeof(AlignSize_Impl) != 12");
+#elif SAL_TYPES_ALIGNMENT8 == 8
+static_assert(offsetof(AlignSize_Impl, dDouble) == 8, "offsetof(AlignSize_Impl, dDouble) != 8");
+static_assert(sizeof(AlignSize_Impl) == 16, "sizeof(AlignSize_Impl) != 16");
+#else
+# error unexpected alignment of 8 byte types
+#endif
+
+// sequence
+static_assert((SAL_SEQUENCE_HEADER_SIZE % 8) == 0, "binary compatibility test failed: (SAL_SEQUENCE_HEADER_SIZE % 8) == 0!!!");
+// enum
+static_assert(sizeof(Enum) == sizeof(sal_Int32), "binary compatibility test failed: (sizeof(Enum) == sizeof(sal_Int32))");
+// any
+static_assert(sizeof(void *) >= sizeof(sal_Int32), "binary compatibility test failed: (sizeof(void *) >= sizeof(sal_Int32))");
+static_assert(sizeof(uno_Any) == sizeof(void *) * 3, "binary compatibility test failed: (sizeof(uno_Any) == sizeof(void *) * 3");
+static_assert(offsetof(uno_Any, pType) == 0, "offsetof(uno_Any, pType) != 0");
+static_assert(offsetof(uno_Any, pData) == 1 * sizeof(void *), "offsetof(uno_Any, pTData) != (1 * sizeof(void *))");
+static_assert(offsetof(uno_Any, pReserved) == 2 * sizeof(void *), "offsetof(uno_Any, pReserved) != (2 * sizeof(void *))");
+// string
+static_assert(sizeof(OUString) == sizeof(rtl_uString *), "binary compatibility test failed: sizeof(OUString) != sizeof(rtl_uString *)");
+// struct
+#if SAL_TYPES_ALIGNMENT8 == 2
+static_assert(sizeof(M) == 6, "sizeof(M) != 6");
+static_assert(sizeof(N) == 8, "sizeof(N) != 8");
+static_assert(sizeof(N2) == 8, "sizeof(N2) != 8");
+static_assert(offsetof(N2, p) == 6, "offsetof(N2, p) != 6");
+#else
+static_assert(sizeof(M) == 8, "sizeof(M) != 8");
+static_assert(sizeof(N) == 12, "sizeof(N) != 12");
+static_assert(sizeof(N2) == 12, "sizeof(N2) != 12");
+static_assert(offsetof(N2, p) == 8, "offsetof(N2, p) != 8");
+#endif
+static_assert(offsetof(M, o) == 4, "offsetof(M, o) != 4");
+
+#if SAL_TYPES_ALIGNMENT8 == 2
+static_assert(sizeof(O) == 16, "sizeof(O) != 16");
+#elif SAL_TYPES_ALIGNMENT8 == 4
+static_assert(sizeof(O) == 20, "sizeof(O) != 20");
+#elif SAL_TYPES_ALIGNMENT8 == 8
+static_assert(sizeof(O) == 24, "sizeof(O) != 24");
+#else
+# error unexpected alignment of 8 byte types
+#endif
+
+#if SAL_TYPES_ALIGNMENT8 == 2
+static_assert(sizeof(C2) == 6, "sizeof(C2) != 6");
+static_assert(sizeof(D) == 6, "sizeof(D) != 6");
+static_assert(offsetof(D, e) == 2, "offsetof(D, e) != 2");
+static_assert(offsetof(E, e) == 6, "offsetof(E, e) != 6");
+#else
+static_assert(sizeof(C2) == 8, "sizeof(C2) != 8");
+static_assert(sizeof(D) == 8, "sizeof(D) != 8");
+static_assert(offsetof(D, e) == 4, "offsetof(D, e) != 4");
+static_assert(offsetof(E, e) == 8, "offsetof(E, e) != 8");
+#endif
+
+static_assert(sizeof(C1) == 2, "sizeof(C1) != 2");
+static_assert(offsetof(E, d) == 4, "offsetof(E, d) != 4");
+
+#if SAL_TYPES_ALIGNMENT8 == 2
+static_assert(sizeof(C3) == 18, "sizeof(C3) != 18");
+static_assert(sizeof(C4) == 30, "sizeof(C4) != 30");
+static_assert(sizeof(C5) == 40, "sizeof(C5) != 40");
+static_assert(sizeof(C6) == 44, "sizeof(C6) != 44");
+
+static_assert(sizeof(O2) == 18, "sizeof(O2) != 18");
+#elif SAL_TYPES_ALIGNMENT8 == 4
+static_assert(sizeof(C3) == 20, "sizeof(C3) != 20");
+static_assert(sizeof(C4) == 32, "sizeof(C4) != 32");
+static_assert(sizeof(C5) == 44, "sizeof(C5) != 44");
+static_assert(sizeof(C6) == 52, "sizeof(C6) != 52");
+
+static_assert(sizeof(O2) == 24, "sizeof(O2) != 24");
+#elif SAL_TYPES_ALIGNMENT8 == 8
+static_assert(sizeof(C3) == 24, "sizeof(C3) != 24");
+static_assert(sizeof(C4) == 40, "sizeof(C4) != 40");
+static_assert(sizeof(C5) == 56, "sizeof(C5) != 56");
+static_assert(sizeof(C6) == 72, "sizeof(C6) != 72");
+
+static_assert(sizeof(O2) == 32, "sizeof(O2) != 32");
+#else
+# error unexpected alignment of 8 byte types
+#endif
+
+static_assert(sizeof(Char3) == 3, "sizeof(Char3) != 3");
+
+#if SAL_TYPES_ALIGNMENT8 == 2
+// max alignment is 2
+static_assert(sizeof(P) == 16, "sizeof(P) != 16");
+#elif SAL_TYPES_ALIGNMENT8 == 4
+// max alignment is 4
+static_assert(sizeof(P) == 20, "sizeof(P) != 20");
+#elif SAL_TYPES_ALIGNMENT8 == 8
+// alignment of P is 8, because of P[] ...
+static_assert(sizeof(P) == 24, "sizeof(P) != 24");
+static_assert(sizeof(second) == sizeof(int), "sizeof(second) != sizeof(int)");
+#else
+# error unexpected alignment of 8 byte types
+#endif
+
+#if OSL_DEBUG_LEVEL > 0 && !defined NDEBUG
+
+#define OFFSET_OF( s, m ) reinterpret_cast< size_t >(reinterpret_cast<char *>(&reinterpret_cast<s *>(16)->m) -16)
+
+class BinaryCompatible_Impl
+{
+public:
+    BinaryCompatible_Impl();
+};
+BinaryCompatible_Impl::BinaryCompatible_Impl()
+{
+    assert(OFFSET_OF(N, p) == 8);
+
+    assert(OFFSET_OF(C2, n2) == 4);
+
+#if SAL_TYPES_ALIGNMENT8 == 2
+    assert(OFFSET_OF(C3, d3) == 6);
+    assert(OFFSET_OF(C3, n3) == 14);
+    assert(OFFSET_OF(C4, n4) == 18);
+    assert(OFFSET_OF(C4, d4) == 22);
+    assert(OFFSET_OF(C5, n5) == 30);
+    assert(OFFSET_OF(C5, b5) == 38);
+    assert(OFFSET_OF(C6, c6) == 2);
+    assert(OFFSET_OF(C6, b6) == 42);
+
+    assert(OFFSET_OF(O2, p2) == 16);
+#elif SAL_TYPES_ALIGNMENT8 == 4
+    assert(OFFSET_OF(C3, d3) == 8);
+    assert(OFFSET_OF(C3, n3) == 16);
+    assert(OFFSET_OF(C4, n4) == 20);
+    assert(OFFSET_OF(C4, d4) == 24);
+    assert(OFFSET_OF(C5, n5) == 32);
+    assert(OFFSET_OF(C5, b5) == 40);
+    assert(OFFSET_OF(C6, c6) == 4);
+    assert(OFFSET_OF(C6, b6) == 48);
+
+    assert(OFFSET_OF(O2, p2) == 20);
+#elif SAL_TYPES_ALIGNMENT8 == 8
+    assert(OFFSET_OF(C3, d3) == 8);
+    assert(OFFSET_OF(C3, n3) == 16);
+    assert(OFFSET_OF(C4, n4) == 24);
+    assert(OFFSET_OF(C4, d4) == 32);
+    assert(OFFSET_OF(C5, n5) == 40);
+    assert(OFFSET_OF(C5, b5) == 48);
+    assert(OFFSET_OF(C6, c6) == 8);
+    assert(OFFSET_OF(C6, b6) == 64);
+
+    assert(OFFSET_OF(O2, p2) == 24);
+#else
+# error unexpected alignment of 8 byte types
+#endif
+
+    assert(OFFSET_OF(Char4, c) == 3);
+}
+
+static BinaryCompatible_Impl aTest;
+
+#endif
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppu/source/uno/constr.hxx b/cppu/source/uno/constr.hxx
new file mode 100644
index 000000000..73d89b915
--- /dev/null
+++ b/cppu/source/uno/constr.hxx
@@ -0,0 +1,141 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef INCLUDED_CPPU_SOURCE_UNO_CONSTR_HXX
+#define INCLUDED_CPPU_SOURCE_UNO_CONSTR_HXX
+
+#include "prim.hxx"
+#include <osl/diagnose.h>
+
+namespace cppu
+{
+
+
+//#### construction ################################################################################
+
+
+void defaultConstructStruct(
+    void * pMem,
+    typelib_CompoundTypeDescription * pCompType );
+
+inline void _defaultConstructStruct(
+    void * pMem,
+    typelib_CompoundTypeDescription * pTypeDescr )
+{
+    if (pTypeDescr->pBaseTypeDescription)
+    {
+        defaultConstructStruct( pMem, pTypeDescr->pBaseTypeDescription );
+    }
+
+    typelib_TypeDescriptionReference ** ppTypeRefs = pTypeDescr->ppTypeRefs;
+    sal_Int32 * pMemberOffsets = pTypeDescr->pMemberOffsets;
+    sal_Int32 nDescr = pTypeDescr->nMembers;
+
+    while (nDescr--)
+    {
+        ::uno_type_constructData( static_cast<char *>(pMem) + pMemberOffsets[nDescr], ppTypeRefs[nDescr] );
+    }
+}
+
+
+inline void _defaultConstructData(
+    void * pMem,
+    typelib_TypeDescriptionReference * pType,
+    typelib_TypeDescription * pTypeDescr )
+{
+    switch (pType->eTypeClass)
+    {
+    case typelib_TypeClass_CHAR:
+        *static_cast<sal_Unicode *>(pMem) = '\0';
+        break;
+    case typelib_TypeClass_BOOLEAN:
+        *static_cast<sal_Bool *>(pMem) = false;
+        break;
+    case typelib_TypeClass_BYTE:
+        *static_cast<sal_Int8 *>(pMem) = 0;
+        break;
+    case typelib_TypeClass_SHORT:
+    case typelib_TypeClass_UNSIGNED_SHORT:
+        *static_cast<sal_Int16 *>(pMem) = 0;
+        break;
+    case typelib_TypeClass_LONG:
+    case typelib_TypeClass_UNSIGNED_LONG:
+        *static_cast<sal_Int32 *>(pMem) = 0;
+        break;
+    case typelib_TypeClass_HYPER:
+    case typelib_TypeClass_UNSIGNED_HYPER:
+        *static_cast<sal_Int64 *>(pMem) = 0;
+        break;
+    case typelib_TypeClass_FLOAT:
+        *static_cast<float *>(pMem) = 0.0;
+        break;
+    case typelib_TypeClass_DOUBLE:
+        *static_cast<double *>(pMem) = 0.0;
+        break;
+    case typelib_TypeClass_STRING:
+        *static_cast<rtl_uString **>(pMem) = nullptr;
+        ::rtl_uString_new( static_cast<rtl_uString **>(pMem) );
+        break;
+    case typelib_TypeClass_TYPE:
+        *static_cast<typelib_TypeDescriptionReference **>(pMem) = _getVoidType();
+        break;
+    case typelib_TypeClass_ANY:
+        CONSTRUCT_EMPTY_ANY( static_cast<uno_Any *>(pMem) );
+        break;
+    case typelib_TypeClass_ENUM:
+        if (pTypeDescr)
+        {
+            *static_cast<sal_Int32 *>(pMem) = reinterpret_cast<typelib_EnumTypeDescription *>(pTypeDescr)->nDefaultEnumValue;
+        }
+        else
+        {
+            TYPELIB_DANGER_GET( &pTypeDescr, pType );
+            *static_cast<sal_Int32 *>(pMem) = reinterpret_cast<typelib_EnumTypeDescription *>(pTypeDescr)->nDefaultEnumValue;
+            TYPELIB_DANGER_RELEASE( pTypeDescr );
+        }
+        break;
+    case typelib_TypeClass_STRUCT:
+    case typelib_TypeClass_EXCEPTION:
+        if (pTypeDescr)
+        {
+            _defaultConstructStruct( pMem, reinterpret_cast<typelib_CompoundTypeDescription *>(pTypeDescr) );
+        }
+        else
+        {
+            TYPELIB_DANGER_GET( &pTypeDescr, pType );
+            _defaultConstructStruct( pMem, reinterpret_cast<typelib_CompoundTypeDescription *>(pTypeDescr) );
+            TYPELIB_DANGER_RELEASE( pTypeDescr );
+        }
+        break;
+    case typelib_TypeClass_SEQUENCE:
+        *static_cast<uno_Sequence **>(pMem) = createEmptySequence();
+        break;
+    case typelib_TypeClass_INTERFACE:
+        *static_cast<void **>(pMem) = nullptr; // either cpp or c-uno interface
+        break;
+    default:
+        OSL_ASSERT(false);
+        break;
+    }
+}
+
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppu/source/uno/copy.hxx b/cppu/source/uno/copy.hxx
new file mode 100644
index 000000000..b61973ec0
--- /dev/null
+++ b/cppu/source/uno/copy.hxx
@@ -0,0 +1,658 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef INCLUDED_CPPU_SOURCE_UNO_COPY_HXX
+#define INCLUDED_CPPU_SOURCE_UNO_COPY_HXX
+
+#include "prim.hxx"
+#include "constr.hxx"
+#include <cassert>
+#include <cstddef>
+#include <cstdlib>
+#include <type_traits>
+
+namespace cppu
+{
+
+
+//#### copy construction ###########################################################################
+
+namespace {
+
+// The non-dynamic prefix of sal_Sequence (aka uno_Sequence):
+struct SequencePrefix {
+    sal_Int32 nRefCount;
+    sal_Int32 nElements;
+};
+static_assert(sizeof (SequencePrefix) < sizeof (uno_Sequence));
+static_assert(offsetof(SequencePrefix, nRefCount) == offsetof(uno_Sequence, nRefCount));
+static_assert(
+    std::is_same_v<decltype(SequencePrefix::nRefCount), decltype(uno_Sequence::nRefCount)>);
+static_assert(offsetof(SequencePrefix, nElements) == offsetof(uno_Sequence, nElements));
+static_assert(
+    std::is_same_v<decltype(SequencePrefix::nElements), decltype(uno_Sequence::nElements)>);
+
+}
+
+inline uno_Sequence * allocSeq(
+    sal_Int32 nElementSize, sal_Int32 nElements )
+{
+    OSL_ASSERT( nElements >= 0 && nElementSize >= 0 );
+    uno_Sequence * pSeq = nullptr;
+    sal_uInt32 nSize = calcSeqMemSize( nElementSize, nElements );
+    if (nSize > 0)
+    {
+        pSeq = static_cast<uno_Sequence *>(std::malloc( nSize ));
+        if (pSeq != nullptr)
+        {
+            // header init, going via SequencePrefix to avoid UBSan insufficient-object-size
+            // warnings when `nElements == 0` and thus `nSize < sizeof (uno_Sequence)`:
+            auto const header = reinterpret_cast<SequencePrefix *>(pSeq);
+            header->nRefCount = 1;
+            header->nElements = nElements;
+        }
+    }
+    return pSeq;
+}
+
+
+void copyConstructStruct(
+    void * pDest, void * pSource,
+    typelib_CompoundTypeDescription * pTypeDescr,
+    uno_AcquireFunc acquire, uno_Mapping * mapping );
+
+inline void _copyConstructStruct(
+    void * pDest, void * pSource,
+    typelib_CompoundTypeDescription * pTypeDescr,
+    uno_AcquireFunc acquire, uno_Mapping * mapping )
+{
+    if (pTypeDescr->pBaseTypeDescription)
+    {
+        // copy base value
+        copyConstructStruct( pDest, pSource, pTypeDescr->pBaseTypeDescription, acquire, mapping );
+    }
+
+    // then copy members
+    typelib_TypeDescriptionReference ** ppTypeRefs = pTypeDescr->ppTypeRefs;
+    sal_Int32 * pMemberOffsets = pTypeDescr->pMemberOffsets;
+    sal_Int32 nDescr = pTypeDescr->nMembers;
+
+    if (mapping)
+    {
+        while (nDescr--)
+        {
+            ::uno_type_copyAndConvertData(
+                static_cast<char *>(pDest) + pMemberOffsets[nDescr],
+                static_cast<char *>(pSource) + pMemberOffsets[nDescr],
+                ppTypeRefs[nDescr], mapping );
+        }
+    }
+    else
+    {
+        while (nDescr--)
+        {
+            ::uno_type_copyData(
+                static_cast<char *>(pDest) + pMemberOffsets[nDescr],
+                static_cast<char *>(pSource) + pMemberOffsets[nDescr],
+                ppTypeRefs[nDescr], acquire );
+        }
+    }
+}
+
+
+uno_Sequence * copyConstructSequence(
+    uno_Sequence * pSource,
+    typelib_TypeDescriptionReference * pElementType,
+    uno_AcquireFunc acquire, uno_Mapping * mapping );
+
+
+inline void _copyConstructAnyFromData(
+    uno_Any * pDestAny, void * pSource,
+    typelib_TypeDescriptionReference * pType, typelib_TypeDescription * pTypeDescr,
+    uno_AcquireFunc acquire, uno_Mapping * mapping )
+{
+    TYPE_ACQUIRE( pType );
+    pDestAny->pType = pType;
+
+    switch (pType->eTypeClass)
+    {
+    case typelib_TypeClass_CHAR:
+        pDestAny->pData = &pDestAny->pReserved;
+        *static_cast<sal_Unicode *>(pDestAny->pData) = *static_cast<sal_Unicode *>(pSource);
+        break;
+    case typelib_TypeClass_BOOLEAN:
+        pDestAny->pData = &pDestAny->pReserved;
+        *static_cast<sal_Bool *>(pDestAny->pData) = bool(*static_cast<sal_Bool *>(pSource));
+        break;
+    case typelib_TypeClass_BYTE:
+        pDestAny->pData = &pDestAny->pReserved;
+        *static_cast<sal_Int8 *>(pDestAny->pData) = *static_cast<sal_Int8 *>(pSource);
+        break;
+    case typelib_TypeClass_SHORT:
+    case typelib_TypeClass_UNSIGNED_SHORT:
+        pDestAny->pData = &pDestAny->pReserved;
+        *static_cast<sal_Int16 *>(pDestAny->pData) = *static_cast<sal_Int16 *>(pSource);
+        break;
+    case typelib_TypeClass_LONG:
+    case typelib_TypeClass_UNSIGNED_LONG:
+        pDestAny->pData = &pDestAny->pReserved;
+        *static_cast<sal_Int32 *>(pDestAny->pData) = *static_cast<sal_Int32 *>(pSource);
+        break;
+    case typelib_TypeClass_HYPER:
+    case typelib_TypeClass_UNSIGNED_HYPER:
+        if (sizeof(void *) >= sizeof(sal_Int64))
+            pDestAny->pData = &pDestAny->pReserved;
+        else
+            pDestAny->pData = std::malloc( sizeof(sal_Int64) );
+        assert(pDestAny->pData);
+        *static_cast<sal_Int64 *>(pDestAny->pData) = *static_cast<sal_Int64 *>(pSource);
+        break;
+    case typelib_TypeClass_FLOAT:
+        if (sizeof(void *) >= sizeof(float))
+            pDestAny->pData = &pDestAny->pReserved;
+        else
+            pDestAny->pData = std::malloc( sizeof(float) );
+        assert(pDestAny->pData);
+        *static_cast<float *>(pDestAny->pData) = *static_cast<float *>(pSource);
+        break;
+    case typelib_TypeClass_DOUBLE:
+        if (sizeof(void *) >= sizeof(double))
+            pDestAny->pData = &pDestAny->pReserved;
+        else
+            pDestAny->pData = std::malloc( sizeof(double) );
+        assert(pDestAny->pData);
+        *static_cast<double *>(pDestAny->pData) = *static_cast<double *>(pSource);
+        break;
+    case typelib_TypeClass_STRING:
+        ::rtl_uString_acquire( *static_cast<rtl_uString **>(pSource) );
+        pDestAny->pData = &pDestAny->pReserved;
+        *static_cast<rtl_uString **>(pDestAny->pData) = *static_cast<rtl_uString **>(pSource);
+        break;
+    case typelib_TypeClass_TYPE:
+        TYPE_ACQUIRE( *static_cast<typelib_TypeDescriptionReference **>(pSource) );
+        pDestAny->pData = &pDestAny->pReserved;
+        *static_cast<typelib_TypeDescriptionReference **>(pDestAny->pData) = *static_cast<typelib_TypeDescriptionReference **>(pSource);
+        break;
+    case typelib_TypeClass_ANY:
+        OSL_FAIL( "### unexpected nested any!" );
+        break;
+    case typelib_TypeClass_ENUM:
+        pDestAny->pData = &pDestAny->pReserved;
+        // enum is forced to 32bit long
+        *static_cast<sal_Int32 *>(pDestAny->pData) = *static_cast<sal_Int32 *>(pSource);
+        break;
+    case typelib_TypeClass_STRUCT:
+    case typelib_TypeClass_EXCEPTION:
+        if (pTypeDescr)
+        {
+            pDestAny->pData = std::malloc( pTypeDescr->nSize );
+            _copyConstructStruct(
+                pDestAny->pData, pSource,
+                reinterpret_cast<typelib_CompoundTypeDescription *>(pTypeDescr),
+                acquire, mapping );
+        }
+        else
+        {
+            TYPELIB_DANGER_GET( &pTypeDescr, pType );
+            pDestAny->pData = std::malloc( pTypeDescr->nSize );
+            _copyConstructStruct(
+                pDestAny->pData, pSource,
+                reinterpret_cast<typelib_CompoundTypeDescription *>(pTypeDescr),
+                acquire, mapping );
+            TYPELIB_DANGER_RELEASE( pTypeDescr );
+        }
+        break;
+    case typelib_TypeClass_SEQUENCE:
+        pDestAny->pData = &pDestAny->pReserved;
+        if (pTypeDescr)
+        {
+            *static_cast<uno_Sequence **>(pDestAny->pData) = copyConstructSequence(
+                *static_cast<uno_Sequence **>(pSource),
+                reinterpret_cast<typelib_IndirectTypeDescription *>(pTypeDescr)->pType,
+                acquire, mapping );
+        }
+        else
+        {
+            TYPELIB_DANGER_GET( &pTypeDescr, pType );
+            *static_cast<uno_Sequence **>(pDestAny->pData) = copyConstructSequence(
+                *static_cast<uno_Sequence **>(pSource),
+                reinterpret_cast<typelib_IndirectTypeDescription *>(pTypeDescr)->pType,
+                acquire, mapping );
+            TYPELIB_DANGER_RELEASE( pTypeDescr );
+        }
+        break;
+    case typelib_TypeClass_INTERFACE:
+        pDestAny->pData = &pDestAny->pReserved;
+        if (mapping)
+        {
+            pDestAny->pReserved = _map( *static_cast<void **>(pSource), pType, pTypeDescr, mapping );
+        }
+        else
+        {
+            pDestAny->pReserved = *static_cast<void **>(pSource);
+            _acquire( pDestAny->pReserved, acquire );
+        }
+        break;
+    default:
+        OSL_ASSERT(false);
+        break;
+    }
+}
+
+inline void _copyConstructAny(
+    uno_Any * pDestAny, void * pSource,
+    typelib_TypeDescriptionReference * pType, typelib_TypeDescription * pTypeDescr,
+    uno_AcquireFunc acquire, uno_Mapping * mapping )
+{
+    if (typelib_TypeClass_VOID == pType->eTypeClass)
+    {
+        CONSTRUCT_EMPTY_ANY( pDestAny );
+    }
+    else
+    {
+        if (typelib_TypeClass_ANY == pType->eTypeClass)
+        {
+            if (pSource)
+            {
+                pType = static_cast<uno_Any *>(pSource)->pType;
+                if (typelib_TypeClass_VOID == pType->eTypeClass)
+                {
+                    CONSTRUCT_EMPTY_ANY( pDestAny );
+                    return;
+                }
+                pTypeDescr = nullptr;
+                pSource = static_cast<uno_Any *>(pSource)->pData;
+            }
+            else
+            {
+                CONSTRUCT_EMPTY_ANY( pDestAny );
+                return;
+            }
+        }
+        if (pSource)
+        {
+            _copyConstructAnyFromData( pDestAny, pSource, pType, pTypeDescr, acquire, mapping );
+        }
+        else // default construct
+        {
+            TYPE_ACQUIRE( pType );
+            pDestAny->pType = pType;
+            switch (pType->eTypeClass)
+            {
+            case typelib_TypeClass_CHAR:
+                pDestAny->pData = &pDestAny->pReserved;
+                *static_cast<sal_Unicode *>(pDestAny->pData) = '\0';
+                break;
+            case typelib_TypeClass_BOOLEAN:
+                pDestAny->pData = &pDestAny->pReserved;
+                *static_cast<sal_Bool *>(pDestAny->pData) = false;
+                break;
+            case typelib_TypeClass_BYTE:
+                pDestAny->pData = &pDestAny->pReserved;
+                *static_cast<sal_Int8 *>(pDestAny->pData) = 0;
+                break;
+            case typelib_TypeClass_SHORT:
+            case typelib_TypeClass_UNSIGNED_SHORT:
+                pDestAny->pData = &pDestAny->pReserved;
+                *static_cast<sal_Int16 *>(pDestAny->pData) = 0;
+                break;
+            case typelib_TypeClass_LONG:
+            case typelib_TypeClass_UNSIGNED_LONG:
+                pDestAny->pData = &pDestAny->pReserved;
+                *static_cast<sal_Int32 *>(pDestAny->pData) = 0;
+                break;
+            case typelib_TypeClass_HYPER:
+            case typelib_TypeClass_UNSIGNED_HYPER:
+                if (sizeof(void *) >= sizeof(sal_Int64))
+                    pDestAny->pData = &pDestAny->pReserved;
+                else
+                    pDestAny->pData = std::malloc( sizeof(sal_Int64) );
+                assert(pDestAny->pData);
+                *static_cast<sal_Int64 *>(pDestAny->pData) = 0;
+                break;
+            case typelib_TypeClass_FLOAT:
+                if (sizeof(void *) >= sizeof(float))
+                    pDestAny->pData = &pDestAny->pReserved;
+                else
+                    pDestAny->pData = std::malloc( sizeof(float) );
+                assert(pDestAny->pData);
+                *static_cast<float *>(pDestAny->pData) = 0.0;
+                break;
+            case typelib_TypeClass_DOUBLE:
+                if (sizeof(void *) >= sizeof(double))
+                    pDestAny->pData = &pDestAny->pReserved;
+                else
+                    pDestAny->pData = std::malloc( sizeof(double) );
+                assert(pDestAny->pData);
+                *static_cast<double *>(pDestAny->pData) = 0.0;
+                break;
+            case typelib_TypeClass_STRING:
+                pDestAny->pData = &pDestAny->pReserved;
+                *static_cast<rtl_uString **>(pDestAny->pData) = nullptr;
+                ::rtl_uString_new( static_cast<rtl_uString **>(pDestAny->pData) );
+                break;
+            case typelib_TypeClass_TYPE:
+                pDestAny->pData = &pDestAny->pReserved;
+                *static_cast<typelib_TypeDescriptionReference **>(pDestAny->pData) = _getVoidType();
+                break;
+            case typelib_TypeClass_ENUM:
+                pDestAny->pData = &pDestAny->pReserved;
+                if (pTypeDescr)
+                {
+                    *static_cast<sal_Int32 *>(pDestAny->pData) = reinterpret_cast<typelib_EnumTypeDescription *>(pTypeDescr)->nDefaultEnumValue;
+                }
+                else
+                {
+                    TYPELIB_DANGER_GET( &pTypeDescr, pType );
+                    *static_cast<sal_Int32 *>(pDestAny->pData) = reinterpret_cast<typelib_EnumTypeDescription *>(pTypeDescr)->nDefaultEnumValue;
+                    TYPELIB_DANGER_RELEASE( pTypeDescr );
+                }
+                break;
+            case typelib_TypeClass_STRUCT:
+            case typelib_TypeClass_EXCEPTION:
+                if (pTypeDescr)
+                {
+                    pDestAny->pData = std::malloc( pTypeDescr->nSize );
+                    _defaultConstructStruct(
+                        pDestAny->pData, reinterpret_cast<typelib_CompoundTypeDescription *>(pTypeDescr) );
+                }
+                else
+                {
+                    TYPELIB_DANGER_GET( &pTypeDescr, pType );
+                    pDestAny->pData = std::malloc( pTypeDescr->nSize );
+                    _defaultConstructStruct(
+                        pDestAny->pData, reinterpret_cast<typelib_CompoundTypeDescription *>(pTypeDescr) );
+                    TYPELIB_DANGER_RELEASE( pTypeDescr );
+                }
+                break;
+            case typelib_TypeClass_SEQUENCE:
+                pDestAny->pData = &pDestAny->pReserved;
+                *static_cast<uno_Sequence **>(pDestAny->pData) = createEmptySequence();
+                break;
+            case typelib_TypeClass_INTERFACE:
+                pDestAny->pData = &pDestAny->pReserved;
+                pDestAny->pReserved = nullptr; // either cpp or c-uno interface
+                break;
+            default:
+                OSL_ASSERT(false);
+                break;
+            }
+        }
+    }
+}
+
+inline uno_Sequence * icopyConstructSequence(
+    uno_Sequence * pSource,
+    typelib_TypeDescriptionReference * pElementType,
+    uno_AcquireFunc acquire, uno_Mapping * mapping )
+{
+    typelib_TypeClass eTypeClass = pElementType->eTypeClass;
+    if (!mapping ||
+        (eTypeClass <= typelib_TypeClass_ENUM &&
+         eTypeClass != typelib_TypeClass_ANY))
+    {
+        osl_atomic_increment( &pSource->nRefCount );
+        return pSource;
+    }
+    else // create new sequence
+    {
+        uno_Sequence * pDest;
+        sal_Int32 nElements = pSource->nElements;
+        if (nElements)
+        {
+            switch (eTypeClass)
+            {
+            case typelib_TypeClass_ANY:
+            {
+                pDest = allocSeq( sizeof (uno_Any), nElements );
+                if (pDest != nullptr)
+                {
+                    uno_Any * pDestElements = reinterpret_cast<uno_Any *>(pDest->elements);
+                    uno_Any * pSourceElements = reinterpret_cast<uno_Any *>(pSource->elements);
+                    for ( sal_Int32 nPos = nElements; nPos--; )
+                    {
+                        typelib_TypeDescriptionReference * pType =
+                            pSourceElements[nPos].pType;
+                        if (typelib_TypeClass_VOID == pType->eTypeClass)
+                        {
+                            CONSTRUCT_EMPTY_ANY( &pDestElements[nPos] );
+                        }
+                        else
+                        {
+                            _copyConstructAnyFromData(
+                                &pDestElements[nPos],
+                                pSourceElements[nPos].pData,
+                                pType, nullptr,
+                                acquire, mapping );
+                        }
+                    }
+                }
+                break;
+            }
+            case typelib_TypeClass_STRUCT:
+            case typelib_TypeClass_EXCEPTION:
+            {
+                typelib_TypeDescription * pElementTypeDescr = nullptr;
+                TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
+                sal_Int32 nElementSize = pElementTypeDescr->nSize;
+                char * pSourceElements = pSource->elements;
+                pDest = allocSeq( nElementSize, nElements );
+                if (pDest != nullptr)
+                {
+                    char * pElements = pDest->elements;
+                    for ( sal_Int32 nPos = nElements; nPos--; )
+                    {
+                        _copyConstructStruct(
+                            pElements + (nPos * nElementSize),
+                            pSourceElements + (nPos * nElementSize),
+                            reinterpret_cast<typelib_CompoundTypeDescription *>(
+                                pElementTypeDescr),
+                            acquire, mapping );
+                    }
+                }
+                TYPELIB_DANGER_RELEASE( pElementTypeDescr );
+                break;
+            }
+            case typelib_TypeClass_SEQUENCE: // sequence of sequence
+            {
+                // coverity[suspicious_sizeof] - sizeof(uno_Sequence*) is correct here
+                pDest = allocSeq( sizeof (uno_Sequence *), nElements );
+                if (pDest != nullptr)
+                {
+                    typelib_TypeDescription * pElementTypeDescr = nullptr;
+                    TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
+                    typelib_TypeDescriptionReference * pSeqElementType =
+                        reinterpret_cast<typelib_IndirectTypeDescription *>(
+                            pElementTypeDescr)->pType;
+
+                    uno_Sequence ** pDestElements =
+                        reinterpret_cast<uno_Sequence **>(pDest->elements);
+                    uno_Sequence ** pSourceElements =
+                        reinterpret_cast<uno_Sequence **>(pSource->elements);
+                    for ( sal_Int32 nPos = nElements; nPos--; )
+                    {
+                        uno_Sequence * pNew = copyConstructSequence(
+                            pSourceElements[nPos],
+                            pSeqElementType,
+                            acquire, mapping );
+                        OSL_ASSERT( pNew != nullptr );
+                        // ought never be a memory allocation problem,
+                        // because of reference counted sequence handles
+                        pDestElements[ nPos ] = pNew;
+                    }
+
+                    TYPELIB_DANGER_RELEASE( pElementTypeDescr );
+                }
+                break;
+            }
+            case typelib_TypeClass_INTERFACE:
+            {
+                pDest = allocSeq( sizeof (void *), nElements );
+                if (pDest != nullptr)
+                {
+                    char * pElements = pDest->elements;
+                    void ** pSourceElements = reinterpret_cast<void **>(pSource->elements);
+                    typelib_TypeDescription * pElementTypeDescr = nullptr;
+                    TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
+                    for ( sal_Int32 nPos = nElements; nPos--; )
+                    {
+                        reinterpret_cast<void **>(pElements)[nPos] = nullptr;
+                        if (pSourceElements[nPos])
+                        {
+                            (*mapping->mapInterface)(
+                                mapping, reinterpret_cast<void **>(pElements) + nPos,
+                                pSourceElements[nPos],
+                                reinterpret_cast<typelib_InterfaceTypeDescription *>(
+                                    pElementTypeDescr) );
+                        }
+                    }
+                    TYPELIB_DANGER_RELEASE( pElementTypeDescr );
+                }
+                break;
+            }
+            default:
+                OSL_FAIL( "### unexpected sequence element type!" );
+                pDest = nullptr;
+                break;
+            }
+        }
+        else // empty sequence
+        {
+            pDest = allocSeq( 0, 0 );
+        }
+
+        return pDest;
+    }
+}
+
+
+inline void _copyConstructData(
+    void * pDest, void * pSource,
+    typelib_TypeDescriptionReference * pType, typelib_TypeDescription * pTypeDescr,
+    uno_AcquireFunc acquire, uno_Mapping * mapping )
+{
+    switch (pType->eTypeClass)
+    {
+    case typelib_TypeClass_CHAR:
+        *static_cast<sal_Unicode *>(pDest) = *static_cast<sal_Unicode *>(pSource);
+        break;
+    case typelib_TypeClass_BOOLEAN:
+        *static_cast<sal_Bool *>(pDest) = bool(*static_cast<sal_Bool *>(pSource));
+        break;
+    case typelib_TypeClass_BYTE:
+        *static_cast<sal_Int8 *>(pDest) = *static_cast<sal_Int8 *>(pSource);
+        break;
+    case typelib_TypeClass_SHORT:
+    case typelib_TypeClass_UNSIGNED_SHORT:
+        *static_cast<sal_Int16 *>(pDest) = *static_cast<sal_Int16 *>(pSource);
+        break;
+    case typelib_TypeClass_LONG:
+    case typelib_TypeClass_UNSIGNED_LONG:
+        *static_cast<sal_Int32 *>(pDest) = *static_cast<sal_Int32 *>(pSource);
+        break;
+    case typelib_TypeClass_HYPER:
+    case typelib_TypeClass_UNSIGNED_HYPER:
+        *static_cast<sal_Int64 *>(pDest) = *static_cast<sal_Int64 *>(pSource);
+        break;
+    case typelib_TypeClass_FLOAT:
+        *static_cast<float *>(pDest) = *static_cast<float *>(pSource);
+        break;
+    case typelib_TypeClass_DOUBLE:
+        *static_cast<double *>(pDest) = *static_cast<double *>(pSource);
+        break;
+    case typelib_TypeClass_STRING:
+        ::rtl_uString_acquire( *static_cast<rtl_uString **>(pSource) );
+        *static_cast<rtl_uString **>(pDest) = *static_cast<rtl_uString **>(pSource);
+        break;
+    case typelib_TypeClass_TYPE:
+        TYPE_ACQUIRE( *static_cast<typelib_TypeDescriptionReference **>(pSource) );
+        *static_cast<typelib_TypeDescriptionReference **>(pDest) = *static_cast<typelib_TypeDescriptionReference **>(pSource);
+        break;
+    case typelib_TypeClass_ANY:
+        _copyConstructAny(
+            static_cast<uno_Any *>(pDest), static_cast<uno_Any *>(pSource)->pData,
+            static_cast<uno_Any *>(pSource)->pType, nullptr,
+            acquire, mapping );
+        break;
+    case typelib_TypeClass_ENUM:
+        *static_cast<sal_Int32 *>(pDest) = *static_cast<sal_Int32 *>(pSource);
+        break;
+    case typelib_TypeClass_STRUCT:
+    case typelib_TypeClass_EXCEPTION:
+        if (pTypeDescr)
+        {
+            _copyConstructStruct(
+                pDest, pSource,
+                reinterpret_cast<typelib_CompoundTypeDescription *>(pTypeDescr),
+                acquire, mapping );
+        }
+        else
+        {
+            TYPELIB_DANGER_GET( &pTypeDescr, pType );
+            _copyConstructStruct(
+                pDest, pSource,
+                reinterpret_cast<typelib_CompoundTypeDescription *>(pTypeDescr),
+                acquire, mapping );
+            TYPELIB_DANGER_RELEASE( pTypeDescr );
+        }
+        break;
+    case typelib_TypeClass_SEQUENCE:
+        if (mapping)
+        {
+            if (pTypeDescr)
+            {
+                *static_cast<uno_Sequence **>(pDest) = icopyConstructSequence(
+                    *static_cast<uno_Sequence **>(pSource),
+                    reinterpret_cast<typelib_IndirectTypeDescription *>(pTypeDescr)->pType,
+                    acquire, mapping );
+            }
+            else
+            {
+                TYPELIB_DANGER_GET( &pTypeDescr, pType );
+                *static_cast<uno_Sequence **>(pDest) = icopyConstructSequence(
+                    *static_cast<uno_Sequence **>(pSource),
+                    reinterpret_cast<typelib_IndirectTypeDescription *>(pTypeDescr)->pType,
+                    acquire, mapping );
+                TYPELIB_DANGER_RELEASE( pTypeDescr );
+            }
+        }
+        else
+        {
+            osl_atomic_increment( &(*static_cast<uno_Sequence **>(pSource))->nRefCount );
+            *static_cast<uno_Sequence **>(pDest) = *static_cast<uno_Sequence **>(pSource);
+        }
+        break;
+    case typelib_TypeClass_INTERFACE:
+        if (mapping)
+            *static_cast<void **>(pDest) = _map( *static_cast<void **>(pSource), pType, pTypeDescr, mapping );
+        else
+        {
+            *static_cast<void **>(pDest) = *static_cast<void **>(pSource);
+            _acquire( *static_cast<void **>(pDest), acquire );
+        }
+        break;
+    default:
+        break;
+    }
+}
+
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppu/source/uno/data.cxx b/cppu/source/uno/data.cxx
new file mode 100644
index 000000000..339e650fe
--- /dev/null
+++ b/cppu/source/uno/data.cxx
@@ -0,0 +1,316 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+
+#include <sal/log.hxx>
+#include <uno/data.h>
+
+#include "constr.hxx"
+#include "destr.hxx"
+#include "copy.hxx"
+#include "assign.hxx"
+#include "eq.hxx"
+
+using namespace ::cppu;
+
+namespace cppu
+{
+
+// Sequence<>() (default ctor) relies on this being static:
+uno_Sequence g_emptySeq = { 1, 0, { 0 } };
+typelib_TypeDescriptionReference * g_pVoidType = nullptr;
+
+
+void * binuno_queryInterface( void * pUnoI, typelib_TypeDescriptionReference * pDestType )
+{
+    // init queryInterface() td
+    static typelib_TypeDescription* g_pQITD = []() {
+        typelib_TypeDescriptionReference* type_XInterface
+            = *typelib_static_type_getByTypeClass(typelib_TypeClass_INTERFACE);
+        typelib_InterfaceTypeDescription* pTXInterfaceDescr = nullptr;
+        TYPELIB_DANGER_GET(reinterpret_cast<typelib_TypeDescription**>(&pTXInterfaceDescr),
+                           type_XInterface);
+        assert(pTXInterfaceDescr->ppAllMembers);
+        typelib_TypeDescription* pQITD = nullptr;
+        typelib_typedescriptionreference_getDescription(&pQITD,
+                                                        pTXInterfaceDescr->ppAllMembers[0]);
+        // coverity[callee_ptr_arith] - not a bug
+        TYPELIB_DANGER_RELEASE(&pTXInterfaceDescr->aBase);
+        return pQITD;
+    }();
+
+    uno_Any aRet, aExc;
+    uno_Any * pExc = &aExc;
+    void * aArgs[ 1 ];
+    aArgs[ 0 ] = &pDestType;
+    (*static_cast<uno_Interface *>(pUnoI)->pDispatcher)(
+        static_cast<uno_Interface *>(pUnoI), g_pQITD, &aRet, aArgs, &pExc );
+
+    uno_Interface * ret = nullptr;
+    if (nullptr == pExc)
+    {
+        typelib_TypeDescriptionReference * ret_type = aRet.pType;
+        switch (ret_type->eTypeClass)
+        {
+        case typelib_TypeClass_VOID: // common case
+            typelib_typedescriptionreference_release( ret_type );
+            break;
+        case typelib_TypeClass_INTERFACE:
+            // tweaky... avoiding acquire/ release pair
+            typelib_typedescriptionreference_release( ret_type );
+            ret = static_cast<uno_Interface *>(aRet.pReserved); // serving acquired interface
+            break;
+        default:
+            _destructAny( &aRet, nullptr );
+            break;
+        }
+    }
+    else
+    {
+        SAL_WARN(
+            "cppu",
+            "exception occurred querying for interface "
+                << OUString(pDestType->pTypeName) << ": ["
+                << OUString(pExc->pType->pTypeName) << "] "
+                << *static_cast<OUString const *>(pExc->pData));
+                    // Message is very first member
+        uno_any_destruct( pExc, nullptr );
+    }
+    return ret;
+}
+
+
+void defaultConstructStruct(
+    void * pMem,
+    typelib_CompoundTypeDescription * pCompType )
+{
+    _defaultConstructStruct( pMem, pCompType );
+}
+
+void copyConstructStruct(
+    void * pDest, void * pSource,
+    typelib_CompoundTypeDescription * pTypeDescr,
+    uno_AcquireFunc acquire, uno_Mapping * mapping )
+{
+    _copyConstructStruct( pDest, pSource, pTypeDescr, acquire, mapping );
+}
+
+void destructStruct(
+    void * pValue,
+    typelib_CompoundTypeDescription * pTypeDescr,
+    uno_ReleaseFunc release )
+{
+    _destructStruct( pValue, pTypeDescr, release );
+}
+
+bool equalStruct(
+    void * pDest, void *pSource,
+    typelib_CompoundTypeDescription * pTypeDescr,
+    uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
+{
+    return _equalStruct( pDest, pSource, pTypeDescr, queryInterface, release );
+}
+
+bool assignStruct(
+    void * pDest, void * pSource,
+    typelib_CompoundTypeDescription * pTypeDescr,
+    uno_QueryInterfaceFunc queryInterface, uno_AcquireFunc acquire, uno_ReleaseFunc release )
+{
+    return _assignStruct( pDest, pSource, pTypeDescr, queryInterface, acquire, release );
+}
+
+
+uno_Sequence * copyConstructSequence(
+    uno_Sequence * pSource,
+    typelib_TypeDescriptionReference * pElementType,
+    uno_AcquireFunc acquire, uno_Mapping * mapping )
+{
+    return icopyConstructSequence( pSource, pElementType, acquire, mapping );
+}
+
+
+void destructSequence(
+    uno_Sequence * pSequence,
+    typelib_TypeDescriptionReference * pType,
+    typelib_TypeDescription * pTypeDescr,
+    uno_ReleaseFunc release )
+{
+    idestructSequence( pSequence, pType, pTypeDescr, release );
+}
+
+
+bool equalSequence(
+    uno_Sequence * pDest, uno_Sequence * pSource,
+    typelib_TypeDescriptionReference * pElementType,
+    uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
+{
+    return _equalSequence( pDest, pSource, pElementType, queryInterface, release );
+}
+
+}
+
+extern "C"
+{
+
+void SAL_CALL uno_type_constructData(
+    void * pMem, typelib_TypeDescriptionReference * pType )
+    SAL_THROW_EXTERN_C()
+{
+    _defaultConstructData( pMem, pType, nullptr );
+}
+
+void SAL_CALL uno_constructData(
+    void * pMem, typelib_TypeDescription * pTypeDescr )
+    SAL_THROW_EXTERN_C()
+{
+    _defaultConstructData( pMem, pTypeDescr->pWeakRef, pTypeDescr );
+}
+
+void SAL_CALL uno_type_destructData(
+    void * pValue, typelib_TypeDescriptionReference * pType,
+    uno_ReleaseFunc release )
+    SAL_THROW_EXTERN_C()
+{
+    _destructData( pValue, pType, nullptr, release );
+}
+
+void SAL_CALL uno_destructData(
+    void * pValue,
+    typelib_TypeDescription * pTypeDescr,
+    uno_ReleaseFunc release )
+    SAL_THROW_EXTERN_C()
+{
+    _destructData( pValue, pTypeDescr->pWeakRef, pTypeDescr, release );
+}
+
+void SAL_CALL uno_type_copyData(
+    void * pDest, void * pSource,
+    typelib_TypeDescriptionReference * pType,
+    uno_AcquireFunc acquire )
+    SAL_THROW_EXTERN_C()
+{
+    _copyConstructData( pDest, pSource, pType, nullptr, acquire, nullptr );
+}
+
+void SAL_CALL uno_copyData(
+    void * pDest, void * pSource,
+    typelib_TypeDescription * pTypeDescr,
+    uno_AcquireFunc acquire )
+    SAL_THROW_EXTERN_C()
+{
+    _copyConstructData( pDest, pSource, pTypeDescr->pWeakRef, pTypeDescr, acquire, nullptr );
+}
+
+void SAL_CALL uno_type_copyAndConvertData(
+    void * pDest, void * pSource,
+    typelib_TypeDescriptionReference * pType,
+    uno_Mapping * mapping )
+    SAL_THROW_EXTERN_C()
+{
+    _copyConstructData( pDest, pSource, pType, nullptr, nullptr, mapping );
+}
+
+void SAL_CALL uno_copyAndConvertData(
+    void * pDest, void * pSource,
+    typelib_TypeDescription * pTypeDescr,
+    uno_Mapping * mapping )
+    SAL_THROW_EXTERN_C()
+{
+    _copyConstructData( pDest, pSource, pTypeDescr->pWeakRef, pTypeDescr, nullptr, mapping );
+}
+
+sal_Bool SAL_CALL uno_type_equalData(
+    void * pVal1, typelib_TypeDescriptionReference * pVal1Type,
+    void * pVal2, typelib_TypeDescriptionReference * pVal2Type,
+    uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
+    SAL_THROW_EXTERN_C()
+{
+    return _equalData(
+        pVal1, pVal1Type, nullptr,
+        pVal2, pVal2Type,
+        queryInterface, release );
+}
+
+sal_Bool SAL_CALL uno_equalData(
+    void * pVal1, typelib_TypeDescription * pVal1TD,
+    void * pVal2, typelib_TypeDescription * pVal2TD,
+    uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
+    SAL_THROW_EXTERN_C()
+{
+    return _equalData(
+        pVal1, pVal1TD->pWeakRef, pVal1TD,
+        pVal2, pVal2TD->pWeakRef,
+        queryInterface, release );
+}
+
+sal_Bool SAL_CALL uno_type_assignData(
+    void * pDest, typelib_TypeDescriptionReference * pDestType,
+    void * pSource, typelib_TypeDescriptionReference * pSourceType,
+    uno_QueryInterfaceFunc queryInterface, uno_AcquireFunc acquire, uno_ReleaseFunc release )
+    SAL_THROW_EXTERN_C()
+{
+    return _assignData(
+        pDest, pDestType, nullptr,
+        pSource, pSourceType, nullptr,
+        queryInterface, acquire, release );
+}
+
+sal_Bool SAL_CALL uno_assignData(
+    void * pDest, typelib_TypeDescription * pDestTD,
+    void * pSource, typelib_TypeDescription * pSourceTD,
+    uno_QueryInterfaceFunc queryInterface, uno_AcquireFunc acquire, uno_ReleaseFunc release )
+    SAL_THROW_EXTERN_C()
+{
+    return _assignData(
+        pDest, pDestTD->pWeakRef, pDestTD,
+        pSource, pSourceTD->pWeakRef, pSourceTD,
+        queryInterface, acquire, release );
+}
+
+sal_Bool SAL_CALL uno_type_isAssignableFromData(
+    typelib_TypeDescriptionReference * pAssignable,
+    void * pFrom, typelib_TypeDescriptionReference * pFromType,
+    uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
+    SAL_THROW_EXTERN_C()
+{
+    if (::typelib_typedescriptionreference_isAssignableFrom( pAssignable, pFromType ))
+        return true;
+    if (typelib_TypeClass_INTERFACE != pFromType->eTypeClass ||
+        typelib_TypeClass_INTERFACE != pAssignable->eTypeClass)
+    {
+        return false;
+    }
+
+    // query
+    if (nullptr == pFrom)
+        return false;
+    void * pInterface = *static_cast<void **>(pFrom);
+    if (nullptr == pInterface)
+        return false;
+
+    if (nullptr == queryInterface)
+        queryInterface = binuno_queryInterface;
+    void * p = (*queryInterface)( pInterface, pAssignable );
+    _release( p, release );
+    return (nullptr != p);
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppu/source/uno/destr.hxx b/cppu/source/uno/destr.hxx
new file mode 100644
index 000000000..1b964e36a
--- /dev/null
+++ b/cppu/source/uno/destr.hxx
@@ -0,0 +1,355 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef INCLUDED_CPPU_SOURCE_UNO_DESTR_HXX
+#define INCLUDED_CPPU_SOURCE_UNO_DESTR_HXX
+
+#include <sal/config.h>
+#include <osl/diagnose.h>
+
+#include <cassert>
+#include <cstdlib>
+
+#include "prim.hxx"
+
+namespace cppu
+{
+
+
+//#### destruction #################################################################################
+
+
+void destructStruct(
+    void * pValue,
+    typelib_CompoundTypeDescription * pTypeDescr,
+    uno_ReleaseFunc release );
+
+inline void _destructStruct(
+    void * pValue,
+    typelib_CompoundTypeDescription * pTypeDescr,
+    uno_ReleaseFunc release )
+{
+    if (pTypeDescr->pBaseTypeDescription)
+    {
+        destructStruct( pValue, pTypeDescr->pBaseTypeDescription, release );
+    }
+
+    typelib_TypeDescriptionReference ** ppTypeRefs = pTypeDescr->ppTypeRefs;
+    sal_Int32 * pMemberOffsets = pTypeDescr->pMemberOffsets;
+    sal_Int32 nDescr = pTypeDescr->nMembers;
+    while (nDescr--)
+    {
+        ::uno_type_destructData(
+            static_cast<char *>(pValue) + pMemberOffsets[nDescr],
+            ppTypeRefs[nDescr], release );
+    }
+}
+
+
+void destructSequence(
+    uno_Sequence * pSequence,
+    typelib_TypeDescriptionReference * pType,
+    typelib_TypeDescription * pTypeDescr,
+    uno_ReleaseFunc release );
+
+
+inline void _destructAny(
+    uno_Any * pAny,
+    uno_ReleaseFunc release )
+{
+    typelib_TypeDescriptionReference * pType = pAny->pType;
+
+    switch (pType->eTypeClass)
+    {
+    case typelib_TypeClass_HYPER:
+    case typelib_TypeClass_UNSIGNED_HYPER:
+        if (sizeof(void *) < sizeof(sal_Int64))
+        {
+            std::free( pAny->pData );
+        }
+        break;
+    case typelib_TypeClass_FLOAT:
+        if (sizeof(void *) < sizeof(float))
+        {
+            std::free( pAny->pData );
+        }
+        break;
+    case typelib_TypeClass_DOUBLE:
+        if (sizeof(void *) < sizeof(double))
+        {
+            std::free( pAny->pData );
+        }
+        break;
+    case typelib_TypeClass_STRING:
+        ::rtl_uString_release( static_cast<rtl_uString *>(pAny->pReserved) );
+        break;
+    case typelib_TypeClass_TYPE:
+        ::typelib_typedescriptionreference_release(
+            static_cast<typelib_TypeDescriptionReference *>(pAny->pReserved) );
+        break;
+    case typelib_TypeClass_ANY:
+        OSL_FAIL( "### unexpected nested any!" );
+        ::uno_any_destruct( static_cast<uno_Any *>(pAny->pData), release );
+        std::free( pAny->pData );
+        break;
+    case typelib_TypeClass_TYPEDEF:
+        OSL_FAIL( "### unexpected typedef!" );
+        break;
+    case typelib_TypeClass_STRUCT:
+    case typelib_TypeClass_EXCEPTION:
+    {
+        typelib_TypeDescription * pTypeDescr = nullptr;
+        TYPELIB_DANGER_GET( &pTypeDescr, pType );
+        _destructStruct( pAny->pData, reinterpret_cast<typelib_CompoundTypeDescription *>(pTypeDescr), release );
+        TYPELIB_DANGER_RELEASE( pTypeDescr );
+        std::free( pAny->pData );
+        break;
+    }
+    case typelib_TypeClass_SEQUENCE:
+    {
+        destructSequence(
+            static_cast<uno_Sequence *>(pAny->pReserved), pType, nullptr, release );
+        break;
+    }
+    case typelib_TypeClass_INTERFACE:
+        _release( pAny->pReserved, release );
+        break;
+    default:
+        break;
+    }
+#if OSL_DEBUG_LEVEL > 0
+    pAny->pData = reinterpret_cast<void *>(uintptr_t(0xdeadbeef));
+#endif
+
+    ::typelib_typedescriptionreference_release( pType );
+}
+
+inline sal_Int32 idestructElements(
+    void * pElements, typelib_TypeDescriptionReference * pElementType,
+    sal_Int32 nStartIndex, sal_Int32 nStopIndex,
+    uno_ReleaseFunc release )
+{
+    switch (pElementType->eTypeClass)
+    {
+    case typelib_TypeClass_CHAR:
+        return sal_Int32(sizeof(sal_Unicode));
+    case typelib_TypeClass_BOOLEAN:
+        return sal_Int32(sizeof(sal_Bool));
+    case typelib_TypeClass_BYTE:
+        return sal_Int32(sizeof(sal_Int8));
+    case typelib_TypeClass_SHORT:
+    case typelib_TypeClass_UNSIGNED_SHORT:
+        return sal_Int32(sizeof(sal_Int16));
+    case typelib_TypeClass_LONG:
+    case typelib_TypeClass_UNSIGNED_LONG:
+        return sal_Int32(sizeof(sal_Int32));
+    case typelib_TypeClass_HYPER:
+    case typelib_TypeClass_UNSIGNED_HYPER:
+        return sal_Int32(sizeof(sal_Int64));
+    case typelib_TypeClass_FLOAT:
+        return sal_Int32(sizeof(float));
+    case typelib_TypeClass_DOUBLE:
+        return sal_Int32(sizeof(double));
+
+    case typelib_TypeClass_STRING:
+    {
+        rtl_uString ** pDest = static_cast<rtl_uString **>(pElements);
+        for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
+        {
+            ::rtl_uString_release( pDest[nPos] );
+        }
+        return sal_Int32(sizeof(rtl_uString *));
+    }
+    case typelib_TypeClass_TYPE:
+    {
+        typelib_TypeDescriptionReference ** pDest = static_cast<typelib_TypeDescriptionReference **>(pElements);
+        for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
+        {
+            ::typelib_typedescriptionreference_release( pDest[nPos] );
+        }
+        return sal_Int32(sizeof(typelib_TypeDescriptionReference *));
+    }
+    case typelib_TypeClass_ANY:
+    {
+        uno_Any * pDest = static_cast<uno_Any *>(pElements);
+        for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
+        {
+            _destructAny( &pDest[nPos], release );
+        }
+        return sal_Int32(sizeof(uno_Any));
+    }
+    case typelib_TypeClass_ENUM:
+        return sal_Int32(sizeof(sal_Int32));
+    case typelib_TypeClass_STRUCT:
+    case typelib_TypeClass_EXCEPTION:
+    {
+        typelib_TypeDescription * pElementTypeDescr = nullptr;
+        TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
+        sal_Int32 nElementSize = pElementTypeDescr->nSize;
+        for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
+        {
+            _destructStruct(
+                static_cast<char *>(pElements) + (nElementSize * nPos),
+                reinterpret_cast<typelib_CompoundTypeDescription *>(pElementTypeDescr),
+                release );
+        }
+        sal_Int32 nSize = pElementTypeDescr->nSize;
+        TYPELIB_DANGER_RELEASE( pElementTypeDescr );
+        return nSize;
+    }
+    case typelib_TypeClass_SEQUENCE:
+    {
+        typelib_TypeDescription * pElementTypeDescr = nullptr;
+        TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
+        uno_Sequence ** pDest = static_cast<uno_Sequence **>(pElements);
+        for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
+        {
+            destructSequence(
+                pDest[nPos],
+                pElementTypeDescr->pWeakRef, pElementTypeDescr,
+                release );
+        }
+        TYPELIB_DANGER_RELEASE( pElementTypeDescr );
+        return sal_Int32(sizeof(uno_Sequence *));
+    }
+    case typelib_TypeClass_INTERFACE:
+    {
+        if (release)
+        {
+            for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
+            {
+                void * p = static_cast<void **>(pElements)[nPos];
+                if (p)
+                {
+                    (*release)( p );
+                }
+            }
+        }
+        else
+        {
+            for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
+            {
+                uno_Interface * p = static_cast<uno_Interface **>(pElements)[nPos];
+                if (p)
+                {
+                    (*p->release)( p );
+                }
+            }
+        }
+        return sal_Int32(sizeof(void *));
+    }
+    default:
+        OSL_ASSERT(false);
+        return 0;
+    }
+}
+
+inline void idestroySequence(
+    uno_Sequence * pSeq,
+    typelib_TypeDescriptionReference * pType,
+    typelib_TypeDescription * pTypeDescr,
+    uno_ReleaseFunc release )
+{
+    assert(pSeq != nullptr);
+    assert(pSeq->nRefCount == 0);
+    if (pSeq->nElements > 0)
+    {
+        if (pTypeDescr)
+        {
+            idestructElements(
+                pSeq->elements,
+                reinterpret_cast<typelib_IndirectTypeDescription *>(pTypeDescr)->pType, 0,
+                pSeq->nElements, release );
+        }
+        else
+        {
+            TYPELIB_DANGER_GET( &pTypeDescr, pType );
+            idestructElements(
+                pSeq->elements,
+                reinterpret_cast<typelib_IndirectTypeDescription *>(pTypeDescr)->pType, 0,
+                pSeq->nElements, release );
+            TYPELIB_DANGER_RELEASE( pTypeDescr );
+        }
+    }
+    std::free( pSeq );
+}
+
+inline void idestructSequence(
+    uno_Sequence * pSeq,
+    typelib_TypeDescriptionReference * pType,
+    typelib_TypeDescription * pTypeDescr,
+    uno_ReleaseFunc release )
+{
+    if (osl_atomic_decrement( &pSeq->nRefCount ) == 0)
+    {
+        idestroySequence(pSeq, pType, pTypeDescr, release);
+    }
+}
+
+inline void _destructData(
+    void * pValue,
+    typelib_TypeDescriptionReference * pType,
+    typelib_TypeDescription * pTypeDescr,
+    uno_ReleaseFunc release )
+{
+    switch (pType->eTypeClass)
+    {
+    case typelib_TypeClass_STRING:
+        ::rtl_uString_release( *static_cast<rtl_uString **>(pValue) );
+        break;
+    case typelib_TypeClass_TYPE:
+        ::typelib_typedescriptionreference_release( *static_cast<typelib_TypeDescriptionReference **>(pValue) );
+        break;
+    case typelib_TypeClass_ANY:
+        _destructAny( static_cast<uno_Any *>(pValue), release );
+        break;
+    case typelib_TypeClass_TYPEDEF:
+        OSL_FAIL( "### unexpected typedef!" );
+        break;
+    case typelib_TypeClass_STRUCT:
+    case typelib_TypeClass_EXCEPTION:
+        if (pTypeDescr)
+        {
+            _destructStruct( pValue, reinterpret_cast<typelib_CompoundTypeDescription *>(pTypeDescr), release );
+        }
+        else
+        {
+            TYPELIB_DANGER_GET( &pTypeDescr, pType );
+            _destructStruct( pValue, reinterpret_cast<typelib_CompoundTypeDescription *>(pTypeDescr), release );
+            TYPELIB_DANGER_RELEASE( pTypeDescr );
+        }
+        break;
+    case typelib_TypeClass_SEQUENCE:
+    {
+        idestructSequence(
+            *static_cast<uno_Sequence **>(pValue), pType, pTypeDescr, release );
+        break;
+    }
+    case typelib_TypeClass_INTERFACE:
+        _release( *static_cast<void **>(pValue), release );
+        break;
+    default:
+        break;
+    }
+}
+
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppu/source/uno/eq.hxx b/cppu/source/uno/eq.hxx
new file mode 100644
index 000000000..59401ad34
--- /dev/null
+++ b/cppu/source/uno/eq.hxx
@@ -0,0 +1,596 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef INCLUDED_CPPU_SOURCE_UNO_EQ_HXX
+#define INCLUDED_CPPU_SOURCE_UNO_EQ_HXX
+
+#include <cmath>
+#include <string.h>
+
+#include <osl/diagnose.h>
+#include <rtl/ustring.hxx>
+
+#include "prim.hxx"
+
+
+namespace cppu
+{
+
+
+//#### equality ####################################################################################
+
+
+inline bool _equalObject(
+    void * pI1, void * pI2,
+    uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
+{
+    if (pI1 == pI2)
+        return true;
+    if ((nullptr == pI1) || (nullptr == pI2))
+        return false;
+    bool bRet = false;
+
+    typelib_TypeDescriptionReference * type_XInterface =
+        * typelib_static_type_getByTypeClass( typelib_TypeClass_INTERFACE );
+    if (nullptr == queryInterface)
+        queryInterface = binuno_queryInterface;
+    pI1 = (*queryInterface)( pI1, type_XInterface );
+    if (nullptr != pI1)
+    {
+        pI2 = (*queryInterface)( pI2, type_XInterface );
+        if (nullptr != pI2)
+        {
+            bRet = (pI1 == pI2);
+            _release( pI2, release );
+        }
+        _release( pI1, release );
+    }
+    return bRet;
+}
+
+
+bool equalStruct(
+    void * pDest, void *pSource,
+    typelib_CompoundTypeDescription * pTypeDescr,
+    uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release );
+
+inline bool _equalStruct(
+    void * pDest, void *pSource,
+    typelib_CompoundTypeDescription * pTypeDescr,
+    uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
+{
+    if (pTypeDescr->pBaseTypeDescription &&
+        !equalStruct( pDest, pSource, pTypeDescr->pBaseTypeDescription, queryInterface, release ))
+    {
+        return false;
+    }
+
+    typelib_TypeDescriptionReference ** ppTypeRefs = pTypeDescr->ppTypeRefs;
+    sal_Int32 * pMemberOffsets = pTypeDescr->pMemberOffsets;
+    sal_Int32 nDescr = pTypeDescr->nMembers;
+
+    while (nDescr--)
+    {
+        sal_Int32 nOffset = pMemberOffsets[nDescr];
+        if (! ::uno_type_equalData( static_cast<char *>(pDest) + nOffset,
+                                    ppTypeRefs[nDescr],
+                                    static_cast<char *>(pSource) + nOffset,
+                                    ppTypeRefs[nDescr],
+                                    queryInterface, release ))
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+bool equalSequence(
+    uno_Sequence * pDest, uno_Sequence * pSource,
+    typelib_TypeDescriptionReference * pElementType,
+    uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release );
+
+inline bool _equalSequence(
+    uno_Sequence * pDest, uno_Sequence * pSource,
+    typelib_TypeDescriptionReference * pElementType,
+    uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
+{
+    if (pDest == pSource)
+        return true;
+    sal_Int32 nElements = pDest->nElements;
+    if (nElements != pSource->nElements)
+        return false;
+    if (! nElements)
+        return true;
+
+    void * pDestElements = pDest->elements;
+    void * pSourceElements = pSource->elements;
+
+    switch (pElementType->eTypeClass)
+    {
+    case typelib_TypeClass_CHAR:
+        return (0 == memcmp( pDestElements, pSourceElements, sizeof(sal_Unicode) * nElements ));
+    case typelib_TypeClass_BOOLEAN:
+    {
+        for ( sal_Int32 nPos = nElements; nPos--; )
+        {
+            if (bool(static_cast<sal_Bool *>(pDestElements)[nPos]) !=
+                bool(static_cast<sal_Bool *>(pSourceElements)[nPos]))
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+    case typelib_TypeClass_BYTE:
+        return (0 == memcmp( pDestElements, pSourceElements, sizeof(sal_Int8) * nElements ));
+    case typelib_TypeClass_SHORT:
+    case typelib_TypeClass_UNSIGNED_SHORT:
+        return (0 == memcmp( pDestElements, pSourceElements, sizeof(sal_Int16) * nElements ));
+    case typelib_TypeClass_LONG:
+    case typelib_TypeClass_UNSIGNED_LONG:
+        return (0 == memcmp( pDestElements, pSourceElements, sizeof(sal_Int32) * nElements ));
+    case typelib_TypeClass_HYPER:
+    case typelib_TypeClass_UNSIGNED_HYPER:
+        return (0 == memcmp( pDestElements, pSourceElements, sizeof(sal_Int64) * nElements ));
+    case typelib_TypeClass_FLOAT:
+    {
+        for ( sal_Int32 nPos = nElements; nPos--; )
+        {
+            if (static_cast<float *>(pDestElements)[nPos] != static_cast<float *>(pSourceElements)[nPos])
+                return false;
+        }
+        return true;
+    }
+    case typelib_TypeClass_DOUBLE:
+    {
+        for ( sal_Int32 nPos = nElements; nPos--; )
+        {
+            if (static_cast<double *>(pDestElements)[nPos] != static_cast<double *>(pSourceElements)[nPos])
+                return false;
+        }
+        return true;
+    }
+    case typelib_TypeClass_STRING:
+    {
+        for ( sal_Int32 nPos = nElements; nPos--; )
+        {
+            if ( static_cast<OUString *>(pDestElements)[nPos] != static_cast<const OUString *>(pSourceElements)[nPos] )
+                return false;
+        }
+        return true;
+    }
+    case typelib_TypeClass_TYPE:
+    {
+        for ( sal_Int32 nPos = nElements; nPos--; )
+        {
+            if (! _type_equals( static_cast<typelib_TypeDescriptionReference **>(pDestElements)[nPos],
+                                static_cast<typelib_TypeDescriptionReference **>(pSourceElements)[nPos] ))
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+    case typelib_TypeClass_ANY:
+    {
+        for ( sal_Int32 nPos = nElements; nPos--; )
+        {
+            uno_Any * pDest2 = static_cast<uno_Any *>(pDestElements) + nPos;
+            uno_Any * pSource2 = static_cast<uno_Any *>(pSourceElements) + nPos;
+            if (! ::uno_type_equalData( pDest2->pData, pDest2->pType,
+                                        pSource2->pData, pSource2->pType,
+                                        queryInterface, release ))
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+    case typelib_TypeClass_ENUM:
+        return (0 == memcmp( pDestElements, pSourceElements, sizeof(sal_Int32) * nElements ));
+    case typelib_TypeClass_STRUCT:
+    case typelib_TypeClass_EXCEPTION:
+    {
+        typelib_TypeDescription * pElementTypeDescr = nullptr;
+        TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
+        sal_Int32 nElementSize = pElementTypeDescr->nSize;
+        for ( sal_Int32 nPos = nElements; nPos--; )
+        {
+            if (! _equalStruct( static_cast<char *>(pDestElements) + (nPos * nElementSize),
+                                static_cast<char *>(pSourceElements) + (nPos * nElementSize),
+                                reinterpret_cast<typelib_CompoundTypeDescription *>(pElementTypeDescr),
+                                queryInterface, release ))
+            {
+                TYPELIB_DANGER_RELEASE( pElementTypeDescr );
+                return false;
+            }
+        }
+        TYPELIB_DANGER_RELEASE( pElementTypeDescr );
+        return true;
+    }
+    case typelib_TypeClass_SEQUENCE: // sequence of sequence
+    {
+        typelib_TypeDescription * pElementTypeDescr = nullptr;
+        TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
+        typelib_TypeDescriptionReference * pSeqElementType =
+            reinterpret_cast<typelib_IndirectTypeDescription *>(pElementTypeDescr)->pType;
+        for ( sal_Int32 nPos = nElements; nPos--; )
+        {
+            if (! equalSequence( static_cast<uno_Sequence **>(pDestElements)[nPos],
+                                 static_cast<uno_Sequence **>(pSourceElements)[nPos],
+                                 pSeqElementType, queryInterface, release ))
+            {
+                TYPELIB_DANGER_RELEASE( pElementTypeDescr );
+                return false;
+            }
+        }
+        TYPELIB_DANGER_RELEASE( pElementTypeDescr );
+        return true;
+    }
+    case typelib_TypeClass_INTERFACE:
+    {
+        for ( sal_Int32 nPos = nElements; nPos--; )
+        {
+            if (! _equalObject( static_cast<void **>(pDestElements)[nPos], static_cast<void **>(pSourceElements)[nPos],
+                                queryInterface, release ))
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+    default:
+        OSL_ASSERT(false);
+        return false;
+    }
+}
+
+inline bool _equalData(
+    void * pDest,
+    typelib_TypeDescriptionReference * pDestType, typelib_TypeDescription * pDestTypeDescr,
+    void * pSource,
+    typelib_TypeDescriptionReference * pSourceType,
+    uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
+{
+    typelib_TypeClass eSourceTypeClass, eDestTypeClass;
+    while (typelib_TypeClass_ANY == (eDestTypeClass = pDestType->eTypeClass))
+    {
+        pDestTypeDescr = nullptr;
+        pDestType = static_cast<uno_Any *>(pDest)->pType;
+        pDest = static_cast<uno_Any *>(pDest)->pData;
+    }
+    while (typelib_TypeClass_ANY == (eSourceTypeClass = pSourceType->eTypeClass))
+    {
+        pSourceType = static_cast<uno_Any *>(pSource)->pType;
+        pSource = static_cast<uno_Any *>(pSource)->pData;
+    }
+
+    switch (eDestTypeClass)
+    {
+    case typelib_TypeClass_VOID:
+        return eSourceTypeClass == typelib_TypeClass_VOID;
+    case typelib_TypeClass_CHAR:
+        return eSourceTypeClass == typelib_TypeClass_CHAR
+            && *static_cast<sal_Unicode *>(pDest) == *static_cast<sal_Unicode *>(pSource);
+    case typelib_TypeClass_BOOLEAN:
+        return eSourceTypeClass == typelib_TypeClass_BOOLEAN
+            && (bool(*static_cast<sal_Bool *>(pDest))
+                == bool(*static_cast<sal_Bool *>(pSource)));
+    case typelib_TypeClass_BYTE:
+        switch (eSourceTypeClass)
+        {
+        case typelib_TypeClass_BYTE:
+            return (*static_cast<sal_Int8 *>(pDest) == *static_cast<sal_Int8 *>(pSource));
+        case typelib_TypeClass_SHORT:
+            return (static_cast<sal_Int16>(*static_cast<sal_Int8 *>(pDest)) == *static_cast<sal_Int16 *>(pSource));
+        case typelib_TypeClass_UNSIGNED_SHORT:
+            return (static_cast<sal_Int32>(*static_cast<sal_Int8 *>(pDest)) == static_cast<sal_Int32>(*static_cast<sal_uInt16 *>(pSource)));
+        case typelib_TypeClass_LONG:
+            return (static_cast<sal_Int32>(*static_cast<sal_Int8 *>(pDest)) == *static_cast<sal_Int32 *>(pSource));
+        case typelib_TypeClass_UNSIGNED_LONG:
+            return (static_cast<sal_Int64>(*static_cast<sal_Int8 *>(pDest)) == static_cast<sal_Int64>(*static_cast<sal_uInt32 *>(pSource)));
+        case typelib_TypeClass_HYPER:
+            return (static_cast<sal_Int64>(*static_cast<sal_Int8 *>(pDest)) == *static_cast<sal_Int64 *>(pSource));
+        case typelib_TypeClass_UNSIGNED_HYPER:
+            return (*static_cast<sal_Int8 *>(pDest) >= 0 &&
+                    static_cast<sal_Int64>(*static_cast<sal_Int8 *>(pDest)) == *static_cast<sal_Int64 *>(pSource)); // same size
+        case typelib_TypeClass_FLOAT:
+            return (static_cast<float>(*static_cast<sal_Int8 *>(pDest)) == *static_cast<float *>(pSource));
+        case typelib_TypeClass_DOUBLE:
+            return (static_cast<double>(*static_cast<sal_Int8 *>(pDest)) == *static_cast<double *>(pSource));
+        default:
+            return false;
+        }
+    case typelib_TypeClass_SHORT:
+        switch (eSourceTypeClass)
+        {
+        case typelib_TypeClass_BYTE:
+            return (*static_cast<sal_Int16 *>(pDest) == static_cast<sal_Int16>(*static_cast<sal_Int8 *>(pSource)));
+        case typelib_TypeClass_SHORT:
+            return (*static_cast<sal_Int16 *>(pDest) == *static_cast<sal_Int16 *>(pSource));
+        case typelib_TypeClass_UNSIGNED_SHORT:
+            return (static_cast<sal_Int32>(*static_cast<sal_Int16 *>(pDest)) == static_cast<sal_Int32>(*static_cast<sal_uInt16 *>(pSource)));
+        case typelib_TypeClass_LONG:
+            return (static_cast<sal_Int32>(*static_cast<sal_Int16 *>(pDest)) == *static_cast<sal_Int32 *>(pSource));
+        case typelib_TypeClass_UNSIGNED_LONG:
+            return (static_cast<sal_Int64>(*static_cast<sal_Int16 *>(pDest)) == static_cast<sal_Int64>(*static_cast<sal_uInt32 *>(pSource)));
+        case typelib_TypeClass_HYPER:
+            return (static_cast<sal_Int64>(*static_cast<sal_Int16 *>(pDest)) == *static_cast<sal_Int64 *>(pSource));
+        case typelib_TypeClass_UNSIGNED_HYPER:
+            return (*static_cast<sal_Int16 *>(pDest) >= 0 &&
+                    static_cast<sal_Int64>(*static_cast<sal_Int16 *>(pDest)) == *static_cast<sal_Int64 *>(pSource)); // same size
+        case typelib_TypeClass_FLOAT:
+            return (static_cast<float>(*static_cast<sal_Int16 *>(pDest)) == *static_cast<float *>(pSource));
+        case typelib_TypeClass_DOUBLE:
+            return (static_cast<double>(*static_cast<sal_Int16 *>(pDest)) == *static_cast<double *>(pSource));
+        default:
+            return false;
+        }
+    case typelib_TypeClass_UNSIGNED_SHORT:
+        switch (eSourceTypeClass)
+        {
+        case typelib_TypeClass_BYTE:
+            return (static_cast<sal_Int32>(*static_cast<sal_uInt16 *>(pDest)) == static_cast<sal_Int32>(*static_cast<sal_Int8 *>(pSource)));
+        case typelib_TypeClass_SHORT:
+            return (static_cast<sal_Int32>(*static_cast<sal_uInt16 *>(pDest)) == static_cast<sal_Int32>(*static_cast<sal_Int16 *>(pSource)));
+        case typelib_TypeClass_UNSIGNED_SHORT:
+            return (*static_cast<sal_uInt16 *>(pDest) == *static_cast<sal_uInt16 *>(pSource));
+        case typelib_TypeClass_LONG:
+            return (static_cast<sal_Int32>(*static_cast<sal_uInt16 *>(pDest)) == *static_cast<sal_Int32 *>(pSource));
+        case typelib_TypeClass_UNSIGNED_LONG:
+            return (static_cast<sal_uInt32>(*static_cast<sal_uInt16 *>(pDest)) == *static_cast<sal_uInt32 *>(pSource));
+        case typelib_TypeClass_HYPER:
+            return (static_cast<sal_Int64>(*static_cast<sal_uInt16 *>(pDest)) == *static_cast<sal_Int64 *>(pSource));
+        case typelib_TypeClass_UNSIGNED_HYPER:
+            return (static_cast<sal_uInt64>(*static_cast<sal_uInt16 *>(pDest)) == *static_cast<sal_uInt64 *>(pSource));
+        case typelib_TypeClass_FLOAT:
+            return (static_cast<float>(*static_cast<sal_uInt16 *>(pDest)) == *static_cast<float *>(pSource));
+        case typelib_TypeClass_DOUBLE:
+            return (static_cast<double>(*static_cast<sal_uInt16 *>(pDest)) == *static_cast<double *>(pSource));
+        default:
+            return false;
+        }
+    case typelib_TypeClass_LONG:
+        switch (eSourceTypeClass)
+        {
+        case typelib_TypeClass_BYTE:
+            return (*static_cast<sal_Int32 *>(pDest) == static_cast<sal_Int32>(*static_cast<sal_Int8 *>(pSource)));
+        case typelib_TypeClass_SHORT:
+            return (*static_cast<sal_Int32 *>(pDest) == static_cast<sal_Int32>(*static_cast<sal_Int16 *>(pSource)));
+        case typelib_TypeClass_UNSIGNED_SHORT:
+            return (*static_cast<sal_Int32 *>(pDest) == static_cast<sal_Int32>(*static_cast<sal_uInt16 *>(pSource)));
+        case typelib_TypeClass_LONG:
+            return (*static_cast<sal_Int32 *>(pDest) == *static_cast<sal_Int32 *>(pSource));
+        case typelib_TypeClass_UNSIGNED_LONG:
+            return (static_cast<sal_Int64>(*static_cast<sal_Int32 *>(pDest)) == static_cast<sal_Int64>(*static_cast<sal_uInt32 *>(pSource)));
+        case typelib_TypeClass_HYPER:
+            return (static_cast<sal_Int64>(*static_cast<sal_Int32 *>(pDest)) == *static_cast<sal_Int64 *>(pSource));
+        case typelib_TypeClass_UNSIGNED_HYPER:
+            return (*static_cast<sal_Int32 *>(pDest) >= 0 &&
+                    static_cast<sal_Int64>(*static_cast<sal_Int32 *>(pDest)) == *static_cast<sal_Int64 *>(pSource)); // same size
+        case typelib_TypeClass_FLOAT:
+            return (static_cast<float>(*static_cast<sal_Int32 *>(pDest)) == *static_cast<float *>(pSource));
+        case typelib_TypeClass_DOUBLE:
+            return (static_cast<double>(*static_cast<sal_Int32 *>(pDest)) == *static_cast<double *>(pSource));
+        default:
+            return false;
+        }
+    case typelib_TypeClass_UNSIGNED_LONG:
+        switch (eSourceTypeClass)
+        {
+        case typelib_TypeClass_BYTE:
+            return (static_cast<sal_Int64>(*static_cast<sal_uInt32 *>(pDest)) == static_cast<sal_Int64>(*static_cast<sal_Int8 *>(pSource)));
+        case typelib_TypeClass_SHORT:
+            return (static_cast<sal_Int64>(*static_cast<sal_uInt32 *>(pDest)) == static_cast<sal_Int64>(*static_cast<sal_Int16 *>(pSource)));
+        case typelib_TypeClass_UNSIGNED_SHORT:
+            return (*static_cast<sal_uInt32 *>(pDest) == static_cast<sal_uInt32>(*static_cast<sal_uInt16 *>(pSource)));
+        case typelib_TypeClass_LONG:
+            return (static_cast<sal_Int64>(*static_cast<sal_uInt32 *>(pDest)) == static_cast<sal_Int64>(*static_cast<sal_Int32 *>(pSource)));
+        case typelib_TypeClass_UNSIGNED_LONG:
+            return (*static_cast<sal_uInt32 *>(pDest) == *static_cast<sal_uInt32 *>(pSource));
+        case typelib_TypeClass_HYPER:
+            return (static_cast<sal_Int64>(*static_cast<sal_uInt32 *>(pDest)) == *static_cast<sal_Int64 *>(pSource));
+        case typelib_TypeClass_UNSIGNED_HYPER:
+            return (static_cast<sal_uInt64>(*static_cast<sal_uInt32 *>(pDest)) == *static_cast<sal_uInt64 *>(pSource));
+        case typelib_TypeClass_FLOAT:
+            return (static_cast<float>(*static_cast<sal_uInt32 *>(pDest)) == *static_cast<float *>(pSource));
+        case typelib_TypeClass_DOUBLE:
+            return (static_cast<double>(*static_cast<sal_uInt32 *>(pDest)) == *static_cast<double *>(pSource));
+        default:
+            return false;
+        }
+    case typelib_TypeClass_HYPER:
+        switch (eSourceTypeClass)
+        {
+        case typelib_TypeClass_BYTE:
+            return (*static_cast<sal_Int64 *>(pDest) == static_cast<sal_Int64>(*static_cast<sal_Int8 *>(pSource)));
+        case typelib_TypeClass_SHORT:
+            return (*static_cast<sal_Int64 *>(pDest) == static_cast<sal_Int64>(*static_cast<sal_Int16 *>(pSource)));
+        case typelib_TypeClass_UNSIGNED_SHORT:
+            return (*static_cast<sal_Int64 *>(pDest) == static_cast<sal_Int64>(*static_cast<sal_uInt16 *>(pSource)));
+        case typelib_TypeClass_LONG:
+            return (*static_cast<sal_Int64 *>(pDest) == static_cast<sal_Int64>(*static_cast<sal_Int32 *>(pSource)));
+        case typelib_TypeClass_UNSIGNED_LONG:
+            return (*static_cast<sal_Int64 *>(pDest) == static_cast<sal_Int64>(*static_cast<sal_uInt32 *>(pSource)));
+        case typelib_TypeClass_HYPER:
+            return (*static_cast<sal_Int64 *>(pDest) == *static_cast<sal_Int64 *>(pSource));
+        case typelib_TypeClass_UNSIGNED_HYPER:
+            return (*static_cast<sal_Int64 *>(pDest) >= 0 &&
+                    *static_cast<sal_Int64 *>(pDest) == *static_cast<sal_Int64 *>(pSource)); // same size
+        case typelib_TypeClass_FLOAT:
+            return (static_cast<float>(*static_cast<sal_Int64 *>(pDest)) == *static_cast<float *>(pSource));
+        case typelib_TypeClass_DOUBLE:
+            return (static_cast<double>(*static_cast<sal_Int64 *>(pDest)) == *static_cast<double *>(pSource));
+        default:
+            return false;
+        }
+    case typelib_TypeClass_UNSIGNED_HYPER:
+        switch (eSourceTypeClass)
+        {
+        case typelib_TypeClass_BYTE:
+            return (*static_cast<sal_Int8 *>(pSource) >= 0 &&
+                    *static_cast<sal_uInt64 *>(pDest) == static_cast<sal_uInt64>(*static_cast<sal_Int8 *>(pSource)));
+        case typelib_TypeClass_SHORT:
+            return (*static_cast<sal_Int16 *>(pSource) >= 0 &&
+                    *static_cast<sal_uInt64 *>(pDest) == static_cast<sal_uInt64>(*static_cast<sal_Int16 *>(pSource)));
+        case typelib_TypeClass_UNSIGNED_SHORT:
+            return (*static_cast<sal_uInt64 *>(pDest) == static_cast<sal_uInt64>(*static_cast<sal_uInt16 *>(pSource)));
+        case typelib_TypeClass_LONG:
+            return (*static_cast<sal_Int32 *>(pSource) >= 0 &&
+                    *static_cast<sal_uInt64 *>(pDest) == static_cast<sal_uInt64>(*static_cast<sal_Int32 *>(pSource)));
+        case typelib_TypeClass_UNSIGNED_LONG:
+            return (*static_cast<sal_uInt64 *>(pDest) == static_cast<sal_uInt64>(*static_cast<sal_uInt32 *>(pSource)));
+        case typelib_TypeClass_HYPER:
+            return (*static_cast<sal_Int64 *>(pSource) >= 0 &&
+                    *static_cast<sal_uInt64 *>(pDest) == static_cast<sal_uInt64>(*static_cast<sal_Int64 *>(pSource)));
+        case typelib_TypeClass_UNSIGNED_HYPER:
+            return (*static_cast<sal_uInt64 *>(pDest) == *static_cast<sal_uInt64 *>(pSource));
+        case typelib_TypeClass_FLOAT:
+            if (::floor( *static_cast<float *>(pSource) ) != *static_cast<float *>(pSource) || *static_cast<float *>(pSource) < 0)
+                return false;
+            return (*static_cast<sal_uInt64 *>(pDest) == static_cast<sal_uInt64>(*static_cast<float *>(pSource)));
+        case typelib_TypeClass_DOUBLE:
+            if (::floor( *static_cast<double *>(pSource) ) != *static_cast<double *>(pSource) || *static_cast<double *>(pSource) < 0)
+                return false;
+            return (*static_cast<sal_uInt64 *>(pDest) == static_cast<sal_uInt64>(*static_cast<double *>(pSource)));
+        default:
+            return false;
+        }
+    case typelib_TypeClass_FLOAT:
+        switch (eSourceTypeClass)
+        {
+        case typelib_TypeClass_BYTE:
+            return (*static_cast<float *>(pDest) == static_cast<float>(*static_cast<sal_Int8 *>(pSource)));
+        case typelib_TypeClass_SHORT:
+            return (*static_cast<float *>(pDest) == static_cast<float>(*static_cast<sal_Int16 *>(pSource)));
+        case typelib_TypeClass_UNSIGNED_SHORT:
+            return (*static_cast<float *>(pDest) == static_cast<float>(*static_cast<sal_uInt16 *>(pSource)));
+        case typelib_TypeClass_LONG:
+            return (*static_cast<float *>(pDest) == static_cast<float>(*static_cast<sal_Int32 *>(pSource)));
+        case typelib_TypeClass_UNSIGNED_LONG:
+            return (*static_cast<float *>(pDest) == static_cast<float>(*static_cast<sal_uInt32 *>(pSource)));
+        case typelib_TypeClass_HYPER:
+            return (*static_cast<float *>(pDest) == static_cast<float>(*static_cast<sal_Int64 *>(pSource)));
+        case typelib_TypeClass_UNSIGNED_HYPER:
+            if (::floor( *static_cast<float *>(pDest) ) != *static_cast<float *>(pDest) || *static_cast<float *>(pDest) < 0)
+                return false;
+            return (static_cast<sal_uInt64>(*static_cast<float *>(pDest)) == *static_cast<sal_uInt64 *>(pSource));
+        case typelib_TypeClass_FLOAT:
+            return (*static_cast<float *>(pDest) == *static_cast<float *>(pSource));
+        case typelib_TypeClass_DOUBLE:
+            return (static_cast<double>(*static_cast<float *>(pDest)) == *static_cast<double *>(pSource));
+        default:
+            return false;
+        }
+    case typelib_TypeClass_DOUBLE:
+        switch (eSourceTypeClass)
+        {
+        case typelib_TypeClass_BYTE:
+            return (*static_cast<double *>(pDest) == static_cast<double>(*static_cast<sal_Int8 *>(pSource)));
+        case typelib_TypeClass_SHORT:
+            return (*static_cast<double *>(pDest) == static_cast<double>(*static_cast<sal_Int16 *>(pSource)));
+        case typelib_TypeClass_UNSIGNED_SHORT:
+            return (*static_cast<double *>(pDest) == static_cast<double>(*static_cast<sal_uInt16 *>(pSource)));
+        case typelib_TypeClass_LONG:
+            return (*static_cast<double *>(pDest) == static_cast<double>(*static_cast<sal_Int32 *>(pSource)));
+        case typelib_TypeClass_UNSIGNED_LONG:
+            return (*static_cast<double *>(pDest) == static_cast<double>(*static_cast<sal_uInt32 *>(pSource)));
+        case typelib_TypeClass_HYPER:
+            return (*static_cast<double *>(pDest) == static_cast<double>(*static_cast<sal_Int64 *>(pSource)));
+        case typelib_TypeClass_UNSIGNED_HYPER:
+            if (::floor( *static_cast<double *>(pDest) ) != *static_cast<double *>(pDest) || *static_cast<double *>(pDest) < 0)
+                return false;
+            return (static_cast<sal_uInt64>(*static_cast<double *>(pDest)) == *static_cast<sal_uInt64 *>(pSource));
+        case typelib_TypeClass_FLOAT:
+            return (*static_cast<double *>(pDest) == static_cast<double>(*static_cast<float *>(pSource)));
+        case typelib_TypeClass_DOUBLE:
+            return (*static_cast<double *>(pDest) == *static_cast<double *>(pSource));
+        default:
+            return false;
+        }
+    case typelib_TypeClass_STRING:
+        return eSourceTypeClass == typelib_TypeClass_STRING
+            && *static_cast<OUString *>(pDest) ==
+                *static_cast<OUString const *>(pSource);
+    case typelib_TypeClass_TYPE:
+        return eSourceTypeClass == typelib_TypeClass_TYPE
+            && _type_equals(
+                *static_cast<typelib_TypeDescriptionReference **>(pDest),
+                *static_cast<typelib_TypeDescriptionReference **>(pSource) );
+    case typelib_TypeClass_ENUM:
+        return (_type_equals( pDestType, pSourceType ) &&
+                *static_cast<sal_Int32 *>(pDest) == *static_cast<sal_Int32 *>(pSource));
+    case typelib_TypeClass_STRUCT:
+    case typelib_TypeClass_EXCEPTION:
+        if (! _type_equals( pDestType, pSourceType ))
+            return false;
+        if (pDestTypeDescr)
+        {
+            return _equalStruct(
+                pDest, pSource,
+                reinterpret_cast<typelib_CompoundTypeDescription *>(pDestTypeDescr),
+                queryInterface, release );
+        }
+        else
+        {
+            TYPELIB_DANGER_GET( &pDestTypeDescr, pDestType );
+            bool bRet = _equalStruct(
+                pDest, pSource,
+                reinterpret_cast<typelib_CompoundTypeDescription *>(pDestTypeDescr),
+                queryInterface, release );
+            TYPELIB_DANGER_RELEASE( pDestTypeDescr );
+            return bRet;
+        }
+    case typelib_TypeClass_SEQUENCE:
+        if (_type_equals( pDestType, pSourceType ))
+        {
+            if (pDestTypeDescr)
+            {
+                return _equalSequence(
+                    *static_cast<uno_Sequence **>(pDest), *static_cast<uno_Sequence **>(pSource),
+                    reinterpret_cast<typelib_IndirectTypeDescription *>(pDestTypeDescr)->pType,
+                    queryInterface, release );
+            }
+            else
+            {
+                TYPELIB_DANGER_GET( &pDestTypeDescr, pDestType );
+                bool bRet = _equalSequence(
+                    *static_cast<uno_Sequence **>(pDest), *static_cast<uno_Sequence **>(pSource),
+                    reinterpret_cast<typelib_IndirectTypeDescription *>(pDestTypeDescr)->pType,
+                    queryInterface, release );
+                TYPELIB_DANGER_RELEASE( pDestTypeDescr );
+                return bRet;
+            }
+        }
+        return false;
+    case typelib_TypeClass_INTERFACE:
+        if (typelib_TypeClass_INTERFACE == eSourceTypeClass)
+            return _equalObject( *static_cast<void **>(pDest), *static_cast<void **>(pSource), queryInterface, release );
+        break;
+    default:
+        OSL_ASSERT(false);
+        break;
+    }
+    return false;
+}
+
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppu/source/uno/lbenv.cxx b/cppu/source/uno/lbenv.cxx
new file mode 100644
index 000000000..c67d47dc9
--- /dev/null
+++ b/cppu/source/uno/lbenv.cxx
@@ -0,0 +1,1154 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifdef DISABLE_DYNLOADING
+#include <config_java.h>
+#endif
+
+#include <cppu/EnvDcp.hxx>
+
+#include <sal/log.hxx>
+#include <osl/diagnose.h>
+#include <osl/interlck.h>
+#include <osl/mutex.hxx>
+#include <osl/module.hxx>
+#include <osl/process.h>
+#include <rtl/process.h>
+#include <rtl/string.hxx>
+#include <rtl/ustring.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <rtl/instance.hxx>
+#include <typelib/typedescription.h>
+#include <uno/dispatcher.h>
+#include <uno/environment.h>
+#include <uno/lbnames.h>
+#include "prim.hxx"
+#include "loadmodule.hxx"
+
+#include <unordered_map>
+#include <vector>
+#include <stdio.h>
+
+
+namespace
+{
+
+
+bool td_equals( typelib_InterfaceTypeDescription const * pTD1,
+                       typelib_InterfaceTypeDescription const * pTD2 )
+{
+    return (pTD1 == pTD2 ||
+            (pTD1->aBase.pTypeName->length == pTD2->aBase.pTypeName->length &&
+             ::rtl_ustr_compare(
+                 pTD1->aBase.pTypeName->buffer,
+                 pTD2->aBase.pTypeName->buffer ) == 0));
+}
+
+struct uno_DefaultEnvironment;
+
+
+struct InterfaceEntry
+{
+    sal_Int32 refCount;
+    void * pInterface;
+    uno_freeProxyFunc fpFreeProxy;
+    typelib_InterfaceTypeDescription * pTypeDescr;
+};
+
+struct ObjectEntry
+{
+    OUString oid;
+    sal_Int32 nRef;
+    std::vector< InterfaceEntry > aInterfaces;
+    bool mixedObject;
+
+    explicit ObjectEntry( const OUString & rOId_ );
+
+    void append(
+        uno_DefaultEnvironment * pEnv,
+        void * pInterface, typelib_InterfaceTypeDescription * pTypeDescr,
+        uno_freeProxyFunc fpFreeProxy );
+    InterfaceEntry * find(
+        typelib_InterfaceTypeDescription * pTypeDescr );
+    sal_Int32 find( void const * iface_ptr, std::size_t pos ) const;
+};
+
+
+struct FctPtrHash
+{
+    std::size_t operator () ( const void * pKey ) const
+        { return reinterpret_cast< std::size_t>( pKey ); }
+};
+
+
+// mapping from environment name to environment
+typedef std::unordered_map<
+    OUString, uno_Environment * > OUString2EnvironmentMap;
+
+// mapping from ptr to object entry
+typedef std::unordered_map<
+    void *, ObjectEntry *, FctPtrHash > Ptr2ObjectMap;
+// mapping from oid to object entry
+typedef std::unordered_map<
+    OUString, ObjectEntry * > OId2ObjectMap;
+
+struct EnvironmentsData
+{
+    ::osl::Mutex mutex;
+    OUString2EnvironmentMap aName2EnvMap;
+
+    EnvironmentsData() : isDisposing(false) {}
+    ~EnvironmentsData();
+
+    void getEnvironment(
+        uno_Environment ** ppEnv, const OUString & rEnvDcp, void * pContext );
+    void registerEnvironment( uno_Environment ** ppEnv );
+    void getRegisteredEnvironments(
+        uno_Environment *** pppEnvs, sal_Int32 * pnLen,
+        uno_memAlloc memAlloc, const OUString & rEnvDcp );
+
+    bool isDisposing;
+};
+
+struct theEnvironmentsData : public rtl::Static< EnvironmentsData, theEnvironmentsData > {};
+
+struct uno_DefaultEnvironment : public uno_ExtEnvironment
+{
+    sal_Int32 nRef;
+    sal_Int32 nWeakRef;
+
+    ::osl::Mutex mutex;
+    Ptr2ObjectMap aPtr2ObjectMap;
+    OId2ObjectMap aOId2ObjectMap;
+
+    uno_DefaultEnvironment(
+        const OUString & rEnvDcp_, void * pContext_ );
+    ~uno_DefaultEnvironment();
+};
+
+
+ObjectEntry::ObjectEntry( OUString const & rOId_ )
+    : oid( rOId_ ),
+      nRef( 0 ),
+      mixedObject( false )
+{
+    aInterfaces.reserve( 2 );
+}
+
+
+void ObjectEntry::append(
+    uno_DefaultEnvironment * pEnv,
+    void * pInterface, typelib_InterfaceTypeDescription * pTypeDescr,
+    uno_freeProxyFunc fpFreeProxy )
+{
+    InterfaceEntry aNewEntry;
+    if (! fpFreeProxy)
+        (*pEnv->acquireInterface)( pEnv, pInterface );
+    aNewEntry.refCount = 1;
+    aNewEntry.pInterface = pInterface;
+    aNewEntry.fpFreeProxy = fpFreeProxy;
+    typelib_typedescription_acquire( &pTypeDescr->aBase );
+    aNewEntry.pTypeDescr = pTypeDescr;
+
+    std::pair< Ptr2ObjectMap::iterator, bool > i(
+        pEnv->aPtr2ObjectMap.emplace( pInterface, this ) );
+    SAL_WARN_IF(
+        !i.second && (find(pInterface, 0) == -1 || i.first->second != this),
+        "cppu",
+        "map already contains " << i.first->second << " != " << this << " for "
+            << pInterface);
+    aInterfaces.push_back( aNewEntry );
+}
+
+
+InterfaceEntry * ObjectEntry::find(
+    typelib_InterfaceTypeDescription * pTypeDescr_ )
+{
+    OSL_ASSERT( ! aInterfaces.empty() );
+    if (aInterfaces.empty())
+        return nullptr;
+
+    // shortcut common case:
+    OUString const & type_name =
+        OUString::unacquired( &pTypeDescr_->aBase.pTypeName );
+    if ( type_name == "com.sun.star.uno.XInterface" )
+    {
+        return aInterfaces.data();
+    }
+
+    std::size_t nSize = aInterfaces.size();
+    for ( std::size_t nPos = 0; nPos < nSize; ++nPos )
+    {
+        typelib_InterfaceTypeDescription * pITD =
+            aInterfaces[ nPos ].pTypeDescr;
+        while (pITD)
+        {
+            if (td_equals( pITD, pTypeDescr_ ))
+                return &aInterfaces[ nPos ];
+            pITD = pITD->pBaseTypeDescription;
+        }
+    }
+    return nullptr;
+}
+
+
+sal_Int32 ObjectEntry::find(
+    void const * iface_ptr, std::size_t pos ) const
+{
+    std::size_t size = aInterfaces.size();
+    for ( ; pos < size; ++pos )
+    {
+        if (aInterfaces[ pos ].pInterface == iface_ptr)
+            return pos;
+    }
+    return -1;
+}
+
+extern "C"
+{
+
+
+static void defenv_registerInterface(
+    uno_ExtEnvironment * pEnv, void ** ppInterface,
+    rtl_uString * pOId, typelib_InterfaceTypeDescription * pTypeDescr )
+{
+    OSL_ENSURE( pEnv && ppInterface && pOId && pTypeDescr, "### null ptr!" );
+    OUString const & rOId = OUString::unacquired( &pOId );
+
+    uno_DefaultEnvironment * that =
+        static_cast< uno_DefaultEnvironment * >( pEnv );
+    ::osl::ClearableMutexGuard guard( that->mutex );
+
+    // try to insert dummy 0:
+    std::pair<OId2ObjectMap::iterator, bool> const insertion(
+        that->aOId2ObjectMap.emplace(  rOId, nullptr ) );
+    if (insertion.second)
+    {
+        ObjectEntry * pOEntry = new ObjectEntry( rOId );
+        insertion.first->second = pOEntry;
+        ++pOEntry->nRef; // another register call on object
+        pOEntry->append( that, *ppInterface, pTypeDescr, nullptr );
+    }
+    else // object entry exists
+    {
+        ObjectEntry * pOEntry = insertion.first->second;
+        ++pOEntry->nRef; // another register call on object
+        InterfaceEntry * pIEntry = pOEntry->find( pTypeDescr );
+
+        if (pIEntry) // type entry exists
+        {
+            ++pIEntry->refCount;
+            if (pIEntry->pInterface != *ppInterface)
+            {
+                void * pInterface = pIEntry->pInterface;
+                (*pEnv->acquireInterface)( pEnv, pInterface );
+                guard.clear();
+                (*pEnv->releaseInterface)( pEnv, *ppInterface );
+                *ppInterface = pInterface;
+            }
+        }
+        else
+        {
+            pOEntry->append( that, *ppInterface, pTypeDescr, nullptr );
+        }
+    }
+}
+
+
+static void defenv_registerProxyInterface(
+    uno_ExtEnvironment * pEnv, void ** ppInterface, uno_freeProxyFunc freeProxy,
+    rtl_uString * pOId, typelib_InterfaceTypeDescription * pTypeDescr )
+{
+    OSL_ENSURE( pEnv && ppInterface && pOId && pTypeDescr && freeProxy,
+                "### null ptr!" );
+    OUString const & rOId = OUString::unacquired( &pOId );
+
+    uno_DefaultEnvironment * that =
+        static_cast< uno_DefaultEnvironment * >( pEnv );
+    ::osl::ClearableMutexGuard guard( that->mutex );
+
+    // try to insert dummy 0:
+    std::pair<OId2ObjectMap::iterator, bool> const insertion(
+        that->aOId2ObjectMap.emplace(  rOId, nullptr ) );
+    if (insertion.second)
+    {
+        ObjectEntry * pOEntry = new ObjectEntry( rOId );
+        insertion.first->second = pOEntry;
+        ++pOEntry->nRef; // another register call on object
+        pOEntry->append( that, *ppInterface, pTypeDescr, freeProxy );
+    }
+    else // object entry exists
+    {
+        ObjectEntry * pOEntry = insertion.first->second;
+
+        // first registration was an original, then registerProxyInterface():
+        pOEntry->mixedObject |=
+            (!pOEntry->aInterfaces.empty() &&
+             pOEntry->aInterfaces[ 0 ].fpFreeProxy == nullptr);
+
+        ++pOEntry->nRef; // another register call on object
+        InterfaceEntry * pIEntry = pOEntry->find( pTypeDescr );
+
+        if (pIEntry) // type entry exists
+        {
+            if (pIEntry->pInterface == *ppInterface)
+            {
+                ++pIEntry->refCount;
+            }
+            else
+            {
+                void * pInterface = pIEntry->pInterface;
+                (*pEnv->acquireInterface)( pEnv, pInterface );
+                --pOEntry->nRef; // manual revoke of proxy to be freed
+                guard.clear();
+                (*freeProxy)( pEnv, *ppInterface );
+                *ppInterface = pInterface;
+            }
+        }
+        else
+        {
+            pOEntry->append( that, *ppInterface, pTypeDescr, freeProxy );
+        }
+    }
+}
+
+
+static void s_stub_defenv_revokeInterface(va_list * pParam)
+{
+    uno_ExtEnvironment * pEnv       = va_arg(*pParam, uno_ExtEnvironment *);
+    void               * pInterface = va_arg(*pParam, void *);
+
+    OSL_ENSURE( pEnv && pInterface, "### null ptr!" );
+    uno_DefaultEnvironment * that =
+        static_cast< uno_DefaultEnvironment * >( pEnv );
+    ::osl::ClearableMutexGuard guard( that->mutex );
+
+    Ptr2ObjectMap::const_iterator const iFind(
+        that->aPtr2ObjectMap.find( pInterface ) );
+    OSL_ASSERT( iFind != that->aPtr2ObjectMap.end() );
+    ObjectEntry * pOEntry = iFind->second;
+    if (! --pOEntry->nRef)
+    {
+        // cleanup maps
+        that->aOId2ObjectMap.erase( pOEntry->oid );
+        sal_Int32 nPos;
+        for ( nPos = pOEntry->aInterfaces.size(); nPos--; )
+        {
+            that->aPtr2ObjectMap.erase( pOEntry->aInterfaces[nPos].pInterface );
+        }
+
+        // the last proxy interface of the environment might kill this
+        // environment, because of releasing its language binding!!!
+        guard.clear();
+
+        // release interfaces
+        for ( nPos = pOEntry->aInterfaces.size(); nPos--; )
+        {
+            InterfaceEntry const & rEntry = pOEntry->aInterfaces[nPos];
+            typelib_typedescription_release( &rEntry.pTypeDescr->aBase );
+            if (rEntry.fpFreeProxy) // is proxy or used interface?
+            {
+                (*rEntry.fpFreeProxy)( pEnv, rEntry.pInterface );
+            }
+            else
+            {
+                (*pEnv->releaseInterface)( pEnv, rEntry.pInterface );
+            }
+        }
+
+        delete pOEntry;
+    }
+    else if (pOEntry->mixedObject)
+    {
+        OSL_ASSERT( !pOEntry->aInterfaces.empty() &&
+                    pOEntry->aInterfaces[ 0 ].fpFreeProxy == nullptr );
+
+        sal_Int32 index = pOEntry->find( pInterface, 1 );
+        OSL_ASSERT( index > 0 );
+        if (index > 0)
+        {
+            InterfaceEntry & entry = pOEntry->aInterfaces[ index ];
+            OSL_ASSERT( entry.pInterface == pInterface );
+            if (entry.fpFreeProxy != nullptr)
+            {
+                --entry.refCount;
+                if (entry.refCount == 0)
+                {
+                    uno_freeProxyFunc fpFreeProxy = entry.fpFreeProxy;
+                    typelib_TypeDescription * pTypeDescr =
+                        reinterpret_cast< typelib_TypeDescription * >(
+                            entry.pTypeDescr );
+
+                    pOEntry->aInterfaces.erase(
+                        pOEntry->aInterfaces.begin() + index );
+                    if (pOEntry->find( pInterface, index ) < 0)
+                    {
+                        // proxy ptr not registered for another interface:
+                        // remove from ptr map
+                        std::size_t erased =
+                              that->aPtr2ObjectMap.erase( pInterface );
+                        OSL_ASSERT( erased == 1 );
+                    }
+
+                    guard.clear();
+
+                    typelib_typedescription_release( pTypeDescr );
+                    (*fpFreeProxy)( pEnv, pInterface );
+                }
+            }
+        }
+    }
+}
+
+static void defenv_revokeInterface(uno_ExtEnvironment * pEnv, void * pInterface)
+{
+    uno_Environment_invoke(&pEnv->aBase, s_stub_defenv_revokeInterface, pEnv, pInterface);
+}
+
+
+static void defenv_getObjectIdentifier(
+    uno_ExtEnvironment * pEnv, rtl_uString ** ppOId, void * pInterface )
+{
+    OSL_ENSURE( pEnv && ppOId && pInterface, "### null ptr!" );
+    if (*ppOId)
+    {
+        ::rtl_uString_release( *ppOId );
+        *ppOId = nullptr;
+    }
+
+    uno_DefaultEnvironment * that =
+        static_cast< uno_DefaultEnvironment * >( pEnv );
+    ::osl::ClearableMutexGuard guard( that->mutex );
+
+    Ptr2ObjectMap::const_iterator const iFind(
+        that->aPtr2ObjectMap.find( pInterface ) );
+    if (iFind == that->aPtr2ObjectMap.end())
+    {
+        guard.clear();
+        (*pEnv->computeObjectIdentifier)( pEnv, ppOId, pInterface );
+    }
+    else
+    {
+        rtl_uString * hstr = iFind->second->oid.pData;
+        rtl_uString_acquire( hstr );
+        *ppOId = hstr;
+    }
+}
+
+
+static void defenv_getRegisteredInterface(
+    uno_ExtEnvironment * pEnv, void ** ppInterface,
+    rtl_uString * pOId, typelib_InterfaceTypeDescription * pTypeDescr )
+{
+    OSL_ENSURE( pEnv && ppInterface && pOId && pTypeDescr, "### null ptr!" );
+    if (*ppInterface)
+    {
+        (*pEnv->releaseInterface)( pEnv, *ppInterface );
+        *ppInterface = nullptr;
+    }
+
+    OUString const & rOId = OUString::unacquired( &pOId );
+    uno_DefaultEnvironment * that =
+        static_cast< uno_DefaultEnvironment * >( pEnv );
+    ::osl::MutexGuard guard( that->mutex );
+
+    OId2ObjectMap::const_iterator const iFind
+        ( that->aOId2ObjectMap.find( rOId ) );
+    if (iFind != that->aOId2ObjectMap.end())
+    {
+        InterfaceEntry const * pIEntry = iFind->second->find( pTypeDescr );
+        if (pIEntry)
+        {
+            (*pEnv->acquireInterface)( pEnv, pIEntry->pInterface );
+            *ppInterface = pIEntry->pInterface;
+        }
+    }
+}
+
+
+static void defenv_getRegisteredInterfaces(
+    uno_ExtEnvironment * pEnv, void *** pppInterfaces, sal_Int32 * pnLen,
+    uno_memAlloc memAlloc )
+{
+    assert(pEnv && pppInterfaces && pnLen && memAlloc && "### null ptr!");
+    uno_DefaultEnvironment * that =
+        static_cast< uno_DefaultEnvironment * >( pEnv );
+    ::osl::MutexGuard guard( that->mutex );
+
+    sal_Int32 nLen = that->aPtr2ObjectMap.size();
+    sal_Int32 nPos = 0;
+    void ** ppInterfaces = static_cast<void **>((*memAlloc)( nLen * sizeof (void *) ));
+
+    for (const auto& rEntry : that->aPtr2ObjectMap)
+    {
+        ppInterfaces[nPos] = rEntry.first;
+        (*pEnv->acquireInterface)( pEnv, ppInterfaces[nPos] );
+        nPos++;
+    }
+
+    *pppInterfaces = ppInterfaces;
+    *pnLen = nLen;
+}
+
+
+static void defenv_acquire( uno_Environment * pEnv )
+{
+    uno_DefaultEnvironment * that = reinterpret_cast<uno_DefaultEnvironment *>(pEnv);
+    osl_atomic_increment( &that->nWeakRef );
+    osl_atomic_increment( &that->nRef );
+}
+
+
+static void defenv_release( uno_Environment * pEnv )
+{
+    uno_DefaultEnvironment * that = reinterpret_cast<uno_DefaultEnvironment *>(pEnv);
+    if (! osl_atomic_decrement( &that->nRef ))
+    {
+        // invoke dispose callback
+        if (pEnv->environmentDisposing)
+        {
+            (*pEnv->environmentDisposing)( pEnv );
+        }
+
+        OSL_ENSURE( that->aOId2ObjectMap.empty(), "### object entries left!" );
+    }
+    // free memory if no weak refs left
+    if (! osl_atomic_decrement( &that->nWeakRef ))
+    {
+        delete that;
+    }
+}
+
+
+static void defenv_acquireWeak( uno_Environment * pEnv )
+{
+    uno_DefaultEnvironment * that = reinterpret_cast<uno_DefaultEnvironment *>(pEnv);
+    osl_atomic_increment( &that->nWeakRef );
+}
+
+
+static void defenv_releaseWeak( uno_Environment * pEnv )
+{
+    uno_DefaultEnvironment * that = reinterpret_cast<uno_DefaultEnvironment *>(pEnv);
+    if (! osl_atomic_decrement( &that->nWeakRef ))
+    {
+        delete that;
+    }
+}
+
+
+static void defenv_harden(
+    uno_Environment ** ppHardEnv, uno_Environment * pEnv )
+{
+    if (*ppHardEnv)
+    {
+        (*(*ppHardEnv)->release)( *ppHardEnv );
+        *ppHardEnv = nullptr;
+    }
+
+    EnvironmentsData & rData = theEnvironmentsData::get();
+
+    if (rData.isDisposing)
+        return;
+
+    uno_DefaultEnvironment * that = reinterpret_cast<uno_DefaultEnvironment *>(pEnv);
+    {
+    ::osl::MutexGuard guard( rData.mutex );
+    if (1 == osl_atomic_increment( &that->nRef )) // is dead
+    {
+        that->nRef = 0;
+        return;
+    }
+    }
+    osl_atomic_increment( &that->nWeakRef );
+    *ppHardEnv = pEnv;
+}
+
+
+static void defenv_dispose( SAL_UNUSED_PARAMETER uno_Environment * )
+{
+}
+}
+
+
+uno_DefaultEnvironment::uno_DefaultEnvironment(
+    const OUString & rEnvDcp_, void * pContext_ )
+    : nRef( 0 ),
+      nWeakRef( 0 )
+{
+    uno_Environment * that = reinterpret_cast< uno_Environment * >(this);
+    that->pReserved = nullptr;
+    // functions
+    that->acquire = defenv_acquire;
+    that->release = defenv_release;
+    that->acquireWeak = defenv_acquireWeak;
+    that->releaseWeak = defenv_releaseWeak;
+    that->harden = defenv_harden;
+    that->dispose = defenv_dispose;
+    that->pExtEnv = this;
+    // identifier
+    ::rtl_uString_acquire( rEnvDcp_.pData );
+    that->pTypeName = rEnvDcp_.pData;
+    that->pContext = pContext_;
+
+    // will be late initialized
+    that->environmentDisposing = nullptr;
+
+    uno_ExtEnvironment::registerInterface = defenv_registerInterface;
+    uno_ExtEnvironment::registerProxyInterface = defenv_registerProxyInterface;
+    uno_ExtEnvironment::revokeInterface = defenv_revokeInterface;
+    uno_ExtEnvironment::getObjectIdentifier = defenv_getObjectIdentifier;
+    uno_ExtEnvironment::getRegisteredInterface = defenv_getRegisteredInterface;
+    uno_ExtEnvironment::getRegisteredInterfaces =
+        defenv_getRegisteredInterfaces;
+
+}
+
+
+uno_DefaultEnvironment::~uno_DefaultEnvironment()
+{
+    ::rtl_uString_release( aBase.pTypeName );
+}
+
+
+void writeLine(
+    void * stream, const char * pLine, const char * pFilter )
+{
+    if (pFilter && *pFilter)
+    {
+        // lookup pFilter in pLine
+        while (*pLine)
+        {
+            if (*pLine == *pFilter)
+            {
+                sal_Int32 nPos = 1;
+                while (pLine[nPos] && pFilter[nPos] == pLine[nPos])
+                {
+                    ++nPos;
+                }
+                if (! pFilter[nPos])
+                {
+                    if (stream)
+                    {
+                        fprintf( static_cast<FILE *>(stream), "%s\n", pLine );
+                    }
+                    else
+                    {
+                        SAL_WARN("cppu", pLine );
+                    }
+                }
+            }
+            ++pLine;
+        }
+    }
+    else
+    {
+        if (stream)
+        {
+            fprintf( static_cast<FILE *>(stream), "%s\n", pLine );
+        }
+        else
+        {
+            fprintf( stderr, "%s\n", pLine );
+        }
+    }
+}
+
+
+void writeLine(
+    void * stream, const OUString & rLine, const char * pFilter )
+{
+    OString aLine( OUStringToOString(
+                              rLine, RTL_TEXTENCODING_ASCII_US ) );
+    writeLine( stream, aLine.getStr(), pFilter );
+}
+
+}
+
+extern "C" void SAL_CALL uno_dumpEnvironment(
+    void * stream, uno_Environment * pEnv, const char * pFilter )
+    SAL_THROW_EXTERN_C()
+{
+    OSL_ENSURE( pEnv, "### null ptr!" );
+    OUStringBuffer buf;
+
+    if (! pEnv->pExtEnv)
+    {
+        writeLine( stream, "###################################"
+                   "###########################################", pFilter );
+        buf.append( "environment: " );
+        buf.append( pEnv->pTypeName );
+        writeLine( stream, buf.makeStringAndClear(), pFilter );
+        writeLine( stream, "NO INTERFACE INFORMATION AVAILABLE!", pFilter );
+        return;
+    }
+
+    writeLine( stream, "########################################"
+               "######################################", pFilter );
+    buf.append( "environment dump: " );
+    buf.append( pEnv->pTypeName );
+    writeLine( stream, buf.makeStringAndClear(), pFilter );
+
+    uno_DefaultEnvironment * that =
+        reinterpret_cast< uno_DefaultEnvironment * >(pEnv);
+    ::osl::MutexGuard guard( that->mutex );
+
+    Ptr2ObjectMap ptr2obj( that->aPtr2ObjectMap );
+    for (const auto& rEntry : that->aOId2ObjectMap)
+    {
+        ObjectEntry * pOEntry = rEntry.second;
+
+        buf.append( "+ " );
+        if (pOEntry->mixedObject)
+            buf.append( "mixed " );
+        buf.append( "object entry: nRef=" );
+        buf.append( pOEntry->nRef );
+        buf.append( "; oid=\"" );
+        buf.append( pOEntry->oid );
+        buf.append( '\"' );
+        writeLine( stream, buf.makeStringAndClear(), pFilter );
+
+        for ( std::size_t nPos = 0;
+              nPos < pOEntry->aInterfaces.size(); ++nPos )
+        {
+            const InterfaceEntry & rIEntry = pOEntry->aInterfaces[nPos];
+
+            buf.append( "  - " );
+            buf.append( rIEntry.pTypeDescr->aBase.pTypeName );
+            if (rIEntry.fpFreeProxy)
+            {
+                buf.append( "; proxy free=0x" );
+                buf.append(
+                    reinterpret_cast< sal_IntPtr >(rIEntry.fpFreeProxy), 16 );
+            }
+            else
+            {
+                buf.append( "; original" );
+            }
+            buf.append( "; ptr=0x" );
+            buf.append(
+                reinterpret_cast< sal_IntPtr >(rIEntry.pInterface), 16 );
+
+            if (pOEntry->find( rIEntry.pInterface, nPos + 1 ) < 0)
+            {
+                std::size_t erased = ptr2obj.erase( rIEntry.pInterface );
+                if (erased != 1)
+                {
+                    buf.append( " (ptr not found in map!)" );
+                }
+            }
+            writeLine( stream, buf.makeStringAndClear(), pFilter );
+        }
+    }
+    if (! ptr2obj.empty())
+        writeLine( stream, "ptr map inconsistency!!!", pFilter );
+    writeLine( stream, "#####################################"
+               "#########################################", pFilter );
+}
+
+
+extern "C" void SAL_CALL uno_dumpEnvironmentByName(
+    void * stream, rtl_uString * pEnvDcp, const char * pFilter )
+    SAL_THROW_EXTERN_C()
+{
+    uno_Environment * pEnv = nullptr;
+    uno_getEnvironment( &pEnv, pEnvDcp, nullptr );
+    if (pEnv)
+    {
+        ::uno_dumpEnvironment( stream, pEnv, pFilter );
+        (*pEnv->release)( pEnv );
+    }
+    else
+    {
+        writeLine(
+            stream, "environment \"" + OUString::unacquired(&pEnvDcp) + "\" does not exist!",
+            pFilter );
+    }
+}
+
+namespace
+{
+    class makeOIdPart
+    {
+    private:
+        OUString m_sOidPart;
+    public:
+        makeOIdPart()
+        {
+            OUStringBuffer aRet( 64 );
+            aRet.append( "];" );
+            // pid
+            oslProcessInfo info;
+            info.Size = sizeof(oslProcessInfo);
+            if (::osl_getProcessInfo( nullptr, osl_Process_IDENTIFIER, &info ) ==
+                osl_Process_E_None)
+            {
+                aRet.append( static_cast<sal_Int64>(info.Ident), 16 );
+            }
+            else
+            {
+                aRet.append( "unknown process id" );
+            }
+            // good guid
+            sal_uInt8 ar[16];
+            ::rtl_getGlobalProcessId( ar );
+            aRet.append( ';' );
+            for (unsigned char i : ar)
+                aRet.append( static_cast<sal_Int32>(i), 16 );
+
+            m_sOidPart = aRet.makeStringAndClear();
+        }
+        const OUString& getOIdPart() const { return m_sOidPart; }
+    };
+
+    class theStaticOIdPart : public rtl::Static<makeOIdPart, theStaticOIdPart> {};
+
+const OUString & unoenv_getStaticOIdPart()
+{
+    return theStaticOIdPart::get().getOIdPart();
+}
+
+}
+
+extern "C"
+{
+
+
+static void unoenv_computeObjectIdentifier(
+    uno_ExtEnvironment * pEnv, rtl_uString ** ppOId, void * pInterface )
+{
+    assert(pEnv && ppOId && pInterface && "### null ptr!");
+    if (*ppOId)
+    {
+        ::rtl_uString_release( *ppOId );
+        *ppOId = nullptr;
+    }
+
+    uno_Interface * pUnoI = static_cast<uno_Interface *>(
+        ::cppu::binuno_queryInterface(
+            pInterface, *typelib_static_type_getByTypeClass(
+                typelib_TypeClass_INTERFACE ) ));
+    if (nullptr == pUnoI)
+        return;
+
+    (*pUnoI->release)( pUnoI );
+    // interface
+    OUStringBuffer oid( 64 );
+    oid.append( reinterpret_cast< sal_Int64 >(pUnoI), 16 );
+    oid.append( ';' );
+    // environment[context]
+    oid.append( pEnv->aBase.pTypeName );
+    oid.append( '[' );
+    oid.append( reinterpret_cast< sal_Int64 >(
+                    reinterpret_cast<
+                    uno_Environment * >(pEnv)->pContext ), 16 );
+    // process;good guid
+    oid.append( unoenv_getStaticOIdPart() );
+    OUString aStr( oid.makeStringAndClear() );
+    *ppOId = aStr.pData;
+    ::rtl_uString_acquire( *ppOId );
+}
+
+
+static void unoenv_acquireInterface(
+    SAL_UNUSED_PARAMETER uno_ExtEnvironment *, void * pUnoI_ )
+{
+    uno_Interface * pUnoI = static_cast< uno_Interface * >(pUnoI_);
+    (*pUnoI->acquire)( pUnoI );
+}
+
+
+static void unoenv_releaseInterface(
+    SAL_UNUSED_PARAMETER uno_ExtEnvironment *, void * pUnoI_ )
+{
+    uno_Interface * pUnoI = static_cast< uno_Interface * >(pUnoI_);
+    (*pUnoI->release)( pUnoI );
+}
+}
+
+namespace {
+
+EnvironmentsData::~EnvironmentsData()
+{
+    ::osl::MutexGuard guard( mutex );
+    isDisposing = true;
+
+    for ( const auto& rEntry : aName2EnvMap )
+    {
+        uno_Environment * pWeak = rEntry.second;
+        uno_Environment * pHard = nullptr;
+        (*pWeak->harden)( &pHard, pWeak );
+        (*pWeak->releaseWeak)( pWeak );
+
+        if (pHard)
+        {
+            (*pHard->dispose)( pHard ); // send explicit dispose
+            (*pHard->release)( pHard );
+        }
+    }
+}
+
+
+void EnvironmentsData::getEnvironment(
+    uno_Environment ** ppEnv, const OUString & rEnvDcp, void * pContext )
+{
+    if (*ppEnv)
+    {
+        (*(*ppEnv)->release)( *ppEnv );
+        *ppEnv = nullptr;
+    }
+
+    OUString aKey = OUString::number( reinterpret_cast< sal_IntPtr >(pContext) ) + rEnvDcp;
+
+    // try to find registered mapping
+    OUString2EnvironmentMap::const_iterator const iFind(
+        aName2EnvMap.find( aKey ) );
+    if (iFind != aName2EnvMap.end())
+    {
+        uno_Environment * pWeak = iFind->second;
+        (*pWeak->harden)( ppEnv, pWeak );
+    }
+}
+
+
+void EnvironmentsData::registerEnvironment( uno_Environment ** ppEnv )
+{
+    OSL_ENSURE( ppEnv, "### null ptr!" );
+    uno_Environment * pEnv =  *ppEnv;
+
+    OUString aKey =
+        OUString::number( reinterpret_cast< sal_IntPtr >(pEnv->pContext) ) +
+        OUString::unacquired(&pEnv->pTypeName);
+
+    // try to find registered environment
+    OUString2EnvironmentMap::const_iterator const iFind(
+        aName2EnvMap.find( aKey ) );
+    if (iFind == aName2EnvMap.end())
+    {
+        (*pEnv->acquireWeak)( pEnv );
+        std::pair< OUString2EnvironmentMap::iterator, bool > insertion (
+            aName2EnvMap.emplace( aKey, pEnv ) );
+        SAL_WARN_IF( !insertion.second, "cppu", "key " << aKey << " already in env map" );
+    }
+    else
+    {
+        uno_Environment * pHard = nullptr;
+        uno_Environment * pWeak = iFind->second;
+        (*pWeak->harden)( &pHard, pWeak );
+        if (pHard)
+        {
+            (*pEnv->release)( pEnv );
+            *ppEnv = pHard;
+        }
+        else // registered one is dead
+        {
+            (*pWeak->releaseWeak)( pWeak );
+            (*pEnv->acquireWeak)( pEnv );
+            aName2EnvMap[ aKey ] = pEnv;
+        }
+    }
+}
+
+
+void EnvironmentsData::getRegisteredEnvironments(
+    uno_Environment *** pppEnvs, sal_Int32 * pnLen, uno_memAlloc memAlloc,
+    const OUString & rEnvDcp )
+{
+    assert(pppEnvs && pnLen && memAlloc && "### null ptr!");
+
+    // max size
+    std::vector<uno_Environment*> aFounds(aName2EnvMap.size());
+    sal_Int32 nSize = 0;
+
+    // find matching environment
+    for ( const auto& rEntry : aName2EnvMap )
+    {
+        uno_Environment * pWeak = rEntry.second;
+        if (rEnvDcp.isEmpty() ||
+            rEnvDcp == pWeak->pTypeName )
+        {
+            aFounds[nSize] = nullptr;
+            (*pWeak->harden)( &aFounds[nSize], pWeak );
+            if (aFounds[nSize])
+                ++nSize;
+        }
+    }
+
+    *pnLen = nSize;
+    if (nSize)
+    {
+        *pppEnvs = static_cast<uno_Environment **>((*memAlloc)(
+            sizeof (uno_Environment *) * nSize ));
+        OSL_ASSERT( *pppEnvs );
+        while (nSize--)
+        {
+            (*pppEnvs)[nSize] = aFounds[nSize];
+        }
+    }
+    else
+    {
+        *pppEnvs = nullptr;
+    }
+}
+
+bool loadEnv(OUString const  & cLibStem,
+                    uno_Environment * pEnv)
+{
+#ifdef DISABLE_DYNLOADING
+    uno_initEnvironmentFunc fpInit;
+
+    if ( cLibStem == CPPU_CURRENT_LANGUAGE_BINDING_NAME "_uno" )
+        fpInit = CPPU_ENV_uno_initEnvironment;
+#if HAVE_FEATURE_JAVA
+    else if ( cLibStem == "java_uno" )
+        fpInit = java_uno_initEnvironment;
+#endif
+    else
+    {
+        SAL_INFO("cppu", ": Unhandled env: " << cLibStem);
+        return false;
+    }
+#else
+    // late init with some code from matching uno language binding
+    // will be unloaded by environment
+    osl::Module aMod;
+    try {
+        bool bMod = cppu::detail::loadModule(aMod, cLibStem);
+        if (!bMod)
+            return false;
+    }
+    catch(...) {
+        // Catch everything and convert to return false
+        return false;
+    }
+
+
+    uno_initEnvironmentFunc fpInit = reinterpret_cast<uno_initEnvironmentFunc>(aMod.getSymbol(UNO_INIT_ENVIRONMENT));
+
+    if (!fpInit)
+        return false;
+
+    aMod.release();
+#endif
+
+    (*fpInit)( pEnv ); // init of environment
+    return true;
+}
+
+}
+
+extern "C"
+{
+
+
+static uno_Environment * initDefaultEnvironment(
+    const OUString & rEnvDcp, void * pContext )
+{
+    // coverity[leaked_storage : FALSE] - lifetime is controlled by acquire()/release() calls
+    uno_Environment * pEnv = &(new uno_DefaultEnvironment( rEnvDcp, pContext ))->aBase;
+    (*pEnv->acquire)( pEnv );
+
+    OUString envTypeName = cppu::EnvDcp::getTypeName(rEnvDcp);
+
+    // create default environment
+    if ( envTypeName == UNO_LB_UNO )
+    {
+        uno_DefaultEnvironment * that = reinterpret_cast<uno_DefaultEnvironment *>(pEnv);
+        that->computeObjectIdentifier = unoenv_computeObjectIdentifier;
+        that->acquireInterface = unoenv_acquireInterface;
+        that->releaseInterface = unoenv_releaseInterface;
+
+        OUString envPurpose = cppu::EnvDcp::getPurpose(rEnvDcp);
+        if (!envPurpose.isEmpty())
+        {
+            OUString libStem(
+                envPurpose.copy(envPurpose.lastIndexOf(':') + 1) + "_uno_uno");
+            if(!loadEnv(libStem, pEnv))
+            {
+                pEnv->release(pEnv);
+                return nullptr;
+            }
+        }
+    }
+    else
+    {
+        // late init with some code from matching uno language binding
+        OUString aStr( envTypeName + "_uno" );
+
+        if (!loadEnv(aStr, pEnv))
+        {
+            pEnv->release(pEnv);
+            return nullptr;
+        }
+    }
+
+    return pEnv;
+}
+
+
+void SAL_CALL uno_createEnvironment(
+    uno_Environment ** ppEnv, rtl_uString * pEnvDcp, void * pContext )
+    SAL_THROW_EXTERN_C()
+{
+    assert(ppEnv && "### null ptr!");
+    if (*ppEnv)
+        (*(*ppEnv)->release)( *ppEnv );
+
+    OUString const & rEnvDcp = OUString::unacquired( &pEnvDcp );
+    *ppEnv = initDefaultEnvironment( rEnvDcp, pContext );
+}
+
+void SAL_CALL uno_getEnvironment(
+    uno_Environment ** ppEnv, rtl_uString * pEnvDcp, void * pContext )
+    SAL_THROW_EXTERN_C()
+{
+    assert(ppEnv && "### null ptr!");
+    OUString const & rEnvDcp = OUString::unacquired( &pEnvDcp );
+
+    EnvironmentsData & rData = theEnvironmentsData::get();
+
+    ::osl::MutexGuard guard( rData.mutex );
+    rData.getEnvironment( ppEnv, rEnvDcp, pContext );
+    if (! *ppEnv)
+    {
+        *ppEnv = initDefaultEnvironment( rEnvDcp, pContext );
+        if (*ppEnv)
+        {
+            // register new environment:
+            rData.registerEnvironment( ppEnv );
+        }
+    }
+}
+
+void SAL_CALL uno_getRegisteredEnvironments(
+    uno_Environment *** pppEnvs, sal_Int32 * pnLen, uno_memAlloc memAlloc,
+    rtl_uString * pEnvDcp )
+    SAL_THROW_EXTERN_C()
+{
+    EnvironmentsData & rData = theEnvironmentsData::get();
+
+    ::osl::MutexGuard guard( rData.mutex );
+    rData.getRegisteredEnvironments(
+        pppEnvs, pnLen, memAlloc,
+        (pEnvDcp ? OUString(pEnvDcp) : OUString()) );
+}
+
+} // extern "C"
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppu/source/uno/lbmap.cxx b/cppu/source/uno/lbmap.cxx
new file mode 100644
index 000000000..1e8655a99
--- /dev/null
+++ b/cppu/source/uno/lbmap.cxx
@@ -0,0 +1,752 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifdef DISABLE_DYNLOADING
+#include <config_java.h>
+#endif
+
+#include "IdentityMapping.hxx"
+
+#include <cassert>
+#include <set>
+#include <unordered_map>
+
+#include <rtl/ustring.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <osl/module.hxx>
+#include <osl/diagnose.h>
+#include <osl/mutex.hxx>
+#include <osl/interlck.h>
+#include <sal/log.hxx>
+
+#include <uno/dispatcher.h>
+#include <uno/mapping.h>
+#include <uno/lbnames.h>
+#include <uno/environment.hxx>
+
+#include <typelib/typedescription.h>
+
+#include <cppu/EnvDcp.hxx>
+#include "cascade_mapping.hxx"
+#include "loadmodule.hxx"
+
+using namespace std;
+using namespace osl;
+using namespace com::sun::star::uno;
+
+namespace cppu
+{
+
+namespace {
+
+class Mapping
+{
+    uno_Mapping * _pMapping;
+
+public:
+    inline explicit Mapping( uno_Mapping * pMapping = nullptr );
+    inline Mapping( const Mapping & rMapping );
+    Mapping(Mapping && other) noexcept : _pMapping(other._pMapping)
+    { other._pMapping = nullptr; }
+    inline ~Mapping();
+    inline Mapping & operator = ( uno_Mapping * pMapping );
+    Mapping & operator = ( const Mapping & rMapping )
+        { return operator = ( rMapping._pMapping ); }
+    Mapping & operator =(Mapping && other) noexcept {
+        if (_pMapping != nullptr) {
+            (*_pMapping->release)(_pMapping);
+        }
+        _pMapping = other._pMapping;
+        other._pMapping = nullptr;
+        return *this;
+    }
+    uno_Mapping * get() const
+        { return _pMapping; }
+    bool is() const
+        { return (_pMapping != nullptr); }
+};
+
+}
+
+inline Mapping::Mapping( uno_Mapping * pMapping )
+    : _pMapping( pMapping )
+{
+    if (_pMapping)
+        (*_pMapping->acquire)( _pMapping );
+}
+
+inline Mapping::Mapping( const Mapping & rMapping )
+    : _pMapping( rMapping._pMapping )
+{
+    if (_pMapping)
+        (*_pMapping->acquire)( _pMapping );
+}
+
+inline Mapping::~Mapping()
+{
+    if (_pMapping)
+        (*_pMapping->release)( _pMapping );
+}
+
+inline Mapping & Mapping::operator = ( uno_Mapping * pMapping )
+{
+    if (pMapping)
+        (*pMapping->acquire)( pMapping );
+    if (_pMapping)
+        (*_pMapping->release)( _pMapping );
+    _pMapping = pMapping;
+    return *this;
+}
+
+namespace {
+
+struct MappingEntry
+{
+    sal_Int32           nRef;
+    uno_Mapping *       pMapping;
+    uno_freeMappingFunc freeMapping;
+    OUString            aMappingName;
+
+    MappingEntry(
+        uno_Mapping * pMapping_, uno_freeMappingFunc freeMapping_,
+        const OUString & rMappingName_ )
+        : nRef( 1 )
+        , pMapping( pMapping_ )
+        , freeMapping( freeMapping_ )
+        , aMappingName( rMappingName_ )
+        {}
+};
+
+struct FctPtrHash
+{
+    size_t operator()( uno_Mapping * pKey ) const
+        { return reinterpret_cast<size_t>(pKey); }
+};
+
+}
+
+typedef std::unordered_map<
+    OUString, MappingEntry * > t_OUString2Entry;
+typedef std::unordered_map<
+    uno_Mapping *, MappingEntry *, FctPtrHash > t_Mapping2Entry;
+
+namespace {
+
+struct MappingsData
+{
+    Mutex               aMappingsMutex;
+    t_OUString2Entry    aName2Entry;
+    t_Mapping2Entry     aMapping2Entry;
+
+    Mutex               aCallbacksMutex;
+    set< uno_getMappingFunc >
+                        aCallbacks;
+
+    Mutex               aNegativeLibsMutex;
+    set<OUString>       aNegativeLibs;
+};
+
+}
+
+static MappingsData & getMappingsData()
+{
+    //TODO  This memory is leaked; see #i63473# for when this should be
+    // changed again:
+    static MappingsData * s_p(new MappingsData);
+
+    return *s_p;
+}
+
+namespace {
+
+/**
+ * This class mediates two different mapping via uno, e.g. form any language to uno,
+ * then from uno to any other language.
+ */
+struct uno_Mediate_Mapping : public uno_Mapping
+{
+    sal_Int32   nRef;
+
+    Environment aFrom;
+    Environment aTo;
+
+    Mapping     aFrom2Uno;
+    Mapping     aUno2To;
+
+    OUString    aAddPurpose;
+
+    uno_Mediate_Mapping(
+        const Environment & rFrom_, const Environment & rTo_,
+        const Mapping & rFrom2Uno_, const Mapping & rUno2To_,
+        const OUString & rAddPurpose );
+};
+
+}
+
+extern "C"
+{
+
+static void mediate_free( uno_Mapping * pMapping )
+{
+    delete static_cast< uno_Mediate_Mapping * >( pMapping );
+}
+
+static void mediate_acquire( uno_Mapping * pMapping )
+{
+    if (1 == osl_atomic_increment(
+        & static_cast< uno_Mediate_Mapping * >( pMapping )->nRef ))
+    {
+        uno_registerMapping(
+            &pMapping, mediate_free,
+            static_cast< uno_Mediate_Mapping * >( pMapping )->aFrom.get(),
+            static_cast< uno_Mediate_Mapping * >( pMapping )->aTo.get(),
+            static_cast< uno_Mediate_Mapping * >( pMapping )->aAddPurpose.pData );
+    }
+}
+
+static void mediate_release( uno_Mapping * pMapping )
+{
+    if (! osl_atomic_decrement(
+        & static_cast< uno_Mediate_Mapping * >( pMapping )->nRef ))
+    {
+        uno_revokeMapping( pMapping );
+    }
+}
+
+static void mediate_mapInterface(
+    uno_Mapping * pMapping,
+    void ** ppOut, void * pInterface,
+    typelib_InterfaceTypeDescription * pInterfaceTypeDescr )
+{
+    OSL_ENSURE( pMapping && ppOut, "### null ptr!" );
+    if (!(pMapping && ppOut))
+        return;
+
+    uno_Mediate_Mapping * that = static_cast< uno_Mediate_Mapping * >( pMapping );
+    uno_Mapping * pFrom2Uno = that->aFrom2Uno.get();
+
+    uno_Interface * pUnoI = nullptr;
+    (*pFrom2Uno->mapInterface)( pFrom2Uno, reinterpret_cast<void **>(&pUnoI), pInterface, pInterfaceTypeDescr );
+    if (nullptr == pUnoI)
+    {
+        void * pOut = *ppOut;
+        if (nullptr != pOut)
+        {
+            uno_ExtEnvironment * pTo = that->aTo.get()->pExtEnv;
+            OSL_ENSURE( nullptr != pTo, "### cannot release out interface: leaking!" );
+            if (nullptr != pTo)
+                (*pTo->releaseInterface)( pTo, pOut );
+            *ppOut = nullptr; // set to 0 anyway, because mapping was not successful!
+        }
+    }
+    else
+    {
+        uno_Mapping * pUno2To = that->aUno2To.get();
+        (*pUno2To->mapInterface)( pUno2To, ppOut, pUnoI, pInterfaceTypeDescr );
+        (*pUnoI->release)( pUnoI );
+    }
+}
+}
+
+uno_Mediate_Mapping::uno_Mediate_Mapping(
+    const Environment & rFrom_, const Environment & rTo_,
+    const Mapping & rFrom2Uno_, const Mapping & rUno2To_,
+    const OUString & rAddPurpose_ )
+    : nRef( 1 )
+    , aFrom( rFrom_ )
+    , aTo( rTo_ )
+    , aFrom2Uno( rFrom2Uno_ )
+    , aUno2To( rUno2To_ )
+    , aAddPurpose( rAddPurpose_ )
+{
+    uno_Mapping::acquire        = mediate_acquire;
+    uno_Mapping::release        = mediate_release;
+    uno_Mapping::mapInterface   = mediate_mapInterface;
+}
+
+
+static OUString getMappingName(
+    const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose )
+{
+    OUStringBuffer aKey( 64 );
+    aKey.append( rAddPurpose );
+    aKey.append( ';' );
+    aKey.append( rFrom.getTypeName() );
+    aKey.append( '[' );
+    aKey.append( reinterpret_cast< sal_IntPtr >(rFrom.get()), 16 );
+    aKey.append( "];" );
+    aKey.append( rTo.getTypeName() );
+    aKey.append( '[' );
+    aKey.append( reinterpret_cast< sal_IntPtr >(rTo.get()), 16 );
+    aKey.append( ']' );
+    return aKey.makeStringAndClear();
+}
+
+static OUString getBridgeName(
+    const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose )
+{
+    OUStringBuffer aBridgeName( 16 );
+    if (!rAddPurpose.isEmpty())
+    {
+        aBridgeName.append( rAddPurpose );
+        aBridgeName.append( '_' );
+    }
+    aBridgeName.append( EnvDcp::getTypeName(rFrom.getTypeName()) );
+    aBridgeName.append( '_' );
+    aBridgeName.append( EnvDcp::getTypeName(rTo.getTypeName()) );
+    return aBridgeName.makeStringAndClear();
+}
+
+#ifndef DISABLE_DYNLOADING
+
+static void setNegativeBridge( const OUString & rBridgeName )
+{
+    MappingsData & rData = getMappingsData();
+    MutexGuard aGuard( rData.aNegativeLibsMutex );
+    rData.aNegativeLibs.insert( rBridgeName );
+}
+
+#endif
+
+#ifdef DISABLE_DYNLOADING
+
+static uno_ext_getMappingFunc selectMapFunc( const OUString & rBridgeName )
+{
+    if (rBridgeName.equalsAscii( CPPU_CURRENT_LANGUAGE_BINDING_NAME "_uno" ))
+        return CPPU_ENV_uno_ext_getMapping;
+#if HAVE_FEATURE_JAVA
+    if (rBridgeName.equalsAscii( "java" "_uno" ))
+        return java_uno_ext_getMapping;
+#endif
+
+#if 0
+    // I don't think the affine or log bridges will be needed on any
+    // DISABLE_DYNLOADING platform (iOS at least, possibly Android), but if
+    // somebody wants to experiment, need to find out then whether these are
+    // needed.
+    if (rBridgeName.equalsAscii( "affine_uno_uno" ))
+        return affine_uno_uno_ext_getMapping;
+    if (rBridgeName.equalsAscii( "log_uno_uno" ))
+        return log_uno_uno_ext_getMapping;
+#endif
+    return 0;
+}
+
+#else
+
+static bool loadModule(osl::Module & rModule, const OUString & rBridgeName)
+{
+    bool bNeg;
+    {
+    MappingsData & rData = getMappingsData();
+    MutexGuard aGuard( rData.aNegativeLibsMutex );
+    const auto iFind( rData.aNegativeLibs.find( rBridgeName ) );
+    bNeg = (iFind != rData.aNegativeLibs.end());
+    }
+
+    if (!bNeg)
+    {
+        bool bModule;
+        try {
+            bModule = cppu::detail::loadModule(rModule, rBridgeName);
+        }
+        catch(...) {
+            // convert throw to return false
+            bModule = false;
+        }
+
+        if (bModule)
+            return true;
+
+        setNegativeBridge( rBridgeName ); // no load again
+    }
+    return false;
+}
+
+#endif
+
+
+static Mapping loadExternalMapping(
+    const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose )
+{
+    OSL_ASSERT( rFrom.is() && rTo.is() );
+    if (rFrom.is() && rTo.is())
+    {
+#ifdef DISABLE_DYNLOADING
+        OUString aName;
+        uno_ext_getMappingFunc fpGetMapFunc = 0;
+
+        if (EnvDcp::getTypeName(rFrom.getTypeName()) == UNO_LB_UNO)
+        {
+            aName = getBridgeName( rTo, rFrom, rAddPurpose );
+            fpGetMapFunc = selectMapFunc( aName );
+        }
+        if (! fpGetMapFunc)
+        {
+            aName = getBridgeName( rFrom, rTo, rAddPurpose );
+            fpGetMapFunc = selectMapFunc( aName );
+        }
+        if (! fpGetMapFunc)
+        {
+            aName = getBridgeName( rTo, rFrom, rAddPurpose );
+            fpGetMapFunc = selectMapFunc( aName );
+        }
+
+        if (! fpGetMapFunc)
+        {
+            SAL_INFO("cppu", "Could not find mapfunc for " << aName);
+            return Mapping();
+        }
+
+        if (fpGetMapFunc)
+        {
+            Mapping aExt;
+            (*fpGetMapFunc)( (uno_Mapping **)&aExt, rFrom.get(), rTo.get() );
+            OSL_ASSERT( aExt.is() );
+            if (aExt.is())
+                return aExt;
+        }
+#else
+        // find proper lib
+        osl::Module aModule;
+        bool bModule(false);
+        OUString aName;
+
+        if ( EnvDcp::getTypeName(rFrom.getTypeName()) == UNO_LB_UNO )
+        {
+            aName = getBridgeName( rTo, rFrom, rAddPurpose );
+            bModule = loadModule( aModule, aName );
+        }
+        if (!bModule)
+        {
+            aName = getBridgeName( rFrom, rTo, rAddPurpose );
+            bModule = loadModule( aModule, aName );
+        }
+        if (!bModule)
+        {
+            aName = getBridgeName( rTo, rFrom, rAddPurpose );
+            bModule = loadModule( aModule, aName );
+        }
+
+        if (bModule)
+        {
+            uno_ext_getMappingFunc fpGetMapFunc =
+                reinterpret_cast<uno_ext_getMappingFunc>(aModule.getSymbol( UNO_EXT_GETMAPPING ));
+
+            if (fpGetMapFunc)
+            {
+                Mapping aExt;
+                (*fpGetMapFunc)( reinterpret_cast<uno_Mapping **>(&aExt), rFrom.get(), rTo.get() );
+                OSL_ASSERT( aExt.is() );
+                if (aExt.is())
+                {
+                    aModule.release();
+                    return aExt;
+                }
+            }
+            aModule.unload();
+            setNegativeBridge( aName );
+        }
+#endif
+    }
+    return Mapping();
+}
+
+
+static Mapping getDirectMapping(
+    const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose = OUString() )
+
+{
+    OSL_ASSERT( rFrom.is() && rTo.is() );
+    if (rFrom.is() && rTo.is())
+    {
+        MappingsData & rData = getMappingsData();
+        ClearableMutexGuard aGuard( rData.aMappingsMutex );
+
+        // try to find registered mapping
+        const t_OUString2Entry::const_iterator iFind( rData.aName2Entry.find(
+            getMappingName( rFrom, rTo, rAddPurpose ) ) );
+
+        if (iFind == rData.aName2Entry.end())
+        {
+            aGuard.clear();
+            return loadExternalMapping( rFrom, rTo, rAddPurpose );
+        }
+        return Mapping( (*iFind).second->pMapping );
+    }
+    return Mapping();
+}
+
+
+static Mapping createMediateMapping(
+    const Environment & rFrom, const Environment & rTo,
+    const Mapping & rFrom2Uno, const Mapping & rUno2To,
+    const OUString & rAddPurpose )
+{
+    uno_Mapping * pRet = new uno_Mediate_Mapping(
+        rFrom, rTo, rFrom2Uno, rUno2To, rAddPurpose ); // ref count initially 1
+    uno_registerMapping(
+        &pRet, mediate_free, rFrom.get(), rTo.get(), rAddPurpose.pData );
+    Mapping aRet( pRet );
+    (*pRet->release)( pRet );
+    return aRet;
+}
+
+static Mapping getMediateMapping(
+    const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose )
+{
+    Environment aUno;
+    Mapping aUno2To;
+
+    // backwards: from dest to source of mapping chain
+
+    // connect to uno
+    OUString aUnoEnvTypeName( UNO_LB_UNO );
+    if (rTo.getTypeName() == aUnoEnvTypeName) // to is uno
+    {
+        aUno = rTo;
+        // no Uno2To mapping necessary
+    }
+    else
+    {
+        // get registered uno env
+        ::uno_getEnvironment( reinterpret_cast<uno_Environment **>(&aUno), aUnoEnvTypeName.pData, nullptr );
+
+        aUno2To = getDirectMapping( aUno, rTo );
+        // : uno <-> to
+        if (! aUno2To.is())
+            return Mapping();
+    }
+
+    // connect to uno
+    if (!rAddPurpose.isEmpty()) // insert purpose mapping between new ano_uno <-> uno
+    {
+        // create anonymous uno env
+        Environment aAnUno;
+        ::uno_createEnvironment( reinterpret_cast<uno_Environment **>(&aAnUno), aUnoEnvTypeName.pData, nullptr );
+
+        Mapping aAnUno2Uno( getDirectMapping( aAnUno, aUno, rAddPurpose ) );
+        if (! aAnUno2Uno.is())
+            return Mapping();
+
+        if (aUno2To.is()) // to is not uno
+        {
+            // create another purposed mediate mapping
+            aUno2To = createMediateMapping( aAnUno, rTo, aAnUno2Uno, aUno2To, rAddPurpose );
+            // : ano_uno <-> uno <-> to
+        }
+        else
+        {
+            aUno2To = aAnUno2Uno;
+            // : ano_uno <-> to (i.e., uno)
+        }
+        aUno = aAnUno;
+    }
+
+    Mapping aFrom2Uno( getDirectMapping( rFrom, aUno ) );
+    if (aFrom2Uno.is() && aUno2To.is())
+    {
+        return createMediateMapping( rFrom, rTo, aFrom2Uno, aUno2To, rAddPurpose );
+        // : from <-> some uno ...
+    }
+
+    return Mapping();
+}
+}
+
+using namespace ::cppu;
+
+extern "C"
+{
+
+void SAL_CALL uno_getMapping(
+    uno_Mapping ** ppMapping, uno_Environment * pFrom, uno_Environment * pTo,
+    rtl_uString * pAddPurpose )
+    SAL_THROW_EXTERN_C()
+{
+    assert(ppMapping != nullptr);
+    assert(pFrom != nullptr);
+    assert(pTo != nullptr);
+    if (*ppMapping)
+    {
+        (*(*ppMapping)->release)( *ppMapping );
+        *ppMapping = nullptr;
+    }
+
+    Mapping aRet;
+    Environment aFrom( pFrom ), aTo( pTo );
+
+    OUString aAddPurpose;
+    if (pAddPurpose)
+        aAddPurpose = pAddPurpose;
+
+    MappingsData & rData = getMappingsData();
+
+    // try registered mapping
+    {
+    MutexGuard aGuard( rData.aMappingsMutex );
+    const t_OUString2Entry::const_iterator iFind( rData.aName2Entry.find(
+        getMappingName( aFrom, aTo, aAddPurpose ) ) );
+    if (iFind != rData.aName2Entry.end())
+        aRet = (*iFind).second->pMapping;
+    }
+
+    // See if an identity mapping does fit.
+    if (!aRet.is() && pFrom == pTo && aAddPurpose.isEmpty())
+        aRet = createIdentityMapping(pFrom);
+
+    if (!aRet.is())
+    {
+        getCascadeMapping(ppMapping, pFrom, pTo, pAddPurpose);
+
+        if (*ppMapping)
+            return;
+
+        // try callback chain
+        {
+            MutexGuard aGuard(rData.aCallbacksMutex);
+            for (const auto& rCallback : rData.aCallbacks)
+            {
+                (*rCallback)(ppMapping, pFrom, pTo, aAddPurpose.pData);
+                if (*ppMapping)
+                    return;
+            }
+        }
+
+        aRet = loadExternalMapping( aFrom, aTo, aAddPurpose ); // direct try
+        if (! aRet.is())
+            aRet = getMediateMapping( aFrom, aTo, aAddPurpose ); // try via uno
+    }
+
+    if (aRet.is())
+    {
+        (*aRet.get()->acquire)( aRet.get() );
+        *ppMapping = aRet.get();
+    }
+}
+
+void SAL_CALL uno_getMappingByName(
+    uno_Mapping ** ppMapping, rtl_uString * pFrom, rtl_uString * pTo,
+    rtl_uString * pAddPurpose )
+    SAL_THROW_EXTERN_C()
+{
+    assert(ppMapping && pFrom && pTo && "### null ptr!");
+    if (*ppMapping)
+    {
+        (*(*ppMapping)->release)( *ppMapping );
+        *ppMapping = nullptr;
+    }
+
+    uno_Environment * pEFrom = nullptr;
+    uno_getEnvironment( &pEFrom, pFrom, nullptr );
+    OSL_ENSURE( pEFrom, "### cannot get source environment!" );
+    if (pEFrom)
+    {
+        uno_Environment * pETo = nullptr;
+        uno_getEnvironment( &pETo, pTo, nullptr );
+        OSL_ENSURE( pETo, "### cannot get target environment!" );
+        if (pETo)
+        {
+            ::uno_getMapping( ppMapping, pEFrom, pETo, pAddPurpose );
+            (*pETo->release)( pETo );
+        }
+        (*pEFrom->release)( pEFrom );
+    }
+}
+
+
+void SAL_CALL uno_registerMapping(
+    uno_Mapping ** ppMapping, uno_freeMappingFunc freeMapping,
+    uno_Environment * pFrom, uno_Environment * pTo, rtl_uString * pAddPurpose )
+    SAL_THROW_EXTERN_C()
+{
+    MappingsData & rData = getMappingsData();
+    ClearableMutexGuard aGuard( rData.aMappingsMutex );
+
+    const t_Mapping2Entry::const_iterator iFind( rData.aMapping2Entry.find( *ppMapping ) );
+    if (iFind == rData.aMapping2Entry.end())
+    {
+        OUString aMappingName(
+            getMappingName( pFrom, pTo, pAddPurpose ? OUString(pAddPurpose) : OUString() ) );
+        SAL_INFO("cppu", "> inserting new mapping: " << aMappingName);
+        // count initially 1
+        MappingEntry * pEntry = new MappingEntry( *ppMapping, freeMapping, aMappingName );
+        rData.aName2Entry[ aMappingName ] = pEntry;
+        rData.aMapping2Entry[ *ppMapping ] = pEntry;
+    }
+    else
+    {
+        MappingEntry * pEntry = (*iFind).second;
+        ++pEntry->nRef;
+
+        if (pEntry->pMapping != *ppMapping) // exchange mapping to be registered
+        {
+            (*pEntry->pMapping->acquire)( pEntry->pMapping );
+            --pEntry->nRef; // correct count; kill mapping to be registered
+            aGuard.clear();
+            (*freeMapping)( *ppMapping );
+            *ppMapping = pEntry->pMapping;
+        }
+    }
+}
+
+void SAL_CALL uno_revokeMapping(
+    uno_Mapping * pMapping )
+    SAL_THROW_EXTERN_C()
+{
+    MappingsData & rData = getMappingsData();
+    ClearableMutexGuard aGuard( rData.aMappingsMutex );
+
+    const t_Mapping2Entry::const_iterator iFind( rData.aMapping2Entry.find( pMapping ) );
+    OSL_ASSERT( iFind != rData.aMapping2Entry.end() );
+    MappingEntry * pEntry = (*iFind).second;
+    if (! --pEntry->nRef)
+    {
+        rData.aMapping2Entry.erase( pEntry->pMapping );
+        rData.aName2Entry.erase( pEntry->aMappingName );
+        aGuard.clear();
+        SAL_INFO("cppu", "> revoking mapping " << pEntry->aMappingName);
+        (*pEntry->freeMapping)( pEntry->pMapping );
+        delete pEntry;
+    }
+}
+
+
+void SAL_CALL uno_registerMappingCallback(
+    uno_getMappingFunc pCallback )
+    SAL_THROW_EXTERN_C()
+{
+    OSL_ENSURE( pCallback, "### null ptr!" );
+    MappingsData & rData = getMappingsData();
+    MutexGuard aGuard( rData.aCallbacksMutex );
+    rData.aCallbacks.insert( pCallback );
+}
+
+void SAL_CALL uno_revokeMappingCallback(
+    uno_getMappingFunc pCallback )
+    SAL_THROW_EXTERN_C()
+{
+    OSL_ENSURE( pCallback, "### null ptr!" );
+    MappingsData & rData = getMappingsData();
+    MutexGuard aGuard( rData.aCallbacksMutex );
+    rData.aCallbacks.erase( pCallback );
+}
+} // extern "C"
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppu/source/uno/loadmodule.cxx b/cppu/source/uno/loadmodule.cxx
new file mode 100644
index 000000000..f3ba0ba21
--- /dev/null
+++ b/cppu/source/uno/loadmodule.cxx
@@ -0,0 +1,76 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+
+#include <sal/config.h>
+
+#include <cassert>
+
+#include <osl/module.h>
+#include <osl/module.hxx>
+#include <rtl/malformeduriexception.hxx>
+#include <rtl/uri.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <rtl/ustring.hxx>
+#include <sal/log.hxx>
+
+#include "loadmodule.hxx"
+
+namespace cppu::detail {
+
+#ifndef DISABLE_DYNLOADING
+
+bool loadModule(osl::Module& rModule, OUString const & name) {
+    static OUString base = [] {
+            OUString url;
+            if (!osl::Module::getUrlFromAddress(
+                    reinterpret_cast<oslGenericFunction>(&loadModule), url))
+            {
+                SAL_WARN("cppu", "osl::Module::getUrlFromAddress failed");
+                return OUString();
+            }
+            assert(!url.isEmpty());
+            return url;
+        }();
+    if (base.isEmpty()) {
+        SAL_INFO("cppu", "osl::Module::getUrlFromAddress had failed");
+        return false;
+    }
+    OUString b =
+#if defined SAL_DLLPREFIX
+        SAL_DLLPREFIX +
+#endif
+        name +
+        SAL_DLLEXTENSION;
+    try {
+        b = rtl::Uri::convertRelToAbs(base, b);
+    } catch (rtl::MalformedUriException & e) {
+        SAL_INFO("cppu", "rtl::MalformedUriException <" << e.getMessage() << ">");
+        return false;
+    }
+    return rModule.load(
+        b,
+        SAL_LOADMODULE_GLOBAL | SAL_LOADMODULE_LAZY);
+}
+
+#endif
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppu/source/uno/loadmodule.hxx b/cppu/source/uno/loadmodule.hxx
new file mode 100644
index 000000000..cde33594c
--- /dev/null
+++ b/cppu/source/uno/loadmodule.hxx
@@ -0,0 +1,48 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#ifndef INCLUDED_CPPU_SOURCE_UNO_LOADMODULE_HXX
+#define INCLUDED_CPPU_SOURCE_UNO_LOADMODULE_HXX
+
+#include <sal/config.h>
+#include <rtl/ustring.hxx>
+
+namespace osl { class Module; }
+
+namespace cppu::detail {
+
+#ifndef DISABLE_DYNLOADING
+
+/** Load a module.
+
+    @param name
+    the nucleus of a module name (without any "lib...so", ".dll", etc.
+    decoration, and without a path).
+
+    @return false if the module could not be loaded, otherwise true
+*/
+bool loadModule(osl::Module & rModule, OUString const & name);
+
+#endif
+
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppu/source/uno/prim.hxx b/cppu/source/uno/prim.hxx
new file mode 100644
index 000000000..84f96e7fd
--- /dev/null
+++ b/cppu/source/uno/prim.hxx
@@ -0,0 +1,156 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+#ifndef INCLUDED_CPPU_SOURCE_UNO_PRIM_HXX
+#define INCLUDED_CPPU_SOURCE_UNO_PRIM_HXX
+
+#include <typelib/typedescription.h>
+#include <typelib/typeclass.h>
+#include <uno/sequence2.h>
+#include <uno/any2.h>
+#include <uno/data.h>
+#include <uno/mapping.h>
+#include <uno/dispatcher.h>
+
+#include <osl/interlck.h>
+#include <stdint.h>
+
+namespace cppu
+{
+
+extern uno_Sequence g_emptySeq;
+extern typelib_TypeDescriptionReference * g_pVoidType;
+
+
+inline void * _map(
+    void * p,
+    typelib_TypeDescriptionReference * pType, typelib_TypeDescription * pTypeDescr,
+    uno_Mapping * mapping )
+
+{
+    void * pRet = nullptr;
+    if (p)
+    {
+        if (pTypeDescr)
+        {
+            (*mapping->mapInterface)(
+                mapping, &pRet, p, reinterpret_cast<typelib_InterfaceTypeDescription *>(pTypeDescr) );
+        }
+        else
+        {
+            TYPELIB_DANGER_GET( &pTypeDescr, pType );
+            (*mapping->mapInterface)(
+                mapping, &pRet, p, reinterpret_cast<typelib_InterfaceTypeDescription *>(pTypeDescr) );
+            TYPELIB_DANGER_RELEASE( pTypeDescr );
+        }
+    }
+    return pRet;
+}
+
+inline void _acquire( void * p, uno_AcquireFunc acquire )
+{
+    if (p)
+    {
+        if (acquire)
+        {
+            (*acquire)( p );
+        }
+        else
+        {
+            (*static_cast<uno_Interface *>(p)->acquire)( static_cast<uno_Interface *>(p) );
+        }
+    }
+}
+
+inline void _release( void * p, uno_ReleaseFunc release )
+{
+    if (p)
+    {
+        if (release)
+        {
+            (*release)( p );
+        }
+        else
+        {
+            (*static_cast<uno_Interface *>(p)->release)( static_cast<uno_Interface *>(p) );
+        }
+    }
+}
+
+
+inline sal_uInt32 calcSeqMemSize(
+    sal_Int32 nElementSize, sal_Int32 nElements )
+{
+    sal_uInt64 nSize =
+        static_cast<sal_uInt64>(SAL_SEQUENCE_HEADER_SIZE) +
+        (static_cast<sal_uInt64>(nElementSize) * static_cast<sal_uInt64>(nElements));
+    if (nSize > 0xffffffffU)
+        return 0;
+    else
+        return static_cast<sal_uInt32>(nSize);
+}
+
+
+inline uno_Sequence * createEmptySequence()
+{
+    osl_atomic_increment( &g_emptySeq.nRefCount );
+    return &g_emptySeq;
+}
+
+inline typelib_TypeDescriptionReference * _getVoidType()
+{
+    if (! g_pVoidType)
+    {
+        g_pVoidType = * ::typelib_static_type_getByTypeClass( typelib_TypeClass_VOID );
+    }
+    ::typelib_typedescriptionreference_acquire( g_pVoidType );
+    return g_pVoidType;
+}
+
+inline void CONSTRUCT_EMPTY_ANY(uno_Any * pAny) {
+    pAny->pType = _getVoidType();
+#if OSL_DEBUG_LEVEL > 0
+    pAny->pData = reinterpret_cast<void *>(uintptr_t(0xdeadbeef));
+#else
+    pAny->pData = pAny;
+#endif
+}
+
+#define TYPE_ACQUIRE( pType ) \
+    osl_atomic_increment( &(pType)->nRefCount );
+
+
+extern "C" void * binuno_queryInterface(
+    void * pUnoI, typelib_TypeDescriptionReference * pDestType );
+
+
+inline bool _type_equals(
+    typelib_TypeDescriptionReference const * pType1, typelib_TypeDescriptionReference const * pType2 )
+
+{
+    return (pType1 == pType2 ||
+            (pType1->eTypeClass == pType2->eTypeClass &&
+             pType1->pTypeName->length == pType2->pTypeName->length &&
+             ::rtl_ustr_compare( pType1->pTypeName->buffer, pType2->pTypeName->buffer ) == 0));
+}
+
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppu/source/uno/sequence.cxx b/cppu/source/uno/sequence.cxx
new file mode 100644
index 000000000..72d3e3ead
--- /dev/null
+++ b/cppu/source/uno/sequence.cxx
@@ -0,0 +1,913 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ *   Licensed to the Apache Software Foundation (ASF) under one or more
+ *   contributor license agreements. See the NOTICE file distributed
+ *   with this work for additional information regarding copyright
+ *   ownership. The ASF licenses this file to you under the Apache
+ *   License, Version 2.0 (the "License"); you may not use this file
+ *   except in compliance with the License. You may obtain a copy of
+ *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+#include <sal/config.h>
+
+#include <cassert>
+#include <string.h>
+
+#include <osl/diagnose.h>
+#include <osl/interlck.h>
+#include <typelib/typedescription.h>
+#include <uno/data.h>
+#include <uno/sequence2.h>
+
+#include "constr.hxx"
+#include "copy.hxx"
+#include "destr.hxx"
+
+
+using namespace cppu;
+
+namespace cppu
+{
+
+
+static uno_Sequence * reallocSeq(
+    uno_Sequence * pReallocate, std::size_t nElementSize, sal_Int32 nElements )
+{
+    OSL_ASSERT( nElements >= 0 );
+    uno_Sequence * pNew = nullptr;
+    sal_uInt32 nSize = calcSeqMemSize( nElementSize, nElements );
+    if (nSize > 0)
+    {
+        if (pReallocate == nullptr)
+        {
+            pNew = static_cast<uno_Sequence *>(std::malloc( nSize ));
+        }
+        else
+        {
+            pNew = static_cast<uno_Sequence *>(std::realloc( pReallocate, nSize ));
+        }
+        if (pNew != nullptr)
+        {
+            // header init
+            pNew->nRefCount = 1;
+            pNew->nElements = nElements;
+        }
+    }
+    return pNew;
+}
+
+
+static bool idefaultConstructElements(
+    uno_Sequence ** ppSeq,
+    typelib_TypeDescriptionReference * pElementType,
+    sal_Int32 nStartIndex, sal_Int32 nStopIndex,
+    sal_Int32 nAlloc ) // >= 0 means (re)alloc memory for nAlloc elements
+{
+    uno_Sequence * pSeq = *ppSeq;
+    switch (pElementType->eTypeClass)
+    {
+    case typelib_TypeClass_CHAR:
+        if (nAlloc >= 0)
+            pSeq = reallocSeq( pSeq, sizeof(sal_Unicode), nAlloc );
+        if (pSeq != nullptr)
+        {
+            memset(
+                pSeq->elements + (sizeof(sal_Unicode) * nStartIndex),
+                0,
+                sizeof(sal_Unicode) * (nStopIndex - nStartIndex) );
+        }
+        break;
+    case typelib_TypeClass_BOOLEAN:
+        if (nAlloc >= 0)
+            pSeq = reallocSeq( pSeq, sizeof(sal_Bool), nAlloc );
+        if (pSeq != nullptr)
+        {
+            memset(
+                pSeq->elements + (sizeof(sal_Bool) * nStartIndex),
+                0,
+                sizeof(sal_Bool) * (nStopIndex - nStartIndex) );
+        }
+        break;
+    case typelib_TypeClass_BYTE:
+        if (nAlloc >= 0)
+            pSeq = reallocSeq( pSeq, sizeof(sal_Int8), nAlloc );
+        if (pSeq != nullptr)
+        {
+            memset(
+                pSeq->elements + (sizeof(sal_Int8) * nStartIndex),
+                0,
+                sizeof(sal_Int8) * (nStopIndex - nStartIndex) );
+        }
+        break;
+    case typelib_TypeClass_SHORT:
+    case typelib_TypeClass_UNSIGNED_SHORT:
+        if (nAlloc >= 0)
+            pSeq = reallocSeq( pSeq, sizeof(sal_Int16), nAlloc );
+        if (pSeq != nullptr)
+        {
+            memset(
+                pSeq->elements + (sizeof(sal_Int16) * nStartIndex),
+                0,
+                sizeof(sal_Int16) * (nStopIndex - nStartIndex) );
+        }
+        break;
+    case typelib_TypeClass_LONG:
+    case typelib_TypeClass_UNSIGNED_LONG:
+        if (nAlloc >= 0)
+            pSeq = reallocSeq( pSeq, sizeof(sal_Int32), nAlloc );
+        if (pSeq != nullptr)
+        {
+            memset(
+                pSeq->elements + (sizeof(sal_Int32) * nStartIndex),
+                0,
+                sizeof(sal_Int32) * (nStopIndex - nStartIndex) );
+        }
+        break;
+    case typelib_TypeClass_HYPER:
+    case typelib_TypeClass_UNSIGNED_HYPER:
+        if (nAlloc >= 0)
+            pSeq = reallocSeq( pSeq, sizeof(sal_Int64), nAlloc );
+        if (pSeq != nullptr)
+        {
+            memset(
+                pSeq->elements + (sizeof(sal_Int64) * nStartIndex),
+                0,
+                sizeof(sal_Int64) * (nStopIndex - nStartIndex) );
+        }
+        break;
+    case typelib_TypeClass_FLOAT:
+    {
+        if (nAlloc >= 0)
+            pSeq = reallocSeq( pSeq, sizeof(float), nAlloc );
+        if (pSeq != nullptr)
+        {
+            float * pElements = reinterpret_cast<float *>(pSeq->elements);
+            for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
+            {
+                pElements[nPos] = 0.0;
+            }
+        }
+        break;
+    }
+    case typelib_TypeClass_DOUBLE:
+    {
+        if (nAlloc >= 0)
+            pSeq = reallocSeq( pSeq, sizeof(double), nAlloc );
+        if (pSeq != nullptr)
+        {
+            double * pElements = reinterpret_cast<double *>(pSeq->elements);
+            for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
+            {
+                pElements[nPos] = 0.0;
+            }
+        }
+        break;
+    }
+    case typelib_TypeClass_STRING:
+    {
+        if (nAlloc >= 0)
+            pSeq = reallocSeq( pSeq, sizeof(rtl_uString *), nAlloc );
+        if (pSeq != nullptr)
+        {
+            rtl_uString ** pElements = reinterpret_cast<rtl_uString **>(pSeq->elements);
+            for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
+            {
+                pElements[nPos] = nullptr;
+                rtl_uString_new( &pElements[nPos] );
+            }
+        }
+        break;
+    }
+    case typelib_TypeClass_TYPE:
+    {
+        if (nAlloc >= 0)
+        {
+            pSeq = reallocSeq(
+                pSeq, sizeof(typelib_TypeDescriptionReference *), nAlloc );
+        }
+        if (pSeq != nullptr)
+        {
+            typelib_TypeDescriptionReference ** pElements =
+                reinterpret_cast<typelib_TypeDescriptionReference **>(pSeq->elements);
+            for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
+            {
+                pElements[nPos] = _getVoidType();
+            }
+        }
+        break;
+    }
+    case typelib_TypeClass_ANY:
+    {
+        if (nAlloc >= 0)
+            pSeq = reallocSeq( pSeq, sizeof(uno_Any), nAlloc );
+        if (pSeq != nullptr)
+        {
+            uno_Any * pElements = reinterpret_cast<uno_Any *>(pSeq->elements);
+            for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
+            {
+                CONSTRUCT_EMPTY_ANY( &pElements[nPos] );
+            }
+        }
+        break;
+    }
+    case typelib_TypeClass_ENUM:
+    {
+        if (nAlloc >= 0)
+            pSeq = reallocSeq( pSeq, sizeof(sal_Int32), nAlloc );
+        if (pSeq != nullptr)
+        {
+            typelib_TypeDescription * pElementTypeDescr = nullptr;
+            TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
+            sal_Int32 eEnum =
+                reinterpret_cast<typelib_EnumTypeDescription *>(
+                 pElementTypeDescr)->nDefaultEnumValue;
+            TYPELIB_DANGER_RELEASE( pElementTypeDescr );
+
+            sal_Int32 * pElements = reinterpret_cast<sal_Int32 *>(pSeq->elements);
+            for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
+            {
+                pElements[nPos] = eEnum;
+            }
+        }
+        break;
+    }
+    case typelib_TypeClass_STRUCT:
+    case typelib_TypeClass_EXCEPTION:
+    {
+        typelib_TypeDescription * pElementTypeDescr = nullptr;
+        TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
+        sal_Int32 nElementSize = pElementTypeDescr->nSize;
+
+        if (nAlloc >= 0)
+            pSeq = reallocSeq( pSeq, nElementSize, nAlloc );
+        if (pSeq != nullptr)
+        {
+            char * pElements = pSeq->elements;
+            for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
+            {
+                _defaultConstructStruct(
+                    pElements + (nElementSize * nPos),
+                    reinterpret_cast<typelib_CompoundTypeDescription *>(pElementTypeDescr) );
+            }
+        }
+
+        TYPELIB_DANGER_RELEASE( pElementTypeDescr );
+        break;
+    }
+    case typelib_TypeClass_SEQUENCE:
+    {
+        if (nAlloc >= 0)
+        {
+            // coverity[suspicious_sizeof : FALSE] - sizeof(uno_Sequence*) is correct here
+            pSeq = reallocSeq(pSeq, sizeof(uno_Sequence*), nAlloc);
+        }
+        if (pSeq != nullptr)
+        {
+            uno_Sequence ** pElements =
+                reinterpret_cast<uno_Sequence **>(pSeq->elements);
+            for ( sal_Int32 nPos = nStartIndex; nPos < nStopIndex; ++nPos )
+            {
+                pElements[nPos] = createEmptySequence();
+            }
+        }
+        break;
+    }
+    case typelib_TypeClass_INTERFACE: // either C++ or C-UNO interface
+        if (nAlloc >= 0)
+            pSeq = reallocSeq( pSeq, sizeof(void *), nAlloc );
+        if (pSeq != nullptr)
+        {
+            memset(
+                pSeq->elements + (sizeof(void *) * nStartIndex),
+                0,
+                sizeof(void *) * (nStopIndex - nStartIndex) );
+        }
+        break;
+    default:
+        OSL_FAIL( "### unexpected element type!" );
+        pSeq = nullptr;
+        break;
+    }
+
+    if (pSeq == nullptr)
+    {
+        OSL_ASSERT( nAlloc >= 0 ); // must have been an allocation failure
+        return false;
+    }
+    *ppSeq = pSeq;
+    return true;
+}
+
+
+static bool icopyConstructFromElements(
+    uno_Sequence ** ppSeq, void * pSourceElements,
+    typelib_TypeDescriptionReference * pElementType,
+    sal_Int32 nStopIndex,
+    uno_AcquireFunc acquire,
+    sal_Int32 nAlloc )
+{
+    uno_Sequence * pSeq = *ppSeq;
+    switch (pElementType->eTypeClass)
+    {
+    case typelib_TypeClass_CHAR:
+        pSeq = reallocSeq( pSeq, sizeof(sal_Unicode), nAlloc );
+        if (pSeq != nullptr)
+        {
+            memcpy(
+                pSeq->elements,
+                pSourceElements,
+                sizeof(sal_Unicode) * nStopIndex );
+        }
+        break;
+    case typelib_TypeClass_BOOLEAN:
+        pSeq = reallocSeq( pSeq, sizeof(sal_Bool), nAlloc );
+        if (pSeq != nullptr)
+        {
+            memcpy(
+                pSeq->elements,
+                pSourceElements,
+                sizeof(sal_Bool) * nStopIndex );
+        }
+        break;
+    case typelib_TypeClass_BYTE:
+        pSeq = reallocSeq( pSeq, sizeof(sal_Int8), nAlloc );
+        if (pSeq != nullptr)
+        {
+            memcpy(
+                pSeq->elements,
+                pSourceElements,
+                sizeof(sal_Int8) * nStopIndex );
+        }
+        break;
+    case typelib_TypeClass_SHORT:
+    case typelib_TypeClass_UNSIGNED_SHORT:
+        pSeq = reallocSeq( pSeq, sizeof(sal_Int16), nAlloc );
+        if (pSeq != nullptr)
+        {
+            memcpy(
+                pSeq->elements,
+                pSourceElements,
+                sizeof(sal_Int16) * nStopIndex );
+        }
+        break;
+    case typelib_TypeClass_LONG:
+    case typelib_TypeClass_UNSIGNED_LONG:
+        pSeq = reallocSeq( pSeq, sizeof(sal_Int32), nAlloc );
+        if (pSeq != nullptr)
+        {
+            memcpy(
+                pSeq->elements,
+                pSourceElements,
+                sizeof(sal_Int32) * nStopIndex );
+        }
+        break;
+    case typelib_TypeClass_HYPER:
+    case typelib_TypeClass_UNSIGNED_HYPER:
+        pSeq = reallocSeq( pSeq, sizeof(sal_Int64), nAlloc );
+        if (pSeq != nullptr)
+        {
+            memcpy(
+                pSeq->elements,
+                pSourceElements,
+                sizeof(sal_Int64) * nStopIndex );
+        }
+        break;
+    case typelib_TypeClass_FLOAT:
+        pSeq = reallocSeq( pSeq, sizeof(float), nAlloc );
+        if (pSeq != nullptr)
+        {
+            memcpy(
+                pSeq->elements,
+                pSourceElements,
+                sizeof(float) * nStopIndex );
+        }
+        break;
+    case typelib_TypeClass_DOUBLE:
+        pSeq = reallocSeq( pSeq, sizeof(double), nAlloc );
+        if (pSeq != nullptr)
+        {
+            memcpy(
+                pSeq->elements,
+                pSourceElements,
+                sizeof(double) * nStopIndex );
+        }
+        break;
+    case typelib_TypeClass_ENUM:
+        pSeq = reallocSeq( pSeq, sizeof(sal_Int32), nAlloc );
+        if (pSeq != nullptr)
+        {
+            memcpy(
+                pSeq->elements,
+                pSourceElements,
+                sizeof(sal_Int32) * nStopIndex );
+        }
+        break;
+    case typelib_TypeClass_STRING:
+    {
+        pSeq = reallocSeq( pSeq, sizeof(rtl_uString *), nAlloc );
+        if (pSeq != nullptr)
+        {
+            rtl_uString ** pDestElements = reinterpret_cast<rtl_uString **>(pSeq->elements);
+            for ( sal_Int32 nPos = 0; nPos < nStopIndex; ++nPos )
+            {
+                // This code tends to trigger coverity's overrun-buffer-arg warning
+                // coverity[index_parm_via_loop_bound] - https://communities.coverity.com/thread/2993
+                ::rtl_uString_acquire(
+                    static_cast<rtl_uString **>(pSourceElements)[nPos] );
+                pDestElements[nPos] = static_cast<rtl_uString **>(pSourceElements)[nPos];
+            }
+        }
+        break;
+    }
+    case typelib_TypeClass_TYPE:
+    {
+        pSeq = reallocSeq(
+            pSeq, sizeof(typelib_TypeDescriptionReference *), nAlloc );
+        if (pSeq != nullptr)
+        {
+            typelib_TypeDescriptionReference ** pDestElements =
+                reinterpret_cast<typelib_TypeDescriptionReference **>(pSeq->elements);
+            for ( sal_Int32 nPos = 0; nPos < nStopIndex; ++nPos )
+            {
+                TYPE_ACQUIRE(
+                    static_cast<typelib_TypeDescriptionReference **>(
+                     pSourceElements)[nPos] );
+                pDestElements[nPos] =
+                    static_cast<typelib_TypeDescriptionReference **>(
+                     pSourceElements)[nPos];
+            }
+        }
+        break;
+    }
+    case typelib_TypeClass_ANY:
+    {
+        pSeq = reallocSeq( pSeq, sizeof(uno_Any), nAlloc );
+        if (pSeq != nullptr)
+        {
+            uno_Any * pDestElements = reinterpret_cast<uno_Any *>(pSeq->elements);
+            for ( sal_Int32 nPos = 0; nPos < nStopIndex; ++nPos )
+            {
+                uno_Any * pSource = static_cast<uno_Any *>(pSourceElements) + nPos;
+                _copyConstructAny(
+                    &pDestElements[nPos],
+                    pSource->pData,
+                    pSource->pType, nullptr,
+                    acquire, nullptr );
+            }
+        }
+        break;
+    }
+    case typelib_TypeClass_STRUCT:
+    case typelib_TypeClass_EXCEPTION:
+    {
+        typelib_TypeDescription * pElementTypeDescr = nullptr;
+        TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
+        sal_Int32 nElementSize = pElementTypeDescr->nSize;
+
+        pSeq = reallocSeq( pSeq, nElementSize, nAlloc );
+        if (pSeq != nullptr)
+        {
+            char * pDestElements = pSeq->elements;
+
+            typelib_CompoundTypeDescription * pTypeDescr =
+                reinterpret_cast<typelib_CompoundTypeDescription *>(pElementTypeDescr);
+            for ( sal_Int32 nPos = 0; nPos < nStopIndex; ++nPos )
+            {
+                char * pDest =
+                    pDestElements + (nElementSize * nPos);
+                char * pSource =
+                    static_cast<char *>(pSourceElements) + (nElementSize * nPos);
+
+                if (pTypeDescr->pBaseTypeDescription)
+                {
+                    // copy base value
+                    _copyConstructStruct(
+                        pDest, pSource,
+                        pTypeDescr->pBaseTypeDescription, acquire, nullptr );
+                }
+
+                // then copy members
+                typelib_TypeDescriptionReference ** ppTypeRefs =
+                    pTypeDescr->ppTypeRefs;
+                sal_Int32 * pMemberOffsets = pTypeDescr->pMemberOffsets;
+                sal_Int32 nDescr = pTypeDescr->nMembers;
+
+                while (nDescr--)
+                {
+                    ::uno_type_copyData(
+                        pDest + pMemberOffsets[nDescr],
+                        pSource + pMemberOffsets[nDescr],
+                        ppTypeRefs[nDescr], acquire );
+                }
+            }
+        }
+
+        TYPELIB_DANGER_RELEASE( pElementTypeDescr );
+        break;
+    }
+    case typelib_TypeClass_SEQUENCE: // sequence of sequence
+    {
+        // coverity[suspicious_sizeof : FALSE] - sizeof(uno_Sequence*) is correct here
+        pSeq = reallocSeq(pSeq, sizeof(uno_Sequence*), nAlloc);
+        if (pSeq != nullptr)
+        {
+            typelib_TypeDescription * pElementTypeDescr = nullptr;
+            TYPELIB_DANGER_GET( &pElementTypeDescr, pElementType );
+            typelib_TypeDescriptionReference * pSeqElementType =
+                reinterpret_cast<typelib_IndirectTypeDescription *>(pElementTypeDescr)->pType;
+            uno_Sequence ** pDestElements = reinterpret_cast<uno_Sequence **>(pSeq->elements);
+            for ( sal_Int32 nPos = 0; nPos < nStopIndex; ++nPos )
+            {
+                uno_Sequence * pNew = icopyConstructSequence(
+                    static_cast<uno_Sequence **>(pSourceElements)[nPos],
+                    pSeqElementType, acquire, nullptr );
+                OSL_ASSERT( pNew != nullptr );
+                // ought never be a memory allocation problem,
+                // because of reference counted sequence handles
+                pDestElements[ nPos ] = pNew;
+            }
+            TYPELIB_DANGER_RELEASE( pElementTypeDescr );
+        }
+        break;
+    }
+    case typelib_TypeClass_INTERFACE:
+    {
+        pSeq = reallocSeq( pSeq, sizeof(void *), nAlloc );
+        if (pSeq != nullptr)
+        {
+            void ** pDestElements = reinterpret_cast<void **>(pSeq->elements);
+            for ( sal_Int32 nPos = 0; nPos < nStopIndex; ++nPos )
+            {
+                pDestElements[nPos] = static_cast<void **>(pSourceElements)[nPos];
+                _acquire( pDestElements[nPos], acquire );
+            }
+        }
+        break;
+    }
+    default:
+        OSL_FAIL( "### unexpected element type!" );
+        pSeq = nullptr;
+        break;
+    }
+
+    if (pSeq == nullptr)
+    {
+        return false; // allocation failure
+    }
+    *ppSeq = pSeq;
+    return true;
+}
+
+
+static bool ireallocSequence(
+    uno_Sequence ** ppSequence,
+    typelib_TypeDescriptionReference * pElementType,
+    sal_Int32 nSize,
+    uno_AcquireFunc acquire, uno_ReleaseFunc release )
+{
+    bool ret = true;
+    uno_Sequence * pSeq = *ppSequence;
+    sal_Int32 nElements = pSeq->nElements;
+
+    if (pSeq->nRefCount > 1 ||
+        // not mem-copyable elements?
+        typelib_TypeClass_ANY == pElementType->eTypeClass ||
+        typelib_TypeClass_STRUCT == pElementType->eTypeClass ||
+        typelib_TypeClass_EXCEPTION == pElementType->eTypeClass)
+    {
+        // split sequence and construct new one from scratch
+        uno_Sequence * pNew = nullptr;
+
+        sal_Int32 nRest = nSize - nElements;
+        sal_Int32 nCopy = (nRest > 0 ? nElements : nSize);
+
+        if (nCopy >= 0)
+        {
+            ret = icopyConstructFromElements(
+                &pNew, pSeq->elements, pElementType,
+                nCopy, acquire,
+                nSize ); // alloc to nSize
+        }
+        if (ret && nRest > 0)
+        {
+            ret = idefaultConstructElements(
+                &pNew, pElementType,
+                nCopy, nSize,
+                nCopy >= 0 ? -1 /* no mem allocation */ : nSize );
+        }
+
+        if (ret)
+        {
+            // destruct sequence
+            if (osl_atomic_decrement( &pSeq->nRefCount ) == 0)
+            {
+                if (nElements > 0)
+                {
+                    idestructElements(
+                        pSeq->elements, pElementType,
+                        0, nElements, release );
+                }
+                std::free( pSeq );
+            }
+            *ppSequence = pNew;
+        }
+    }
+    else
+    {
+        OSL_ASSERT( pSeq->nRefCount == 1 );
+        if (nSize > nElements) // default construct the rest
+        {
+            ret = idefaultConstructElements(
+                ppSequence, pElementType,
+                nElements, nSize,
+                nSize ); // realloc to nSize
+        }
+        else // or destruct the rest and realloc mem
+        {
+            sal_Int32 nElementSize = idestructElements(
+                pSeq->elements, pElementType,
+                nSize, nElements, release );
+            // warning: it is assumed that the following will never fail,
+            //          else this leads to a sequence null handle
+            *ppSequence = reallocSeq( pSeq, nElementSize, nSize );
+            OSL_ASSERT( *ppSequence != nullptr );
+            ret = (*ppSequence != nullptr);
+        }
+    }
+
+    return ret;
+}
+
+}
+
+extern "C"
+{
+
+
+sal_Bool SAL_CALL uno_type_sequence_construct(
+    uno_Sequence ** ppSequence, typelib_TypeDescriptionReference * pType,
+    void * pElements, sal_Int32 len,
+    uno_AcquireFunc acquire )
+    SAL_THROW_EXTERN_C()
+{
+    assert( len >= 0 );
+    bool ret;
+    if (len)
+    {
+        typelib_TypeDescription * pTypeDescr = nullptr;
+        TYPELIB_DANGER_GET( &pTypeDescr, pType );
+
+        typelib_TypeDescriptionReference * pElementType =
+            reinterpret_cast<typelib_IndirectTypeDescription *>(pTypeDescr)->pType;
+
+        *ppSequence = nullptr;
+        if (pElements == nullptr)
+        {
+            ret = idefaultConstructElements(
+                ppSequence, pElementType,
+                0, len,
+                len ); // alloc to len
+        }
+        else
+        {
+            ret = icopyConstructFromElements(
+                ppSequence, pElements, pElementType,
+                len, acquire,
+                len ); // alloc to len
+        }
+
+        TYPELIB_DANGER_RELEASE( pTypeDescr );
+    }
+    else
+    {
+        *ppSequence = createEmptySequence();
+        ret = true;
+    }
+
+    OSL_ASSERT( (*ppSequence != nullptr) == ret );
+    return ret;
+}
+
+
+sal_Bool SAL_CALL uno_sequence_construct(
+    uno_Sequence ** ppSequence, typelib_TypeDescription * pTypeDescr,
+    void * pElements, sal_Int32 len,
+    uno_AcquireFunc acquire )
+    SAL_THROW_EXTERN_C()
+{
+    bool ret;
+    if (len > 0)
+    {
+        typelib_TypeDescriptionReference * pElementType =
+            reinterpret_cast<typelib_IndirectTypeDescription *>(pTypeDescr)->pType;
+
+        *ppSequence = nullptr;
+        if (pElements == nullptr)
+        {
+            ret = idefaultConstructElements(
+                ppSequence, pElementType,
+                0, len,
+                len ); // alloc to len
+        }
+        else
+        {
+            ret = icopyConstructFromElements(
+                ppSequence, pElements, pElementType,
+                len, acquire,
+                len ); // alloc to len
+        }
+    }
+    else
+    {
+        *ppSequence = createEmptySequence();
+        ret = true;
+    }
+
+    OSL_ASSERT( (*ppSequence != nullptr) == ret );
+    return ret;
+}
+
+
+sal_Bool SAL_CALL uno_type_sequence_realloc(
+    uno_Sequence ** ppSequence, typelib_TypeDescriptionReference * pType,
+    sal_Int32 nSize, uno_AcquireFunc acquire, uno_ReleaseFunc release )
+    SAL_THROW_EXTERN_C()
+{
+    assert(ppSequence && "### null ptr!");
+    assert(nSize >= 0 && "### new size must be at least 0!");
+
+    bool ret = true;
+    if (nSize != (*ppSequence)->nElements)
+    {
+        typelib_TypeDescription * pTypeDescr = nullptr;
+        TYPELIB_DANGER_GET( &pTypeDescr, pType );
+        ret = ireallocSequence(
+            ppSequence, reinterpret_cast<typelib_IndirectTypeDescription *>(pTypeDescr)->pType,
+            nSize, acquire, release );
+        TYPELIB_DANGER_RELEASE( pTypeDescr );
+    }
+    return ret;
+}
+
+
+sal_Bool SAL_CALL uno_sequence_realloc(
+    uno_Sequence ** ppSequence, typelib_TypeDescription * pTypeDescr,
+    sal_Int32 nSize, uno_AcquireFunc acquire, uno_ReleaseFunc release )
+    SAL_THROW_EXTERN_C()
+{
+    OSL_ENSURE( ppSequence, "### null ptr!" );
+    OSL_ENSURE( nSize >= 0, "### new size must be at least 0!" );
+
+    bool ret = true;
+    if (nSize != (*ppSequence)->nElements)
+    {
+        ret = ireallocSequence(
+            ppSequence, reinterpret_cast<typelib_IndirectTypeDescription *>(pTypeDescr)->pType,
+            nSize, acquire, release );
+    }
+    return ret;
+}
+
+
+sal_Bool SAL_CALL uno_type_sequence_reference2One(
+    uno_Sequence ** ppSequence,
+    typelib_TypeDescriptionReference * pType,
+    uno_AcquireFunc acquire, uno_ReleaseFunc release )
+    SAL_THROW_EXTERN_C()
+{
+    OSL_ENSURE( ppSequence, "### null ptr!" );
+    bool ret = true;
+    uno_Sequence * pSequence = *ppSequence;
+    if (pSequence->nRefCount > 1)
+    {
+        uno_Sequence * pNew = nullptr;
+        if (pSequence->nElements > 0)
+        {
+            typelib_TypeDescription * pTypeDescr = nullptr;
+            TYPELIB_DANGER_GET( &pTypeDescr, pType );
+
+            ret = icopyConstructFromElements(
+                &pNew, pSequence->elements,
+                reinterpret_cast<typelib_IndirectTypeDescription *>(pTypeDescr)->pType,
+                pSequence->nElements, acquire,
+                pSequence->nElements ); // alloc nElements
+            if (ret)
+            {
+                idestructSequence( *ppSequence, pType, pTypeDescr, release );
+                *ppSequence = pNew;
+            }
+
+            TYPELIB_DANGER_RELEASE( pTypeDescr );
+        }
+        else
+        {
+            pNew = allocSeq( 0, 0 );
+            ret = (pNew != nullptr);
+            if (ret)
+            {
+                // easy destruction of empty sequence:
+                if (osl_atomic_decrement( &pSequence->nRefCount ) == 0)
+                    std::free( pSequence );
+                *ppSequence = pNew;
+            }
+        }
+    }
+    return ret;
+}
+
+
+sal_Bool SAL_CALL uno_sequence_reference2One(
+    uno_Sequence ** ppSequence,
+    typelib_TypeDescription * pTypeDescr,
+    uno_AcquireFunc acquire, uno_ReleaseFunc release )
+    SAL_THROW_EXTERN_C()
+{
+    OSL_ENSURE( ppSequence, "### null ptr!" );
+    bool ret = true;
+    uno_Sequence * pSequence = *ppSequence;
+    if (pSequence->nRefCount > 1)
+    {
+        uno_Sequence * pNew = nullptr;
+        if (pSequence->nElements > 0)
+        {
+            ret = icopyConstructFromElements(
+                &pNew, pSequence->elements,
+                reinterpret_cast<typelib_IndirectTypeDescription *>(pTypeDescr)->pType,
+                pSequence->nElements, acquire,
+                pSequence->nElements ); // alloc nElements
+            if (ret)
+            {
+                idestructSequence(
+                    pSequence, pTypeDescr->pWeakRef, pTypeDescr, release );
+                *ppSequence = pNew;
+            }
+        }
+        else
+        {
+            pNew = allocSeq( 0, 0 );
+            ret = (pNew != nullptr);
+            if (ret)
+            {
+                // easy destruction of empty sequence:
+                if (osl_atomic_decrement( &pSequence->nRefCount ) == 0)
+                    std::free( pSequence );
+                *ppSequence = pNew;
+            }
+        }
+
+    }
+    return ret;
+}
+
+
+void SAL_CALL uno_sequence_assign(
+    uno_Sequence ** ppDest,
+    uno_Sequence * pSource,
+    typelib_TypeDescription * pTypeDescr,
+    uno_ReleaseFunc release )
+    SAL_THROW_EXTERN_C()
+{
+    if (*ppDest != pSource)
+    {
+        osl_atomic_increment( &pSource->nRefCount );
+        idestructSequence( *ppDest, pTypeDescr->pWeakRef, pTypeDescr, release );
+        *ppDest = pSource;
+    }
+}
+
+
+void SAL_CALL uno_type_sequence_assign(
+    uno_Sequence ** ppDest,
+    uno_Sequence * pSource,
+    typelib_TypeDescriptionReference * pType,
+    uno_ReleaseFunc release )
+    SAL_THROW_EXTERN_C()
+{
+    if (*ppDest != pSource)
+    {
+        osl_atomic_increment( &pSource->nRefCount );
+        idestructSequence( *ppDest, pType, nullptr, release );
+        *ppDest = pSource;
+    }
+}
+
+void uno_type_sequence_destroy(
+    uno_Sequence * sequence, typelib_TypeDescriptionReference * type,
+    uno_ReleaseFunc release)
+    SAL_THROW_EXTERN_C()
+{
+    idestroySequence(sequence, type, nullptr, release);
+}
+
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */