Adding upstream version 4:7.4.7.upstream/4%7.4.7upstream

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

31 files changed, 9655 insertions, 0 deletions

diff --git a/registry/Executable_regmerge.mk b/registry/Executable_regmerge.mk
new file mode 100644
index 000000000..a55acf885
--- /dev/null
+++ b/registry/Executable_regmerge.mk
@@ -0,0 +1,29 @@
+# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*-
+#
+# 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/.
+#
+
+$(eval $(call gb_Executable_Executable,regmerge))
+
+$(eval $(call gb_Executable_use_libraries,regmerge,\
+    reg \
+    $(if $(filter TRUE,$(DISABLE_DYNLOADING)),store) \
+    $(if $(filter TRUE,$(DISABLE_DYNLOADING)),salhelper) \
+    sal \
+))
+
+$(eval $(call gb_Executable_use_static_libraries,regmerge,\
+    registry_helper \
+))
+
+$(eval $(call gb_Executable_add_exception_objects,regmerge,\
+    registry/tools/regmerge \
+))
+
+$(eval $(call gb_Executable_add_default_nativeres,regmerge))
+
+# vim:set noet sw=4 ts=4:
diff --git a/registry/Executable_regview.mk b/registry/Executable_regview.mk
new file mode 100644
index 000000000..9ff105236
--- /dev/null
+++ b/registry/Executable_regview.mk
@@ -0,0 +1,34 @@
+# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*-
+#
+# 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/.
+#
+
+$(eval $(call gb_Executable_Executable,regview))
+
+$(eval $(call gb_Executable_set_include,regview, \
+    $$(INCLUDE) \
+    -I$(SRCDIR)/registry/inc \
+))
+
+$(eval $(call gb_Executable_use_libraries,regview,\
+    reg \
+    $(if $(filter TRUE,$(DISABLE_DYNLOADING)),store) \
+    $(if $(filter TRUE,$(DISABLE_DYNLOADING)),salhelper) \
+    sal \
+))
+
+$(eval $(call gb_Executable_use_static_libraries,regview,\
+    registry_helper \
+))
+
+$(eval $(call gb_Executable_add_exception_objects,regview,\
+    registry/tools/regview \
+))
+
+$(eval $(call gb_Executable_add_default_nativeres,regview))
+
+# vim:set noet sw=4 ts=4:
diff --git a/registry/IwyuFilter_registry.yaml b/registry/IwyuFilter_registry.yaml
new file mode 100644
index 000000000..7acf6c936
--- /dev/null
+++ b/registry/IwyuFilter_registry.yaml
@@ -0,0 +1,16 @@
+---
+assumeFilename: registry/source/registry.cxx
+excludelist:
+    registry/source/regimpl.hxx:
+    # Needed for correct linker visibility
+    - regapi.hxx
+    registry/source/reflwrit.cxx:
+    # OSL_BIGENDIAN is being checked
+    - osl/endian.h
+    # Needed for correct linker visibility
+    - registry/writer.h
+    registry/source/reflread.cxx:
+    # OSL_BIGENDIAN is being checked
+    - osl/endian.h
+    # Needed for correct linker visibility
+    - registry/typereg_reader.hxx
diff --git a/registry/Library_reg.mk b/registry/Library_reg.mk
new file mode 100644
index 000000000..d17b11969
--- /dev/null
+++ b/registry/Library_reg.mk
@@ -0,0 +1,37 @@
+# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*-
+#
+# 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/.
+#
+
+$(eval $(call gb_Library_Library,reg))
+
+$(eval $(call gb_Library_add_defs,reg,\
+	-DREG_DLLIMPLEMENTATION \
+))
+
+$(eval $(call gb_Library_set_include,reg, \
+    $$(INCLUDE) \
+    -I$(SRCDIR)/registry/inc \
+))
+
+$(eval $(call gb_Library_use_external,reg,boost_headers))
+
+$(eval $(call gb_Library_use_libraries,reg,\
+	sal \
+	store \
+))
+
+$(eval $(call gb_Library_add_exception_objects,reg,\
+	registry/source/keyimpl \
+	registry/source/reflread \
+	registry/source/reflwrit \
+	registry/source/regimpl \
+	registry/source/registry \
+	registry/source/regkey \
+))
+
+# vim: set noet sw=4 ts=4:
diff --git a/registry/Makefile b/registry/Makefile
new file mode 100644
index 000000000..0997e6284
--- /dev/null
+++ b/registry/Makefile
@@ -0,0 +1,14 @@
+# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*-
+#
+# 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/.
+#
+
+module_directory:=$(dir $(realpath $(firstword $(MAKEFILE_LIST))))
+
+include $(module_directory)/../solenv/gbuild/partial_build.mk
+
+# vim: set noet sw=4 ts=4:
diff --git a/registry/Module_registry.mk b/registry/Module_registry.mk
new file mode 100644
index 000000000..40f7230bb
--- /dev/null
+++ b/registry/Module_registry.mk
@@ -0,0 +1,21 @@
+# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*-
+#
+# 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/.
+#
+
+$(eval $(call gb_Module_Module,registry))
+
+$(eval $(call gb_Module_add_targets,registry,\
+	Library_reg \
+    $(call gb_CondExeRegistryTools, \
+        Executable_regmerge \
+        Executable_regview \
+        StaticLibrary_registry_helper \
+    ) \
+))
+
+# vim:set noet sw=4 ts=4:
diff --git a/registry/README.md b/registry/README.md
new file mode 100644
index 000000000..617ef4a73
--- /dev/null
+++ b/registry/README.md
@@ -0,0 +1,15 @@
+# Registry Reading, etc
+
+This provides tools for dealing with the legacy binary types database
+format, still in use by extensions and the core code. While the actual
+binary file format is implemented by the `store` code, the wrapper
+that turns this into a type registry is implemented here.
+
+While this code is primarily used in only two modes:
+
+* linear write / concatenate
+* random access read
+
+The API unfortunately exposes a random-access write approach, which -
+while ~unused needs before we can re-write this away from the store
+backend.
diff --git a/registry/StaticLibrary_registry_helper.mk b/registry/StaticLibrary_registry_helper.mk
new file mode 100644
index 000000000..a0c11428e
--- /dev/null
+++ b/registry/StaticLibrary_registry_helper.mk
@@ -0,0 +1,18 @@
+# -*- Mode: makefile-gmake; tab-width: 4; indent-tabs-mode: t -*-
+#
+#
+# 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/.
+#
+
+$(eval $(call gb_StaticLibrary_StaticLibrary,registry_helper))
+
+$(eval $(call gb_StaticLibrary_add_exception_objects,registry_helper,\
+    registry/tools/fileurl \
+    registry/tools/options \
+))
+
+# vim: set noet sw=4 ts=4:
diff --git a/registry/inc/regapi.hxx b/registry/inc/regapi.hxx
new file mode 100644
index 000000000..ae5b7e119
--- /dev/null
+++ b/registry/inc/regapi.hxx
@@ -0,0 +1,90 @@
+/* -*- 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_REGISTRY_INC_REGAPI_HXX
+#define INCLUDED_REGISTRY_INC_REGAPI_HXX
+
+#include <rtl/ustring.h>
+#include <registry/regtype.h>
+#include <registry/regdllapi.h>
+
+/** This function opens the specified key.
+
+    @param  hKey identifies a currently open key. The key which will be opened by this function
+                 is a subkey of the key identified by hKey
+    @param  keyName points to a null terminated string specifying the name of a key.
+    @param  phOpenKey points to a variable that receives the handle of the opened key.
+                     The memory to store this variable will be allocated and will be freed by the function
+                     reg_closeKey. If the function fails, phNewKey is NULL.
+    @return REG_NO_ERROR if succeeds else an error code.
+*/
+REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_openKey(RegKeyHandle hKey,
+                                         rtl_uString* keyName,
+                                         RegKeyHandle* phOpenKey);
+
+
+/** This function closes the specified key.
+
+    @param  hKey identifies a currently open key which will be closed by this function.
+                 The memory of the variable specifying the key will be freed.
+    @return REG_NO_ERROR if succeeds else an error code.
+*/
+REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_closeKey(RegKeyHandle hKey);
+
+
+/** This function opens the root key of a registry.
+
+    @param  hRegistry identifies a currently open registry whose rootKey will be returned.
+    @param  phRootKey points to a handle of the open root key if the function succeeds otherwise NULL.
+    @return REG_NO_ERROR if succeeds else an error code.
+*/
+REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_openRootKey(RegHandle hRegistry,
+                                             RegKeyHandle* phRootKey);
+
+
+/** This function opens a registry with the specified name. in readonly mode.
+
+    @param  registryName points to a null terminated string specifying the name of the registry.
+    @param  phRegistry points to a handle of the opened registry if the function succeeds otherwise NULL.
+    @return REG_NO_ERROR if succeeds else an error code.
+*/
+REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_openRegistry(rtl_uString* registryName,
+                                               RegHandle* phRegistry);
+
+
+/** This function closes a registry.
+
+    @param  hRegistry identifies a currently open registry which should be closed.
+    @return REG_NO_ERROR if succeeds else an error code.
+*/
+REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_closeRegistry(RegHandle hRegistry);
+
+
+/** This function reports the complete registry information of a key and all of its subkeys.
+
+    All information which are available (keynames, value types, values, ...)
+    will be printed to stdout for report issues only.
+    @param  hKey identifies a currently open key which content will be reported.
+    @return REG_NO_ERROR if succeeds else an error code.
+*/
+REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_dumpRegistry(RegKeyHandle hKey);
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/registry/source/keyimpl.cxx b/registry/source/keyimpl.cxx
new file mode 100644
index 000000000..abf8e0d1e
--- /dev/null
+++ b/registry/source/keyimpl.cxx
@@ -0,0 +1,983 @@
+/* -*- 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 <string.h>
+#include <string_view>
+
+#include "keyimpl.hxx"
+
+#include "reflcnst.hxx"
+#include <rtl/alloc.h>
+#include <rtl/ustrbuf.hxx>
+#include <osl/diagnose.h>
+#include <sal/log.hxx>
+#include <memory>
+
+using namespace store;
+
+namespace { char const VALUE_PREFIX[] = "$VL_"; }
+
+
+//  ORegKey()
+
+ORegKey::ORegKey(const OUString& keyName, ORegistry* pReg)
+    : m_refCount(1)
+    , m_name(keyName)
+    , m_bDeleted(false)
+    , m_bModified(false)
+    , m_pRegistry(pReg)
+{
+}
+
+
+//  ~ORegKey()
+
+ORegKey::~ORegKey()
+{
+    SAL_WARN_IF(m_refCount != 0, "registry", "registry::ORegKey::dtor(): refcount not zero.");
+}
+
+
+//  releaseKey
+
+RegError ORegKey::releaseKey(RegKeyHandle hKey)
+{
+    return m_pRegistry->releaseKey(hKey);
+}
+
+
+//  createKey
+
+RegError ORegKey::createKey(std::u16string_view keyName, RegKeyHandle* phNewKey)
+{
+    return m_pRegistry->createKey(this, keyName, phNewKey);
+}
+
+
+//  openKey
+
+RegError ORegKey::openKey(std::u16string_view keyName, RegKeyHandle* phOpenKey)
+{
+    return m_pRegistry->openKey(this, keyName, phOpenKey);
+}
+
+
+//  openSubKeys
+
+RegError ORegKey::openSubKeys(std::u16string_view keyName, RegKeyHandle** phOpenSubKeys, sal_uInt32* pnSubKeys)
+{
+    RegError _ret = RegError::NO_ERROR;
+
+    *phOpenSubKeys = nullptr;
+    *pnSubKeys = 0;
+
+    ORegKey* pKey = this;
+    if ( !keyName.empty() )
+    {
+        _ret = openKey(keyName, reinterpret_cast<RegKeyHandle*>(&pKey));
+        if (_ret != RegError::NO_ERROR)
+            return _ret;
+    }
+
+    sal_uInt32 nSubKeys = pKey->countSubKeys();
+    *pnSubKeys = nSubKeys;
+
+    ORegKey** pSubKeys;
+    pSubKeys = static_cast<ORegKey**>(rtl_allocateZeroMemory(nSubKeys * sizeof(ORegKey*)));
+
+    OStoreDirectory::iterator   iter;
+    OStoreDirectory             rStoreDir(pKey->getStoreDir());
+    storeError                  _err = rStoreDir.first(iter);
+
+    nSubKeys = 0;
+    while ( _err == store_E_None )
+    {
+        if ( iter.m_nAttrib & STORE_ATTRIB_ISDIR )
+        {
+            OUString const sSubKeyName(iter.m_pszName, iter.m_nLength);
+
+            ORegKey* pOpenSubKey = nullptr;
+            _ret = pKey->openKey(sSubKeyName, reinterpret_cast<RegKeyHandle*>(&pOpenSubKey));
+            if (_ret != RegError::NO_ERROR)
+            {
+                *phOpenSubKeys = nullptr;
+                *pnSubKeys = 0;
+                std::free(pSubKeys); // @@@ leaking 'pSubKeys[0...nSubkeys-1]'
+                return _ret;              // @@@ leaking 'pKey'
+            }
+
+            pSubKeys[nSubKeys] = pOpenSubKey;
+
+            nSubKeys++;
+        }
+
+        _err = rStoreDir.next(iter);
+    }
+
+    *phOpenSubKeys = reinterpret_cast<RegKeyHandle*>(pSubKeys);
+    if (!keyName.empty())
+    {
+        (void) releaseKey(pKey);
+    }
+    return RegError::NO_ERROR;
+}
+
+
+//  getKeyNames
+
+RegError ORegKey::getKeyNames(std::u16string_view keyName,
+                              rtl_uString*** pSubKeyNames,
+                              sal_uInt32* pnSubKeys)
+{
+    *pSubKeyNames = nullptr;
+    *pnSubKeys = 0;
+
+    ORegKey* pKey = this;
+    if (!keyName.empty())
+    {
+        RegError _ret = openKey(keyName, reinterpret_cast<RegKeyHandle*>(&pKey));
+        if (_ret != RegError::NO_ERROR)
+            return _ret;
+    }
+
+    sal_uInt32 nSubKeys = pKey->countSubKeys();
+    *pnSubKeys = nSubKeys;
+
+    rtl_uString** pSubKeys
+        = static_cast<rtl_uString**>(rtl_allocateZeroMemory(nSubKeys * sizeof(rtl_uString*)));
+
+    OStoreDirectory::iterator   iter;
+    OStoreDirectory             rStoreDir(pKey->getStoreDir());
+    storeError                  _err = rStoreDir.first(iter);
+
+    nSubKeys = 0;
+
+    while ( _err == store_E_None )
+    {
+        if ( iter.m_nAttrib & STORE_ATTRIB_ISDIR)
+        {
+            OUString const sSubKeyName(iter.m_pszName, iter.m_nLength);
+
+            OUString sFullKeyName(pKey->getName());
+            if (sFullKeyName.getLength() > 1)
+                sFullKeyName += ORegistry::ROOT;
+            sFullKeyName += sSubKeyName;
+
+            rtl_uString_newFromString(&pSubKeys[nSubKeys], sFullKeyName.pData);
+
+            nSubKeys++;
+        }
+
+        _err = rStoreDir.next(iter);
+    }
+
+    *pSubKeyNames = pSubKeys;
+    if (!keyName.empty())
+    {
+        releaseKey(pKey);
+    }
+    return RegError::NO_ERROR;
+}
+
+
+//  closeKey
+
+RegError ORegKey::closeKey(RegKeyHandle hKey)
+{
+    return m_pRegistry->closeKey(hKey);
+}
+
+
+//  deleteKey
+
+RegError ORegKey::deleteKey(std::u16string_view keyName)
+{
+    return m_pRegistry->deleteKey(this, keyName);
+}
+
+
+//  getValueType
+
+RegError ORegKey::getValueInfo(std::u16string_view valueName, RegValueType* pValueType, sal_uInt32* pValueSize) const
+{
+    OStoreStream    rValue;
+    std::unique_ptr<sal_uInt8[]> pBuffer;
+    storeAccessMode accessMode = storeAccessMode::ReadWrite;
+
+    if (m_pRegistry->isReadOnly())
+    {
+        accessMode = storeAccessMode::ReadOnly;
+    }
+
+    OUString sImplValueName = OUString::Concat(VALUE_PREFIX) + valueName;
+
+    REG_GUARD(m_pRegistry->m_mutex);
+
+    if ( rValue.create(m_pRegistry->getStoreFile(), m_name + ORegistry::ROOT, sImplValueName, accessMode) )
+    {
+        *pValueType = RegValueType::NOT_DEFINED;
+        *pValueSize = 0;
+        return RegError::VALUE_NOT_EXISTS;
+    }
+
+    pBuffer.reset(new sal_uInt8[VALUE_HEADERSIZE]);
+
+    sal_uInt32  readBytes;
+    if ( rValue.readAt(0, pBuffer.get(), VALUE_HEADERSIZE, readBytes) )
+    {
+        return RegError::INVALID_VALUE;
+    }
+    if (readBytes != VALUE_HEADERSIZE)
+    {
+        return RegError::INVALID_VALUE;
+    }
+
+    sal_uInt32  size;
+    sal_uInt8   type = pBuffer[0];
+    readUINT32(pBuffer.get()+VALUE_TYPEOFFSET, size);
+
+    *pValueType = static_cast<RegValueType>(type);
+    if (*pValueType > RegValueType::BINARY)
+    {
+        pBuffer.reset(new sal_uInt8[4]);
+        rValue.readAt(VALUE_HEADEROFFSET, pBuffer.get(), 4, readBytes);
+
+        readUINT32(pBuffer.get(), size);
+    }
+
+    *pValueSize = size;
+
+    return RegError::NO_ERROR;
+}
+
+
+//  setValue
+
+RegError ORegKey::setValue(std::u16string_view valueName, RegValueType vType, RegValue value, sal_uInt32 vSize)
+{
+    OStoreStream    rValue;
+    std::unique_ptr<sal_uInt8[]> pBuffer;
+
+    if (m_pRegistry->isReadOnly())
+    {
+        return RegError::REGISTRY_READONLY;
+    }
+
+    if (vType > RegValueType::BINARY)
+    {
+        return RegError::INVALID_VALUE;
+    }
+
+    OUString sImplValueName = OUString::Concat(VALUE_PREFIX) + valueName;
+
+    REG_GUARD(m_pRegistry->m_mutex);
+
+    if ( rValue.create(getStoreFile(), m_name + ORegistry::ROOT , sImplValueName, storeAccessMode::Create) )
+    {
+        return RegError::SET_VALUE_FAILED;
+    }
+
+    sal_uInt32 size = vSize;
+
+    sal_uInt8 type = static_cast<sal_uInt8>(vType);
+    pBuffer.reset(new sal_uInt8[VALUE_HEADERSIZE + size]);
+    memcpy(pBuffer.get(), &type, 1);
+
+    writeUINT32(pBuffer.get()+VALUE_TYPEOFFSET, size);
+
+    switch (vType)
+    {
+        case RegValueType::NOT_DEFINED:
+            memcpy(pBuffer.get()+VALUE_HEADEROFFSET, value, size);
+            break;
+        case RegValueType::LONG:
+            writeINT32(pBuffer.get()+VALUE_HEADEROFFSET, *static_cast<sal_Int32*>(value));
+            break;
+        case RegValueType::STRING:
+            writeUtf8(pBuffer.get()+VALUE_HEADEROFFSET, static_cast<const char*>(value));
+            break;
+        case RegValueType::UNICODE:
+            writeString(pBuffer.get()+VALUE_HEADEROFFSET, static_cast<const sal_Unicode*>(value));
+            break;
+        case RegValueType::BINARY:
+            memcpy(pBuffer.get()+VALUE_HEADEROFFSET, value, size);
+            break;
+        default:
+            OSL_ASSERT(false);
+            break;
+    }
+
+    sal_uInt32  writenBytes;
+    if ( rValue.writeAt(0, pBuffer.get(), VALUE_HEADERSIZE+size, writenBytes) )
+    {
+        return RegError::SET_VALUE_FAILED;
+    }
+    if (writenBytes != (VALUE_HEADERSIZE+size))
+    {
+        return RegError::SET_VALUE_FAILED;
+    }
+    setModified();
+
+    return RegError::NO_ERROR;
+}
+
+
+//  setLongListValue
+
+RegError ORegKey::setLongListValue(std::u16string_view valueName, sal_Int32 const * pValueList, sal_uInt32 len)
+{
+    OStoreStream    rValue;
+    std::unique_ptr<sal_uInt8[]> pBuffer;
+
+    if (m_pRegistry->isReadOnly())
+    {
+        return RegError::REGISTRY_READONLY;
+    }
+
+    OUString sImplValueName = OUString::Concat(VALUE_PREFIX) + valueName;
+
+    REG_GUARD(m_pRegistry->m_mutex);
+
+    if (rValue.create(getStoreFile(), m_name + ORegistry::ROOT, sImplValueName, storeAccessMode::Create) )
+    {
+        return RegError::SET_VALUE_FAILED;
+    }
+
+    sal_uInt32 size = 4; // 4 bytes (sal_uInt32) for the length
+
+    size += len * 4;
+
+    sal_uInt8 type = sal_uInt8(RegValueType::LONGLIST);
+    pBuffer.reset(new sal_uInt8[VALUE_HEADERSIZE + size]);
+    memcpy(pBuffer.get(), &type, 1);
+
+    writeUINT32(pBuffer.get()+VALUE_TYPEOFFSET, size);
+    writeUINT32(pBuffer.get()+VALUE_HEADEROFFSET, len);
+
+    sal_uInt32 offset = 4; // initial 4 bytes for the size of the array
+
+    for (sal_uInt32 i=0; i < len; i++)
+    {
+        writeINT32(pBuffer.get()+VALUE_HEADEROFFSET+offset, pValueList[i]);
+        offset += 4;
+    }
+
+    sal_uInt32  writenBytes;
+    if ( rValue.writeAt(0, pBuffer.get(), VALUE_HEADERSIZE+size, writenBytes) )
+    {
+        return RegError::SET_VALUE_FAILED;
+    }
+    if (writenBytes != (VALUE_HEADEROFFSET+size))
+    {
+        return RegError::SET_VALUE_FAILED;
+    }
+    setModified();
+
+    return RegError::NO_ERROR;
+}
+
+
+//  setStringListValue
+
+RegError ORegKey::setStringListValue(
+    std::u16string_view valueName, char** pValueList, sal_uInt32 len)
+{
+    OStoreStream    rValue;
+    std::unique_ptr<sal_uInt8[]> pBuffer;
+
+    if (m_pRegistry->isReadOnly())
+    {
+        return RegError::REGISTRY_READONLY;
+    }
+
+    OUString sImplValueName = OUString::Concat(VALUE_PREFIX) + valueName;
+
+    REG_GUARD(m_pRegistry->m_mutex);
+
+    if (rValue.create(getStoreFile(), m_name + ORegistry::ROOT, sImplValueName, storeAccessMode::Create) )
+    {
+        return RegError::SET_VALUE_FAILED;
+    }
+
+    sal_uInt32 size = 4; // 4 bytes (sal_uInt32) for the length
+
+    sal_uInt32 i;
+    for (i=0; i < len; i++)
+    {
+        size +=  4 + strlen(pValueList[i]) + 1;
+    }
+
+    sal_uInt8 type = sal_uInt8(RegValueType::STRINGLIST);
+    pBuffer.reset(new sal_uInt8[VALUE_HEADERSIZE + size]);
+    memcpy(pBuffer.get(), &type, 1);
+
+    writeUINT32(pBuffer.get()+VALUE_TYPEOFFSET, size);
+    writeUINT32(pBuffer.get()+VALUE_HEADEROFFSET, len);
+
+    sal_uInt32 offset = 4; // initial 4 bytes for the size of the array;
+    sal_uInt32 sLen = 0;
+
+    for (i=0; i < len; i++)
+    {
+        sLen = strlen(pValueList[i]) + 1;
+        writeUINT32(pBuffer.get()+VALUE_HEADEROFFSET+offset, sLen);
+
+        offset += 4;
+        writeUtf8(pBuffer.get()+VALUE_HEADEROFFSET+offset, pValueList[i]);
+        offset += sLen;
+    }
+
+    sal_uInt32  writenBytes;
+    if ( rValue.writeAt(0, pBuffer.get(), VALUE_HEADERSIZE+size, writenBytes) )
+    {
+        return RegError::SET_VALUE_FAILED;
+    }
+    if (writenBytes != (VALUE_HEADERSIZE+size))
+    {
+        return RegError::SET_VALUE_FAILED;
+    }
+    setModified();
+
+    return RegError::NO_ERROR;
+}
+
+
+//  setUnicodeListValue
+
+RegError ORegKey::setUnicodeListValue(std::u16string_view valueName, sal_Unicode** pValueList, sal_uInt32 len)
+{
+    OStoreStream    rValue;
+    std::unique_ptr<sal_uInt8[]> pBuffer;
+
+    if (m_pRegistry->isReadOnly())
+    {
+        return RegError::REGISTRY_READONLY;
+    }
+
+    OUString sImplValueName = OUString::Concat(VALUE_PREFIX) + valueName;
+
+    REG_GUARD(m_pRegistry->m_mutex);
+
+    if (rValue.create(getStoreFile(), m_name + ORegistry::ROOT, sImplValueName, storeAccessMode::Create) )
+    {
+        return RegError::SET_VALUE_FAILED;
+    }
+
+    sal_uInt32 size = 4; // 4 bytes (sal_uInt32) for the length
+
+    sal_uInt32 i;
+    for (i=0; i < len; i++)
+    {
+        size +=  4 + ((rtl_ustr_getLength(pValueList[i]) +1) * 2);
+    }
+
+    sal_uInt8 type = sal_uInt8(RegValueType::UNICODELIST);
+    pBuffer.reset(new sal_uInt8[VALUE_HEADERSIZE + size]);
+    memcpy(pBuffer.get(), &type, 1);
+
+    writeUINT32(pBuffer.get()+VALUE_TYPEOFFSET, size);
+    writeUINT32(pBuffer.get()+VALUE_HEADEROFFSET, len);
+
+    sal_uInt32 offset = 4; // initial 4 bytes for the size of the array;
+    sal_uInt32 sLen = 0;
+
+    for (i=0; i < len; i++)
+    {
+        sLen = (rtl_ustr_getLength(pValueList[i]) + 1) * 2;
+        writeUINT32(pBuffer.get()+VALUE_HEADEROFFSET+offset, sLen);
+
+        offset += 4;
+        writeString(pBuffer.get()+VALUE_HEADEROFFSET+offset, pValueList[i]);
+        offset += sLen;
+    }
+
+    sal_uInt32  writenBytes;
+    if ( rValue.writeAt(0, pBuffer.get(), VALUE_HEADERSIZE+size, writenBytes) )
+    {
+        return RegError::SET_VALUE_FAILED;
+    }
+    if (writenBytes != (VALUE_HEADERSIZE+size))
+    {
+        return RegError::SET_VALUE_FAILED;
+    }
+    setModified();
+
+    return RegError::NO_ERROR;
+}
+
+
+//  getValue
+
+RegError ORegKey::getValue(std::u16string_view valueName, RegValue value) const
+{
+    OStoreStream    rValue;
+    std::unique_ptr<sal_uInt8[]> pBuffer;
+    RegValueType    valueType;
+    sal_uInt32      valueSize;
+    storeAccessMode accessMode = storeAccessMode::ReadWrite;
+
+    if (m_pRegistry->isReadOnly())
+    {
+        accessMode = storeAccessMode::ReadOnly;
+    }
+
+    OUString sImplValueName = OUString::Concat(VALUE_PREFIX) + valueName;
+
+    REG_GUARD(m_pRegistry->m_mutex);
+
+    if (rValue.create(getStoreFile(), m_name + ORegistry::ROOT, sImplValueName, accessMode) )
+    {
+        return RegError::VALUE_NOT_EXISTS;
+    }
+
+    pBuffer.reset(new sal_uInt8[VALUE_HEADERSIZE]);
+
+    sal_uInt32  readBytes;
+    if ( rValue.readAt(0, pBuffer.get(), VALUE_HEADERSIZE, readBytes) )
+    {
+        return RegError::INVALID_VALUE;
+    }
+    if (readBytes != VALUE_HEADERSIZE)
+    {
+        return RegError::INVALID_VALUE;
+    }
+
+    sal_uInt8   type = pBuffer[0];
+    valueType = static_cast<RegValueType>(type);
+    readUINT32(pBuffer.get()+VALUE_TYPEOFFSET, valueSize);
+
+    if (valueType > RegValueType::BINARY)
+    {
+        return RegError::INVALID_VALUE;
+    }
+
+    pBuffer.reset(new sal_uInt8[valueSize]);
+
+    if ( rValue.readAt(VALUE_HEADEROFFSET, pBuffer.get(), valueSize, readBytes) )
+    {
+        return RegError::INVALID_VALUE;
+    }
+    if (readBytes != valueSize)
+    {
+        return RegError::INVALID_VALUE;
+    }
+
+    switch (valueType)
+    {
+        case RegValueType::LONG:
+            readINT32(pBuffer.get(), *static_cast<sal_Int32*>(value));
+            break;
+        case RegValueType::STRING:
+            readUtf8(pBuffer.get(), static_cast<char*>(value), valueSize);
+            break;
+        case RegValueType::UNICODE:
+            readString(pBuffer.get(), static_cast<sal_Unicode*>(value), valueSize);
+            break;
+        case RegValueType::BINARY:
+            memcpy(value, pBuffer.get(), valueSize);
+            break;
+        default:
+            memcpy(value, pBuffer.get(), valueSize);
+            break;
+    }
+
+    return RegError::NO_ERROR;
+}
+
+
+//  getLongListValue
+
+RegError ORegKey::getLongListValue(std::u16string_view valueName, sal_Int32** pValueList, sal_uInt32* pLen) const
+{
+    OStoreStream    rValue;
+    std::unique_ptr<sal_uInt8[]> pBuffer;
+    RegValueType    valueType;
+    sal_uInt32      valueSize;
+    storeAccessMode accessMode = storeAccessMode::ReadWrite;
+
+    if (m_pRegistry->isReadOnly())
+    {
+        accessMode = storeAccessMode::ReadOnly;
+    }
+
+    OUString sImplValueName = OUString::Concat(VALUE_PREFIX) + valueName;
+
+    REG_GUARD(m_pRegistry->m_mutex);
+
+    if (rValue.create(getStoreFile(), m_name + ORegistry::ROOT, sImplValueName, accessMode) )
+    {
+        pValueList = nullptr;
+        *pLen = 0;
+        return RegError::VALUE_NOT_EXISTS;
+    }
+
+    pBuffer.reset(new sal_uInt8[VALUE_HEADERSIZE]);
+
+    sal_uInt32  readBytes;
+    if ( rValue.readAt(0, pBuffer.get(), VALUE_HEADERSIZE, readBytes) )
+    {
+        pValueList = nullptr;
+        *pLen = 0;
+        return RegError::INVALID_VALUE;
+    }
+    if (readBytes != VALUE_HEADERSIZE)
+    {
+        pValueList = nullptr;
+        *pLen = 0;
+        return RegError::INVALID_VALUE;
+    }
+
+    sal_uInt8   type = pBuffer[0];
+    valueType = static_cast<RegValueType>(type);
+
+    if (valueType != RegValueType::LONGLIST)
+    {
+        pValueList = nullptr;
+        *pLen = 0;
+        return RegError::INVALID_VALUE;
+    }
+
+    readUINT32(pBuffer.get()+VALUE_TYPEOFFSET, valueSize);
+
+    /* check for 'reasonable' value */
+    /* surely 10 millions entry in a registry list should be enough */
+    if(valueSize > 40000000)
+    {
+        pValueList = nullptr;
+        *pLen = 0;
+        return RegError::INVALID_VALUE;
+    }
+    pBuffer.reset(new sal_uInt8[valueSize]);
+
+    if ( rValue.readAt(VALUE_HEADEROFFSET, pBuffer.get(), valueSize, readBytes) )
+    {
+        pValueList = nullptr;
+        *pLen = 0;
+        return RegError::INVALID_VALUE;
+    }
+    if (readBytes != valueSize)
+    {
+        pValueList = nullptr;
+        *pLen = 0;
+        return RegError::INVALID_VALUE;
+    }
+
+    sal_uInt32 len = 0;
+    readUINT32(pBuffer.get(), len);
+
+    /* make sure the declared size of the array is consistent with the amount of data we have read */
+    if(len > (valueSize - 4) / 4)
+    {
+        pValueList = nullptr;
+        *pLen = 0;
+        return RegError::INVALID_VALUE;
+    }
+    *pLen = len;
+    sal_Int32* pVList = static_cast<sal_Int32*>(rtl_allocateZeroMemory(len * sizeof(sal_Int32)));
+
+    sal_uInt32 offset = 4; // initial 4 bytes for the size of the array;
+
+    for (sal_uInt32 i = 0; i < len; i++)
+    {
+        readINT32(pBuffer.get()+offset, pVList[i]);
+        offset += 4;
+    }
+
+    *pValueList = pVList;
+    return RegError::NO_ERROR;
+}
+
+
+//  getStringListValue
+
+RegError ORegKey::getStringListValue(std::u16string_view valueName, char*** pValueList, sal_uInt32* pLen) const
+{
+    OStoreStream    rValue;
+    std::unique_ptr<sal_uInt8[]> pBuffer;
+    RegValueType    valueType;
+    sal_uInt32      valueSize;
+    storeAccessMode accessMode = storeAccessMode::ReadWrite;
+
+    if (m_pRegistry->isReadOnly())
+    {
+        accessMode = storeAccessMode::ReadOnly;
+    }
+
+    OUString sImplValueName = OUString::Concat(VALUE_PREFIX) + valueName;
+
+    REG_GUARD(m_pRegistry->m_mutex);
+
+    if ( rValue.create(getStoreFile(), m_name + ORegistry::ROOT, sImplValueName, accessMode) )
+    {
+        pValueList = nullptr;
+        *pLen = 0;
+        return RegError::VALUE_NOT_EXISTS;
+    }
+
+    pBuffer.reset(new sal_uInt8[VALUE_HEADERSIZE]);
+
+    sal_uInt32  readBytes;
+    if ( rValue.readAt(0, pBuffer.get(), VALUE_HEADERSIZE, readBytes) )
+    {
+        pValueList = nullptr;
+        *pLen = 0;
+        return RegError::INVALID_VALUE;
+    }
+    if (readBytes != VALUE_HEADERSIZE)
+    {
+        pValueList = nullptr;
+        *pLen = 0;
+        return RegError::INVALID_VALUE;
+    }
+
+    sal_uInt8   type = pBuffer[0];
+    valueType = static_cast<RegValueType>(type);
+
+    if (valueType != RegValueType::STRINGLIST)
+    {
+        pValueList = nullptr;
+        *pLen = 0;
+        return RegError::INVALID_VALUE;
+    }
+
+    readUINT32(pBuffer.get()+VALUE_TYPEOFFSET, valueSize);
+
+    pBuffer.reset(new sal_uInt8[valueSize]);
+
+    if ( rValue.readAt(VALUE_HEADEROFFSET, pBuffer.get(), valueSize, readBytes) )
+    {
+        pValueList = nullptr;
+        *pLen = 0;
+        return RegError::INVALID_VALUE;
+    }
+    if (readBytes != valueSize)
+    {
+        pValueList = nullptr;
+        *pLen = 0;
+        return RegError::INVALID_VALUE;
+    }
+
+    sal_uInt32 len = 0;
+    readUINT32(pBuffer.get(), len);
+
+    *pLen = len;
+    char** pVList = static_cast<char**>(rtl_allocateZeroMemory(len * sizeof(char*)));
+
+    sal_uInt32 offset = 4; // initial 4 bytes for the size of the array;
+    sal_uInt32 sLen = 0;
+
+    char *pValue;
+    for (sal_uInt32 i=0; i < len; i++)
+    {
+        readUINT32(pBuffer.get()+offset, sLen);
+
+        offset += 4;
+
+        pValue = static_cast<char*>(std::malloc(sLen));
+        readUtf8(pBuffer.get()+offset, pValue, sLen);
+        pVList[i] = pValue;
+
+        offset += sLen;
+    }
+
+    *pValueList = pVList;
+    return RegError::NO_ERROR;
+}
+
+
+//  getUnicodeListValue
+
+RegError ORegKey::getUnicodeListValue(std::u16string_view valueName, sal_Unicode*** pValueList, sal_uInt32* pLen) const
+{
+    OStoreStream    rValue;
+    std::unique_ptr<sal_uInt8[]> pBuffer;
+    RegValueType    valueType;
+    sal_uInt32      valueSize;
+    storeAccessMode accessMode = storeAccessMode::ReadWrite;
+
+    if (m_pRegistry->isReadOnly())
+    {
+        accessMode = storeAccessMode::ReadOnly;
+    }
+
+    OUString sImplValueName = OUString::Concat(VALUE_PREFIX) + valueName;
+
+    REG_GUARD(m_pRegistry->m_mutex);
+
+    if ( rValue.create(getStoreFile(), m_name + ORegistry::ROOT, sImplValueName, accessMode) )
+    {
+        pValueList = nullptr;
+        *pLen = 0;
+        return RegError::VALUE_NOT_EXISTS;
+    }
+
+    pBuffer.reset(new sal_uInt8[VALUE_HEADERSIZE]);
+
+    sal_uInt32  readBytes;
+    if ( rValue.readAt(0, pBuffer.get(), VALUE_HEADERSIZE, readBytes) )
+    {
+        pValueList = nullptr;
+        *pLen = 0;
+        return RegError::INVALID_VALUE;
+    }
+    if (readBytes != VALUE_HEADERSIZE)
+    {
+        pValueList = nullptr;
+        *pLen = 0;
+        return RegError::INVALID_VALUE;
+    }
+
+    sal_uInt8   type = pBuffer[0];
+    valueType = static_cast<RegValueType>(type);
+
+    if (valueType != RegValueType::UNICODELIST)
+    {
+        pValueList = nullptr;
+        *pLen = 0;
+        return RegError::INVALID_VALUE;
+    }
+
+    readUINT32(pBuffer.get()+VALUE_TYPEOFFSET, valueSize);
+
+    pBuffer.reset(new sal_uInt8[valueSize]);
+
+    if ( rValue.readAt(VALUE_HEADEROFFSET, pBuffer.get(), valueSize, readBytes) )
+    {
+        pValueList = nullptr;
+        *pLen = 0;
+        return RegError::INVALID_VALUE;
+    }
+    if (readBytes != valueSize)
+    {
+        pValueList = nullptr;
+        *pLen = 0;
+        return RegError::INVALID_VALUE;
+    }
+
+    sal_uInt32 len = 0;
+    readUINT32(pBuffer.get(), len);
+
+    *pLen = len;
+    sal_Unicode** pVList = static_cast<sal_Unicode**>(rtl_allocateZeroMemory(len * sizeof(sal_Unicode*)));
+
+    sal_uInt32 offset = 4; // initial 4 bytes for the size of the array;
+    sal_uInt32 sLen = 0;
+
+    sal_Unicode *pValue;
+    for (sal_uInt32 i=0; i < len; i++)
+    {
+        readUINT32(pBuffer.get()+offset, sLen);
+
+        offset += 4;
+
+        pValue = static_cast<sal_Unicode*>(std::malloc((sLen / 2) * sizeof(sal_Unicode)));
+        readString(pBuffer.get()+offset, pValue, sLen);
+        pVList[i] = pValue;
+
+        offset += sLen;
+    }
+
+    *pValueList = pVList;
+    return RegError::NO_ERROR;
+}
+
+
+RegError ORegKey::getResolvedKeyName(std::u16string_view keyName,
+                                     OUString& resolvedName) const
+{
+    if (keyName.empty())
+        return RegError::INVALID_KEYNAME;
+
+    resolvedName = getFullPath(keyName);
+    return RegError::NO_ERROR;
+}
+
+
+//  countSubKeys()
+
+sal_uInt32 ORegKey::countSubKeys()
+{
+    REG_GUARD(m_pRegistry->m_mutex);
+
+    OStoreDirectory::iterator   iter;
+    OStoreDirectory             rStoreDir = getStoreDir();
+    storeError                  _err = rStoreDir.first(iter);
+    sal_uInt32                  count = 0;
+
+    while ( _err == store_E_None )
+    {
+        if ( iter.m_nAttrib & STORE_ATTRIB_ISDIR )
+        {
+            count++;
+        }
+
+        _err = rStoreDir.next(iter);
+    }
+
+    return count;
+}
+
+OStoreDirectory ORegKey::getStoreDir() const
+{
+    OStoreDirectory rStoreDir;
+    OUString        fullPath;
+    OUString        relativName;
+    storeAccessMode accessMode = storeAccessMode::ReadWrite;
+
+    if ( m_name == ORegistry::ROOT )
+    {
+        fullPath.clear();
+        relativName.clear();
+    } else
+    {
+        fullPath = m_name.copy(0, m_name.lastIndexOf('/') + 1);
+        relativName = m_name.copy(m_name.lastIndexOf('/') + 1);
+    }
+
+    if (m_pRegistry->isReadOnly())
+    {
+        accessMode = storeAccessMode::ReadOnly;
+    }
+
+    rStoreDir.create(getStoreFile(), fullPath, relativName, accessMode);
+
+    return rStoreDir;
+}
+
+OUString ORegKey::getFullPath(std::u16string_view path) const {
+    OSL_ASSERT(!m_name.isEmpty() && !path.empty());
+    OUStringBuffer b(32);
+    b.append(m_name);
+    if (!b.isEmpty() && b[b.getLength() - 1] == '/') {
+        if (path[0] == '/') {
+            b.append(path.substr(1));
+        } else {
+            b.append(path);
+        }
+    } else {
+        if (path[0] != '/') {
+            b.append('/');
+        }
+        b.append(path);
+    }
+    return b.makeStringAndClear();
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/registry/source/keyimpl.hxx b/registry/source/keyimpl.hxx
new file mode 100644
index 000000000..1958a7b62
--- /dev/null
+++ b/registry/source/keyimpl.hxx
@@ -0,0 +1,140 @@
+/* -*- 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_REGISTRY_SOURCE_KEYIMPL_HXX
+#define INCLUDED_REGISTRY_SOURCE_KEYIMPL_HXX
+
+#include <sal/config.h>
+
+#include <string_view>
+
+#include "regimpl.hxx"
+#include <rtl/ustring.hxx>
+
+class ORegKey
+{
+public:
+
+    ORegKey(const OUString& keyName, ORegistry* pReg);
+    ~ORegKey();
+
+    void        acquire()
+        { ++m_refCount; }
+
+    sal_uInt32  release()
+        { return --m_refCount; }
+
+    RegError    releaseKey(RegKeyHandle hKey);
+
+    RegError    createKey(std::u16string_view keyName, RegKeyHandle* phNewKey);
+
+    RegError    openKey(std::u16string_view keyName, RegKeyHandle* phOpenKey);
+
+    RegError    openSubKeys(std::u16string_view keyName,
+                            RegKeyHandle** phOpenSubKeys,
+                            sal_uInt32* pnSubKeys);
+
+    RegError    getKeyNames(std::u16string_view keyName,
+                            rtl_uString*** pSubKeyNames,
+                            sal_uInt32* pnSubKeys);
+
+    RegError    closeKey(RegKeyHandle hKey);
+
+    RegError    deleteKey(std::u16string_view keyName);
+
+    RegError    getValueInfo(std::u16string_view valueName,
+                             RegValueType* pValueTye,
+                             sal_uInt32* pValueSize) const;
+
+    RegError    setValue(std::u16string_view valueName,
+                         RegValueType vType,
+                         RegValue value,
+                         sal_uInt32 vSize);
+
+    RegError    setLongListValue(std::u16string_view valueName,
+                                 sal_Int32 const * pValueList,
+                                 sal_uInt32 len);
+
+    RegError    setStringListValue(std::u16string_view valueName,
+                                   char** pValueList,
+                                  sal_uInt32 len);
+
+    RegError    setUnicodeListValue(std::u16string_view valueName,
+                                   sal_Unicode** pValueList,
+                                  sal_uInt32 len);
+
+    RegError    getValue(std::u16string_view valueName, RegValue value) const;
+
+    RegError    getLongListValue(std::u16string_view valueName,
+                                  sal_Int32** pValueList,
+                                 sal_uInt32* pLen) const;
+
+    RegError    getStringListValue(std::u16string_view valueName,
+                                    char*** pValueList,
+                                   sal_uInt32* pLen) const;
+
+    RegError    getUnicodeListValue(std::u16string_view valueName,
+                                     sal_Unicode*** pValueList,
+                                    sal_uInt32* pLen) const;
+
+    RegError    getResolvedKeyName(std::u16string_view keyName,
+                                   OUString& resolvedName) const;
+
+    bool isDeleted() const
+        { return m_bDeleted; }
+
+    void setDeleted (bool bKeyDeleted)
+        { m_bDeleted = bKeyDeleted; }
+
+    bool isModified() const
+        { return m_bModified; }
+
+    void setModified (bool bModified = true)
+        { m_bModified = bModified; }
+
+    bool        isReadOnly() const
+                    { return m_pRegistry->isReadOnly(); }
+
+    sal_uInt32      countSubKeys();
+
+    ORegistry* getRegistry() const
+                    { return m_pRegistry; }
+
+    const store::OStoreFile& getStoreFile() const
+                    { return m_pRegistry->getStoreFile(); }
+
+    store::OStoreDirectory getStoreDir() const;
+
+    const OUString& getName() const
+                    { return m_name; }
+
+    OUString getFullPath(std::u16string_view path) const;
+
+private:
+    sal_uInt32               m_refCount;
+    OUString                 m_name;
+    bool                     m_bDeleted:1;
+    bool                     m_bModified:1;
+    ORegistry*               m_pRegistry;
+};
+
+#endif
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/registry/source/reflcnst.hxx b/registry/source/reflcnst.hxx
new file mode 100644
index 000000000..2254b94b5
--- /dev/null
+++ b/registry/source/reflcnst.hxx
@@ -0,0 +1,229 @@
+/* -*- 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_REGISTRY_SOURCE_REFLCNST_HXX
+#define INCLUDED_REGISTRY_SOURCE_REFLCNST_HXX
+
+#include <registry/types.hxx>
+
+#include <string.h>
+
+#define REGTYPE_IEEE_NATIVE 1
+
+extern const sal_uInt32 magic;
+extern const sal_uInt16 minorVersion;
+extern const sal_uInt16 majorVersion;
+
+#define OFFSET_MAGIC                0
+#define OFFSET_SIZE                 static_cast<sal_uInt32>(OFFSET_MAGIC + sizeof(magic))
+#define OFFSET_MINOR_VERSION        static_cast<sal_uInt32>(OFFSET_SIZE + sizeof(sal_uInt32))
+#define OFFSET_MAJOR_VERSION        static_cast<sal_uInt32>(OFFSET_MINOR_VERSION + sizeof(minorVersion))
+#define OFFSET_N_ENTRIES            static_cast<sal_uInt32>(OFFSET_MAJOR_VERSION + sizeof(majorVersion))
+#define OFFSET_TYPE_SOURCE          static_cast<sal_uInt32>(OFFSET_N_ENTRIES + sizeof(sal_uInt16))
+#define OFFSET_TYPE_CLASS           static_cast<sal_uInt32>(OFFSET_TYPE_SOURCE + sizeof(sal_uInt16))
+#define OFFSET_THIS_TYPE            static_cast<sal_uInt32>(OFFSET_TYPE_CLASS + sizeof(sal_uInt16))
+#define OFFSET_UIK                  static_cast<sal_uInt32>(OFFSET_THIS_TYPE + sizeof(sal_uInt16))
+#define OFFSET_DOKU                 static_cast<sal_uInt32>(OFFSET_UIK + sizeof(sal_uInt16))
+#define OFFSET_FILENAME             static_cast<sal_uInt32>(OFFSET_DOKU + sizeof(sal_uInt16))
+
+#define OFFSET_N_SUPERTYPES         static_cast<sal_uInt32>(OFFSET_FILENAME + sizeof(sal_uInt16))
+#define OFFSET_SUPERTYPES           static_cast<sal_uInt32>(OFFSET_N_SUPERTYPES + sizeof(sal_uInt16))
+
+#define OFFSET_CP_SIZE              static_cast<sal_uInt32>(OFFSET_SUPERTYPES + sizeof(sal_uInt16))
+#define OFFSET_CP                   static_cast<sal_uInt32>(OFFSET_CP_SIZE + sizeof(sal_uInt16))
+
+#define CP_OFFSET_ENTRY_SIZE        0
+#define CP_OFFSET_ENTRY_TAG         static_cast<sal_uInt32>(CP_OFFSET_ENTRY_SIZE + sizeof(sal_uInt32))
+#define CP_OFFSET_ENTRY_DATA        static_cast<sal_uInt32>(CP_OFFSET_ENTRY_TAG + sizeof(sal_uInt16))
+#define CP_OFFSET_ENTRY_UIK1        static_cast<sal_uInt32>(CP_OFFSET_ENTRY_DATA)
+#define CP_OFFSET_ENTRY_UIK2        static_cast<sal_uInt32>(CP_OFFSET_ENTRY_UIK1 + sizeof(sal_uInt32))
+#define CP_OFFSET_ENTRY_UIK3        static_cast<sal_uInt32>(CP_OFFSET_ENTRY_UIK2 + sizeof(sal_uInt16))
+#define CP_OFFSET_ENTRY_UIK4        static_cast<sal_uInt32>(CP_OFFSET_ENTRY_UIK3 + sizeof(sal_uInt16))
+#define CP_OFFSET_ENTRY_UIK5        static_cast<sal_uInt32>(CP_OFFSET_ENTRY_UIK4 + sizeof(sal_uInt32))
+
+#define FIELD_OFFSET_ACCESS         0
+#define FIELD_OFFSET_NAME           static_cast<sal_uInt32>(FIELD_OFFSET_ACCESS + sizeof(sal_uInt16))
+#define FIELD_OFFSET_TYPE           static_cast<sal_uInt32>(FIELD_OFFSET_NAME + sizeof(sal_uInt16))
+#define FIELD_OFFSET_VALUE          static_cast<sal_uInt32>(FIELD_OFFSET_TYPE + sizeof(sal_uInt16))
+#define FIELD_OFFSET_DOKU           static_cast<sal_uInt32>(FIELD_OFFSET_VALUE + sizeof(sal_uInt16))
+#define FIELD_OFFSET_FILENAME       static_cast<sal_uInt32>(FIELD_OFFSET_DOKU + sizeof(sal_uInt16))
+
+#define PARAM_OFFSET_TYPE           0
+#define PARAM_OFFSET_MODE           static_cast<sal_uInt32>(PARAM_OFFSET_TYPE + sizeof(sal_uInt16))
+#define PARAM_OFFSET_NAME           static_cast<sal_uInt32>(PARAM_OFFSET_MODE + sizeof(sal_uInt16))
+
+#define METHOD_OFFSET_SIZE          0
+#define METHOD_OFFSET_MODE          static_cast<sal_uInt32>(METHOD_OFFSET_SIZE + sizeof(sal_uInt16))
+#define METHOD_OFFSET_NAME          static_cast<sal_uInt32>(METHOD_OFFSET_MODE + sizeof(sal_uInt16))
+#define METHOD_OFFSET_RETURN        static_cast<sal_uInt32>(METHOD_OFFSET_NAME + sizeof(sal_uInt16))
+#define METHOD_OFFSET_DOKU          static_cast<sal_uInt32>(METHOD_OFFSET_RETURN + sizeof(sal_uInt16))
+#define METHOD_OFFSET_PARAM_COUNT   static_cast<sal_uInt32>(METHOD_OFFSET_DOKU + sizeof(sal_uInt16))
+
+#define REFERENCE_OFFSET_TYPE       0
+#define REFERENCE_OFFSET_NAME       static_cast<sal_uInt32>(REFERENCE_OFFSET_TYPE + sizeof(sal_uInt16))
+#define REFERENCE_OFFSET_DOKU       static_cast<sal_uInt32>(REFERENCE_OFFSET_NAME + sizeof(sal_uInt16))
+#define REFERENCE_OFFSET_ACCESS     static_cast<sal_uInt32>(REFERENCE_OFFSET_DOKU + sizeof(sal_uInt16))
+
+enum CPInfoTag
+{
+    CP_TAG_INVALID = RT_TYPE_NONE,
+    CP_TAG_CONST_BOOL = RT_TYPE_BOOL,
+    CP_TAG_CONST_BYTE  = RT_TYPE_BYTE,
+    CP_TAG_CONST_INT16 = RT_TYPE_INT16,
+    CP_TAG_CONST_UINT16 = RT_TYPE_UINT16,
+    CP_TAG_CONST_INT32 = RT_TYPE_INT32,
+    CP_TAG_CONST_UINT32 = RT_TYPE_UINT32,
+    CP_TAG_CONST_INT64 = RT_TYPE_INT64,
+    CP_TAG_CONST_UINT64 = RT_TYPE_UINT64,
+    CP_TAG_CONST_FLOAT = RT_TYPE_FLOAT,
+    CP_TAG_CONST_DOUBLE = RT_TYPE_DOUBLE,
+    CP_TAG_CONST_STRING = RT_TYPE_STRING,
+    CP_TAG_UTF8_NAME,
+    CP_TAG_UIK
+};
+
+inline sal_uInt32 writeBYTE(sal_uInt8* buffer, sal_uInt8 v)
+{
+    buffer[0] = v;
+
+    return sizeof(sal_uInt8);
+}
+
+inline sal_uInt32 writeINT16(sal_uInt8* buffer, sal_Int16 v)
+{
+    buffer[0] = static_cast<sal_uInt8>((v >> 8) & 0xFF);
+    buffer[1] = static_cast<sal_uInt8>((v >> 0) & 0xFF);
+
+    return sizeof(sal_Int16);
+}
+
+inline sal_uInt32 writeUINT16(sal_uInt8* buffer, sal_uInt16 v)
+{
+    buffer[0] = static_cast<sal_uInt8>((v >> 8) & 0xFF);
+    buffer[1] = static_cast<sal_uInt8>((v >> 0) & 0xFF);
+
+    return sizeof(sal_uInt16);
+}
+
+inline sal_uInt32 readUINT16(const sal_uInt8* buffer, sal_uInt16& v)
+{
+    //This is untainted data which comes from a controlled source
+    //so, using a byte-swapping pattern which coverity doesn't
+    //detect as such
+    //http://security.coverity.com/blog/2014/Apr/on-detecting-heartbleed-with-static-analysis.html
+    v = *buffer++; v <<= 8;
+    v |= *buffer;
+    return sizeof(sal_uInt16);
+}
+
+inline sal_uInt32 writeINT32(sal_uInt8* buffer, sal_Int32 v)
+{
+    buffer[0] = static_cast<sal_uInt8>((v >> 24) & 0xFF);
+    buffer[1] = static_cast<sal_uInt8>((v >> 16) & 0xFF);
+    buffer[2] = static_cast<sal_uInt8>((v >> 8) & 0xFF);
+    buffer[3] = static_cast<sal_uInt8>((v >> 0) & 0xFF);
+
+    return sizeof(sal_Int32);
+}
+
+inline sal_uInt32 readINT32(const sal_uInt8* buffer, sal_Int32& v)
+{
+    v = (
+            (buffer[0] << 24) |
+            (buffer[1] << 16) |
+            (buffer[2] << 8)  |
+            (buffer[3] << 0)
+        );
+
+    return sizeof(sal_Int32);
+}
+
+inline sal_uInt32 writeUINT32(sal_uInt8* buffer, sal_uInt32 v)
+{
+    buffer[0] = static_cast<sal_uInt8>((v >> 24) & 0xFF);
+    buffer[1] = static_cast<sal_uInt8>((v >> 16) & 0xFF);
+    buffer[2] = static_cast<sal_uInt8>((v >> 8) & 0xFF);
+    buffer[3] = static_cast<sal_uInt8>((v >> 0) & 0xFF);
+
+    return sizeof(sal_uInt32);
+}
+
+inline sal_uInt32 readUINT32(const sal_uInt8* buffer, sal_uInt32& v)
+{
+    //This is untainted data which comes from a controlled source
+    //so, using a byte-swapping pattern which coverity doesn't
+    //detect as such
+    //http://security.coverity.com/blog/2014/Apr/on-detecting-heartbleed-with-static-analysis.html
+    v = *buffer++; v <<= 8;
+    v |= *buffer++; v <<= 8;
+    v |= *buffer++; v <<= 8;
+    v |= *buffer;
+    return sizeof(sal_uInt32);
+}
+
+inline sal_uInt32 writeUINT64(sal_uInt8* buffer, sal_uInt64 v)
+{
+    buffer[0] = static_cast<sal_uInt8>((v >> 56) & 0xFF);
+    buffer[1] = static_cast<sal_uInt8>((v >> 48) & 0xFF);
+    buffer[2] = static_cast<sal_uInt8>((v >> 40) & 0xFF);
+    buffer[3] = static_cast<sal_uInt8>((v >> 32) & 0xFF);
+    buffer[4] = static_cast<sal_uInt8>((v >> 24) & 0xFF);
+    buffer[5] = static_cast<sal_uInt8>((v >> 16) & 0xFF);
+    buffer[6] = static_cast<sal_uInt8>((v >> 8) & 0xFF);
+    buffer[7] = static_cast<sal_uInt8>((v >> 0) & 0xFF);
+
+    return sizeof(sal_uInt64);
+}
+
+inline sal_uInt32 writeUtf8(sal_uInt8* buffer, const char* v)
+{
+    sal_uInt32 size = strlen(v) + 1;
+
+    memcpy(buffer, v, size);
+
+    return size;
+}
+
+inline sal_uInt32 readUtf8(const sal_uInt8* buffer, char* v, sal_uInt32 maxSize)
+{
+    sal_uInt32 size = strlen(reinterpret_cast<const char*>(buffer)) + 1;
+    if(size > maxSize)
+    {
+        size = maxSize;
+    }
+
+    memcpy(v, buffer, size);
+
+    if (size == maxSize) v[size - 1] = '\0';
+
+    return size;
+}
+
+
+sal_uInt32 writeFloat(sal_uInt8* buffer, float v);
+sal_uInt32 writeDouble(sal_uInt8* buffer, double v);
+sal_uInt32 writeString(sal_uInt8* buffer, const sal_Unicode* v);
+sal_uInt32 readString(const sal_uInt8* buffer, sal_Unicode* v, sal_uInt32 maxSize);
+
+sal_uInt32 UINT16StringLen(const sal_uInt8* wstring);
+
+#endif
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/registry/source/reflread.cxx b/registry/source/reflread.cxx
new file mode 100644
index 000000000..57884e110
--- /dev/null
+++ b/registry/source/reflread.cxx
@@ -0,0 +1,1760 @@
+/* -*- 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 <cstring>
+#include <memory>
+#include <new>
+#include <vector>
+
+#include <sal/types.h>
+#include <osl/endian.h>
+#include <osl/diagnose.h>
+#include "reflread.hxx"
+#include <sal/log.hxx>
+
+#include <registry/typereg_reader.hxx>
+#include <registry/version.h>
+
+#include "reflcnst.hxx"
+
+#include <cstddef>
+
+const char NULL_STRING[1] = { 0 };
+const sal_Unicode NULL_WSTRING[1] = { 0 };
+
+const sal_uInt32    magic = 0x12345678;
+const sal_uInt16 minorVersion = 0x0000;
+const sal_uInt16 majorVersion = 0x0001;
+
+/**************************************************************************
+
+    class BlopObject
+
+    holds any data in a flat memory buffer
+
+**************************************************************************/
+
+namespace {
+
+class BlopObject
+{
+public:
+    struct BoundsError {};
+
+    const sal_uInt8* m_pBuffer;
+    sal_uInt32      m_bufferLen;
+
+    BlopObject(const sal_uInt8* buffer, sal_uInt32 len);
+        // throws std::bad_alloc
+
+    sal_uInt8 readBYTE(sal_uInt32 index) const
+    {
+        if (index >= m_bufferLen) {
+            throw BoundsError();
+        }
+        return m_pBuffer[index];
+    }
+
+    sal_Int16 readINT16(sal_uInt32 index) const
+    {
+        if (m_bufferLen < 2 || index >= m_bufferLen - 1) {
+            throw BoundsError();
+        }
+        return ((m_pBuffer[index] << 8) | (m_pBuffer[index+1] << 0));
+    }
+
+    sal_uInt16 readUINT16(sal_uInt32 index) const
+    {
+        if (m_bufferLen < 2 || index >= m_bufferLen - 1) {
+            throw BoundsError();
+        }
+        return ((m_pBuffer[index] << 8) | (m_pBuffer[index+1] << 0));
+    }
+
+    sal_Int32 readINT32(sal_uInt32 index) const
+    {
+        if (m_bufferLen < 4 || index >= m_bufferLen - 3) {
+            throw BoundsError();
+        }
+        return (
+            (m_pBuffer[index]   << 24) |
+            (m_pBuffer[index+1] << 16) |
+            (m_pBuffer[index+2] << 8)  |
+            (m_pBuffer[index+3] << 0)
+        );
+    }
+
+    sal_uInt32 readUINT32(sal_uInt32 index) const
+    {
+        if (m_bufferLen < 4 || index >= m_bufferLen - 3) {
+            throw BoundsError();
+        }
+        return (
+            (m_pBuffer[index]   << 24) |
+            (m_pBuffer[index+1] << 16) |
+            (m_pBuffer[index+2] << 8)  |
+            (m_pBuffer[index+3] << 0)
+        );
+    }
+
+    sal_Int64 readINT64(sal_uInt32 index) const
+    {
+        if (m_bufferLen < 8 || index >= m_bufferLen - 7) {
+            throw BoundsError();
+        }
+        return (
+            (static_cast<sal_Int64>(m_pBuffer[index])   << 56) |
+            (static_cast<sal_Int64>(m_pBuffer[index+1]) << 48) |
+            (static_cast<sal_Int64>(m_pBuffer[index+2]) << 40) |
+            (static_cast<sal_Int64>(m_pBuffer[index+3]) << 32) |
+            (static_cast<sal_Int64>(m_pBuffer[index+4]) << 24) |
+            (static_cast<sal_Int64>(m_pBuffer[index+5]) << 16) |
+            (static_cast<sal_Int64>(m_pBuffer[index+6]) << 8)  |
+            (static_cast<sal_Int64>(m_pBuffer[index+7]) << 0)
+        );
+    }
+
+    sal_uInt64 readUINT64(sal_uInt32 index) const
+    {
+        if (m_bufferLen < 8 || index >= m_bufferLen - 7) {
+            throw BoundsError();
+        }
+        return (
+            (static_cast<sal_uInt64>(m_pBuffer[index])   << 56) |
+            (static_cast<sal_uInt64>(m_pBuffer[index+1]) << 48) |
+            (static_cast<sal_uInt64>(m_pBuffer[index+2]) << 40) |
+            (static_cast<sal_uInt64>(m_pBuffer[index+3]) << 32) |
+            (static_cast<sal_uInt64>(m_pBuffer[index+4]) << 24) |
+            (static_cast<sal_uInt64>(m_pBuffer[index+5]) << 16) |
+            (static_cast<sal_uInt64>(m_pBuffer[index+6]) << 8)  |
+            (static_cast<sal_uInt64>(m_pBuffer[index+7]) << 0)
+        );
+    }
+};
+
+}
+
+BlopObject::BlopObject(const sal_uInt8* buffer, sal_uInt32 len)
+    : m_bufferLen(len)
+{
+    m_pBuffer = buffer;
+}
+
+/**************************************************************************
+
+    class StringCache
+
+**************************************************************************/
+
+namespace {
+
+class StringCache
+{
+public:
+    std::vector<std::unique_ptr<sal_Unicode[]>> m_stringTable;
+    sal_uInt16      m_stringsCopied;
+
+    explicit StringCache(sal_uInt16 size); // throws std::bad_alloc
+
+    const sal_Unicode*  getString(sal_uInt16 index) const;
+    sal_uInt16 createString(const sal_uInt8* buffer); // throws std::bad_alloc
+};
+
+}
+
+StringCache::StringCache(sal_uInt16 size)
+    : m_stringTable(size)
+    , m_stringsCopied(0)
+{
+}
+
+const sal_Unicode* StringCache::getString(sal_uInt16 index) const
+{
+    if ((index > 0) && (index <= m_stringsCopied))
+        return m_stringTable[index - 1].get();
+    else
+        return nullptr;
+}
+
+sal_uInt16 StringCache::createString(const sal_uInt8* buffer)
+{
+    if (m_stringsCopied < m_stringTable.size())
+    {
+        sal_uInt32 len = UINT16StringLen(buffer);
+
+        m_stringTable[m_stringsCopied].reset( new sal_Unicode[len + 1] );
+
+        readString(buffer, m_stringTable[m_stringsCopied].get(), (len + 1) * sizeof(sal_Unicode));
+
+        return ++m_stringsCopied;
+    }
+    else
+        return 0;
+}
+
+/**************************************************************************
+
+    class ConstantPool
+
+**************************************************************************/
+
+namespace {
+
+class ConstantPool : public BlopObject
+{
+public:
+
+    sal_uInt16                   m_numOfEntries;
+    std::unique_ptr<sal_Int32[]> m_pIndex;           // index values may be < 0 for cached string constants
+
+    std::unique_ptr<StringCache> m_pStringCache;
+
+    ConstantPool(const sal_uInt8* buffer, sal_uInt32 len, sal_uInt16 numEntries)
+        : BlopObject(buffer, len)
+        , m_numOfEntries(numEntries)
+    {
+    }
+
+    sal_uInt32 parseIndex(); // throws std::bad_alloc
+
+    CPInfoTag           readTag(sal_uInt16 index) const;
+
+    const char*         readUTF8NameConstant(sal_uInt16 index) const;
+    bool                readBOOLConstant(sal_uInt16 index) const;
+    sal_Int8            readBYTEConstant(sal_uInt16 index) const;
+    sal_Int16           readINT16Constant(sal_uInt16 index) const;
+    sal_uInt16          readUINT16Constant(sal_uInt16 index) const;
+    sal_Int32           readINT32Constant(sal_uInt16 index) const;
+    sal_uInt32          readUINT32Constant(sal_uInt16 index) const;
+    sal_Int64           readINT64Constant(sal_uInt16 index) const;
+    sal_uInt64          readUINT64Constant(sal_uInt16 index) const;
+    float               readFloatConstant(sal_uInt16 index) const;
+    double              readDoubleConstant(sal_uInt16 index) const;
+    const sal_Unicode*  readStringConstant(sal_uInt16 index) const;
+        // throws std::bad_alloc
+};
+
+}
+
+sal_uInt32 ConstantPool::parseIndex()
+{
+    m_pIndex.reset();
+    m_pStringCache.reset();
+
+    sal_uInt32  offset = 0;
+    sal_uInt16  numOfStrings = 0;
+
+    if (m_numOfEntries)
+    {
+        m_pIndex.reset( new sal_Int32[m_numOfEntries] );
+
+        for (int i = 0; i < m_numOfEntries; i++)
+        {
+            m_pIndex[i] = offset;
+
+            offset += readUINT32(offset);
+
+            if ( static_cast<CPInfoTag>(readUINT16(m_pIndex[i] + CP_OFFSET_ENTRY_TAG)) ==
+                 CP_TAG_CONST_STRING )
+            {
+                numOfStrings++;
+            }
+
+        }
+    }
+
+    if (numOfStrings)
+    {
+        m_pStringCache.reset( new StringCache(numOfStrings) );
+    }
+
+    m_bufferLen = offset;
+
+    return offset;
+}
+
+CPInfoTag ConstantPool::readTag(sal_uInt16 index) const
+{
+    CPInfoTag tag = CP_TAG_INVALID;
+
+    if (m_pIndex && (index > 0) && (index <= m_numOfEntries))
+    {
+        tag = static_cast<CPInfoTag>(readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG));
+    }
+
+    return tag;
+}
+
+const char* ConstantPool::readUTF8NameConstant(sal_uInt16 index) const
+{
+    const char* aName = NULL_STRING;
+
+    if (m_pIndex && (index > 0) && (index <= m_numOfEntries))
+    {
+        if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_UTF8_NAME)
+        {
+            sal_uInt32 n = m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA;
+            if (n < m_bufferLen
+                && std::memchr(m_pBuffer + n, 0, m_bufferLen - n) != nullptr)
+            {
+                aName = reinterpret_cast<const char*>(m_pBuffer + n);
+            }
+        }
+    }
+
+    return aName;
+}
+
+bool ConstantPool::readBOOLConstant(sal_uInt16 index) const
+{
+    bool aBool = false;
+
+    if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
+    {
+        if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_BOOL)
+        {
+            aBool = readBYTE(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA) != 0;
+        }
+    }
+
+    return aBool;
+}
+
+sal_Int8 ConstantPool::readBYTEConstant(sal_uInt16 index) const
+{
+    sal_Int8 aByte = 0;
+
+    if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
+    {
+        if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_BYTE)
+        {
+            aByte = static_cast< sal_Int8 >(
+                readBYTE(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA));
+        }
+    }
+
+    return aByte;
+}
+
+sal_Int16 ConstantPool::readINT16Constant(sal_uInt16 index) const
+{
+    sal_Int16 aINT16 = 0;
+
+    if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
+    {
+        if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_INT16)
+        {
+            aINT16 = readINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
+        }
+    }
+
+    return aINT16;
+}
+
+sal_uInt16 ConstantPool::readUINT16Constant(sal_uInt16 index) const
+{
+    sal_uInt16 asal_uInt16 = 0;
+
+    if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
+    {
+        if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_UINT16)
+        {
+            asal_uInt16 = readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
+        }
+    }
+
+    return asal_uInt16;
+}
+
+sal_Int32 ConstantPool::readINT32Constant(sal_uInt16 index) const
+{
+    sal_Int32 aINT32 = 0;
+
+    if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
+    {
+        if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_INT32)
+        {
+            aINT32 = readINT32(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
+        }
+    }
+
+    return aINT32;
+}
+
+sal_uInt32 ConstantPool::readUINT32Constant(sal_uInt16 index) const
+{
+    sal_uInt32 aUINT32 = 0;
+
+    if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
+    {
+        if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_UINT32)
+        {
+            aUINT32 = readUINT32(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
+        }
+    }
+
+    return aUINT32;
+}
+
+sal_Int64 ConstantPool::readINT64Constant(sal_uInt16 index) const
+{
+    sal_Int64 aINT64 = 0;
+
+    if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
+    {
+        if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_INT64)
+        {
+            aINT64 = readINT64(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
+        }
+    }
+
+    return aINT64;
+}
+
+sal_uInt64 ConstantPool::readUINT64Constant(sal_uInt16 index) const
+{
+    sal_uInt64 aUINT64 = 0;
+
+    if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
+    {
+        if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_UINT64)
+        {
+            aUINT64 = readUINT64(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
+        }
+    }
+
+    return aUINT64;
+}
+
+float ConstantPool::readFloatConstant(sal_uInt16 index) const
+{
+    union
+    {
+        float   v;
+        sal_uInt32  b;
+    } x = { 0.0f };
+
+    if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
+    {
+        if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_FLOAT)
+        {
+#ifdef REGTYPE_IEEE_NATIVE
+            x.b = readUINT32(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
+#else
+#   error no IEEE
+#endif
+        }
+    }
+
+    return  x.v;
+}
+
+double ConstantPool::readDoubleConstant(sal_uInt16 index) const
+{
+    union
+    {
+        double v;
+        struct
+        {
+            sal_uInt32  b1;
+            sal_uInt32  b2;
+        } b;
+    } x = { 0.0 };
+
+    if (m_pIndex && (index> 0) && (index <= m_numOfEntries))
+    {
+        if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_DOUBLE)
+        {
+
+#ifdef REGTYPE_IEEE_NATIVE
+#   ifdef OSL_BIGENDIAN
+            x.b.b1 = readUINT32(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
+            x.b.b2 = readUINT32(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA + sizeof(sal_uInt32));
+#   else
+            x.b.b1 = readUINT32(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA + sizeof(sal_uInt32));
+            x.b.b2 = readUINT32(m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA);
+#   endif
+#else
+#   error no IEEE
+#endif
+        }
+    }
+
+    return x.v;
+}
+
+const sal_Unicode* ConstantPool::readStringConstant(sal_uInt16 index) const
+{
+    const sal_Unicode* aString = NULL_WSTRING;
+
+    if (m_pIndex && (index> 0) && (index <= m_numOfEntries) && m_pStringCache)
+    {
+        if (m_pIndex[index - 1] >= 0)
+        {
+            // create cached string now
+
+            if (readUINT16(m_pIndex[index - 1] + CP_OFFSET_ENTRY_TAG) == CP_TAG_CONST_STRING)
+            {
+                sal_uInt32 n = m_pIndex[index - 1] + CP_OFFSET_ENTRY_DATA;
+                if (n >= m_bufferLen
+                    || (std::memchr(m_pBuffer + n, 0, m_bufferLen - n)
+                        == nullptr))
+                {
+                    throw BoundsError();
+                }
+                m_pIndex[index - 1] = -1 * m_pStringCache->createString(m_pBuffer + n);
+            }
+        }
+
+        aString = m_pStringCache->getString(static_cast<sal_uInt16>(m_pIndex[index - 1] * -1));
+    }
+
+    return aString;
+}
+
+/**************************************************************************
+
+    class FieldList
+
+**************************************************************************/
+
+namespace {
+
+class FieldList : public BlopObject
+{
+public:
+
+    sal_uInt16      m_numOfEntries;
+    size_t          m_FIELD_ENTRY_SIZE;
+    ConstantPool*   m_pCP;
+
+    FieldList(const sal_uInt8* buffer, sal_uInt32 len, sal_uInt16 numEntries, ConstantPool* pCP)
+        : BlopObject(buffer, len)
+        , m_numOfEntries(numEntries)
+        , m_pCP(pCP)
+    {
+        if ( m_numOfEntries > 0 )
+        {
+            sal_uInt16 numOfFieldEntries = readUINT16(0);
+            m_FIELD_ENTRY_SIZE = numOfFieldEntries * sizeof(sal_uInt16);
+        } else
+        {
+            m_FIELD_ENTRY_SIZE = 0;
+        }
+    }
+
+    sal_uInt32 parseIndex() const { return ((m_numOfEntries ? sizeof(sal_uInt16) : 0) + (m_numOfEntries * m_FIELD_ENTRY_SIZE));}
+
+    const char* getFieldName(sal_uInt16 index) const;
+    const char* getFieldType(sal_uInt16 index) const;
+    RTFieldAccess getFieldAccess(sal_uInt16 index) const;
+    RTValueType     getFieldConstValue(sal_uInt16 index, RTConstValueUnion* value) const;
+        // throws std::bad_alloc
+    const char* getFieldDoku(sal_uInt16 index) const;
+    const char* getFieldFileName(sal_uInt16 index) const;
+};
+
+}
+
+const char* FieldList::getFieldName(sal_uInt16 index) const
+{
+    const char* aName = nullptr;
+
+    if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
+    {
+        try {
+            aName = m_pCP->readUTF8NameConstant(readUINT16(sizeof(sal_uInt16) + (index * m_FIELD_ENTRY_SIZE) + FIELD_OFFSET_NAME));
+        } catch (BlopObject::BoundsError &) {
+            SAL_WARN("registry", "bad data");
+        }
+    }
+
+    return aName;
+}
+
+const char* FieldList::getFieldType(sal_uInt16 index) const
+{
+    const char* aName = nullptr;
+
+    if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
+    {
+        try {
+            aName = m_pCP->readUTF8NameConstant(readUINT16(sizeof(sal_uInt16) + (index * m_FIELD_ENTRY_SIZE) + FIELD_OFFSET_TYPE));
+        } catch (BlopObject::BoundsError &) {
+            SAL_WARN("registry", "bad data");
+        }
+    }
+
+    return aName;
+}
+
+RTFieldAccess FieldList::getFieldAccess(sal_uInt16 index) const
+{
+    RTFieldAccess aAccess = RTFieldAccess::INVALID;
+
+    if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
+    {
+        try {
+            aAccess = static_cast<RTFieldAccess>(readUINT16(sizeof(sal_uInt16) + (index * m_FIELD_ENTRY_SIZE) + FIELD_OFFSET_ACCESS));
+        } catch (BlopObject::BoundsError &) {
+            SAL_WARN("registry", "bad data");
+        }
+    }
+
+    return aAccess;
+}
+
+RTValueType FieldList::getFieldConstValue(sal_uInt16 index, RTConstValueUnion* value) const
+{
+    RTValueType ret = RT_TYPE_NONE;
+    try {
+        if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
+        {
+            sal_uInt16 cpIndex = readUINT16(sizeof(sal_uInt16) + (index * m_FIELD_ENTRY_SIZE) + FIELD_OFFSET_VALUE);
+            switch (m_pCP->readTag(cpIndex))
+            {
+            case CP_TAG_CONST_BOOL:
+                value->aBool = m_pCP->readBOOLConstant(cpIndex);
+                ret = RT_TYPE_BOOL;
+                break;
+            case CP_TAG_CONST_BYTE:
+                value->aByte = m_pCP->readBYTEConstant(cpIndex);
+                ret = RT_TYPE_BYTE;
+                break;
+            case CP_TAG_CONST_INT16:
+                value->aShort = m_pCP->readINT16Constant(cpIndex);
+                ret = RT_TYPE_INT16;
+                break;
+            case CP_TAG_CONST_UINT16:
+                value->aUShort = m_pCP->readUINT16Constant(cpIndex);
+                ret = RT_TYPE_UINT16;
+                break;
+            case CP_TAG_CONST_INT32:
+                value->aLong = m_pCP->readINT32Constant(cpIndex);
+                ret = RT_TYPE_INT32;
+                break;
+            case CP_TAG_CONST_UINT32:
+                value->aULong = m_pCP->readUINT32Constant(cpIndex);
+                ret = RT_TYPE_UINT32;
+                break;
+            case CP_TAG_CONST_INT64:
+              value->aHyper = m_pCP->readINT64Constant(cpIndex);
+                ret = RT_TYPE_INT64;
+                break;
+            case CP_TAG_CONST_UINT64:
+              value->aUHyper = m_pCP->readUINT64Constant(cpIndex);
+                ret = RT_TYPE_UINT64;
+                break;
+            case CP_TAG_CONST_FLOAT:
+                value->aFloat = m_pCP->readFloatConstant(cpIndex);
+                ret = RT_TYPE_FLOAT;
+                break;
+            case CP_TAG_CONST_DOUBLE:
+                value->aDouble = m_pCP->readDoubleConstant(cpIndex);
+                ret = RT_TYPE_DOUBLE;
+                break;
+            case CP_TAG_CONST_STRING:
+                value->aString = m_pCP->readStringConstant(cpIndex);
+                ret = RT_TYPE_STRING;
+                break;
+            default:
+                break;
+            }
+        }
+    } catch (BlopObject::BoundsError &) {
+        SAL_WARN("registry", "bad data");
+    }
+    return ret;
+}
+
+const char* FieldList::getFieldDoku(sal_uInt16 index) const
+{
+    const char* aDoku = nullptr;
+
+    if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
+    {
+        try {
+            aDoku = m_pCP->readUTF8NameConstant(readUINT16(sizeof(sal_uInt16) + (index * m_FIELD_ENTRY_SIZE) + FIELD_OFFSET_DOKU));
+        } catch (BlopObject::BoundsError &) {
+            SAL_WARN("registry", "bad data");
+        }
+    }
+
+    return aDoku;
+}
+
+const char* FieldList::getFieldFileName(sal_uInt16 index) const
+{
+    const char* aFileName = nullptr;
+
+    if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
+    {
+        try {
+            aFileName = m_pCP->readUTF8NameConstant(readUINT16(sizeof(sal_uInt16) + (index * m_FIELD_ENTRY_SIZE) + FIELD_OFFSET_FILENAME));
+        } catch (BlopObject::BoundsError &) {
+            SAL_WARN("registry", "bad data");
+        }
+    }
+
+    return aFileName;
+}
+
+/**************************************************************************
+
+    class ReferenceList
+
+**************************************************************************/
+
+namespace {
+
+class ReferenceList : public BlopObject
+{
+public:
+
+    sal_uInt16      m_numOfEntries;
+    size_t          m_REFERENCE_ENTRY_SIZE;
+    ConstantPool*   m_pCP;
+
+    ReferenceList(const sal_uInt8* buffer, sal_uInt32 len, sal_uInt16 numEntries, ConstantPool* pCP)
+        : BlopObject(buffer, len)
+        , m_numOfEntries(numEntries)
+        , m_pCP(pCP)
+    {
+        if ( m_numOfEntries > 0 )
+        {
+            sal_uInt16 numOfReferenceEntries = readUINT16(0);
+            m_REFERENCE_ENTRY_SIZE = numOfReferenceEntries * sizeof(sal_uInt16);
+        } else
+        {
+            m_REFERENCE_ENTRY_SIZE = 0;
+        }
+    }
+
+    const char* getReferenceName(sal_uInt16 index) const;
+    RTReferenceType getReferenceType(sal_uInt16 index) const;
+    const char* getReferenceDoku(sal_uInt16 index) const;
+    RTFieldAccess   getReferenceAccess(sal_uInt16 index) const;
+};
+
+}
+
+const char* ReferenceList::getReferenceName(sal_uInt16 index) const
+{
+    const char* aName = nullptr;
+
+    if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
+    {
+        try {
+            aName = m_pCP->readUTF8NameConstant(readUINT16(sizeof(sal_uInt16) + (index * m_REFERENCE_ENTRY_SIZE) + REFERENCE_OFFSET_NAME));
+        } catch (BlopObject::BoundsError &) {
+            SAL_WARN("registry", "bad data");
+        }
+    }
+
+    return aName;
+}
+
+RTReferenceType ReferenceList::getReferenceType(sal_uInt16 index) const
+{
+    RTReferenceType refType = RTReferenceType::INVALID;
+
+    if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
+    {
+        try {
+            refType = static_cast<RTReferenceType>(readUINT16(sizeof(sal_uInt16) + (index * m_REFERENCE_ENTRY_SIZE) + REFERENCE_OFFSET_TYPE));
+        } catch (BlopObject::BoundsError &) {
+            SAL_WARN("registry", "bad data");
+        }
+    }
+
+    return refType;
+}
+
+const char* ReferenceList::getReferenceDoku(sal_uInt16 index) const
+{
+    const char* aDoku = nullptr;
+
+    if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
+    {
+        try {
+            aDoku = m_pCP->readUTF8NameConstant(readUINT16(sizeof(sal_uInt16) + (index * m_REFERENCE_ENTRY_SIZE) + REFERENCE_OFFSET_DOKU));
+        } catch (BlopObject::BoundsError &) {
+            SAL_WARN("registry", "bad data");
+        }
+    }
+
+    return aDoku;
+}
+
+RTFieldAccess ReferenceList::getReferenceAccess(sal_uInt16 index) const
+{
+    RTFieldAccess aAccess = RTFieldAccess::INVALID;
+
+    if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
+    {
+        try {
+            aAccess = static_cast<RTFieldAccess>(readUINT16(sizeof(sal_uInt16) + (index * m_REFERENCE_ENTRY_SIZE) + REFERENCE_OFFSET_ACCESS));
+        } catch (BlopObject::BoundsError &) {
+            SAL_WARN("registry", "bad data");
+        }
+    }
+
+    return aAccess;
+}
+
+/**************************************************************************
+
+    class MethodList
+
+**************************************************************************/
+
+namespace {
+
+class MethodList : public BlopObject
+{
+public:
+
+    sal_uInt16      m_numOfEntries;
+    size_t          m_PARAM_ENTRY_SIZE;
+    std::unique_ptr<sal_uInt32[]>  m_pIndex;
+    ConstantPool*   m_pCP;
+
+    MethodList(const sal_uInt8* buffer, sal_uInt32 len, sal_uInt16 numEntries, ConstantPool* pCP)
+        : BlopObject(buffer, len)
+        , m_numOfEntries(numEntries)
+        , m_pCP(pCP)
+    {
+        if ( m_numOfEntries > 0 )
+        {
+            readUINT16(0) /* numOfMethodEntries */;
+            sal_uInt16 numOfParamEntries = readUINT16(sizeof(sal_uInt16));
+            m_PARAM_ENTRY_SIZE = numOfParamEntries * sizeof(sal_uInt16);
+        } else
+        {
+            m_PARAM_ENTRY_SIZE = 0;
+        }
+    }
+
+    sal_uInt32 parseIndex(); // throws std::bad_alloc
+
+    const char* getMethodName(sal_uInt16 index) const;
+    sal_uInt16      getMethodParamCount(sal_uInt16 index) const;
+    const char* getMethodParamType(sal_uInt16 index, sal_uInt16 paramIndex) const;
+    const char* getMethodParamName(sal_uInt16 index, sal_uInt16 paramIndex) const;
+    RTParamMode     getMethodParamMode(sal_uInt16 index, sal_uInt16 paramIndex) const;
+    sal_uInt16      getMethodExcCount(sal_uInt16 index) const;
+    const char* getMethodExcType(sal_uInt16 index, sal_uInt16 excIndex) const;
+    const char* getMethodReturnType(sal_uInt16 index) const;
+    RTMethodMode    getMethodMode(sal_uInt16 index) const;
+    const char* getMethodDoku(sal_uInt16 index) const;
+
+private:
+    sal_uInt16 calcMethodParamIndex( const sal_uInt16 index ) const;
+};
+
+}
+
+sal_uInt16 MethodList::calcMethodParamIndex( const sal_uInt16 index ) const
+{
+    return (METHOD_OFFSET_PARAM_COUNT + sizeof(sal_uInt16) + (index * m_PARAM_ENTRY_SIZE));
+}
+
+sal_uInt32 MethodList::parseIndex()
+{
+    m_pIndex.reset();
+
+    sal_uInt32 offset = 0;
+
+    if (m_numOfEntries)
+    {
+        offset = 2 * sizeof(sal_uInt16);
+        m_pIndex.reset( new sal_uInt32[m_numOfEntries] );
+
+        for (int i = 0; i < m_numOfEntries; i++)
+        {
+            m_pIndex[i] = offset;
+
+            offset += readUINT16(offset);
+        }
+    }
+
+    return offset;
+}
+
+const char* MethodList::getMethodName(sal_uInt16 index) const
+{
+    const char* aName = nullptr;
+
+    if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
+    {
+        try {
+            aName = m_pCP->readUTF8NameConstant(readUINT16(m_pIndex[index] + METHOD_OFFSET_NAME));
+        } catch (BlopObject::BoundsError &) {
+            SAL_WARN("registry", "bad data");
+        }
+    }
+
+    return aName;
+}
+
+sal_uInt16 MethodList::getMethodParamCount(sal_uInt16 index) const
+{
+    sal_uInt16 aCount = 0;
+
+    if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
+    {
+        try {
+            aCount = readUINT16(m_pIndex[index] + METHOD_OFFSET_PARAM_COUNT);
+        } catch (BlopObject::BoundsError &) {
+            SAL_WARN("registry", "bad data");
+        }
+    }
+
+    return aCount;
+}
+
+const char* MethodList::getMethodParamType(sal_uInt16 index, sal_uInt16 paramIndex) const
+{
+    const char* aName = nullptr;
+    try {
+        if ((m_numOfEntries > 0) &&
+            (index <= m_numOfEntries) &&
+            (paramIndex <= readUINT16(m_pIndex[index] + METHOD_OFFSET_PARAM_COUNT)))
+        {
+            aName = m_pCP->readUTF8NameConstant(
+                readUINT16(
+                    m_pIndex[index] +
+                    calcMethodParamIndex(paramIndex) +
+                    PARAM_OFFSET_TYPE));
+        }
+    } catch (BlopObject::BoundsError &) {
+        SAL_WARN("registry", "bad data");
+    }
+    return aName;
+}
+
+const char* MethodList::getMethodParamName(sal_uInt16 index, sal_uInt16 paramIndex) const
+{
+    const char* aName = nullptr;
+    try {
+        if ((m_numOfEntries > 0) &&
+            (index <= m_numOfEntries) &&
+            (paramIndex <= readUINT16(m_pIndex[index] + METHOD_OFFSET_PARAM_COUNT)))
+        {
+            aName = m_pCP->readUTF8NameConstant(
+                readUINT16(
+                    m_pIndex[index] +
+                    calcMethodParamIndex(paramIndex) +
+                    PARAM_OFFSET_NAME));
+        }
+    } catch (BlopObject::BoundsError &) {
+        SAL_WARN("registry", "bad data");
+    }
+    return aName;
+}
+
+RTParamMode MethodList::getMethodParamMode(sal_uInt16 index, sal_uInt16 paramIndex) const
+{
+    RTParamMode aMode = RT_PARAM_INVALID;
+    try {
+        if ((m_numOfEntries > 0) &&
+            (index <= m_numOfEntries) &&
+            (paramIndex <= readUINT16(m_pIndex[index] + METHOD_OFFSET_PARAM_COUNT)))
+        {
+            aMode = static_cast<RTParamMode>(readUINT16(
+                m_pIndex[index] +
+                calcMethodParamIndex(paramIndex) +
+                PARAM_OFFSET_MODE));
+        }
+    } catch (BlopObject::BoundsError &) {
+        SAL_WARN("registry", "bad data");
+    }
+    return aMode;
+}
+
+#if defined(__COVERITY__)
+extern "C" void __coverity_tainted_data_sanitize__(void *);
+#endif
+
+sal_uInt16 MethodList::getMethodExcCount(sal_uInt16 index) const
+{
+    sal_uInt16 aCount = 0;
+
+    if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
+    {
+        try {
+            aCount = readUINT16(m_pIndex[index] + calcMethodParamIndex(readUINT16(m_pIndex[index] + METHOD_OFFSET_PARAM_COUNT)));
+#if defined(__COVERITY__)
+            __coverity_tainted_data_sanitize__(&aCount);
+#endif
+        } catch (BlopObject::BoundsError &) {
+            SAL_WARN("registry", "bad data");
+        }
+    }
+
+    return aCount;
+}
+
+const char* MethodList::getMethodExcType(sal_uInt16 index, sal_uInt16 excIndex) const
+{
+    const char* aName = nullptr;
+
+    if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
+    {
+        try {
+            sal_uInt32 excOffset = m_pIndex[index] + calcMethodParamIndex(readUINT16(m_pIndex[index] + METHOD_OFFSET_PARAM_COUNT));
+            if (excIndex <= readUINT16(excOffset))
+            {
+                aName = m_pCP->readUTF8NameConstant(
+                    readUINT16(
+                        excOffset +
+                        sizeof(sal_uInt16) +
+                        (excIndex * sizeof(sal_uInt16))));
+            }
+        } catch (BlopObject::BoundsError &) {
+            SAL_WARN("registry", "bad data");
+        }
+    }
+
+    return aName;
+}
+
+const char* MethodList::getMethodReturnType(sal_uInt16 index) const
+{
+    const char* aName = nullptr;
+
+    if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
+    {
+        try {
+            aName = m_pCP->readUTF8NameConstant(readUINT16(m_pIndex[index] + METHOD_OFFSET_RETURN));
+        } catch (BlopObject::BoundsError &) {
+            SAL_WARN("registry", "bad data");
+        }
+    }
+
+    return aName;
+}
+
+RTMethodMode MethodList::getMethodMode(sal_uInt16 index) const
+{
+    RTMethodMode aMode = RTMethodMode::INVALID;
+
+    if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
+    {
+        try {
+            aMode = static_cast<RTMethodMode>(readUINT16(m_pIndex[index] + METHOD_OFFSET_MODE));
+        } catch (BlopObject::BoundsError &) {
+            SAL_WARN("registry", "bad data");
+        }
+    }
+
+    return aMode;
+}
+
+const char* MethodList::getMethodDoku(sal_uInt16 index) const
+{
+    const char* aDoku = nullptr;
+
+    if ((m_numOfEntries > 0) && (index <= m_numOfEntries))
+    {
+        try {
+            aDoku = m_pCP->readUTF8NameConstant(readUINT16(m_pIndex[index] + METHOD_OFFSET_DOKU));
+        } catch (BlopObject::BoundsError &) {
+            SAL_WARN("registry", "bad data");
+        }
+    }
+
+    return aDoku;
+}
+
+/**************************************************************************
+
+    class TypeRegistryEntry
+
+**************************************************************************/
+
+namespace {
+
+class TypeRegistryEntry: public BlopObject {
+public:
+    std::unique_ptr<ConstantPool> m_pCP;
+    std::unique_ptr<FieldList> m_pFields;
+    std::unique_ptr<MethodList> m_pMethods;
+    std::unique_ptr<ReferenceList> m_pReferences;
+    sal_uInt32      m_refCount;
+    sal_uInt16      m_nSuperTypes;
+    sal_uInt32      m_offset_SUPERTYPES;
+
+    TypeRegistryEntry(
+        const sal_uInt8* buffer, sal_uInt32 len);
+        // throws std::bad_alloc
+
+    typereg_Version getVersion() const;
+};
+
+}
+
+TypeRegistryEntry::TypeRegistryEntry(
+    const sal_uInt8* buffer, sal_uInt32 len):
+    BlopObject(buffer, len), m_refCount(1), m_nSuperTypes(0),
+    m_offset_SUPERTYPES(0)
+{
+    std::size_t const entrySize = sizeof(sal_uInt16);
+    sal_uInt16 nHeaderEntries = readUINT16(OFFSET_N_ENTRIES);
+    sal_uInt32 offset_N_SUPERTYPES = OFFSET_N_ENTRIES + entrySize + (nHeaderEntries * entrySize); // cannot overflow
+    m_offset_SUPERTYPES = offset_N_SUPERTYPES + entrySize; // cannot overflow
+    m_nSuperTypes = readUINT16(offset_N_SUPERTYPES);
+
+    sal_uInt32 offset_CP_SIZE = m_offset_SUPERTYPES + (m_nSuperTypes * entrySize); // cannot overflow
+    sal_uInt32 offset_CP = offset_CP_SIZE + entrySize; // cannot overflow
+
+    if (offset_CP > m_bufferLen) {
+        throw BoundsError();
+    }
+    m_pCP.reset(
+        new ConstantPool(
+            m_pBuffer + offset_CP, m_bufferLen - offset_CP,
+            readUINT16(offset_CP_SIZE)));
+
+    sal_uInt32 offset = offset_CP + m_pCP->parseIndex(); //TODO: overflow
+
+    assert(m_bufferLen >= entrySize);
+    if (offset > m_bufferLen - entrySize) {
+        throw BoundsError();
+    }
+    m_pFields.reset(
+        new FieldList(
+            m_pBuffer + offset + entrySize, m_bufferLen - (offset + entrySize),
+            readUINT16(offset), m_pCP.get()));
+
+    offset += sizeof(sal_uInt16) + m_pFields->parseIndex(); //TODO: overflow
+
+    assert(m_bufferLen >= entrySize);
+    if (offset > m_bufferLen - entrySize) {
+        throw BoundsError();
+    }
+    m_pMethods.reset(
+        new MethodList(
+            m_pBuffer + offset + entrySize, m_bufferLen - (offset + entrySize),
+            readUINT16(offset), m_pCP.get()));
+
+    offset += sizeof(sal_uInt16) + m_pMethods->parseIndex(); //TODO: overflow
+
+    assert(m_bufferLen >= entrySize);
+    if (offset > m_bufferLen - entrySize) {
+        throw BoundsError();
+    }
+    m_pReferences.reset(
+        new ReferenceList(
+            m_pBuffer + offset + entrySize, m_bufferLen - (offset + entrySize),
+            readUINT16(offset), m_pCP.get()));
+}
+
+typereg_Version TypeRegistryEntry::getVersion() const {
+    // Assumes two's complement arithmetic with modulo-semantics:
+    return static_cast< typereg_Version >(readUINT32(OFFSET_MAGIC) - magic);
+}
+
+/**************************************************************************
+
+    C-API
+
+**************************************************************************/
+
+bool TYPEREG_CALLTYPE typereg_reader_create(
+    void const * buffer, sal_uInt32 length,
+    void ** result)
+{
+    if (length < OFFSET_CP || length > SAL_MAX_UINT32) {
+        *result = nullptr;
+        return true;
+    }
+    std::unique_ptr< TypeRegistryEntry > entry;
+    try {
+        try {
+            entry.reset(
+                new TypeRegistryEntry(
+                    static_cast< sal_uInt8 const * >(buffer), length));
+        } catch (std::bad_alloc &) {
+            return false;
+        }
+        if (entry->readUINT32(OFFSET_SIZE) != length) {
+            *result = nullptr;
+            return true;
+        }
+        typereg_Version version = entry->getVersion();
+        if (version < TYPEREG_VERSION_0 || version > TYPEREG_VERSION_1) {
+            *result = nullptr;
+            return true;
+        }
+        *result = entry.release();
+        return true;
+    } catch (BlopObject::BoundsError &) {
+        SAL_WARN("registry", "bad data");
+        return false;
+    }
+}
+
+static TypeReaderImpl TYPEREG_CALLTYPE createEntry(const sal_uInt8* buffer, sal_uInt32 len)
+{
+    void * handle;
+    typereg_reader_create(buffer, len, &handle);
+    return handle;
+}
+
+void TYPEREG_CALLTYPE typereg_reader_acquire(void * hEntry)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+
+    if (pEntry != nullptr)
+        pEntry->m_refCount++;
+}
+
+void TYPEREG_CALLTYPE typereg_reader_release(void * hEntry)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+
+    if (pEntry != nullptr)
+    {
+        if (--pEntry->m_refCount == 0)
+            delete pEntry;
+    }
+}
+
+typereg_Version TYPEREG_CALLTYPE typereg_reader_getVersion(void const * handle) {
+    if (handle != nullptr) {
+        try {
+            return static_cast< TypeRegistryEntry const * >(handle)->getVersion();
+        } catch (BlopObject::BoundsError &) {
+            SAL_WARN("registry", "bad data");
+        }
+    }
+    return TYPEREG_VERSION_0;
+}
+
+RTTypeClass TYPEREG_CALLTYPE typereg_reader_getTypeClass(void * hEntry)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+    if (pEntry != nullptr) {
+        try {
+            return static_cast<RTTypeClass>(pEntry->readUINT16(OFFSET_TYPE_CLASS) & ~RT_TYPE_PUBLISHED);
+        } catch (BlopObject::BoundsError &) {
+            SAL_WARN("registry", "bad data");
+        }
+    }
+    return RT_TYPE_INVALID;
+}
+
+bool TYPEREG_CALLTYPE typereg_reader_isPublished(void * hEntry)
+{
+    TypeRegistryEntry * entry = static_cast< TypeRegistryEntry * >(hEntry);
+    if (entry != nullptr) {
+        try {
+            return (entry->readUINT16(OFFSET_TYPE_CLASS) & RT_TYPE_PUBLISHED) != 0;
+        } catch (BlopObject::BoundsError &) {
+            SAL_WARN("registry", "bad data");
+        }
+    }
+    return false;
+}
+
+void TYPEREG_CALLTYPE typereg_reader_getTypeName(void * hEntry, rtl_uString** pTypeName)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+    if (pEntry != nullptr) {
+        try {
+            const char* pTmp = pEntry->m_pCP->readUTF8NameConstant(pEntry->readUINT16(OFFSET_THIS_TYPE));
+            rtl_string2UString(
+                pTypeName, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp),
+                RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
+            return;
+        } catch (BlopObject::BoundsError &) {
+            SAL_WARN("registry", "bad data");
+        }
+    }
+    rtl_uString_new(pTypeName);
+}
+
+
+static void TYPEREG_CALLTYPE getSuperTypeName(TypeReaderImpl hEntry, rtl_uString** pSuperTypeName)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+    if (pEntry != nullptr && pEntry->m_nSuperTypes != 0) {
+        try {
+            const char* pTmp = pEntry->m_pCP->readUTF8NameConstant(pEntry->readUINT16(pEntry->m_offset_SUPERTYPES )); //+ (index * sizeof(sal_uInt16))));
+            rtl_string2UString(
+                pSuperTypeName, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp),
+                RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
+            return;
+        } catch (BlopObject::BoundsError &) {
+            SAL_WARN("registry", "bad data");
+        }
+    }
+    rtl_uString_new(pSuperTypeName);
+}
+
+void TYPEREG_CALLTYPE typereg_reader_getDocumentation(void * hEntry, rtl_uString** pDoku)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+    if (pEntry != nullptr) {
+        try {
+            const char* pTmp = pEntry->m_pCP->readUTF8NameConstant(pEntry->readUINT16(OFFSET_DOKU));
+            rtl_string2UString(
+                pDoku, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp),
+                RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
+            return;
+        } catch (BlopObject::BoundsError &) {
+            SAL_WARN("registry", "bad data");
+        }
+    }
+    rtl_uString_new(pDoku);
+}
+
+void TYPEREG_CALLTYPE typereg_reader_getFileName(void * hEntry, rtl_uString** pFileName)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+    if (pEntry != nullptr) {
+        try {
+            const char* pTmp = pEntry->m_pCP->readUTF8NameConstant(pEntry->readUINT16(OFFSET_FILENAME));
+            rtl_string2UString(
+                pFileName, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp),
+                RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
+            return;
+        } catch (BlopObject::BoundsError &) {
+            SAL_WARN("registry", "bad data");
+        }
+    }
+    rtl_uString_new(pFileName);
+}
+
+
+sal_uInt16 TYPEREG_CALLTYPE typereg_reader_getFieldCount(void * hEntry)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+
+    if (pEntry == nullptr) return 0;
+
+    return pEntry->m_pFields->m_numOfEntries;
+}
+
+static sal_uInt32 TYPEREG_CALLTYPE getFieldCount(TypeReaderImpl hEntry)
+{
+    return typereg_reader_getFieldCount(hEntry);
+}
+
+void TYPEREG_CALLTYPE typereg_reader_getFieldName(void * hEntry, rtl_uString** pFieldName, sal_uInt16 index)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+
+    if (pEntry == nullptr)
+    {
+        rtl_uString_new(pFieldName);
+        return;
+    }
+    const char* pTmp = pEntry->m_pFields->getFieldName(index);
+    rtl_string2UString(
+        pFieldName, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp),
+        RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
+}
+
+void TYPEREG_CALLTYPE typereg_reader_getFieldTypeName(void * hEntry, rtl_uString** pFieldType, sal_uInt16 index)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+
+    if (pEntry == nullptr)
+    {
+        rtl_uString_new(pFieldType);
+        return;
+    }
+
+    const char* pTmp = pEntry->m_pFields->getFieldType(index);
+    rtl_string2UString(
+        pFieldType, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp),
+        RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
+}
+
+RTFieldAccess TYPEREG_CALLTYPE typereg_reader_getFieldFlags(void * hEntry, sal_uInt16 index)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+
+    if (pEntry == nullptr) return RTFieldAccess::INVALID;
+
+    return pEntry->m_pFields->getFieldAccess(index);
+}
+
+bool TYPEREG_CALLTYPE typereg_reader_getFieldValue(
+    void * hEntry, sal_uInt16 index, RTValueType * type,
+    RTConstValueUnion * value)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+
+    if (pEntry == nullptr) {
+        *type = RT_TYPE_NONE;
+        return true;
+    }
+
+    try {
+        *type = pEntry->m_pFields->getFieldConstValue(index, value);
+    } catch (std::bad_alloc &) {
+        return false;
+    }
+    return true;
+}
+
+static RTValueType TYPEREG_CALLTYPE getFieldConstValue(TypeReaderImpl hEntry, sal_uInt16 index, RTConstValueUnion* value)
+{
+    RTValueType t = RT_TYPE_NONE;
+    typereg_reader_getFieldValue(hEntry, index, &t, value);
+    return t;
+}
+
+void TYPEREG_CALLTYPE typereg_reader_getFieldDocumentation(void * hEntry, rtl_uString** pDoku, sal_uInt16 index)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+
+    if (pEntry == nullptr)
+    {
+        rtl_uString_new(pDoku);
+        return;
+    }
+
+    const char* pTmp = pEntry->m_pFields->getFieldDoku(index);
+    rtl_string2UString(
+        pDoku, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp),
+        RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
+}
+
+void TYPEREG_CALLTYPE typereg_reader_getFieldFileName(void * hEntry, rtl_uString** pFieldFileName, sal_uInt16 index)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+
+    if (pEntry == nullptr)
+    {
+        rtl_uString_new(pFieldFileName);
+        return;
+    }
+
+    const char* pTmp = pEntry->m_pFields->getFieldFileName(index);
+    rtl_string2UString(
+        pFieldFileName, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp),
+        RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
+}
+
+
+sal_uInt16 TYPEREG_CALLTYPE typereg_reader_getMethodCount(void * hEntry)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+
+    if (pEntry == nullptr) return 0;
+
+    return pEntry->m_pMethods->m_numOfEntries;
+}
+
+void TYPEREG_CALLTYPE typereg_reader_getMethodName(void * hEntry, rtl_uString** pMethodName, sal_uInt16 index)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+
+    if (pEntry == nullptr)
+    {
+        rtl_uString_new(pMethodName);
+        return;
+    }
+
+    const char* pTmp = pEntry->m_pMethods->getMethodName(index);
+    rtl_string2UString(
+        pMethodName, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp),
+        RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
+}
+
+sal_uInt16 TYPEREG_CALLTYPE typereg_reader_getMethodParameterCount(
+    void * hEntry, sal_uInt16 index)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+
+    if (pEntry == nullptr) return 0;
+
+    return pEntry->m_pMethods->getMethodParamCount(index);
+}
+
+void TYPEREG_CALLTYPE typereg_reader_getMethodParameterTypeName(void * hEntry, rtl_uString** pMethodParamType, sal_uInt16 index, sal_uInt16 paramIndex)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+
+    if (pEntry == nullptr)
+    {
+        rtl_uString_new(pMethodParamType);
+        return;
+    }
+
+    const char* pTmp = pEntry->m_pMethods->getMethodParamType(index, paramIndex);
+    rtl_string2UString(
+        pMethodParamType, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp),
+        RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
+}
+
+void TYPEREG_CALLTYPE typereg_reader_getMethodParameterName(void * hEntry, rtl_uString** pMethodParamName, sal_uInt16 index, sal_uInt16 paramIndex)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+
+    if (pEntry == nullptr)
+    {
+        rtl_uString_new(pMethodParamName);
+        return;
+    }
+
+    const char* pTmp = pEntry->m_pMethods->getMethodParamName(index, paramIndex);
+    rtl_string2UString(
+        pMethodParamName, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp),
+        RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
+}
+
+RTParamMode TYPEREG_CALLTYPE typereg_reader_getMethodParameterFlags(void * hEntry, sal_uInt16 index, sal_uInt16 paramIndex)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+
+    if (pEntry == nullptr) return RT_PARAM_INVALID;
+
+    return pEntry->m_pMethods->getMethodParamMode(index, paramIndex);
+}
+
+sal_uInt16 TYPEREG_CALLTYPE typereg_reader_getMethodExceptionCount(
+    void * hEntry, sal_uInt16 index)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+
+    if (pEntry == nullptr) return 0;
+
+    return pEntry->m_pMethods->getMethodExcCount(index);
+}
+
+void TYPEREG_CALLTYPE typereg_reader_getMethodExceptionTypeName(void * hEntry, rtl_uString** pMethodExcpType, sal_uInt16 index, sal_uInt16 excIndex)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+
+    if (pEntry == nullptr)
+    {
+        rtl_uString_new(pMethodExcpType);
+        return;
+    }
+
+    const char* pTmp = pEntry->m_pMethods->getMethodExcType(index, excIndex);
+    rtl_string2UString(
+        pMethodExcpType, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp),
+        RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
+}
+
+void TYPEREG_CALLTYPE typereg_reader_getMethodReturnTypeName(void * hEntry, rtl_uString** pMethodReturnType, sal_uInt16 index)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+
+    if (pEntry == nullptr)
+    {
+        rtl_uString_new(pMethodReturnType);
+        return;
+    }
+
+    const char* pTmp = pEntry->m_pMethods->getMethodReturnType(index);
+    rtl_string2UString(
+        pMethodReturnType, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp),
+        RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
+}
+
+RTMethodMode TYPEREG_CALLTYPE typereg_reader_getMethodFlags(void * hEntry, sal_uInt16 index)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+
+    if (pEntry == nullptr) return RTMethodMode::INVALID;
+
+    return pEntry->m_pMethods->getMethodMode(index);
+}
+
+void TYPEREG_CALLTYPE typereg_reader_getMethodDocumentation(void * hEntry, rtl_uString** pMethodDoku, sal_uInt16 index)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+
+    if (pEntry == nullptr)
+    {
+        rtl_uString_new(pMethodDoku);
+        return;
+    }
+
+    const char* pTmp = pEntry->m_pMethods->getMethodDoku(index);
+    rtl_string2UString(
+        pMethodDoku, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp),
+        RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
+}
+
+sal_uInt16 TYPEREG_CALLTYPE typereg_reader_getReferenceCount(void * hEntry)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+
+    if (pEntry == nullptr) return 0;
+
+    return pEntry->m_pReferences->m_numOfEntries;
+}
+
+void TYPEREG_CALLTYPE typereg_reader_getReferenceTypeName(void * hEntry, rtl_uString** pReferenceName, sal_uInt16 index)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+
+    if (pEntry == nullptr)
+    {
+        rtl_uString_new(pReferenceName);
+        return;
+    }
+
+    const char* pTmp = pEntry->m_pReferences->getReferenceName(index);
+    rtl_string2UString(
+        pReferenceName, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp),
+        RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
+}
+
+RTReferenceType TYPEREG_CALLTYPE typereg_reader_getReferenceSort(void * hEntry, sal_uInt16 index)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+
+    if (pEntry == nullptr) return RTReferenceType::INVALID;
+
+    return pEntry->m_pReferences->getReferenceType(index);
+}
+
+void TYPEREG_CALLTYPE typereg_reader_getReferenceDocumentation(void * hEntry, rtl_uString** pReferenceDoku, sal_uInt16 index)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+
+    if (pEntry == nullptr)
+    {
+        rtl_uString_new(pReferenceDoku);
+        return;
+    }
+
+    const char* pTmp = pEntry->m_pReferences->getReferenceDoku(index);
+    rtl_string2UString(
+        pReferenceDoku, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp),
+        RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
+}
+
+RTFieldAccess TYPEREG_CALLTYPE typereg_reader_getReferenceFlags(void * hEntry, sal_uInt16 index)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+
+    if (pEntry == nullptr) return RTFieldAccess::INVALID;
+
+    return pEntry->m_pReferences->getReferenceAccess(index);
+}
+
+sal_uInt16 TYPEREG_CALLTYPE typereg_reader_getSuperTypeCount(void * hEntry)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+
+    if (pEntry == nullptr) return 0;
+
+    return pEntry->m_nSuperTypes;
+}
+
+void TYPEREG_CALLTYPE typereg_reader_getSuperTypeName(
+    void * hEntry, rtl_uString ** pSuperTypeName, sal_uInt16 index)
+{
+    TypeRegistryEntry* pEntry = static_cast<TypeRegistryEntry*>(hEntry);
+    if (pEntry != nullptr) {
+        try {
+            OSL_ASSERT(index < pEntry->m_nSuperTypes);
+            const char* pTmp = pEntry->m_pCP->readUTF8NameConstant(pEntry->readUINT16(pEntry->m_offset_SUPERTYPES + (index * sizeof(sal_uInt16))));
+            rtl_string2UString(
+                pSuperTypeName, pTmp, pTmp == nullptr ? 0 : rtl_str_getLength(pTmp),
+                RTL_TEXTENCODING_UTF8, OSTRING_TO_OUSTRING_CVTFLAGS);
+            return;
+        } catch (BlopObject::BoundsError &) {
+            SAL_WARN("registry", "bad data");
+        }
+    }
+    rtl_uString_new(pSuperTypeName);
+}
+
+RegistryTypeReader::RegistryTypeReader(const sal_uInt8* buffer,
+                                              sal_uInt32 bufferLen)
+    : m_hImpl(nullptr)
+{
+    m_hImpl = createEntry(buffer, bufferLen);
+}
+
+RegistryTypeReader::~RegistryTypeReader()
+{ typereg_reader_release(m_hImpl); }
+
+RTTypeClass RegistryTypeReader::getTypeClass() const
+{  return typereg_reader_getTypeClass(m_hImpl); }
+
+OUString RegistryTypeReader::getTypeName() const
+{
+    OUString sRet;
+    typereg_reader_getTypeName(m_hImpl, &sRet.pData);
+    return sRet;
+}
+
+OUString RegistryTypeReader::getSuperTypeName() const
+{
+    OUString sRet;
+    ::getSuperTypeName(m_hImpl, &sRet.pData);
+    return sRet;
+}
+
+sal_uInt32 RegistryTypeReader::getFieldCount() const
+{   return ::getFieldCount(m_hImpl); }
+
+OUString RegistryTypeReader::getFieldName( sal_uInt16 index ) const
+{
+    OUString sRet;
+    typereg_reader_getFieldName(m_hImpl, &sRet.pData, index);
+    return sRet;
+}
+
+OUString RegistryTypeReader::getFieldType( sal_uInt16 index ) const
+{
+    OUString sRet;
+    typereg_reader_getFieldTypeName(m_hImpl, &sRet.pData, index);
+    return sRet;
+}
+
+RTFieldAccess RegistryTypeReader::getFieldAccess( sal_uInt16 index ) const
+{  return typereg_reader_getFieldFlags(m_hImpl, index); }
+
+RTConstValue RegistryTypeReader::getFieldConstValue( sal_uInt16 index ) const
+{
+    RTConstValue ret;
+    ret.m_type = ::getFieldConstValue(m_hImpl, index, &ret.m_value);
+    return ret;
+}
+
+OUString RegistryTypeReader::getFieldDoku( sal_uInt16 index ) const
+{
+    OUString sRet;
+    typereg_reader_getFieldDocumentation(m_hImpl, &sRet.pData, index);
+    return sRet;
+}
+
+OUString RegistryTypeReader::getFieldFileName( sal_uInt16 index ) const
+{
+    OUString sRet;
+    typereg_reader_getFieldFileName(m_hImpl, &sRet.pData, index);
+    return sRet;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/registry/source/reflread.hxx b/registry/source/reflread.hxx
new file mode 100644
index 000000000..5fc428212
--- /dev/null
+++ b/registry/source/reflread.hxx
@@ -0,0 +1,114 @@
+/* -*- 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_REGISTRY_SOURCE_REFLREAD_HXX
+#define INCLUDED_REGISTRY_SOURCE_REFLREAD_HXX
+
+#include <registry/refltype.hxx>
+#include <rtl/ustring.hxx>
+
+/// Implementation handle
+typedef void* TypeReaderImpl;
+
+/** RegistryTypeReades reads a binary type blob.
+
+    This class provides the necessary functions to read type information
+    for all kinds of types of a type blob.
+
+    @deprecated
+    use typereg::Reader instead
+*/
+class RegistryTypeReader
+{
+public:
+
+    /** Constructor.
+
+        @param buffer points to the binary data block.
+        @param bufferLen specifies the size of the binary data block.
+     */
+    RegistryTypeReader(const sal_uInt8* buffer,
+                              sal_uInt32 bufferLen);
+
+    /// Destructor. The Destructor frees the data block if the copyData flag was TRUE.
+    ~RegistryTypeReader();
+
+    /** returns the typeclass of the type represented by this blob.
+
+        This function will always return the type class without the internal
+        RT_TYPE_PUBLISHED flag set.
+     */
+    RTTypeClass      getTypeClass() const;
+
+    /** returns the full qualified name of the type.
+     */
+    OUString  getTypeName() const;
+
+    /** returns the full qualified name of the supertype.
+     */
+    OUString  getSuperTypeName() const;
+
+    /** returns the number of fields (attributes/properties, enum values or number
+        of constants in a module).
+
+     */
+    sal_uInt32       getFieldCount() const;
+
+    /** returns the name of the field specified by index.
+     */
+    OUString  getFieldName( sal_uInt16 index ) const;
+
+    /** returns the full qualified name of the field specified by index.
+     */
+    OUString  getFieldType( sal_uInt16 index ) const;
+
+    /** returns the access mode of the field specified by index.
+     */
+    RTFieldAccess    getFieldAccess( sal_uInt16 index ) const;
+
+    /** returns the value of the field specified by index.
+
+        This function returns the value of an enum value or of a constant.
+     */
+    RTConstValue     getFieldConstValue( sal_uInt16 index ) const;
+
+    /** returns the documentation string for the field specified by index.
+
+        Each field of a type can have their own documentation.
+     */
+    OUString  getFieldDoku( sal_uInt16 index ) const;
+
+    /** returns the IDL filename of the field specified by index.
+
+        The IDL filename of a field can differ from the filename of the ype itself
+        because modules and also constants can be defined in different IDL files.
+     */
+    OUString  getFieldFileName( sal_uInt16 index ) const;
+
+private:
+    RegistryTypeReader(RegistryTypeReader const &) = delete;
+    void operator =(RegistryTypeReader const &) = delete;
+
+    /// stores the handle of an implementation class
+    TypeReaderImpl                                              m_hImpl;
+};
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/registry/source/reflwrit.cxx b/registry/source/reflwrit.cxx
new file mode 100644
index 000000000..8f8e83318
--- /dev/null
+++ b/registry/source/reflwrit.cxx
@@ -0,0 +1,1336 @@
+/* -*- 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 <new>
+#include <memory>
+#include <algorithm>
+#include <sal/types.h>
+#include <osl/endian.h>
+#include <rtl/string.hxx>
+#include <rtl/ustring.hxx>
+
+#include "reflwrit.hxx"
+#include <registry/refltype.hxx>
+#include <registry/version.h>
+#include <registry/writer.h>
+
+#include "reflcnst.hxx"
+
+
+namespace {
+
+OString toByteString(rtl_uString const * str) {
+    return OString(
+        str->buffer, str->length, RTL_TEXTENCODING_UTF8,
+        OUSTRING_TO_OSTRING_CVTFLAGS);
+}
+
+}
+
+const sal_Unicode NULL_WSTRING[1] = { 0 };
+
+#define BLOP_OFFSET_MAGIC       0
+#define BLOP_OFFSET_SIZE        (BLOP_OFFSET_MAGIC + sizeof(sal_uInt32))
+#define BLOP_OFFSET_MINOR       (BLOP_OFFSET_SIZE + sizeof(sal_uInt32))
+#define BLOP_OFFSET_MAJOR       (BLOP_OFFSET_MINOR + sizeof(sal_uInt16))
+#define BLOP_OFFSET_N_ENTRIES   (BLOP_OFFSET_MAJOR + sizeof(sal_uInt16))
+#define BLOP_HEADER_N_ENTRIES   6
+
+#define BLOP_FIELD_N_ENTRIES        6
+
+#define BLOP_METHOD_N_ENTRIES   5
+
+#define BLOP_PARAM_N_ENTRIES    3
+
+#define BLOP_REFERENCE_N_ENTRIES    4
+
+sal_uInt32 UINT16StringLen(const sal_uInt8* wstring)
+{
+    if (!wstring) return 0;
+
+    const sal_uInt8* b = wstring;
+
+    while (b[0] || b[1]) b += sizeof(sal_uInt16);
+
+    return ((b - wstring) / sizeof(sal_uInt16));
+}
+
+sal_uInt32 writeString(sal_uInt8* buffer, const sal_Unicode* v)
+{
+    sal_uInt32 len = rtl_ustr_getLength(v) + 1;
+    sal_uInt32 i;
+    sal_uInt8* buff = buffer;
+
+    for (i = 0; i < len; i++)
+    {
+        buff += writeUINT16(buff, static_cast<sal_uInt16>(v[i]));
+    }
+
+    return (buff - buffer);
+}
+
+sal_uInt32 readString(const sal_uInt8* buffer, sal_Unicode* v, sal_uInt32 maxSize)
+{
+    sal_uInt32 len = UINT16StringLen(buffer) + 1;
+    sal_uInt32 i;
+    sal_uInt8* buff = const_cast<sal_uInt8*>(buffer);
+
+    if(len > maxSize / 2)
+    {
+        len = maxSize / 2;
+    }
+
+    for (i = 0; i < (len - 1); i++)
+    {
+        sal_uInt16 aChar;
+
+        buff += readUINT16(buff, aChar);
+
+        v[i] = static_cast<sal_Unicode>(aChar);
+    }
+
+    v[len - 1] = L'\0';
+
+    return (buff - buffer);
+}
+
+sal_uInt32 writeFloat(sal_uInt8* buffer, float v)
+{
+    union
+    {
+        float   v;
+        sal_uInt32  b;
+    } x;
+
+    x.v = v;
+
+#ifdef REGTYPE_IEEE_NATIVE
+    writeUINT32(buffer, x.b);
+#else
+#   error no IEEE
+#endif
+
+    return sizeof(sal_uInt32);
+}
+
+sal_uInt32 writeDouble(sal_uInt8* buffer, double v)
+{
+    union
+    {
+        double v;
+        struct
+        {
+            sal_uInt32  b1;
+            sal_uInt32  b2;
+        } b;
+    } x;
+
+    x.v = v;
+
+#ifdef REGTYPE_IEEE_NATIVE
+#   ifdef OSL_BIGENDIAN
+    writeUINT32(buffer, x.b.b1);
+    writeUINT32(buffer + sizeof(sal_uInt32), x.b.b2);
+#   else
+    writeUINT32(buffer, x.b.b2);
+    writeUINT32(buffer + sizeof(sal_uInt32), x.b.b1);
+#   endif
+#else
+#   error no IEEE
+#endif
+
+    return (sizeof(sal_uInt32) + sizeof(sal_uInt32));
+}
+
+/**************************************************************************
+
+    buffer write functions
+
+**************************************************************************/
+
+namespace {
+
+/**************************************************************************
+
+    struct CPInfo
+
+**************************************************************************/
+
+struct CPInfo
+{
+    union
+    {
+        const char*         aUtf8;
+        RTUik*              aUik;
+        RTConstValueUnion   aConst;
+    } m_value;
+    struct CPInfo*  m_next;
+    CPInfoTag       m_tag;
+    sal_uInt16      m_index;
+
+    CPInfo(CPInfoTag tag, struct CPInfo* prev);
+
+    sal_uInt32 getBlopSize() const;
+
+    sal_uInt32 toBlop(sal_uInt8* buffer);
+};
+
+CPInfo::CPInfo(CPInfoTag tag, struct CPInfo* prev)
+    : m_next(nullptr)
+    , m_tag(tag)
+    , m_index(0)
+{
+    if (prev)
+    {
+        m_index = prev->m_index + 1;
+        prev->m_next = this;
+    }
+}
+
+sal_uInt32 CPInfo::getBlopSize() const
+{
+    sal_uInt32 size = sizeof(sal_uInt32) /* size */ + sizeof(sal_uInt16) /* tag */;
+
+    switch (m_tag)
+    {
+        case CP_TAG_CONST_BOOL:
+            size += sizeof(sal_uInt8);
+            break;
+        case CP_TAG_CONST_BYTE:
+            size += sizeof(sal_uInt8);
+            break;
+        case CP_TAG_CONST_INT16:
+            size += sizeof(sal_Int16);
+            break;
+        case CP_TAG_CONST_UINT16:
+            size += sizeof(sal_uInt16);
+            break;
+        case CP_TAG_CONST_INT32:
+            size += sizeof(sal_Int32);
+            break;
+        case CP_TAG_CONST_UINT32:
+            size += sizeof(sal_uInt32);
+            break;
+        case CP_TAG_CONST_INT64:
+              size += sizeof(sal_Int64);
+            break;
+        case CP_TAG_CONST_UINT64:
+            size += sizeof(sal_uInt64);
+            break;
+        case CP_TAG_CONST_FLOAT:
+            size += sizeof(sal_uInt32);
+            break;
+        case CP_TAG_CONST_DOUBLE:
+            size += sizeof(sal_uInt32) + sizeof(sal_uInt32);
+            break;
+        case CP_TAG_CONST_STRING:
+            size += (rtl_ustr_getLength(m_value.aConst.aString) + 1) * sizeof(sal_uInt16);
+            break;
+        case CP_TAG_UTF8_NAME:
+            size += strlen(m_value.aUtf8) + 1;
+            break;
+        case CP_TAG_UIK:
+            size += sizeof(sal_uInt32) + sizeof(sal_uInt16) + sizeof(sal_uInt16) + sizeof(sal_uInt32) + sizeof(sal_uInt32);
+            break;
+        default:
+            break;
+    }
+
+    return size;
+}
+
+
+sal_uInt32 CPInfo::toBlop(sal_uInt8* buffer)
+{
+    sal_uInt8* buff = buffer;
+
+    buff += writeUINT32(buff, getBlopSize());
+    buff += writeUINT16(buff, static_cast<sal_uInt16>(m_tag));
+
+    switch (m_tag)
+    {
+        case CP_TAG_CONST_BOOL:
+            buff += writeBYTE(buff, static_cast<sal_uInt8>(m_value.aConst.aBool));
+            break;
+        case CP_TAG_CONST_BYTE:
+            buff += writeBYTE(
+                buff, static_cast< sal_uInt8 >(m_value.aConst.aByte));
+            break;
+        case CP_TAG_CONST_INT16:
+            buff += writeINT16(buff, m_value.aConst.aShort);
+            break;
+        case CP_TAG_CONST_UINT16:
+            buff += writeINT16(buff, m_value.aConst.aUShort);
+            break;
+        case CP_TAG_CONST_INT32:
+            buff += writeINT32(buff, m_value.aConst.aLong);
+            break;
+        case CP_TAG_CONST_UINT32:
+            buff += writeUINT32(buff, m_value.aConst.aULong);
+            break;
+        case CP_TAG_CONST_INT64:
+            buff += writeUINT64(buff, m_value.aConst.aHyper);
+            break;
+        case CP_TAG_CONST_UINT64:
+            buff += writeUINT64(buff, m_value.aConst.aUHyper);
+            break;
+        case CP_TAG_CONST_FLOAT:
+            buff += writeFloat(buff, m_value.aConst.aFloat);
+            break;
+        case CP_TAG_CONST_DOUBLE:
+            buff += writeDouble(buff, m_value.aConst.aDouble);
+            break;
+        case CP_TAG_CONST_STRING:
+            buff += writeString(buff, m_value.aConst.aString);
+            break;
+        case CP_TAG_UTF8_NAME:
+            buff += writeUtf8(buff, m_value.aUtf8);
+            break;
+        case CP_TAG_UIK:
+            buff += writeUINT32(buff, m_value.aUik->m_Data1);
+            buff += writeUINT16(buff, m_value.aUik->m_Data2);
+            buff += writeUINT16(buff, m_value.aUik->m_Data3);
+            buff += writeUINT32(buff, m_value.aUik->m_Data4);
+            buff += writeUINT32(buff, m_value.aUik->m_Data5);
+            break;
+        default:
+            break;
+    }
+
+    return (buff - buffer);
+}
+
+
+/**************************************************************************
+
+    class FieldEntry
+
+**************************************************************************/
+
+class FieldEntry
+{
+
+public:
+
+    OString           m_name;
+    OString           m_typeName;
+    OString           m_doku;
+    OString           m_fileName;
+    RTFieldAccess     m_access;
+    RTValueType       m_constValueType;
+    RTConstValueUnion m_constValue;
+
+    FieldEntry();
+    ~FieldEntry();
+
+    void setData(const OString&    name,
+                 const OString&    typeName,
+                 const OString&    doku,
+                 const OString&    fileName,
+                 RTFieldAccess     access,
+                 RTValueType       constValueType,
+                 RTConstValueUnion constValue);
+        // throws std::bad_alloc
+};
+
+FieldEntry::FieldEntry()
+    : m_access(RTFieldAccess::INVALID)
+    , m_constValueType(RT_TYPE_NONE)
+{
+}
+
+FieldEntry::~FieldEntry()
+{
+    if (
+        (m_constValueType == RT_TYPE_STRING) &&
+        m_constValue.aString &&
+        (m_constValue.aString != NULL_WSTRING)
+       )
+    {
+        delete[] m_constValue.aString;
+    }
+}
+
+void FieldEntry::setData(const OString&    name,
+                         const OString&    typeName,
+                         const OString&    doku,
+                         const OString&    fileName,
+                         RTFieldAccess      access,
+                         RTValueType        constValueType,
+                         RTConstValueUnion  constValue)
+{
+    std::unique_ptr<sal_Unicode[]> newValue;
+    if (constValueType == RT_TYPE_STRING && constValue.aString != nullptr) {
+        sal_Int32 n = rtl_ustr_getLength(constValue.aString) + 1;
+        newValue.reset(new sal_Unicode[n]);
+        memcpy(newValue.get(), constValue.aString, n * sizeof (sal_Unicode));
+    }
+
+    m_name = name;
+    m_typeName = typeName;
+    m_doku = doku;
+    m_fileName = fileName;
+
+    if (
+        (m_constValueType == RT_TYPE_STRING) &&
+        m_constValue.aString &&
+        (m_constValue.aString != NULL_WSTRING)
+       )
+    {
+        delete[] m_constValue.aString;
+    }
+
+    m_access = access;
+    m_constValueType = constValueType;
+
+    if (m_constValueType == RT_TYPE_STRING)
+    {
+        if (constValue.aString == nullptr)
+            m_constValue.aString = NULL_WSTRING;
+        else
+        {
+            m_constValue.aString = newValue.release();
+        }
+    }
+    else
+    {
+        m_constValue = constValue;
+    }
+}
+
+/**************************************************************************
+
+    class ParamEntry
+
+**************************************************************************/
+
+class ParamEntry
+{
+public:
+
+    OString     m_typeName;
+    OString     m_name;
+    RTParamMode m_mode;
+
+    ParamEntry();
+
+    void setData(const OString& typeName,
+                 const OString& name,
+                 RTParamMode    mode);
+};
+
+ParamEntry::ParamEntry()
+    : m_mode(RT_PARAM_INVALID)
+{
+}
+
+void ParamEntry::setData(const OString& typeName,
+                         const OString& name,
+                         RTParamMode    mode)
+{
+    m_name = name;
+    m_typeName = typeName;
+    m_mode = mode;
+}
+
+/**************************************************************************
+
+    class ReferenceEntry
+
+**************************************************************************/
+
+class ReferenceEntry
+{
+public:
+
+    OString         m_name;
+    OString         m_doku;
+    RTReferenceType m_type;
+    RTFieldAccess   m_access;
+
+    ReferenceEntry();
+
+    void setData(const OString&     name,
+                 RTReferenceType    refType,
+                 const OString&     doku,
+                 RTFieldAccess      access);
+};
+
+ReferenceEntry::ReferenceEntry()
+    : m_type(RTReferenceType::INVALID)
+    , m_access(RTFieldAccess::INVALID)
+{
+}
+
+void ReferenceEntry::setData(const OString&    name,
+                             RTReferenceType   refType,
+                             const OString&    doku,
+                             RTFieldAccess     access)
+{
+    m_name = name;
+    m_doku = doku;
+    m_type = refType;
+    m_access = access;
+}
+
+/**************************************************************************
+
+    class MethodEntry
+
+**************************************************************************/
+
+class MethodEntry
+{
+public:
+
+    OString         m_name;
+    OString         m_returnTypeName;
+    RTMethodMode    m_mode;
+    sal_uInt16      m_paramCount;
+    std::unique_ptr<ParamEntry[]> m_params;
+    sal_uInt16      m_excCount;
+    std::unique_ptr<OString[]>    m_excNames;
+    OString         m_doku;
+
+    MethodEntry();
+
+    void setData(const OString&    name,
+                 const OString&    returnTypeName,
+                 RTMethodMode      mode,
+                 sal_uInt16        paramCount,
+                 sal_uInt16        excCount,
+                 const OString&    doku);
+
+    void setExcName(sal_uInt16 excIndex, const OString& name) const;
+
+protected:
+
+    void reallocParams(sal_uInt16 size);
+    void reallocExcs(sal_uInt16 size);
+};
+
+MethodEntry::MethodEntry()
+    : m_mode(RTMethodMode::INVALID)
+    , m_paramCount(0)
+    , m_excCount(0)
+{
+}
+
+void MethodEntry::setData(const OString&    name,
+                          const OString&    returnTypeName,
+                          RTMethodMode      mode,
+                          sal_uInt16        paramCount,
+                          sal_uInt16        excCount,
+                          const OString&    doku)
+{
+    m_name = name;
+    m_returnTypeName = returnTypeName;
+    m_doku = doku;
+
+    m_mode = mode;
+
+    reallocParams(paramCount);
+    reallocExcs(excCount);
+}
+
+void MethodEntry::setExcName(sal_uInt16 excIndex, const OString& name) const
+{
+    if (excIndex < m_excCount)
+    {
+        m_excNames[excIndex] = name;
+    }
+}
+
+void MethodEntry::reallocParams(sal_uInt16 size)
+{
+    ParamEntry* newParams;
+
+    if (size)
+        newParams = new ParamEntry[size];
+    else
+        newParams = nullptr;
+
+    if (m_paramCount)
+    {
+        sal_uInt16 i;
+        sal_uInt16 mn = std::min(size, m_paramCount);
+
+        for (i = 0; i < mn; i++)
+        {
+            newParams[i].setData(m_params[i].m_typeName, m_params[i].m_name, m_params[i].m_mode);
+        }
+
+        m_params.reset();
+    }
+
+    m_paramCount = size;
+    m_params.reset( newParams );
+}
+
+void MethodEntry::reallocExcs(sal_uInt16 size)
+{
+    OString* newExcNames;
+
+    if (size)
+        newExcNames = new OString[size];
+    else
+        newExcNames = nullptr;
+
+    sal_uInt16 i;
+    sal_uInt16 mn = std::min(size, m_excCount);
+
+    for (i = 0; i < mn; i++)
+    {
+        newExcNames[i] = m_excNames[i];
+    }
+
+    m_excCount = size;
+    m_excNames.reset( newExcNames );
+}
+
+
+/**************************************************************************
+
+    class TypeRegistryEntry
+
+**************************************************************************/
+
+class TypeWriter
+{
+
+public:
+
+    sal_uInt32          m_refCount;
+    typereg_Version     m_version;
+    RTTypeClass         m_typeClass;
+    OString             m_typeName;
+    sal_uInt16          m_nSuperTypes;
+    std::unique_ptr<OString[]>
+                        m_superTypeNames;
+    OString             m_doku;
+    OString             m_fileName;
+    sal_uInt16          m_fieldCount;
+    FieldEntry*         m_fields;
+    sal_uInt16          m_methodCount;
+    MethodEntry*        m_methods;
+    sal_uInt16          m_referenceCount;
+    ReferenceEntry*     m_references;
+
+    std::unique_ptr<sal_uInt8[]> m_blop;
+    sal_uInt32          m_blopSize;
+
+    TypeWriter(typereg_Version version,
+               OString const & documentation,
+               OString const & fileName,
+               RTTypeClass      RTTypeClass,
+               bool             published,
+               const OString&   typeName,
+               sal_uInt16       superTypeCount,
+               sal_uInt16       FieldCount,
+               sal_uInt16       methodCount,
+               sal_uInt16       referenceCount);
+
+    ~TypeWriter();
+
+    void setSuperType(sal_uInt16 index, OString const & name) const;
+
+    void createBlop(); // throws std::bad_alloc
+};
+
+TypeWriter::TypeWriter(typereg_Version version,
+                       OString const & documentation,
+                       OString const & fileName,
+                       RTTypeClass      RTTypeClass,
+                       bool             published,
+                       const OString&   typeName,
+                       sal_uInt16       superTypeCount,
+                       sal_uInt16       fieldCount,
+                       sal_uInt16       methodCount,
+                       sal_uInt16       referenceCount)
+    : m_refCount(1)
+    , m_version(version)
+    , m_typeClass(
+        static_cast< enum RTTypeClass >(
+            RTTypeClass | (published ? RT_TYPE_PUBLISHED : 0)))
+     , m_typeName(typeName)
+    , m_nSuperTypes(superTypeCount)
+    , m_doku(documentation)
+    , m_fileName(fileName)
+    , m_fieldCount(fieldCount)
+    , m_fields(nullptr)
+    , m_methodCount(methodCount)
+    , m_methods(nullptr)
+    , m_referenceCount(referenceCount)
+    , m_references(nullptr)
+    , m_blopSize(0)
+{
+    if (m_nSuperTypes > 0)
+    {
+        m_superTypeNames.reset( new OString[m_nSuperTypes] );
+    }
+
+    if (m_fieldCount)
+        m_fields = new FieldEntry[fieldCount];
+
+    if (m_methodCount)
+        m_methods = new MethodEntry[methodCount];
+
+    if (m_referenceCount)
+        m_references = new ReferenceEntry[referenceCount];
+}
+
+TypeWriter::~TypeWriter()
+{
+    if (m_fieldCount)
+        delete[] m_fields;
+
+    if (m_methodCount)
+        delete[] m_methods;
+
+    if (m_referenceCount)
+        delete[] m_references;
+}
+
+void TypeWriter::setSuperType(sal_uInt16 index, OString const & name) const
+{
+    m_superTypeNames[index] = name;
+}
+
+void TypeWriter::createBlop()
+{
+    //TODO: Fix memory leaks that occur when std::bad_alloc is thrown
+
+    std::unique_ptr<sal_uInt8[]>  pBlopFields;
+    std::unique_ptr<sal_uInt8[]>  pBlopMethods;
+    std::unique_ptr<sal_uInt8[]>  pBlopReferences;
+    sal_uInt8*  pBuffer             = nullptr;
+    sal_uInt32  blopFieldsSize      = 0;
+    sal_uInt32  blopMethodsSize     = 0;
+    sal_uInt32  blopReferenceSize   = 0;
+
+    CPInfo  root(CP_TAG_INVALID, nullptr);
+    sal_uInt16  cpIndexThisName = 0;
+    std::unique_ptr<sal_uInt16[]> cpIndexSuperNames;
+    sal_uInt16  cpIndexDoku = 0;
+    sal_uInt16  cpIndexFileName = 0;
+    CPInfo* pInfo = nullptr;
+
+    sal_uInt16  entrySize = sizeof(sal_uInt16);
+    sal_uInt32  blopHeaderEntrySize = BLOP_OFFSET_N_ENTRIES + entrySize + (BLOP_HEADER_N_ENTRIES * entrySize);
+    sal_uInt32  blopFieldEntrySize = BLOP_FIELD_N_ENTRIES * entrySize;
+    sal_uInt32  blopMethodEntrySize = BLOP_METHOD_N_ENTRIES * entrySize;
+    sal_uInt32  blopParamEntrySize = BLOP_PARAM_N_ENTRIES * entrySize;
+    sal_uInt32  blopReferenceEntrySize = BLOP_REFERENCE_N_ENTRIES * entrySize;
+
+    sal_uInt32 blopSize = blopHeaderEntrySize;
+
+    // create CP entry for this name
+    pInfo = new CPInfo(CP_TAG_UTF8_NAME, &root);
+    pInfo->m_value.aUtf8 = m_typeName.getStr();
+    cpIndexThisName = pInfo->m_index;
+
+    // nSuperTypes
+    blopSize += entrySize;
+
+    // create CP entry for super names
+    if (m_nSuperTypes)
+    {
+        blopSize += m_nSuperTypes * entrySize;
+
+        cpIndexSuperNames.reset(new sal_uInt16[m_nSuperTypes]);
+
+        for (sal_uInt32 i=0; i < m_nSuperTypes; i++)
+        {
+            pInfo = new CPInfo(CP_TAG_UTF8_NAME, pInfo);
+            pInfo->m_value.aUtf8 = m_superTypeNames[i].getStr();
+            cpIndexSuperNames[i] = pInfo->m_index;
+        }
+    }
+
+    // create CP entry for doku
+    if (!m_doku.isEmpty())
+    {
+        pInfo = new CPInfo(CP_TAG_UTF8_NAME, pInfo);
+        pInfo->m_value.aUtf8 = m_doku.getStr();
+        cpIndexDoku = pInfo->m_index;
+    }
+
+    // create CP entry for idl source filename
+    if (!m_fileName.isEmpty())
+    {
+        pInfo = new CPInfo(CP_TAG_UTF8_NAME, pInfo);
+        pInfo->m_value.aUtf8 = m_fileName.getStr();
+        cpIndexFileName = pInfo->m_index;
+    }
+
+    // fields blop
+    blopSize += sizeof(sal_uInt16); // fieldCount + nFieldEntries
+
+    if (m_fieldCount)
+    {
+        sal_uInt16 cpIndexName = 0;
+        sal_uInt16 cpIndexTypeName = 0;
+        sal_uInt16 cpIndexValue = 0;
+        sal_uInt16 cpIndexDoku2 = 0;
+        sal_uInt16 cpIndexFileName2 = 0;
+
+        // nFieldEntries + n fields
+        blopFieldsSize = sizeof(sal_uInt16) + (m_fieldCount * blopFieldEntrySize);
+
+        blopSize += blopFieldsSize;
+
+        pBlopFields.reset(new sal_uInt8[blopFieldsSize]);
+        pBuffer = pBlopFields.get();
+
+        pBuffer += writeUINT16(pBuffer, BLOP_FIELD_N_ENTRIES);
+
+        for (sal_uInt16 i = 0; i < m_fieldCount; i++)
+        {
+            cpIndexName = 0;
+            cpIndexTypeName = 0;
+            cpIndexValue = 0;
+            cpIndexDoku2 = 0;
+            cpIndexFileName2 = 0;
+
+            pBuffer += writeUINT16(pBuffer, static_cast<sal_uInt16>(m_fields[i].m_access));
+
+            if (!m_fields[i].m_name.isEmpty())
+            {
+                pInfo = new CPInfo(CP_TAG_UTF8_NAME, pInfo);
+                pInfo->m_value.aUtf8 = m_fields[i].m_name.getStr();
+                cpIndexName = pInfo->m_index;
+            }
+            pBuffer += writeUINT16(pBuffer, cpIndexName);
+
+            if (!m_fields[i].m_typeName.isEmpty())
+            {
+                pInfo = new CPInfo(CP_TAG_UTF8_NAME, pInfo);
+                pInfo->m_value.aUtf8 = m_fields[i].m_typeName.getStr();
+                cpIndexTypeName = pInfo->m_index;
+            }
+            pBuffer += writeUINT16(pBuffer, cpIndexTypeName);
+
+            if (m_fields[i].m_constValueType != RT_TYPE_NONE)
+            {
+                pInfo = new CPInfo(static_cast<CPInfoTag>(m_fields[i].m_constValueType), pInfo);
+                pInfo->m_value.aConst = m_fields[i].m_constValue;
+                cpIndexValue = pInfo->m_index;
+            }
+            pBuffer += writeUINT16(pBuffer, cpIndexValue);
+
+            if (!m_fields[i].m_doku.isEmpty())
+            {
+                pInfo = new CPInfo(CP_TAG_UTF8_NAME, pInfo);
+                pInfo->m_value.aUtf8 = m_fields[i].m_doku.getStr();
+                cpIndexDoku2 = pInfo->m_index;
+            }
+            pBuffer += writeUINT16(pBuffer, cpIndexDoku2);
+
+            if (!m_fields[i].m_fileName.isEmpty())
+            {
+                pInfo = new CPInfo(CP_TAG_UTF8_NAME, pInfo);
+                pInfo->m_value.aUtf8 = m_fields[i].m_fileName.getStr();
+                cpIndexFileName2 = pInfo->m_index;
+            }
+            pBuffer += writeUINT16(pBuffer, cpIndexFileName2);
+        }
+    }
+
+    // methods blop
+    blopSize += sizeof(sal_uInt16); // methodCount
+
+    if (m_methodCount)
+    {
+        std::unique_ptr<sal_uInt16[]> pMethodEntrySize( new sal_uInt16[m_methodCount] );
+        sal_uInt16  cpIndexName = 0;
+        sal_uInt16  cpIndexReturn = 0;
+        sal_uInt16  cpIndexDoku2 = 0;
+
+        // nMethodEntries + nParamEntries
+        blopMethodsSize = (2 * sizeof(sal_uInt16));
+
+        for (sal_uInt16 i = 0; i < m_methodCount; i++)
+        {
+            pMethodEntrySize[i] = static_cast<sal_uInt16>( blopMethodEntrySize +                                 // header
+                  sizeof(sal_uInt16) +                                  // parameterCount
+                  (m_methods[i].m_paramCount * blopParamEntrySize) +    // exceptions
+                  sizeof(sal_uInt16) +                                  // exceptionCount
+                  (m_methods[i].m_excCount * sizeof(sal_uInt16)) );     // exceptions
+
+            blopMethodsSize += pMethodEntrySize[i];
+        }
+
+        pBlopMethods.reset(new sal_uInt8[blopMethodsSize]);
+
+        blopSize += blopMethodsSize;
+
+        pBuffer = pBlopMethods.get();
+
+        pBuffer += writeUINT16(pBuffer, BLOP_METHOD_N_ENTRIES);
+        pBuffer += writeUINT16(pBuffer, BLOP_PARAM_N_ENTRIES );
+
+        for (sal_uInt16 i = 0; i < m_methodCount; i++)
+        {
+            cpIndexReturn = 0;
+            cpIndexDoku2 = 0;
+
+            pBuffer += writeUINT16(pBuffer, pMethodEntrySize[i]);
+            pBuffer += writeUINT16(
+                pBuffer,
+                sal::static_int_cast< sal_uInt16 >(m_methods[i].m_mode));
+
+            if (!m_methods[i].m_name.isEmpty())
+            {
+                pInfo = new CPInfo(CP_TAG_UTF8_NAME, pInfo);
+                pInfo->m_value.aUtf8 = m_methods[i].m_name.getStr();
+                cpIndexName = pInfo->m_index;
+            }
+            pBuffer += writeUINT16(pBuffer, cpIndexName);
+            cpIndexName = 0;
+
+            if (!m_methods[i].m_returnTypeName.isEmpty())
+            {
+                pInfo = new CPInfo(CP_TAG_UTF8_NAME, pInfo);
+                pInfo->m_value.aUtf8 = m_methods[i].m_returnTypeName.getStr();
+                cpIndexReturn = pInfo->m_index;
+            }
+            pBuffer += writeUINT16(pBuffer, cpIndexReturn);
+
+            if (!m_methods[i].m_doku.isEmpty())
+            {
+                pInfo = new CPInfo(CP_TAG_UTF8_NAME, pInfo);
+                pInfo->m_value.aUtf8 = m_methods[i].m_doku.getStr();
+                cpIndexDoku2 = pInfo->m_index;
+            }
+            pBuffer += writeUINT16(pBuffer, cpIndexDoku2);
+
+            sal_uInt16 j;
+
+            pBuffer += writeUINT16(pBuffer, m_methods[i].m_paramCount);
+
+            for (j = 0; j < m_methods[i].m_paramCount; j++)
+            {
+                if (!m_methods[i].m_params[j].m_typeName.isEmpty())
+                {
+                    pInfo = new CPInfo(CP_TAG_UTF8_NAME, pInfo);
+                    pInfo->m_value.aUtf8 = m_methods[i].m_params[j].m_typeName.getStr();
+                    cpIndexName = pInfo->m_index;
+                }
+                pBuffer += writeUINT16(pBuffer, cpIndexName);
+                cpIndexName = 0;
+
+                pBuffer += writeUINT16(
+                    pBuffer,
+                    sal::static_int_cast< sal_uInt16 >(
+                        m_methods[i].m_params[j].m_mode));
+
+                if (!m_methods[i].m_params[j].m_name.isEmpty())
+                {
+                    pInfo = new CPInfo(CP_TAG_UTF8_NAME, pInfo);
+                    pInfo->m_value.aUtf8 = m_methods[i].m_params[j].m_name.getStr();
+                    cpIndexName = pInfo->m_index;
+                }
+                pBuffer += writeUINT16(pBuffer, cpIndexName);
+                cpIndexName = 0;
+            }
+
+            pBuffer += writeUINT16(pBuffer, m_methods[i].m_excCount);
+
+            for (j = 0; j < m_methods[i].m_excCount; j++)
+            {
+                if (!m_methods[i].m_excNames[j].isEmpty())
+                {
+                    pInfo = new CPInfo(CP_TAG_UTF8_NAME, pInfo);
+                    pInfo->m_value.aUtf8 = m_methods[i].m_excNames[j].getStr();
+                    cpIndexName = pInfo->m_index;
+                }
+                pBuffer += writeUINT16(pBuffer, cpIndexName);
+                cpIndexName = 0;
+            }
+        }
+    }
+
+    // reference blop
+    blopSize += entrySize; // referenceCount
+
+    if (m_referenceCount)
+    {
+        sal_uInt16 cpIndexName = 0;
+        sal_uInt16 cpIndexDoku2 = 0;
+
+        // nReferenceEntries + n references
+        blopReferenceSize = entrySize + (m_referenceCount * blopReferenceEntrySize);
+
+        blopSize += blopReferenceSize;
+
+        pBlopReferences.reset(new sal_uInt8[blopReferenceSize]);
+        pBuffer = pBlopReferences.get();
+
+        pBuffer += writeUINT16(pBuffer, BLOP_REFERENCE_N_ENTRIES);
+
+        for (sal_uInt16 i = 0; i < m_referenceCount; i++)
+        {
+            pBuffer += writeUINT16(
+                pBuffer,
+                sal::static_int_cast< sal_uInt16 >(m_references[i].m_type));
+
+            cpIndexName = 0;
+            cpIndexDoku2 = 0;
+
+            if (!m_references[i].m_name.isEmpty())
+            {
+                pInfo = new CPInfo(CP_TAG_UTF8_NAME, pInfo);
+                pInfo->m_value.aUtf8 = m_references[i].m_name.getStr();
+                cpIndexName = pInfo->m_index;
+            }
+            pBuffer += writeUINT16(pBuffer, cpIndexName);
+
+            if (!m_references[i].m_doku.isEmpty())
+            {
+                pInfo = new CPInfo(CP_TAG_UTF8_NAME, pInfo);
+                pInfo->m_value.aUtf8 = m_references[i].m_doku.getStr();
+                cpIndexDoku2 = pInfo->m_index;
+            }
+            pBuffer += writeUINT16(pBuffer, cpIndexDoku2);
+
+            pBuffer += writeUINT16(pBuffer, static_cast<sal_uInt16>(m_references[i].m_access));
+        }
+    }
+
+
+    // get CP infos blop-length
+    pInfo = root.m_next;
+    sal_uInt32 cpBlopSize = 0;
+    sal_uInt16 cpCount = 0;
+
+    while (pInfo)
+    {
+        cpBlopSize += pInfo->getBlopSize();
+        cpCount++;
+        pInfo = pInfo->m_next;
+    }
+
+    blopSize += cpBlopSize;
+    blopSize += sizeof(sal_uInt16);   // constantPoolCount
+
+    // write all in flat buffer
+
+    sal_uInt8 * blop = new sal_uInt8[blopSize];
+
+    pBuffer = blop;
+
+    // Assumes two's complement arithmetic with modulo-semantics:
+    pBuffer += writeUINT32(pBuffer, magic + m_version);
+    pBuffer += writeUINT32(pBuffer, blopSize);
+    pBuffer += writeUINT16(pBuffer, minorVersion);
+    pBuffer += writeUINT16(pBuffer, majorVersion);
+    pBuffer += writeUINT16(pBuffer, BLOP_HEADER_N_ENTRIES);
+
+    pBuffer += writeUINT16(pBuffer, sal_uInt16(RT_UNO_IDL));
+    pBuffer += writeUINT16(pBuffer, static_cast<sal_uInt16>(m_typeClass));
+    pBuffer += writeUINT16(pBuffer, cpIndexThisName);
+    pBuffer += writeUINT16(pBuffer, 0); // cpIndexUik
+    pBuffer += writeUINT16(pBuffer, cpIndexDoku);
+    pBuffer += writeUINT16(pBuffer, cpIndexFileName);
+
+    // write supertypes
+    pBuffer += writeUINT16(pBuffer, m_nSuperTypes);
+    if (m_nSuperTypes)
+    {
+        for (sal_uInt32 i=0; i < m_nSuperTypes; i++)
+        {
+            pBuffer += writeUINT16(pBuffer, cpIndexSuperNames[i]);
+        }
+        cpIndexSuperNames.reset();
+    }
+
+    pBuffer += writeUINT16(pBuffer, cpCount);
+
+    // write and delete CP infos
+    pInfo = root.m_next;
+
+    while (pInfo)
+    {
+        CPInfo* pNextInfo = pInfo->m_next;
+
+        pBuffer += pInfo->toBlop(pBuffer);
+        delete pInfo;
+
+        pInfo = pNextInfo;
+    }
+
+    auto writeList = [&pBuffer](
+        sal_uInt16 count, sal_uInt8 * data, sal_uInt32 size)
+    {
+        pBuffer += writeUINT16(pBuffer, count);
+        if (size != 0) {
+            memcpy(pBuffer, data, size);
+            pBuffer += size;
+        }
+    };
+
+    // write fields
+    writeList(m_fieldCount, pBlopFields.get(), blopFieldsSize);
+
+    // write methods
+    writeList(m_methodCount, pBlopMethods.get(), blopMethodsSize);
+
+    // write references
+    writeList(m_referenceCount, pBlopReferences.get(), blopReferenceSize);
+
+    m_blop.reset( blop );
+    m_blopSize = blopSize;
+}
+
+} // unnamed namespace
+
+/**************************************************************************
+
+    C-API
+
+**************************************************************************/
+
+extern "C" {
+
+static void TYPEREG_CALLTYPE release(TypeWriterImpl hEntry)
+{
+    TypeWriter* pEntry = static_cast<TypeWriter*>(hEntry);
+
+    if (pEntry != nullptr)
+    {
+        if (--pEntry->m_refCount == 0)
+            delete pEntry;
+    }
+}
+
+sal_Bool TYPEREG_CALLTYPE typereg_writer_setFieldData(
+    void * handle, sal_uInt16 index, rtl_uString const * documentation,
+    rtl_uString const * fileName, RTFieldAccess flags, rtl_uString const * name,
+    rtl_uString const * typeName, RTValueType valueType,
+    RTConstValueUnion valueValue)
+    SAL_THROW_EXTERN_C()
+{
+    try {
+        static_cast< TypeWriter * >(handle)->m_fields[index].setData(
+            toByteString(name), toByteString(typeName),
+            toByteString(documentation), toByteString(fileName), flags,
+            valueType, valueValue);
+    } catch (std::bad_alloc &) {
+        return false;
+    }
+    return true;
+}
+
+static void TYPEREG_CALLTYPE setFieldData(TypeWriterImpl    hEntry,
+                                          sal_uInt16        index,
+                                          rtl_uString const * name,
+                                          rtl_uString const * typeName,
+                                          rtl_uString const * doku,
+                                          rtl_uString const * fileName,
+                                          RTFieldAccess     access,
+                                          RTValueType       valueType,
+                                          RTConstValueUnion constValue)
+{
+    typereg_writer_setFieldData(
+        hEntry, index, doku, fileName, access, name, typeName, valueType,
+        constValue);
+}
+
+sal_Bool TYPEREG_CALLTYPE typereg_writer_setMethodData(
+    void * handle, sal_uInt16 index, rtl_uString const * documentation,
+    RTMethodMode flags, rtl_uString const * name,
+    rtl_uString const * returnTypeName, sal_uInt16 parameterCount,
+    sal_uInt16 exceptionCount)
+    SAL_THROW_EXTERN_C()
+{
+    try {
+        static_cast< TypeWriter * >(handle)->m_methods[index].setData(
+            toByteString(name), toByteString(returnTypeName), flags,
+            parameterCount, exceptionCount, toByteString(documentation));
+    } catch (std::bad_alloc &) {
+        return false;
+    }
+    return true;
+}
+
+sal_Bool TYPEREG_CALLTYPE typereg_writer_setMethodParameterData(
+    void const * handle, sal_uInt16 methodIndex, sal_uInt16 parameterIndex,
+    RTParamMode flags, rtl_uString const * name, rtl_uString const * typeName)
+    SAL_THROW_EXTERN_C()
+{
+    try {
+        static_cast< TypeWriter const * >(handle)->
+            m_methods[methodIndex].m_params[parameterIndex].setData(
+                toByteString(typeName), toByteString(name), flags);
+    } catch (std::bad_alloc &) {
+        return false;
+    }
+    return true;
+}
+
+sal_Bool TYPEREG_CALLTYPE typereg_writer_setMethodExceptionTypeName(
+    void const * handle, sal_uInt16 methodIndex, sal_uInt16 exceptionIndex,
+    rtl_uString const * typeName)
+    SAL_THROW_EXTERN_C()
+{
+    try {
+        static_cast< TypeWriter const * >(handle)->m_methods[methodIndex].setExcName(
+            exceptionIndex, toByteString(typeName));
+    } catch (std::bad_alloc &) {
+        return false;
+    }
+    return true;
+}
+
+void const * TYPEREG_CALLTYPE typereg_writer_getBlob(void * handle, sal_uInt32 * size)
+    SAL_THROW_EXTERN_C()
+{
+    TypeWriter * writer = static_cast< TypeWriter * >(handle);
+    if (!writer->m_blop) {
+        try {
+            writer->createBlop();
+        } catch (std::bad_alloc &) {
+            *size = 0;
+            return nullptr;
+        }
+    }
+    *size = writer->m_blopSize;
+    return writer->m_blop.get();
+}
+
+static const sal_uInt8* TYPEREG_CALLTYPE getBlop(TypeWriterImpl hEntry)
+{
+    sal_uInt32 size;
+    return static_cast< sal_uInt8 const * >(
+        typereg_writer_getBlob(hEntry, &size));
+}
+
+static sal_uInt32 TYPEREG_CALLTYPE getBlopSize(TypeWriterImpl hEntry)
+{
+    sal_uInt32 size;
+    typereg_writer_getBlob(hEntry, &size);
+    return size;
+}
+
+sal_Bool TYPEREG_CALLTYPE typereg_writer_setReferenceData(
+    void * handle, sal_uInt16 index, rtl_uString const * documentation,
+    RTReferenceType sort, RTFieldAccess flags, rtl_uString const * typeName)
+    SAL_THROW_EXTERN_C()
+{
+    try {
+        static_cast< TypeWriter * >(handle)->m_references[index].setData(
+            toByteString(typeName), sort, toByteString(documentation), flags);
+    } catch (std::bad_alloc &) {
+        return false;
+    }
+    return true;
+}
+
+void * TYPEREG_CALLTYPE typereg_writer_create(
+    typereg_Version version, rtl_uString const * documentation,
+    rtl_uString const * fileName, RTTypeClass typeClass, sal_Bool published,
+    rtl_uString const * typeName, sal_uInt16 superTypeCount,
+    sal_uInt16 fieldCount, sal_uInt16 methodCount, sal_uInt16 referenceCount)
+    SAL_THROW_EXTERN_C()
+{
+    try {
+        return new TypeWriter(
+            version, toByteString(documentation), toByteString(fileName),
+            typeClass, published, toByteString(typeName), superTypeCount,
+            fieldCount, methodCount, referenceCount);
+    } catch (std::bad_alloc &) {
+        return nullptr;
+    }
+}
+
+void TYPEREG_CALLTYPE typereg_writer_destroy(void * handle) SAL_THROW_EXTERN_C() {
+    delete static_cast< TypeWriter * >(handle);
+}
+
+sal_Bool TYPEREG_CALLTYPE typereg_writer_setSuperTypeName(
+    void const * handle, sal_uInt16 index, rtl_uString const * typeName)
+    SAL_THROW_EXTERN_C()
+{
+    try {
+        static_cast< TypeWriter const * >(handle)->setSuperType(
+            index, toByteString(typeName));
+    } catch (std::bad_alloc &) {
+        return false;
+    }
+    return true;
+}
+
+static TypeWriterImpl TYPEREG_CALLTYPE createEntry(
+    RTTypeClass typeClass, rtl_uString const * typeName, rtl_uString const * superTypeName,
+    sal_uInt16 fieldCount)
+{
+    OUString empty;
+    sal_uInt16 superTypeCount = rtl_uString_getLength(superTypeName) == 0
+        ? 0 : 1;
+    TypeWriterImpl t = typereg_writer_create(
+        TYPEREG_VERSION_0, empty.pData, empty.pData, typeClass, false, typeName,
+        superTypeCount, fieldCount, 0/*methodCount*/, 0/*referenceCount*/);
+    if (superTypeCount > 0) {
+        typereg_writer_setSuperTypeName(t, 0, superTypeName);
+    }
+    return t;
+}
+
+}
+
+RegistryTypeWriter::RegistryTypeWriter(RTTypeClass               RTTypeClass,
+                                              const OUString&    typeName,
+                                              const OUString&    superTypeName,
+                                              sal_uInt16                fieldCount)
+    : m_hImpl(nullptr)
+{
+    m_hImpl = createEntry(RTTypeClass,
+                                  typeName.pData,
+                                  superTypeName.pData,
+                                  fieldCount);
+}
+
+RegistryTypeWriter::~RegistryTypeWriter()
+{
+    release(m_hImpl);
+}
+
+void RegistryTypeWriter::setFieldData( sal_uInt16              index,
+                                              const OUString&    name,
+                                              const OUString&    typeName,
+                                              const OUString&    doku,
+                                              const OUString&    fileName,
+                                              RTFieldAccess           access,
+                                              const RTConstValue&     constValue)
+{
+    ::setFieldData(m_hImpl, index, name.pData, typeName.pData, doku.pData, fileName.pData, access, constValue.m_type, constValue.m_value);
+}
+
+const sal_uInt8* RegistryTypeWriter::getBlop()
+{
+    return ::getBlop(m_hImpl);
+}
+
+sal_uInt32 RegistryTypeWriter::getBlopSize()
+{
+    return ::getBlopSize(m_hImpl);
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/registry/source/reflwrit.hxx b/registry/source/reflwrit.hxx
new file mode 100644
index 000000000..93cee0697
--- /dev/null
+++ b/registry/source/reflwrit.hxx
@@ -0,0 +1,103 @@
+/* -*- 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_REGISTRY_SOURCE_REFLWRIT_HXX
+#define INCLUDED_REGISTRY_SOURCE_REFLWRIT_HXX
+
+#include <registry/types.hxx>
+#include <rtl/ustring.hxx>
+
+class RTConstValue;
+
+/// Implementation handle
+typedef void* TypeWriterImpl;
+
+/** RegistryTypeWriter writes/creates a binary type blob.
+
+    This class provides the necessary functions to write type information
+    for all kinds of types into a blob.
+
+    @deprecated
+    use typereg::Writer instead
+*/
+class RegistryTypeWriter
+{
+public:
+
+    /** Constructor.
+
+        @param RTTypeClass specifies the type of the new blob.
+        @param typeName specifies the full qualified type name with '/' as separator.
+        @param superTypeName specifies the full qualified type name of the base type
+                             with '/' as separator.
+        @param fieldCount specifies the number of fields (eg. number of attributes/properties,
+                          enum values or constants).
+     */
+    RegistryTypeWriter(RTTypeClass               RTTypeClass,
+                              const OUString&    typeName,
+                              const OUString&    superTypeName,
+                              sal_uInt16                fieldCount);
+
+    /** Destructor. The Destructor frees the internal data block.
+
+        The pointer (returned by getBlop) will be set to NULL.
+     */
+    ~RegistryTypeWriter();
+
+    /** sets the data for a field member of a type blob.
+
+        @param index indicates the index of the field.
+        @param name specifies the name.
+        @param typeName specifies the full qualified typename.
+        @param doku specifies the documentation string of the field.
+        @param fileName specifies the name of the IDL file where the field is defined.
+        @param access specifies the access mode of the field.
+        @param constValue specifies the value of the field. The value is only interesting
+                          for enum values or constants.
+     */
+    void setFieldData( sal_uInt16              index,
+                              const OUString&    name,
+                              const OUString&    typeName,
+                              const OUString&    doku,
+                              const OUString&    fileName,
+                              RTFieldAccess           access,
+                              const RTConstValue&     constValue);
+
+    /** returns a pointer to the new type blob.
+
+        The pointer will be invalid (NULL) if the instance of
+        the RegistryTypeWriter will be destroyed.
+     */
+    const sal_uInt8*     getBlop();
+
+    /** returns the size of the new type blob in bytes.
+     */
+    sal_uInt32       getBlopSize();
+
+private:
+    RegistryTypeWriter(RegistryTypeWriter const &) = delete;
+    void operator =(RegistryTypeWriter const &) = delete;
+
+    /// stores the handle of an implementation class
+    TypeWriterImpl                                               m_hImpl;
+};
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/registry/source/regimpl.cxx b/registry/source/regimpl.cxx
new file mode 100644
index 000000000..0d69c64cd
--- /dev/null
+++ b/registry/source/regimpl.cxx
@@ -0,0 +1,1577 @@
+/* -*- 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 "regimpl.hxx"
+
+#include <cstddef>
+#include <memory>
+#include <set>
+#include <string_view>
+#include <vector>
+#include <string.h>
+#include <stdio.h>
+
+#if defined(UNX)
+#include <unistd.h>
+#endif
+
+#include "reflread.hxx"
+
+#include "reflwrit.hxx"
+
+#include <registry/reader.hxx>
+#include <registry/refltype.hxx>
+#include <registry/types.hxx>
+
+#include "reflcnst.hxx"
+#include "keyimpl.hxx"
+
+#include <osl/thread.h>
+#include <rtl/ustring.hxx>
+#include <rtl/ustrbuf.hxx>
+#include <osl/file.hxx>
+
+using namespace osl;
+using namespace store;
+
+
+namespace {
+
+void printString(std::u16string_view s) {
+    printf("\"");
+    for (std::size_t i = 0; i < s.size(); ++i) {
+        sal_Unicode c = s[i];
+        if (c == '"' || c == '\\') {
+            printf("\\%c", static_cast< char >(c));
+        } else if (s[i] >= ' ' && s[i] <= '~') {
+            printf("%c", static_cast< char >(c));
+        } else {
+            printf("\\u%04X", static_cast< unsigned int >(c));
+        }
+    }
+    printf("\"");
+}
+
+void printFieldOrReferenceFlag(
+    RTFieldAccess * flags, RTFieldAccess flag, char const * name, bool * first)
+{
+    if ((*flags & flag) != RTFieldAccess::NONE) {
+        if (!*first) {
+            printf("|");
+        }
+        *first = false;
+        printf("%s", name);
+        *flags &= ~flag;
+    }
+}
+
+void printFieldOrReferenceFlags(RTFieldAccess flags) {
+    if (flags == RTFieldAccess::NONE) {
+        printf("none");
+    } else {
+        bool first = true;
+        printFieldOrReferenceFlag(
+            &flags, RTFieldAccess::READONLY, "readonly", &first);
+        printFieldOrReferenceFlag(
+            &flags, RTFieldAccess::OPTIONAL, "optional", &first);
+        printFieldOrReferenceFlag(
+            &flags, RTFieldAccess::MAYBEVOID, "maybevoid", &first);
+        printFieldOrReferenceFlag(&flags, RTFieldAccess::BOUND, "bound", &first);
+        printFieldOrReferenceFlag(
+            &flags, RTFieldAccess::CONSTRAINED, "constrained", &first);
+        printFieldOrReferenceFlag(
+            &flags, RTFieldAccess::TRANSIENT, "transient", &first);
+        printFieldOrReferenceFlag(
+            &flags, RTFieldAccess::MAYBEAMBIGUOUS, "maybeambiguous", &first);
+        printFieldOrReferenceFlag(
+            &flags, RTFieldAccess::MAYBEDEFAULT, "maybedefault", &first);
+        printFieldOrReferenceFlag(
+            &flags, RTFieldAccess::REMOVABLE, "removable", &first);
+        printFieldOrReferenceFlag(
+            &flags, RTFieldAccess::ATTRIBUTE, "attribute", &first);
+        printFieldOrReferenceFlag(
+            &flags, RTFieldAccess::PROPERTY, "property", &first);
+        printFieldOrReferenceFlag(&flags, RTFieldAccess::CONST, "const", &first);
+        printFieldOrReferenceFlag(
+            &flags, RTFieldAccess::READWRITE, "readwrite", &first);
+        printFieldOrReferenceFlag(
+            &flags, RTFieldAccess::PARAMETERIZED_TYPE, "parameterized type", &first);
+        printFieldOrReferenceFlag(
+            &flags, RTFieldAccess::PUBLISHED, "published", &first);
+        if (flags != RTFieldAccess::NONE) {
+            if (!first) {
+                printf("|");
+            }
+            printf("<invalid (0x%04X)>", static_cast< unsigned int >(flags));
+        }
+    }
+}
+
+void dumpType(typereg::Reader const & reader, OString const & indent) {
+    if (reader.isValid()) {
+        printf("version: %ld\n", static_cast< long >(reader.getVersion()));
+        printf("%sdocumentation: ", indent.getStr());
+        printString(reader.getDocumentation());
+        printf("\n");
+        printf("%sfile name: ", indent.getStr());
+        printString(reader.getFileName());
+        printf("\n");
+        printf("%stype class: ", indent.getStr());
+        if (reader.isPublished()) {
+            printf("published ");
+        }
+        switch (reader.getTypeClass()) {
+        case RT_TYPE_INTERFACE:
+            printf("interface");
+            break;
+
+        case RT_TYPE_MODULE:
+            printf("module");
+            break;
+
+        case RT_TYPE_STRUCT:
+            printf("struct");
+            break;
+
+        case RT_TYPE_ENUM:
+            printf("enum");
+            break;
+
+        case RT_TYPE_EXCEPTION:
+            printf("exception");
+            break;
+
+        case RT_TYPE_TYPEDEF:
+            printf("typedef");
+            break;
+
+        case RT_TYPE_SERVICE:
+            printf("service");
+            break;
+
+        case RT_TYPE_SINGLETON:
+            printf("singleton");
+            break;
+
+        case RT_TYPE_CONSTANTS:
+            printf("constants");
+            break;
+
+        default:
+            printf(
+                "<invalid (%ld)>", static_cast< long >(reader.getTypeClass()));
+            break;
+        }
+        printf("\n");
+        printf("%stype name: ", indent.getStr());
+        printString(reader.getTypeName());
+        printf("\n");
+        printf(
+            "%ssuper type count: %u\n", indent.getStr(),
+            static_cast< unsigned int >(reader.getSuperTypeCount()));
+        for (sal_uInt16 i = 0; i < reader.getSuperTypeCount(); ++i) {
+            printf(
+                "%ssuper type name %u: ", indent.getStr(),
+                static_cast< unsigned int >(i));
+            printString(reader.getSuperTypeName(i));
+            printf("\n");
+        }
+        printf(
+            "%sfield count: %u\n", indent.getStr(),
+            static_cast< unsigned int >(reader.getFieldCount()));
+        for (sal_uInt16 i = 0; i < reader.getFieldCount(); ++i) {
+            printf(
+                "%sfield %u:\n", indent.getStr(),
+                static_cast< unsigned int >(i));
+            printf("%s    documentation: ", indent.getStr());
+            printString(reader.getFieldDocumentation(i));
+            printf("\n");
+            printf("%s    file name: ", indent.getStr());
+            printString(reader.getFieldFileName(i));
+            printf("\n");
+            printf("%s    flags: ", indent.getStr());
+            printFieldOrReferenceFlags(reader.getFieldFlags(i));
+            printf("\n");
+            printf("%s    name: ", indent.getStr());
+            printString(reader.getFieldName(i));
+            printf("\n");
+            printf("%s    type name: ", indent.getStr());
+            printString(reader.getFieldTypeName(i));
+            printf("\n");
+            printf("%s    value: ", indent.getStr());
+            RTConstValue value(reader.getFieldValue(i));
+            switch (value.m_type) {
+            case RT_TYPE_NONE:
+                printf("none");
+                break;
+
+            case RT_TYPE_BOOL:
+                printf("boolean %s", value.m_value.aBool ? "true" : "false");
+                break;
+
+            case RT_TYPE_BYTE:
+                printf("byte %d", static_cast< int >(value.m_value.aByte));
+                break;
+
+            case RT_TYPE_INT16:
+                printf("short %d", static_cast< int >(value.m_value.aShort));
+                break;
+
+            case RT_TYPE_UINT16:
+                printf(
+                    "unsigned short %u",
+                    static_cast< unsigned int >(value.m_value.aUShort));
+                break;
+
+            case RT_TYPE_INT32:
+                printf("long %ld", static_cast< long >(value.m_value.aLong));
+                break;
+
+            case RT_TYPE_UINT32:
+                printf(
+                    "unsigned long %lu",
+                    static_cast< unsigned long >(value.m_value.aULong));
+                break;
+
+            case RT_TYPE_INT64:
+                // TODO: no portable way to print hyper values
+                printf("hyper");
+                break;
+
+            case RT_TYPE_UINT64:
+                // TODO: no portable way to print unsigned hyper values
+                printf("unsigned hyper");
+                break;
+
+            case RT_TYPE_FLOAT:
+                // TODO: no portable way to print float values
+                printf("float");
+                break;
+
+            case RT_TYPE_DOUBLE:
+                // TODO: no portable way to print double values
+                printf("double");
+                break;
+
+            case RT_TYPE_STRING:
+                printf("string ");
+                printString(value.m_value.aString);
+                break;
+
+            default:
+                printf("<invalid (%ld)>", static_cast< long >(value.m_type));
+                break;
+            }
+            printf("\n");
+        }
+        printf(
+            "%smethod count: %u\n", indent.getStr(),
+            static_cast< unsigned int >(reader.getMethodCount()));
+        for (sal_uInt16 i = 0; i < reader.getMethodCount(); ++i) {
+            printf(
+                "%smethod %u:\n", indent.getStr(),
+                static_cast< unsigned int >(i));
+            printf("%s    documentation: ", indent.getStr());
+            printString(reader.getMethodDocumentation(i));
+            printf("\n");
+            printf("%s    flags: ", indent.getStr());
+            switch (reader.getMethodFlags(i)) {
+            case RTMethodMode::ONEWAY:
+                printf("oneway");
+                break;
+
+            case RTMethodMode::TWOWAY:
+                printf("synchronous");
+                break;
+
+            case RTMethodMode::ATTRIBUTE_GET:
+                printf("attribute get");
+                break;
+
+            case RTMethodMode::ATTRIBUTE_SET:
+                printf("attribute set");
+                break;
+
+            default:
+                printf(
+                    "<invalid (%ld)>",
+                    static_cast< long >(reader.getMethodFlags(i)));
+                break;
+            }
+            printf("\n");
+            printf("%s    name: ", indent.getStr());
+            printString(reader.getMethodName(i));
+            printf("\n");
+            printf("%s    return type name: ", indent.getStr());
+            printString(reader.getMethodReturnTypeName(i));
+            printf("\n");
+            printf(
+                "%s    parameter count: %u\n", indent.getStr(),
+                static_cast< unsigned int >(reader.getMethodParameterCount(i)));
+            // coverity[tainted_data] - cid#1215304 unhelpfully warns about untrusted loop bound
+            for (sal_uInt16 j = 0; j < reader.getMethodParameterCount(i); ++j)
+            {
+                printf(
+                    "%s    parameter %u:\n", indent.getStr(),
+                    static_cast< unsigned int >(j));
+                printf("%s        flags: ", indent.getStr());
+                RTParamMode flags = reader.getMethodParameterFlags(i, j);
+                bool rest = (flags & RT_PARAM_REST) != 0;
+                switch (flags & ~RT_PARAM_REST) {
+                case RT_PARAM_IN:
+                    printf("in");
+                    break;
+
+                case RT_PARAM_OUT:
+                    printf("out");
+                    break;
+
+                case RT_PARAM_INOUT:
+                    printf("inout");
+                    break;
+
+                default:
+                    printf("<invalid (%ld)>", static_cast< long >(flags));
+                    rest = false;
+                    break;
+                }
+                if (rest) {
+                    printf("|rest");
+                }
+                printf("\n");
+                printf("%s        name: ", indent.getStr());
+                printString(reader.getMethodParameterName(i, j));
+                printf("\n");
+                printf("%s        type name: ", indent.getStr());
+                printString(reader.getMethodParameterTypeName(i, j));
+                printf("\n");
+            }
+            printf(
+                "%s    exception count: %u\n", indent.getStr(),
+                static_cast< unsigned int >(reader.getMethodExceptionCount(i)));
+            // coverity[tainted_data] - cid#1215304 unhelpfully warns about untrusted loop bound
+            for (sal_uInt16 j = 0; j < reader.getMethodExceptionCount(i); ++j)
+            {
+                printf(
+                    "%s    exception type name %u: ", indent.getStr(),
+                    static_cast< unsigned int >(j));
+                printString(reader.getMethodExceptionTypeName(i, j));
+                printf("\n");
+            }
+        }
+        printf(
+            "%sreference count: %u\n", indent.getStr(),
+            static_cast< unsigned int >(reader.getReferenceCount()));
+        for (sal_uInt16 i = 0; i < reader.getReferenceCount(); ++i) {
+            printf(
+                "%sreference %u:\n", indent.getStr(),
+                static_cast< unsigned int >(i));
+            printf("%s    documentation: ", indent.getStr());
+            printString(reader.getReferenceDocumentation(i));
+            printf("\n");
+            printf("%s    flags: ", indent.getStr());
+            printFieldOrReferenceFlags(reader.getReferenceFlags(i));
+            printf("\n");
+            printf("%s    sort: ", indent.getStr());
+            switch (reader.getReferenceSort(i)) {
+            case RTReferenceType::SUPPORTS:
+                printf("supports");
+                break;
+
+            case RTReferenceType::EXPORTS:
+                printf("exports");
+                break;
+
+            case RTReferenceType::TYPE_PARAMETER:
+                printf("type parameter");
+                break;
+
+            default:
+                printf(
+                    "<invalid (%ld)>",
+                    static_cast< long >(reader.getReferenceSort(i)));
+                break;
+            }
+            printf("\n");
+            printf("%s    type name: ", indent.getStr());
+            printString(reader.getReferenceTypeName(i));
+            printf("\n");
+        }
+    } else {
+        printf("<invalid>\n");
+    }
+}
+
+}
+
+ORegistry::ORegistry()
+    : m_refCount(1)
+    , m_readOnly(false)
+    , m_isOpen(false)
+{
+}
+
+ORegistry::~ORegistry()
+{
+    ORegKey* pRootKey = m_openKeyTable[ROOT];
+    if (pRootKey != nullptr)
+        (void) releaseKey(pRootKey);
+
+    if (m_file.isValid())
+        m_file.close();
+}
+
+RegError ORegistry::initRegistry(const OUString& regName, RegAccessMode accessMode, bool bCreate)
+{
+    RegError eRet = RegError::INVALID_REGISTRY;
+    OStoreFile      rRegFile;
+    storeAccessMode sAccessMode = storeAccessMode::ReadWrite;
+    storeError      errCode;
+
+    if (bCreate)
+    {
+        sAccessMode = storeAccessMode::Create;
+    }
+    else if (accessMode & RegAccessMode::READONLY)
+    {
+        sAccessMode = storeAccessMode::ReadOnly;
+        m_readOnly = true;
+    }
+
+    if (regName.isEmpty() &&
+        storeAccessMode::Create == sAccessMode)
+    {
+        errCode = rRegFile.createInMemory();
+    }
+    else
+    {
+        errCode = rRegFile.create(regName, sAccessMode);
+    }
+
+    if (errCode)
+    {
+        switch (errCode)
+        {
+            case store_E_NotExists:
+                eRet = RegError::REGISTRY_NOT_EXISTS;
+                break;
+            case store_E_LockingViolation:
+                eRet = RegError::CANNOT_OPEN_FOR_READWRITE;
+                break;
+            default:
+                eRet = RegError::INVALID_REGISTRY;
+                break;
+        }
+    }
+    else
+    {
+        OStoreDirectory rStoreDir;
+        storeError _err = rStoreDir.create(rRegFile, OUString(), OUString(), sAccessMode);
+
+        if (_err == store_E_None)
+        {
+            m_file = rRegFile;
+            m_name = regName;
+            m_isOpen = true;
+
+            m_openKeyTable[ROOT] = new ORegKey(ROOT, this);
+            eRet = RegError::NO_ERROR;
+        }
+        else
+            eRet = RegError::INVALID_REGISTRY;
+    }
+
+    return eRet;
+}
+
+RegError ORegistry::closeRegistry()
+{
+    REG_GUARD(m_mutex);
+
+    if (m_file.isValid())
+    {
+        (void) releaseKey(m_openKeyTable[ROOT]);
+        m_file.close();
+        m_isOpen = false;
+        return RegError::NO_ERROR;
+    } else
+    {
+        return RegError::REGISTRY_NOT_EXISTS;
+    }
+}
+
+RegError ORegistry::destroyRegistry(const OUString& regName)
+{
+    REG_GUARD(m_mutex);
+
+    if (!regName.isEmpty())
+    {
+        std::unique_ptr<ORegistry> pReg(new ORegistry());
+
+        if (pReg->initRegistry(regName, RegAccessMode::READWRITE) == RegError::NO_ERROR)
+        {
+            pReg.reset();
+
+            OUString systemName;
+            if (FileBase::getSystemPathFromFileURL(regName, systemName) != FileBase::E_None)
+                systemName = regName;
+
+            OString name(OUStringToOString(systemName, osl_getThreadTextEncoding()));
+            if (unlink(name.getStr()) != 0)
+            {
+                return RegError::DESTROY_REGISTRY_FAILED;
+            }
+        } else
+        {
+            return RegError::DESTROY_REGISTRY_FAILED;
+        }
+    } else
+    {
+        if (m_refCount != 1 || isReadOnly())
+        {
+            return RegError::DESTROY_REGISTRY_FAILED;
+        }
+
+        if (m_file.isValid())
+        {
+            releaseKey(m_openKeyTable[ROOT]);
+            m_file.close();
+            m_isOpen = false;
+
+            if (!m_name.isEmpty())
+            {
+                OUString systemName;
+                if (FileBase::getSystemPathFromFileURL(m_name, systemName) != FileBase::E_None)
+                    systemName = m_name;
+
+                OString name(OUStringToOString(systemName, osl_getThreadTextEncoding()));
+                if (unlink(name.getStr()) != 0)
+                {
+                    return RegError::DESTROY_REGISTRY_FAILED;
+                }
+            }
+        } else
+        {
+            return RegError::REGISTRY_NOT_EXISTS;
+        }
+    }
+
+    return RegError::NO_ERROR;
+}
+
+RegError ORegistry::acquireKey (RegKeyHandle hKey)
+{
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return RegError::INVALID_KEY;
+
+    REG_GUARD(m_mutex);
+    pKey->acquire();
+
+    return RegError::NO_ERROR;
+}
+
+RegError ORegistry::releaseKey (RegKeyHandle hKey)
+{
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return RegError::INVALID_KEY;
+
+    REG_GUARD(m_mutex);
+    if (pKey->release() == 0)
+    {
+        m_openKeyTable.erase(pKey->getName());
+        delete pKey;
+    }
+    return RegError::NO_ERROR;
+}
+
+RegError ORegistry::createKey(RegKeyHandle hKey, std::u16string_view keyName,
+                              RegKeyHandle* phNewKey)
+{
+    ORegKey*    pKey;
+
+    *phNewKey = nullptr;
+
+    if (keyName.empty())
+        return RegError::INVALID_KEYNAME;
+
+    REG_GUARD(m_mutex);
+
+    if (hKey)
+        pKey = static_cast<ORegKey*>(hKey);
+    else
+        pKey = m_openKeyTable[ROOT];
+
+    OUString sFullKeyName = pKey->getFullPath(keyName);
+
+    if (m_openKeyTable.count(sFullKeyName) > 0)
+    {
+        *phNewKey = m_openKeyTable[sFullKeyName];
+        static_cast<ORegKey*>(*phNewKey)->acquire();
+        static_cast<ORegKey*>(*phNewKey)->setDeleted(false);
+        return RegError::NO_ERROR;
+    }
+
+    OStoreDirectory rStoreDir;
+    OUStringBuffer  sFullPath(sFullKeyName.getLength()+16);
+    OUString        token;
+
+    sFullPath.append('/');
+
+    sal_Int32 nIndex = 0;
+    do
+    {
+        token = sFullKeyName.getToken(0, '/', nIndex);
+        if (!token.isEmpty())
+        {
+            if (rStoreDir.create(pKey->getStoreFile(), sFullPath.toString(), token, storeAccessMode::Create))
+            {
+                return RegError::CREATE_KEY_FAILED;
+            }
+
+            sFullPath.append(token);
+            sFullPath.append('/');
+        }
+    } while(nIndex != -1);
+
+
+    pKey = new ORegKey(sFullKeyName, this);
+    *phNewKey = pKey;
+    m_openKeyTable[sFullKeyName] = pKey;
+
+    return RegError::NO_ERROR;
+}
+
+RegError ORegistry::openKey(RegKeyHandle hKey, std::u16string_view keyName,
+                            RegKeyHandle* phOpenKey)
+{
+    ORegKey*        pKey;
+
+    *phOpenKey = nullptr;
+
+    if (keyName.empty())
+    {
+        return RegError::INVALID_KEYNAME;
+    }
+
+    REG_GUARD(m_mutex);
+
+    if (hKey)
+        pKey = static_cast<ORegKey*>(hKey);
+    else
+        pKey = m_openKeyTable[ROOT];
+
+    OUString path(pKey->getFullPath(keyName));
+    KeyMap::iterator i(m_openKeyTable.find(path));
+    if (i == m_openKeyTable.end()) {
+        sal_Int32 n = path.lastIndexOf('/') + 1;
+        switch (OStoreDirectory().create(
+                    pKey->getStoreFile(), path.copy(0, n), path.copy(n),
+                    isReadOnly() ? storeAccessMode::ReadOnly : storeAccessMode::ReadWrite))
+        {
+        case store_E_NotExists:
+            return RegError::KEY_NOT_EXISTS;
+        case store_E_WrongFormat:
+            return RegError::INVALID_KEY;
+        default:
+            break;
+        }
+
+        std::unique_ptr< ORegKey > p(new ORegKey(path, this));
+        i = m_openKeyTable.insert(std::make_pair(path, p.get())).first;
+        p.release();
+    } else {
+        i->second->acquire();
+    }
+    *phOpenKey = i->second;
+    return RegError::NO_ERROR;
+}
+
+RegError ORegistry::closeKey(RegKeyHandle hKey)
+{
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+
+    REG_GUARD(m_mutex);
+
+    OUString const aKeyName (pKey->getName());
+    if (m_openKeyTable.count(aKeyName) <= 0)
+        return RegError::KEY_NOT_OPEN;
+
+    if (pKey->isModified())
+    {
+        ORegKey * pRootKey = getRootKey();
+        if (pKey != pRootKey)
+        {
+            // propagate "modified" state to RootKey.
+            pRootKey->setModified();
+        }
+        else
+        {
+            // closing modified RootKey, flush registry file.
+            (void) m_file.flush();
+        }
+        pKey->setModified(false);
+        (void) releaseKey(pRootKey);
+    }
+
+    return releaseKey(pKey);
+}
+
+RegError ORegistry::deleteKey(RegKeyHandle hKey, std::u16string_view keyName)
+{
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (keyName.empty())
+        return RegError::INVALID_KEYNAME;
+
+    REG_GUARD(m_mutex);
+
+    if (!pKey)
+        pKey = m_openKeyTable[ROOT];
+
+    OUString sFullKeyName(pKey->getFullPath(keyName));
+    return eraseKey(m_openKeyTable[ROOT], sFullKeyName);
+}
+
+RegError ORegistry::eraseKey(ORegKey* pKey, std::u16string_view keyName)
+{
+    RegError _ret = RegError::NO_ERROR;
+
+    if (keyName.empty())
+    {
+        return RegError::INVALID_KEYNAME;
+    }
+
+    OUString     sFullKeyName(pKey->getName());
+    OUString     sFullPath(sFullKeyName);
+    OUString     sRelativKey;
+    size_t    lastIndex = keyName.rfind('/');
+
+    if (lastIndex != std::u16string_view::npos)
+    {
+        sRelativKey += keyName.substr(lastIndex + 1);
+
+        if (sFullKeyName.getLength() > 1)
+            sFullKeyName += keyName;
+        else
+            sFullKeyName += keyName.substr(1);
+
+        sFullPath = sFullKeyName.copy(0, keyName.rfind('/') + 1);
+    } else
+    {
+        if (sFullKeyName.getLength() > 1)
+            sFullKeyName += ROOT;
+
+        sRelativKey += keyName;
+        sFullKeyName += keyName;
+
+        if (sFullPath.getLength() > 1)
+            sFullPath += ROOT;
+    }
+
+    ORegKey* pOldKey = nullptr;
+    _ret = pKey->openKey(keyName, reinterpret_cast<RegKeyHandle*>(&pOldKey));
+    if (_ret != RegError::NO_ERROR)
+        return _ret;
+
+    _ret = deleteSubkeysAndValues(pOldKey);
+    if (_ret != RegError::NO_ERROR)
+    {
+        pKey->closeKey(pOldKey);
+        return _ret;
+    }
+
+    OUString tmpName = sRelativKey + ROOT;
+
+    OStoreFile sFile(pKey->getStoreFile());
+    if (sFile.isValid() && sFile.remove(sFullPath, tmpName))
+    {
+        return RegError::DELETE_KEY_FAILED;
+    }
+    pOldKey->setModified();
+
+    // set flag deleted !!!
+    pOldKey->setDeleted(true);
+
+    return pKey->closeKey(pOldKey);
+}
+
+RegError ORegistry::deleteSubkeysAndValues(ORegKey* pKey)
+{
+    OStoreDirectory::iterator   iter;
+    RegError                    _ret = RegError::NO_ERROR;
+    OStoreDirectory             rStoreDir(pKey->getStoreDir());
+    storeError                  _err = rStoreDir.first(iter);
+
+    while (_err == store_E_None)
+    {
+        OUString const keyName(iter.m_pszName, iter.m_nLength);
+
+        if (iter.m_nAttrib & STORE_ATTRIB_ISDIR)
+        {
+            _ret = eraseKey(pKey, keyName);
+            if (_ret != RegError::NO_ERROR)
+                return _ret;
+        }
+        else
+        {
+            OUString sFullPath(pKey->getName());
+
+            if (sFullPath.getLength() > 1)
+                sFullPath += ROOT;
+
+            if (const_cast<OStoreFile&>(pKey->getStoreFile()).remove(sFullPath, keyName))
+            {
+                return RegError::DELETE_VALUE_FAILED;
+            }
+            pKey->setModified();
+        }
+
+        _err = rStoreDir.next(iter);
+    }
+
+    return RegError::NO_ERROR;
+}
+
+RegError ORegistry::loadKey(RegKeyHandle hKey, const OUString& regFileName,
+                            bool bWarnings, bool bReport)
+{
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+
+    ORegistry aReg;
+    RegError _ret = aReg.initRegistry(regFileName, RegAccessMode::READONLY);
+    if (_ret != RegError::NO_ERROR)
+        return _ret;
+    ORegKey* pRootKey = aReg.getRootKey();
+
+    REG_GUARD(m_mutex);
+
+    OStoreDirectory::iterator   iter;
+    OStoreDirectory             rStoreDir(pRootKey->getStoreDir());
+    storeError                  _err = rStoreDir.first(iter);
+
+    while (_err == store_E_None)
+    {
+        OUString const keyName(iter.m_pszName, iter.m_nLength);
+
+        if (iter.m_nAttrib & STORE_ATTRIB_ISDIR)
+        {
+            _ret = loadAndSaveKeys(pKey, pRootKey, keyName, 0, bWarnings, bReport);
+        }
+        else
+        {
+            _ret = loadAndSaveValue(pKey, pRootKey, keyName, 0, bWarnings, bReport);
+        }
+
+        if (_ret == RegError::MERGE_ERROR)
+            break;
+        if (_ret == RegError::MERGE_CONFLICT && bWarnings)
+            break;
+
+        _err = rStoreDir.next(iter);
+    }
+
+    rStoreDir = OStoreDirectory();
+    (void) aReg.releaseKey(pRootKey);
+    return _ret;
+}
+
+RegError ORegistry::loadAndSaveValue(ORegKey* pTargetKey,
+                                     ORegKey const * pSourceKey,
+                                     const OUString& valueName,
+                                     sal_uInt32 nCut,
+                                     bool bWarnings,
+                                     bool bReport)
+{
+    OStoreStream    rValue;
+    RegValueType    valueType;
+    sal_uInt32      valueSize;
+    sal_uInt32      nSize;
+    storeAccessMode sourceAccess = storeAccessMode::ReadWrite;
+    OUString        sTargetPath(pTargetKey->getName());
+    OUString        sSourcePath(pSourceKey->getName());
+
+    if (pSourceKey->isReadOnly())
+    {
+        sourceAccess = storeAccessMode::ReadOnly;
+    }
+
+    if (nCut)
+    {
+        sTargetPath = sSourcePath.copy(nCut);
+    } else
+    {
+        if (sTargetPath.getLength() > 1)
+        {
+            if (sSourcePath.getLength() > 1)
+                sTargetPath += sSourcePath;
+        } else
+            sTargetPath = sSourcePath;
+    }
+
+    if (sTargetPath.getLength() > 1) sTargetPath += ROOT;
+    if (sSourcePath.getLength() > 1) sSourcePath += ROOT;
+
+    if (rValue.create(pSourceKey->getStoreFile(), sSourcePath, valueName, sourceAccess))
+    {
+        return RegError::VALUE_NOT_EXISTS;
+    }
+
+    std::vector<sal_uInt8> aBuffer(VALUE_HEADERSIZE);
+
+    sal_uInt32  rwBytes;
+    if (rValue.readAt(0, aBuffer.data(), VALUE_HEADERSIZE, rwBytes))
+    {
+        return RegError::INVALID_VALUE;
+    }
+    if (rwBytes != VALUE_HEADERSIZE)
+    {
+        return RegError::INVALID_VALUE;
+    }
+
+    RegError _ret = RegError::NO_ERROR;
+    sal_uInt8   type = aBuffer[0];
+    valueType = static_cast<RegValueType>(type);
+    readUINT32(aBuffer.data() + VALUE_TYPEOFFSET, valueSize);
+
+    nSize = VALUE_HEADERSIZE + valueSize;
+    aBuffer.resize(nSize);
+
+    if (rValue.readAt(0, aBuffer.data(), nSize, rwBytes))
+    {
+        return RegError::INVALID_VALUE;
+    }
+    if (rwBytes != nSize)
+    {
+        return RegError::INVALID_VALUE;
+    }
+
+    OStoreFile  rTargetFile(pTargetKey->getStoreFile());
+
+    if (!rValue.create(rTargetFile, sTargetPath, valueName, storeAccessMode::ReadWrite))
+    {
+        if (valueType == RegValueType::BINARY)
+        {
+            _ret = checkBlop(
+                rValue, sTargetPath, valueSize, aBuffer.data() + VALUE_HEADEROFFSET,
+                bReport);
+            if (_ret != RegError::NO_ERROR)
+            {
+                if (_ret == RegError::MERGE_ERROR ||
+                    (_ret == RegError::MERGE_CONFLICT && bWarnings))
+                {
+                    return _ret;
+                }
+            } else
+            {
+                return _ret;
+            }
+        }
+    }
+
+    if (rValue.create(rTargetFile, sTargetPath, valueName, storeAccessMode::Create))
+    {
+        return RegError::INVALID_VALUE;
+    }
+    if (rValue.writeAt(0, aBuffer.data(), nSize, rwBytes))
+    {
+        return RegError::INVALID_VALUE;
+    }
+
+    if (rwBytes != nSize)
+    {
+        return RegError::INVALID_VALUE;
+    }
+    pTargetKey->setModified();
+
+    return _ret;
+}
+
+RegError ORegistry::checkBlop(OStoreStream& rValue,
+                              std::u16string_view sTargetPath,
+                              sal_uInt32 srcValueSize,
+                              sal_uInt8 const * pSrcBuffer,
+                              bool bReport)
+{
+    RegistryTypeReader reader(pSrcBuffer, srcValueSize);
+
+    if (reader.getTypeClass() == RT_TYPE_INVALID)
+    {
+        return RegError::INVALID_VALUE;
+    }
+
+    std::vector<sal_uInt8> aBuffer(VALUE_HEADERSIZE);
+    sal_uInt32      rwBytes;
+    OString         targetPath(OUStringToOString(sTargetPath, RTL_TEXTENCODING_UTF8));
+
+    if (!rValue.readAt(0, aBuffer.data(), VALUE_HEADERSIZE, rwBytes) &&
+        (rwBytes == VALUE_HEADERSIZE))
+    {
+        sal_uInt8 type = aBuffer[0];
+        RegValueType valueType = static_cast<RegValueType>(type);
+        sal_uInt32      valueSize;
+        readUINT32(aBuffer.data() + VALUE_TYPEOFFSET, valueSize);
+
+        if (valueType == RegValueType::BINARY)
+        {
+            aBuffer.resize(valueSize);
+            if (!rValue.readAt(VALUE_HEADEROFFSET, aBuffer.data(), valueSize, rwBytes) &&
+                (rwBytes == valueSize))
+            {
+                RegistryTypeReader reader2(aBuffer.data(), valueSize);
+
+                if ((reader.getTypeClass() != reader2.getTypeClass())
+                    || reader2.getTypeClass() == RT_TYPE_INVALID)
+                {
+                    if (bReport)
+                    {
+                        fprintf(stdout, "ERROR: values of blop from key \"%s\" has different types.\n",
+                                targetPath.getStr());
+                    }
+                    return RegError::MERGE_ERROR;
+                }
+
+                if (reader.getTypeClass() == RT_TYPE_MODULE)
+                {
+                    if (reader.getFieldCount() > 0 &&
+                        reader2.getFieldCount() > 0)
+                    {
+                        mergeModuleValue(rValue, reader, reader2);
+
+                        return RegError::NO_ERROR;
+                    } else
+                    if (reader2.getFieldCount() > 0)
+                    {
+                        return RegError::NO_ERROR;
+                    } else
+                    {
+                        return RegError::MERGE_CONFLICT;
+                    }
+                } else
+                {
+                    if (bReport)
+                    {
+                        fprintf(stderr, "WARNING: value of key \"%s\" already exists.\n",
+                                targetPath.getStr());
+                    }
+                    return RegError::MERGE_CONFLICT;
+                }
+            } else
+            {
+                if (bReport)
+                {
+                    fprintf(stderr, "ERROR: values of key \"%s\" contains bad data.\n",
+                            targetPath.getStr());
+                }
+                return RegError::MERGE_ERROR;
+            }
+        } else
+        {
+            if (bReport)
+            {
+                fprintf(stderr, "ERROR: values of key \"%s\" has different types.\n",
+                        targetPath.getStr());
+            }
+            return RegError::MERGE_ERROR;
+        }
+    } else
+    {
+        return RegError::INVALID_VALUE;
+    }
+}
+
+static sal_uInt32 checkTypeReaders(RegistryTypeReader const & reader1,
+                                   RegistryTypeReader const & reader2,
+                                   std::set< OUString >& nameSet)
+{
+    sal_uInt32 count=0;
+    for (sal_uInt32 i=0 ; i < reader1.getFieldCount(); i++)
+    {
+        nameSet.insert(reader1.getFieldName(i));
+        count++;
+    }
+    for (sal_uInt32 i=0 ; i < reader2.getFieldCount(); i++)
+    {
+        if (nameSet.insert(reader2.getFieldName(i)).second)
+            count++;
+    }
+    return count;
+}
+
+RegError ORegistry::mergeModuleValue(OStoreStream& rTargetValue,
+                                     RegistryTypeReader const & reader,
+                                     RegistryTypeReader const & reader2)
+{
+    std::set< OUString > nameSet;
+    sal_uInt32 count = checkTypeReaders(reader, reader2, nameSet);
+
+    if (count == reader.getFieldCount())
+        return RegError::NO_ERROR;
+
+    sal_uInt16 index = 0;
+
+    RegistryTypeWriter writer(reader.getTypeClass(),
+                              reader.getTypeName(),
+                              reader.getSuperTypeName(),
+                              static_cast<sal_uInt16>(count));
+
+    for (sal_uInt32 i=0 ; i < reader.getFieldCount(); i++)
+    {
+        writer.setFieldData(index,
+                           reader.getFieldName(i),
+                           reader.getFieldType(i),
+                           reader.getFieldDoku(i),
+                           reader.getFieldFileName(i),
+                           reader.getFieldAccess(i),
+                           reader.getFieldConstValue(i));
+        index++;
+    }
+    for (sal_uInt32 i=0 ; i < reader2.getFieldCount(); i++)
+    {
+        if (nameSet.find(reader2.getFieldName(i)) == nameSet.end())
+        {
+            writer.setFieldData(index,
+                               reader2.getFieldName(i),
+                               reader2.getFieldType(i),
+                               reader2.getFieldDoku(i),
+                               reader2.getFieldFileName(i),
+                               reader2.getFieldAccess(i),
+                               reader2.getFieldConstValue(i));
+            index++;
+        }
+    }
+
+    const sal_uInt8*    pBlop = writer.getBlop();
+    sal_uInt32          aBlopSize = writer.getBlopSize();
+
+    sal_uInt8   type = sal_uInt8(RegValueType::BINARY);
+    std::vector<sal_uInt8> aBuffer(VALUE_HEADERSIZE + aBlopSize);
+
+    memcpy(aBuffer.data(), &type, 1);
+    writeUINT32(aBuffer.data() + VALUE_TYPEOFFSET, aBlopSize);
+    memcpy(aBuffer.data() + VALUE_HEADEROFFSET, pBlop, aBlopSize);
+
+    sal_uInt32  rwBytes;
+    if (rTargetValue.writeAt(0, aBuffer.data(), VALUE_HEADERSIZE+aBlopSize, rwBytes))
+    {
+        return RegError::INVALID_VALUE;
+    }
+
+    if (rwBytes != VALUE_HEADERSIZE+aBlopSize)
+    {
+        return RegError::INVALID_VALUE;
+    }
+    return RegError::NO_ERROR;
+}
+
+RegError ORegistry::loadAndSaveKeys(ORegKey* pTargetKey,
+                                    ORegKey* pSourceKey,
+                                    const OUString& keyName,
+                                    sal_uInt32 nCut,
+                                    bool bWarnings,
+                                    bool bReport)
+{
+    RegError    _ret = RegError::NO_ERROR;
+    OUString    sRelPath(pSourceKey->getName().copy(nCut));
+    OUString    sFullPath;
+
+    if(pTargetKey->getName().getLength() > 1)
+        sFullPath += pTargetKey->getName();
+    sFullPath += sRelPath;
+    if (sRelPath.getLength() > 1 || sFullPath.isEmpty())
+        sFullPath += ROOT;
+
+    OUString sFullKeyName = sFullPath + keyName;
+
+    OStoreDirectory rStoreDir;
+    if (rStoreDir.create(pTargetKey->getStoreFile(), sFullPath, keyName, storeAccessMode::Create))
+    {
+        return RegError::CREATE_KEY_FAILED;
+    }
+
+    if (m_openKeyTable.count(sFullKeyName) > 0)
+    {
+        m_openKeyTable[sFullKeyName]->setDeleted(false);
+    }
+
+    ORegKey* pTmpKey = nullptr;
+    _ret = pSourceKey->openKey(keyName, reinterpret_cast<RegKeyHandle*>(&pTmpKey));
+    if (_ret != RegError::NO_ERROR)
+        return _ret;
+
+    OStoreDirectory::iterator   iter;
+    OStoreDirectory             rTmpStoreDir(pTmpKey->getStoreDir());
+    storeError                  _err = rTmpStoreDir.first(iter);
+
+    while (_err == store_E_None)
+    {
+        OUString const sName(iter.m_pszName, iter.m_nLength);
+
+        if (iter.m_nAttrib & STORE_ATTRIB_ISDIR)
+        {
+            _ret = loadAndSaveKeys(pTargetKey, pTmpKey,
+                                   sName, nCut, bWarnings, bReport);
+        } else
+        {
+            _ret = loadAndSaveValue(pTargetKey, pTmpKey,
+                                    sName, nCut, bWarnings, bReport);
+        }
+
+        if (_ret == RegError::MERGE_ERROR)
+            break;
+        if (_ret == RegError::MERGE_CONFLICT && bWarnings)
+            break;
+
+        _err = rTmpStoreDir.next(iter);
+    }
+
+    pSourceKey->releaseKey(pTmpKey);
+    return _ret;
+}
+
+ORegKey* ORegistry::getRootKey()
+{
+    m_openKeyTable[ROOT]->acquire();
+    return m_openKeyTable[ROOT];
+}
+
+RegError ORegistry::dumpRegistry(RegKeyHandle hKey) const
+{
+    ORegKey                     *pKey = static_cast<ORegKey*>(hKey);
+    OUString                    sName;
+    RegError                    _ret = RegError::NO_ERROR;
+    OStoreDirectory::iterator   iter;
+    OStoreDirectory             rStoreDir(pKey->getStoreDir());
+    storeError                  _err = rStoreDir.first(iter);
+
+    OString regName(OUStringToOString(getName(), osl_getThreadTextEncoding()));
+    OString keyName(OUStringToOString(pKey->getName(), RTL_TEXTENCODING_UTF8));
+    fprintf(stdout, "Registry \"%s\":\n\n%s\n", regName.getStr(), keyName.getStr());
+
+    while (_err == store_E_None)
+    {
+        sName = OUString(iter.m_pszName, iter.m_nLength);
+
+        if (iter.m_nAttrib & STORE_ATTRIB_ISDIR)
+        {
+            _ret = dumpKey(pKey->getName(), sName, 1);
+        } else
+        {
+            _ret = dumpValue(pKey->getName(), sName, 1);
+        }
+
+        if (_ret != RegError::NO_ERROR)
+        {
+            return _ret;
+        }
+
+        _err = rStoreDir.next(iter);
+    }
+
+    return RegError::NO_ERROR;
+}
+
+RegError ORegistry::dumpValue(const OUString& sPath, const OUString& sName, sal_Int16 nSpc) const
+{
+    OStoreStream    rValue;
+    sal_uInt32      valueSize;
+    RegValueType    valueType;
+    OUString        sFullPath(sPath);
+    OString         sIndent;
+    storeAccessMode accessMode = storeAccessMode::ReadWrite;
+
+    if (isReadOnly())
+    {
+        accessMode = storeAccessMode::ReadOnly;
+    }
+
+    for (int i= 0; i < nSpc; i++) sIndent += " ";
+
+    if (sFullPath.getLength() > 1)
+    {
+        sFullPath += ROOT;
+    }
+    if (rValue.create(m_file, sFullPath, sName, accessMode))
+    {
+        return RegError::VALUE_NOT_EXISTS;
+    }
+
+    std::vector<sal_uInt8> aBuffer(VALUE_HEADERSIZE);
+
+    sal_uInt32  rwBytes;
+    if (rValue.readAt(0, aBuffer.data(), VALUE_HEADERSIZE, rwBytes))
+    {
+        return RegError::INVALID_VALUE;
+    }
+    if (rwBytes != (VALUE_HEADERSIZE))
+    {
+        return RegError::INVALID_VALUE;
+    }
+
+    sal_uInt8 type = aBuffer[0];
+    valueType = static_cast<RegValueType>(type);
+    readUINT32(aBuffer.data() + VALUE_TYPEOFFSET, valueSize);
+
+    aBuffer.resize(valueSize);
+    if (rValue.readAt(VALUE_HEADEROFFSET, aBuffer.data(), valueSize, rwBytes))
+    {
+        return RegError::INVALID_VALUE;
+    }
+    if (rwBytes != valueSize)
+    {
+        return RegError::INVALID_VALUE;
+    }
+
+    const char* indent = sIndent.getStr();
+    switch (valueType)
+    {
+        case RegValueType::NOT_DEFINED:
+            fprintf(stdout, "%sValue: Type = VALUETYPE_NOT_DEFINED\n", indent);
+            break;
+        case RegValueType::LONG:
+            {
+                fprintf(stdout, "%sValue: Type = RegValueType::LONG\n", indent);
+                fprintf(
+                    stdout, "%s       Size = %lu\n", indent,
+                    sal::static_int_cast< unsigned long >(valueSize));
+                fprintf(stdout, "%s       Data = ", indent);
+
+                sal_Int32 value;
+                readINT32(aBuffer.data(), value);
+                fprintf(stdout, "%ld\n", sal::static_int_cast< long >(value));
+            }
+            break;
+        case RegValueType::STRING:
+            {
+                char* value = static_cast<char*>(std::malloc(valueSize));
+                readUtf8(aBuffer.data(), value, valueSize);
+                fprintf(stdout, "%sValue: Type = RegValueType::STRING\n", indent);
+                fprintf(
+                    stdout, "%s       Size = %lu\n", indent,
+                    sal::static_int_cast< unsigned long >(valueSize));
+                fprintf(stdout, "%s       Data = \"%s\"\n", indent, value);
+                std::free(value);
+            }
+            break;
+        case RegValueType::UNICODE:
+            {
+                sal_uInt32 size = (valueSize / 2) * sizeof(sal_Unicode);
+                fprintf(stdout, "%sValue: Type = RegValueType::UNICODE\n", indent);
+                fprintf(
+                    stdout, "%s       Size = %lu\n", indent,
+                    sal::static_int_cast< unsigned long >(valueSize));
+                fprintf(stdout, "%s       Data = ", indent);
+
+                std::unique_ptr<sal_Unicode[]> value(new sal_Unicode[size]);
+                readString(aBuffer.data(), value.get(), size);
+
+                OString uStr(value.get(), rtl_ustr_getLength(value.get()), RTL_TEXTENCODING_UTF8);
+                fprintf(stdout, "L\"%s\"\n", uStr.getStr());
+            }
+            break;
+        case RegValueType::BINARY:
+            {
+                fprintf(stdout, "%sValue: Type = RegValueType::BINARY\n", indent);
+                fprintf(
+                    stdout, "%s       Size = %lu\n", indent,
+                    sal::static_int_cast< unsigned long >(valueSize));
+                fprintf(stdout, "%s       Data = ", indent);
+                dumpType(
+                    typereg::Reader(aBuffer.data(), valueSize),
+                    sIndent + "              ");
+            }
+            break;
+        case RegValueType::LONGLIST:
+            {
+                sal_uInt32 offset = 4; // initial 4 bytes for the size of the array
+                sal_uInt32 len = 0;
+
+                readUINT32(aBuffer.data(), len);
+
+                fprintf(stdout, "%sValue: Type = RegValueType::LONGLIST\n", indent);
+                fprintf(
+                    stdout, "%s       Size = %lu\n", indent,
+                    sal::static_int_cast< unsigned long >(valueSize));
+                fprintf(
+                    stdout, "%s       Len  = %lu\n", indent,
+                    sal::static_int_cast< unsigned long >(len));
+                fprintf(stdout, "%s       Data = ", indent);
+
+                sal_Int32 longValue;
+                for (sal_uInt32 i=0; i < len; i++)
+                {
+                    readINT32(aBuffer.data() + offset, longValue);
+
+                    if (offset > 4)
+                        fprintf(stdout, "%s              ", indent);
+
+                    fprintf(
+                        stdout, "%lu = %ld\n",
+                        sal::static_int_cast< unsigned long >(i),
+                        sal::static_int_cast< long >(longValue));
+                    offset += 4; // 4 Bytes for sal_Int32
+                }
+            }
+            break;
+        case RegValueType::STRINGLIST:
+            {
+                sal_uInt32 offset = 4; // initial 4 bytes for the size of the array
+                sal_uInt32 sLen = 0;
+                sal_uInt32 len = 0;
+
+                readUINT32(aBuffer.data(), len);
+
+                fprintf(stdout, "%sValue: Type = RegValueType::STRINGLIST\n", indent);
+                fprintf(
+                    stdout, "%s       Size = %lu\n", indent,
+                    sal::static_int_cast< unsigned long >(valueSize));
+                fprintf(
+                    stdout, "%s       Len  = %lu\n", indent,
+                    sal::static_int_cast< unsigned long >(len));
+                fprintf(stdout, "%s       Data = ", indent);
+
+                for (sal_uInt32 i=0; i < len; i++)
+                {
+                    readUINT32(aBuffer.data() + offset, sLen);
+
+                    offset += 4; // 4 bytes (sal_uInt32) for the string size
+
+                    char *pValue = static_cast<char*>(std::malloc(sLen));
+                    readUtf8(aBuffer.data() + offset, pValue, sLen);
+
+                    if (offset > 8)
+                        fprintf(stdout, "%s              ", indent);
+
+                    fprintf(
+                        stdout, "%lu = \"%s\"\n",
+                        sal::static_int_cast< unsigned long >(i), pValue);
+                    std::free(pValue);
+                    offset += sLen;
+                }
+            }
+            break;
+        case RegValueType::UNICODELIST:
+            {
+                sal_uInt32 offset = 4; // initial 4 bytes for the size of the array
+                sal_uInt32 sLen = 0;
+                sal_uInt32 len = 0;
+
+                readUINT32(aBuffer.data(), len);
+
+                fprintf(stdout, "%sValue: Type = RegValueType::UNICODELIST\n", indent);
+                fprintf(
+                    stdout, "%s       Size = %lu\n", indent,
+                    sal::static_int_cast< unsigned long >(valueSize));
+                fprintf(
+                    stdout, "%s       Len  = %lu\n", indent,
+                    sal::static_int_cast< unsigned long >(len));
+                fprintf(stdout, "%s       Data = ", indent);
+
+                OString uStr;
+                for (sal_uInt32 i=0; i < len; i++)
+                {
+                    readUINT32(aBuffer.data() + offset, sLen);
+
+                    offset += 4; // 4 bytes (sal_uInt32) for the string size
+
+                    sal_Unicode *pValue = static_cast<sal_Unicode*>(std::malloc((sLen / 2) * sizeof(sal_Unicode)));
+                    readString(aBuffer.data() + offset, pValue, sLen);
+
+                    if (offset > 8)
+                        fprintf(stdout, "%s              ", indent);
+
+                    uStr = OString(pValue, rtl_ustr_getLength(pValue), RTL_TEXTENCODING_UTF8);
+                    fprintf(
+                        stdout, "%lu = L\"%s\"\n",
+                        sal::static_int_cast< unsigned long >(i),
+                        uStr.getStr());
+
+                    offset += sLen;
+
+                    std::free(pValue);
+                }
+            }
+            break;
+    }
+
+    fprintf(stdout, "\n");
+
+    return RegError::NO_ERROR;
+}
+
+RegError ORegistry::dumpKey(const OUString& sPath, const OUString& sName, sal_Int16 nSpace) const
+{
+    OStoreDirectory     rStoreDir;
+    OUString            sFullPath(sPath);
+    OString             sIndent;
+    storeAccessMode     accessMode = storeAccessMode::ReadWrite;
+    RegError            _ret = RegError::NO_ERROR;
+
+    if (isReadOnly())
+    {
+        accessMode = storeAccessMode::ReadOnly;
+    }
+
+    for (int i= 0; i < nSpace; i++) sIndent += " ";
+
+    if (sFullPath.getLength() > 1)
+        sFullPath += ROOT;
+
+    storeError _err = rStoreDir.create(m_file, sFullPath, sName, accessMode);
+
+    if (_err == store_E_NotExists)
+        return RegError::KEY_NOT_EXISTS;
+    else if (_err == store_E_WrongFormat)
+        return RegError::INVALID_KEY;
+
+    fprintf(stdout, "%s/ %s\n", sIndent.getStr(), OUStringToOString(sName, RTL_TEXTENCODING_UTF8).getStr());
+
+    OUString sSubPath(sFullPath);
+    OUString sSubName;
+    sSubPath += sName;
+
+    OStoreDirectory::iterator   iter;
+
+    _err = rStoreDir.first(iter);
+
+    while (_err == store_E_None)
+    {
+        sSubName = OUString(iter.m_pszName, iter.m_nLength);
+
+        if (iter.m_nAttrib & STORE_ATTRIB_ISDIR)
+        {
+            _ret = dumpKey(sSubPath, sSubName, nSpace+2);
+        } else
+        {
+            _ret = dumpValue(sSubPath, sSubName, nSpace+2);
+        }
+
+        if (_ret != RegError::NO_ERROR)
+        {
+            return _ret;
+        }
+
+        _err = rStoreDir.next(iter);
+    }
+
+    return RegError::NO_ERROR;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/registry/source/regimpl.hxx b/registry/source/regimpl.hxx
new file mode 100644
index 000000000..973a24986
--- /dev/null
+++ b/registry/source/regimpl.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_REGISTRY_SOURCE_REGIMPL_HXX
+#define INCLUDED_REGISTRY_SOURCE_REGIMPL_HXX
+
+#include <sal/config.h>
+
+#include <string_view>
+#include <unordered_map>
+
+#include <regapi.hxx>
+#include <registry/regtype.h>
+#include <rtl/ustring.hxx>
+#include <osl/mutex.hxx>
+#include <store/store.hxx>
+
+// 5 bytes = 1 (byte for the type) + 4 (bytes for the size of the data)
+#define VALUE_HEADERSIZE    5
+#define VALUE_TYPEOFFSET    1
+#define VALUE_HEADEROFFSET  5
+
+#define REG_GUARD(mutex) \
+    osl::Guard< osl::Mutex > aGuard( mutex );
+
+class ORegKey;
+class RegistryTypeReader;
+
+class ORegistry
+{
+public:
+    ORegistry();
+
+    sal_uInt32  acquire()
+        { return ++m_refCount; }
+
+    sal_uInt32  release()
+        { return --m_refCount; }
+
+    RegError    initRegistry(const OUString& name,
+                             RegAccessMode accessMode,
+                             bool bCreate = false);
+
+    RegError    closeRegistry();
+
+    RegError    destroyRegistry(const OUString& name);
+
+    RegError    acquireKey(RegKeyHandle hKey);
+    RegError    releaseKey(RegKeyHandle hKey);
+
+    RegError    createKey(RegKeyHandle hKey,
+                          std::u16string_view keyName,
+                          RegKeyHandle* phNewKey);
+
+    RegError    openKey(RegKeyHandle hKey,
+                        std::u16string_view keyName,
+                        RegKeyHandle* phOpenKey);
+
+    RegError    closeKey(RegKeyHandle hKey);
+
+    RegError    deleteKey(RegKeyHandle hKey, std::u16string_view keyName);
+
+    RegError    loadKey(RegKeyHandle hKey,
+                        const OUString& regFileName,
+                        bool bWarnings,
+                        bool bReport);
+
+    RegError    dumpRegistry(RegKeyHandle hKey) const;
+
+    ~ORegistry();
+
+    bool            isReadOnly() const
+        { return m_readOnly; }
+
+    bool            isOpen() const
+        { return m_isOpen; }
+
+    ORegKey*    getRootKey();
+
+    const store::OStoreFile& getStoreFile() const
+        { return m_file; }
+
+    const OUString&    getName() const
+        { return m_name; }
+
+    friend class ORegKey;
+
+private:
+    RegError    eraseKey(ORegKey* pKey, std::u16string_view keyName);
+
+    RegError    deleteSubkeysAndValues(ORegKey* pKey);
+
+    static RegError loadAndSaveValue(ORegKey* pTargetKey,
+                                 ORegKey const * pSourceKey,
+                                 const OUString& valueName,
+                                 sal_uInt32 nCut,
+                                 bool bWarnings,
+                                 bool bReport);
+
+    static RegError checkBlop(store::OStoreStream& rValue,
+                          std::u16string_view sTargetPath,
+                          sal_uInt32 srcValueSize,
+                          sal_uInt8 const * pSrcBuffer,
+                          bool bReport);
+
+    static RegError mergeModuleValue(store::OStoreStream& rTargetValue,
+                                 RegistryTypeReader const & reader,
+                                 RegistryTypeReader const & reader2);
+
+    RegError    loadAndSaveKeys(ORegKey* pTargetKey,
+                                ORegKey* pSourceKey,
+                                const OUString& keyName,
+                                sal_uInt32 nCut,
+                                bool bWarnings,
+                                bool bReport);
+
+    RegError    dumpValue(const OUString& sPath,
+                          const OUString& sName,
+                          sal_Int16 nSpace) const;
+
+    RegError    dumpKey(const OUString& sPath,
+                        const OUString& sName,
+                        sal_Int16 nSpace) const;
+
+    typedef std::unordered_map< OUString, ORegKey* > KeyMap;
+
+    sal_uInt32          m_refCount;
+    osl::Mutex          m_mutex;
+    bool                m_readOnly;
+    bool                m_isOpen;
+    OUString            m_name;
+    store::OStoreFile   m_file;
+    KeyMap              m_openKeyTable;
+
+    static constexpr OUStringLiteral ROOT { u"/" };
+};
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/registry/source/registry.cxx b/registry/source/registry.cxx
new file mode 100644
index 000000000..1727dfc11
--- /dev/null
+++ b/registry/source/registry.cxx
@@ -0,0 +1,393 @@
+/* -*- 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 <registry/registry.hxx>
+
+#include "keyimpl.hxx"
+#include "regimpl.hxx"
+#include "regkey.hxx"
+
+#if defined(_WIN32)
+#include <io.h>
+#endif
+
+extern "C" {
+
+
+//  acquire
+
+static void REGISTRY_CALLTYPE acquire(RegHandle hReg)
+{
+    ORegistry* pReg = static_cast<ORegistry*>(hReg);
+
+    if (pReg != nullptr)
+        pReg->acquire();
+}
+
+
+//  release
+
+static void REGISTRY_CALLTYPE release(RegHandle hReg)
+{
+    ORegistry* pReg = static_cast<ORegistry*>(hReg);
+
+    if (pReg && pReg->release() == 0)
+    {
+        delete pReg;
+        hReg = nullptr;
+    }
+}
+
+
+//  getName
+
+static RegError REGISTRY_CALLTYPE getName(RegHandle hReg, rtl_uString** pName)
+{
+    if (hReg)
+    {
+        ORegistry*  pReg = static_cast<ORegistry*>(hReg);
+        if ( pReg->isOpen() )
+        {
+            rtl_uString_assign(pName, pReg->getName().pData);
+            return RegError::NO_ERROR;
+        } else
+        {
+            rtl_uString_new(pName);
+            return RegError::REGISTRY_NOT_OPEN;
+        }
+    }
+
+    rtl_uString_new(pName);
+    return RegError::INVALID_REGISTRY;
+}
+
+
+//  isReadOnly
+
+static sal_Bool REGISTRY_CALLTYPE isReadOnly(RegHandle hReg)
+{
+    if (hReg)
+        return static_cast<ORegistry*>(hReg)->isReadOnly();
+    else
+        return false;
+}
+
+
+//  createRegistry
+
+static RegError REGISTRY_CALLTYPE createRegistry(rtl_uString* registryName,
+                                                 RegHandle* phRegistry)
+{
+    RegError ret;
+
+    ORegistry* pReg = new ORegistry();
+    if ((ret = pReg->initRegistry(registryName, RegAccessMode::READWRITE, true/*bCreate*/)) != RegError::NO_ERROR)
+    {
+        delete pReg;
+        *phRegistry = nullptr;
+        return ret;
+    }
+
+    *phRegistry = pReg;
+
+    return RegError::NO_ERROR;
+}
+
+
+//  openRootKey
+
+static RegError REGISTRY_CALLTYPE openRootKey(RegHandle hReg,
+                                              RegKeyHandle* phRootKey)
+{
+    ORegistry* pReg;
+
+    if (hReg)
+    {
+        pReg = static_cast<ORegistry*>(hReg);
+        if (!pReg->isOpen())
+            return RegError::REGISTRY_NOT_OPEN;
+    } else
+    {
+        phRootKey = nullptr;
+        return RegError::INVALID_REGISTRY;
+    }
+
+    *phRootKey = pReg->getRootKey();
+
+    return RegError::NO_ERROR;
+}
+
+
+//  openRegistry
+
+static RegError REGISTRY_CALLTYPE openRegistry(rtl_uString* registryName,
+                                               RegHandle* phRegistry,
+                                               RegAccessMode accessMode)
+{
+    RegError _ret;
+
+    ORegistry* pReg = new ORegistry();
+    if ((_ret = pReg->initRegistry(registryName, accessMode)) != RegError::NO_ERROR)
+    {
+        *phRegistry = nullptr;
+        delete pReg;
+        return _ret;
+    }
+
+
+    *phRegistry = pReg;
+
+    return RegError::NO_ERROR;
+}
+
+
+//  closeRegistry
+
+static RegError REGISTRY_CALLTYPE closeRegistry(RegHandle hReg)
+{
+    if (hReg)
+    {
+        ORegistry *pReg = static_cast<ORegistry*>(hReg);
+        if (!pReg->isOpen())
+            return RegError::REGISTRY_NOT_OPEN;
+
+        RegError ret = RegError::NO_ERROR;
+        if (pReg->release() == 0)
+        {
+            delete pReg;
+            hReg = nullptr;
+        }
+        else
+            ret = pReg->closeRegistry();
+
+        return ret;
+    } else
+    {
+        return RegError::INVALID_REGISTRY;
+    }
+}
+
+
+//  destroyRegistry
+
+static RegError REGISTRY_CALLTYPE destroyRegistry(RegHandle hReg,
+                                                  rtl_uString* registryName)
+{
+    if (hReg)
+    {
+        ORegistry *pReg = static_cast<ORegistry*>(hReg);
+        if (!pReg->isOpen())
+            return RegError::INVALID_REGISTRY;
+
+        RegError ret = pReg->destroyRegistry(registryName);
+        if (ret == RegError::NO_ERROR)
+        {
+            if (!registryName->length)
+            {
+                delete pReg;
+                hReg = nullptr;
+            }
+        }
+        return ret;
+    } else
+    {
+        return RegError::INVALID_REGISTRY;
+    }
+}
+
+
+//  mergeKey
+
+static RegError REGISTRY_CALLTYPE mergeKey(RegHandle hReg,
+                                              RegKeyHandle hKey,
+                                           rtl_uString* keyName,
+                                           rtl_uString* regFileName,
+                                           sal_Bool bWarnings,
+                                           sal_Bool bReport)
+{
+    ORegistry* pReg = static_cast< ORegistry* >(hReg);
+    if (!pReg)
+        return RegError::INVALID_REGISTRY;
+    if (!pReg->isOpen())
+        return RegError::REGISTRY_NOT_OPEN;
+
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return RegError::INVALID_KEY;
+    if (pKey->getRegistry() != pReg)
+        return RegError::INVALID_KEY;
+    if (pKey->isDeleted())
+        return RegError::INVALID_KEY;
+    if (pKey->isReadOnly())
+        return RegError::REGISTRY_READONLY;
+
+    if (keyName->length)
+    {
+        ORegKey* pNewKey = nullptr;
+        RegError _ret = pKey->createKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pNewKey));
+        if (_ret != RegError::NO_ERROR)
+            return _ret;
+
+        _ret = pReg->loadKey(pNewKey, regFileName, bWarnings, bReport);
+        if (_ret != RegError::NO_ERROR && (_ret != RegError::MERGE_CONFLICT || bWarnings))
+        {
+            if (pNewKey != pKey)
+                (void) pKey->closeKey(pNewKey);
+            else
+                (void) pKey->releaseKey(pNewKey);
+            return _ret;
+        }
+
+        return (pNewKey != pKey) ? pKey->closeKey(pNewKey) : pKey->releaseKey(pNewKey);
+    }
+
+    return pReg->loadKey(pKey, regFileName, bWarnings, bReport);
+}
+
+
+//  dumpRegistry
+
+static RegError REGISTRY_CALLTYPE dumpRegistry(RegHandle hReg,
+                                               RegKeyHandle hKey)
+{
+    ORegistry* pReg = static_cast< ORegistry* >(hReg);
+    if (!pReg)
+        return RegError::INVALID_REGISTRY;
+    if (!pReg->isOpen())
+        return RegError::REGISTRY_NOT_OPEN;
+
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return RegError::INVALID_KEY;
+    if (pKey->getRegistry() != pReg)
+        return RegError::INVALID_KEY;
+    if (pKey->isDeleted())
+        return RegError::INVALID_KEY;
+
+    return pReg->dumpRegistry(hKey);
+}
+
+
+//  initRegistry_Api
+
+Registry_Api* REGISTRY_CALLTYPE initRegistry_Api()
+{
+    static Registry_Api aApi= {&acquire,
+                               &release,
+                               &isReadOnly,
+                               &openRootKey,
+                               &getName,
+                               &createRegistry,
+                               &openRegistry,
+                               &closeRegistry,
+                               &destroyRegistry,
+                               &mergeKey,
+                               &acquireKey,
+                               &releaseKey,
+                               &isKeyReadOnly,
+                               &getKeyName,
+                               &createKey,
+                               &openKey,
+                               &openSubKeys,
+                               &closeSubKeys,
+                               &deleteKey,
+                               &closeKey,
+                               &setValue,
+                               &setLongListValue,
+                               &setStringListValue,
+                               &setUnicodeListValue,
+                               &getValueInfo,
+                               &getValue,
+                               &getLongListValue,
+                               &getStringListValue,
+                               &getUnicodeListValue,
+                               &freeValueList,
+                               &getResolvedKeyName,
+                               &getKeyNames,
+                               &freeKeyNames};
+
+    return (&aApi);
+}
+
+}
+
+
+//  reg_openRootKey
+
+RegError REGISTRY_CALLTYPE reg_openRootKey(RegHandle hRegistry,
+                                          RegKeyHandle* phRootKey)
+{
+    return openRootKey(hRegistry, phRootKey);
+}
+
+
+//  reg_openRegistry
+
+RegError REGISTRY_CALLTYPE reg_openRegistry(rtl_uString* registryName,
+                                            RegHandle* phRegistry)
+{
+    RegError _ret;
+
+    ORegistry* pReg = new ORegistry();
+    if ((_ret = pReg->initRegistry(registryName, RegAccessMode::READONLY)) != RegError::NO_ERROR)
+    {
+        delete pReg;
+        *phRegistry = nullptr;
+        return _ret;
+    }
+
+    *phRegistry = pReg;
+
+    return RegError::NO_ERROR;
+}
+
+
+//  reg_closeRegistry
+
+RegError REGISTRY_CALLTYPE reg_closeRegistry(RegHandle hRegistry)
+{
+    if (hRegistry)
+    {
+        ORegistry* pReg = static_cast<ORegistry*>(hRegistry);
+        delete pReg;
+        return RegError::NO_ERROR;
+    } else
+    {
+        return RegError::REGISTRY_NOT_OPEN;
+    }
+}
+
+
+//  reg_dumpRegistry
+
+RegError REGISTRY_CALLTYPE reg_dumpRegistry(RegKeyHandle hKey)
+{
+    ORegKey *pKey;
+
+    if (hKey)
+        pKey = static_cast<ORegKey*>(hKey);
+    else
+        return RegError::INVALID_KEY;
+
+    return dumpRegistry(pKey->getRegistry(), hKey);
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/registry/source/regkey.cxx b/registry/source/regkey.cxx
new file mode 100644
index 000000000..4f0d51897
--- /dev/null
+++ b/registry/source/regkey.cxx
@@ -0,0 +1,694 @@
+/* -*- 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 "regkey.hxx"
+
+#include <osl/diagnose.h>
+#include "regimpl.hxx"
+#include "keyimpl.hxx"
+
+
+//  acquireKey
+
+void REGISTRY_CALLTYPE acquireKey(RegKeyHandle hKey)
+{
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (pKey != nullptr)
+    {
+        ORegistry* pReg = pKey->getRegistry();
+        (void) pReg->acquireKey(pKey);
+    }
+}
+
+
+//  releaseKey
+
+void REGISTRY_CALLTYPE releaseKey(RegKeyHandle hKey)
+{
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (pKey != nullptr)
+    {
+        ORegistry* pReg = pKey->getRegistry();
+        (void) pReg->releaseKey(pKey);
+    }
+}
+
+
+//  isKeyReadOnly
+
+sal_Bool REGISTRY_CALLTYPE isKeyReadOnly(RegKeyHandle hKey)
+{
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    return pKey != nullptr && pKey->isReadOnly();
+}
+
+
+//  getKeyName
+
+RegError REGISTRY_CALLTYPE getKeyName(RegKeyHandle hKey, rtl_uString** pKeyName)
+{
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (pKey)
+    {
+        rtl_uString_assign( pKeyName, pKey->getName().pData );
+        return RegError::NO_ERROR;
+    } else
+    {
+        rtl_uString_new(pKeyName);
+        return RegError::INVALID_KEY;
+    }
+}
+
+
+//  createKey
+
+RegError REGISTRY_CALLTYPE createKey(RegKeyHandle hKey,
+                                     rtl_uString* keyName,
+                                     RegKeyHandle* phNewKey)
+{
+    *phNewKey = nullptr;
+
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return RegError::INVALID_KEY;
+
+    if (pKey->isDeleted())
+        return RegError::INVALID_KEY;
+
+    if (pKey->isReadOnly())
+        return RegError::REGISTRY_READONLY;
+
+    return pKey->createKey(OUString::unacquired(&keyName), phNewKey);
+}
+
+
+//  openKey
+
+RegError REGISTRY_CALLTYPE openKey(RegKeyHandle hKey,
+                                   rtl_uString* keyName,
+                                   RegKeyHandle* phOpenKey)
+{
+    *phOpenKey = nullptr;
+
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return RegError::INVALID_KEY;
+
+    if (pKey->isDeleted())
+        return RegError::INVALID_KEY;
+
+    return pKey->openKey(OUString::unacquired(&keyName), phOpenKey);
+}
+
+
+//  openSubKeys
+
+RegError REGISTRY_CALLTYPE openSubKeys(RegKeyHandle hKey,
+                                       rtl_uString* keyName,
+                                       RegKeyHandle** pphSubKeys,
+                                       sal_uInt32* pnSubKeys)
+{
+    *pphSubKeys = nullptr;
+    *pnSubKeys = 0;
+
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return RegError::INVALID_KEY;
+
+    if (pKey->isDeleted())
+        return RegError::INVALID_KEY;
+
+    return pKey->openSubKeys(OUString::unacquired(&keyName), pphSubKeys, pnSubKeys);
+}
+
+
+//  closeSubKeys
+
+RegError REGISTRY_CALLTYPE closeSubKeys(RegKeyHandle* phSubKeys,
+                                        sal_uInt32 nSubKeys)
+{
+    if (phSubKeys == nullptr || nSubKeys == 0)
+        return RegError::INVALID_KEY;
+
+    ORegistry* pReg = static_cast<ORegKey*>(phSubKeys[0])->getRegistry();
+    for (sal_uInt32 i = 0; i < nSubKeys; i++)
+    {
+        (void) pReg->closeKey(phSubKeys[i]);
+    }
+    std::free(phSubKeys);
+
+    return RegError::NO_ERROR;
+}
+
+
+//  deleteKey
+
+RegError REGISTRY_CALLTYPE deleteKey(RegKeyHandle hKey,
+                                     rtl_uString* keyName)
+{
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return RegError::INVALID_KEY;
+
+    if (pKey->isDeleted())
+        return RegError::INVALID_KEY;
+
+    if (pKey->isReadOnly())
+        return RegError::REGISTRY_READONLY;
+
+    return pKey->deleteKey(OUString::unacquired(&keyName));
+}
+
+
+//  closeKey
+
+RegError REGISTRY_CALLTYPE closeKey(RegKeyHandle hKey)
+{
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return RegError::INVALID_KEY;
+
+    return pKey->closeKey(hKey);
+}
+
+
+//  setValue
+
+RegError REGISTRY_CALLTYPE setValue(RegKeyHandle hKey,
+                                       rtl_uString* keyName,
+                                       RegValueType valueType,
+                                       RegValue pData,
+                                       sal_uInt32 valueSize)
+{
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return RegError::INVALID_KEY;
+
+    if (pKey->isDeleted())
+        return RegError::INVALID_KEY;
+
+    if (pKey->isReadOnly())
+        return RegError::REGISTRY_READONLY;
+
+    OUString valueName("value");
+    if (keyName->length)
+    {
+        ORegKey* pSubKey = nullptr;
+        RegError _ret1 = pKey->openKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pSubKey));
+        if (_ret1 != RegError::NO_ERROR)
+            return _ret1;
+
+        _ret1 = pSubKey->setValue(valueName, valueType, pData, valueSize);
+        if (_ret1 != RegError::NO_ERROR)
+        {
+            RegError _ret2 = pKey->closeKey(pSubKey);
+            if (_ret2 != RegError::NO_ERROR)
+                return _ret2;
+            else
+                return _ret1;
+        }
+
+        return pKey->closeKey(pSubKey);
+    }
+
+    return pKey->setValue(valueName, valueType, pData, valueSize);
+}
+
+
+//  setLongValueList
+
+RegError REGISTRY_CALLTYPE setLongListValue(RegKeyHandle hKey,
+                                                  rtl_uString* keyName,
+                                                  sal_Int32 const * pValueList,
+                                                  sal_uInt32 len)
+{
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return RegError::INVALID_KEY;
+
+    if (pKey->isDeleted())
+        return RegError::INVALID_KEY;
+
+    if (pKey->isReadOnly())
+        return RegError::REGISTRY_READONLY;
+
+    OUString valueName("value");
+    if (keyName->length)
+    {
+        ORegKey* pSubKey = nullptr;
+        RegError _ret1 = pKey->openKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pSubKey));
+        if (_ret1 != RegError::NO_ERROR)
+            return _ret1;
+
+        _ret1 = pSubKey->setLongListValue(valueName, pValueList, len);
+        if (_ret1 != RegError::NO_ERROR)
+        {
+            RegError _ret2 = pKey->closeKey(pSubKey);
+            if (_ret2 != RegError::NO_ERROR)
+                return _ret2;
+            else
+                return _ret1;
+        }
+
+        return pKey->closeKey(pSubKey);
+    }
+
+    return pKey->setLongListValue(valueName, pValueList, len);
+}
+
+
+//  setStringValueList
+
+RegError REGISTRY_CALLTYPE setStringListValue(RegKeyHandle hKey,
+                                                   rtl_uString* keyName,
+                                                   char** pValueList,
+                                                   sal_uInt32 len)
+{
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return RegError::INVALID_KEY;
+
+    if (pKey->isDeleted())
+        return RegError::INVALID_KEY;
+
+    if (pKey->isReadOnly())
+        return RegError::REGISTRY_READONLY;
+
+    OUString valueName("value");
+    if (keyName->length)
+    {
+        ORegKey* pSubKey = nullptr;
+        RegError _ret1 = pKey->openKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pSubKey));
+        if (_ret1 != RegError::NO_ERROR)
+            return _ret1;
+
+        _ret1 = pSubKey->setStringListValue(valueName, pValueList, len);
+        if (_ret1 != RegError::NO_ERROR)
+        {
+            RegError _ret2 = pKey->closeKey(pSubKey);
+            if (_ret2 != RegError::NO_ERROR)
+                return _ret2;
+            else
+                return _ret1;
+        }
+
+        return pKey->closeKey(pSubKey);
+    }
+
+    return pKey->setStringListValue(valueName, pValueList, len);
+}
+
+
+//  setUnicodeValueList
+
+RegError REGISTRY_CALLTYPE setUnicodeListValue(RegKeyHandle hKey,
+                                                     rtl_uString* keyName,
+                                                     sal_Unicode** pValueList,
+                                                     sal_uInt32 len)
+{
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return RegError::INVALID_KEY;
+
+    if (pKey->isDeleted())
+        return RegError::INVALID_KEY;
+
+    if (pKey->isReadOnly())
+        return RegError::REGISTRY_READONLY;
+
+    OUString valueName("value");
+    if (keyName->length)
+    {
+        ORegKey* pSubKey = nullptr;
+        RegError _ret1 = pKey->openKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pSubKey));
+        if (_ret1 != RegError::NO_ERROR)
+            return _ret1;
+
+        _ret1 = pSubKey->setUnicodeListValue(valueName, pValueList, len);
+        if (_ret1 != RegError::NO_ERROR)
+        {
+            RegError _ret2 = pKey->closeKey(pSubKey);
+            if (_ret2 != RegError::NO_ERROR)
+                return _ret2;
+            else
+                return _ret1;
+        }
+
+        return pKey->closeKey(pSubKey);
+    }
+
+    return pKey->setUnicodeListValue(valueName, pValueList, len);
+}
+
+
+//  getValueInfo
+
+RegError REGISTRY_CALLTYPE getValueInfo(RegKeyHandle hKey,
+                                        rtl_uString* keyName,
+                                        RegValueType* pValueType,
+                                        sal_uInt32* pValueSize)
+{
+    *pValueType = RegValueType::NOT_DEFINED;
+    *pValueSize = 0;
+
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return RegError::INVALID_KEY;
+
+    if (pKey->isDeleted())
+        return RegError::INVALID_KEY;
+
+    RegValueType valueType;
+    sal_uInt32   valueSize;
+
+    OUString valueName("value");
+    if (keyName->length)
+    {
+        ORegKey* pSubKey = nullptr;
+        RegError _ret = pKey->openKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pSubKey));
+        if (_ret != RegError::NO_ERROR)
+            return _ret;
+
+        if (pSubKey->getValueInfo(valueName, &valueType, &valueSize) != RegError::NO_ERROR)
+        {
+            (void) pKey->releaseKey(pSubKey);
+            return RegError::INVALID_VALUE;
+        }
+
+        *pValueType = valueType;
+        *pValueSize = valueSize;
+
+        return pKey->releaseKey(pSubKey);
+    }
+
+
+    if (pKey->getValueInfo(valueName, &valueType, &valueSize) != RegError::NO_ERROR)
+    {
+        return RegError::INVALID_VALUE;
+    }
+
+    *pValueType = valueType;
+    *pValueSize = valueSize;
+
+    return RegError::NO_ERROR;
+}
+
+
+//  getValueInfo
+
+RegError REGISTRY_CALLTYPE getValue(RegKeyHandle hKey,
+                                    rtl_uString* keyName,
+                                    RegValue pValue)
+{
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return RegError::INVALID_KEY;
+
+    if (pKey->isDeleted())
+        return RegError::INVALID_KEY;
+
+    OUString valueName("value");
+    if (keyName->length)
+    {
+        ORegKey* pSubKey = nullptr;
+        RegError _ret1 = pKey->openKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pSubKey));
+        if (_ret1 != RegError::NO_ERROR)
+            return _ret1;
+
+        _ret1 = pSubKey->getValue(valueName, pValue);
+        if (_ret1 != RegError::NO_ERROR)
+        {
+            (void) pKey->releaseKey(pSubKey);
+            return _ret1;
+        }
+
+        return pKey->releaseKey(pSubKey);
+    }
+
+    return pKey->getValue(valueName, pValue);
+}
+
+
+//  getLongValueList
+
+RegError REGISTRY_CALLTYPE getLongListValue(RegKeyHandle hKey,
+                                            rtl_uString* keyName,
+                                            sal_Int32** pValueList,
+                                            sal_uInt32* pLen)
+{
+    assert((pValueList != nullptr) && (pLen != nullptr) && "registry::getLongListValue(): invalid parameter");
+    *pValueList = nullptr;
+    *pLen = 0;
+
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return RegError::INVALID_KEY;
+
+    if (pKey->isDeleted())
+        return RegError::INVALID_KEY;
+
+    OUString valueName("value");
+    if (keyName->length)
+    {
+        ORegKey* pSubKey = nullptr;
+        RegError _ret1 = pKey->openKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pSubKey));
+        if (_ret1 != RegError::NO_ERROR)
+            return _ret1;
+
+        _ret1 = pSubKey->getLongListValue(valueName, pValueList, pLen);
+        if (_ret1 != RegError::NO_ERROR)
+        {
+            (void) pKey->releaseKey(pSubKey);
+            return _ret1;
+        }
+
+        return pKey->releaseKey(pSubKey);
+    }
+
+    return pKey->getLongListValue(valueName, pValueList, pLen);
+}
+
+
+//  getStringValueList
+
+RegError REGISTRY_CALLTYPE getStringListValue(RegKeyHandle hKey,
+                                              rtl_uString* keyName,
+                                              char*** pValueList,
+                                              sal_uInt32* pLen)
+{
+    OSL_PRECOND((pValueList != nullptr) && (pLen != nullptr), "registry::getStringListValue(): invalid parameter");
+    *pValueList = nullptr;
+    *pLen = 0;
+
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return RegError::INVALID_KEY;
+
+    if (pKey->isDeleted())
+        return RegError::INVALID_KEY;
+
+    OUString valueName("value");
+    if (keyName->length)
+    {
+        ORegKey* pSubKey = nullptr;
+        RegError _ret1 = pKey->openKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pSubKey));
+        if (_ret1 != RegError::NO_ERROR)
+            return _ret1;
+
+        _ret1 = pSubKey->getStringListValue(valueName, pValueList, pLen);
+        if (_ret1 != RegError::NO_ERROR)
+        {
+            (void) pKey->releaseKey(pSubKey);
+            return _ret1;
+        }
+
+        return pKey->releaseKey(pSubKey);
+    }
+
+    return pKey->getStringListValue(valueName, pValueList, pLen);
+}
+
+//  getUnicodeListValue
+RegError REGISTRY_CALLTYPE getUnicodeListValue(RegKeyHandle hKey,
+                                               rtl_uString* keyName,
+                                               sal_Unicode*** pValueList,
+                                               sal_uInt32* pLen)
+{
+    assert((pValueList != nullptr) && (pLen != nullptr) && "registry::getUnicodeListValue(): invalid parameter");
+    *pValueList = nullptr;
+    *pLen = 0;
+
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return RegError::INVALID_KEY;
+
+    if (pKey->isDeleted())
+        return RegError::INVALID_KEY;
+
+    OUString valueName("value");
+    if (keyName->length)
+    {
+        ORegKey* pSubKey = nullptr;
+        RegError _ret1 = pKey->openKey(OUString::unacquired(&keyName), reinterpret_cast<RegKeyHandle*>(&pSubKey));
+        if (_ret1 != RegError::NO_ERROR)
+            return _ret1;
+
+        _ret1 = pSubKey->getUnicodeListValue(valueName, pValueList, pLen);
+        if (_ret1 != RegError::NO_ERROR)
+        {
+            (void) pKey->releaseKey(pSubKey);
+            return _ret1;
+        }
+
+        return pKey->releaseKey(pSubKey);
+    }
+
+    return pKey->getUnicodeListValue(valueName, pValueList, pLen);
+}
+
+
+//  freeValueList
+
+RegError REGISTRY_CALLTYPE freeValueList(RegValueType valueType,
+                                              RegValue pValueList,
+                                              sal_uInt32 len)
+{
+    switch (valueType)
+    {
+        case RegValueType::LONGLIST:
+            {
+                std::free(pValueList);
+            }
+            break;
+        case RegValueType::STRINGLIST:
+            {
+                char** pVList = static_cast<char**>(pValueList);
+                for (sal_uInt32 i=0; i < len; i++)
+                {
+                    std::free(pVList[i]);
+                }
+
+                std::free(pVList);
+            }
+            break;
+        case RegValueType::UNICODELIST:
+            {
+                sal_Unicode** pVList = static_cast<sal_Unicode**>(pValueList);
+                for (sal_uInt32 i=0; i < len; i++)
+                {
+                    std::free(pVList[i]);
+                }
+
+                std::free(pVList);
+            }
+            break;
+        default:
+            return RegError::INVALID_VALUE;
+    }
+
+    pValueList = nullptr;
+    return RegError::NO_ERROR;
+}
+
+
+//  getName
+
+RegError REGISTRY_CALLTYPE getResolvedKeyName(RegKeyHandle hKey,
+                                              rtl_uString* keyName,
+                                              SAL_UNUSED_PARAMETER sal_Bool,
+                                                rtl_uString** pResolvedName)
+{
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return RegError::INVALID_KEY;
+
+    if (pKey->isDeleted())
+        return RegError::INVALID_KEY;
+
+    OUString resolvedName;
+    RegError _ret = pKey->getResolvedKeyName(OUString::unacquired(&keyName), resolvedName);
+    if (_ret == RegError::NO_ERROR)
+        rtl_uString_assign(pResolvedName, resolvedName.pData);
+    return _ret;
+}
+
+
+//  getKeyNames
+
+RegError REGISTRY_CALLTYPE getKeyNames(RegKeyHandle hKey,
+                                       rtl_uString* keyName,
+                                         rtl_uString*** pSubKeyNames,
+                                         sal_uInt32* pnSubKeys)
+{
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return RegError::INVALID_KEY;
+
+    if (pKey->isDeleted())
+        return RegError::INVALID_KEY;
+
+    return pKey->getKeyNames(OUString::unacquired(&keyName), pSubKeyNames, pnSubKeys);
+}
+
+
+//  freeKeyNames
+
+RegError REGISTRY_CALLTYPE freeKeyNames(rtl_uString** pKeyNames,
+                                          sal_uInt32 nKeys)
+{
+    for (sal_uInt32 i=0; i < nKeys; i++)
+    {
+        rtl_uString_release(pKeyNames[i]);
+    }
+
+    std::free(pKeyNames);
+
+    return RegError::NO_ERROR;
+}
+
+
+//  C API
+
+
+//  reg_openKey
+
+RegError REGISTRY_CALLTYPE reg_openKey(RegKeyHandle hKey,
+                                       rtl_uString* keyName,
+                                       RegKeyHandle* phOpenKey)
+{
+    if (!hKey)
+        return RegError::INVALID_KEY;
+
+    return openKey(hKey, keyName, phOpenKey);
+}
+
+
+//  reg_closeKey
+
+RegError REGISTRY_CALLTYPE reg_closeKey(RegKeyHandle hKey)
+{
+    if (!hKey)
+        return RegError::INVALID_KEY;
+
+    return closeKey(hKey);
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/registry/source/regkey.hxx b/registry/source/regkey.hxx
new file mode 100644
index 000000000..76e8c2993
--- /dev/null
+++ b/registry/source/regkey.hxx
@@ -0,0 +1,69 @@
+/* -*- 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_REGISTRY_SOURCE_REGKEY_HXX
+#define INCLUDED_REGISTRY_SOURCE_REGKEY_HXX
+
+#include <sal/config.h>
+#include <registry/regtype.h>
+#include <rtl/ustring.h>
+#include <sal/types.h>
+
+extern "C" {
+
+void REGISTRY_CALLTYPE acquireKey(RegKeyHandle);
+void REGISTRY_CALLTYPE releaseKey(RegKeyHandle);
+sal_Bool REGISTRY_CALLTYPE isKeyReadOnly(RegKeyHandle);
+RegError REGISTRY_CALLTYPE getKeyName(RegKeyHandle, rtl_uString**);
+RegError REGISTRY_CALLTYPE createKey(RegKeyHandle, rtl_uString*, RegKeyHandle*);
+RegError REGISTRY_CALLTYPE openKey(RegKeyHandle, rtl_uString*, RegKeyHandle*);
+RegError REGISTRY_CALLTYPE openSubKeys(
+    RegKeyHandle, rtl_uString*, RegKeyHandle**, sal_uInt32*);
+RegError REGISTRY_CALLTYPE closeSubKeys(RegKeyHandle*, sal_uInt32);
+RegError REGISTRY_CALLTYPE deleteKey(RegKeyHandle, rtl_uString*);
+RegError REGISTRY_CALLTYPE closeKey(RegKeyHandle);
+RegError REGISTRY_CALLTYPE setValue(
+    RegKeyHandle, rtl_uString*, RegValueType, RegValue, sal_uInt32);
+RegError REGISTRY_CALLTYPE setLongListValue(
+    RegKeyHandle, rtl_uString*, sal_Int32 const *, sal_uInt32);
+RegError REGISTRY_CALLTYPE setStringListValue(
+    RegKeyHandle, rtl_uString*, char**, sal_uInt32);
+RegError REGISTRY_CALLTYPE setUnicodeListValue(
+    RegKeyHandle, rtl_uString*, sal_Unicode**, sal_uInt32);
+RegError REGISTRY_CALLTYPE getValueInfo(
+    RegKeyHandle, rtl_uString*, RegValueType*, sal_uInt32*);
+RegError REGISTRY_CALLTYPE getValue(RegKeyHandle, rtl_uString*, RegValue);
+RegError REGISTRY_CALLTYPE getLongListValue(
+    RegKeyHandle, rtl_uString*, sal_Int32**, sal_uInt32*);
+RegError REGISTRY_CALLTYPE getStringListValue(
+    RegKeyHandle, rtl_uString*, char***, sal_uInt32*);
+RegError REGISTRY_CALLTYPE getUnicodeListValue(
+    RegKeyHandle, rtl_uString*, sal_Unicode***, sal_uInt32*);
+RegError REGISTRY_CALLTYPE freeValueList(RegValueType, RegValue, sal_uInt32);
+RegError REGISTRY_CALLTYPE getResolvedKeyName(
+    RegKeyHandle, rtl_uString*, sal_Bool, rtl_uString**);
+RegError REGISTRY_CALLTYPE getKeyNames(
+    RegKeyHandle, rtl_uString*, rtl_uString***, sal_uInt32*);
+RegError REGISTRY_CALLTYPE freeKeyNames(rtl_uString**, sal_uInt32);
+
+}
+
+#endif
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/registry/test/makefile.mk b/registry/test/makefile.mk
new file mode 100644
index 000000000..f6d99120f
--- /dev/null
+++ b/registry/test/makefile.mk
@@ -0,0 +1,81 @@
+#
+# 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 .
+#
+
+PRJ=..
+
+PRJNAME=registry
+TARGET=regtest
+
+USE_LDUMP2=TRUE
+
+ENABLE_EXCEPTIONS := TRUE
+
+# --- Settings -----------------------------------------------------
+.INCLUDE :  settings.mk
+
+
+# ------------------------------------------------------------------
+CDEFS += -DDLL_VERSION=$(EMQ)"$(DLLPOSTFIX)$(EMQ)"
+
+CXXFILES= \
+               testregcpp.cxx	\
+               testmerge.cxx		
+
+
+LIB1TARGET= $(SLB)$/$(TARGET).lib
+
+LIB1OBJFILES= \
+                $(SLO)$/testregcpp.obj	\
+                $(SLO)$/testmerge.obj
+
+
+SHL1TARGET= rgt$(DLLPOSTFIX)
+SHL1IMPLIB= rgt
+SHL1STDLIBS=	\
+                $(SALLIB) \
+                $(SALHELPERLIB)	\
+                $(REGLIB) \
+                $(STDLIBCPP)
+
+SHL1LIBS=	$(LIB1TARGET)
+SHL1DEPN=	$(LIB1TARGET)
+SHL1DEF=	$(MISC)$/$(SHL1TARGET).def
+DEF1NAME=	$(SHL1TARGET)
+             
+DEF1DEPN	=$(MISC)$/rgt$(DLLPOSTFIX).flt $(SLOFILES)
+DEFLIB1NAME =$(TARGET)
+DEF1DES 	=Registry Runtime - TestDll
+
+# --- Targets ------------------------------------------------------
+
+#all: \
+#	ALLTAR	
+
+.INCLUDE :  target.mk
+
+# --- SO2-Filter-Datei ---
+
+
+$(MISC)$/rgt$(DLLPOSTFIX).flt:
+    @echo ------------------------------
+    @echo Making: $@
+    @echo WEP>$@
+    @echo LIBMAIN>>$@
+    @echo LibMain>>$@
+
+
diff --git a/registry/test/regdiagnose.h b/registry/test/regdiagnose.h
new file mode 100644
index 000000000..9d4562d9e
--- /dev/null
+++ b/registry/test/regdiagnose.h
@@ -0,0 +1,38 @@
+/* -*- 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_REGISTRY_TEST_REGDIAGNOSE_H
+#define INCLUDED_REGISTRY_TEST_REGDIAGNOSE_H
+
+#include <osl/diagnose.h>
+
+#define REG_ENSURE(c, m)   _REG_ENSURE(c, __FILE__, __LINE__, m)
+
+#define _REG_ENSURE(c, f, l, m) \
+    do \
+    {  \
+        if (!(c) && ::osl_assertFailedLine(f, l, m)) \
+           ::osl_breakDebug(); \
+    } while (0)
+
+
+#endif // INCLUDED_REGISTRY_TEST_REGDIAGNOSE_H
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/registry/test/testmerge.cxx b/registry/test/testmerge.cxx
new file mode 100644
index 000000000..d16100c5c
--- /dev/null
+++ b/registry/test/testmerge.cxx
@@ -0,0 +1,405 @@
+/* -*- 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 <iostream>
+#include <stdio.h>
+#include <string.h>
+
+#include "registry/registry.hxx"
+#include "registry/reflread.hxx"
+#include "registry/reflwrit.hxx"
+#include "regdiagnose.h"
+#include <rtl/alloc.h>
+#include <rtl/ustring.hxx>
+
+
+sal_Int32 lValue1   = 123456789;
+sal_Int32 lValue2   = 54321;
+sal_Int32 lValue3   = 111333111;
+sal_Int32 lValue4   = 333111333;
+char* sValue        = (char*)"string Value";
+OUString wValue("unicode Value");
+
+
+void test_generateMerge1()
+{
+    Registry *myRegistry = new Registry();
+
+    RegistryKey rootKey, key1, key2, key3, key4, key5, key6, key7, key8, key9;
+
+    REG_ENSURE(!myRegistry->create(OUString("merge1.rdb")), "testGenerateMerge1 error 1");
+    REG_ENSURE(!myRegistry->openRootKey(rootKey), "testGenerateMerge1 error 2");
+
+    REG_ENSURE(!rootKey.createKey(OUString("MergeKey1"), key1), "testGenerateMerge1 error 3");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1/MK1SubKey1"), key2), "testGenerateMerge1 error 4");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1/MK1SubKey1/KeyWithLongValue"), key3), "testGenerateMerge1 error 5");
+    REG_ENSURE(!key3.setValue(OUString(), RegValueType::LONG, &lValue1, sizeof(sal_Int32)), "testGenerateMerge1 error 5a");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1/MK1SubKey2"), key4), "testGenerateMerge1 error 6");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1/MK1SubKey2/KeyWithStringValue"), key5), "testGenerateMerge1 error 7");
+    REG_ENSURE(!key5.setValue(OUString(), RegValueType::STRING, sValue, strlen(sValue)+1), "testGenerateMerge1 error 7a");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1/MK1SubKey3"), key6), "testGenerateMerge1 error 8");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1/MK1SubKey3/KeyWithUnicodeValue"), key7), "testGenerateMerge1 error 9");
+    REG_ENSURE(!key7.setValue(OUString(), RegValueType::UNICODE, (void*)wValue.getStr(), ((wValue.getLength()+1)*sizeof(sal_Unicode))), "testGenerateMerge1 error 9a");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1/MK1SubKey4"), key8), "testGenerateMerge1 error 10");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1/MK1SubKey4/KeyWithBinaryValue"), key9), "testGenerateMerge1 error 11");
+    REG_ENSURE(!key9.setValue(OUString(), RegValueType::BINARY, (void*)"abcdefghijklmnopqrstuvwxyz", 27), "testGenerateMerge1 error 11a");
+
+
+    REG_ENSURE(!key1.closeKey() &&
+                !key2.closeKey() &&
+                !key3.closeKey() &&
+                !key4.closeKey() &&
+                !key5.closeKey() &&
+                !key6.closeKey() &&
+                !key7.closeKey() &&
+                !key8.closeKey() &&
+                !key9.closeKey(), "testGenerateMerge1 error 12");
+
+    REG_ENSURE(!rootKey.createKey(OUString("MergeKey1u2"), key1), "testGenerateMerge1 error 13");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK1SubKey11"), key2), "testGenerateMerge1 error 14");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK1SubKey11/KeyWithLongValue"), key3), "testGenerateMerge1 error 15");
+    REG_ENSURE(!key3.setValue(OUString(), RegValueType::LONG, &lValue2, sizeof(sal_Int32)), "testGenerateMerge1 error 15a");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK1SubKey12"), key4), "testGenerateMerge1 error 16");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK1SubKey12/KeyWithStringValue"), key5), "testGenerateMerge1 error 17");
+    REG_ENSURE(!key5.setValue(OUString(), RegValueType::STRING, sValue, strlen(sValue)+1), "testGenerateMerge1 error 17a");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK1SubKey13"), key6), "testGenerateMerge1 error 18");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK1SubKey13/KeyWithUnicodeValue"), key7), "testGenerateMerge1 error 19");
+    REG_ENSURE(!key7.setValue(OUString(), RegValueType::UNICODE, (void*)wValue.getStr(), ((wValue.getLength()+1)*sizeof(sal_Unicode))), "testGenerateMerge1 error 19a");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK12SubKey1u2"), key8), "testGenerateMerge1 error 20");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK12SubKey1u2/KeyWithLongValue"), key9), "testGenerateMerge1 error 21");
+    REG_ENSURE(!key9.setValue(OUString(), RegValueType::LONG, &lValue3, sizeof(sal_Int32)), "testGenerateMerge1 error 21a");
+
+    REG_ENSURE(!rootKey.closeKey() &&
+                !key1.closeKey() &&
+                !key2.closeKey() &&
+                !key3.closeKey() &&
+                !key4.closeKey() &&
+                !key5.closeKey() &&
+                !key6.closeKey() &&
+                !key7.closeKey() &&
+                !key8.closeKey() &&
+                !key9.closeKey(), "testGenerateMerge1 error 22");
+
+
+    delete myRegistry;
+
+    std::cout << "test_generateMerge1() Ok!\n";
+    return;
+}
+
+void test_generateMerge2()
+{
+    Registry *myRegistry = new Registry();
+
+    RegistryKey rootKey, key1, key2, key3, key4, key5, key6, key7, key8, key9;
+
+    REG_ENSURE(!myRegistry->create(OUString("merge2.rdb")), "testGenerateMerge2 error 1");
+    REG_ENSURE(!myRegistry->openRootKey(rootKey), "testGenerateMerge2 error 2");
+
+    REG_ENSURE(!rootKey.createKey(OUString("MergeKey2"), key1), "testGenerateMerge2 error 3");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey2/MK2SubKey1"), key2), "testGenerateMerge2 error 4");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey2/MK2SubKey1/KeyWithBinaryValue"), key3), "testGenerateMerge2 error 5");
+    REG_ENSURE(!key3.setValue(OUString(), RegValueType::BINARY, (void*)"1234567890", 11), "testGenerateMerge1 error 5a");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey2/MK2SubKey2"), key4), "testGenerateMerge2 error 6");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey2/MK2SubKey2/KeyWithUnicodeValue"), key5), "testGenerateMerge2 error 7");
+    REG_ENSURE(!key5.setValue(OUString(), RegValueType::UNICODE, (void*)wValue.getStr(), ((wValue.getLength()+1)*sizeof(sal_Unicode))), "testGenerateMerge1 error 7a");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey2/MK2SubKey3"), key6), "testGenerateMerge2 error 8");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey2/MK2SubKey3/KeyWithStringValue"), key7), "testGenerateMerge2 error 9");
+    REG_ENSURE(!key7.setValue(OUString(), RegValueType::STRING, sValue, strlen(sValue)+1), "testGenerateMerge1 error 9a");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey2/MK2SubKey4"), key8), "testGenerateMerge2 error 10");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey2/MK2SubKey4/KeyWithLongValue"), key9), "testGenerateMerge2 error 11");
+    REG_ENSURE(!key9.setValue(OUString(), RegValueType::LONG, &lValue1, sizeof(sal_Int32)), "testGenerateMerge1 error 11a");
+
+    REG_ENSURE(!key1.closeKey() &&
+                !key2.closeKey() &&
+                !key3.closeKey() &&
+                !key4.closeKey() &&
+                !key5.closeKey() &&
+                !key6.closeKey() &&
+                !key7.closeKey() &&
+                !key8.closeKey() &&
+                !key9.closeKey(), "testGenerateMerge2 error 12");
+
+    REG_ENSURE(!rootKey.createKey(OUString("MergeKey1u2"), key1), "testGenerateMerge2 error 13");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK2SubKey21"), key2), "testGenerateMerge2 error 14");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK2SubKey21/KeyWithBinaryValue"), key3), "testGenerateMerge2 error 15");
+    REG_ENSURE(!key3.setValue(OUString(), RegValueType::BINARY, (void*)"a1b2c3d4e5f6g7h8i9", 19), "testGenerateMerge1 error 15a");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK2SubKey22"), key4), "testGenerateMerge2 error 16");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK2SubKey22/KeyWithLongValue"), key5), "testGenerateMerge2 error 17");
+    REG_ENSURE(!key5.setValue(OUString(), RegValueType::LONG, &lValue2, sizeof(sal_Int32)), "testGenerateMerge1 error 17a");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK2SubKey23"), key6), "testGenerateMerge2 error 18");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK2SubKey23/KeyWithStringValue"), key7), "testGenerateMerge2 error 19");
+    REG_ENSURE(!key7.setValue(OUString(), RegValueType::STRING, sValue, strlen(sValue)+1), "testGenerateMerge1 error 19a");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK12SubKey1u2"), key8), "testGenerateMerge2 error 20");
+    REG_ENSURE(!rootKey.createKey(OUString("/MergeKey1u2/MK12SubKey1u2/KeyWithLongValue"), key9), "testGenerateMerge2 error 21");
+    REG_ENSURE(!key9.setValue(OUString(), RegValueType::LONG, &lValue4, sizeof(sal_Int32)), "testGenerateMerge1 error 21a");
+
+    REG_ENSURE(!rootKey.closeKey() &&
+                !key1.closeKey() &&
+                !key2.closeKey() &&
+                !key3.closeKey() &&
+                !key4.closeKey() &&
+                !key5.closeKey() &&
+                !key6.closeKey() &&
+                !key7.closeKey() &&
+                !key8.closeKey() &&
+                !key9.closeKey(), "testGenerateMerge2 error 22");
+
+
+    delete myRegistry;
+
+    std::cout << "test_generateMerge2() Ok!\n";
+    return;
+}
+
+void test_merge()
+{
+    Registry *myRegistry = new Registry();
+
+    RegistryKey rootKey, key1, mkey1, key2, mkey2, key1u2, mkey1u2;
+
+    REG_ENSURE(!myRegistry->create(OUString("mergetest.rdb")), "testMerge error 1");
+    REG_ENSURE(myRegistry->getName() == "mergetest.rdb", "testMerge error 1.a)");
+    REG_ENSURE(!myRegistry->openRootKey(rootKey), "testMerge error 2");
+    REG_ENSURE(!myRegistry->loadKey(rootKey, OUString("/stardiv/IchbineinMergeKey"),
+                OUString("merge1.rdb")), "testMerge error 3");
+    REG_ENSURE(!myRegistry->mergeKey(rootKey, OUString("/stardiv/IchbineinMergeKey"),
+                OUString("merge2.rdb")), "testMerge error 4");
+
+
+    REG_ENSURE(!rootKey.openKey("/stardiv/IchbineinMergeKey", key1), "testMerge error 5");
+
+    REG_ENSURE(!key1.openKey("MergeKey1", mkey1), "testMerge error 6");
+    REG_ENSURE(!mkey1.closeKey(), "testMerge error 7");
+
+    REG_ENSURE(!key1.openKey("/MergeKey1/MK1SubKey1", mkey1), "testMerge error 8");
+    REG_ENSURE(!mkey1.closeKey(), "testMerge error 9");
+    REG_ENSURE(!key1.openKey("/MergeKey1/MK1SubKey1/KeyWithLongValue", mkey1), "testMerge error 10");
+    REG_ENSURE(!mkey1.closeKey(), "testMerge error 11");
+
+    REG_ENSURE(!key1.openKey("/MergeKey1/MK1SubKey2", mkey1), "testMerge error 12");
+    REG_ENSURE(!mkey1.closeKey(), "testMerge error 13");
+    REG_ENSURE(!key1.openKey("/MergeKey1/MK1SubKey2/KeyWithStringValue", mkey1), "testMerge error 14");
+    REG_ENSURE(!mkey1.closeKey(), "testMerge error 15");
+
+    REG_ENSURE(!key1.openKey("/MergeKey1/MK1SubKey3", mkey1), "testMerge error 16");
+    REG_ENSURE(!mkey1.closeKey(), "testMerge error 17");
+    REG_ENSURE(!key1.openKey("/MergeKey1/MK1SubKey3/KeyWithUnicodeValue", mkey1), "testMerge error 18");
+    REG_ENSURE(!mkey1.closeKey(), "testMerge error 19");
+
+    REG_ENSURE(!key1.openKey("/MergeKey1/MK1SubKey4", mkey1), "testMerge error 20");
+    REG_ENSURE(!mkey1.closeKey(), "testMerge error 21");
+    REG_ENSURE(!key1.openKey("/MergeKey1/MK1SubKey4/KeyWithBinaryValue", mkey1), "testMerge error 22");
+    REG_ENSURE(!mkey1.closeKey(), "testMerge error 23");
+
+    REG_ENSURE(!key1.closeKey(), "testMerge error 24");
+
+
+    REG_ENSURE(!rootKey.openKey("/stardiv/IchbineinMergeKey", key2), "testMerge error 25");
+
+    REG_ENSURE(!key2.openKey("MergeKey2", mkey2), "testMerge error 26");
+    REG_ENSURE(!mkey2.closeKey(), "testMerge error 27");
+
+    REG_ENSURE(!key2.openKey("/MergeKey2/MK2SubKey1", mkey2), "testMerge error 28");
+    REG_ENSURE(!mkey2.closeKey(), "testMerge error 29");
+    REG_ENSURE(!key2.openKey("/MergeKey2/MK2SubKey1/KeyWithBinaryValue", mkey2), "testMerge error 30");
+    REG_ENSURE(!mkey2.closeKey(), "testMerge error 31");
+
+    REG_ENSURE(!key2.openKey("/MergeKey2/MK2SubKey2", mkey2), "testMerge error 31");
+    REG_ENSURE(!mkey2.closeKey(), "testMerge error 33");
+    REG_ENSURE(!key2.openKey("/MergeKey2/MK2SubKey2/KeyWithUnicodeValue", mkey2), "testMerge error 34");
+    REG_ENSURE(!mkey2.closeKey(), "testMerge error 35");
+
+    REG_ENSURE(!key2.openKey("/MergeKey2/MK2SubKey3", mkey2), "testMerge error 36");
+    REG_ENSURE(!mkey2.closeKey(), "testMerge error 37");
+    REG_ENSURE(!key2.openKey("/MergeKey2/MK2SubKey3/KeyWithStringValue", mkey2), "testMerge error 38");
+    REG_ENSURE(!mkey2.closeKey(), "testMerge error 39");
+
+    REG_ENSURE(!key2.openKey("/MergeKey2/MK2SubKey4", mkey2), "testMerge error 40");
+    REG_ENSURE(!mkey2.closeKey(), "testMerge error 41");
+    REG_ENSURE(!key2.openKey("/MergeKey2/MK2SubKey4/KeyWithLongValue", mkey2), "testMerge error 42");
+    REG_ENSURE(!mkey2.closeKey(), "testMerge error 43");
+
+    REG_ENSURE(!key2.closeKey(), "testMerge error 44");
+
+
+    REG_ENSURE(!rootKey.openKey("/stardiv/IchbineinMergeKey", key1u2), "testMerge error 40");
+
+    REG_ENSURE(!key1u2.openKey("MergeKey1u2", mkey1u2), "testMerge error 41");
+    REG_ENSURE(!mkey1u2.closeKey(), "testMerge error 42");
+
+    REG_ENSURE(!key1u2.openKey("/MergeKey1u2/MK1SubKey11", mkey1u2), "testMerge error 43");
+    REG_ENSURE(!mkey1u2.closeKey(), "testMerge error 44");
+    REG_ENSURE(!key1u2.openKey("/MergeKey1u2/MK1SubKey11/KeyWithLongValue", mkey1u2), "testMerge error 45");
+    REG_ENSURE(!mkey1u2.closeKey(), "testMerge error 46");
+
+    REG_ENSURE(!key1u2.openKey("/MergeKey1u2/MK1SubKey12", mkey1u2), "testMerge error 47");
+    REG_ENSURE(!mkey1u2.closeKey(), "testMerge error 48");
+    REG_ENSURE(!key1u2.openKey("/MergeKey1u2/MK1SubKey12/KeyWithStringValue", mkey1u2), "testMerge error 49");
+    REG_ENSURE(!mkey1u2.closeKey(), "testMerge error 50");
+
+    REG_ENSURE(!key1u2.openKey("/MergeKey1u2/MK1SubKey13", mkey1u2), "testMerge error 51");
+    REG_ENSURE(!mkey1u2.closeKey(), "testMerge error 52");
+    REG_ENSURE(!key1u2.openKey("/MergeKey1u2/MK1SubKey13/KeyWithUnicodeValue", mkey1u2), "testMerge error 53");
+    REG_ENSURE(!mkey1u2.closeKey(), "testMerge error 54");
+
+    REG_ENSURE(!key1u2.openKey("/MergeKey1u2/MK2SubKey21", mkey1u2), "testMerge error 55");
+    REG_ENSURE(!mkey1u2.closeKey(), "testMerge error 56");
+    REG_ENSURE(!key1u2.openKey("/MergeKey1u2/MK2SubKey21/KeyWithBinaryValue", mkey1u2), "testMerge error 57");
+    REG_ENSURE(!mkey1u2.closeKey(), "testMerge error 58");
+
+    REG_ENSURE(!key1u2.openKey("/MergeKey1u2/MK2SubKey22", mkey1u2), "testMerge error 59");
+    REG_ENSURE(!mkey1u2.closeKey(), "testMerge error 60");
+    REG_ENSURE(!key1u2.openKey("/MergeKey1u2/MK2SubKey22/KeyWithLongValue", mkey1u2), "testMerge error 61");
+    REG_ENSURE(!mkey1u2.closeKey(), "testMerge error 62");
+
+    REG_ENSURE(!key1u2.openKey("/MergeKey1u2/MK2SubKey23", mkey1u2), "testMerge error 63");
+    REG_ENSURE(!mkey1u2.closeKey(), "testMerge error 64");
+    REG_ENSURE(!key1u2.openKey("/MergeKey1u2/MK2SubKey23/KeyWithStringValue", mkey1u2), "testMerge error 65");
+    REG_ENSURE(!mkey1u2.closeKey(), "testMerge error 66");
+
+    REG_ENSURE(!key1u2.openKey("/MergeKey1u2/MK12SubKey1u2", mkey1u2), "testMerge error 67");
+    REG_ENSURE(!mkey1u2.closeKey(), "testMerge error 68");
+    REG_ENSURE(!key1u2.openKey("/MergeKey1u2/MK12SubKey1u2/KeyWithLongValue", mkey1u2), "testMerge error 69");
+    REG_ENSURE(!mkey1u2.closeKey(), "testMerge error 70");
+
+    REG_ENSURE(!key1u2.closeKey(), "testMerge error 71");
+
+
+    RegValueType    valueType;
+    sal_uInt32          valueSize;
+    sal_Int32           int32Value;
+    sal_uInt8           *Value;
+
+    REG_ENSURE(!rootKey.openKey("/stardiv/IchbineinMergeKey", key1), "testMerge error 72");
+
+    REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey1/MK1SubKey1/KeyWithLongValue"), &valueType, &valueSize), "testMerge error 73");
+    REG_ENSURE(valueType == RegValueType::LONG && valueSize == sizeof(sal_Int32), "testMerge error 74");
+    REG_ENSURE(!key1.getValue(OUString("/MergeKey1/MK1SubKey1/KeyWithLongValue"), (RegValue)&int32Value), "testMerge error 74.a)");
+    REG_ENSURE(int32Value == lValue1, "testMerge error 74.b)");
+
+    REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey1/MK1SubKey2/KeyWithStringValue"), &valueType, &valueSize), "testMerge error 75");
+    REG_ENSURE(valueType == RegValueType::STRING && valueSize == strlen(sValue)+1, "testMerge error 76");
+    Value = new sal_uInt8[valueSize];
+    REG_ENSURE(!key1.getValue(OUString("/MergeKey1/MK1SubKey2/KeyWithStringValue"), (RegValue)Value), "testMerge error 76.a)");
+    REG_ENSURE(strcmp((const char*)Value, sValue) == 0, "testMerge error 76.b)");
+    delete [] Value;
+
+    REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey1/MK1SubKey3/KeyWithUnicodeValue"), &valueType, &valueSize), "testMerge error 77");
+    REG_ENSURE(valueType == RegValueType::UNICODE && valueSize == (wValue.getLength()+1)*sizeof(sal_Unicode), "testMerge error 78");
+    Value = new sal_uInt8[valueSize];
+    REG_ENSURE(!key1.getValue(OUString("/MergeKey1/MK1SubKey3/KeyWithUnicodeValue"), (RegValue)Value), "testMerge error 78.a)");
+    REG_ENSURE(wValue.equals( (const sal_Unicode*)Value ), "testMerge error 78.b)");
+    delete [] Value;
+
+    REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey1/MK1SubKey4/KeyWithBinaryValue"), &valueType, &valueSize), "testMerge error 79");
+    REG_ENSURE(valueType == RegValueType::BINARY && valueSize == 27, "testMerge error 80");
+    Value = new sal_uInt8[valueSize];
+    REG_ENSURE(!key1.getValue(OUString("/MergeKey1/MK1SubKey4/KeyWithBinaryValue"), (RegValue)Value), "testMerge error 80.a)");
+    REG_ENSURE(strcmp((const char*)Value, "abcdefghijklmnopqrstuvwxyz") == 0, "testMerge error 80.b)");
+    delete [] Value;
+
+    REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey2/MK2SubKey1/KeyWithBinaryValue"), &valueType, &valueSize), "testMerge error 81");
+    REG_ENSURE(valueType == RegValueType::BINARY && valueSize == 11, "testMerge error 82");
+    Value = new sal_uInt8[valueSize];
+    REG_ENSURE(!key1.getValue(OUString("/MergeKey2/MK2SubKey1/KeyWithBinaryValue"), (RegValue)Value), "testMerge error 82.a)");
+    REG_ENSURE(strcmp((const char*)Value, "1234567890") == 0, "testMerge error 82.b)");
+    delete [] Value;
+
+    REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey2/MK2SubKey2/KeyWithUnicodeValue"), &valueType, &valueSize), "testMerge error 83");
+    REG_ENSURE(valueType == RegValueType::UNICODE&& valueSize == (wValue.getLength()+1)*sizeof(sal_Unicode), "testMerge error 84");
+    Value = new sal_uInt8[valueSize];
+    REG_ENSURE(!key1.getValue(OUString("/MergeKey2/MK2SubKey2/KeyWithUnicodeValue"), (RegValue)Value), "testMerge error 84.a)");
+    REG_ENSURE(wValue.equals( (const sal_Unicode*)Value ), "testMerge error 84.b)");
+    delete [] Value;
+
+    REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey2/MK2SubKey3/KeyWithStringValue"), &valueType, &valueSize), "testMerge error 85");
+    REG_ENSURE(valueType == RegValueType::STRING && valueSize == strlen(sValue)+1, "testMerge error 86");
+    Value = new sal_uInt8[valueSize];
+    REG_ENSURE(!key1.getValue(OUString("/MergeKey2/MK2SubKey3/KeyWithStringValue"), (RegValue)Value), "testMerge error 86.a)");
+    REG_ENSURE(strcmp((const char*)Value, sValue) == 0, "testMerge error 86.b)");
+    delete [] Value;
+
+    REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey2/MK2SubKey4/KeyWithLongValue"), &valueType, &valueSize), "testMerge error 87");
+    REG_ENSURE(valueType == RegValueType::LONG && valueSize == sizeof(sal_Int32), "testMerge error 88");
+    REG_ENSURE(!key1.getValue(OUString("/MergeKey2/MK2SubKey4/KeyWithLongValue"), (RegValue)&int32Value), "testMerge error 88.a)");
+    REG_ENSURE(int32Value == lValue1, "testMerge error 88.b)");
+
+    REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey1u2/MK1SubKey11/KeyWithLongValue"), &valueType, &valueSize), "testMerge error 89");
+    REG_ENSURE(valueType == RegValueType::LONG && valueSize == sizeof(sal_Int32), "testMerge error 90");
+    REG_ENSURE(!key1.getValue(OUString("/MergeKey1u2/MK1SubKey11/KeyWithLongValue"), (RegValue)&int32Value), "testMerge error 90.a)");
+    REG_ENSURE(int32Value == lValue2, "testMerge error 90.b)");
+
+    REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey1u2/MK1SubKey12/KeyWithStringValue"), &valueType, &valueSize), "testMerge error 91");
+    REG_ENSURE(valueType == RegValueType::STRING && valueSize == strlen(sValue)+1, "testMerge error 92");
+    Value = new sal_uInt8[valueSize];
+    REG_ENSURE(!key1.getValue(OUString("/MergeKey1u2/MK1SubKey12/KeyWithStringValue"), (RegValue)Value), "testMerge error 92.a)");
+    REG_ENSURE(strcmp((const char*)Value, sValue) == 0, "testMerge error 92.b)");
+    delete [] Value;
+
+    REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey1u2/MK1SubKey13/KeyWithUnicodeValue"), &valueType, &valueSize), "testMerge error 93");
+    REG_ENSURE(valueType == RegValueType::UNICODE && valueSize == (wValue.getLength()+1)*sizeof(sal_Unicode), "testMerge error 94");
+    Value = new sal_uInt8[valueSize];
+    REG_ENSURE(!key1.getValue(OUString("/MergeKey1u2/MK1SubKey13/KeyWithUnicodeValue"), (RegValue)Value), "testMerge error 94.a)");
+    REG_ENSURE(wValue.equals( (const sal_Unicode*)Value ), "testMerge error 94.b)");
+    delete [] Value;
+
+    REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey1u2/MK2SubKey21/KeyWithBinaryValue"), &valueType, &valueSize), "testMerge error 95");
+    REG_ENSURE(valueType == RegValueType::BINARY && valueSize == 19, "testMerge error 96");
+    Value = new sal_uInt8[valueSize];
+    REG_ENSURE(!key1.getValue(OUString("/MergeKey1u2/MK2SubKey21/KeyWithBinaryValue"), (RegValue)Value), "testMerge error 96.a)");
+    REG_ENSURE(strcmp((const char*)Value, "a1b2c3d4e5f6g7h8i9") == 0, "testMerge error 96.b)");
+    delete [] Value;
+
+    REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey1u2/MK2SubKey22/KeyWithLongValue"), &valueType, &valueSize), "testMerge error 97");
+    REG_ENSURE(valueType == RegValueType::LONG && valueSize == sizeof(sal_Int32), "testMerge error 98");
+    REG_ENSURE(!key1.getValue(OUString("/MergeKey1u2/MK2SubKey22/KeyWithLongValue"), (RegValue)&int32Value), "testMerge error 98.a)");
+    REG_ENSURE(int32Value == lValue2, "testMerge error 98.b)");
+
+    REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey1u2/MK2SubKey23/KeyWithStringValue"), &valueType, &valueSize), "testMerge error 99");
+    REG_ENSURE(valueType == RegValueType::STRING && valueSize == strlen(sValue)+1, "testMerge error 100");
+    Value = new sal_uInt8[valueSize];
+    REG_ENSURE(!key1.getValue(OUString("/MergeKey1u2/MK2SubKey23/KeyWithStringValue"), (RegValue)Value), "testMerge error 100.a)");
+    REG_ENSURE(strcmp((const char*)Value, sValue) == 0, "testMerge error 100.b)");
+    delete [] Value;
+
+    REG_ENSURE(!key1.getValueInfo(OUString("/MergeKey1u2/MK12SubKey1u2/KeyWithLongValue"), &valueType, &valueSize), "testMerge error 101");
+    REG_ENSURE(valueType == RegValueType::LONG && valueSize == sizeof(sal_Int32), "testMerge error 102");
+    REG_ENSURE(!key1.getValue(OUString("/MergeKey1u2/MK12SubKey1u2/KeyWithLongValue"), (RegValue)&int32Value), "testMerge error 102.a)");
+    REG_ENSURE(int32Value == lValue4, "testMerge error 102.b)");
+
+
+    REG_ENSURE(!key1.closeKey(), "testMerge error 24");
+
+
+    REG_ENSURE(!rootKey.closeKey(), "testMerge error 10");
+
+    REG_ENSURE(!myRegistry->destroy( OUString("merge1.rdb") ), "test_registry_CppApi error 11");
+    REG_ENSURE(!myRegistry->destroy( OUString("merge2.rdb") ), "test_registry_CppApi error 12");
+    REG_ENSURE(!myRegistry->destroy( OUString() ), "test_registry_CppApi error 13");
+
+    delete myRegistry;
+
+    std::cout << "test_merge() Ok!\n";
+    return;
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/registry/test/testregcpp.cxx b/registry/test/testregcpp.cxx
new file mode 100644
index 000000000..6d545359b
--- /dev/null
+++ b/registry/test/testregcpp.cxx
@@ -0,0 +1,696 @@
+/* -*- 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 <iostream>
+#include <stdio.h>
+#include <string.h>
+
+#include "registry/registry.hxx"
+#include "registry/reflread.hxx"
+#include "registry/reflwrit.hxx"
+#include "regdiagnose.h"
+#include <rtl/alloc.h>
+#include <rtl/ustring.hxx>
+
+
+void test_coreReflection()
+{
+    Registry *myRegistry = new Registry();
+
+    RegistryKey rootKey, key1, key2, key3, key4 ,key5, key6, key7, key8;
+
+    REG_ENSURE(!myRegistry->create(OUString("ucrtest.rdb")), "testCoreReflection error 1");
+    REG_ENSURE(!myRegistry->openRootKey(rootKey), "testCoreReflection error 2");
+
+    REG_ENSURE(!rootKey.createKey(OUString("UCR"), key1), "testCoreReflection error 3");
+    REG_ENSURE(!key1.createKey(OUString("ModuleA"), key2), "testCoreReflection error 4");
+    REG_ENSURE(!key2.createKey(OUString("StructA"), key3), "testCoreReflection error 5");
+    REG_ENSURE(!key2.createKey(OUString("EnumA"), key4), "testCoreReflection error 6");
+    REG_ENSURE(!key2.createKey(OUString("XInterfaceA"), key5), "testCoreReflection error 7");
+    REG_ENSURE(!key2.createKey(OUString("ExceptionA"), key6), "testCoreReflection error 8");
+    REG_ENSURE(!key2.createKey(OUString("ServiceA"), key7), "testCoreReflection error 8a");
+    REG_ENSURE(!key2.createKey(OUString("ConstantsA"), key8), "testCoreReflection error 8b");
+
+    {
+        RegistryTypeWriter writer(RT_TYPE_MODULE,
+                                  OUString("ModuleA"),
+                                  OUString(), 11, 0, 0);
+
+        RTConstValue aConst;
+
+        writer.setDoku(OUString("Hello I am a module"));
+        writer.setFileName(OUString("DummyFile"));
+
+        aConst.m_type = RT_TYPE_BOOL;
+        aConst.m_value.aBool = sal_True;
+        writer.setFieldData(0, OUString("aConstBool"),
+                            OUString("boolean"),
+                            OUString("I am a boolean"),
+                            OUString("DummyFile"), RTFieldAccess::CONST, aConst);
+        aConst.m_type = RT_TYPE_BYTE;
+        aConst.m_value.aByte = 127;
+        writer.setFieldData(1, OUString("aConstByte"),
+                            OUString("byte"),
+                            OUString("I am a byte"),
+                            OUString("DummyFile"),  RTFieldAccess::CONST, aConst);
+        aConst.m_type = RT_TYPE_INT16;
+        aConst.m_value.aShort = -10;
+        writer.setFieldData(2, OUString("aConstShort"),
+                            OUString("short"),
+                            OUString("I am a short"),
+                            OUString("DummyFile"),  RTFieldAccess::CONST, aConst);
+        aConst.m_type = RT_TYPE_UINT16;
+        aConst.m_value.aUShort = 10;
+        writer.setFieldData(3, OUString("aConstUShort"),
+                            OUString("unsigned short"),
+                            OUString("I am an unsigned short"),
+                            OUString("DummyFile"), RTFieldAccess::CONST, aConst);
+        aConst.m_type = RT_TYPE_INT32;
+        aConst.m_value.aLong = -100000;
+        writer.setFieldData(4, OUString("aConstLong"),
+                            OUString("long"),
+                            OUString("I am a long"),
+                            OUString("DummyFile"), RTFieldAccess::CONST, aConst);
+        aConst.m_type = RT_TYPE_UINT32;
+        aConst.m_value.aULong = 100000;
+        writer.setFieldData(5, OUString("aConstULong"),
+                            OUString("unsigned long"),
+                            OUString("I am an unsigned long"),
+                            OUString("DummyFile"), RTFieldAccess::CONST, aConst);
+        aConst.m_type = RT_TYPE_INT64;
+        aConst.m_value.aHyper = -100000000;
+        writer.setFieldData(6, OUString("aConstHyper"),
+                            OUString("hyper"),
+                            OUString("I am an hyper"),
+                            OUString("DummyFile"), RTFieldAccess::CONST, aConst);
+        aConst.m_type = RT_TYPE_UINT64;
+        aConst.m_value.aUHyper = 100000000;
+        writer.setFieldData(7, OUString("aConstULong"),
+                            OUString("unsigned long"),
+                            OUString("I am an unsigned long"),
+                            OUString("DummyFile"), RTFieldAccess::CONST, aConst);
+        aConst.m_type = RT_TYPE_FLOAT;
+        aConst.m_value.aFloat = -2e-10f;
+        writer.setFieldData(8, OUString("aConstFloat"),
+                            OUString("float"),
+                            OUString("I am a float"),
+                            OUString("DummyFile"), RTFieldAccess::CONST, aConst);
+        aConst.m_type = RT_TYPE_DOUBLE;
+        aConst.m_value.aDouble = -2e-100; writer.setFieldData(9, OUString("aConstDouble"),
+                                                              OUString("double"),
+                                                              OUString("I am a double"),
+                                                              OUString("DummyFile"), RTFieldAccess::CONST, aConst);
+        aConst.m_type = RT_TYPE_STRING;
+        OUString tmpStr("this is a unicode string");
+        aConst.m_value.aString = tmpStr.getStr();
+
+        writer.setFieldData(10, OUString("aConstString"),
+                            OUString("string"),
+                            OUString("I am a string"),
+                            OUString("DummyFile"), RTFieldAccess::CONST, aConst);
+
+        const sal_uInt8* pBlop = writer.getBlop();
+        sal_uInt32      aBlopSize = writer.getBlopSize();
+
+        REG_ENSURE(!key2.setValue(OUString(), RegValueType::BINARY, (void*)pBlop, aBlopSize), "testCoreReflection error 9");
+
+        sal_uInt8* readBlop = (sal_uInt8*)std::malloc(aBlopSize);
+        REG_ENSURE(!key2.getValue(OUString(), (void*)readBlop) , "testCoreReflection error 9a");
+
+        RegistryTypeReader reader(readBlop, aBlopSize, sal_True);
+
+        if (reader.isValid())
+        {
+            REG_ENSURE(reader.getTypeName() == "ModuleA", "testCoreReflection error 9a2");
+
+            RTConstValue aReadConst = reader.getFieldConstValue(4);
+            REG_ENSURE( aReadConst.m_type == RT_TYPE_INT32, "testCoreReflection error 9a3");
+            REG_ENSURE( aReadConst.m_value.aLong == -100000, "testCoreReflection error 9a4");
+
+            aReadConst = reader.getFieldConstValue(6);
+            REG_ENSURE( aReadConst.m_type == RT_TYPE_INT64, "testCoreReflection error 9a5");
+            REG_ENSURE( aReadConst.m_value.aHyper == -100000000, "testCoreReflection error 9a6");
+
+            aReadConst = reader.getFieldConstValue(10);
+            OString aConstStr = OUStringToOString(aConst.m_value.aString, RTL_TEXTENCODING_ASCII_US);
+            REG_ENSURE(aConstStr.equals("this is a unicode string"), "testCoreReflection error 9b");
+        }
+
+    }
+
+    {
+        RegistryTypeWriter writer(RT_TYPE_STRUCT,
+                                  OUString("ModuleA/StructA"),
+                                  OUString(), 3, 0, 0);
+
+        writer.setDoku(OUString("Hello I am a structure"));
+        writer.setFileName(OUString("DummyFile"));
+
+        writer.setFieldData(0, OUString("asal_uInt32"),
+                            OUString("unsigned long"),
+                            OUString(), OUString(), RTFieldAccess::READWRITE);
+        writer.setFieldData(1, OUString("aXInterface"),
+                            OUString("stardiv/uno/XInterface"),
+                            OUString(), OUString(), RTFieldAccess::READWRITE);
+        writer.setFieldData(2, OUString("aSequence"),
+                            OUString("[]ModuleA/EnumA"),
+                            OUString(), OUString(), RTFieldAccess::READWRITE);
+
+        const sal_uInt8* pBlop = writer.getBlop();
+        sal_uInt32      aBlopSize = writer.getBlopSize();
+
+        REG_ENSURE(!key3.setValue(OUString(), RegValueType::BINARY, (void*)pBlop, aBlopSize), "testCoreReflection error 9a");
+    }
+
+    {
+        RegistryTypeWriter writer(RT_TYPE_ENUM,
+                                  OUString("ModuleA/EnumA"),
+                                  OUString(), 2, 0, 0);
+
+        RTConstValue aConst;
+
+        aConst.m_type = RT_TYPE_UINT32;
+        aConst.m_value.aULong = 10;
+
+        writer.setDoku(OUString("Hello I am an enum"));
+        writer.setFileName(OUString("DummyFile"));
+
+        writer.setFieldData(0, OUString("ENUM_VAL_1"),
+                            OUString(), OUString("I am an enum value"),
+                            OUString(), RTFieldAccess::CONST, aConst);
+
+        aConst.m_value.aULong = 10;
+        writer.setFieldData(1, OUString("ENUM_VAL_2"),
+                            OUString(), OUString(), OUString(), RTFieldAccess::CONST, aConst);
+
+        const sal_uInt8* pBlop = writer.getBlop();
+        sal_uInt32      aBlopSize = writer.getBlopSize();
+
+        REG_ENSURE(!key4.setValue(OUString(), RegValueType::BINARY, (void*)pBlop, aBlopSize), "testCoreReflection error 9b");
+    }
+
+    {
+        RegistryTypeWriter writer(RT_TYPE_INTERFACE,
+                                  OUString("ModuleA/XInterfaceA"),
+                                  OUString("stardiv/uno/XInterface"),
+                                  4, 1, 0);
+        RTConstValue aConst;
+
+        RTUik aUik = {1,2,3,4,5};
+
+        writer.setUik(aUik);
+        writer.setDoku(OUString("Hello I am an interface"));
+        writer.setFileName(OUString("DummyFile"));
+
+        writer.setFieldData(0, OUString("aString"),
+                            OUString("string"), OUString(), OUString(), RTFieldAccess::READWRITE);
+        writer.setFieldData(1, OUString("aStruct"),
+                            OUString("ModuleA/StructA"),
+                            OUString(), OUString(), RTFieldAccess::READONLY);
+        writer.setFieldData(2, OUString("aEnum"),
+                            OUString("ModuleA/EnumA"), OUString(), OUString(), RTFieldAccess::BOUND);
+        aConst.m_type = RT_TYPE_UINT16;
+        aConst.m_value.aUShort = 12;
+        writer.setFieldData(3, OUString("aConstUShort"),
+                            OUString("unsigned short"), OUString(),
+                            OUString("DummyFile"), RTFieldAccess::CONST, aConst);
+
+        writer.setMethodData(0, OUString("methodA"),
+                             OUString("double"), RTMethodMode::TWOWAY, 2, 1,
+                             OUString("Hello I am the methodA"));
+        writer.setParamData(0, 0, OUString("ModuleA/StructA"),
+                            OUString("aStruct"), RT_PARAM_IN);
+        writer.setParamData(0, 1, OUString("unsigned short"),
+                            OUString("aShort"), RT_PARAM_INOUT);
+        writer.setExcData(0, 0, OUString("ModuleA/ExceptionA"));
+
+        const sal_uInt8* pBlop = writer.getBlop();
+        sal_uInt32      aBlopSize = writer.getBlopSize();
+
+        REG_ENSURE(!key5.setValue(OUString(), RegValueType::BINARY, (void*)pBlop, aBlopSize), "testCoreReflection error 9c");
+
+        sal_uInt8* readBlop = (sal_uInt8*)std::malloc(aBlopSize);
+        REG_ENSURE(!key5.getValue(OUString(), (void*)readBlop) , "testCoreReflection error 9c1");
+
+        RegistryTypeReader reader(readBlop, aBlopSize, sal_True);
+
+        if (reader.isValid())
+        {
+            REG_ENSURE(reader.getTypeName() == "ModuleA/XInterfaceA", "testCoreReflection error 9c2");
+
+            RTUik retUik;
+            reader.getUik(retUik);
+            REG_ENSURE(retUik.m_Data1 = 1, "testCoreReflection error 9c3");
+            REG_ENSURE(retUik.m_Data2 = 2, "testCoreReflection error 9c4");
+            REG_ENSURE(retUik.m_Data3 = 3, "testCoreReflection error 9c5");
+            REG_ENSURE(retUik.m_Data4 = 4, "testCoreReflection error 9c6");
+            REG_ENSURE(retUik.m_Data5 = 5, "testCoreReflection error 9c7");
+        }
+
+    }
+
+    {
+        RegistryTypeWriter writer(RT_TYPE_EXCEPTION,
+                                  OUString("ModuleA/ExceptionA"),
+                                  OUString(), 1, 0, 0);
+
+        writer.setDoku(OUString("Hello I am an exception"));
+
+        writer.setFieldData(0, OUString("aSource"),
+                            OUString("stardiv/uno/XInterface"),
+                            OUString("I am an interface member"),
+                            OUString(), RTFieldAccess::READWRITE);
+
+        const sal_uInt8* pBlop = writer.getBlop();
+        sal_uInt32      aBlopSize = writer.getBlopSize();
+
+        REG_ENSURE(!key6.setValue(OUString(), RegValueType::BINARY, (void*)pBlop, aBlopSize), "testCoreReflection error 9d");
+    }
+
+    {
+        RegistryTypeWriter writer(RT_TYPE_SERVICE,
+                                  OUString("ModuleA/ServiceA"),
+                                  OUString(), 1, 0, 4);
+
+        writer.setDoku(OUString("Hello I am a service"));
+        writer.setFileName(OUString("DummyFile"));
+
+        writer.setFieldData(0, OUString("aProperty"),
+                            OUString("stardiv/uno/XInterface"),
+                            OUString("I am a property"),
+                            OUString(), RTFieldAccess::READWRITE);
+
+        writer.setReferenceData(0, OUString("ModuleA/XInterfaceA"), RTReferenceType::SUPPORTS,
+                                OUString("Hello I am a reference to a supported interface"),
+                                RTFieldAccess::OPTIONAL);
+        writer.setReferenceData(1, OUString("ModuleA/XInterfaceA"), RTReferenceType::OBSERVES,
+                                OUString("Hello I am a reference to an observed interface"));
+        writer.setReferenceData(2, OUString("ModuleA/ServiceB"), RTReferenceType::EXPORTS,
+                                OUString("Hello I am a reference to an exported service"));
+        writer.setReferenceData(3, OUString("ModuleA/ServiceB"), RTReferenceType::NEEDS,
+                                OUString("Hello I am a reference to a needed service"));
+
+        const sal_uInt8* pBlop = writer.getBlop();
+        sal_uInt32      aBlopSize = writer.getBlopSize();
+
+        REG_ENSURE(!key7.setValue(OUString(), RegValueType::BINARY, (void*)pBlop, aBlopSize), "testCoreReflection error 9e");
+        sal_uInt8* readBlop = (sal_uInt8*)std::malloc(aBlopSize);
+        REG_ENSURE(!key7.getValue(OUString(), (void*)readBlop) , "testCoreReflection error 9e2");
+
+        RegistryTypeReader reader(readBlop, aBlopSize, sal_True);
+
+        if (reader.isValid())
+        {
+            REG_ENSURE(reader.getTypeName() == "ModuleA/ServiceA", "testCoreReflection error 9e3");
+
+            sal_uInt32 referenceCount = reader.getReferenceCount();
+            REG_ENSURE( referenceCount == 4, "testCoreReflection error 9e4");
+
+            OUString refName = reader.getReferenceName(0);
+            REG_ENSURE(refName == "ModuleA/XInterfaceA", "testCoreReflection error 9e5");
+        }
+    }
+
+    {
+        RegistryTypeWriter writer(RT_TYPE_CONSTANTS,
+                                  OUString("ModuleA/ConstansA"),
+                                  OUString(), 3, 0, 0);
+
+        RTConstValue aConst;
+
+        writer.setDoku(OUString("Hello I am a constants group"));
+        writer.setFileName(OUString("DummyFile"));
+
+        aConst.m_type = RT_TYPE_BOOL;
+        aConst.m_value.aBool = sal_True;
+        writer.setFieldData(0, OUString("ConstantsA_aConstBool"),
+                            OUString("boolean"),
+                            OUString("I am a boolean"),
+                            OUString("DummyFile"), RTFieldAccess::CONST, aConst);
+        aConst.m_type = RT_TYPE_BYTE;
+        aConst.m_value.aByte = 127;
+        writer.setFieldData(1, OUString("ConstantsA_aConstByte"),
+                            OUString("byte"),
+                            OUString("I am a byte"),
+                            OUString("DummyFile"),  RTFieldAccess::CONST, aConst);
+        aConst.m_type = RT_TYPE_INT16;
+        aConst.m_value.aShort = -10;
+        writer.setFieldData(2, OUString("ConstantsA_aConstShort"),
+                            OUString("short"),
+                            OUString("I am a short"),
+                            OUString("DummyFile"),  RTFieldAccess::CONST, aConst);
+
+        const sal_uInt8* pBlop = writer.getBlop();
+        sal_uInt32      aBlopSize = writer.getBlopSize();
+
+        REG_ENSURE(!key8.setValue(OUString(), RegValueType::BINARY, (void*)pBlop, aBlopSize), "testCoreReflection error 9f");
+    }
+
+//  REG_ENSURE(!myRegistry->destroy(NULL), "testCoreReflection error 10");
+    delete myRegistry;
+
+    std::cout << "test_coreReflection() Ok!\n";
+}
+
+void test_registry_CppApi()
+{
+    Registry *myRegistry = new Registry();
+
+    RegistryKey rootKey, key1, key2, key3, key4 ,key5, key6, key7, key8, key9;
+
+    REG_ENSURE(!myRegistry->create(OUString("test.rdb")), "test_registry_CppApi error 1");
+    REG_ENSURE(!myRegistry->openRootKey(rootKey), "test_registry_CppApi error 2");
+
+    REG_ENSURE(!rootKey.createKey(OUString("myFirstKey"), key1), "test_registry_CppApi error 3");
+    REG_ENSURE(!rootKey.createKey(OUString("mySecondKey"), key2), "test_registry_CppApi error 4");
+    REG_ENSURE(!key1.createKey(OUString("X"), key3), "test_registry_CppApi error 5");
+    REG_ENSURE(!key1.createKey(OUString("mySecondSubKey"), key4), "test_registry_CppApi error 6");
+    REG_ENSURE(!rootKey.createKey(OUString("myThirdKey"), key5), "test_registry_CppApi error 6a");
+
+    REG_ENSURE(!key5.createKey(OUString("1"), key4), "test_registry_CppApi error 6b");
+    REG_ENSURE(!key4.createKey(OUString("2"), key3), "test_registry_CppApi error 6c");
+    REG_ENSURE(!key5.openKey("1", key4), "test_registry_CppApi error 6d");
+    REG_ENSURE(!rootKey.openKey("/myThirdKey/1", key4), "test_registry_CppApi error 6e");
+    REG_ENSURE(key4.getName() == "/myThirdKey/1", "test_registry_CppApi error 6f");
+
+    REG_ENSURE(!rootKey.createKey(OUString("myFourthKey"), key6), "test_registry_CppApi error 7");
+    REG_ENSURE(!rootKey.createKey(OUString("myFifthKey"), key6), "test_registry_CppApi error 7a");
+    REG_ENSURE(!rootKey.createKey(OUString("mySixthKey"), key6), "test_registry_CppApi error 7b");
+
+    // Link Test
+
+
+    REG_ENSURE(!rootKey.createKey(OUString("/myFourthKey/X"), key7), "test_registry_CppApi error 7c)");
+    REG_ENSURE(!key6.createLink(OUString("myFirstLink"), OUString("/myFourthKey/X")), "test_registry_CppApi error 7d");
+    REG_ENSURE(!key6.createKey(OUString("mySixthSubKey"), key7), "test_registry_CppApi error 7e");
+
+    OUString linkTarget;
+    REG_ENSURE(!key6.getLinkTarget(OUString("myFirstLink"), linkTarget), "test_registry_CppApi error 7f");
+    REG_ENSURE(linkTarget == "/myFourthKey/X", "test_registry_CppApi error 7g");
+
+    RegistryKeyNames* pSubKeyNames = new RegistryKeyNames();
+    sal_uInt32           nSubKeys=0;
+
+    REG_ENSURE(!rootKey.getKeyNames(OUString("mySixthKey"), *pSubKeyNames), "test_registry_CppApi error 7h)");
+    REG_ENSURE(pSubKeyNames->getLength() == 2, "test_registry_CppApi error 7i)");
+
+    for (sal_uInt32 i=0; i < pSubKeyNames->getLength(); i++)
+    {
+        if ( pSubKeyNames->getElement(i) == "/mySixthKey/myFirstLink" )
+        {
+            RegKeyType keyType;
+            REG_ENSURE(!rootKey.getKeyType(pSubKeyNames->getElement(i), &keyType), "test_registry_CppApi error 7j");
+            REG_ENSURE(keyType == RG_LINKTYPE, "test_registry_CppApi error 7k");
+        }
+    }
+
+    REG_ENSURE(!key7.closeKey(), "test_registry_CppApi error 7k1");
+    delete pSubKeyNames;
+
+    REG_ENSURE(!rootKey.openKey("/mySixthKey/myFirstLink", key6), "test_registry_CppApi error 7l");
+//    REG_ENSURE(key6.getName() == "/myFourthKey/X", "test_registry_CppApi error 7m");
+
+    REG_ENSURE(!rootKey.openKey("myFifthKey", key6), "test_registry_CppApi error 7m1");
+    REG_ENSURE(!key6.createLink(OUString("mySecondLink"),
+                                 OUString("/mySixthKey/myFirstLink")), "test_registry_CppApi error 7m2");
+
+    REG_ENSURE(!rootKey.openKey("/myFifthKey/mySecondLink", key6), "test_registry_CppApi error 7m3");
+//    REG_ENSURE(key6.getName() == "/myFourthKey/X", "test_registry_CppApi error 7m4");
+
+    REG_ENSURE(!rootKey.createKey(OUString("/myFifthKey/mySecondLink/myFirstLinkSubKey"), key7), "test_registry_CppApi error 7m5");
+    REG_ENSURE(key7.getName() == "/myFourthKey/X/myFirstLinkSubKey", "test_registry_CppApi error 7m6");
+
+    REG_ENSURE(!key7.createLink(OUString("myThirdLink"), OUString("/myFifthKey/mySecondLink")), "test_registry_CppApi error 7m7");
+    REG_ENSURE(!rootKey.openKey("/myFourthKey/X/myFirstLinkSubKey/myThirdLink", key7), "test_registry_CppApi error 7m8");
+//    REG_ENSURE(!key7.openKey("/myFirstLinkSubKey/myThirdLink/myFirstLinkSubKey/myThirdLink", key6), "test_registry_CppApi error 7m9");
+//    REG_ENSURE(key7.getName() == "/myFourthKey/X", "test_registry_CppApi error 7m10");
+    REG_ENSURE(!key7.closeKey(), "test_registry_CppApi error 7m11");
+
+    REG_ENSURE(!rootKey.deleteLink(OUString("/myFifthKey/mySecondLink")), "test_registry_CppApi error 7m12");
+
+    REG_ENSURE(!rootKey.createLink(OUString("/myFifthKey/mySecondLink"),
+                                    OUString("/myFourthKey/X/myFirstLinkSubKey/myThirdLink")),
+                                    "test_registry_CppApi error 7m13");
+
+//    REG_ENSURE(rootKey.openKey("/myFourthKey/X/myFirstLinkSubKey/myThirdLink", key7) == REG_DETECT_RECURSION,
+//                "test_registry_CppApi error 7m14");
+
+//    REG_ENSURE(key7.closeKey() == REG_INVALID_KEY, "test_registry_CppApi error 7m11");
+
+    RegistryKeyNames subKeyNames;
+    nSubKeys=0;
+
+    REG_ENSURE(!rootKey.getKeyNames(OUString("mySixthKey"), subKeyNames), "test_registry_CppApi error 7n");
+
+    nSubKeys = subKeyNames.getLength();
+    REG_ENSURE(nSubKeys == 2, "test_registry_CppApi error 7n1");
+    REG_ENSURE(subKeyNames.getElement(0) == "/mySixthKey/myFirstLink", "test_registry_CppApi error 7p1)");
+    REG_ENSURE(subKeyNames.getElement(1) =="/mySixthKey/mySixthSubKey", "test_registry_CppApi error 7p2");
+
+
+    RegistryKeyArray subKeys;
+    nSubKeys=0;
+
+    REG_ENSURE(!rootKey.openSubKeys(OUString("myFirstKey"), subKeys), "test_registry_CppApi error 7o");
+
+    nSubKeys = subKeys.getLength();
+    REG_ENSURE(nSubKeys == 2, "test_registry_CppApi error 7o1");
+    REG_ENSURE(subKeys.getElement(0).getName() == "/myFirstKey/mySecondSubKey", "test_registry_CppApi error 7p1)");
+    REG_ENSURE(subKeys.getElement(1).getName() == "/myFirstKey/X", "test_registry_CppApi error 7p2");
+
+    REG_ENSURE(!rootKey.closeSubKeys(subKeys), "test_registry_CppApi error 7q)");
+
+
+    REG_ENSURE(!rootKey.createKey(OUString("/TEST"), key8), "test_registry_CppApi error 8");
+    REG_ENSURE(!rootKey.createKey(OUString("/TEST/Child1"), key8), "test_registry_CppApi error 8a");
+    REG_ENSURE(!rootKey.createKey(OUString("/TEST/Child2"), key8), "test_registry_CppApi error 8a1");
+    REG_ENSURE(!rootKey.openKey("/TEST", key9), "test_registry_CppApi error 8b");
+    REG_ENSURE(!key8.closeKey() && !key9.closeKey(),  "test_registry_CppApi error 8b1");
+    REG_ENSURE(!rootKey.openKey("/TEST", key8), "test_registry_CppApi error 8b");
+    REG_ENSURE(!key8.closeKey(),  "test_registry_CppApi error 8c");
+    REG_ENSURE(!rootKey.openKey("TEST", key8), "test_registry_CppApi error 8c");
+    REG_ENSURE(!key8.closeKey(),  "test_registry_CppApi error 8d");
+
+
+    char* Value=(char*)"My first value";
+    REG_ENSURE(!rootKey.setValue(OUString("mySecondKey"), RegValueType::STRING, Value, 18), "test_registry_CppApi error 9");
+
+    RegValueType    valueType;
+    sal_uInt32          valueSize;
+    char*           readValue;
+    REG_ENSURE(!rootKey.getValueInfo(OUString("mySecondKey"), &valueType, &valueSize), "test_registry_CppApi error 9a");
+
+    readValue = (char*)std::malloc(valueSize);
+    REG_ENSURE(!key2.getValue(OUString(), readValue), "test_registry_CppApi error 10");
+
+    REG_ENSURE(valueType == RegValueType::STRING, "test_registry_CppApi error 11");
+    REG_ENSURE(valueSize == 18, "test_registry_CppApi error 12");
+    REG_ENSURE(strcmp(readValue, Value) == 0, "test_registry_CppApi error 13");
+    std::free(readValue);
+
+    const char* pList[3];
+    const char* n1= "Hello";
+    const char* n2= "now I";
+    const char* n3= "come";
+
+    pList[0]=n1;
+    pList[1]=n2;
+    pList[2]=n3;
+
+    REG_ENSURE(!rootKey.setStringListValue(OUString("myFourthKey"), (char**)pList, 3), "test_registry_CppApi error 13a");
+
+    RegistryValueList<char*> valueList;
+    REG_ENSURE(!rootKey.getStringListValue(OUString("myFourthKey"), valueList), "test_registry_CppApi error 13b");
+
+    REG_ENSURE(strcmp(n1, valueList.getElement(0)) == 0, "test_registry_CppApi error 13c");
+    REG_ENSURE(strcmp(n2, valueList.getElement(1)) == 0, "test_registry_CppApi error 13d");
+    REG_ENSURE(strcmp(n3, valueList.getElement(2)) == 0, "test_registry_CppApi error 13e");
+
+    REG_ENSURE(!rootKey.getValueInfo(OUString("myFourthKey"), &valueType, &valueSize), "test_registry_CppApi error 13e1");
+    REG_ENSURE(valueType == RegValueType::STRINGLIST, "test_registry_CppApi error 13e2");
+    REG_ENSURE(valueSize == 3, "test_registry_CppApi error 13e3");
+
+    sal_Int32 pLong[3];
+    pLong[0] = 123;
+    pLong[1] = 456;
+    pLong[2] = 789;
+
+    REG_ENSURE(!rootKey.setLongListValue(OUString("myFifthKey"), pLong, 3), "test_registry_CppApi error 13f");
+
+    RegistryValueList<sal_Int32> longList;
+    REG_ENSURE(!rootKey.getLongListValue(OUString("myFifthKey"), longList), "test_registry_CppApi error 13g");
+
+    REG_ENSURE(pLong[0] == longList.getElement(0), "test_registry_CppApi error 13h");
+    REG_ENSURE(pLong[1] == longList.getElement(1), "test_registry_CppApi error 13i");
+    REG_ENSURE(pLong[2] == longList.getElement(2), "test_registry_CppApi error 13j");
+
+
+    OUString sWTestValue("My first unicode value");
+    const sal_Unicode* wTestValue= sWTestValue.getStr();
+    REG_ENSURE(!rootKey.setValue(OUString("mySixthKey"), RegValueType::UNICODE, (void*)wTestValue,
+                (rtl_ustr_getLength(wTestValue)+1)*sizeof(sal_Unicode)), "test_registry_CppApi error 13j1");
+
+    REG_ENSURE(!rootKey.getValueInfo(OUString("mySixthKey"), &valueType, &valueSize), "test_registry_CppApi error 13j2");
+    sal_Unicode* pTmpValue = (sal_Unicode*)std::malloc(valueSize);
+    REG_ENSURE(!rootKey.getValue(OUString("mySixthKey"), pTmpValue), "test_registry_CppApi error 13j3");
+    REG_ENSURE(rtl_ustr_getLength(wTestValue) == rtl_ustr_getLength(pTmpValue), "test_registry_CppApi error 13j4");
+    REG_ENSURE(rtl_ustr_compare(wTestValue, pTmpValue) == 0, "test_registry_CppApi error 13j4");
+
+    const sal_Unicode* pUnicode[3];
+    OUString w1("Hello");
+    OUString w2("now I");
+    OUString w3("come as unicode");
+
+    pUnicode[0]=w1.getStr();
+    pUnicode[1]=w2.getStr();
+    pUnicode[2]=w3.getStr();
+
+    REG_ENSURE(!rootKey.setUnicodeListValue(OUString("mySixthKey"), (sal_Unicode**)pUnicode, 3), "test_registry_CppApi error 13k");
+
+    RegistryValueList<sal_Unicode*> unicodeList;
+    REG_ENSURE(!rootKey.getUnicodeListValue(OUString("mySixthKey"), unicodeList), "test_registry_CppApi error 13l");
+
+    REG_ENSURE(rtl_ustr_compare(w1, unicodeList.getElement(0)) == 0, "test_registry_CppApi error 13m");
+    REG_ENSURE(rtl_ustr_compare(w2, unicodeList.getElement(1)) == 0, "test_registry_CppApi error 13n");
+    REG_ENSURE(rtl_ustr_compare(w3, unicodeList.getElement(2)) == 0, "test_registry_CppApi error 13o");
+
+    REG_ENSURE(!key6.closeKey(),  "test_registry_CppApi error 14");
+
+    REG_ENSURE(!key1.closeKey() &&
+               !key3.closeKey() &&
+               !key4.closeKey(),  "test_registry_CppApi error 14");
+
+    REG_ENSURE(!rootKey.deleteKey(OUString("myFirstKey")), "test_registry_CppApi error 15");
+
+    REG_ENSURE(!key2.closeKey(), "test_registry_CppApi error 16");
+    REG_ENSURE(!rootKey.openKey("mySecondKey", key2), "test_registry_CppApi error 17");
+
+    REG_ENSURE(!key5.closeKey(), "test_registry_CppApi error 18");
+
+    REG_ENSURE(!rootKey.deleteKey(OUString("myThirdKey")), "test_registry_CppApi error 19");
+
+    REG_ENSURE(rootKey.openKey("myThirdKey", key5), "test_registry_CppApi error 20");
+
+    REG_ENSURE(!key2.closeKey() &&
+                !rootKey.closeKey(),  "test_registry_CppApi error 21");
+
+    REG_ENSURE(!myRegistry->close(), "test_registry_CppApi error 22");
+
+    // Test loadkey
+    RegistryKey rootKey2, key21, key22, key23, key24 , key25;
+
+    REG_ENSURE(!myRegistry->create(OUString("test2.rdb")), "test_registry_CppApi error 23");
+    REG_ENSURE(!myRegistry->openRootKey(rootKey2), "test_registry_CppApi error 24");
+
+    REG_ENSURE(!rootKey2.createKey(OUString("reg2FirstKey"), key21), "test_registry_CppApi error 25");
+    REG_ENSURE(!rootKey2.createKey(OUString("reg2SecondKey"), key22), "test_registry_CppApi error 26");
+    REG_ENSURE(!key21.createKey(OUString("reg2FirstSubKey"), key23), "test_registry_CppApi error 27");
+    REG_ENSURE(!key21.createKey(OUString("reg2SecondSubKey"), key24), "test_registry_CppApi error 28");
+    REG_ENSURE(!rootKey2.createKey(OUString("reg2ThirdKey"), key25), "test_registry_CppApi error 29");
+
+    sal_uInt32 nValue= 123456789;
+    REG_ENSURE(!key23.setValue(OUString(), RegValueType::LONG, &nValue, sizeof(sal_uInt32)), "test_registry_CppApi error 30");
+
+    REG_ENSURE(!key21.closeKey() &&
+               !key22.closeKey() &&
+               !key23.closeKey() &&
+               !key24.closeKey() &&
+               !key25.closeKey() &&
+               !rootKey2.closeKey(), "test_registry_CppApi error 31");
+
+    REG_ENSURE(!myRegistry->close(), "test_registry_CppApi error 32");
+
+    REG_ENSURE(!myRegistry->open(OUString("test.rdb"), RegAccessMode::READWRITE), "test_registry_CppApi error 33");
+    REG_ENSURE(!myRegistry->openRootKey(rootKey), "test_registry_CppApi error 34");
+
+    REG_ENSURE(!myRegistry->loadKey(rootKey, OUString("allFromTest2"),
+                    OUString("test2.rdb")), "test_registry_CppApi error 35");
+    REG_ENSURE(!myRegistry->saveKey(rootKey, OUString("allFromTest2"),
+                    OUString("test3.rdb")), "test_registry_CppApi error 36");
+
+    REG_ENSURE(!rootKey.createKey(OUString("allFromTest3"), key1), "test_registry_CppApi error 37");
+    REG_ENSURE(!key1.createKey(OUString("myFirstKey2"), key2), "test_registry_CppApi error 38");
+    REG_ENSURE(!key1.createKey(OUString("mySecondKey2"), key3), "test_registry_CppApi error 39");
+
+    REG_ENSURE(!myRegistry->mergeKey(rootKey, OUString("allFromTest3"),
+                    OUString("test3.rdb")), "test_registry_CppApi error 40");
+    REG_ENSURE(!myRegistry->mergeKey(rootKey, OUString("allFromTest3"),
+                    OUString("ucrtest.rdb"), sal_True), "test_registry_CppApi error 40.a)");
+
+//     REG_ENSURE(myRegistry->mergeKey(rootKey, OUString("allFromTest3"), OUString("ucrtest.rdb"), sal_True)
+//                  == REG_NO_ERROR/*REG_MERGE_CONFLICT*/, "test_registry_CppApi error 40.b)");
+
+    REG_ENSURE(!key1.closeKey() &&
+                !key2.closeKey(), "test_registry_CppApi error 41");
+
+    const sal_Unicode* wValue= OUString("My first unicode value").getStr();
+    REG_ENSURE(!key3.setValue(OUString(), RegValueType::UNICODE, (void*)wValue,
+                (rtl_ustr_getLength(wValue)+1)*sizeof(sal_Unicode)), "test_registry_CppApi error 42");
+
+    REG_ENSURE(!key3.closeKey(), "test_registry_CppApi error 43");
+
+    REG_ENSURE(!rootKey.openKey("/allFromTest3/reg2FirstKey/reg2FirstSubKey", key1),
+                "test_registry_CppApi error 43.a)");
+    REG_ENSURE(!rootKey.deleteKey(OUString("/allFromTest3/reg2FirstKey/reg2FirstSubKey")), "test_registry_CppApi error 44");
+    REG_ENSURE(key1.getValueInfo(OUString(), &valueType, &valueSize) == REG_INVALID_KEY,
+                "test_registry_CppApi error 44.a)");
+    REG_ENSURE(!key1.closeKey(), "test_registry_CppApi error 44.b)");
+
+    REG_ENSURE(!rootKey.closeKey(), "test_registry_CppApi error 45");
+
+    REG_ENSURE(!myRegistry->close(), "test_registry_CppApi error 46");
+
+    REG_ENSURE(!myRegistry->open(OUString("test.rdb"), RegAccessMode::READWRITE), "test_registry_CppApi error 47");
+
+    REG_ENSURE(!myRegistry->destroy(OUString("test2.rdb")), "test_registry_CppApi error 48");
+//  REG_ENSURE(!myRegistry->destroy("test3.rdb"), "test_registry_CppApi error 49");
+
+    Registry *myRegistry2 = new Registry(*myRegistry);
+
+    REG_ENSURE(myRegistry->destroy(OUString()), "test_registry_CppApi error 50");
+
+    delete(myRegistry2);
+
+    REG_ENSURE(!myRegistry->create(OUString("destroytest.rdb")), "test_registry_CppApi error 51");
+    REG_ENSURE(!myRegistry->close(), "test_registry_CppApi error 52");
+    REG_ENSURE(!myRegistry->open(OUString("destroytest.rdb"), RegAccessMode::READONLY), "test_registry_CppApi error 53");
+    REG_ENSURE(!myRegistry->openRootKey(rootKey), "test_registry_CppApi error 54");
+
+    REG_ENSURE(myRegistry->mergeKey(rootKey, OUString("allFromTest3"),
+                    OUString("test3.rdb")), "test_registry_CppApi error 55");
+    REG_ENSURE(!myRegistry->destroy(OUString("test3.rdb")), "test_registry_CppApi error 56");
+
+    REG_ENSURE(!rootKey.closeKey(), "test_registry_CppApi error 57");
+    REG_ENSURE(!myRegistry->close(), "test_registry_CppApi error 58");
+    REG_ENSURE(!myRegistry->open(OUString("destroytest.rdb"), RegAccessMode::READWRITE), "test_registry_CppApi error 59");
+    REG_ENSURE(!myRegistry->destroy(OUString()), "test_registry_CppApi error 60");
+
+    REG_ENSURE(!myRegistry->open(OUString("test.rdb"), RegAccessMode::READWRITE), "test_registry_CppApi error 61");
+    REG_ENSURE(!myRegistry->destroy(OUString("ucrtest.rdb")), "test_registry_CppApi error 62");
+    REG_ENSURE(!myRegistry->destroy(OUString()), "test_registry_CppApi error 63");
+    delete(myRegistry);
+
+    std::cout << "test_registry_CppApi() Ok!\n";
+
+    return;
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/registry/tools/fileurl.cxx b/registry/tools/fileurl.cxx
new file mode 100644
index 000000000..ce99be5a1
--- /dev/null
+++ b/registry/tools/fileurl.cxx
@@ -0,0 +1,77 @@
+/* -*- 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 "fileurl.hxx"
+
+#include <rtl/ustring.hxx>
+#include <osl/file.hxx>
+#include <osl/process.h>
+#include <osl/thread.h>
+
+#include <string.h>
+
+#ifdef SAL_UNX
+#define SEPARATOR '/'
+#else
+#define SEPARATOR '\\'
+#endif
+
+using osl::FileBase;
+
+namespace registry::tools
+{
+OUString convertToFileUrl(char const* filename, sal_Int32 length)
+{
+    OUString const uFileName(filename, length, osl_getThreadTextEncoding());
+    if (strncmp(filename, "file://", 7) == 0)
+    {
+        // already a FileUrl.
+        return uFileName;
+    }
+
+    OUString uFileUrl;
+    if (length <= 0)
+        return uFileUrl;
+    if (filename[0] != SEPARATOR)
+    {
+        // relative path name.
+        OUString uWorkingDir;
+        if (osl_getProcessWorkingDir(&uWorkingDir.pData) != osl_Process_E_None)
+        {
+            assert(false);
+        }
+        if (FileBase::getAbsoluteFileURL(uWorkingDir, uFileName, uFileUrl) != FileBase::E_None)
+        {
+            assert(false);
+        }
+    }
+    else
+    {
+        // absolute path name.
+        if (FileBase::getFileURLFromSystemPath(uFileName, uFileUrl) != FileBase::E_None)
+        {
+            assert(false);
+        }
+    }
+    return uFileUrl;
+}
+
+} // namespace registry::tools
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/registry/tools/fileurl.hxx b/registry/tools/fileurl.hxx
new file mode 100644
index 000000000..c09c7ff6a
--- /dev/null
+++ b/registry/tools/fileurl.hxx
@@ -0,0 +1,33 @@
+/* -*- 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_REGISTRY_TOOLS_FILEURL_HXX
+#define INCLUDED_REGISTRY_TOOLS_FILEURL_HXX
+
+#include <rtl/ustring.hxx>
+
+namespace registry::tools
+{
+OUString convertToFileUrl(char const* filename, sal_Int32 length);
+
+} // namespace registry::tools
+
+#endif /* INCLUDED_REGISTRY_TOOLS_FILEURL_HXX */
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/registry/tools/options.cxx b/registry/tools/options.cxx
new file mode 100644
index 000000000..0212c94e9
--- /dev/null
+++ b/registry/tools/options.cxx
@@ -0,0 +1,144 @@
+/* -*- 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 "options.hxx"
+
+#include <osl/diagnose.h>
+
+#include <stdio.h>
+
+namespace registry::tools
+{
+
+Options::Options (char const * program)
+    : m_program (program)
+{}
+
+Options::~Options()
+{}
+
+// static
+bool Options::checkArgument(std::vector< std::string> & rArgs, char const * arg, size_t len)
+{
+    bool result = ((arg != nullptr) && (len > 0));
+    OSL_PRECOND(result, "registry::tools::Options::checkArgument(): invalid arguments");
+    if (!result)
+        return false;
+
+    switch (arg[0])
+    {
+    case '@':
+        result = len > 1;
+        if (result)
+        {
+            // "@<cmdfile>"
+            result = Options::checkCommandFile(rArgs, &(arg[1]));
+        }
+        break;
+    case '-':
+        result = len > 1;
+        if (result)
+        {
+            // "-<option>"
+            std::string option (&(arg[0]), 2);
+            rArgs.push_back(option);
+            if (len > 2)
+            {
+                // "-<option><param>"
+                std::string param(&(arg[2]), len - 2);
+                rArgs.push_back(param);
+            }
+        }
+        break;
+    default:
+        rArgs.push_back(std::string(arg, len));
+        break;
+    }
+    return result;
+}
+
+// static
+bool Options::checkCommandFile(std::vector< std::string > & rArgs, char const * filename)
+{
+    FILE * fp = fopen(filename, "r");
+    if (fp == nullptr)
+    {
+        fprintf(stderr, "ERROR: Can't open command file \"%s\"\n", filename);
+        return false;
+    }
+
+    std::string buffer;
+    buffer.reserve(256);
+
+    bool quoted = false;
+    int  c = EOF;
+    while ((c = fgetc(fp)) != EOF)
+    {
+        switch(c)
+        {
+        case '\"':
+            quoted = !quoted;
+            break;
+        case ' ':
+        case '\t':
+        case '\r':
+        case '\n':
+            if (!quoted)
+            {
+                if (!buffer.empty())
+                {
+                    if (!checkArgument(rArgs, buffer.c_str(), buffer.size()))
+                    {
+                        // failure.
+                        (void) fclose(fp);
+                        return false;
+                    }
+                    buffer.clear();
+                }
+                break;
+            }
+            [[fallthrough]];
+        default:
+            buffer.push_back(sal::static_int_cast<char>(c));
+            break;
+        }
+    }
+    return fclose(fp) == 0;
+}
+
+bool Options::initOptions (std::vector< std::string > & rArgs)
+{
+    return initOptions_Impl (rArgs);
+}
+
+bool Options::badOption (char const * reason, char const * option) const
+{
+    (void) fprintf(stderr, "%s: %s option '%s'\n", m_program.c_str(), reason, option);
+    return printUsage();
+}
+
+bool Options::printUsage() const
+{
+    printUsage_Impl();
+    return false;
+}
+
+} // namespace registry::tools
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/registry/tools/options.hxx b/registry/tools/options.hxx
new file mode 100644
index 000000000..6813d21fc
--- /dev/null
+++ b/registry/tools/options.hxx
@@ -0,0 +1,57 @@
+/* -*- 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_REGISTRY_TOOLS_OPTIONS_HXX
+#define INCLUDED_REGISTRY_TOOLS_OPTIONS_HXX
+
+#include <string>
+#include <vector>
+
+namespace registry::tools
+{
+class Options
+{
+    std::string m_program;
+
+    Options (Options const &) = delete;
+    Options & operator= (Options const &) = delete;
+
+public:
+    explicit Options (char const * program);
+    virtual ~Options();
+
+    static bool checkArgument (std::vector< std::string > & rArgs, char const * arg, size_t len);
+
+    bool initOptions (std::vector< std::string > & rArgs);
+    bool badOption (char const * reason, char const * option) const;
+
+    bool printUsage() const;
+
+protected:
+    static  bool checkCommandFile(std::vector< std::string > & rArgs, char const * filename);
+
+    virtual bool initOptions_Impl(std::vector< std::string > & rArgs) = 0;
+    virtual void printUsage_Impl() const = 0;
+};
+
+} // namespace registry::tools
+
+#endif /* INCLUDED_REGISTRY_TOOLS_OPTIONS_HXX */
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/registry/tools/regmerge.cxx b/registry/tools/regmerge.cxx
new file mode 100644
index 000000000..409773a70
--- /dev/null
+++ b/registry/tools/regmerge.cxx
@@ -0,0 +1,183 @@
+/* -*- 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 <registry/registry.hxx>
+#include "fileurl.hxx"
+#include "options.hxx"
+
+#include <rtl/ustring.hxx>
+#include <sal/log.hxx>
+
+#include <stdio.h>
+#include <string.h>
+
+using namespace registry::tools;
+
+namespace {
+
+class Options_Impl : public Options
+{
+    bool m_bVerbose;
+
+public:
+    explicit Options_Impl (char const * program)
+        : Options(program), m_bVerbose(false)
+    {}
+    bool isVerbose() const { return m_bVerbose; }
+
+protected:
+    virtual void printUsage_Impl() const override;
+    virtual bool initOptions_Impl(std::vector< std::string > & rArgs) override;
+};
+
+}
+
+void Options_Impl::printUsage_Impl() const
+{
+    fprintf(stderr, "using: regmerge [-v|--verbose] mergefile mergeKeyName regfile_1 ... regfile_n\n");
+    fprintf(stderr, "       regmerge @regcmds\nOptions:\n");
+    fprintf(stderr, "  -v, --verbose : verbose output on stdout.\n");
+    fprintf(stderr, "  mergefile     : specifies the merged registry file. If this file doesn't exists,\n");
+    fprintf(stderr, "                  it is created.\n");
+    fprintf(stderr, "  mergeKeyName  : specifies the merge key, everything is merged under this key.\n");
+    fprintf(stderr, "                  If this key doesn't exists, it is created.\n");
+    fprintf(stderr, "  regfile_1..n  : specifies one or more registry files which are merged.\n");
+}
+
+bool Options_Impl::initOptions_Impl (std::vector< std::string > & rArgs)
+{
+    std::vector< std::string >::iterator first = rArgs.begin(), last = rArgs.end();
+    if ((first != last) && ((*first)[0] == '-'))
+    {
+        std::string option(*first);
+        if ((option.compare("-v") == 0) || (option.compare("--verbose") == 0))
+        {
+            m_bVerbose = true;
+        }
+        else if ((option.compare("-h") == 0) || (option.compare("-?") == 0))
+        {
+            return printUsage();
+        }
+        else
+        {
+            return badOption("unknown", option.c_str());
+        }
+        (void) rArgs.erase(first);
+    }
+    return true;
+}
+
+#if (defined UNX)
+int main( int argc, char * argv[] )
+#else
+int __cdecl main( int argc, char * argv[] )
+#endif
+{
+    try
+    {
+        Options_Impl options(argv[0]);
+
+        std::vector< std::string > args;
+        for (int i = 1; i < argc; i++)
+        {
+            if (!Options::checkArgument(args, argv[i], strlen(argv[i])))
+            {
+                options.printUsage();
+                return 1;
+            }
+        }
+        if (!options.initOptions(args))
+        {
+            return 1;
+        }
+        if (args.size() < 3)
+        {
+            options.printUsage();
+            return 1;
+        }
+
+        Registry reg;
+        OUString regName( convertToFileUrl(args[0].c_str(), args[0].size()) );
+        if (reg.open(regName, RegAccessMode::READWRITE) != RegError::NO_ERROR)
+        {
+            if (reg.create(regName) != RegError::NO_ERROR)
+            {
+                if (options.isVerbose())
+                    fprintf(stderr, "open registry \"%s\" failed\n", args[0].c_str());
+                return -1;
+            }
+        }
+
+        RegistryKey rootKey;
+        if (reg.openRootKey(rootKey) != RegError::NO_ERROR)
+        {
+            if (options.isVerbose())
+                fprintf(stderr, "open root key of registry \"%s\" failed\n", args[0].c_str());
+            return -4;
+        }
+
+        OUString mergeKeyName( OUString::createFromAscii(args[1].c_str()) );
+        for (size_t i = 2; i < args.size(); i++)
+        {
+            OUString targetRegName( convertToFileUrl(args[i].c_str(), args[i].size()) );
+            RegError _ret = reg.mergeKey(rootKey, mergeKeyName, targetRegName, options.isVerbose());
+            if (_ret != RegError::NO_ERROR)
+            {
+                if (_ret == RegError::MERGE_CONFLICT)
+                {
+                    if (options.isVerbose())
+                        fprintf(stderr, "merging registry \"%s\" under key \"%s\" in registry \"%s\".\n",
+                                args[i].c_str(), args[1].c_str(), args[0].c_str());
+                }
+                else
+                {
+                    if (options.isVerbose())
+                        fprintf(stderr, "ERROR: merging registry \"%s\" under key \"%s\" in registry \"%s\" failed.\n",
+                                args[i].c_str(), args[1].c_str(), args[0].c_str());
+                    return -2;
+                }
+            }
+            else
+            {
+                if (options.isVerbose())
+                    fprintf(stderr, "merging registry \"%s\" under key \"%s\" in registry \"%s\".\n",
+                            args[i].c_str(), args[1].c_str(), args[0].c_str());
+            }
+        }
+
+        rootKey.releaseKey();
+        if (reg.close() != RegError::NO_ERROR)
+        {
+            if (options.isVerbose())
+                fprintf(stderr, "closing registry \"%s\" failed\n", args[0].c_str());
+            return -5;
+        }
+    }
+    catch (const std::exception &e)
+    {
+        SAL_WARN("registry", "Fatal exception: " << e.what());
+        return -5;
+    }
+
+
+    return 0;
+}
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/registry/tools/regview.cxx b/registry/tools/regview.cxx
new file mode 100644
index 000000000..56aa343f4
--- /dev/null
+++ b/registry/tools/regview.cxx
@@ -0,0 +1,113 @@
+/* -*- 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 <regapi.hxx>
+#include "fileurl.hxx"
+
+#include <rtl/ustring.hxx>
+
+#include <stdio.h>
+#include <string.h>
+
+using namespace registry::tools;
+
+#if (defined UNX)
+int main( int argc, char * argv[] )
+#else
+int __cdecl main( int argc, char * argv[] )
+#endif
+{
+    try
+    {
+        RegHandle       hReg;
+        RegKeyHandle    hRootKey, hKey;
+
+        if (argc < 2 || argc > 3)
+        {
+            fprintf(stderr, "using: regview registryfile [keyName]\n");
+            exit(1);
+        }
+
+        OUString regName( convertToFileUrl(argv[1], strlen(argv[1])) );
+        if (reg_openRegistry(regName.pData, &hReg) != RegError::NO_ERROR)
+        {
+            fprintf(stderr, "open registry \"%s\" failed\n", argv[1]);
+            exit(1);
+        }
+
+        if (reg_openRootKey(hReg, &hRootKey) == RegError::NO_ERROR)
+        {
+            if (argc == 3)
+            {
+                OUString keyName( OUString::createFromAscii(argv[2]) );
+                if (reg_openKey(hRootKey, keyName.pData, &hKey) == RegError::NO_ERROR)
+                {
+                    if (reg_dumpRegistry(hKey) != RegError::NO_ERROR)
+                    {
+                        fprintf(stderr, "dumping registry \"%s\" failed\n", argv[1]);
+                    }
+
+                    if (reg_closeKey(hKey) != RegError::NO_ERROR)
+                    {
+                        fprintf(stderr, "closing key \"%s\" of registry \"%s\" failed\n",
+                                argv[2], argv[1]);
+                    }
+                }
+                else
+                {
+                    fprintf(stderr, "key \"%s\" not exists in registry \"%s\"\n",
+                            argv[2], argv[1]);
+                }
+            }
+            else
+            {
+                if (reg_dumpRegistry(hRootKey) != RegError::NO_ERROR)
+                {
+                    fprintf(stderr, "dumping registry \"%s\" failed\n", argv[1]);
+                }
+            }
+
+            if (reg_closeKey(hRootKey) != RegError::NO_ERROR)
+            {
+                fprintf(stderr, "closing root key of registry \"%s\" failed\n", argv[1]);
+            }
+        }
+        else
+        {
+            fprintf(stderr, "open root key of registry \"%s\" failed\n", argv[1]);
+        }
+
+        if (reg_closeRegistry(hReg) != RegError::NO_ERROR)
+        {
+            fprintf(stderr, "closing registry \"%s\" failed\n", argv[1]);
+            exit(1);
+        }
+
+        return 0;
+    }
+    catch (std::exception& e)
+    {
+        fprintf(stderr, "failure: \"%s\"\n", e.what());
+        return 1;
+    }
+}
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */