mhu22: #i105430# #i108349# Fixed registry:ORegKey reference counting to avoid redundant closeKey()/flush() calls.

10 files changed, 565 insertions, 838 deletions

diff --git a/registry/inc/registry/registry.hxx b/registry/inc/registry/registry.hxx
index e3ee4574023d..fe31978c5ca0 100644
--- a/registry/inc/registry/registry.hxx
+++ b/registry/inc/registry/registry.hxx
@@ -486,6 +486,9 @@ public:
     /// closes explicitly the current key
     inline RegError closeKey();
 
+    /// releases the current key
+    inline void releaseKey();
+
     /** sets a value of a key.
 
         @param  keyName specifies the name of the key which value will be set.
@@ -810,19 +813,18 @@ inline void RegistryKey::setRegistry(Registry& registry)
 inline RegistryKey::~RegistryKey()
     {
         if (m_hImpl)
-            m_registry.m_pApi->closeKey(m_hImpl);
+            m_registry.m_pApi->releaseKey(m_hImpl);
     }
 
 inline RegistryKey& RegistryKey::operator = (const RegistryKey& toAssign)
 {
     m_registry = toAssign.m_registry;
 
-    if (m_hImpl != toAssign.m_hImpl)
-    {
+    if (toAssign.m_hImpl)
+        m_registry.m_pApi->acquireKey(toAssign.m_hImpl);
+    if (m_hImpl)
         m_registry.m_pApi->releaseKey(m_hImpl);
-        m_hImpl = toAssign.m_hImpl;
-        m_registry.m_pApi->acquireKey(m_hImpl);
-    }
+    m_hImpl = toAssign.m_hImpl;
 
     return *this;
 }
@@ -948,6 +950,14 @@ inline RegError RegistryKey::closeKey()
             return REG_INVALID_KEY;
     }
 
+inline void RegistryKey::releaseKey()
+{
+    if (m_registry.isValid() && (m_hImpl != 0))
+    {
+        m_registry.m_pApi->releaseKey(m_hImpl), m_hImpl = 0;
+    }
+}
+
 inline RegError RegistryKey::setValue(const ::rtl::OUString& keyName,
                                               RegValueType valueType,
                                            RegValue pValue,
@@ -1166,15 +1176,13 @@ inline Registry::~Registry()
 
 inline Registry& Registry::operator = (const Registry& toAssign)
 {
-
-    if (m_hImpl != toAssign.m_hImpl)
-    {
-        m_pApi->release(m_hImpl);
-        m_pApi = toAssign.m_pApi;
-        m_hImpl = toAssign.m_hImpl;
-    }
+    if (toAssign.m_hImpl)
+        toAssign.m_pApi->acquire(toAssign.m_hImpl);
     if (m_hImpl)
-        m_pApi->acquire(m_hImpl);
+        m_pApi->release(m_hImpl);
+
+    m_pApi  = toAssign.m_pApi;
+    m_hImpl = toAssign.m_hImpl;
 
     return *this;
 }
diff --git a/registry/source/keyimpl.cxx b/registry/source/keyimpl.cxx
index f8de7e20b148..5300b158769d 100644
--- a/registry/source/keyimpl.cxx
+++ b/registry/source/keyimpl.cxx
@@ -31,13 +31,17 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_registry.hxx"
 
-#include    "reflcnst.hxx"
-
 #include "keyimpl.hxx"
-#include    <rtl/alloc.h>
-#include    <rtl/memory.h>
+
+#include "reflcnst.hxx"
+#include "rtl/alloc.h"
+#include "rtl/memory.h"
 #include "rtl/ustrbuf.hxx"
 
+using rtl::OUString;
+using rtl::OUStringBuffer;
+using namespace store;
+
 namespace { static char const VALUE_PREFIX[] = "$VL_"; }
 
 //*********************************************************************
@@ -46,9 +50,35 @@ namespace { static char const VALUE_PREFIX[] = "$VL_"; }
 ORegKey::ORegKey(const OUString& keyName, ORegistry* pReg)
     : m_refCount(1)
     , m_name(keyName)
-    , m_bDeleted(sal_False)
+    , m_bDeleted(0)
+    , m_bModified(0)
     , m_pRegistry(pReg)
-{}
+{
+}
+
+//*********************************************************************
+//  ~ORegKey()
+//
+ORegKey::~ORegKey()
+{
+    OSL_POSTCOND(m_refCount == 0, "registry::ORegKey::dtor(): refcount not zero.");
+}
+
+//*********************************************************************
+//  acquireKey
+//
+RegError ORegKey::acquireKey(RegKeyHandle hKey)
+{
+    return m_pRegistry->acquireKey(hKey);
+}
+
+//*********************************************************************
+//  releaseKey
+//
+RegError ORegKey::releaseKey(RegKeyHandle hKey)
+{
+    return m_pRegistry->releaseKey(hKey);
+}
 
 //*********************************************************************
 //  createKey
@@ -64,7 +94,7 @@ RegError ORegKey::createKey(const OUString& keyName, RegKeyHandle* phNewKey)
 //
 RegError ORegKey::openKey(const OUString& keyName, RegKeyHandle* phOpenKey)
 {
-    return (m_pRegistry->openKey(this, keyName, phOpenKey));
+    return m_pRegistry->openKey(this, keyName, phOpenKey);
 }
 
 
@@ -73,33 +103,24 @@ RegError ORegKey::openKey(const OUString& keyName, RegKeyHandle* phOpenKey)
 //
 RegError ORegKey::openSubKeys(const OUString& keyName, RegKeyHandle** phOpenSubKeys, sal_uInt32* pnSubKeys)
 {
-    ORegKey*        pKey;
-    OUString        sFullKeyName, sSubKeyName;
-    RegKeyHandle    hSKey = 0, hSubKey;
-    RegError        _ret = REG_NO_ERROR;
-    sal_uInt32      nSubKeys;
-    ORegKey*        *subKeys;
+    RegError _ret = REG_NO_ERROR;
+
+    *phOpenSubKeys = 0;
+    *pnSubKeys = 0;
 
+    ORegKey* pKey = this;
     if ( keyName.getLength() )
     {
-        _ret = openKey(keyName, &hSKey);
-        if (_ret)
-        {
-            *phOpenSubKeys = NULL;
-            *pnSubKeys = 0;
+        _ret = openKey(keyName, (RegKeyHandle*)&pKey);
+        if (_ret != REG_NO_ERROR)
             return _ret;
-        }
-
-        pKey = (ORegKey*)hSKey;
-    } else
-    {
-        pKey = this;
     }
 
-    nSubKeys = pKey->countSubKeys();
-
+    sal_uInt32 nSubKeys = pKey->countSubKeys();
     *pnSubKeys = nSubKeys;
-    subKeys = (ORegKey**)rtl_allocateZeroMemory(nSubKeys * sizeof(ORegKey*));
+
+    ORegKey** pSubKeys;
+    pSubKeys = (ORegKey**)rtl_allocateZeroMemory(nSubKeys * sizeof(ORegKey*));
 
     OStoreDirectory::iterator   iter;
     OStoreDirectory             rStoreDir(pKey->getStoreDir());
@@ -110,22 +131,19 @@ RegError ORegKey::openSubKeys(const OUString& keyName, RegKeyHandle** phOpenSubK
     {
         if ( iter.m_nAttrib & STORE_ATTRIB_ISDIR )
         {
-            sSubKeyName = iter.m_pszName;
-            sFullKeyName = pKey->getName();
-            if (sFullKeyName.getLength() > 1)
-                sFullKeyName += m_pRegistry->ROOT;
-            sFullKeyName += sSubKeyName;
+            OUString const sSubKeyName = iter.m_pszName;
 
-            _ret = pKey->openKey(sSubKeyName, &hSubKey);
-            if (_ret)
+            ORegKey* pOpenSubKey = 0;
+            _ret = pKey->openKey(sSubKeyName, (RegKeyHandle*)&pOpenSubKey);
+            if (_ret != REG_NO_ERROR)
             {
                 *phOpenSubKeys = NULL;
                 *pnSubKeys = 0;
-                rtl_freeMemory(subKeys);
-                return _ret;
+                rtl_freeMemory(pSubKeys); // @@@ leaking 'pSubKeys[0...nSubkeys-1]'
+                return _ret;              // @@@ leaking 'pKey'
             }
 
-            subKeys[nSubKeys] = ((ORegKey*)hSubKey);
+            pSubKeys[nSubKeys] = pOpenSubKey;
 
             nSubKeys++;
         }
@@ -133,10 +151,10 @@ RegError ORegKey::openSubKeys(const OUString& keyName, RegKeyHandle** phOpenSubK
         _err = rStoreDir.next(iter);
     }
 
-    *phOpenSubKeys = (RegKeyHandle*)subKeys;
+    *phOpenSubKeys = (RegKeyHandle*)pSubKeys;
     if (keyName.getLength())
     {
-        closeKey(hSKey);
+        (void) releaseKey(pKey);
     }
     return REG_NO_ERROR;
 }
@@ -149,35 +167,28 @@ RegError ORegKey::getKeyNames(const OUString& keyName,
                               rtl_uString*** pSubKeyNames,
                               sal_uInt32* pnSubKeys)
 {
-    ORegKey*            pKey;
-    OUString            sFullKeyName, sSubKeyName;
-    RegError            _ret = REG_NO_ERROR;
-    sal_uInt32          nSubKeys;
-    rtl_uString**       pSubKeys;
+    RegError _ret = REG_NO_ERROR;
+
+    *pSubKeyNames = 0;
+    *pnSubKeys = 0;
 
+    ORegKey* pKey = this;
     if (keyName.getLength())
     {
         _ret = openKey(keyName, (RegKeyHandle*)&pKey);
-        if (_ret)
-        {
-            *pSubKeyNames = NULL;
-            *pnSubKeys = 0;
+        if (_ret != REG_NO_ERROR)
             return _ret;
-        }
-    } else
-    {
-        pKey = this;
     }
 
-    nSubKeys = pKey->countSubKeys();
-
+    sal_uInt32 nSubKeys = pKey->countSubKeys();
     *pnSubKeys = nSubKeys;
+
+    rtl_uString** pSubKeys = 0;
     pSubKeys = (rtl_uString**)rtl_allocateZeroMemory(nSubKeys * sizeof(rtl_uString*));
 
     OStoreDirectory::iterator   iter;
     OStoreDirectory             rStoreDir(pKey->getStoreDir());
     storeError                  _err = rStoreDir.first(iter);
-    OUString                    subKey;
 
     nSubKeys = 0;
 
@@ -185,14 +196,14 @@ RegError ORegKey::getKeyNames(const OUString& keyName,
     {
         if ( iter.m_nAttrib & STORE_ATTRIB_ISDIR)
         {
-            sSubKeyName = iter.m_pszName;
-            sFullKeyName = pKey->getName();
+            OUString const sSubKeyName = iter.m_pszName;
+
+            OUString sFullKeyName(pKey->getName());
             if (sFullKeyName.getLength() > 1)
                 sFullKeyName += m_pRegistry->ROOT;
             sFullKeyName += sSubKeyName;
 
-            subKey = sFullKeyName;
-            rtl_uString_newFromString(&pSubKeys[nSubKeys], subKey.pData);
+            rtl_uString_newFromString(&pSubKeys[nSubKeys], sFullKeyName.pData);
 
             nSubKeys++;
         }
@@ -203,7 +214,7 @@ RegError ORegKey::getKeyNames(const OUString& keyName,
     *pSubKeyNames = pSubKeys;
     if (keyName.getLength())
     {
-        closeKey((RegKeyHandle)pKey);
+        releaseKey(pKey);
     }
     return REG_NO_ERROR;
 }
@@ -352,7 +363,6 @@ RegError ORegKey::setValue(const OUString& valueName, RegValueType vType, RegVal
             break;
     }
 
-
     sal_uInt32  writenBytes;
     if ( rValue.writeAt(0, pBuffer, VALUE_HEADERSIZE+size, writenBytes) )
     {
@@ -364,6 +374,7 @@ RegError ORegKey::setValue(const OUString& valueName, RegValueType vType, RegVal
         rtl_freeMemory(pBuffer);
         return REG_SET_VALUE_FAILED;
     }
+    setModified();
 
     rtl_freeMemory(pBuffer);
     return REG_NO_ERROR;
@@ -422,6 +433,7 @@ RegError ORegKey::setLongListValue(const OUString& valueName, sal_Int32* pValueL
         rtl_freeMemory(pBuffer);
         return REG_SET_VALUE_FAILED;
     }
+    setModified();
 
     rtl_freeMemory(pBuffer);
     return REG_NO_ERROR;
@@ -489,6 +501,7 @@ RegError ORegKey::setStringListValue(const OUString& valueName, sal_Char** pValu
         rtl_freeMemory(pBuffer);
         return REG_SET_VALUE_FAILED;
     }
+    setModified();
 
     rtl_freeMemory(pBuffer);
     return REG_NO_ERROR;
@@ -556,6 +569,7 @@ RegError ORegKey::setUnicodeListValue(const OUString& valueName, sal_Unicode** p
         rtl_freeMemory(pBuffer);
         return REG_SET_VALUE_FAILED;
     }
+    setModified();
 
     rtl_freeMemory(pBuffer);
     return REG_NO_ERROR;
@@ -625,7 +639,6 @@ RegError ORegKey::getValue(const OUString& valueName, RegValue value) const
         return REG_INVALID_VALUE;
     }
 
-//  rtl_copyMemory(value, pBuffer, valueSize);
     switch (valueType)
     {
         case RG_VALUETYPE_NOT_DEFINED:
@@ -969,33 +982,30 @@ RegError ORegKey::getUnicodeListValue(const OUString& valueName, sal_Unicode***
 //
 RegError ORegKey::getKeyType(const OUString& name, RegKeyType* pKeyType) const
 {
-    ORegKey*    pKey;
-    RegError    _ret = REG_NO_ERROR;
-
     *pKeyType = RG_KEYTYPE;
 
     REG_GUARD(m_pRegistry->m_mutex);
 
     if ( name.getLength() )
     {
-        _ret = ((ORegKey*)this)->openKey(
-            name, (RegKeyHandle*)&pKey);
-        if (_ret)
+        ORegKey* pThis = const_cast< ORegKey* >(this);
+
+        RegKeyHandle hKey = 0;
+        RegError _ret = pThis->openKey(name, &hKey);
+        if (_ret != REG_NO_ERROR)
             return _ret;
-        ((ORegKey*)this)->closeKey((RegKeyHandle)pKey);
-        return _ret;
-    } else
-    {
-        return _ret;
+        (void) pThis->releaseKey(hKey);
     }
+
+    return REG_NO_ERROR;
 }
 
 RegError ORegKey::getResolvedKeyName(const OUString& keyName,
                                      OUString& resolvedName)
 {
-    if (keyName.getLength() == 0) {
+    if (keyName.getLength() == 0)
         return REG_INVALID_KEYNAME;
-    }
+
     resolvedName = getFullPath(keyName);
     return REG_NO_ERROR;
 }
diff --git a/registry/source/keyimpl.hxx b/registry/source/keyimpl.hxx
index 4e99696bcd44..ab0de6710e31 100644
--- a/registry/source/keyimpl.hxx
+++ b/registry/source/keyimpl.hxx
@@ -33,16 +33,14 @@
 
 #include    <registry/registry.h>
 #include    "regimpl.hxx"
-#include    <rtl/string.hxx>
-
-using namespace rtl;
-using namespace store;
+#include    <rtl/ustring.hxx>
 
 class ORegKey
 {
 public:
 
-    ORegKey(const OUString& keyName, ORegistry* pReg);
+    ORegKey(const rtl::OUString& keyName, ORegistry* pReg);
+    ~ORegKey();
 
       sal_uInt32    acquire()
         { return ++m_refCount; }
@@ -50,68 +48,77 @@ public:
     sal_uInt32  release()
         { return --m_refCount; }
 
-    RegError    createKey(const OUString& keyName, RegKeyHandle* phNewKey);
+    RegError    acquireKey(RegKeyHandle hKey);
+    RegError    releaseKey(RegKeyHandle hKey);
+
+    RegError    createKey(const rtl::OUString& keyName, RegKeyHandle* phNewKey);
 
-    RegError    openKey(const OUString& keyName, RegKeyHandle* phOpenKey);
+    RegError    openKey(const rtl::OUString& keyName, RegKeyHandle* phOpenKey);
 
-    RegError    openSubKeys(const OUString& keyName,
+    RegError    openSubKeys(const rtl::OUString& keyName,
                             RegKeyHandle** phOpenSubKeys,
                             sal_uInt32* pnSubKeys);
 
-    RegError    getKeyNames(const OUString& keyName,
+    RegError    getKeyNames(const rtl::OUString& keyName,
                             rtl_uString*** pSubKeyNames,
                             sal_uInt32* pnSubKeys);
 
     RegError    closeKey(RegKeyHandle hKey);
 
-    RegError    deleteKey(const OUString& keyName);
+    RegError    deleteKey(const rtl::OUString& keyName);
 
-    RegError    getValueInfo(const OUString& valueName,
+    RegError    getValueInfo(const rtl::OUString& valueName,
                              RegValueType* pValueTye,
                              sal_uInt32* pValueSize) const;
 
-    RegError    setValue(const OUString& valueName,
+    RegError    setValue(const rtl::OUString& valueName,
                          RegValueType vType,
                          RegValue value,
                          sal_uInt32 vSize);
 
-    RegError    setLongListValue(const OUString& valueName,
+    RegError    setLongListValue(const rtl::OUString& valueName,
                                   sal_Int32* pValueList,
                                  sal_uInt32 len);
 
-    RegError    setStringListValue(const OUString& valueName,
+    RegError    setStringListValue(const rtl::OUString& valueName,
                                    sal_Char** pValueList,
                                   sal_uInt32 len);
 
-    RegError    setUnicodeListValue(const OUString& valueName,
+    RegError    setUnicodeListValue(const rtl::OUString& valueName,
                                    sal_Unicode** pValueList,
                                   sal_uInt32 len);
 
-    RegError    getValue(const OUString& valueName, RegValue value) const;
+    RegError    getValue(const rtl::OUString& valueName, RegValue value) const;
 
-    RegError    getLongListValue(const OUString& valueName,
+    RegError    getLongListValue(const rtl::OUString& valueName,
                                   sal_Int32** pValueList,
                                  sal_uInt32* pLen) const;
 
-    RegError    getStringListValue(const OUString& valueName,
+    RegError    getStringListValue(const rtl::OUString& valueName,
                                     sal_Char*** pValueList,
                                    sal_uInt32* pLen) const;
 
-    RegError    getUnicodeListValue(const OUString& valueName,
+    RegError    getUnicodeListValue(const rtl::OUString& valueName,
                                      sal_Unicode*** pValueList,
                                     sal_uInt32* pLen) const;
 
-    RegError    getKeyType(const OUString& name,
+    RegError    getKeyType(const rtl::OUString& name,
                            RegKeyType* pKeyType) const;
 
-    RegError    getResolvedKeyName(const OUString& keyName,
-                                   OUString& resolvedName);
+    RegError    getResolvedKeyName(const rtl::OUString& keyName,
+                                   rtl::OUString& resolvedName);
+
+    bool isDeleted() const
+        { return m_bDeleted != 0; }
 
-    sal_Bool        isDeleted() const
-                    { return m_bDeleted; }
+    void setDeleted (sal_Bool bKeyDeleted)
+        { m_bDeleted = bKeyDeleted ? 1 : 0; }
 
-    void        setDeleted(sal_Bool bKeyDeleted)
-                    { m_bDeleted = bKeyDeleted; }
+    bool isModified() const
+        { return m_bModified != 0; }
+
+    void setModified (bool bModified = true)
+        { m_bModified = bModified ? 1 : 0; }
 
     sal_Bool        isReadOnly() const
                     { return m_pRegistry->isReadOnly(); }
@@ -121,28 +128,27 @@ public:
     ORegistry* getRegistry() const
                     { return m_pRegistry; }
 
-    const OStoreFile& getStoreFile() const
+    const store::OStoreFile& getStoreFile() const
                     { return m_pRegistry->getStoreFile(); }
 
-    OStoreDirectory getStoreDir();
+    store::OStoreDirectory getStoreDir();
 
-    const OUString& getName() const
+    const rtl::OUString& getName() const
                     { return m_name; }
 
     sal_uInt32 getRefCount() const
                     { return m_refCount; }
 
-    OUString getFullPath(OUString const & path) const;
+    rtl::OUString getFullPath(rtl::OUString const & path) const;
 
 private:
     sal_uInt32              m_refCount;
-    OUString                m_name;
-    sal_Bool                m_bDeleted;
+    rtl::OUString           m_name;
+    int                     m_bDeleted:1;
+    int                     m_bModified:1;
     ORegistry*              m_pRegistry;
 };
 
-
-
 #endif
 
 
diff --git a/registry/source/regimpl.cxx b/registry/source/regimpl.cxx
index 7a4e8fc44083..3b0587a5a433 100644
--- a/registry/source/regimpl.cxx
+++ b/registry/source/regimpl.cxx
@@ -31,6 +31,8 @@
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_registry.hxx"
 
+#include    "regimpl.hxx"
+
 #include <memory>
 #include    <string.h>
 #include    <stdio.h>
@@ -42,18 +44,6 @@
 #include    <unistd.h>
 #endif
 
-#ifdef MACOSX
-// Get the store.hxx inlines non-inline, solves crashes in cppumaker
-#define inline
-#endif
-
-#include    "regimpl.hxx"
-
-#ifdef MACOSX
-// Get the store.hxx inlines non-inline, solves crashes in cppumaker
-#undef inline
-#endif
-
 #ifndef __REGISTRY_REFLREAD_HXX__
 #include    <registry/reflread.hxx>
 #endif
@@ -67,19 +57,19 @@
 #include "registry/types.h"
 #include "registry/version.h"
 
-#ifndef __REFLCNST_HXX__
 #include    "reflcnst.hxx"
-#endif
 #include    "keyimpl.hxx"
+
 #include    <osl/thread.h>
 #include    <rtl/alloc.h>
 #include    <rtl/memory.h>
 #include    <rtl/ustring.hxx>
 #include    <rtl/ustrbuf.hxx>
-#ifndef _ODL_FILE_HXX_
 #include    <osl/file.hxx>
-#endif
 
+using namespace rtl;
+using namespace osl;
+using namespace store;
 
 #if defined ( GCC ) && ( defined ( SCO ) )
 sal_helper::ORealDynamicLoader* sal_helper::ODynamicLoader<RegistryTypeReader_Api>::m_pLoader = NULL;
@@ -470,11 +460,9 @@ ORegistry::ORegistry()
 //
 ORegistry::~ORegistry()
 {
-    if (m_openKeyTable.count(ROOT) > 0)
-    {
-        m_openKeyTable[ROOT]->release();
-        delete(m_openKeyTable[ROOT]);
-    }
+    ORegKey* pRootKey = m_openKeyTable[ROOT];
+    if (pRootKey != 0)
+        (void) releaseKey(pRootKey);
 
     if (m_file.isValid())
         m_file.close();
@@ -549,7 +537,7 @@ RegError ORegistry::closeRegistry()
 
     if (m_file.isValid())
     {
-        closeKey(m_openKeyTable[ROOT]);
+        (void) releaseKey(m_openKeyTable[ROOT]);
         m_file.close();
         m_isOpen = sal_False;
         return REG_NO_ERROR;
@@ -597,7 +585,7 @@ RegError ORegistry::destroyRegistry(const OUString& regName)
 
         if (m_file.isValid())
         {
-            closeKey(m_openKeyTable[ROOT]);
+            releaseKey(m_openKeyTable[ROOT]);
             m_file.close();
             m_isOpen = sal_False;
 
@@ -623,6 +611,39 @@ RegError ORegistry::destroyRegistry(const OUString& regName)
 }
 
 //*********************************************************************
+//  acquireKey
+//
+RegError ORegistry::acquireKey (RegKeyHandle hKey)
+{
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return REG_INVALID_KEY;
+
+    REG_GUARD(m_mutex);
+    pKey->acquire();
+
+    return REG_NO_ERROR;
+}
+
+//*********************************************************************
+//  releaseKey
+//
+RegError ORegistry::releaseKey (RegKeyHandle hKey)
+{
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return REG_INVALID_KEY;
+
+    REG_GUARD(m_mutex);
+    if (pKey->release() == 0)
+    {
+        m_openKeyTable.erase(pKey->getName());
+        delete pKey;
+    }
+    return REG_NO_ERROR;
+}
+
+//*********************************************************************
 //  createKey
 //
 RegError ORegistry::createKey(RegKeyHandle hKey, const OUString& keyName,
@@ -720,6 +741,7 @@ RegError ORegistry::openKey(RegKeyHandle hKey, const OUString& keyName,
         default:
             break;
         }
+
         std::auto_ptr< ORegKey > p(new ORegKey(path, this));
         i = m_openKeyTable.insert(std::make_pair(path, p.get())).first;
         p.release();
@@ -736,56 +758,51 @@ RegError ORegistry::openKey(RegKeyHandle hKey, const OUString& keyName,
 //
 RegError ORegistry::closeKey(RegKeyHandle hKey)
 {
-    ORegKey* pKey = (ORegKey*)hKey;
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
 
     REG_GUARD(m_mutex);
 
-    if (m_openKeyTable.count(pKey->getName()) > 0)
+    OUString const aKeyName (pKey->getName());
+    if (!(m_openKeyTable.count(aKeyName) > 0))
+        return REG_KEY_NOT_OPEN;
+
+    if (pKey->isModified())
     {
-        if (pKey->getRefCount() == 1)
+        ORegKey * pRootKey = getRootKey();
+        if (pKey != pRootKey)
         {
-            m_openKeyTable.erase(pKey->getName());
-            delete(pKey);
-            hKey = NULL;
-        } else
+            // propagate "modified" state to RootKey.
+            pRootKey->setModified();
+        }
+        else
         {
-            pKey->release();
+            // closing modified RootKey, flush registry file.
+            OSL_TRACE("registry::ORegistry::closeKey(): flushing modified RootKey");
+            (void) m_file.flush();
         }
-
-        return REG_NO_ERROR;
-    } else
-    {
-        return REG_KEY_NOT_OPEN;
+        pKey->setModified(false);
+        (void) releaseKey(pRootKey);
     }
-}
 
+    return releaseKey(pKey);
+}
 
 //*********************************************************************
 //  deleteKey
 //
 RegError ORegistry::deleteKey(RegKeyHandle hKey, const OUString& keyName)
 {
-    ORegKey*    pKey;
-    RegError    _ret = REG_NO_ERROR;
-
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
     if ( !keyName.getLength() )
-    {
         return REG_INVALID_KEYNAME;
-    }
 
     REG_GUARD(m_mutex);
 
-    if (hKey)
-        pKey = (ORegKey*)hKey;
-    else
+    if (!pKey)
         pKey = m_openKeyTable[ROOT];
 
-    OUString sFullKeyName = pKey->getFullPath(keyName);
-
-    pKey = m_openKeyTable[ROOT];
-    _ret = eraseKey(pKey, sFullKeyName);
-
-    return _ret;
+    OUString sFullKeyName(pKey->getFullPath(keyName));
+    return eraseKey(m_openKeyTable[ROOT], sFullKeyName);
 }
 
 RegError ORegistry::eraseKey(ORegKey* pKey, const OUString& keyName)
@@ -824,17 +841,15 @@ RegError ORegistry::eraseKey(ORegKey* pKey, const OUString& keyName)
             sFullPath += ROOT;
     }
 
-    RegKeyHandle    hOldKey;
-    _ret = pKey->openKey(keyName, &hOldKey);
-    if (_ret)
-    {
+    ORegKey* pOldKey = 0;
+    _ret = pKey->openKey(keyName, (RegKeyHandle*)&pOldKey);
+    if (_ret != REG_NO_ERROR)
         return _ret;
-    }
 
-    _ret = deleteSubkeysAndValues((ORegKey*)hOldKey);
-    if (_ret)
+    _ret = deleteSubkeysAndValues(pOldKey);
+    if (_ret != REG_NO_ERROR)
     {
-        pKey->closeKey(hOldKey);
+        pKey->closeKey(pOldKey);
         return _ret;
     }
 
@@ -842,46 +857,39 @@ RegError ORegistry::eraseKey(ORegKey* pKey, const OUString& keyName)
     tmpName += ROOT;
 
     OStoreFile sFile(pKey->getStoreFile());
-
     if ( sFile.isValid() && sFile.remove(sFullPath, tmpName) )
     {
         return REG_DELETE_KEY_FAILED;
     }
+    pOldKey->setModified();
 
     // set flag deleted !!!
-    ((ORegKey*)hOldKey)->setDeleted(sal_True);
+    pOldKey->setDeleted(sal_True);
 
-    _ret = pKey->closeKey(hOldKey);
-    if (_ret)
-    {
-        return _ret;
-    }
-
-    return REG_NO_ERROR;
+    return pKey->closeKey(pOldKey);
 }
 
-
 //*********************************************************************
-//  deleteSubKeys
+//  deleteSubKeysAndValues
 //
 RegError ORegistry::deleteSubkeysAndValues(ORegKey* pKey)
 {
     OStoreDirectory::iterator   iter;
-    OUString                    keyName;
     RegError                    _ret = REG_NO_ERROR;
     OStoreDirectory             rStoreDir(pKey->getStoreDir());
     storeError                  _err = rStoreDir.first(iter);
 
     while ( _err == store_E_None )
     {
-        keyName = iter.m_pszName;
+        OUString const keyName = iter.m_pszName;
 
         if (iter.m_nAttrib & STORE_ATTRIB_ISDIR)
         {
             _ret = eraseKey(pKey, keyName);
             if (_ret)
                 return _ret;
-        } else
+        }
+        else
         {
             OUString sFullPath(pKey->getName());
 
@@ -892,6 +900,7 @@ RegError ORegistry::deleteSubkeysAndValues(ORegKey* pKey)
             {
                 return REG_DELETE_VALUE_FAILED;
             }
+            pKey->setModified();
         }
 
         _err = rStoreDir.next(iter);
@@ -907,119 +916,99 @@ RegError ORegistry::deleteSubkeysAndValues(ORegKey* pKey)
 RegError ORegistry::loadKey(RegKeyHandle hKey, const OUString& regFileName,
                             sal_Bool bWarnings, sal_Bool bReport)
 {
-    RegError        _ret = REG_NO_ERROR;
-    ORegistry*      pReg;
-    ORegKey         *pKey, *pRootKey;
+    RegError _ret = REG_NO_ERROR;
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
 
-    pReg = new ORegistry();
+    std::auto_ptr< ORegistry > pReg (new ORegistry());
     _ret = pReg->initRegistry(regFileName, REG_READONLY);
-    if (_ret)
-    {
+    if (_ret != REG_NO_ERROR)
         return _ret;
-    }
-
-    pKey = (ORegKey*)hKey;
-    pRootKey = pReg->getRootKey();
+    ORegKey* pRootKey = pReg->getRootKey();
 
     REG_GUARD(m_mutex);
 
     OStoreDirectory::iterator   iter;
-    OUString                    keyName;
     OStoreDirectory             rStoreDir(pRootKey->getStoreDir());
     storeError                  _err = rStoreDir.first(iter);
 
     while ( _err == store_E_None )
     {
-        keyName = iter.m_pszName;
+        OUString const keyName = iter.m_pszName;
 
         if ( iter.m_nAttrib & STORE_ATTRIB_ISDIR )
         {
             _ret = loadAndSaveKeys(pKey, pRootKey, keyName, 0, bWarnings, bReport);
-        } else
+        }
+        else
         {
             _ret = loadAndSaveValue(pKey, pRootKey, keyName, 0, bWarnings, bReport);
         }
 
-        if (_ret == REG_MERGE_ERROR ||
-            (_ret == REG_MERGE_CONFLICT && bWarnings))
-        {
-            rStoreDir = OStoreDirectory();
-            pRootKey->release();
-            delete(pReg);
-            return _ret;
-        }
+        if (_ret == REG_MERGE_ERROR)
+            break;
+        if (_ret == REG_MERGE_CONFLICT && bWarnings)
+            break;
 
         _err = rStoreDir.next(iter);
     }
 
     rStoreDir = OStoreDirectory();
-    pRootKey->release();
-    delete(pReg);
+    (void) pReg->releaseKey(pRootKey);
     return _ret;
 }
 
 
 //*********************************************************************
-//  loadKey
+//  saveKey
 //
 RegError ORegistry::saveKey(RegKeyHandle hKey, const OUString& regFileName,
                             sal_Bool bWarnings, sal_Bool bReport)
 {
-    RegError        _ret = REG_NO_ERROR;
-    ORegistry*      pReg;
-    ORegKey         *pKey, *pRootKey;
+    RegError _ret = REG_NO_ERROR;
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
 
-    pReg = new ORegistry();
+    std::auto_ptr< ORegistry > pReg (new ORegistry());
     _ret = pReg->initRegistry(regFileName, REG_CREATE);
-    if (_ret)
-    {
+    if (_ret != REG_NO_ERROR)
         return _ret;
-    }
-
-    pKey = (ORegKey*)hKey;
-    pRootKey = pReg->getRootKey();
+    ORegKey* pRootKey = pReg->getRootKey();
 
     REG_GUARD(m_mutex);
 
     OStoreDirectory::iterator   iter;
-    OUString                    keyName;
     OStoreDirectory             rStoreDir(pKey->getStoreDir());
     storeError                  _err = rStoreDir.first(iter);
 
     while ( _err == store_E_None )
     {
-        keyName = iter.m_pszName;
+        OUString const keyName = iter.m_pszName;
 
         if ( iter.m_nAttrib & STORE_ATTRIB_ISDIR )
         {
             _ret = loadAndSaveKeys(pRootKey, pKey, keyName,
                                    pKey->getName().getLength(),
                                    bWarnings, bReport);
-        } else
+        }
+        else
         {
             _ret = loadAndSaveValue(pRootKey, pKey, keyName,
                                     pKey->getName().getLength(),
                                     bWarnings, bReport);
         }
 
-        if (_ret)
-        {
-            pRootKey->release();
-            delete(pReg);
-            return _ret;
-        }
+        if (_ret != REG_NO_ERROR)
+            break;
 
         _err = rStoreDir.next(iter);
     }
 
-    pRootKey->release();
-    delete(pReg);
-    return REG_NO_ERROR;
+    (void) pReg->releaseKey(pRootKey);
+    return _ret;
 }
 
 
 //*********************************************************************
-//  loadValue()
+//  loadAndSaveValue()
 //
 RegError ORegistry::loadAndSaveValue(ORegKey* pTargetKey,
                                      ORegKey* pSourceKey,
@@ -1139,6 +1128,7 @@ RegError ORegistry::loadAndSaveValue(ORegKey* pTargetKey,
         rtl_freeMemory(pBuffer);
         return REG_INVALID_VALUE;
     }
+    pTargetKey->setModified();
 
     rtl_freeMemory(pBuffer);
     return _ret;
@@ -1352,7 +1342,7 @@ RegError ORegistry::mergeModuleValue(OStoreStream& rTargetValue,
 }
 
 //*********************************************************************
-//  loadKeys()
+//  loadAndSaveKeys()
 //
 RegError ORegistry::loadAndSaveKeys(ORegKey* pTargetKey,
                                     ORegKey* pSourceKey,
@@ -1361,7 +1351,6 @@ RegError ORegistry::loadAndSaveKeys(ORegKey* pTargetKey,
                                     sal_Bool bWarnings,
                                     sal_Bool bReport)
 {
-    ORegKey*    pTmpKey;
     RegError    _ret = REG_NO_ERROR;
     OUString    sRelPath(pSourceKey->getName().copy(nCut));
     OUString    sFullPath;
@@ -1372,11 +1361,10 @@ RegError ORegistry::loadAndSaveKeys(ORegKey* pTargetKey,
     if (sRelPath.getLength() > 1 || sFullPath.getLength() == 0)
         sFullPath += ROOT;
 
-    OUString        sFullKeyName = sFullPath;
-    OStoreDirectory rStoreDir;
-
+    OUString sFullKeyName = sFullPath;
     sFullKeyName += keyName;
 
+    OStoreDirectory rStoreDir;
     if (rStoreDir.create(pTargetKey->getStoreFile(), sFullPath, keyName, KEY_MODE_CREATE))
     {
         return REG_CREATE_KEY_FAILED;
@@ -1387,21 +1375,18 @@ RegError ORegistry::loadAndSaveKeys(ORegKey* pTargetKey,
         m_openKeyTable[sFullKeyName]->setDeleted(sal_False);
     }
 
-    _ret = pSourceKey->openKey(
-        keyName, (RegKeyHandle*)&pTmpKey);
-    if (_ret)
-    {
+    ORegKey* pTmpKey = 0;
+    _ret = pSourceKey->openKey(keyName, (RegKeyHandle*)&pTmpKey);
+    if (_ret != REG_NO_ERROR)
         return _ret;
-    }
 
     OStoreDirectory::iterator   iter;
-    OUString                    sName;
     OStoreDirectory             rTmpStoreDir(pTmpKey->getStoreDir());
     storeError                  _err = rTmpStoreDir.first(iter);
 
     while ( _err == store_E_None)
     {
-        sName = iter.m_pszName;
+        OUString const sName = iter.m_pszName;
 
         if (iter.m_nAttrib & STORE_ATTRIB_ISDIR)
         {
@@ -1413,17 +1398,15 @@ RegError ORegistry::loadAndSaveKeys(ORegKey* pTargetKey,
                                     sName, nCut, bWarnings, bReport);
         }
 
-        if (_ret == REG_MERGE_ERROR ||
-            (_ret == REG_MERGE_CONFLICT && bWarnings))
-        {
-            pSourceKey->closeKey(pTmpKey);
-            return _ret;
-        }
+        if (_ret == REG_MERGE_ERROR)
+            break;
+        if (_ret == REG_MERGE_CONFLICT && bWarnings)
+            break;
 
         _err = rTmpStoreDir.next(iter);
     }
 
-    pSourceKey->closeKey(pTmpKey);
+    pSourceKey->releaseKey(pTmpKey);
     return _ret;
 }
 
@@ -1477,21 +1460,6 @@ RegError ORegistry::dumpRegistry(RegKeyHandle hKey) const
     return REG_NO_ERROR;
 }
 
-RegError ORegistry::flush()
-{
-    REG_GUARD(m_mutex);
-
-    if (m_file.isValid())
-    {
-        m_file.flush();
-        return REG_NO_ERROR;
-    } else
-    {
-        return REG_REGISTRY_NOT_EXISTS;
-    }
-}
-
-
 //*********************************************************************
 //  dumpValue()
 //
diff --git a/registry/source/regimpl.hxx b/registry/source/regimpl.hxx
index 32baf9cc6ed5..54048584d7f7 100644
--- a/registry/source/regimpl.hxx
+++ b/registry/source/regimpl.hxx
@@ -32,10 +32,10 @@
 #define _REGIMPL_HXX_
 
 #include <set>
-
 #include <hash_map>
 
 #include    <registry/registry.h>
+#include    <rtl/ustring.hxx>
 #include    <osl/mutex.hxx>
 #include    <store/store.hxx>
 
@@ -62,11 +62,10 @@
 #define REG_CREATE      0x0004  // allow write accesses
 
 #define REG_GUARD(mutex) \
-    Guard< Mutex > aGuard( mutex );
+    osl::Guard< osl::Mutex > aGuard( mutex );
 
-using namespace rtl;
-using namespace osl;
-using namespace store;
+// @@@ using namespace rtl;
+// @@@ using namespace osl;
 
 class ORegKey;
 class RegistryTypeReader;
@@ -82,39 +81,40 @@ public:
     sal_uInt32  release()
         { return --m_refCount; }
 
-    RegError    initRegistry(const OUString& name,
+    RegError    initRegistry(const rtl::OUString& name,
                              RegAccessMode accessMode);
 
     RegError    closeRegistry();
 
-    RegError    destroyRegistry(const OUString& name);
+    RegError    destroyRegistry(const rtl::OUString& name);
+
+    RegError    acquireKey(RegKeyHandle hKey);
+    RegError    releaseKey(RegKeyHandle hKey);
 
     RegError    createKey(RegKeyHandle hKey,
-                          const OUString& keyName,
+                          const rtl::OUString& keyName,
                           RegKeyHandle* phNewKey);
 
     RegError    openKey(RegKeyHandle hKey,
-                        const OUString& keyName,
+                        const rtl::OUString& keyName,
                         RegKeyHandle* phOpenKey);
 
     RegError    closeKey(RegKeyHandle hKey);
 
-    RegError    deleteKey(RegKeyHandle hKey, const OUString& keyName);
+    RegError    deleteKey(RegKeyHandle hKey, const rtl::OUString& keyName);
 
     RegError    loadKey(RegKeyHandle hKey,
-                        const OUString& regFileName,
+                        const rtl::OUString& regFileName,
                         sal_Bool bWarings=sal_False,
                         sal_Bool bReport=sal_False);
 
     RegError    saveKey(RegKeyHandle hKey,
-                        const OUString& regFileName,
+                        const rtl::OUString& regFileName,
                         sal_Bool bWarings=sal_False,
                         sal_Bool bReport=sal_False);
 
     RegError    dumpRegistry(RegKeyHandle hKey) const;
 
-    RegError    flush();
-
     ~ORegistry();
 
     sal_Bool            isReadOnly() const
@@ -125,62 +125,62 @@ public:
 
     ORegKey*    getRootKey();
 
-    const OStoreFile&   getStoreFile()
+    const store::OStoreFile& getStoreFile()
         { return m_file; }
 
-    const OUString&     getName() const
+    const rtl::OUString&    getName() const
         { return m_name; }
 
     friend class ORegKey;
 
 private:
-    RegError    eraseKey(ORegKey* pKey, const OUString& keyName);
+    RegError    eraseKey(ORegKey* pKey, const rtl::OUString& keyName);
 
     RegError    deleteSubkeysAndValues(ORegKey* pKey);
 
     RegError    loadAndSaveValue(ORegKey* pTargetKey,
                                  ORegKey* pSourceKey,
-                                 const OUString& valueName,
+                                 const rtl::OUString& valueName,
                                  sal_uInt32 nCut,
                                  sal_Bool bWarnings=sal_False,
                                  sal_Bool bReport=sal_False);
 
-    RegError    checkBlop(OStoreStream& rValue,
-                          const OUString& sTargetPath,
+    RegError    checkBlop(store::OStoreStream& rValue,
+                          const rtl::OUString& sTargetPath,
                           sal_uInt32 srcValueSize,
                           sal_uInt8* pSrcBuffer,
                           sal_Bool bReport=sal_False);
 
-    RegError    mergeModuleValue(OStoreStream& rTargetValue,
+    RegError    mergeModuleValue(store::OStoreStream& rTargetValue,
                                  RegistryTypeReader& reader,
                                  RegistryTypeReader& reader2);
 
     RegError    loadAndSaveKeys(ORegKey* pTargetKey,
                                 ORegKey* pSourceKey,
-                                const OUString& keyName,
+                                const rtl::OUString& keyName,
                                 sal_uInt32 nCut,
                                 sal_Bool bWarnings=sal_False,
                                 sal_Bool bReport=sal_False);
 
-    RegError    dumpValue(const OUString& sPath,
-                          const OUString& sName,
+    RegError    dumpValue(const rtl::OUString& sPath,
+                          const rtl::OUString& sName,
                           sal_Int16 nSpace) const;
 
-    RegError    dumpKey(const OUString& sPath,
-                        const OUString& sName,
+    RegError    dumpKey(const rtl::OUString& sPath,
+                        const rtl::OUString& sName,
                         sal_Int16 nSpace) const;
 
-    typedef std::hash_map< OUString, ORegKey*, OUStringHash > KeyMap;
+    typedef std::hash_map< rtl::OUString, ORegKey*, rtl::OUStringHash > KeyMap;
 
     sal_uInt32      m_refCount;
-    Mutex           m_mutex;
+    osl::Mutex          m_mutex;
     sal_Bool        m_readOnly;
     sal_Bool        m_isOpen;
-    OUString        m_name;
-    OStoreFile      m_file;
+    rtl::OUString       m_name;
+    store::OStoreFile   m_file;
     KeyMap          m_openKeyTable;
 
-    const OUString  ROOT;
+    const rtl::OUString ROOT;
 };
 
 #endif
diff --git a/registry/source/registry.cxx b/registry/source/registry.cxx
index 139646f7cdc7..cef3630f8b7e 100644
--- a/registry/source/registry.cxx
+++ b/registry/source/registry.cxx
@@ -30,13 +30,13 @@
 
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_registry.hxx"
+
 #include <registry/registry.h>
 #include <registry/registry.hxx>
 #include <osl/process.h>
-#include "regimpl.hxx"
-#ifndef _REGKEY_HXX_
+
 #include "keyimpl.hxx"
-#endif
+#include "regimpl.hxx"
 #include "regkey.hxx"
 
 #if defined(WIN32) || defined(WNT) || defined(OS2)
@@ -260,46 +260,42 @@ static RegError REGISTRY_CALLTYPE loadKey(RegHandle hReg,
                                            rtl_uString* keyName,
                                            rtl_uString* regFileName)
 {
-    ORegistry   *pReg;
-    ORegKey     *pKey, *pNewKey;
-    RegError    _ret;
 
-    if (hReg)
-    {
-        pReg = (ORegistry*)hReg;
-        if (!pReg->isOpen())
-            return REG_REGISTRY_NOT_OPEN;
-    } else
-    {
+    ORegistry* pReg = static_cast< ORegistry* >(hReg);
+    if (!pReg)
         return REG_INVALID_REGISTRY;
-    }
 
-    if (hKey)
-    {
-        pKey = (ORegKey*)hKey;
+    if (!pReg->isOpen())
+        return REG_REGISTRY_NOT_OPEN;
 
-        if (pKey->getRegistry() != pReg || pKey->isDeleted())
-            return REG_INVALID_KEY;
-    } else
-    {
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
         return REG_INVALID_KEY;
-    }
 
+    if (pKey->getRegistry() != pReg)
+        return REG_INVALID_KEY;
+    if (pKey->isDeleted())
+        return REG_INVALID_KEY;
     if (pKey->isReadOnly())
         return REG_REGISTRY_READONLY;
 
-    if (!pKey->openKey(keyName, (RegKeyHandle*)&pNewKey))
+
+    ORegKey* pNewKey = 0;
+    RegError _ret = pKey->openKey(keyName, (RegKeyHandle*)&pNewKey);
+    if (_ret == REG_NO_ERROR)
     {
-        pKey->closeKey(pNewKey);
+        pKey->releaseKey(pNewKey);
         pKey->deleteKey(keyName);
     }
 
-    if ((_ret = pKey->createKey(keyName, (RegKeyHandle*)&pNewKey)))
+    _ret = pKey->createKey(keyName, (RegKeyHandle*)&pNewKey);
+    if (_ret != REG_NO_ERROR)
         return _ret;
 
-    if ((_ret = pReg->loadKey(pNewKey, regFileName)))
+    _ret = pReg->loadKey(pNewKey, regFileName);
+    if (_ret != REG_NO_ERROR)
     {
-        pKey->closeKey(pNewKey);
+        pKey->releaseKey(pNewKey);
         pKey->deleteKey(keyName);
         return _ret;
     }
@@ -315,41 +311,36 @@ static RegError REGISTRY_CALLTYPE saveKey(RegHandle hReg,
                                            rtl_uString* keyName,
                                            rtl_uString* regFileName)
 {
-    ORegistry   *pReg;
-    ORegKey     *pKey, *pNewKey;
-    RegError    _ret;
 
-    if (hReg)
-    {
-        pReg = (ORegistry*)hReg;
-        if (!pReg->isOpen())
-            return REG_REGISTRY_NOT_OPEN;
-    } else
-    {
+    ORegistry* pReg = static_cast< ORegistry* >(hReg);
+    if (!pReg)
         return REG_INVALID_REGISTRY;
-    }
 
-    if (hKey)
-    {
-        pKey = (ORegKey*)hKey;
+    if (!pReg->isOpen())
+        return REG_REGISTRY_NOT_OPEN;
 
-        if (pKey->getRegistry() != pReg || pKey->isDeleted())
-            return REG_INVALID_KEY;
-    } else
-    {
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return REG_INVALID_KEY;
+
+    if (pKey->getRegistry() != pReg)
+        return REG_INVALID_KEY;
+    if (pKey->isDeleted())
         return REG_INVALID_KEY;
-    }
 
-    if ((_ret = pKey->openKey(keyName, (RegKeyHandle*)&pNewKey)))
+    ORegKey* pNewKey = 0;
+    RegError _ret = pKey->openKey(keyName, (RegKeyHandle*)&pNewKey);
+    if (_ret != REG_NO_ERROR)
         return _ret;
 
-    if ((_ret = pReg->saveKey(pNewKey, regFileName)))
+    _ret = pReg->saveKey(pNewKey, regFileName);
+    if (_ret != REG_NO_ERROR)
     {
-        pKey->closeKey(pNewKey);
+        (void) pKey->releaseKey(pNewKey);
         return _ret;
     }
 
-    return pKey->closeKey(pNewKey);
+    return pKey->releaseKey(pNewKey);
 }
 
 //*********************************************************************
@@ -362,114 +353,68 @@ static RegError REGISTRY_CALLTYPE mergeKey(RegHandle hReg,
                                            sal_Bool bWarnings,
                                            sal_Bool bReport)
 {
-    ORegistry   *pReg;
-    ORegKey     *pKey, *pNewKey;
-    RegError    _ret;
-
-    if (hReg)
-    {
-        pReg = (ORegistry*)hReg;
-        if (!pReg->isOpen())
-            return(REG_REGISTRY_NOT_OPEN);
-    } else
-    {
+    ORegistry* pReg = static_cast< ORegistry* >(hReg);
+    if (!pReg)
         return REG_INVALID_REGISTRY;
-    }
-
-    if (hKey)
-    {
-        pKey = (ORegKey*)hKey;
+    if (!pReg->isOpen())
+        return REG_REGISTRY_NOT_OPEN;
 
-        if (pKey->getRegistry() != pReg || pKey->isDeleted())
-            return REG_INVALID_KEY;
-    } else
-    {
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return REG_INVALID_KEY;
+    if (pKey->getRegistry() != pReg)
+        return REG_INVALID_KEY;
+    if (pKey->isDeleted())
         return REG_INVALID_KEY;
-    }
-
     if (pKey->isReadOnly())
         return REG_REGISTRY_READONLY;
 
     if (keyName->length)
     {
-        if ((_ret = pKey->createKey(keyName, (RegKeyHandle*)&pNewKey) ))
+        ORegKey* pNewKey = 0;
+        RegError _ret = pKey->createKey(keyName, (RegKeyHandle*)&pNewKey);
+        if (_ret != REG_NO_ERROR)
             return _ret;
-    } else
-    {
-        pNewKey = pKey;
-    }
-
-    _ret = pKey->getRegistry()->loadKey(pNewKey, regFileName, bWarnings, bReport);
-
-    if (_ret == REG_MERGE_ERROR ||
-        (_ret == REG_MERGE_CONFLICT && bWarnings))
-    {
-        pKey->closeKey(pNewKey);
-        return _ret;
-    }
 
-    /*
-    if (_ret)
-    {
-        if (_ret == REG_MERGE_ERROR ||
-            (_ret == REG_MERGE_CONFLICT && bWarnings))
+        _ret = pReg->loadKey(pNewKey, regFileName, bWarnings, bReport);
+        if (_ret == REG_MERGE_ERROR || (_ret == REG_MERGE_CONFLICT && bWarnings))
         {
-            pKey->closeKey(pNewKey);
-            pKey->deleteKey(keyName);
-            pKey->createKey(keyName, (RegKeyHandle*)&pNewKey);
-            pReg->loadKey(pNewKey, tmpName, sal_False, sal_False);
+            if (pNewKey != pKey)
+                (void) pKey->closeKey(pNewKey);
+            else
+                (void) pKey->releaseKey(pNewKey);
+            return _ret;
         }
 
-        destroyRegistry(hReg, tmpName);
-
-        pKey->closeKey(pNewKey);
-        return _ret;
+        return (pNewKey != pKey) ? pKey->closeKey(pNewKey) : pKey->releaseKey(pNewKey);
     }
 
-    destroyRegistry(hReg, tmpName);
-    */
-    _ret = pKey->closeKey(pNewKey);
-
-    if (_ret == REG_NO_ERROR )
-        _ret = pReg->flush();
-    return _ret;
+    return pReg->loadKey(pKey, regFileName, bWarnings, bReport);
 }
 
-
 //*********************************************************************
 //  dumpRegistry
 //
 static RegError REGISTRY_CALLTYPE dumpRegistry(RegHandle hReg,
                                                RegKeyHandle hKey)
 {
-    ORegistry   *pReg;
-    ORegKey     *pKey;
-
-    if (hReg)
-    {
-        pReg = (ORegistry*)hReg;
-        if (!pReg->isOpen())
-            return REG_REGISTRY_NOT_OPEN;
-    } else
-    {
+    ORegistry* pReg = static_cast< ORegistry* >(hReg);
+    if (!pReg)
         return REG_INVALID_REGISTRY;
-    }
-
-    if (hKey)
-    {
-        pKey = (ORegKey*)hKey;
+    if (!pReg->isOpen())
+        return REG_REGISTRY_NOT_OPEN;
 
-        if (pKey->getRegistry() != pReg || pKey->isDeleted())
-            return REG_INVALID_KEY;
-    } else
-    {
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return REG_INVALID_KEY;
+    if (pKey->getRegistry() != pReg)
+        return REG_INVALID_KEY;
+    if (pKey->isDeleted())
         return REG_INVALID_KEY;
-    }
 
     return pReg->dumpRegistry(hKey);
 }
 
-
 //*********************************************************************
 //  initRegistry_Api
 //
diff --git a/registry/source/regkey.cxx b/registry/source/regkey.cxx
index 1d828a862a96..4ea3e9345e0b 100644
--- a/registry/source/regkey.cxx
+++ b/registry/source/regkey.cxx
@@ -32,21 +32,25 @@
 #include "precompiled_registry.hxx"
 
 #include "regkey.hxx"
+
 #include    <registry/registry.hxx>
 #include    <rtl/alloc.h>
 #include    "regimpl.hxx"
 #include    "keyimpl.hxx"
 
+using rtl::OUString;
 
 //*********************************************************************
 //  acquireKey
 //
 void REGISTRY_CALLTYPE acquireKey(RegKeyHandle hKey)
 {
-    ORegKey* pKey = (ORegKey*) hKey;
-
-    if (pKey != NULL)
-        pKey->acquire();
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (pKey != 0)
+    {
+        ORegistry* pReg = pKey->getRegistry();
+        (void) pReg->acquireKey(pKey);
+    }
 }
 
 
@@ -55,12 +59,11 @@ void REGISTRY_CALLTYPE acquireKey(RegKeyHandle hKey)
 //
 void REGISTRY_CALLTYPE releaseKey(RegKeyHandle hKey)
 {
-    ORegKey* pKey = (ORegKey*) hKey;
-
-    if (pKey)
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (pKey != 0)
     {
-        if (pKey->release() == 0)
-            delete pKey;
+        ORegistry* pReg = pKey->getRegistry();
+        (void) pReg->releaseKey(pKey);
     }
 }
 
@@ -70,13 +73,8 @@ void REGISTRY_CALLTYPE releaseKey(RegKeyHandle hKey)
 //
 sal_Bool REGISTRY_CALLTYPE isKeyReadOnly(RegKeyHandle hKey)
 {
-    if (hKey)
-    {
-        return ((ORegKey*)hKey)->isReadOnly();
-    } else
-    {
-        return sal_False;
-    }
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    return (pKey != 0) ? pKey->isReadOnly() : sal_False;
 }
 
 
@@ -85,9 +83,10 @@ sal_Bool REGISTRY_CALLTYPE isKeyReadOnly(RegKeyHandle hKey)
 //
 RegError REGISTRY_CALLTYPE getKeyName(RegKeyHandle hKey, rtl_uString** pKeyName)
 {
-    if (hKey)
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (pKey)
     {
-        rtl_uString_assign( pKeyName, ((ORegKey*)hKey)->getName().pData );
+        rtl_uString_assign( pKeyName, pKey->getName().pData );
         return REG_NO_ERROR;
     } else
     {
@@ -104,22 +103,14 @@ RegError REGISTRY_CALLTYPE createKey(RegKeyHandle hKey,
                                      rtl_uString* keyName,
                                      RegKeyHandle* phNewKey)
 {
-    ORegKey*    pKey;
+    *phNewKey = 0;
 
-    if (hKey)
-    {
-        pKey = (ORegKey*)hKey;
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return REG_INVALID_KEY;
 
-        if (pKey->isDeleted())
-        {
-            phNewKey = NULL;
-            return REG_INVALID_KEY;
-        }
-    } else
-    {
-        phNewKey = NULL;
+    if (pKey->isDeleted())
         return REG_INVALID_KEY;
-    }
 
     if (pKey->isReadOnly())
         return REG_REGISTRY_READONLY;
@@ -134,22 +125,14 @@ RegError REGISTRY_CALLTYPE openKey(RegKeyHandle hKey,
                                    rtl_uString* keyName,
                                    RegKeyHandle* phOpenKey)
 {
-    ORegKey*    pKey;
+    *phOpenKey = 0;
 
-    if (hKey)
-    {
-        pKey = (ORegKey*)hKey;
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return REG_INVALID_KEY;
 
-        if (pKey->isDeleted())
-        {
-            phOpenKey = NULL;
-            return REG_INVALID_KEY;
-        }
-    } else
-    {
-        phOpenKey = NULL;
+    if (pKey->isDeleted())
         return REG_INVALID_KEY;
-    }
 
     return pKey->openKey(keyName, phOpenKey);
 }
@@ -162,24 +145,15 @@ RegError REGISTRY_CALLTYPE openSubKeys(RegKeyHandle hKey,
                                        RegKeyHandle** pphSubKeys,
                                        sal_uInt32* pnSubKeys)
 {
-    ORegKey*    pKey;
+    *pphSubKeys = NULL;
+    *pnSubKeys = 0;
 
-    if (hKey)
-    {
-        pKey = (ORegKey*)hKey;
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return REG_INVALID_KEY;
 
-        if (pKey->isDeleted())
-        {
-            *pphSubKeys = NULL;
-            *pnSubKeys = 0;
-            return REG_INVALID_KEY;
-        }
-    } else
-    {
-        *pphSubKeys = NULL;
-        *pnSubKeys = 0;
+    if (pKey->isDeleted())
         return REG_INVALID_KEY;
-    }
 
     return pKey->openSubKeys(keyName, pphSubKeys, pnSubKeys);
 }
@@ -190,43 +164,30 @@ RegError REGISTRY_CALLTYPE openSubKeys(RegKeyHandle hKey,
 RegError REGISTRY_CALLTYPE closeSubKeys(RegKeyHandle* phSubKeys,
                                         sal_uInt32 nSubKeys)
 {
-    RegError _ret = REG_NO_ERROR;
+    if (phSubKeys == 0 || nSubKeys == 0)
+        return REG_INVALID_KEY;
 
-    if (phSubKeys != 0 && nSubKeys != 0)
+    ORegistry* pReg = ((ORegKey*)(phSubKeys[0]))->getRegistry();
+    for (sal_uInt32 i = 0; i < nSubKeys; i++)
     {
-        ORegistry* pReg = NULL;
-
-        pReg = ((ORegKey*)phSubKeys[0])->getRegistry();
-
-        for (sal_uInt32 i=0; (i < nSubKeys) && (_ret == REG_NO_ERROR); i++)
-        {
-            _ret = pReg->closeKey(phSubKeys[i]);
-        }
-
-        rtl_freeMemory(phSubKeys);
+        (void) pReg->closeKey(phSubKeys[i]);
     }
-    else
-        _ret = REG_INVALID_KEY;
+    rtl_freeMemory(phSubKeys);
 
-    return _ret;
+    return REG_NO_ERROR;
 }
 
-
 //*********************************************************************
 //  deleteKey
 //
 RegError REGISTRY_CALLTYPE deleteKey(RegKeyHandle hKey,
                                      rtl_uString* keyName)
 {
-    ORegKey*    pKey;
-
-    if (hKey)
-    {
-        pKey = (ORegKey*)hKey;
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return REG_INVALID_KEY;
 
-        if (pKey->isDeleted())
-            return REG_INVALID_KEY;
-    } else
+    if (pKey->isDeleted())
         return REG_INVALID_KEY;
 
     if (pKey->isReadOnly())
@@ -240,24 +201,13 @@ RegError REGISTRY_CALLTYPE deleteKey(RegKeyHandle hKey,
 //
 RegError REGISTRY_CALLTYPE closeKey(RegKeyHandle hKey)
 {
-    ORegKey*    pKey;
-    ORegistry*  pReg;
-
-    if (hKey)
-    {
-        pKey = (ORegKey*)hKey;
-
-        pReg = pKey->getRegistry();
-
-        if (pReg->closeKey(hKey))
-            return REG_INVALID_KEY;
-    } else
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
         return REG_INVALID_KEY;
 
-    return REG_NO_ERROR;
+    return pKey->closeKey(hKey);
 }
 
-
 //*********************************************************************
 //  setValue
 //
@@ -267,15 +217,11 @@ RegError REGISTRY_CALLTYPE setValue(RegKeyHandle hKey,
                                        RegValue pData,
                                        sal_uInt32 valueSize)
 {
-    ORegKey*    pKey;
-
-    if (hKey)
-    {
-        pKey = (ORegKey*)hKey;
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return REG_INVALID_KEY;
 
-        if (pKey->isDeleted())
-            return REG_INVALID_KEY;
-    } else
+    if (pKey->isDeleted())
         return REG_INVALID_KEY;
 
     if (pKey->isReadOnly())
@@ -284,24 +230,22 @@ RegError REGISTRY_CALLTYPE setValue(RegKeyHandle hKey,
     OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
     if (keyName->length)
     {
-        RegKeyHandle hSubKey;
-        ORegKey* pSubKey;
-        RegError _ret1 = pKey->openKey(keyName, &hSubKey);
-        if (_ret1)
+        ORegKey* pSubKey = 0;
+        RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
+        if (_ret1 != REG_NO_ERROR)
             return _ret1;
 
-        pSubKey = (ORegKey*)hSubKey;
         _ret1 = pSubKey->setValue(valueName, valueType, pData, valueSize);
-        if (_ret1)
+        if (_ret1 != REG_NO_ERROR)
         {
-            RegError _ret2 = pKey->closeKey(hSubKey);
+            RegError _ret2 = pKey->closeKey(pSubKey);
             if (_ret2)
                 return _ret2;
             else
                 return _ret1;
         }
 
-        return pKey->closeKey(hSubKey);
+        return pKey->closeKey(pSubKey);
     }
 
     return pKey->setValue(valueName, valueType, pData, valueSize);
@@ -315,15 +259,11 @@ RegError REGISTRY_CALLTYPE setLongListValue(RegKeyHandle hKey,
                                                   sal_Int32* pValueList,
                                                   sal_uInt32 len)
 {
-    ORegKey*    pKey;
-
-    if (hKey)
-    {
-        pKey = (ORegKey*)hKey;
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return REG_INVALID_KEY;
 
-        if (pKey->isDeleted())
-            return REG_INVALID_KEY;
-    } else
+    if (pKey->isDeleted())
         return REG_INVALID_KEY;
 
     if (pKey->isReadOnly())
@@ -332,24 +272,22 @@ RegError REGISTRY_CALLTYPE setLongListValue(RegKeyHandle hKey,
     OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
     if (keyName->length)
     {
-        RegKeyHandle hSubKey;
-        ORegKey* pSubKey;
-        RegError _ret1 = pKey->openKey(keyName, &hSubKey);
-        if (_ret1)
+        ORegKey* pSubKey = 0;
+        RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
+        if (_ret1 != REG_NO_ERROR)
             return _ret1;
 
-        pSubKey = (ORegKey*)hSubKey;
         _ret1 = pSubKey->setLongListValue(valueName, pValueList, len);
-        if (_ret1)
+        if (_ret1 != REG_NO_ERROR)
         {
-            RegError _ret2 = pKey->closeKey(hSubKey);
-            if (_ret2)
+            RegError _ret2 = pKey->closeKey(pSubKey);
+            if (_ret2 != REG_NO_ERROR)
                 return _ret2;
             else
                 return _ret1;
         }
 
-        return pKey->closeKey(hSubKey);
+        return pKey->closeKey(pSubKey);
     }
 
     return pKey->setLongListValue(valueName, pValueList, len);
@@ -363,15 +301,11 @@ RegError REGISTRY_CALLTYPE setStringListValue(RegKeyHandle hKey,
                                                    sal_Char** pValueList,
                                                    sal_uInt32 len)
 {
-    ORegKey*    pKey;
-
-    if (hKey)
-    {
-        pKey = (ORegKey*)hKey;
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return REG_INVALID_KEY;
 
-        if (pKey->isDeleted())
-            return REG_INVALID_KEY;
-    } else
+    if (pKey->isDeleted())
         return REG_INVALID_KEY;
 
     if (pKey->isReadOnly())
@@ -380,24 +314,22 @@ RegError REGISTRY_CALLTYPE setStringListValue(RegKeyHandle hKey,
     OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
     if (keyName->length)
     {
-        RegKeyHandle hSubKey;
-        ORegKey* pSubKey;
-        RegError _ret1 = pKey->openKey(keyName, &hSubKey);
-        if (_ret1)
+        ORegKey* pSubKey = 0;
+        RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
+        if (_ret1 != REG_NO_ERROR)
             return _ret1;
 
-        pSubKey = (ORegKey*)hSubKey;
         _ret1 = pSubKey->setStringListValue(valueName, pValueList, len);
-        if (_ret1)
+        if (_ret1 != REG_NO_ERROR)
         {
-            RegError _ret2 = pKey->closeKey(hSubKey);
-            if (_ret2)
+            RegError _ret2 = pKey->closeKey(pSubKey);
+            if (_ret2 != REG_NO_ERROR)
                 return _ret2;
             else
                 return _ret1;
         }
 
-        return pKey->closeKey(hSubKey);
+        return pKey->closeKey(pSubKey);
     }
 
     return pKey->setStringListValue(valueName, pValueList, len);
@@ -411,15 +343,11 @@ RegError REGISTRY_CALLTYPE setUnicodeListValue(RegKeyHandle hKey,
                                                      sal_Unicode** pValueList,
                                                      sal_uInt32 len)
 {
-    ORegKey*    pKey;
-
-    if (hKey)
-    {
-        pKey = (ORegKey*)hKey;
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return REG_INVALID_KEY;
 
-        if (pKey->isDeleted())
-            return REG_INVALID_KEY;
-    } else
+    if (pKey->isDeleted())
         return REG_INVALID_KEY;
 
     if (pKey->isReadOnly())
@@ -428,24 +356,22 @@ RegError REGISTRY_CALLTYPE setUnicodeListValue(RegKeyHandle hKey,
     OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
     if (keyName->length)
     {
-        RegKeyHandle hSubKey;
-        ORegKey* pSubKey;
-        RegError _ret1 = pKey->openKey(keyName, &hSubKey);
-        if (_ret1)
+        ORegKey* pSubKey = 0;
+        RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
+        if (_ret1 != REG_NO_ERROR)
             return _ret1;
 
-        pSubKey = (ORegKey*)hSubKey;
         _ret1 = pSubKey->setUnicodeListValue(valueName, pValueList, len);
-        if (_ret1)
+        if (_ret1 != REG_NO_ERROR)
         {
-            RegError _ret2 = pKey->closeKey(hSubKey);
-            if (_ret2)
+            RegError _ret2 = pKey->closeKey(pSubKey);
+            if (_ret2 != REG_NO_ERROR)
                 return _ret2;
             else
                 return _ret1;
         }
 
-        return pKey->closeKey(hSubKey);
+        return pKey->closeKey(pSubKey);
     }
 
     return pKey->setUnicodeListValue(valueName, pValueList, len);
@@ -459,49 +385,41 @@ RegError REGISTRY_CALLTYPE getValueInfo(RegKeyHandle hKey,
                                         RegValueType* pValueType,
                                         sal_uInt32* pValueSize)
 {
-    ORegKey*        pKey;
-    RegValueType    valueType;
-    sal_uInt32      valueSize;
-
     *pValueType = RG_VALUETYPE_NOT_DEFINED;
     *pValueSize = 0;
 
-    if (hKey)
-    {
-        pKey = (ORegKey*)hKey;
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return REG_INVALID_KEY;
 
-        if (pKey->isDeleted())
-            return REG_INVALID_KEY;
-    } else
+    if (pKey->isDeleted())
         return REG_INVALID_KEY;
 
+    RegValueType valueType;
+    sal_uInt32   valueSize;
+
     OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
     if (keyName->length)
     {
-        RegKeyHandle hSubKey;
-        ORegKey* pSubKey;
-        RegError _ret = pKey->openKey(keyName, &hSubKey);
-        if (_ret)
+        ORegKey* pSubKey = 0;
+        RegError _ret = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
+        if (_ret != REG_NO_ERROR)
             return _ret;
 
-        pSubKey = (ORegKey*)hSubKey;
-        if (pSubKey->getValueInfo(valueName, &valueType, &valueSize))
+        if (pSubKey->getValueInfo(valueName, &valueType, &valueSize) != REG_NO_ERROR)
         {
-            _ret = pKey->closeKey(hSubKey);
-            if (_ret)
-                return _ret;
-            else
-                return REG_INVALID_VALUE;
+            (void) pKey->releaseKey(pSubKey);
+            return REG_INVALID_VALUE;
         }
 
         *pValueType = valueType;
         *pValueSize = valueSize;
 
-        return pKey->closeKey(hSubKey);
+        return pKey->releaseKey(pSubKey);
     }
 
 
-    if (pKey->getValueInfo(valueName, &valueType, &valueSize))
+    if (pKey->getValueInfo(valueName, &valueType, &valueSize) != REG_NO_ERROR)
     {
         return REG_INVALID_VALUE;
     }
@@ -519,52 +437,29 @@ RegError REGISTRY_CALLTYPE getValue(RegKeyHandle hKey,
                                     rtl_uString* keyName,
                                     RegValue pValue)
 {
-    ORegKey*    pKey;
-
-    if (hKey)
-    {
-        pKey = (ORegKey*)hKey;
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return REG_INVALID_KEY;
 
-        if (pKey->isDeleted())
-        {
-            pValue = NULL;
-            return REG_INVALID_KEY;
-        }
-    } else
-    {
-        pValue = NULL;
+    if (pKey->isDeleted())
         return REG_INVALID_KEY;
-    }
 
     OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
     if (keyName->length)
     {
-        RegKeyHandle hSubKey;
-        ORegKey* pSubKey;
-        RegError _ret1 = pKey->openKey(keyName, &hSubKey);
-        if (_ret1)
-        {
-            pValue = NULL;
+        ORegKey* pSubKey = 0;
+        RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
+        if (_ret1 != REG_NO_ERROR)
             return _ret1;
-        }
 
-        pSubKey = (ORegKey*)hSubKey;
         _ret1 = pSubKey->getValue(valueName, pValue);
-        if (_ret1)
+        if (_ret1 != REG_NO_ERROR)
         {
-            RegError _ret2 = pKey->closeKey(hSubKey);
-            if (_ret2)
-            {
-                pValue = NULL;
-                return _ret2;
-            } else
-            {
-                pValue = NULL;
-                return _ret1;
-            }
+            (void) pKey->releaseKey(pSubKey);
+            return _ret1;
         }
 
-        return pKey->closeKey(hSubKey);
+        return pKey->releaseKey(pSubKey);
     }
 
     return pKey->getValue(valueName, pValue);
@@ -578,58 +473,32 @@ RegError REGISTRY_CALLTYPE getLongListValue(RegKeyHandle hKey,
                                             sal_Int32** pValueList,
                                             sal_uInt32* pLen)
 {
-    ORegKey*    pKey;
+    OSL_PRECOND((pValueList != 0) && (pLen != 0), "registry::getLongListValue(): invalid parameter");
+    *pValueList = 0, *pLen = 0;
 
-    if (hKey)
-    {
-        pKey = (ORegKey*)hKey;
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return REG_INVALID_KEY;
 
-        if (pKey->isDeleted())
-        {
-            pValueList = NULL;
-            *pLen = 0;
-            return REG_INVALID_KEY;
-        }
-    } else
-    {
-        pValueList = NULL;
-        *pLen = 0;
+    if (pKey->isDeleted())
         return REG_INVALID_KEY;
-    }
 
     OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
     if (keyName->length)
     {
-        RegKeyHandle hSubKey;
-        ORegKey* pSubKey;
-        RegError _ret1 = pKey->openKey(keyName, &hSubKey);
-        if (_ret1)
-        {
-            pValueList = NULL;
-            *pLen = 0;
+        ORegKey* pSubKey = 0;
+        RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
+        if (_ret1 != REG_NO_ERROR)
             return _ret1;
-        }
-
-        pSubKey = (ORegKey*)hSubKey;
 
         _ret1 = pSubKey->getLongListValue(valueName, pValueList, pLen);
-        if (_ret1)
+        if (_ret1 != REG_NO_ERROR)
         {
-            RegError _ret2 = pKey->closeKey(hSubKey);
-            if (_ret2)
-            {
-                pValueList = NULL;
-                *pLen = 0;
-                return _ret2;
-            } else
-            {
-                pValueList = NULL;
-                *pLen = 0;
-                return _ret1;
-            }
+            (void) pKey->releaseKey(pSubKey);
+            return _ret1;
         }
 
-        return pKey->closeKey(hSubKey);
+        return pKey->releaseKey(pSubKey);
     }
 
     return pKey->getLongListValue(valueName, pValueList, pLen);
@@ -643,58 +512,32 @@ RegError REGISTRY_CALLTYPE getStringListValue(RegKeyHandle hKey,
                                               sal_Char*** pValueList,
                                               sal_uInt32* pLen)
 {
-    ORegKey*    pKey;
+    OSL_PRECOND((pValueList != 0) && (pLen != 0), "registry::getStringListValue(): invalid parameter");
+    *pValueList = 0, *pLen = 0;
 
-    if (hKey)
-    {
-        pKey = (ORegKey*)hKey;
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return REG_INVALID_KEY;
 
-        if (pKey->isDeleted())
-        {
-            pValueList = NULL;
-            *pLen = 0;
-            return REG_INVALID_KEY;
-        }
-    } else
-    {
-        pValueList = NULL;
-        *pLen = 0;
+    if (pKey->isDeleted())
         return REG_INVALID_KEY;
-    }
 
     OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
     if (keyName->length)
     {
-        RegKeyHandle hSubKey;
-        ORegKey* pSubKey;
-        RegError _ret1 = pKey->openKey(keyName, &hSubKey);
-        if (_ret1)
-        {
-            pValueList = NULL;
-            *pLen = 0;
+        ORegKey* pSubKey = 0;
+        RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
+        if (_ret1 != REG_NO_ERROR)
             return _ret1;
-        }
-
-        pSubKey = (ORegKey*)hSubKey;
 
         _ret1 = pSubKey->getStringListValue(valueName, pValueList, pLen);
-        if (_ret1)
+        if (_ret1 != REG_NO_ERROR)
         {
-            RegError _ret2 = pKey->closeKey(hSubKey);
-            if (_ret2)
-            {
-                pValueList = NULL;
-                *pLen = 0;
-                return _ret2;
-            } else
-            {
-                pValueList = NULL;
-                *pLen = 0;
-                return _ret1;
-            }
+            (void) pKey->releaseKey(pSubKey);
+            return _ret1;
         }
 
-        return pKey->closeKey(hSubKey);
+        return pKey->releaseKey(pSubKey);
     }
 
     return pKey->getStringListValue(valueName, pValueList, pLen);
@@ -708,58 +551,32 @@ RegError REGISTRY_CALLTYPE getUnicodeListValue(RegKeyHandle hKey,
                                                sal_Unicode*** pValueList,
                                                sal_uInt32* pLen)
 {
-    ORegKey*    pKey;
+    OSL_PRECOND((pValueList != 0) && (pLen != 0), "registry::getUnicodeListValue(): invalid parameter");
+    *pValueList = 0, *pLen = 0;
 
-    if (hKey)
-    {
-        pKey = (ORegKey*)hKey;
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return REG_INVALID_KEY;
 
-        if (pKey->isDeleted())
-        {
-            pValueList = NULL;
-            *pLen = 0;
-            return REG_INVALID_KEY;
-        }
-    } else
-    {
-        pValueList = NULL;
-        *pLen = 0;
+    if (pKey->isDeleted())
         return REG_INVALID_KEY;
-    }
 
     OUString valueName( RTL_CONSTASCII_USTRINGPARAM("value") );
     if (keyName->length)
     {
-        RegKeyHandle hSubKey;
-        ORegKey* pSubKey;
-        RegError _ret1 = pKey->openKey(keyName, &hSubKey);
-        if (_ret1)
-        {
-            pValueList = NULL;
-            *pLen = 0;
+        ORegKey* pSubKey = 0;
+        RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
+        if (_ret1 != REG_NO_ERROR)
             return _ret1;
-        }
-
-        pSubKey = (ORegKey*)hSubKey;
 
         _ret1 = pSubKey->getUnicodeListValue(valueName, pValueList, pLen);
-        if (_ret1)
+        if (_ret1 != REG_NO_ERROR)
         {
-            RegError _ret2 = pKey->closeKey(hSubKey);
-            if (_ret2)
-            {
-                pValueList = NULL;
-                *pLen = 0;
-                return _ret2;
-            } else
-            {
-                pValueList = NULL;
-                *pLen = 0;
-                return _ret1;
-            }
+            (void) pKey->releaseKey(pSubKey);
+            return _ret1;
         }
 
-        return pKey->closeKey(hSubKey);
+        return pKey->releaseKey(pSubKey);
     }
 
     return pKey->getUnicodeListValue(valueName, pValueList, pLen);
@@ -809,7 +626,6 @@ RegError REGISTRY_CALLTYPE freeValueList(RegValueType valueType,
     return REG_NO_ERROR;
 }
 
-
 //*********************************************************************
 //  createLink
 //
@@ -833,15 +649,11 @@ RegError REGISTRY_CALLTYPE getKeyType(RegKeyHandle hKey,
                                       rtl_uString* keyName,
                                          RegKeyType* pKeyType)
 {
-    ORegKey*    pKey;
-
-    if (hKey)
-    {
-        pKey = (ORegKey*)hKey;
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return REG_INVALID_KEY;
 
-        if (pKey->isDeleted())
-            return REG_INVALID_KEY;
-    } else
+    if (pKey->isDeleted())
         return REG_INVALID_KEY;
 
     return pKey->getKeyType(keyName, pKeyType);
@@ -864,26 +676,20 @@ RegError REGISTRY_CALLTYPE getResolvedKeyName(RegKeyHandle hKey,
                                               sal_Bool,
                                                 rtl_uString** pResolvedName)
 {
-    ORegKey     *pKey;
-    RegError    _ret = REG_NO_ERROR;
-
-    if (hKey)
-    {
-        pKey = (ORegKey*)hKey;
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return REG_INVALID_KEY;
 
-        if (pKey->isDeleted())
-            return REG_INVALID_KEY;
-    } else
+    if (pKey->isDeleted())
         return REG_INVALID_KEY;
 
     OUString resolvedName;
-    _ret = pKey->getResolvedKeyName(keyName, resolvedName);
-    if (!_ret)
+    RegError _ret = pKey->getResolvedKeyName(keyName, resolvedName);
+    if (_ret == REG_NO_ERROR)
         rtl_uString_assign(pResolvedName, resolvedName.pData);
     return _ret;
 }
 
-
 //*********************************************************************
 //  getKeyNames
 //
@@ -892,15 +698,11 @@ RegError REGISTRY_CALLTYPE getKeyNames(RegKeyHandle hKey,
                                          rtl_uString*** pSubKeyNames,
                                          sal_uInt32* pnSubKeys)
 {
-    ORegKey*    pKey;
-
-    if (hKey)
-    {
-        pKey = (ORegKey*)hKey;
+    ORegKey* pKey = static_cast< ORegKey* >(hKey);
+    if (!pKey)
+        return REG_INVALID_KEY;
 
-        if (pKey->isDeleted())
-            return REG_INVALID_KEY;
-    } else
+    if (pKey->isDeleted())
         return REG_INVALID_KEY;
 
     return pKey->getKeyNames(keyName, pSubKeyNames, pnSubKeys);
@@ -1208,7 +1010,6 @@ RegError REGISTRY_CALLTYPE reg_getLinkTarget(RegKeyHandle hKey,
     return getLinkTarget(hKey, linkName, pLinkTarget);
 }
 
-
 //*********************************************************************
 //  reg_getResolvedKeyName
 //
@@ -1217,14 +1018,8 @@ RegError REGISTRY_CALLTYPE reg_getResolvedKeyName(RegKeyHandle hKey,
                                                     sal_Bool firstLinkOnly,
                                                       rtl_uString** pResolvedName)
 {
-    ORegKey *pKey;
-
-    if (hKey)
-        pKey = (ORegKey*)hKey;
-    else
+    if (!hKey)
         return REG_INVALID_KEY;
 
     return getResolvedKeyName(hKey, keyName, firstLinkOnly, pResolvedName);
 }
-
-
diff --git a/registry/tools/checksingleton.cxx b/registry/tools/checksingleton.cxx
index 7900b1db7a62..ba32ae038ba8 100644
--- a/registry/tools/checksingleton.cxx
+++ b/registry/tools/checksingleton.cxx
@@ -30,6 +30,7 @@
 
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_registry.hxx"
+
 #include <stdio.h>
 #include <string.h>
 
@@ -455,10 +456,10 @@ int _cdecl main( int argc, char * argv[] )
 
     sal_Bool bSingletonsExist = checkSingletons(singletonKey, typeKey);
 
-    indexRoot.closeKey();
-    typeRoot.closeKey();
-    typeKey.closeKey();
-    singletonKey.closeKey();
+    indexRoot.releaseKey();
+    typeRoot.releaseKey();
+    typeKey.releaseKey();
+    singletonKey.releaseKey();
     if ( indexReg.close() )
     {
         fprintf(stderr, "%s: closing registry \"%s\" failed\n",
diff --git a/registry/tools/regcompare.cxx b/registry/tools/regcompare.cxx
index f41103afb826..73662007dcad 100644
--- a/registry/tools/regcompare.cxx
+++ b/registry/tools/regcompare.cxx
@@ -30,6 +30,7 @@
 
 // MARKER(update_precomp.py): autogen include statement, do not remove
 #include "precompiled_registry.hxx"
+
 #include <stdio.h>
 #include <string.h>
 
@@ -2276,8 +2277,8 @@ static sal_uInt32 compareKeys(RegistryKey& key1, RegistryKey& key2)
         {
             nError += compareKeys(subKey1, subKey2);
         }
-        subKey1.closeKey();
-        subKey2.closeKey();
+        subKey1.releaseKey();
+        subKey2.releaseKey();
         ++iter;
     }
 
@@ -2380,8 +2381,8 @@ int _cdecl main( int argc, char * argv[] )
         }
     }
 
-    key1.closeKey();
-    key2.closeKey();
+    key1.releaseKey();
+    key2.releaseKey();
     if ( reg1.close() )
     {
         fprintf(stdout, "%s: closing registry \"%s\" failed\n",
diff --git a/registry/tools/regmerge.cxx b/registry/tools/regmerge.cxx
index 45cab0927b10..4fcb19a03c00 100644
--- a/registry/tools/regmerge.cxx
+++ b/registry/tools/regmerge.cxx
@@ -34,7 +34,7 @@
 #include <stdio.h>
 #include <string.h>
 
-#include "registry/registry.h"
+#include "registry/registry.hxx"
 #include    <rtl/ustring.hxx>
 #include    <rtl/alloc.h>
 #include <osl/process.h>
@@ -207,9 +207,7 @@ int main( int argc, char * argv[] )
 int _cdecl main( int argc, char * argv[] )
 #endif
 {
-    RegHandle       hReg;
-    RegKeyHandle    hRootKey;
-    bool            bVerbose = checkCommandArgs(argc, argv);
+    bool bVerbose = checkCommandArgs(argc, argv);
 
     if (realargc < 4)
     {
@@ -219,9 +217,11 @@ int _cdecl main( int argc, char * argv[] )
     }
 
     ::rtl::OUString regName( convertToFileUrl(realargv[1]) );
-    if (reg_openRegistry(regName.pData, &hReg, REG_READWRITE))
+
+    Registry reg;
+    if (reg.open(regName, REG_READWRITE) != REG_NO_ERROR)
     {
-        if (reg_createRegistry(regName.pData, &hReg))
+        if (reg.create(regName) != REG_NO_ERROR)
         {
             if (bVerbose)
                 fprintf(stderr, "open registry \"%s\" failed\n", realargv[1]);
@@ -230,17 +230,16 @@ int _cdecl main( int argc, char * argv[] )
         }
     }
 
-    if (!reg_openRootKey(hReg, &hRootKey))
+    RegistryKey rootKey;
+    if (reg.openRootKey(rootKey) == REG_NO_ERROR)
     {
         ::rtl::OUString mergeKeyName( ::rtl::OUString::createFromAscii(realargv[2]) );
         ::rtl::OUString targetRegName;
         for (int i = 3; i < realargc; i++)
         {
             targetRegName = convertToFileUrl(realargv[i]);
-            RegError _ret = reg_mergeKey(
-                hRootKey, mergeKeyName.pData, targetRegName.pData, sal_False,
-                bVerbose);
-            if (_ret)
+            RegError _ret = reg.mergeKey(rootKey, mergeKeyName, targetRegName, sal_False, bVerbose);
+            if (_ret != REG_NO_ERROR)
             {
                 if (_ret == REG_MERGE_CONFLICT)
                 {
@@ -262,13 +261,7 @@ int _cdecl main( int argc, char * argv[] )
             }
         }
 
-        if (reg_closeKey(hRootKey))
-        {
-            if (bVerbose)
-                fprintf(stderr, "closing root key of registry \"%s\" failed\n",
-                        realargv[1]);
-            exit(-3);
-        }
+        rootKey.releaseKey();
     } else
     {
         if (bVerbose)
@@ -277,7 +270,7 @@ int _cdecl main( int argc, char * argv[] )
         exit(-4);
     }
 
-    if (reg_closeRegistry(hReg))
+    if (reg.close() != REG_NO_ERROR)
     {
         if (bVerbose)
             fprintf(stderr, "closing registry \"%s\" failed\n", realargv[1]);