LCOV - code coverage report
Current view: top level - usr/local/src/libreoffice/registry/source - regkey.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 109 390 27.9 %
Date: 2013-07-09 Functions: 17 46 37.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : 
      21             : #include "regkey.hxx"
      22             : 
      23             : #include <registry/registry.hxx>
      24             : #include <rtl/alloc.h>
      25             : #include "regimpl.hxx"
      26             : #include "keyimpl.hxx"
      27             : 
      28             : 
      29             : //*********************************************************************
      30             : //  acquireKey
      31             : //
      32        6190 : void REGISTRY_CALLTYPE acquireKey(RegKeyHandle hKey)
      33             : {
      34        6190 :     ORegKey* pKey = static_cast< ORegKey* >(hKey);
      35        6190 :     if (pKey != 0)
      36             :     {
      37        6190 :         ORegistry* pReg = pKey->getRegistry();
      38        6190 :         (void) pReg->acquireKey(pKey);
      39             :     }
      40        6190 : }
      41             : 
      42             : 
      43             : //*********************************************************************
      44             : //  releaseKey
      45             : //
      46       53274 : void REGISTRY_CALLTYPE releaseKey(RegKeyHandle hKey)
      47             : {
      48       53274 :     ORegKey* pKey = static_cast< ORegKey* >(hKey);
      49       53274 :     if (pKey != 0)
      50             :     {
      51       53274 :         ORegistry* pReg = pKey->getRegistry();
      52       53274 :         (void) pReg->releaseKey(pKey);
      53             :     }
      54       53274 : }
      55             : 
      56             : 
      57             : //*********************************************************************
      58             : //  isKeyReadOnly
      59             : //
      60           1 : sal_Bool REGISTRY_CALLTYPE isKeyReadOnly(RegKeyHandle hKey)
      61             : {
      62           1 :     ORegKey* pKey = static_cast< ORegKey* >(hKey);
      63           1 :     return (pKey != 0) ? pKey->isReadOnly() : sal_False;
      64             : }
      65             : 
      66             : 
      67             : //*********************************************************************
      68             : //  getKeyName
      69             : //
      70         304 : RegError REGISTRY_CALLTYPE getKeyName(RegKeyHandle hKey, rtl_uString** pKeyName)
      71             : {
      72         304 :     ORegKey* pKey = static_cast< ORegKey* >(hKey);
      73         304 :     if (pKey)
      74             :     {
      75         304 :         rtl_uString_assign( pKeyName, pKey->getName().pData );
      76         304 :         return REG_NO_ERROR;
      77             :     } else
      78             :     {
      79           0 :         rtl_uString_new(pKeyName);
      80           0 :         return REG_INVALID_KEY;
      81             :     }
      82             : }
      83             : 
      84             : 
      85             : //*********************************************************************
      86             : //  createKey
      87             : //
      88       27114 : RegError REGISTRY_CALLTYPE createKey(RegKeyHandle hKey,
      89             :                                      rtl_uString* keyName,
      90             :                                      RegKeyHandle* phNewKey)
      91             : {
      92       27114 :     *phNewKey = 0;
      93             : 
      94       27114 :     ORegKey* pKey = static_cast< ORegKey* >(hKey);
      95       27114 :     if (!pKey)
      96           0 :         return REG_INVALID_KEY;
      97             : 
      98       27114 :     if (pKey->isDeleted())
      99           0 :         return REG_INVALID_KEY;
     100             : 
     101       27114 :     if (pKey->isReadOnly())
     102           0 :         return REG_REGISTRY_READONLY;
     103             : 
     104       27114 :     return pKey->createKey(keyName, phNewKey);
     105             : }
     106             : 
     107             : //*********************************************************************
     108             : //  openKey
     109             : //
     110       14538 : RegError REGISTRY_CALLTYPE openKey(RegKeyHandle hKey,
     111             :                                    rtl_uString* keyName,
     112             :                                    RegKeyHandle* phOpenKey)
     113             : {
     114       14538 :     *phOpenKey = 0;
     115             : 
     116       14538 :     ORegKey* pKey = static_cast< ORegKey* >(hKey);
     117       14538 :     if (!pKey)
     118           0 :         return REG_INVALID_KEY;
     119             : 
     120       14538 :     if (pKey->isDeleted())
     121           0 :         return REG_INVALID_KEY;
     122             : 
     123       14538 :     return pKey->openKey(keyName, phOpenKey);
     124             : }
     125             : 
     126             : //*********************************************************************
     127             : //  openSubKeys
     128             : //
     129           7 : RegError REGISTRY_CALLTYPE openSubKeys(RegKeyHandle hKey,
     130             :                                        rtl_uString* keyName,
     131             :                                        RegKeyHandle** pphSubKeys,
     132             :                                        sal_uInt32* pnSubKeys)
     133             : {
     134           7 :     *pphSubKeys = NULL;
     135           7 :     *pnSubKeys = 0;
     136             : 
     137           7 :     ORegKey* pKey = static_cast< ORegKey* >(hKey);
     138           7 :     if (!pKey)
     139           0 :         return REG_INVALID_KEY;
     140             : 
     141           7 :     if (pKey->isDeleted())
     142           0 :         return REG_INVALID_KEY;
     143             : 
     144           7 :     return pKey->openSubKeys(keyName, pphSubKeys, pnSubKeys);
     145             : }
     146             : 
     147             : //*********************************************************************
     148             : //  closeSubKeys
     149             : //
     150           7 : RegError REGISTRY_CALLTYPE closeSubKeys(RegKeyHandle* phSubKeys,
     151             :                                         sal_uInt32 nSubKeys)
     152             : {
     153           7 :     if (phSubKeys == 0 || nSubKeys == 0)
     154           1 :         return REG_INVALID_KEY;
     155             : 
     156           6 :     ORegistry* pReg = ((ORegKey*)(phSubKeys[0]))->getRegistry();
     157          14 :     for (sal_uInt32 i = 0; i < nSubKeys; i++)
     158             :     {
     159           8 :         (void) pReg->closeKey(phSubKeys[i]);
     160             :     }
     161           6 :     rtl_freeMemory(phSubKeys);
     162             : 
     163           6 :     return REG_NO_ERROR;
     164             : }
     165             : 
     166             : //*********************************************************************
     167             : //  deleteKey
     168             : //
     169           2 : RegError REGISTRY_CALLTYPE deleteKey(RegKeyHandle hKey,
     170             :                                      rtl_uString* keyName)
     171             : {
     172           2 :     ORegKey* pKey = static_cast< ORegKey* >(hKey);
     173           2 :     if (!pKey)
     174           0 :         return REG_INVALID_KEY;
     175             : 
     176           2 :     if (pKey->isDeleted())
     177           0 :         return REG_INVALID_KEY;
     178             : 
     179           2 :     if (pKey->isReadOnly())
     180           0 :         return REG_REGISTRY_READONLY;
     181             : 
     182           2 :     return pKey->deleteKey(keyName);
     183             : }
     184             : 
     185             : //*********************************************************************
     186             : //  closeKey
     187             : //
     188          20 : RegError REGISTRY_CALLTYPE closeKey(RegKeyHandle hKey)
     189             : {
     190          20 :     ORegKey* pKey = static_cast< ORegKey* >(hKey);
     191          20 :     if (!pKey)
     192           0 :         return REG_INVALID_KEY;
     193             : 
     194          20 :     return pKey->closeKey(hKey);
     195             : }
     196             : 
     197             : //*********************************************************************
     198             : //  setValue
     199             : //
     200       27103 : RegError REGISTRY_CALLTYPE setValue(RegKeyHandle hKey,
     201             :                                        rtl_uString* keyName,
     202             :                                        RegValueType valueType,
     203             :                                        RegValue pData,
     204             :                                        sal_uInt32 valueSize)
     205             : {
     206       27103 :     ORegKey* pKey = static_cast< ORegKey* >(hKey);
     207       27103 :     if (!pKey)
     208           0 :         return REG_INVALID_KEY;
     209             : 
     210       27103 :     if (pKey->isDeleted())
     211           0 :         return REG_INVALID_KEY;
     212             : 
     213       27103 :     if (pKey->isReadOnly())
     214           0 :         return REG_REGISTRY_READONLY;
     215             : 
     216       27103 :     OUString valueName("value");
     217       27103 :     if (keyName->length)
     218             :     {
     219           0 :         ORegKey* pSubKey = 0;
     220           0 :         RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
     221           0 :         if (_ret1 != REG_NO_ERROR)
     222           0 :             return _ret1;
     223             : 
     224           0 :         _ret1 = pSubKey->setValue(valueName, valueType, pData, valueSize);
     225           0 :         if (_ret1 != REG_NO_ERROR)
     226             :         {
     227           0 :             RegError _ret2 = pKey->closeKey(pSubKey);
     228           0 :             if (_ret2)
     229           0 :                 return _ret2;
     230             :             else
     231           0 :                 return _ret1;
     232             :         }
     233             : 
     234           0 :         return pKey->closeKey(pSubKey);
     235             :     }
     236             : 
     237       27103 :     return pKey->setValue(valueName, valueType, pData, valueSize);
     238             : }
     239             : 
     240             : //*********************************************************************
     241             : //  setLongValueList
     242             : //
     243           0 : RegError REGISTRY_CALLTYPE setLongListValue(RegKeyHandle hKey,
     244             :                                                   rtl_uString* keyName,
     245             :                                                   sal_Int32* pValueList,
     246             :                                                   sal_uInt32 len)
     247             : {
     248           0 :     ORegKey* pKey = static_cast< ORegKey* >(hKey);
     249           0 :     if (!pKey)
     250           0 :         return REG_INVALID_KEY;
     251             : 
     252           0 :     if (pKey->isDeleted())
     253           0 :         return REG_INVALID_KEY;
     254             : 
     255           0 :     if (pKey->isReadOnly())
     256           0 :         return REG_REGISTRY_READONLY;
     257             : 
     258           0 :     OUString valueName("value");
     259           0 :     if (keyName->length)
     260             :     {
     261           0 :         ORegKey* pSubKey = 0;
     262           0 :         RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
     263           0 :         if (_ret1 != REG_NO_ERROR)
     264           0 :             return _ret1;
     265             : 
     266           0 :         _ret1 = pSubKey->setLongListValue(valueName, pValueList, len);
     267           0 :         if (_ret1 != REG_NO_ERROR)
     268             :         {
     269           0 :             RegError _ret2 = pKey->closeKey(pSubKey);
     270           0 :             if (_ret2 != REG_NO_ERROR)
     271           0 :                 return _ret2;
     272             :             else
     273           0 :                 return _ret1;
     274             :         }
     275             : 
     276           0 :         return pKey->closeKey(pSubKey);
     277             :     }
     278             : 
     279           0 :     return pKey->setLongListValue(valueName, pValueList, len);
     280             : }
     281             : 
     282             : //*********************************************************************
     283             : //  setStringValueList
     284             : //
     285           1 : RegError REGISTRY_CALLTYPE setStringListValue(RegKeyHandle hKey,
     286             :                                                    rtl_uString* keyName,
     287             :                                                    sal_Char** pValueList,
     288             :                                                    sal_uInt32 len)
     289             : {
     290           1 :     ORegKey* pKey = static_cast< ORegKey* >(hKey);
     291           1 :     if (!pKey)
     292           0 :         return REG_INVALID_KEY;
     293             : 
     294           1 :     if (pKey->isDeleted())
     295           0 :         return REG_INVALID_KEY;
     296             : 
     297           1 :     if (pKey->isReadOnly())
     298           0 :         return REG_REGISTRY_READONLY;
     299             : 
     300           1 :     OUString valueName("value");
     301           1 :     if (keyName->length)
     302             :     {
     303           0 :         ORegKey* pSubKey = 0;
     304           0 :         RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
     305           0 :         if (_ret1 != REG_NO_ERROR)
     306           0 :             return _ret1;
     307             : 
     308           0 :         _ret1 = pSubKey->setStringListValue(valueName, pValueList, len);
     309           0 :         if (_ret1 != REG_NO_ERROR)
     310             :         {
     311           0 :             RegError _ret2 = pKey->closeKey(pSubKey);
     312           0 :             if (_ret2 != REG_NO_ERROR)
     313           0 :                 return _ret2;
     314             :             else
     315           0 :                 return _ret1;
     316             :         }
     317             : 
     318           0 :         return pKey->closeKey(pSubKey);
     319             :     }
     320             : 
     321           1 :     return pKey->setStringListValue(valueName, pValueList, len);
     322             : }
     323             : 
     324             : //*********************************************************************
     325             : //  setUnicodeValueList
     326             : //
     327           0 : RegError REGISTRY_CALLTYPE setUnicodeListValue(RegKeyHandle hKey,
     328             :                                                      rtl_uString* keyName,
     329             :                                                      sal_Unicode** pValueList,
     330             :                                                      sal_uInt32 len)
     331             : {
     332           0 :     ORegKey* pKey = static_cast< ORegKey* >(hKey);
     333           0 :     if (!pKey)
     334           0 :         return REG_INVALID_KEY;
     335             : 
     336           0 :     if (pKey->isDeleted())
     337           0 :         return REG_INVALID_KEY;
     338             : 
     339           0 :     if (pKey->isReadOnly())
     340           0 :         return REG_REGISTRY_READONLY;
     341             : 
     342           0 :     OUString valueName("value");
     343           0 :     if (keyName->length)
     344             :     {
     345           0 :         ORegKey* pSubKey = 0;
     346           0 :         RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
     347           0 :         if (_ret1 != REG_NO_ERROR)
     348           0 :             return _ret1;
     349             : 
     350           0 :         _ret1 = pSubKey->setUnicodeListValue(valueName, pValueList, len);
     351           0 :         if (_ret1 != REG_NO_ERROR)
     352             :         {
     353           0 :             RegError _ret2 = pKey->closeKey(pSubKey);
     354           0 :             if (_ret2 != REG_NO_ERROR)
     355           0 :                 return _ret2;
     356             :             else
     357           0 :                 return _ret1;
     358             :         }
     359             : 
     360           0 :         return pKey->closeKey(pSubKey);
     361             :     }
     362             : 
     363           0 :     return pKey->setUnicodeListValue(valueName, pValueList, len);
     364             : }
     365             : 
     366             : //*********************************************************************
     367             : //  getValueInfo
     368             : //
     369       14529 : RegError REGISTRY_CALLTYPE getValueInfo(RegKeyHandle hKey,
     370             :                                         rtl_uString* keyName,
     371             :                                         RegValueType* pValueType,
     372             :                                         sal_uInt32* pValueSize)
     373             : {
     374       14529 :     *pValueType = RG_VALUETYPE_NOT_DEFINED;
     375       14529 :     *pValueSize = 0;
     376             : 
     377       14529 :     ORegKey* pKey = static_cast< ORegKey* >(hKey);
     378       14529 :     if (!pKey)
     379           0 :         return REG_INVALID_KEY;
     380             : 
     381       14529 :     if (pKey->isDeleted())
     382           0 :         return REG_INVALID_KEY;
     383             : 
     384             :     RegValueType valueType;
     385             :     sal_uInt32   valueSize;
     386             : 
     387       14529 :     OUString valueName("value");
     388       14529 :     if (keyName->length)
     389             :     {
     390           0 :         ORegKey* pSubKey = 0;
     391           0 :         RegError _ret = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
     392           0 :         if (_ret != REG_NO_ERROR)
     393           0 :             return _ret;
     394             : 
     395           0 :         if (pSubKey->getValueInfo(valueName, &valueType, &valueSize) != REG_NO_ERROR)
     396             :         {
     397           0 :             (void) pKey->releaseKey(pSubKey);
     398           0 :             return REG_INVALID_VALUE;
     399             :         }
     400             : 
     401           0 :         *pValueType = valueType;
     402           0 :         *pValueSize = valueSize;
     403             : 
     404           0 :         return pKey->releaseKey(pSubKey);
     405             :     }
     406             : 
     407             : 
     408       14529 :     if (pKey->getValueInfo(valueName, &valueType, &valueSize) != REG_NO_ERROR)
     409             :     {
     410          16 :         return REG_INVALID_VALUE;
     411             :     }
     412             : 
     413       14513 :     *pValueType = valueType;
     414       14513 :     *pValueSize = valueSize;
     415             : 
     416       14513 :     return REG_NO_ERROR;
     417             : }
     418             : 
     419             : //*********************************************************************
     420             : //  getValueInfo
     421             : //
     422       14510 : RegError REGISTRY_CALLTYPE getValue(RegKeyHandle hKey,
     423             :                                     rtl_uString* keyName,
     424             :                                     RegValue pValue)
     425             : {
     426       14510 :     ORegKey* pKey = static_cast< ORegKey* >(hKey);
     427       14510 :     if (!pKey)
     428           0 :         return REG_INVALID_KEY;
     429             : 
     430       14510 :     if (pKey->isDeleted())
     431           0 :         return REG_INVALID_KEY;
     432             : 
     433       14510 :     OUString valueName("value");
     434       14510 :     if (keyName->length)
     435             :     {
     436           0 :         ORegKey* pSubKey = 0;
     437           0 :         RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
     438           0 :         if (_ret1 != REG_NO_ERROR)
     439           0 :             return _ret1;
     440             : 
     441           0 :         _ret1 = pSubKey->getValue(valueName, pValue);
     442           0 :         if (_ret1 != REG_NO_ERROR)
     443             :         {
     444           0 :             (void) pKey->releaseKey(pSubKey);
     445           0 :             return _ret1;
     446             :         }
     447             : 
     448           0 :         return pKey->releaseKey(pSubKey);
     449             :     }
     450             : 
     451       14510 :     return pKey->getValue(valueName, pValue);
     452             : }
     453             : 
     454             : //*********************************************************************
     455             : //  getLongValueList
     456             : //
     457           0 : RegError REGISTRY_CALLTYPE getLongListValue(RegKeyHandle hKey,
     458             :                                             rtl_uString* keyName,
     459             :                                             sal_Int32** pValueList,
     460             :                                             sal_uInt32* pLen)
     461             : {
     462             :     OSL_PRECOND((pValueList != 0) && (pLen != 0), "registry::getLongListValue(): invalid parameter");
     463           0 :     *pValueList = 0, *pLen = 0;
     464             : 
     465           0 :     ORegKey* pKey = static_cast< ORegKey* >(hKey);
     466           0 :     if (!pKey)
     467           0 :         return REG_INVALID_KEY;
     468             : 
     469           0 :     if (pKey->isDeleted())
     470           0 :         return REG_INVALID_KEY;
     471             : 
     472           0 :     OUString valueName("value");
     473           0 :     if (keyName->length)
     474             :     {
     475           0 :         ORegKey* pSubKey = 0;
     476           0 :         RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
     477           0 :         if (_ret1 != REG_NO_ERROR)
     478           0 :             return _ret1;
     479             : 
     480           0 :         _ret1 = pSubKey->getLongListValue(valueName, pValueList, pLen);
     481           0 :         if (_ret1 != REG_NO_ERROR)
     482             :         {
     483           0 :             (void) pKey->releaseKey(pSubKey);
     484           0 :             return _ret1;
     485             :         }
     486             : 
     487           0 :         return pKey->releaseKey(pSubKey);
     488             :     }
     489             : 
     490           0 :     return pKey->getLongListValue(valueName, pValueList, pLen);
     491             : }
     492             : 
     493             : //*********************************************************************
     494             : //  getStringValueList
     495             : //
     496           0 : RegError REGISTRY_CALLTYPE getStringListValue(RegKeyHandle hKey,
     497             :                                               rtl_uString* keyName,
     498             :                                               sal_Char*** pValueList,
     499             :                                               sal_uInt32* pLen)
     500             : {
     501             :     OSL_PRECOND((pValueList != 0) && (pLen != 0), "registry::getStringListValue(): invalid parameter");
     502           0 :     *pValueList = 0, *pLen = 0;
     503             : 
     504           0 :     ORegKey* pKey = static_cast< ORegKey* >(hKey);
     505           0 :     if (!pKey)
     506           0 :         return REG_INVALID_KEY;
     507             : 
     508           0 :     if (pKey->isDeleted())
     509           0 :         return REG_INVALID_KEY;
     510             : 
     511           0 :     OUString valueName("value");
     512           0 :     if (keyName->length)
     513             :     {
     514           0 :         ORegKey* pSubKey = 0;
     515           0 :         RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
     516           0 :         if (_ret1 != REG_NO_ERROR)
     517           0 :             return _ret1;
     518             : 
     519           0 :         _ret1 = pSubKey->getStringListValue(valueName, pValueList, pLen);
     520           0 :         if (_ret1 != REG_NO_ERROR)
     521             :         {
     522           0 :             (void) pKey->releaseKey(pSubKey);
     523           0 :             return _ret1;
     524             :         }
     525             : 
     526           0 :         return pKey->releaseKey(pSubKey);
     527             :     }
     528             : 
     529           0 :     return pKey->getStringListValue(valueName, pValueList, pLen);
     530             : }
     531             : 
     532             : //*********************************************************************
     533             : //  getUnicodeListValue
     534             : //
     535           0 : RegError REGISTRY_CALLTYPE getUnicodeListValue(RegKeyHandle hKey,
     536             :                                                rtl_uString* keyName,
     537             :                                                sal_Unicode*** pValueList,
     538             :                                                sal_uInt32* pLen)
     539             : {
     540             :     OSL_PRECOND((pValueList != 0) && (pLen != 0), "registry::getUnicodeListValue(): invalid parameter");
     541           0 :     *pValueList = 0, *pLen = 0;
     542             : 
     543           0 :     ORegKey* pKey = static_cast< ORegKey* >(hKey);
     544           0 :     if (!pKey)
     545           0 :         return REG_INVALID_KEY;
     546             : 
     547           0 :     if (pKey->isDeleted())
     548           0 :         return REG_INVALID_KEY;
     549             : 
     550           0 :     OUString valueName("value");
     551           0 :     if (keyName->length)
     552             :     {
     553           0 :         ORegKey* pSubKey = 0;
     554           0 :         RegError _ret1 = pKey->openKey(keyName, (RegKeyHandle*)&pSubKey);
     555           0 :         if (_ret1 != REG_NO_ERROR)
     556           0 :             return _ret1;
     557             : 
     558           0 :         _ret1 = pSubKey->getUnicodeListValue(valueName, pValueList, pLen);
     559           0 :         if (_ret1 != REG_NO_ERROR)
     560             :         {
     561           0 :             (void) pKey->releaseKey(pSubKey);
     562           0 :             return _ret1;
     563             :         }
     564             : 
     565           0 :         return pKey->releaseKey(pSubKey);
     566             :     }
     567             : 
     568           0 :     return pKey->getUnicodeListValue(valueName, pValueList, pLen);
     569             : }
     570             : 
     571             : //*********************************************************************
     572             : //  freeValueList
     573             : //
     574           0 : RegError REGISTRY_CALLTYPE freeValueList(RegValueType valueType,
     575             :                                               RegValue pValueList,
     576             :                                               sal_uInt32 len)
     577             : {
     578           0 :     switch (valueType)
     579             :     {
     580             :         case 5:
     581             :             {
     582           0 :                 rtl_freeMemory(pValueList);
     583             :             }
     584           0 :             break;
     585             :         case 6:
     586             :             {
     587           0 :                 sal_Char** pVList = (sal_Char**)pValueList;
     588           0 :                 for (sal_uInt32 i=0; i < len; i++)
     589             :                 {
     590           0 :                     rtl_freeMemory(pVList[i]);
     591             :                 }
     592             : 
     593           0 :                 rtl_freeMemory(pVList);
     594             :             }
     595           0 :             break;
     596             :         case 7:
     597             :             {
     598           0 :                 sal_Unicode** pVList = (sal_Unicode**)pValueList;
     599           0 :                 for (sal_uInt32 i=0; i < len; i++)
     600             :                 {
     601           0 :                     rtl_freeMemory(pVList[i]);
     602             :                 }
     603             : 
     604           0 :                 rtl_freeMemory(pVList);
     605             :             }
     606           0 :             break;
     607             :         default:
     608           0 :             return REG_INVALID_VALUE;
     609             :     }
     610             : 
     611           0 :     pValueList = NULL;
     612           0 :     return REG_NO_ERROR;
     613             : }
     614             : 
     615             : //*********************************************************************
     616             : //  createLink
     617             : //
     618           0 : RegError REGISTRY_CALLTYPE createLink(
     619             :     SAL_UNUSED_PARAMETER RegKeyHandle, SAL_UNUSED_PARAMETER rtl_uString*,
     620             :     SAL_UNUSED_PARAMETER rtl_uString*)
     621             : {
     622           0 :     return REG_INVALID_LINK; // links are no longer supported
     623             : }
     624             : 
     625             : //*********************************************************************
     626             : //  deleteLink
     627             : //
     628           0 : RegError REGISTRY_CALLTYPE deleteLink(
     629             :     SAL_UNUSED_PARAMETER RegKeyHandle, SAL_UNUSED_PARAMETER rtl_uString*)
     630             : {
     631           0 :     return REG_INVALID_LINK; // links are no longer supported
     632             : }
     633             : 
     634             : //*********************************************************************
     635             : //  getKeyType
     636             : //
     637           7 : RegError REGISTRY_CALLTYPE getKeyType(RegKeyHandle hKey,
     638             :                                       rtl_uString* keyName,
     639             :                                          RegKeyType* pKeyType)
     640             : {
     641           7 :     ORegKey* pKey = static_cast< ORegKey* >(hKey);
     642           7 :     if (!pKey)
     643           0 :         return REG_INVALID_KEY;
     644             : 
     645           7 :     if (pKey->isDeleted())
     646           0 :         return REG_INVALID_KEY;
     647             : 
     648           7 :     return pKey->getKeyType(keyName, pKeyType);
     649             : }
     650             : 
     651             : //*********************************************************************
     652             : //  getLinkTarget
     653             : //
     654           0 : RegError REGISTRY_CALLTYPE getLinkTarget(
     655             :     SAL_UNUSED_PARAMETER RegKeyHandle, SAL_UNUSED_PARAMETER rtl_uString*,
     656             :     SAL_UNUSED_PARAMETER rtl_uString**)
     657             : {
     658           0 :     return REG_INVALID_LINK; // links are no longer supported
     659             : }
     660             : 
     661             : //*********************************************************************
     662             : //  getName
     663             : //
     664           0 : RegError REGISTRY_CALLTYPE getResolvedKeyName(RegKeyHandle hKey,
     665             :                                               rtl_uString* keyName,
     666             :                                               SAL_UNUSED_PARAMETER sal_Bool,
     667             :                                                 rtl_uString** pResolvedName)
     668             : {
     669           0 :     ORegKey* pKey = static_cast< ORegKey* >(hKey);
     670           0 :     if (!pKey)
     671           0 :         return REG_INVALID_KEY;
     672             : 
     673           0 :     if (pKey->isDeleted())
     674           0 :         return REG_INVALID_KEY;
     675             : 
     676           0 :     OUString resolvedName;
     677           0 :     RegError _ret = pKey->getResolvedKeyName(keyName, resolvedName);
     678           0 :     if (_ret == REG_NO_ERROR)
     679           0 :         rtl_uString_assign(pResolvedName, resolvedName.pData);
     680           0 :     return _ret;
     681             : }
     682             : 
     683             : //*********************************************************************
     684             : //  getKeyNames
     685             : //
     686        8823 : RegError REGISTRY_CALLTYPE getKeyNames(RegKeyHandle hKey,
     687             :                                        rtl_uString* keyName,
     688             :                                          rtl_uString*** pSubKeyNames,
     689             :                                          sal_uInt32* pnSubKeys)
     690             : {
     691        8823 :     ORegKey* pKey = static_cast< ORegKey* >(hKey);
     692        8823 :     if (!pKey)
     693           0 :         return REG_INVALID_KEY;
     694             : 
     695        8823 :     if (pKey->isDeleted())
     696           0 :         return REG_INVALID_KEY;
     697             : 
     698        8823 :     return pKey->getKeyNames(keyName, pSubKeyNames, pnSubKeys);
     699             : }
     700             : 
     701             : //*********************************************************************
     702             : //  freeKeyNames
     703             : //
     704         452 : RegError REGISTRY_CALLTYPE freeKeyNames(rtl_uString** pKeyNames,
     705             :                                           sal_uInt32 nKeys)
     706             : {
     707       15011 :     for (sal_uInt32 i=0; i < nKeys; i++)
     708             :     {
     709       14559 :         rtl_uString_release(pKeyNames[i]);
     710             :     }
     711             : 
     712         452 :     rtl_freeMemory(pKeyNames);
     713             : 
     714         452 :     return REG_NO_ERROR;
     715             : }
     716             : 
     717             : //*********************************************************************
     718             : //  C API
     719             : //
     720             : 
     721             : //*********************************************************************
     722             : //  reg_createKey
     723             : //
     724           0 : RegError REGISTRY_CALLTYPE reg_createKey(RegKeyHandle hKey,
     725             :                                          rtl_uString* keyName,
     726             :                                          RegKeyHandle* phNewKey)
     727             : {
     728           0 :     if (!hKey)
     729           0 :          return REG_INVALID_KEY;
     730             : 
     731           0 :     return createKey(hKey, keyName, phNewKey);
     732             : }
     733             : 
     734             : //*********************************************************************
     735             : //  reg_openKey
     736             : //
     737           0 : RegError REGISTRY_CALLTYPE reg_openKey(RegKeyHandle hKey,
     738             :                                        rtl_uString* keyName,
     739             :                                        RegKeyHandle* phOpenKey)
     740             : {
     741           0 :     if (!hKey)
     742           0 :         return REG_INVALID_KEY;
     743             : 
     744           0 :     return openKey(hKey, keyName, phOpenKey);
     745             : }
     746             : 
     747             : //*********************************************************************
     748             : //  reg_openSubKeys
     749             : //
     750           0 : RegError REGISTRY_CALLTYPE reg_openSubKeys(RegKeyHandle hKey,
     751             :                                            rtl_uString* keyName,
     752             :                                            RegKeyHandle** pphSubKeys,
     753             :                                            sal_uInt32* pnSubKeys)
     754             : {
     755           0 :     if (!hKey)
     756           0 :         return REG_INVALID_KEY;
     757             : 
     758           0 :     return openSubKeys(hKey, keyName, pphSubKeys, pnSubKeys);
     759             : }
     760             : 
     761             : //*********************************************************************
     762             : //  reg_closeSubKeys
     763             : //
     764           0 : RegError REGISTRY_CALLTYPE reg_closeSubKeys(RegKeyHandle* pphSubKeys,
     765             :                                             sal_uInt32 nSubKeys)
     766             : {
     767           0 :     if (!pphSubKeys)
     768           0 :         return REG_INVALID_KEY;
     769             : 
     770           0 :     return closeSubKeys(pphSubKeys, nSubKeys);
     771             : }
     772             : 
     773             : //*********************************************************************
     774             : //  reg_deleteKey
     775             : //
     776           0 : RegError REGISTRY_CALLTYPE reg_deleteKey(RegKeyHandle hKey,
     777             :                                          rtl_uString* keyName)
     778             : {
     779           0 :     if (!hKey)
     780           0 :         return REG_INVALID_KEY;
     781             : 
     782           0 :     return deleteKey(hKey, keyName);
     783             : }
     784             : 
     785             : //*********************************************************************
     786             : //  reg_closeKey
     787             : //
     788           0 : RegError REGISTRY_CALLTYPE reg_closeKey(RegKeyHandle hKey)
     789             : {
     790           0 :     if (!hKey)
     791           0 :         return REG_INVALID_KEY;
     792             : 
     793           0 :     return closeKey(hKey);
     794             : }
     795             : 
     796             : 
     797             : //*********************************************************************
     798             : //  reg_getKeyName
     799             : //
     800           0 : RegError REGISTRY_CALLTYPE reg_getKeyName(RegKeyHandle hKey, rtl_uString** pKeyName)
     801             : {
     802           0 :     if (hKey)
     803             :     {
     804           0 :         rtl_uString_assign( pKeyName, ((ORegKey*)hKey)->getName().pData );
     805           0 :         return REG_NO_ERROR;
     806             :     } else
     807             :     {
     808           0 :         rtl_uString_new( pKeyName );
     809           0 :         return REG_INVALID_KEY;
     810             :     }
     811             : }
     812             : 
     813             : //*********************************************************************
     814             : //  reg_setValue
     815             : //
     816           0 : RegError REGISTRY_CALLTYPE reg_setValue(RegKeyHandle hKey,
     817             :                                         rtl_uString* keyName,
     818             :                                         RegValueType valueType,
     819             :                                         RegValue pData,
     820             :                                         sal_uInt32 valueSize)
     821             : {
     822           0 :     if (!hKey)
     823           0 :         return REG_INVALID_KEY;
     824             : 
     825           0 :     return setValue(hKey, keyName, valueType, pData, valueSize);
     826             : }
     827             : 
     828             : //*********************************************************************
     829             : //  reg_setLongListValue
     830             : //
     831           0 : RegError REGISTRY_CALLTYPE reg_setLongListValue(RegKeyHandle hKey,
     832             :                                                       rtl_uString* keyName,
     833             :                                                       sal_Int32* pValueList,
     834             :                                                       sal_uInt32 len)
     835             : {
     836           0 :     if (!hKey)
     837           0 :         return REG_INVALID_KEY;
     838             : 
     839           0 :     return setLongListValue(hKey, keyName, pValueList, len);
     840             : }
     841             : 
     842             : //*********************************************************************
     843             : //  reg_setStringListValue
     844             : //
     845           0 : RegError REGISTRY_CALLTYPE reg_setStringListValue(RegKeyHandle hKey,
     846             :                                                           rtl_uString* keyName,
     847             :                                                           sal_Char** pValueList,
     848             :                                                           sal_uInt32 len)
     849             : {
     850           0 :     if (!hKey)
     851           0 :         return REG_INVALID_KEY;
     852             : 
     853           0 :     return setStringListValue(hKey, keyName, pValueList, len);
     854             : }
     855             : 
     856             : //*********************************************************************
     857             : //  reg_setUnicodeListValue
     858             : //
     859           0 : RegError REGISTRY_CALLTYPE reg_setUnicodeListValue(RegKeyHandle hKey,
     860             :                                                             rtl_uString* keyName,
     861             :                                                             sal_Unicode** pValueList,
     862             :                                                             sal_uInt32 len)
     863             : {
     864           0 :     if (!hKey)
     865           0 :         return REG_INVALID_KEY;
     866             : 
     867           0 :     return setUnicodeListValue(hKey, keyName, pValueList, len);
     868             : }
     869             : 
     870             : //*********************************************************************
     871             : //  reg_getValueInfo
     872             : //
     873           0 : RegError REGISTRY_CALLTYPE reg_getValueInfo(RegKeyHandle hKey,
     874             :                                             rtl_uString* keyName,
     875             :                                             RegValueType* pValueType,
     876             :                                             sal_uInt32* pValueSize)
     877             : {
     878           0 :     if (!hKey)
     879           0 :         return REG_INVALID_KEY;
     880             : 
     881           0 :     return getValueInfo(hKey, keyName, pValueType, pValueSize);
     882             : }
     883             : 
     884             : //*********************************************************************
     885             : //  reg_getValueInfo
     886             : //
     887           0 : RegError REGISTRY_CALLTYPE reg_getValue(RegKeyHandle hKey,
     888             :                                         rtl_uString* keyName,
     889             :                                         RegValue pData)
     890             : {
     891           0 :     if (!hKey)
     892           0 :         return REG_INVALID_KEY;
     893             : 
     894           0 :     return getValue(hKey, keyName, pData);
     895             : }
     896             : 
     897             : //*********************************************************************
     898             : //  reg_getLongListValue
     899             : //
     900           0 : RegError REGISTRY_CALLTYPE reg_getLongListValue(RegKeyHandle hKey,
     901             :                                                       rtl_uString* keyName,
     902             :                                                       sal_Int32** pValueList,
     903             :                                                       sal_uInt32* pLen)
     904             : {
     905           0 :     if (!hKey)
     906           0 :         return REG_INVALID_KEY;
     907             : 
     908           0 :     return getLongListValue(hKey, keyName, pValueList, pLen);
     909             : }
     910             : 
     911             : //*********************************************************************
     912             : //  reg_getStringListValue
     913             : //
     914           0 : RegError REGISTRY_CALLTYPE reg_getStringListValue(RegKeyHandle hKey,
     915             :                                                        rtl_uString* keyName,
     916             :                                                        sal_Char*** pValueList,
     917             :                                                        sal_uInt32* pLen)
     918             : {
     919           0 :     if (!hKey)
     920           0 :         return REG_INVALID_KEY;
     921             : 
     922           0 :     return getStringListValue(hKey, keyName, pValueList, pLen);
     923             : }
     924             : 
     925             : //*********************************************************************
     926             : //  reg_getUnicodeListValue
     927             : //
     928           0 : RegError REGISTRY_CALLTYPE reg_getUnicodeListValue(RegKeyHandle hKey,
     929             :                                                          rtl_uString* keyName,
     930             :                                                          sal_Unicode*** pValueList,
     931             :                                                          sal_uInt32* pLen)
     932             : {
     933           0 :     if (!hKey)
     934           0 :         return REG_INVALID_KEY;
     935             : 
     936           0 :     return getUnicodeListValue(hKey, keyName, pValueList, pLen);
     937             : }
     938             : 
     939             : //*********************************************************************
     940             : //  reg_freeValueList
     941             : //
     942           0 : RegError REGISTRY_CALLTYPE reg_freeValueList(RegValueType valueType,
     943             :                                                   RegValue pValueList,
     944             :                                                   sal_uInt32 len)
     945             : {
     946           0 :     if (pValueList)
     947           0 :         return freeValueList(valueType, pValueList, len);
     948             :     else
     949           0 :         return REG_INVALID_VALUE;
     950             : }
     951             : 
     952             : //*********************************************************************
     953             : //  reg_getKeyType
     954             : //
     955           0 : RegError REGISTRY_CALLTYPE reg_getKeyType(RegKeyHandle hKey,
     956             :                                           rtl_uString* keyName,
     957             :                                              RegKeyType* pKeyType)
     958             : {
     959           0 :     if (!hKey)
     960           0 :         return REG_INVALID_KEY;
     961             : 
     962           0 :     return getKeyType(hKey, keyName, pKeyType);
     963             : }
     964             : 
     965             : //*********************************************************************
     966             : //  reg_getResolvedKeyName
     967             : //
     968           0 : RegError REGISTRY_CALLTYPE reg_getResolvedKeyName(RegKeyHandle hKey,
     969             :                                                     rtl_uString* keyName,
     970             :                                                     sal_Bool firstLinkOnly,
     971             :                                                       rtl_uString** pResolvedName)
     972             : {
     973           0 :     if (!hKey)
     974           0 :         return REG_INVALID_KEY;
     975             : 
     976           0 :     return getResolvedKeyName(hKey, keyName, firstLinkOnly, pResolvedName);
     977             : }
     978             : 
     979             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10