Remove visual noise from registry

Change-Id: Ica0c7fe04dae3c52583cc2324bae1cfa5af1e197
Reviewed-on: https://gerrit.libreoffice.org/8292
Reviewed-by: Caolán McNamara <caolanm@redhat.com>
Tested-by: Caolán McNamara <caolanm@redhat.com>

6 files changed, 234 insertions, 234 deletions

diff --git a/registry/source/keyimpl.cxx b/registry/source/keyimpl.cxx
index 793427efa180..c8a3ddd92beb 100644
--- a/registry/source/keyimpl.cxx
+++ b/registry/source/keyimpl.cxx
@@ -30,9 +30,9 @@ using namespace store;
 
 namespace { static char const VALUE_PREFIX[] = "$VL_"; }
 
-//*********************************************************************
+
 //  ORegKey()
-//
+
 ORegKey::ORegKey(const OUString& keyName, ORegistry* pReg)
     : m_refCount(1)
     , m_name(keyName)
@@ -42,43 +42,43 @@ ORegKey::ORegKey(const OUString& keyName, ORegistry* pReg)
 {
 }
 
-//*********************************************************************
+
 //  ~ORegKey()
-//
+
 ORegKey::~ORegKey()
 {
     OSL_POSTCOND(m_refCount == 0, "registry::ORegKey::dtor(): refcount not zero.");
 }
 
-//*********************************************************************
+
 //  releaseKey
-//
+
 RegError ORegKey::releaseKey(RegKeyHandle hKey)
 {
     return m_pRegistry->releaseKey(hKey);
 }
 
-//*********************************************************************
+
 //  createKey
-//
+
 RegError ORegKey::createKey(const OUString& keyName, RegKeyHandle* phNewKey)
 {
     return m_pRegistry->createKey(this, keyName, phNewKey);
 }
 
 
-//*********************************************************************
+
 //  openKey
-//
+
 RegError ORegKey::openKey(const OUString& keyName, RegKeyHandle* phOpenKey)
 {
     return m_pRegistry->openKey(this, keyName, phOpenKey);
 }
 
 
-//*********************************************************************
+
 //  openSubKeys
-//
+
 RegError ORegKey::openSubKeys(const OUString& keyName, RegKeyHandle** phOpenSubKeys, sal_uInt32* pnSubKeys)
 {
     RegError _ret = REG_NO_ERROR;
@@ -138,9 +138,9 @@ RegError ORegKey::openSubKeys(const OUString& keyName, RegKeyHandle** phOpenSubK
 }
 
 
-//*********************************************************************
+
 //  getKeyNames
-//
+
 RegError ORegKey::getKeyNames(const OUString& keyName,
                               rtl_uString*** pSubKeyNames,
                               sal_uInt32* pnSubKeys)
@@ -198,27 +198,27 @@ RegError ORegKey::getKeyNames(const OUString& keyName,
 }
 
 
-//*********************************************************************
+
 //  closeKey
-//
+
 RegError ORegKey::closeKey(RegKeyHandle hKey)
 {
     return (m_pRegistry->closeKey(hKey));
 }
 
 
-//*********************************************************************
+
 //  deleteKey
-//
+
 RegError ORegKey::deleteKey(const OUString& keyName)
 {
     return (m_pRegistry->deleteKey(this, keyName));
 }
 
 
-//*********************************************************************
+
 //  getValueType
-//
+
 RegError ORegKey::getValueInfo(const OUString& valueName, RegValueType* pValueType, sal_uInt32* pValueSize) const
 {
     OStoreStream    rValue;
@@ -283,9 +283,9 @@ RegError ORegKey::getValueInfo(const OUString& valueName, RegValueType* pValueTy
 }
 
 
-//*********************************************************************
+
 //  setValue
-//
+
 RegError ORegKey::setValue(const OUString& valueName, RegValueType vType, RegValue value, sal_uInt32 vSize)
 {
     OStoreStream    rValue;
@@ -358,9 +358,9 @@ RegError ORegKey::setValue(const OUString& valueName, RegValueType vType, RegVal
     return REG_NO_ERROR;
 }
 
-//*********************************************************************
+
 //  setLongListValue
-//
+
 RegError ORegKey::setLongListValue(const OUString& valueName, sal_Int32* pValueList, sal_uInt32 len)
 {
     OStoreStream    rValue;
@@ -417,9 +417,9 @@ RegError ORegKey::setLongListValue(const OUString& valueName, sal_Int32* pValueL
     return REG_NO_ERROR;
 }
 
-//*********************************************************************
+
 //  setStringListValue
-//
+
 RegError ORegKey::setStringListValue(const OUString& valueName, sal_Char** pValueList, sal_uInt32 len)
 {
     OStoreStream    rValue;
@@ -485,9 +485,9 @@ RegError ORegKey::setStringListValue(const OUString& valueName, sal_Char** pValu
     return REG_NO_ERROR;
 }
 
-//*********************************************************************
+
 //  setUnicodeListValue
-//
+
 RegError ORegKey::setUnicodeListValue(const OUString& valueName, sal_Unicode** pValueList, sal_uInt32 len)
 {
     OStoreStream    rValue;
@@ -553,9 +553,9 @@ RegError ORegKey::setUnicodeListValue(const OUString& valueName, sal_Unicode** p
     return REG_NO_ERROR;
 }
 
-//*********************************************************************
+
 //  getValue
-//
+
 RegError ORegKey::getValue(const OUString& valueName, RegValue value) const
 {
     OStoreStream    rValue;
@@ -646,9 +646,9 @@ RegError ORegKey::getValue(const OUString& valueName, RegValue value) const
     return REG_NO_ERROR;
 }
 
-//*********************************************************************
+
 //  getLongListValue
-//
+
 RegError ORegKey::getLongListValue(const OUString& valueName, sal_Int32** pValueList, sal_uInt32* pLen) const
 {
     OStoreStream    rValue;
@@ -743,9 +743,9 @@ RegError ORegKey::getLongListValue(const OUString& valueName, sal_Int32** pValue
     return REG_NO_ERROR;
 }
 
-//*********************************************************************
+
 //  getStringListValue
-//
+
 RegError ORegKey::getStringListValue(const OUString& valueName, sal_Char*** pValueList, sal_uInt32* pLen) const
 {
     OStoreStream    rValue;
@@ -849,9 +849,9 @@ RegError ORegKey::getStringListValue(const OUString& valueName, sal_Char*** pVal
     return REG_NO_ERROR;
 }
 
-//*********************************************************************
+
 //  getUnicodeListValue
-//
+
 RegError ORegKey::getUnicodeListValue(const OUString& valueName, sal_Unicode*** pValueList, sal_uInt32* pLen) const
 {
     OStoreStream    rValue;
@@ -955,9 +955,9 @@ RegError ORegKey::getUnicodeListValue(const OUString& valueName, sal_Unicode***
     return REG_NO_ERROR;
 }
 
-//*********************************************************************
+
 //  getKeyType()
-//
+
 RegError ORegKey::getKeyType(const OUString& name, RegKeyType* pKeyType) const
 {
     *pKeyType = RG_KEYTYPE;
@@ -988,9 +988,9 @@ RegError ORegKey::getResolvedKeyName(const OUString& keyName,
     return REG_NO_ERROR;
 }
 
-//*********************************************************************
+
 //  countSubKeys()
-//
+
 sal_uInt32 ORegKey::countSubKeys()
 {
     REG_GUARD(m_pRegistry->m_mutex);
diff --git a/registry/source/regimpl.cxx b/registry/source/regimpl.cxx
index 9c23c266c622..9f07d16b2ded 100644
--- a/registry/source/regimpl.cxx
+++ b/registry/source/regimpl.cxx
@@ -420,9 +420,9 @@ void dumpType(typereg::Reader const & reader, OString const & indent) {
 
 }
 
-//*********************************************************************
+
 //  ORegistry()
-//
+
 ORegistry::ORegistry()
     : m_refCount(1)
     , m_readOnly(false)
@@ -431,9 +431,9 @@ ORegistry::ORegistry()
 {
 }
 
-//*********************************************************************
+
 //  ~ORegistry()
-//
+
 ORegistry::~ORegistry()
 {
     ORegKey* pRootKey = m_openKeyTable[ROOT];
@@ -445,9 +445,9 @@ ORegistry::~ORegistry()
 }
 
 
-//*********************************************************************
+
 //  initRegistry
-//
+
 RegError ORegistry::initRegistry(const OUString& regName, RegAccessMode accessMode)
 {
     RegError eRet = REG_INVALID_REGISTRY;
@@ -512,9 +512,9 @@ RegError ORegistry::initRegistry(const OUString& regName, RegAccessMode accessMo
 }
 
 
-//*********************************************************************
+
 //  closeRegistry
-//
+
 RegError ORegistry::closeRegistry()
 {
     REG_GUARD(m_mutex);
@@ -532,9 +532,9 @@ RegError ORegistry::closeRegistry()
 }
 
 
-//*********************************************************************
+
 //  destroyRegistry
-//
+
 RegError ORegistry::destroyRegistry(const OUString& regName)
 {
     REG_GUARD(m_mutex);
@@ -594,9 +594,9 @@ RegError ORegistry::destroyRegistry(const OUString& regName)
     return REG_NO_ERROR;
 }
 
-//*********************************************************************
+
 //  acquireKey
-//
+
 RegError ORegistry::acquireKey (RegKeyHandle hKey)
 {
     ORegKey* pKey = static_cast< ORegKey* >(hKey);
@@ -609,9 +609,9 @@ RegError ORegistry::acquireKey (RegKeyHandle hKey)
     return REG_NO_ERROR;
 }
 
-//*********************************************************************
+
 //  releaseKey
-//
+
 RegError ORegistry::releaseKey (RegKeyHandle hKey)
 {
     ORegKey* pKey = static_cast< ORegKey* >(hKey);
@@ -627,9 +627,9 @@ RegError ORegistry::releaseKey (RegKeyHandle hKey)
     return REG_NO_ERROR;
 }
 
-//*********************************************************************
+
 //  createKey
-//
+
 RegError ORegistry::createKey(RegKeyHandle hKey, const OUString& keyName,
                               RegKeyHandle* phNewKey)
 {
@@ -688,9 +688,9 @@ RegError ORegistry::createKey(RegKeyHandle hKey, const OUString& keyName,
 }
 
 
-//*********************************************************************
+
 //  openKey
-//
+
 RegError ORegistry::openKey(RegKeyHandle hKey, const OUString& keyName,
                             RegKeyHandle* phOpenKey)
 {
@@ -739,9 +739,9 @@ RegError ORegistry::openKey(RegKeyHandle hKey, const OUString& keyName,
 }
 
 
-//*********************************************************************
+
 //  closeKey
-//
+
 RegError ORegistry::closeKey(RegKeyHandle hKey)
 {
     ORegKey* pKey = static_cast< ORegKey* >(hKey);
@@ -773,9 +773,9 @@ RegError ORegistry::closeKey(RegKeyHandle hKey)
     return releaseKey(pKey);
 }
 
-//*********************************************************************
+
 //  deleteKey
-//
+
 RegError ORegistry::deleteKey(RegKeyHandle hKey, const OUString& keyName)
 {
     ORegKey* pKey = static_cast< ORegKey* >(hKey);
@@ -855,9 +855,9 @@ RegError ORegistry::eraseKey(ORegKey* pKey, const OUString& keyName)
     return pKey->closeKey(pOldKey);
 }
 
-//*********************************************************************
+
 //  deleteSubKeysAndValues
-//
+
 RegError ORegistry::deleteSubkeysAndValues(ORegKey* pKey)
 {
     OStoreDirectory::iterator   iter;
@@ -896,9 +896,9 @@ RegError ORegistry::deleteSubkeysAndValues(ORegKey* pKey)
 }
 
 
-//*********************************************************************
+
 //  loadKey
-//
+
 RegError ORegistry::loadKey(RegKeyHandle hKey, const OUString& regFileName,
                             bool bWarnings, bool bReport)
 {
@@ -944,9 +944,9 @@ RegError ORegistry::loadKey(RegKeyHandle hKey, const OUString& regFileName,
 }
 
 
-//*********************************************************************
+
 //  saveKey
-//
+
 RegError ORegistry::saveKey(RegKeyHandle hKey, const OUString& regFileName,
                             bool bWarnings, bool bReport)
 {
@@ -995,9 +995,9 @@ SAL_WNODEPRECATED_DECLARATIONS_POP
 }
 
 
-//*********************************************************************
+
 //  loadAndSaveValue()
-//
+
 RegError ORegistry::loadAndSaveValue(ORegKey* pTargetKey,
                                      ORegKey* pSourceKey,
                                      const OUString& valueName,
@@ -1123,9 +1123,9 @@ RegError ORegistry::loadAndSaveValue(ORegKey* pTargetKey,
 }
 
 
-//*********************************************************************
+
 //  checkblop()
-//
+
 RegError ORegistry::checkBlop(OStoreStream& rValue,
                               const OUString& sTargetPath,
                               sal_uInt32 srcValueSize,
@@ -1253,9 +1253,9 @@ static sal_uInt32 checkTypeReaders(RegistryTypeReader& reader1,
     return count;
 }
 
-//*********************************************************************
+
 //  mergeModuleValue()
-//
+
 RegError ORegistry::mergeModuleValue(OStoreStream& rTargetValue,
                                      RegistryTypeReader& reader,
                                      RegistryTypeReader& reader2)
@@ -1328,9 +1328,9 @@ RegError ORegistry::mergeModuleValue(OStoreStream& rTargetValue,
     return REG_NO_ERROR;
 }
 
-//*********************************************************************
+
 //  loadAndSaveKeys()
-//
+
 RegError ORegistry::loadAndSaveKeys(ORegKey* pTargetKey,
                                     ORegKey* pSourceKey,
                                     const OUString& keyName,
@@ -1398,9 +1398,9 @@ RegError ORegistry::loadAndSaveKeys(ORegKey* pTargetKey,
 }
 
 
-//*********************************************************************
+
 //  getRootKey()
-//
+
 ORegKey* ORegistry::getRootKey()
 {
     m_openKeyTable[ROOT]->acquire();
@@ -1408,9 +1408,9 @@ ORegKey* ORegistry::getRootKey()
 }
 
 
-//*********************************************************************
+
 //  dumpRegistry()
-//
+
 RegError ORegistry::dumpRegistry(RegKeyHandle hKey) const
 {
     ORegKey                     *pKey = (ORegKey*)hKey;
@@ -1447,9 +1447,9 @@ RegError ORegistry::dumpRegistry(RegKeyHandle hKey) const
     return REG_NO_ERROR;
 }
 
-//*********************************************************************
+
 //  dumpValue()
-//
+
 RegError ORegistry::dumpValue(const OUString& sPath, const OUString& sName, sal_Int16 nSpc) const
 {
     OStoreStream    rValue;
@@ -1688,9 +1688,9 @@ RegError ORegistry::dumpValue(const OUString& sPath, const OUString& sName, sal_
     return REG_NO_ERROR;
 }
 
-//*********************************************************************
+
 //  dumpKey()
-//
+
 RegError ORegistry::dumpKey(const OUString& sPath, const OUString& sName, sal_Int16 nSpace) const
 {
     OStoreDirectory     rStoreDir;
diff --git a/registry/source/registry.cxx b/registry/source/registry.cxx
index 345631ad1773..d3ba33d3a81c 100644
--- a/registry/source/registry.cxx
+++ b/registry/source/registry.cxx
@@ -39,9 +39,9 @@
 
 extern "C" {
 
-//*********************************************************************
+
 //  acquire
-//
+
 static void REGISTRY_CALLTYPE acquire(RegHandle hReg)
 {
     ORegistry* pReg = (ORegistry*) hReg;
@@ -51,9 +51,9 @@ static void REGISTRY_CALLTYPE acquire(RegHandle hReg)
 }
 
 
-//*********************************************************************
+
 //  release
-//
+
 static void REGISTRY_CALLTYPE release(RegHandle hReg)
 {
     ORegistry* pReg = (ORegistry*) hReg;
@@ -69,9 +69,9 @@ static void REGISTRY_CALLTYPE release(RegHandle hReg)
 }
 
 
-//*********************************************************************
+
 //  getName
-//
+
 static RegError REGISTRY_CALLTYPE getName(RegHandle hReg, rtl_uString** pName)
 {
     ORegistry*  pReg;
@@ -95,9 +95,9 @@ static RegError REGISTRY_CALLTYPE getName(RegHandle hReg, rtl_uString** pName)
 }
 
 
-//*********************************************************************
+
 //  isReadOnly
-//
+
 static sal_Bool REGISTRY_CALLTYPE isReadOnly(RegHandle hReg)
 {
     if (hReg)
@@ -107,9 +107,9 @@ static sal_Bool REGISTRY_CALLTYPE isReadOnly(RegHandle hReg)
 }
 
 
-//*********************************************************************
+
 //  createRegistry
-//
+
 static RegError REGISTRY_CALLTYPE createRegistry(rtl_uString* registryName,
                                                  RegHandle* phRegistry)
 {
@@ -127,9 +127,9 @@ static RegError REGISTRY_CALLTYPE createRegistry(rtl_uString* registryName,
     return REG_NO_ERROR;
 }
 
-//*********************************************************************
+
 //  openRootKey
-//
+
 static RegError REGISTRY_CALLTYPE openRootKey(RegHandle hReg,
                                               RegKeyHandle* phRootKey)
 {
@@ -152,9 +152,9 @@ static RegError REGISTRY_CALLTYPE openRootKey(RegHandle hReg,
 }
 
 
-//*********************************************************************
+
 //  openRegistry
-//
+
 static RegError REGISTRY_CALLTYPE openRegistry(rtl_uString* registryName,
                                                RegHandle* phRegistry,
                                                RegAccessMode accessMode)
@@ -175,9 +175,9 @@ static RegError REGISTRY_CALLTYPE openRegistry(rtl_uString* registryName,
     return REG_NO_ERROR;
 }
 
-//*********************************************************************
+
 //  closeRegistry
-//
+
 static RegError REGISTRY_CALLTYPE closeRegistry(RegHandle hReg)
 {
     ORegistry   *pReg;
@@ -205,9 +205,9 @@ static RegError REGISTRY_CALLTYPE closeRegistry(RegHandle hReg)
 }
 
 
-//*********************************************************************
+
 //  destroyRegistry
-//
+
 static RegError REGISTRY_CALLTYPE destroyRegistry(RegHandle hReg,
                                                   rtl_uString* registryName)
 {
@@ -236,9 +236,9 @@ static RegError REGISTRY_CALLTYPE destroyRegistry(RegHandle hReg,
 }
 
 
-//*********************************************************************
+
 //  loadRegKey
-//
+
 static RegError REGISTRY_CALLTYPE loadKey(RegHandle hReg,
                                               RegKeyHandle hKey,
                                            rtl_uString* keyName,
@@ -287,9 +287,9 @@ static RegError REGISTRY_CALLTYPE loadKey(RegHandle hReg,
     return pKey->closeKey(pNewKey);
 }
 
-//*********************************************************************
+
 //  saveKey
-//
+
 static RegError REGISTRY_CALLTYPE saveKey(RegHandle hReg,
                                               RegKeyHandle hKey,
                                            rtl_uString* keyName,
@@ -327,9 +327,9 @@ static RegError REGISTRY_CALLTYPE saveKey(RegHandle hReg,
     return pKey->releaseKey(pNewKey);
 }
 
-//*********************************************************************
+
 //  mergeKey
-//
+
 static RegError REGISTRY_CALLTYPE mergeKey(RegHandle hReg,
                                               RegKeyHandle hKey,
                                            rtl_uString* keyName,
@@ -376,9 +376,9 @@ static RegError REGISTRY_CALLTYPE mergeKey(RegHandle hReg,
     return pReg->loadKey(pKey, regFileName, bWarnings, bReport);
 }
 
-//*********************************************************************
+
 //  dumpRegistry
-//
+
 static RegError REGISTRY_CALLTYPE dumpRegistry(RegHandle hReg,
                                                RegKeyHandle hKey)
 {
@@ -399,9 +399,9 @@ static RegError REGISTRY_CALLTYPE dumpRegistry(RegHandle hReg,
     return pReg->dumpRegistry(hKey);
 }
 
-//*********************************************************************
+
 //  initRegistry_Api
-//
+
 REG_DLLPUBLIC Registry_Api* REGISTRY_CALLTYPE initRegistry_Api(void)
 {
     static Registry_Api aApi= {&acquire,
@@ -450,9 +450,9 @@ REG_DLLPUBLIC Registry_Api* REGISTRY_CALLTYPE initRegistry_Api(void)
 
 }
 
-//*********************************************************************
+
 //  reg_loadRegKey
-//
+
 REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_loadKey(RegKeyHandle hKey,
                                        rtl_uString* keyName,
                                        rtl_uString* regFileName)
@@ -467,9 +467,9 @@ REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_loadKey(RegKeyHandle hKey,
     return loadKey(pKey->getRegistry(), hKey, keyName, regFileName);
 }
 
-//*********************************************************************
+
 //  reg_saveKey
-//
+
 REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_saveKey(RegKeyHandle hKey,
                                        rtl_uString* keyName,
                                        rtl_uString* regFileName)
@@ -484,9 +484,9 @@ REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_saveKey(RegKeyHandle hKey,
     return saveKey(pKey->getRegistry(), hKey, keyName, regFileName);
 }
 
-//*********************************************************************
+
 //  reg_mergeKey
-//
+
 REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_mergeKey(RegKeyHandle hKey,
                                         rtl_uString* keyName,
                                         rtl_uString* regFileName,
@@ -503,9 +503,9 @@ REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_mergeKey(RegKeyHandle hKey,
     return mergeKey(pKey->getRegistry(), hKey, keyName, regFileName, bWarnings, bReport);
 }
 
-//*********************************************************************
+
 //  reg_createRegistry
-//
+
 REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_createRegistry(rtl_uString* registryName,
                                               RegHandle* phRegistry)
 {
@@ -523,9 +523,9 @@ REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_createRegistry(rtl_uString* registr
     return REG_NO_ERROR;
 }
 
-//*********************************************************************
+
 //  reg_openRootKey
-//
+
 REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_openRootKey(RegHandle hRegistry,
                                           RegKeyHandle* phRootKey)
 {
@@ -533,27 +533,27 @@ REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_openRootKey(RegHandle hRegistry,
 }
 
 
-//*********************************************************************
+
 //  reg_getName
-//
+
 REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_getName(RegHandle hRegistry, rtl_uString** pName)
 {
     return getName(hRegistry, pName);
 }
 
 
-//*********************************************************************
+
 //  reg_isReadOnly
-//
+
 REG_DLLPUBLIC sal_Bool REGISTRY_CALLTYPE reg_isReadOnly(RegHandle hRegistry)
 {
     return isReadOnly(hRegistry);
 }
 
 
-//*********************************************************************
+
 //  reg_openRegistry
-//
+
 REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_openRegistry(rtl_uString* registryName,
                                             RegHandle* phRegistry,
                                             RegAccessMode accessMode)
@@ -572,9 +572,9 @@ REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_openRegistry(rtl_uString* registryN
     return REG_NO_ERROR;
 }
 
-//*********************************************************************
+
 //  reg_closeRegistry
-//
+
 REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_closeRegistry(RegHandle hRegistry)
 {
     ORegistry* pReg;
@@ -591,9 +591,9 @@ REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_closeRegistry(RegHandle hRegistry)
 }
 
 
-//*********************************************************************
+
 //  reg_destroyRegistry
-//
+
 REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_destroyRegistry(RegHandle hRegistry,
                                                rtl_uString* registryName)
 {
@@ -601,9 +601,9 @@ REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_destroyRegistry(RegHandle hRegistry
 }
 
 
-//*********************************************************************
+
 //  reg_dumpRegistry
-//
+
 REG_DLLPUBLIC RegError REGISTRY_CALLTYPE reg_dumpRegistry(RegKeyHandle hKey)
 {
     ORegKey *pKey;
diff --git a/registry/source/regkey.cxx b/registry/source/regkey.cxx
index 2e0d93c77303..f2c73756f35f 100644
--- a/registry/source/regkey.cxx
+++ b/registry/source/regkey.cxx
@@ -26,9 +26,9 @@
 #include "keyimpl.hxx"
 
 
-//*********************************************************************
+
 //  acquireKey
-//
+
 void REGISTRY_CALLTYPE acquireKey(RegKeyHandle hKey)
 {
     ORegKey* pKey = static_cast< ORegKey* >(hKey);
@@ -40,9 +40,9 @@ void REGISTRY_CALLTYPE acquireKey(RegKeyHandle hKey)
 }
 
 
-//*********************************************************************
+
 //  releaseKey
-//
+
 void REGISTRY_CALLTYPE releaseKey(RegKeyHandle hKey)
 {
     ORegKey* pKey = static_cast< ORegKey* >(hKey);
@@ -54,9 +54,9 @@ void REGISTRY_CALLTYPE releaseKey(RegKeyHandle hKey)
 }
 
 
-//*********************************************************************
+
 //  isKeyReadOnly
-//
+
 sal_Bool REGISTRY_CALLTYPE isKeyReadOnly(RegKeyHandle hKey)
 {
     ORegKey* pKey = static_cast< ORegKey* >(hKey);
@@ -64,9 +64,9 @@ sal_Bool REGISTRY_CALLTYPE isKeyReadOnly(RegKeyHandle hKey)
 }
 
 
-//*********************************************************************
+
 //  getKeyName
-//
+
 RegError REGISTRY_CALLTYPE getKeyName(RegKeyHandle hKey, rtl_uString** pKeyName)
 {
     ORegKey* pKey = static_cast< ORegKey* >(hKey);
@@ -82,9 +82,9 @@ RegError REGISTRY_CALLTYPE getKeyName(RegKeyHandle hKey, rtl_uString** pKeyName)
 }
 
 
-//*********************************************************************
+
 //  createKey
-//
+
 RegError REGISTRY_CALLTYPE createKey(RegKeyHandle hKey,
                                      rtl_uString* keyName,
                                      RegKeyHandle* phNewKey)
@@ -104,9 +104,9 @@ RegError REGISTRY_CALLTYPE createKey(RegKeyHandle hKey,
     return pKey->createKey(keyName, phNewKey);
 }
 
-//*********************************************************************
+
 //  openKey
-//
+
 RegError REGISTRY_CALLTYPE openKey(RegKeyHandle hKey,
                                    rtl_uString* keyName,
                                    RegKeyHandle* phOpenKey)
@@ -123,9 +123,9 @@ RegError REGISTRY_CALLTYPE openKey(RegKeyHandle hKey,
     return pKey->openKey(keyName, phOpenKey);
 }
 
-//*********************************************************************
+
 //  openSubKeys
-//
+
 RegError REGISTRY_CALLTYPE openSubKeys(RegKeyHandle hKey,
                                        rtl_uString* keyName,
                                        RegKeyHandle** pphSubKeys,
@@ -144,9 +144,9 @@ RegError REGISTRY_CALLTYPE openSubKeys(RegKeyHandle hKey,
     return pKey->openSubKeys(keyName, pphSubKeys, pnSubKeys);
 }
 
-//*********************************************************************
+
 //  closeSubKeys
-//
+
 RegError REGISTRY_CALLTYPE closeSubKeys(RegKeyHandle* phSubKeys,
                                         sal_uInt32 nSubKeys)
 {
@@ -163,9 +163,9 @@ RegError REGISTRY_CALLTYPE closeSubKeys(RegKeyHandle* phSubKeys,
     return REG_NO_ERROR;
 }
 
-//*********************************************************************
+
 //  deleteKey
-//
+
 RegError REGISTRY_CALLTYPE deleteKey(RegKeyHandle hKey,
                                      rtl_uString* keyName)
 {
@@ -182,9 +182,9 @@ RegError REGISTRY_CALLTYPE deleteKey(RegKeyHandle hKey,
     return pKey->deleteKey(keyName);
 }
 
-//*********************************************************************
+
 //  closeKey
-//
+
 RegError REGISTRY_CALLTYPE closeKey(RegKeyHandle hKey)
 {
     ORegKey* pKey = static_cast< ORegKey* >(hKey);
@@ -194,9 +194,9 @@ RegError REGISTRY_CALLTYPE closeKey(RegKeyHandle hKey)
     return pKey->closeKey(hKey);
 }
 
-//*********************************************************************
+
 //  setValue
-//
+
 RegError REGISTRY_CALLTYPE setValue(RegKeyHandle hKey,
                                        rtl_uString* keyName,
                                        RegValueType valueType,
@@ -237,9 +237,9 @@ RegError REGISTRY_CALLTYPE setValue(RegKeyHandle hKey,
     return pKey->setValue(valueName, valueType, pData, valueSize);
 }
 
-//*********************************************************************
+
 //  setLongValueList
-//
+
 RegError REGISTRY_CALLTYPE setLongListValue(RegKeyHandle hKey,
                                                   rtl_uString* keyName,
                                                   sal_Int32* pValueList,
@@ -279,9 +279,9 @@ RegError REGISTRY_CALLTYPE setLongListValue(RegKeyHandle hKey,
     return pKey->setLongListValue(valueName, pValueList, len);
 }
 
-//*********************************************************************
+
 //  setStringValueList
-//
+
 RegError REGISTRY_CALLTYPE setStringListValue(RegKeyHandle hKey,
                                                    rtl_uString* keyName,
                                                    sal_Char** pValueList,
@@ -321,9 +321,9 @@ RegError REGISTRY_CALLTYPE setStringListValue(RegKeyHandle hKey,
     return pKey->setStringListValue(valueName, pValueList, len);
 }
 
-//*********************************************************************
+
 //  setUnicodeValueList
-//
+
 RegError REGISTRY_CALLTYPE setUnicodeListValue(RegKeyHandle hKey,
                                                      rtl_uString* keyName,
                                                      sal_Unicode** pValueList,
@@ -363,9 +363,9 @@ RegError REGISTRY_CALLTYPE setUnicodeListValue(RegKeyHandle hKey,
     return pKey->setUnicodeListValue(valueName, pValueList, len);
 }
 
-//*********************************************************************
+
 //  getValueInfo
-//
+
 RegError REGISTRY_CALLTYPE getValueInfo(RegKeyHandle hKey,
                                         rtl_uString* keyName,
                                         RegValueType* pValueType,
@@ -416,9 +416,9 @@ RegError REGISTRY_CALLTYPE getValueInfo(RegKeyHandle hKey,
     return REG_NO_ERROR;
 }
 
-//*********************************************************************
+
 //  getValueInfo
-//
+
 RegError REGISTRY_CALLTYPE getValue(RegKeyHandle hKey,
                                     rtl_uString* keyName,
                                     RegValue pValue)
@@ -451,9 +451,9 @@ RegError REGISTRY_CALLTYPE getValue(RegKeyHandle hKey,
     return pKey->getValue(valueName, pValue);
 }
 
-//*********************************************************************
+
 //  getLongValueList
-//
+
 RegError REGISTRY_CALLTYPE getLongListValue(RegKeyHandle hKey,
                                             rtl_uString* keyName,
                                             sal_Int32** pValueList,
@@ -490,9 +490,9 @@ RegError REGISTRY_CALLTYPE getLongListValue(RegKeyHandle hKey,
     return pKey->getLongListValue(valueName, pValueList, pLen);
 }
 
-//*********************************************************************
+
 //  getStringValueList
-//
+
 RegError REGISTRY_CALLTYPE getStringListValue(RegKeyHandle hKey,
                                               rtl_uString* keyName,
                                               sal_Char*** pValueList,
@@ -529,9 +529,9 @@ RegError REGISTRY_CALLTYPE getStringListValue(RegKeyHandle hKey,
     return pKey->getStringListValue(valueName, pValueList, pLen);
 }
 
-//*********************************************************************
+
 //  getUnicodeListValue
-//
+
 RegError REGISTRY_CALLTYPE getUnicodeListValue(RegKeyHandle hKey,
                                                rtl_uString* keyName,
                                                sal_Unicode*** pValueList,
@@ -568,9 +568,9 @@ RegError REGISTRY_CALLTYPE getUnicodeListValue(RegKeyHandle hKey,
     return pKey->getUnicodeListValue(valueName, pValueList, pLen);
 }
 
-//*********************************************************************
+
 //  freeValueList
-//
+
 RegError REGISTRY_CALLTYPE freeValueList(RegValueType valueType,
                                               RegValue pValueList,
                                               sal_uInt32 len)
@@ -612,9 +612,9 @@ RegError REGISTRY_CALLTYPE freeValueList(RegValueType valueType,
     return REG_NO_ERROR;
 }
 
-//*********************************************************************
+
 //  createLink
-//
+
 RegError REGISTRY_CALLTYPE createLink(
     SAL_UNUSED_PARAMETER RegKeyHandle, SAL_UNUSED_PARAMETER rtl_uString*,
     SAL_UNUSED_PARAMETER rtl_uString*)
@@ -622,18 +622,18 @@ RegError REGISTRY_CALLTYPE createLink(
     return REG_INVALID_LINK; // links are no longer supported
 }
 
-//*********************************************************************
+
 //  deleteLink
-//
+
 RegError REGISTRY_CALLTYPE deleteLink(
     SAL_UNUSED_PARAMETER RegKeyHandle, SAL_UNUSED_PARAMETER rtl_uString*)
 {
     return REG_INVALID_LINK; // links are no longer supported
 }
 
-//*********************************************************************
+
 //  getKeyType
-//
+
 RegError REGISTRY_CALLTYPE getKeyType(RegKeyHandle hKey,
                                       rtl_uString* keyName,
                                          RegKeyType* pKeyType)
@@ -648,9 +648,9 @@ RegError REGISTRY_CALLTYPE getKeyType(RegKeyHandle hKey,
     return pKey->getKeyType(keyName, pKeyType);
 }
 
-//*********************************************************************
+
 //  getLinkTarget
-//
+
 RegError REGISTRY_CALLTYPE getLinkTarget(
     SAL_UNUSED_PARAMETER RegKeyHandle, SAL_UNUSED_PARAMETER rtl_uString*,
     SAL_UNUSED_PARAMETER rtl_uString**)
@@ -658,9 +658,9 @@ RegError REGISTRY_CALLTYPE getLinkTarget(
     return REG_INVALID_LINK; // links are no longer supported
 }
 
-//*********************************************************************
+
 //  getName
-//
+
 RegError REGISTRY_CALLTYPE getResolvedKeyName(RegKeyHandle hKey,
                                               rtl_uString* keyName,
                                               SAL_UNUSED_PARAMETER sal_Bool,
@@ -680,9 +680,9 @@ RegError REGISTRY_CALLTYPE getResolvedKeyName(RegKeyHandle hKey,
     return _ret;
 }
 
-//*********************************************************************
+
 //  getKeyNames
-//
+
 RegError REGISTRY_CALLTYPE getKeyNames(RegKeyHandle hKey,
                                        rtl_uString* keyName,
                                          rtl_uString*** pSubKeyNames,
@@ -698,9 +698,9 @@ RegError REGISTRY_CALLTYPE getKeyNames(RegKeyHandle hKey,
     return pKey->getKeyNames(keyName, pSubKeyNames, pnSubKeys);
 }
 
-//*********************************************************************
+
 //  freeKeyNames
-//
+
 RegError REGISTRY_CALLTYPE freeKeyNames(rtl_uString** pKeyNames,
                                           sal_uInt32 nKeys)
 {
@@ -714,13 +714,13 @@ RegError REGISTRY_CALLTYPE freeKeyNames(rtl_uString** pKeyNames,
     return REG_NO_ERROR;
 }
 
-//*********************************************************************
+
 //  C API
-//
 
-//*********************************************************************
+
+
 //  reg_createKey
-//
+
 RegError REGISTRY_CALLTYPE reg_createKey(RegKeyHandle hKey,
                                          rtl_uString* keyName,
                                          RegKeyHandle* phNewKey)
@@ -731,9 +731,9 @@ RegError REGISTRY_CALLTYPE reg_createKey(RegKeyHandle hKey,
     return createKey(hKey, keyName, phNewKey);
 }
 
-//*********************************************************************
+
 //  reg_openKey
-//
+
 RegError REGISTRY_CALLTYPE reg_openKey(RegKeyHandle hKey,
                                        rtl_uString* keyName,
                                        RegKeyHandle* phOpenKey)
@@ -744,9 +744,9 @@ RegError REGISTRY_CALLTYPE reg_openKey(RegKeyHandle hKey,
     return openKey(hKey, keyName, phOpenKey);
 }
 
-//*********************************************************************
+
 //  reg_openSubKeys
-//
+
 RegError REGISTRY_CALLTYPE reg_openSubKeys(RegKeyHandle hKey,
                                            rtl_uString* keyName,
                                            RegKeyHandle** pphSubKeys,
@@ -758,9 +758,9 @@ RegError REGISTRY_CALLTYPE reg_openSubKeys(RegKeyHandle hKey,
     return openSubKeys(hKey, keyName, pphSubKeys, pnSubKeys);
 }
 
-//*********************************************************************
+
 //  reg_closeSubKeys
-//
+
 RegError REGISTRY_CALLTYPE reg_closeSubKeys(RegKeyHandle* pphSubKeys,
                                             sal_uInt32 nSubKeys)
 {
@@ -770,9 +770,9 @@ RegError REGISTRY_CALLTYPE reg_closeSubKeys(RegKeyHandle* pphSubKeys,
     return closeSubKeys(pphSubKeys, nSubKeys);
 }
 
-//*********************************************************************
+
 //  reg_deleteKey
-//
+
 RegError REGISTRY_CALLTYPE reg_deleteKey(RegKeyHandle hKey,
                                          rtl_uString* keyName)
 {
@@ -782,9 +782,9 @@ RegError REGISTRY_CALLTYPE reg_deleteKey(RegKeyHandle hKey,
     return deleteKey(hKey, keyName);
 }
 
-//*********************************************************************
+
 //  reg_closeKey
-//
+
 RegError REGISTRY_CALLTYPE reg_closeKey(RegKeyHandle hKey)
 {
     if (!hKey)
@@ -794,9 +794,9 @@ RegError REGISTRY_CALLTYPE reg_closeKey(RegKeyHandle hKey)
 }
 
 
-//*********************************************************************
+
 //  reg_getKeyName
-//
+
 RegError REGISTRY_CALLTYPE reg_getKeyName(RegKeyHandle hKey, rtl_uString** pKeyName)
 {
     if (hKey)
@@ -810,9 +810,9 @@ RegError REGISTRY_CALLTYPE reg_getKeyName(RegKeyHandle hKey, rtl_uString** pKeyN
     }
 }
 
-//*********************************************************************
+
 //  reg_setValue
-//
+
 RegError REGISTRY_CALLTYPE reg_setValue(RegKeyHandle hKey,
                                         rtl_uString* keyName,
                                         RegValueType valueType,
@@ -825,9 +825,9 @@ RegError REGISTRY_CALLTYPE reg_setValue(RegKeyHandle hKey,
     return setValue(hKey, keyName, valueType, pData, valueSize);
 }
 
-//*********************************************************************
+
 //  reg_setLongListValue
-//
+
 RegError REGISTRY_CALLTYPE reg_setLongListValue(RegKeyHandle hKey,
                                                       rtl_uString* keyName,
                                                       sal_Int32* pValueList,
@@ -839,9 +839,9 @@ RegError REGISTRY_CALLTYPE reg_setLongListValue(RegKeyHandle hKey,
     return setLongListValue(hKey, keyName, pValueList, len);
 }
 
-//*********************************************************************
+
 //  reg_setStringListValue
-//
+
 RegError REGISTRY_CALLTYPE reg_setStringListValue(RegKeyHandle hKey,
                                                           rtl_uString* keyName,
                                                           sal_Char** pValueList,
@@ -853,9 +853,9 @@ RegError REGISTRY_CALLTYPE reg_setStringListValue(RegKeyHandle hKey,
     return setStringListValue(hKey, keyName, pValueList, len);
 }
 
-//*********************************************************************
+
 //  reg_setUnicodeListValue
-//
+
 RegError REGISTRY_CALLTYPE reg_setUnicodeListValue(RegKeyHandle hKey,
                                                             rtl_uString* keyName,
                                                             sal_Unicode** pValueList,
@@ -867,9 +867,9 @@ RegError REGISTRY_CALLTYPE reg_setUnicodeListValue(RegKeyHandle hKey,
     return setUnicodeListValue(hKey, keyName, pValueList, len);
 }
 
-//*********************************************************************
+
 //  reg_getValueInfo
-//
+
 RegError REGISTRY_CALLTYPE reg_getValueInfo(RegKeyHandle hKey,
                                             rtl_uString* keyName,
                                             RegValueType* pValueType,
@@ -881,9 +881,9 @@ RegError REGISTRY_CALLTYPE reg_getValueInfo(RegKeyHandle hKey,
     return getValueInfo(hKey, keyName, pValueType, pValueSize);
 }
 
-//*********************************************************************
+
 //  reg_getValueInfo
-//
+
 RegError REGISTRY_CALLTYPE reg_getValue(RegKeyHandle hKey,
                                         rtl_uString* keyName,
                                         RegValue pData)
@@ -894,9 +894,9 @@ RegError REGISTRY_CALLTYPE reg_getValue(RegKeyHandle hKey,
     return getValue(hKey, keyName, pData);
 }
 
-//*********************************************************************
+
 //  reg_getLongListValue
-//
+
 RegError REGISTRY_CALLTYPE reg_getLongListValue(RegKeyHandle hKey,
                                                       rtl_uString* keyName,
                                                       sal_Int32** pValueList,
@@ -908,9 +908,9 @@ RegError REGISTRY_CALLTYPE reg_getLongListValue(RegKeyHandle hKey,
     return getLongListValue(hKey, keyName, pValueList, pLen);
 }
 
-//*********************************************************************
+
 //  reg_getStringListValue
-//
+
 RegError REGISTRY_CALLTYPE reg_getStringListValue(RegKeyHandle hKey,
                                                        rtl_uString* keyName,
                                                        sal_Char*** pValueList,
@@ -922,9 +922,9 @@ RegError REGISTRY_CALLTYPE reg_getStringListValue(RegKeyHandle hKey,
     return getStringListValue(hKey, keyName, pValueList, pLen);
 }
 
-//*********************************************************************
+
 //  reg_getUnicodeListValue
-//
+
 RegError REGISTRY_CALLTYPE reg_getUnicodeListValue(RegKeyHandle hKey,
                                                          rtl_uString* keyName,
                                                          sal_Unicode*** pValueList,
@@ -936,9 +936,9 @@ RegError REGISTRY_CALLTYPE reg_getUnicodeListValue(RegKeyHandle hKey,
     return getUnicodeListValue(hKey, keyName, pValueList, pLen);
 }
 
-//*********************************************************************
+
 //  reg_freeValueList
-//
+
 RegError REGISTRY_CALLTYPE reg_freeValueList(RegValueType valueType,
                                                   RegValue pValueList,
                                                   sal_uInt32 len)
@@ -949,9 +949,9 @@ RegError REGISTRY_CALLTYPE reg_freeValueList(RegValueType valueType,
         return REG_INVALID_VALUE;
 }
 
-//*********************************************************************
+
 //  reg_getKeyType
-//
+
 RegError REGISTRY_CALLTYPE reg_getKeyType(RegKeyHandle hKey,
                                           rtl_uString* keyName,
                                              RegKeyType* pKeyType)
@@ -962,9 +962,9 @@ RegError REGISTRY_CALLTYPE reg_getKeyType(RegKeyHandle hKey,
     return getKeyType(hKey, keyName, pKeyType);
 }
 
-//*********************************************************************
+
 //  reg_getResolvedKeyName
-//
+
 RegError REGISTRY_CALLTYPE reg_getResolvedKeyName(RegKeyHandle hKey,
                                                     rtl_uString* keyName,
                                                     sal_Bool firstLinkOnly,
diff --git a/registry/test/testmerge.cxx b/registry/test/testmerge.cxx
index 0982d28d1606..44ae7944ccb7 100644
--- a/registry/test/testmerge.cxx
+++ b/registry/test/testmerge.cxx
@@ -186,7 +186,7 @@ void test_merge()
     REG_ENSURE(!myRegistry->mergeKey(rootKey, OUString("/stardiv/IchbineinMergeKey"),
                 OUString("merge2.rdb")), "testMerge error 4");
 
-    ///////////////////////////////////////////////////////////////////////////
+
 
     REG_ENSURE(!rootKey.openKey("/stardiv/IchbineinMergeKey", key1), "testMerge error 5");
 
@@ -215,7 +215,7 @@ void test_merge()
 
     REG_ENSURE(!key1.closeKey(), "testMerge error 24");
 
-    ///////////////////////////////////////////////////////////////////////////
+
 
     REG_ENSURE(!rootKey.openKey("/stardiv/IchbineinMergeKey", key2), "testMerge error 25");
 
@@ -244,7 +244,7 @@ void test_merge()
 
     REG_ENSURE(!key2.closeKey(), "testMerge error 44");
 
-    ///////////////////////////////////////////////////////////////////////////
+
 
     REG_ENSURE(!rootKey.openKey("/stardiv/IchbineinMergeKey", key1u2), "testMerge error 40");
 
@@ -288,7 +288,7 @@ void test_merge()
 
     REG_ENSURE(!key1u2.closeKey(), "testMerge error 71");
 
-    ///////////////////////////////////////////////////////////////////////////
+
 
     RegValueType    valueType;
     sal_uInt32          valueSize;
@@ -395,7 +395,7 @@ void test_merge()
 
     REG_ENSURE(!key1.closeKey(), "testMerge error 24");
 
-    ///////////////////////////////////////////////////////////////////////////
+
 
     REG_ENSURE(!rootKey.closeKey(), "testMerge error 10");
 
diff --git a/registry/test/testregcpp.cxx b/registry/test/testregcpp.cxx
index 95adc988bc63..0d9aa977f855 100644
--- a/registry/test/testregcpp.cxx
+++ b/registry/test/testregcpp.cxx
@@ -397,7 +397,7 @@ void test_registry_CppApi()
     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");