mozilla
/
pjs
зеркало из https://github.com/mozilla/pjs.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

- Threading fixed. Changed member that stored error from nsRegistry 

to be an automatic variable.
- Using XPCOM_ComponentRegistry for OpenWellknownRegistry()
This commit is contained in:
dp%netscape.com 1999-06-21 23:40:21 +00:00
Родитель 4418e22473
Коммит 91b58aabba
2 изменённых файлов: 284 добавлений и 184 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

234
modules/libreg/xpcom/nsRegistry.cpp
Просмотреть файл

@ -77,7 +77,6 @@ struct nsRegistry : public nsIRegistry {
protected:
HREG mReg; // Registry handle.
REGERR mErr; // Last libreg error code.
PRLock *mregLock; // libreg isn't threadsafe. Use locks to synchronize.
}; // nsRegistry
@ -115,16 +114,17 @@ struct nsRegSubtreeEnumerator : public nsIEnumerator {
// ctor/dtor
nsRegSubtreeEnumerator( HREG hReg, RKEY rKey, PRBool all );
virtual ~nsRegSubtreeEnumerator();
protected:
NS_IMETHOD advance(); // Implementation file; does appropriate NR_RegEnum call.
PRLock *mregLock;
HREG mReg; // Handle to registry we're affiliated with.
RKEY mKey; // Base key being enumerated.
REGENUM mEnum; // Corresponding libreg "enumerator".
REGENUM mNext; // Lookahead value.
uint32 mStyle; // Style (indicates all or some);
PRBool mDone; // Done flag.
REGERR mErr; // Last libreg error code.
}; // nsRegSubtreeEnumerator
@ -158,12 +158,13 @@ struct nsRegistryNode : public nsIRegistryNode {
// ctor
nsRegistryNode( HREG hReg, RKEY key, REGENUM slot );
virtual ~nsRegistryNode();
protected:
HREG mReg; // Handle to registry this node is part of.
PRLock *mregLock;
RKEY mKey; // Key this node is under.
REGENUM mEnum; // Copy of corresponding content of parent enumerator.
REGERR mErr; // Last libreg error code.
char mName[MAXREGPATHLEN]; // Buffer to hold name.
}; // nsRegistryNode
@ -183,13 +184,14 @@ struct nsRegistryValue : public nsIRegistryValue {
// ctor
nsRegistryValue( HREG hReg, RKEY key, REGENUM slot );
virtual ~nsRegistryValue();
protected:
nsresult getInfo(); // Get registry info.
HREG mReg; // Handle to registry this node is part of.
PRLock *mregLock;
RKEY mKey; // Key this node is under.
REGENUM mEnum; // Copy of corresponding content of parent enumerator.
REGERR mErr; // Last libreg error code.
REGINFO mInfo; // Value info.
char mName[MAXREGNAMELEN]; // Buffer to hold name.
}; // nsRegistryValue
@ -385,6 +387,7 @@ nsRegistry::~nsRegistry() {
| it if so. |
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::Open( const char *regFile ) {
REGERR err = REGERR_OK;
// Check for default.
if( !regFile ) {
return OpenDefault();
@ -393,10 +396,10 @@ NS_IMETHODIMP nsRegistry::Open( const char *regFile ) {
Close();
// Open specified registry.
PR_Lock(mregLock);
mErr = NR_RegOpen((char*)regFile, &mReg );
err = NR_RegOpen((char*)regFile, &mReg );
PR_Unlock(mregLock);
// Convert the result.
return regerr2nsresult( mErr );
return regerr2nsresult( err );
}
/*----------------------------- nsRegistry::OpenWellKnownRegistry --------------
@ -404,20 +407,20 @@ NS_IMETHODIMP nsRegistry::Open( const char *regFile ) {
| to see if a registry file is already open and close it if so. |
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::OpenWellKnownRegistry( uint32 regid ) {
REGERR err = REGERR_OK;
// Ensure existing registry is closed.
Close();
nsSpecialSystemDirectory reg(nsSpecialSystemDirectory::OS_CurrentProcessDirectory);
nsSpecialSystemDirectory *registryLocation = NULL;
PRBool foundReg = PR_FALSE;
switch ( (WellKnownRegistry) regid ) {
case ApplicationComponentRegistry:
#ifdef XP_MAC
reg += "Component Registry";
#else
reg += "component.reg";
#endif /* XP_MAC */
foundReg = PR_TRUE;
registryLocation =
new nsSpecialSystemDirectory(nsSpecialSystemDirectory::XPCOM_CurrentProcessComponentRegistry);
if (registryLocation != NULL)
foundReg = PR_TRUE;
break;
default:
@ -431,17 +434,19 @@ NS_IMETHODIMP nsRegistry::OpenWellKnownRegistry( uint32 regid ) {
// WARNING:
// regNSPRPath and regFile need to have the same scope
// since the regFile will point to data in regNSPRPath
nsNSPRPath regNSPRPath(reg);
nsNSPRPath regNSPRPath(*registryLocation);
const char *regFile = (const char *) regNSPRPath;
#ifdef DEBUG_dp
printf("nsRegistry: Opening std registry %s\n", regFile);
#endif /* DEBUG_dp */
PR_Lock(mregLock);
mErr = NR_RegOpen((char*)regFile, &mReg );
err = NR_RegOpen((char*)regFile, &mReg );
PR_Unlock(mregLock);
// Cleanup
delete registryLocation;
// Convert the result.
return regerr2nsresult( mErr );
return regerr2nsresult( err );
}
/*-------------------------- nsRegistry::OpenDefault ---------------------------
@ -449,28 +454,29 @@ NS_IMETHODIMP nsRegistry::OpenWellKnownRegistry( uint32 regid ) {
| that is done by passing a null file name pointer to NR_RegOpen. |
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::OpenDefault() {
REGERR err = REGERR_OK;
// Ensure existing registry is closed.
Close();
// Open default registry.
PR_Lock(mregLock);
mErr = NR_RegOpen( 0, &mReg );
err = NR_RegOpen( 0, &mReg );
PR_Unlock(mregLock);
// Convert the result.
return regerr2nsresult( mErr );
return regerr2nsresult( err );
}
/*----------------------------- nsRegistry::Close ------------------------------
| Tests the mReg handle and if non-null, closes the registry via NR_RegClose. |
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::Close() {
mErr = REGERR_OK;
REGERR err = REGERR_OK;
if( mReg ) {
PR_Lock(mregLock);
mErr = NR_RegClose( mReg );
err = NR_RegClose( mReg );
PR_Unlock(mregLock);
mReg = 0;
}
return regerr2nsresult( mErr );
return regerr2nsresult( err );
}
/*--------------------------- nsRegistry::GetString ----------------------------
@ -479,6 +485,8 @@ NS_IMETHODIMP nsRegistry::Close() {
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::GetString( Key baseKey, const char *path, char **result ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Make sure caller gave us place for result.
if( result ) {
*result = 0; // Clear result.
@ -498,10 +506,10 @@ NS_IMETHODIMP nsRegistry::GetString( Key baseKey, const char *path, char **resul
if( *result ) {
// Get string from registry into result buffer.
PR_Lock(mregLock);
mErr = NR_RegGetEntryString( mReg,(RKEY)baseKey,(char*)path, *result, length+1 );
err = NR_RegGetEntryString( mReg,(RKEY)baseKey,(char*)path, *result, length+1 );
PR_Unlock(mregLock);
// Convert status.
rv = regerr2nsresult( mErr );
rv = regerr2nsresult( err );
// Test result.
if( rv != NS_OK ) {
// Didn't get result, free buffer.
@ -527,14 +535,13 @@ NS_IMETHODIMP nsRegistry::GetString( Key baseKey, const char *path, char **resul
| Simply sets the registry contents using NR_RegSetEntryString. |
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::SetString( Key baseKey, const char *path, const char *value ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Set the contents.
PR_Lock(mregLock);
mErr = NR_RegSetEntryString( mReg,(RKEY)baseKey,(char*)path,(char*)value );
err = NR_RegSetEntryString( mReg,(RKEY)baseKey,(char*)path,(char*)value );
PR_Unlock(mregLock);
// Convert result.
rv = regerr2nsresult( mErr );
return rv;
return regerr2nsresult( err );
}
/*---------------------------- nsRegistry::GetInt ------------------------------
@ -544,6 +551,7 @@ NS_IMETHODIMP nsRegistry::SetString( Key baseKey, const char *path, const char *
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::GetInt( Key baseKey, const char *path, int32 *result ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Make sure caller gave us place for result.
if( result ) {
@ -557,10 +565,10 @@ NS_IMETHODIMP nsRegistry::GetInt( Key baseKey, const char *path, int32 *result )
uint32 len = sizeof *result;
// Get int from registry into result field.
PR_Lock(mregLock);
mErr = NR_RegGetEntry( mReg,(RKEY)baseKey,(char*)path, result, &len );
err = NR_RegGetEntry( mReg,(RKEY)baseKey,(char*)path, result, &len );
PR_Unlock(mregLock);
// Convert status.
rv = regerr2nsresult( mErr );
rv = regerr2nsresult( err );
} else {
// They asked for the wrong type of value.
rv = NS_ERROR_REG_BADTYPE;
@ -576,10 +584,10 @@ NS_IMETHODIMP nsRegistry::GetInt( Key baseKey, const char *path, int32 *result )
| Write out the value as a one-element int32 array, using NR_RegSetEntry. |
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::SetInt( Key baseKey, const char *path, int32 value ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Set the contents.
PR_Lock(mregLock);
mErr = NR_RegSetEntry( mReg,
err = NR_RegSetEntry( mReg,
(RKEY)baseKey,
(char*)path,
REGTYPE_ENTRY_INT32_ARRAY,
@ -587,8 +595,7 @@ NS_IMETHODIMP nsRegistry::SetInt( Key baseKey, const char *path, int32 value ) {
sizeof value );
PR_Unlock(mregLock);
// Convert result.
rv = regerr2nsresult( mErr );
return rv;
return regerr2nsresult( err );
}
/*--------------------------- nsRegistry::GetBytes -----------------------------
@ -596,6 +603,7 @@ NS_IMETHODIMP nsRegistry::SetInt( Key baseKey, const char *path, int32 value ) {
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::GetBytes( Key baseKey, const char *path, void **result, uint32 *len ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Make sure caller gave us place for result.
if( result && len ) {
@ -609,10 +617,10 @@ NS_IMETHODIMP nsRegistry::GetBytes( Key baseKey, const char *path, void **result
// Get bytes from registry into result field.
*result = PR_Malloc(*len);
PR_Lock(mregLock);
mErr = NR_RegGetEntry( mReg,(RKEY)baseKey,(char*)path, *result, len );
err = NR_RegGetEntry( mReg,(RKEY)baseKey,(char*)path, *result, len );
PR_Unlock(mregLock);
// Convert status.
rv = regerr2nsresult( mErr );
rv = regerr2nsresult( err );
} else {
// They asked for the wrong type of value.
rv = NS_ERROR_REG_BADTYPE;
@ -628,15 +636,14 @@ NS_IMETHODIMP nsRegistry::GetBytes( Key baseKey, const char *path, void **result
| Set the contents at the specified registry location, using NR_RegSetEntry. |
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::SetBytes( Key baseKey, const char *path, void *value, uint32 len ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Set contents.
PR_Lock(mregLock);
mErr = NR_RegSetEntry( mReg,(RKEY)baseKey,(char*)path,
err = NR_RegSetEntry( mReg,(RKEY)baseKey,(char*)path,
REGTYPE_ENTRY_BYTES, value, len );
PR_Unlock(mregLock);
// Convert result;
rv = regerr2nsresult( mErr );
return rv;
return regerr2nsresult( err );
}
/*-------------------------- nsRegistry::GetIntArray ---------------------------
@ -646,6 +653,7 @@ NS_IMETHODIMP nsRegistry::SetBytes( Key baseKey, const char *path, void *value,
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::GetIntArray( Key baseKey, const char *path, int32 **result, uint32 *len ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Make sure caller gave us place for result.
if( result && len ) {
@ -666,14 +674,14 @@ NS_IMETHODIMP nsRegistry::GetIntArray( Key baseKey, const char *path, int32 **re
if( *result ) {
// Get array from registry into result field.
PR_Lock(mregLock);
mErr = NR_RegGetEntry( mReg,(RKEY)baseKey,(char*)path, *result, len );
err = NR_RegGetEntry( mReg,(RKEY)baseKey,(char*)path, *result, len );
PR_Unlock(mregLock);
// Convert status.
if( mErr == REGERR_OK ) {
if( err == REGERR_OK ) {
// Convert size in bytes to array dimension.
*len /= sizeof(int32);
} else {
rv = regerr2nsresult( mErr );
rv = regerr2nsresult( err );
// Free buffer that we allocated(error will tell caller not to).
PR_Free( *result );
*result = 0;
@ -698,45 +706,42 @@ NS_IMETHODIMP nsRegistry::GetIntArray( Key baseKey, const char *path, int32 **re
| size in bytes in order to use NR_RegSetEntry. |
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::SetIntArray( Key baseKey, const char *path, const int32 *value, uint32 len ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Convert array dimension to byte count.
uint32 size = len * sizeof(int32);
// Set contents.
PR_Lock(mregLock);
mErr = NR_RegSetEntry( mReg,(RKEY)baseKey,(char*)path,
err = NR_RegSetEntry( mReg,(RKEY)baseKey,(char*)path,
REGTYPE_ENTRY_INT32_ARRAY,(void*)value, size );
PR_Unlock(mregLock);
// Convert result.
rv = regerr2nsresult( mErr );
return rv;
return regerr2nsresult( err );
}
/*-------------------------- nsRegistry::AddSubtree ----------------------------
| Add a new registry subkey with the specified name, using NR_RegAddKey. |
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::AddSubtree( Key baseKey, const char *path, Key *result ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Add the subkey.
PR_Lock(mregLock);
mErr = NR_RegAddKey( mReg,(RKEY)baseKey,(char*)path,(RKEY*)result );
err = NR_RegAddKey( mReg,(RKEY)baseKey,(char*)path,(RKEY*)result );
PR_Unlock(mregLock);
// Convert result.
rv = regerr2nsresult( mErr );
return rv;
return regerr2nsresult( err );
}
/*-------------------------- nsRegistry::AddSubtreeRaw--------------------------
| Add a new registry subkey with the specified name, using NR_RegAddKeyRaw |
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::AddSubtreeRaw( Key baseKey, const char *path, Key *result ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Add the subkey.
PR_Lock(mregLock);
mErr = NR_RegAddKeyRaw( mReg,(RKEY)baseKey,(char*)path,(RKEY*)result );
err = NR_RegAddKeyRaw( mReg,(RKEY)baseKey,(char*)path,(RKEY*)result );
PR_Unlock(mregLock);
// Convert result.
rv = regerr2nsresult( mErr );
return rv;
return regerr2nsresult( err );
}
@ -744,14 +749,13 @@ NS_IMETHODIMP nsRegistry::AddSubtreeRaw( Key baseKey, const char *path, Key *res
| Deletes the subtree at a given location using NR_RegDeleteKey. |
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::RemoveSubtree( Key baseKey, const char *path ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Delete the subkey.
PR_Lock(mregLock);
mErr = NR_RegDeleteKey( mReg,(RKEY)baseKey,(char*)path );
err = NR_RegDeleteKey( mReg,(RKEY)baseKey,(char*)path );
PR_Unlock(mregLock);
// Convert result.
rv = regerr2nsresult( mErr );
return rv;
return regerr2nsresult( err );
}
@ -760,6 +764,7 @@ NS_IMETHODIMP nsRegistry::RemoveSubtree( Key baseKey, const char *path ) {
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::RemoveSubtreeRaw( Key baseKey, const char *keyname ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// libreg doesn't delete keys if there are subkeys under the key
// Hence we have to recurse through to delete the subtree
@ -770,7 +775,7 @@ NS_IMETHODIMP nsRegistry::RemoveSubtreeRaw( Key baseKey, const char *keyname ) {
REGENUM state = 0;
PR_Lock(mregLock);
REGERR err = NR_RegGetKeyRaw(mReg, baseKey, (char *)keyname, &key);
err = NR_RegGetKeyRaw(mReg, baseKey, (char *)keyname, &key);
PR_Unlock(mregLock);
if (err != REGERR_OK)
{
@ -811,14 +816,15 @@ NS_IMETHODIMP nsRegistry::RemoveSubtreeRaw( Key baseKey, const char *keyname ) {
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::GetSubtree( Key baseKey, const char *path, Key *result ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Make sure we have a place for the result.
if( result ) {
// Get key.
PR_Lock(mregLock);
mErr = NR_RegGetKey( mReg,(RKEY)baseKey,(char*)path,(RKEY*)result );
err = NR_RegGetKey( mReg,(RKEY)baseKey,(char*)path,(RKEY*)result );
PR_Unlock(mregLock);
// Convert result.
rv = regerr2nsresult( mErr );
rv = regerr2nsresult( err );
} else {
rv = NS_ERROR_NULL_POINTER;
}
@ -831,14 +837,15 @@ NS_IMETHODIMP nsRegistry::GetSubtree( Key baseKey, const char *path, Key *result
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::GetSubtreeRaw( Key baseKey, const char *path, Key *result ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Make sure we have a place for the result.
if( result ) {
// Get key.
PR_Lock(mregLock);
mErr = NR_RegGetKeyRaw( mReg,(RKEY)baseKey,(char*)path,(RKEY*)result );
err = NR_RegGetKeyRaw( mReg,(RKEY)baseKey,(char*)path,(RKEY*)result );
PR_Unlock(mregLock);
// Convert result.
rv = regerr2nsresult( mErr );
rv = regerr2nsresult( err );
} else {
rv = NS_ERROR_NULL_POINTER;
}
@ -902,18 +909,19 @@ NS_IMETHODIMP nsRegistry::EnumerateAllSubtrees( Key baseKey, nsIEnumerator **res
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::GetValueType( Key baseKey, const char *path, uint32 *result ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Make sure we have a place to put the result.
if( result ) {
// Get registry info into local structure.
REGINFO info = { sizeof info, 0, 0 };
PR_Lock(mregLock);
mErr = NR_RegGetEntryInfo( mReg,(RKEY)baseKey,(char*)path, &info );
err = NR_RegGetEntryInfo( mReg,(RKEY)baseKey,(char*)path, &info );
PR_Unlock(mregLock);
if( mErr == REGERR_OK ) {
if( err == REGERR_OK ) {
// Copy info to user's result value.
reginfo2DataType( info, *result );
} else {
rv = regerr2nsresult( mErr );
rv = regerr2nsresult( err );
}
} else {
rv = NS_ERROR_NULL_POINTER;
@ -927,18 +935,19 @@ NS_IMETHODIMP nsRegistry::GetValueType( Key baseKey, const char *path, uint32 *r
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::GetValueLength( Key baseKey, const char *path, uint32 *result ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Make sure we have a place to put the result.
if( result ) {
// Get registry info into local structure.
REGINFO info = { sizeof info, 0, 0 };
PR_Lock(mregLock);
mErr = NR_RegGetEntryInfo( mReg,(RKEY)baseKey,(char*)path, &info );
err = NR_RegGetEntryInfo( mReg,(RKEY)baseKey,(char*)path, &info );
PR_Unlock(mregLock);
if( mErr == REGERR_OK ) {
if( err == REGERR_OK ) {
// Copy info to user's result value.
reginfo2Length( info, *result );
} else {
rv = regerr2nsresult( mErr );
rv = regerr2nsresult( err );
}
} else {
rv = NS_ERROR_NULL_POINTER;
@ -975,14 +984,15 @@ NS_IMETHODIMP nsRegistry::EnumerateValues( Key baseKey, nsIEnumerator **result )
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::GetCurrentUserName( char **result ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Make sure we have a place to put the result.
if( result ) {
// Get the user name.
PR_Lock(mregLock);
mErr = NR_RegGetUsername( result );
err = NR_RegGetUsername( result );
PR_Unlock(mregLock);
// Convert the result.
rv = regerr2nsresult( mErr );
rv = regerr2nsresult( err );
} else {
rv = NS_ERROR_NULL_POINTER;
}
@ -994,12 +1004,13 @@ NS_IMETHODIMP nsRegistry::GetCurrentUserName( char **result ) {
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::SetCurrentUserName( const char *name ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Set the user name.
PR_Lock(mregLock);
mErr = NR_RegSetUsername( name );
err = NR_RegSetUsername( name );
PR_Unlock(mregLock);
// Convert result.
rv = regerr2nsresult( mErr );
rv = regerr2nsresult( err );
return rv;
}
@ -1008,12 +1019,13 @@ NS_IMETHODIMP nsRegistry::SetCurrentUserName( const char *name ) {
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::Pack() {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Pack the registry.
PR_Lock(mregLock);
mErr = NR_RegPack( mReg, 0, 0 );
err = NR_RegPack( mReg, 0, 0 );
PR_Unlock(mregLock);
// Convert result.
rv = regerr2nsresult( mErr );
rv = regerr2nsresult( err );
return rv;
}
@ -1023,11 +1035,20 @@ NS_IMETHODIMP nsRegistry::Pack() {
------------------------------------------------------------------------------*/
nsRegSubtreeEnumerator::nsRegSubtreeEnumerator( HREG hReg, RKEY rKey, PRBool all )
: mReg( hReg ), mKey( rKey ), mEnum( 0 ), mNext( 0 ),
mStyle( all ? REGENUM_DESCEND : 0 ), mDone( PR_FALSE ), mErr( -1 ) {
mStyle( all ? REGENUM_DESCEND : 0 ), mDone( PR_FALSE ) {
NS_INIT_REFCNT();
// Create a registry lock
mregLock = PR_NewLock();
return;
}
nsRegSubtreeEnumerator::~nsRegSubtreeEnumerator()
{
if (mregLock) {
PR_DestroyLock(mregLock);
}
}
/*----------------------- nsRegSubtreeEnumerator::First ------------------------
| Set mEnum to 0; this will cause the next NR_RegEnum call to go to |
| the beginning. We then do a Next() call in order to do a "lookahead" to |
@ -1074,16 +1095,19 @@ nsRegSubtreeEnumerator::Next() {
| there are no more subkeys. |
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegSubtreeEnumerator::advance() {
REGERR err = REGERR_OK;
char name[MAXREGPATHLEN];
uint32 len = sizeof name;
mErr = NR_RegEnumSubkeys( mReg, mKey, &mNext, name, len, mStyle );
PR_Lock(mregLock);
err = NR_RegEnumSubkeys( mReg, mKey, &mNext, name, len, mStyle );
// See if we ran off end.
if( mErr == REGERR_NOMORE ) {
if( err == REGERR_NOMORE ) {
// Remember we've run off end.
mDone = PR_TRUE;
}
PR_Unlock(mregLock);
// Convert result.
nsresult rv = regerr2nsresult( mErr );
nsresult rv = regerr2nsresult( err );
return rv;
};
@ -1099,7 +1123,7 @@ nsRegSubtreeEnumerator::CurrentItem( nsISupports **result) {
if( result ) {
*result = new nsRegistryNode( mReg, mKey, mEnum );
if( *result ) {
(*result)->AddRef();
(*result)->AddRef();
} else {
rv = NS_ERROR_OUT_OF_MEMORY;
}
@ -1154,17 +1178,20 @@ nsRegValueEnumerator::CurrentItem( nsISupports **result ) {
| there are no more entries. |
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegValueEnumerator::advance() {
REGERR err = REGERR_OK;
char name[MAXREGNAMELEN];
uint32 len = sizeof name;
REGINFO info = { sizeof info, 0, 0 };
mErr = NR_RegEnumEntries( mReg, mKey, &mNext, name, len, &info );
PR_Lock(mregLock);
err = NR_RegEnumEntries( mReg, mKey, &mNext, name, len, &info );
// See if we ran off end.
if( mErr == REGERR_NOMORE ) {
if( err == REGERR_NOMORE ) {
// Remember we've run off end.
mDone = PR_TRUE;
}
PR_Unlock(mregLock);
// Convert result.
nsresult rv = regerr2nsresult( mErr );
nsresult rv = regerr2nsresult( err );
return rv;
};
@ -1175,28 +1202,40 @@ NS_IMETHODIMP nsRegValueEnumerator::advance() {
| our name. We use mErr==-1 to indicate we haven't fetched the name yet. |
------------------------------------------------------------------------------*/
nsRegistryNode::nsRegistryNode( HREG hReg, RKEY key, REGENUM slot )
: mReg( hReg ), mKey( key ), mEnum( slot ), mErr( -1 ) {
: mReg( hReg ), mKey( key ), mEnum( slot ){
NS_INIT_REFCNT();
mregLock = PR_NewLock();
return;
}
nsRegistryNode::~nsRegistryNode()
{
if (mregLock) {
PR_DestroyLock(mregLock);
}
}
/*-------------------------- nsRegistryNode::GetName ---------------------------
| If we haven't fetched it yet, get the name of the corresponding subkey now, |
| using NR_RegEnumSubkeys. |
------------------------------------------------------------------------------*/
y------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistryNode::GetName( char **result ) {
REGERR err = REGERR_OK;
nsresult rv = NS_OK;
// Make sure there is a place to put the result.
if( result ) {
// Test whether we haven't tried to get it yet.
if( mErr == -1 ) {
if( err == -1 ) {
REGENUM temp = mEnum;
// Get name.
mErr = NR_RegEnumSubkeys( mReg, mKey, &temp, mName, sizeof mName, PR_FALSE );
PR_Lock(mregLock);
err = NR_RegEnumSubkeys( mReg, mKey, &temp, mName, sizeof mName, PR_FALSE );
PR_Unlock(mregLock);
}
// Convert result from prior libreg call.
rv = regerr2nsresult( mErr );
rv = regerr2nsresult( err );
if( rv == NS_OK || rv == NS_ERROR_REG_NO_MORE ) {
// worked, return actual result.
*result = PR_strdup( mName );
@ -1218,11 +1257,19 @@ NS_IMETHODIMP nsRegistryNode::GetName( char **result ) {
| Implemented the same way as the nsRegistryNode ctor. |
------------------------------------------------------------------------------*/
nsRegistryValue::nsRegistryValue( HREG hReg, RKEY key, REGENUM slot )
: mReg( hReg ), mKey( key ), mEnum( slot ), mErr( -1 ) {
: mReg( hReg ), mKey( key ), mEnum( slot ) {
NS_INIT_REFCNT();
mregLock = PR_NewLock();
return;
}
nsRegistryValue::~nsRegistryValue()
{
if (mregLock) {
PR_DestroyLock(mregLock);
}
}
/*------------------------- nsRegistryValue::GetName ---------------------------
| See nsRegistryNode::GetName; we use NR_RegEnumEntries in this case. |
------------------------------------------------------------------------------*/
@ -1295,14 +1342,17 @@ NS_IMETHODIMP nsRegistryValue::GetValueLength( uint32 *result ) {
| Call NR_RegEnumEntries to set the mInfo/mName data members. |
------------------------------------------------------------------------------*/
nsresult nsRegistryValue::getInfo() {
REGERR err = REGERR_OK;
nsresult rv = NS_OK;
// Test whether we haven't tried to get it yet.
if( mErr == -1 ) {
if( err == -1 ) {
REGENUM temp = mEnum;
// Get name and info.
mErr = NR_RegEnumEntries( mReg, mKey, &temp, mName, sizeof mName, &mInfo );
PR_Lock(mregLock);
err = NR_RegEnumEntries( mReg, mKey, &temp, mName, sizeof mName, &mInfo );
PR_Unlock(mregLock);
// Convert result.
rv = regerr2nsresult( mErr );
rv = regerr2nsresult( err );
}
return rv;
}

234
xpcom/components/nsRegistry.cpp
Просмотреть файл

@ -77,7 +77,6 @@ struct nsRegistry : public nsIRegistry {
protected:
HREG mReg; // Registry handle.
REGERR mErr; // Last libreg error code.
PRLock *mregLock; // libreg isn't threadsafe. Use locks to synchronize.
}; // nsRegistry
@ -115,16 +114,17 @@ struct nsRegSubtreeEnumerator : public nsIEnumerator {
// ctor/dtor
nsRegSubtreeEnumerator( HREG hReg, RKEY rKey, PRBool all );
virtual ~nsRegSubtreeEnumerator();
protected:
NS_IMETHOD advance(); // Implementation file; does appropriate NR_RegEnum call.
PRLock *mregLock;
HREG mReg; // Handle to registry we're affiliated with.
RKEY mKey; // Base key being enumerated.
REGENUM mEnum; // Corresponding libreg "enumerator".
REGENUM mNext; // Lookahead value.
uint32 mStyle; // Style (indicates all or some);
PRBool mDone; // Done flag.
REGERR mErr; // Last libreg error code.
}; // nsRegSubtreeEnumerator
@ -158,12 +158,13 @@ struct nsRegistryNode : public nsIRegistryNode {
// ctor
nsRegistryNode( HREG hReg, RKEY key, REGENUM slot );
virtual ~nsRegistryNode();
protected:
HREG mReg; // Handle to registry this node is part of.
PRLock *mregLock;
RKEY mKey; // Key this node is under.
REGENUM mEnum; // Copy of corresponding content of parent enumerator.
REGERR mErr; // Last libreg error code.
char mName[MAXREGPATHLEN]; // Buffer to hold name.
}; // nsRegistryNode
@ -183,13 +184,14 @@ struct nsRegistryValue : public nsIRegistryValue {
// ctor
nsRegistryValue( HREG hReg, RKEY key, REGENUM slot );
virtual ~nsRegistryValue();
protected:
nsresult getInfo(); // Get registry info.
HREG mReg; // Handle to registry this node is part of.
PRLock *mregLock;
RKEY mKey; // Key this node is under.
REGENUM mEnum; // Copy of corresponding content of parent enumerator.
REGERR mErr; // Last libreg error code.
REGINFO mInfo; // Value info.
char mName[MAXREGNAMELEN]; // Buffer to hold name.
}; // nsRegistryValue
@ -385,6 +387,7 @@ nsRegistry::~nsRegistry() {
| it if so. |
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::Open( const char *regFile ) {
REGERR err = REGERR_OK;
// Check for default.
if( !regFile ) {
return OpenDefault();
@ -393,10 +396,10 @@ NS_IMETHODIMP nsRegistry::Open( const char *regFile ) {
Close();
// Open specified registry.
PR_Lock(mregLock);
mErr = NR_RegOpen((char*)regFile, &mReg );
err = NR_RegOpen((char*)regFile, &mReg );
PR_Unlock(mregLock);
// Convert the result.
return regerr2nsresult( mErr );
return regerr2nsresult( err );
}
/*----------------------------- nsRegistry::OpenWellKnownRegistry --------------
@ -404,20 +407,20 @@ NS_IMETHODIMP nsRegistry::Open( const char *regFile ) {
| to see if a registry file is already open and close it if so. |
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::OpenWellKnownRegistry( uint32 regid ) {
REGERR err = REGERR_OK;
// Ensure existing registry is closed.
Close();
nsSpecialSystemDirectory reg(nsSpecialSystemDirectory::OS_CurrentProcessDirectory);
nsSpecialSystemDirectory *registryLocation = NULL;
PRBool foundReg = PR_FALSE;
switch ( (WellKnownRegistry) regid ) {
case ApplicationComponentRegistry:
#ifdef XP_MAC
reg += "Component Registry";
#else
reg += "component.reg";
#endif /* XP_MAC */
foundReg = PR_TRUE;
registryLocation =
new nsSpecialSystemDirectory(nsSpecialSystemDirectory::XPCOM_CurrentProcessComponentRegistry);
if (registryLocation != NULL)
foundReg = PR_TRUE;
break;
default:
@ -431,17 +434,19 @@ NS_IMETHODIMP nsRegistry::OpenWellKnownRegistry( uint32 regid ) {
// WARNING:
// regNSPRPath and regFile need to have the same scope
// since the regFile will point to data in regNSPRPath
nsNSPRPath regNSPRPath(reg);
nsNSPRPath regNSPRPath(*registryLocation);
const char *regFile = (const char *) regNSPRPath;
#ifdef DEBUG_dp
printf("nsRegistry: Opening std registry %s\n", regFile);
#endif /* DEBUG_dp */
PR_Lock(mregLock);
mErr = NR_RegOpen((char*)regFile, &mReg );
err = NR_RegOpen((char*)regFile, &mReg );
PR_Unlock(mregLock);
// Cleanup
delete registryLocation;
// Convert the result.
return regerr2nsresult( mErr );
return regerr2nsresult( err );
}
/*-------------------------- nsRegistry::OpenDefault ---------------------------
@ -449,28 +454,29 @@ NS_IMETHODIMP nsRegistry::OpenWellKnownRegistry( uint32 regid ) {
| that is done by passing a null file name pointer to NR_RegOpen. |
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::OpenDefault() {
REGERR err = REGERR_OK;
// Ensure existing registry is closed.
Close();
// Open default registry.
PR_Lock(mregLock);
mErr = NR_RegOpen( 0, &mReg );
err = NR_RegOpen( 0, &mReg );
PR_Unlock(mregLock);
// Convert the result.
return regerr2nsresult( mErr );
return regerr2nsresult( err );
}
/*----------------------------- nsRegistry::Close ------------------------------
| Tests the mReg handle and if non-null, closes the registry via NR_RegClose. |
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::Close() {
mErr = REGERR_OK;
REGERR err = REGERR_OK;
if( mReg ) {
PR_Lock(mregLock);
mErr = NR_RegClose( mReg );
err = NR_RegClose( mReg );
PR_Unlock(mregLock);
mReg = 0;
}
return regerr2nsresult( mErr );
return regerr2nsresult( err );
}
/*--------------------------- nsRegistry::GetString ----------------------------
@ -479,6 +485,8 @@ NS_IMETHODIMP nsRegistry::Close() {
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::GetString( Key baseKey, const char *path, char **result ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Make sure caller gave us place for result.
if( result ) {
*result = 0; // Clear result.
@ -498,10 +506,10 @@ NS_IMETHODIMP nsRegistry::GetString( Key baseKey, const char *path, char **resul
if( *result ) {
// Get string from registry into result buffer.
PR_Lock(mregLock);
mErr = NR_RegGetEntryString( mReg,(RKEY)baseKey,(char*)path, *result, length+1 );
err = NR_RegGetEntryString( mReg,(RKEY)baseKey,(char*)path, *result, length+1 );
PR_Unlock(mregLock);
// Convert status.
rv = regerr2nsresult( mErr );
rv = regerr2nsresult( err );
// Test result.
if( rv != NS_OK ) {
// Didn't get result, free buffer.
@ -527,14 +535,13 @@ NS_IMETHODIMP nsRegistry::GetString( Key baseKey, const char *path, char **resul
| Simply sets the registry contents using NR_RegSetEntryString. |
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::SetString( Key baseKey, const char *path, const char *value ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Set the contents.
PR_Lock(mregLock);
mErr = NR_RegSetEntryString( mReg,(RKEY)baseKey,(char*)path,(char*)value );
err = NR_RegSetEntryString( mReg,(RKEY)baseKey,(char*)path,(char*)value );
PR_Unlock(mregLock);
// Convert result.
rv = regerr2nsresult( mErr );
return rv;
return regerr2nsresult( err );
}
/*---------------------------- nsRegistry::GetInt ------------------------------
@ -544,6 +551,7 @@ NS_IMETHODIMP nsRegistry::SetString( Key baseKey, const char *path, const char *
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::GetInt( Key baseKey, const char *path, int32 *result ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Make sure caller gave us place for result.
if( result ) {
@ -557,10 +565,10 @@ NS_IMETHODIMP nsRegistry::GetInt( Key baseKey, const char *path, int32 *result )
uint32 len = sizeof *result;
// Get int from registry into result field.
PR_Lock(mregLock);
mErr = NR_RegGetEntry( mReg,(RKEY)baseKey,(char*)path, result, &len );
err = NR_RegGetEntry( mReg,(RKEY)baseKey,(char*)path, result, &len );
PR_Unlock(mregLock);
// Convert status.
rv = regerr2nsresult( mErr );
rv = regerr2nsresult( err );
} else {
// They asked for the wrong type of value.
rv = NS_ERROR_REG_BADTYPE;
@ -576,10 +584,10 @@ NS_IMETHODIMP nsRegistry::GetInt( Key baseKey, const char *path, int32 *result )
| Write out the value as a one-element int32 array, using NR_RegSetEntry. |
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::SetInt( Key baseKey, const char *path, int32 value ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Set the contents.
PR_Lock(mregLock);
mErr = NR_RegSetEntry( mReg,
err = NR_RegSetEntry( mReg,
(RKEY)baseKey,
(char*)path,
REGTYPE_ENTRY_INT32_ARRAY,
@ -587,8 +595,7 @@ NS_IMETHODIMP nsRegistry::SetInt( Key baseKey, const char *path, int32 value ) {
sizeof value );
PR_Unlock(mregLock);
// Convert result.
rv = regerr2nsresult( mErr );
return rv;
return regerr2nsresult( err );
}
/*--------------------------- nsRegistry::GetBytes -----------------------------
@ -596,6 +603,7 @@ NS_IMETHODIMP nsRegistry::SetInt( Key baseKey, const char *path, int32 value ) {
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::GetBytes( Key baseKey, const char *path, void **result, uint32 *len ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Make sure caller gave us place for result.
if( result && len ) {
@ -609,10 +617,10 @@ NS_IMETHODIMP nsRegistry::GetBytes( Key baseKey, const char *path, void **result
// Get bytes from registry into result field.
*result = PR_Malloc(*len);
PR_Lock(mregLock);
mErr = NR_RegGetEntry( mReg,(RKEY)baseKey,(char*)path, *result, len );
err = NR_RegGetEntry( mReg,(RKEY)baseKey,(char*)path, *result, len );
PR_Unlock(mregLock);
// Convert status.
rv = regerr2nsresult( mErr );
rv = regerr2nsresult( err );
} else {
// They asked for the wrong type of value.
rv = NS_ERROR_REG_BADTYPE;
@ -628,15 +636,14 @@ NS_IMETHODIMP nsRegistry::GetBytes( Key baseKey, const char *path, void **result
| Set the contents at the specified registry location, using NR_RegSetEntry. |
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::SetBytes( Key baseKey, const char *path, void *value, uint32 len ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Set contents.
PR_Lock(mregLock);
mErr = NR_RegSetEntry( mReg,(RKEY)baseKey,(char*)path,
err = NR_RegSetEntry( mReg,(RKEY)baseKey,(char*)path,
REGTYPE_ENTRY_BYTES, value, len );
PR_Unlock(mregLock);
// Convert result;
rv = regerr2nsresult( mErr );
return rv;
return regerr2nsresult( err );
}
/*-------------------------- nsRegistry::GetIntArray ---------------------------
@ -646,6 +653,7 @@ NS_IMETHODIMP nsRegistry::SetBytes( Key baseKey, const char *path, void *value,
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::GetIntArray( Key baseKey, const char *path, int32 **result, uint32 *len ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Make sure caller gave us place for result.
if( result && len ) {
@ -666,14 +674,14 @@ NS_IMETHODIMP nsRegistry::GetIntArray( Key baseKey, const char *path, int32 **re
if( *result ) {
// Get array from registry into result field.
PR_Lock(mregLock);
mErr = NR_RegGetEntry( mReg,(RKEY)baseKey,(char*)path, *result, len );
err = NR_RegGetEntry( mReg,(RKEY)baseKey,(char*)path, *result, len );
PR_Unlock(mregLock);
// Convert status.
if( mErr == REGERR_OK ) {
if( err == REGERR_OK ) {
// Convert size in bytes to array dimension.
*len /= sizeof(int32);
} else {
rv = regerr2nsresult( mErr );
rv = regerr2nsresult( err );
// Free buffer that we allocated(error will tell caller not to).
PR_Free( *result );
*result = 0;
@ -698,45 +706,42 @@ NS_IMETHODIMP nsRegistry::GetIntArray( Key baseKey, const char *path, int32 **re
| size in bytes in order to use NR_RegSetEntry. |
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::SetIntArray( Key baseKey, const char *path, const int32 *value, uint32 len ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Convert array dimension to byte count.
uint32 size = len * sizeof(int32);
// Set contents.
PR_Lock(mregLock);
mErr = NR_RegSetEntry( mReg,(RKEY)baseKey,(char*)path,
err = NR_RegSetEntry( mReg,(RKEY)baseKey,(char*)path,
REGTYPE_ENTRY_INT32_ARRAY,(void*)value, size );
PR_Unlock(mregLock);
// Convert result.
rv = regerr2nsresult( mErr );
return rv;
return regerr2nsresult( err );
}
/*-------------------------- nsRegistry::AddSubtree ----------------------------
| Add a new registry subkey with the specified name, using NR_RegAddKey. |
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::AddSubtree( Key baseKey, const char *path, Key *result ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Add the subkey.
PR_Lock(mregLock);
mErr = NR_RegAddKey( mReg,(RKEY)baseKey,(char*)path,(RKEY*)result );
err = NR_RegAddKey( mReg,(RKEY)baseKey,(char*)path,(RKEY*)result );
PR_Unlock(mregLock);
// Convert result.
rv = regerr2nsresult( mErr );
return rv;
return regerr2nsresult( err );
}
/*-------------------------- nsRegistry::AddSubtreeRaw--------------------------
| Add a new registry subkey with the specified name, using NR_RegAddKeyRaw |
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::AddSubtreeRaw( Key baseKey, const char *path, Key *result ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Add the subkey.
PR_Lock(mregLock);
mErr = NR_RegAddKeyRaw( mReg,(RKEY)baseKey,(char*)path,(RKEY*)result );
err = NR_RegAddKeyRaw( mReg,(RKEY)baseKey,(char*)path,(RKEY*)result );
PR_Unlock(mregLock);
// Convert result.
rv = regerr2nsresult( mErr );
return rv;
return regerr2nsresult( err );
}
@ -744,14 +749,13 @@ NS_IMETHODIMP nsRegistry::AddSubtreeRaw( Key baseKey, const char *path, Key *res
| Deletes the subtree at a given location using NR_RegDeleteKey. |
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::RemoveSubtree( Key baseKey, const char *path ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Delete the subkey.
PR_Lock(mregLock);
mErr = NR_RegDeleteKey( mReg,(RKEY)baseKey,(char*)path );
err = NR_RegDeleteKey( mReg,(RKEY)baseKey,(char*)path );
PR_Unlock(mregLock);
// Convert result.
rv = regerr2nsresult( mErr );
return rv;
return regerr2nsresult( err );
}
@ -760,6 +764,7 @@ NS_IMETHODIMP nsRegistry::RemoveSubtree( Key baseKey, const char *path ) {
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::RemoveSubtreeRaw( Key baseKey, const char *keyname ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// libreg doesn't delete keys if there are subkeys under the key
// Hence we have to recurse through to delete the subtree
@ -770,7 +775,7 @@ NS_IMETHODIMP nsRegistry::RemoveSubtreeRaw( Key baseKey, const char *keyname ) {
REGENUM state = 0;
PR_Lock(mregLock);
REGERR err = NR_RegGetKeyRaw(mReg, baseKey, (char *)keyname, &key);
err = NR_RegGetKeyRaw(mReg, baseKey, (char *)keyname, &key);
PR_Unlock(mregLock);
if (err != REGERR_OK)
{
@ -811,14 +816,15 @@ NS_IMETHODIMP nsRegistry::RemoveSubtreeRaw( Key baseKey, const char *keyname ) {
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::GetSubtree( Key baseKey, const char *path, Key *result ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Make sure we have a place for the result.
if( result ) {
// Get key.
PR_Lock(mregLock);
mErr = NR_RegGetKey( mReg,(RKEY)baseKey,(char*)path,(RKEY*)result );
err = NR_RegGetKey( mReg,(RKEY)baseKey,(char*)path,(RKEY*)result );
PR_Unlock(mregLock);
// Convert result.
rv = regerr2nsresult( mErr );
rv = regerr2nsresult( err );
} else {
rv = NS_ERROR_NULL_POINTER;
}
@ -831,14 +837,15 @@ NS_IMETHODIMP nsRegistry::GetSubtree( Key baseKey, const char *path, Key *result
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::GetSubtreeRaw( Key baseKey, const char *path, Key *result ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Make sure we have a place for the result.
if( result ) {
// Get key.
PR_Lock(mregLock);
mErr = NR_RegGetKeyRaw( mReg,(RKEY)baseKey,(char*)path,(RKEY*)result );
err = NR_RegGetKeyRaw( mReg,(RKEY)baseKey,(char*)path,(RKEY*)result );
PR_Unlock(mregLock);
// Convert result.
rv = regerr2nsresult( mErr );
rv = regerr2nsresult( err );
} else {
rv = NS_ERROR_NULL_POINTER;
}
@ -902,18 +909,19 @@ NS_IMETHODIMP nsRegistry::EnumerateAllSubtrees( Key baseKey, nsIEnumerator **res
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::GetValueType( Key baseKey, const char *path, uint32 *result ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Make sure we have a place to put the result.
if( result ) {
// Get registry info into local structure.
REGINFO info = { sizeof info, 0, 0 };
PR_Lock(mregLock);
mErr = NR_RegGetEntryInfo( mReg,(RKEY)baseKey,(char*)path, &info );
err = NR_RegGetEntryInfo( mReg,(RKEY)baseKey,(char*)path, &info );
PR_Unlock(mregLock);
if( mErr == REGERR_OK ) {
if( err == REGERR_OK ) {
// Copy info to user's result value.
reginfo2DataType( info, *result );
} else {
rv = regerr2nsresult( mErr );
rv = regerr2nsresult( err );
}
} else {
rv = NS_ERROR_NULL_POINTER;
@ -927,18 +935,19 @@ NS_IMETHODIMP nsRegistry::GetValueType( Key baseKey, const char *path, uint32 *r
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::GetValueLength( Key baseKey, const char *path, uint32 *result ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Make sure we have a place to put the result.
if( result ) {
// Get registry info into local structure.
REGINFO info = { sizeof info, 0, 0 };
PR_Lock(mregLock);
mErr = NR_RegGetEntryInfo( mReg,(RKEY)baseKey,(char*)path, &info );
err = NR_RegGetEntryInfo( mReg,(RKEY)baseKey,(char*)path, &info );
PR_Unlock(mregLock);
if( mErr == REGERR_OK ) {
if( err == REGERR_OK ) {
// Copy info to user's result value.
reginfo2Length( info, *result );
} else {
rv = regerr2nsresult( mErr );
rv = regerr2nsresult( err );
}
} else {
rv = NS_ERROR_NULL_POINTER;
@ -975,14 +984,15 @@ NS_IMETHODIMP nsRegistry::EnumerateValues( Key baseKey, nsIEnumerator **result )
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::GetCurrentUserName( char **result ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Make sure we have a place to put the result.
if( result ) {
// Get the user name.
PR_Lock(mregLock);
mErr = NR_RegGetUsername( result );
err = NR_RegGetUsername( result );
PR_Unlock(mregLock);
// Convert the result.
rv = regerr2nsresult( mErr );
rv = regerr2nsresult( err );
} else {
rv = NS_ERROR_NULL_POINTER;
}
@ -994,12 +1004,13 @@ NS_IMETHODIMP nsRegistry::GetCurrentUserName( char **result ) {
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::SetCurrentUserName( const char *name ) {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Set the user name.
PR_Lock(mregLock);
mErr = NR_RegSetUsername( name );
err = NR_RegSetUsername( name );
PR_Unlock(mregLock);
// Convert result.
rv = regerr2nsresult( mErr );
rv = regerr2nsresult( err );
return rv;
}
@ -1008,12 +1019,13 @@ NS_IMETHODIMP nsRegistry::SetCurrentUserName( const char *name ) {
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistry::Pack() {
nsresult rv = NS_OK;
REGERR err = REGERR_OK;
// Pack the registry.
PR_Lock(mregLock);
mErr = NR_RegPack( mReg, 0, 0 );
err = NR_RegPack( mReg, 0, 0 );
PR_Unlock(mregLock);
// Convert result.
rv = regerr2nsresult( mErr );
rv = regerr2nsresult( err );
return rv;
}
@ -1023,11 +1035,20 @@ NS_IMETHODIMP nsRegistry::Pack() {
------------------------------------------------------------------------------*/
nsRegSubtreeEnumerator::nsRegSubtreeEnumerator( HREG hReg, RKEY rKey, PRBool all )
: mReg( hReg ), mKey( rKey ), mEnum( 0 ), mNext( 0 ),
mStyle( all ? REGENUM_DESCEND : 0 ), mDone( PR_FALSE ), mErr( -1 ) {
mStyle( all ? REGENUM_DESCEND : 0 ), mDone( PR_FALSE ) {
NS_INIT_REFCNT();
// Create a registry lock
mregLock = PR_NewLock();
return;
}
nsRegSubtreeEnumerator::~nsRegSubtreeEnumerator()
{
if (mregLock) {
PR_DestroyLock(mregLock);
}
}
/*----------------------- nsRegSubtreeEnumerator::First ------------------------
| Set mEnum to 0; this will cause the next NR_RegEnum call to go to |
| the beginning. We then do a Next() call in order to do a "lookahead" to |
@ -1074,16 +1095,19 @@ nsRegSubtreeEnumerator::Next() {
| there are no more subkeys. |
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegSubtreeEnumerator::advance() {
REGERR err = REGERR_OK;
char name[MAXREGPATHLEN];
uint32 len = sizeof name;
mErr = NR_RegEnumSubkeys( mReg, mKey, &mNext, name, len, mStyle );
PR_Lock(mregLock);
err = NR_RegEnumSubkeys( mReg, mKey, &mNext, name, len, mStyle );
// See if we ran off end.
if( mErr == REGERR_NOMORE ) {
if( err == REGERR_NOMORE ) {
// Remember we've run off end.
mDone = PR_TRUE;
}
PR_Unlock(mregLock);
// Convert result.
nsresult rv = regerr2nsresult( mErr );
nsresult rv = regerr2nsresult( err );
return rv;
};
@ -1099,7 +1123,7 @@ nsRegSubtreeEnumerator::CurrentItem( nsISupports **result) {
if( result ) {
*result = new nsRegistryNode( mReg, mKey, mEnum );
if( *result ) {
(*result)->AddRef();
(*result)->AddRef();
} else {
rv = NS_ERROR_OUT_OF_MEMORY;
}
@ -1154,17 +1178,20 @@ nsRegValueEnumerator::CurrentItem( nsISupports **result ) {
| there are no more entries. |
------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegValueEnumerator::advance() {
REGERR err = REGERR_OK;
char name[MAXREGNAMELEN];
uint32 len = sizeof name;
REGINFO info = { sizeof info, 0, 0 };
mErr = NR_RegEnumEntries( mReg, mKey, &mNext, name, len, &info );
PR_Lock(mregLock);
err = NR_RegEnumEntries( mReg, mKey, &mNext, name, len, &info );
// See if we ran off end.
if( mErr == REGERR_NOMORE ) {
if( err == REGERR_NOMORE ) {
// Remember we've run off end.
mDone = PR_TRUE;
}
PR_Unlock(mregLock);
// Convert result.
nsresult rv = regerr2nsresult( mErr );
nsresult rv = regerr2nsresult( err );
return rv;
};
@ -1175,28 +1202,40 @@ NS_IMETHODIMP nsRegValueEnumerator::advance() {
| our name. We use mErr==-1 to indicate we haven't fetched the name yet. |
------------------------------------------------------------------------------*/
nsRegistryNode::nsRegistryNode( HREG hReg, RKEY key, REGENUM slot )
: mReg( hReg ), mKey( key ), mEnum( slot ), mErr( -1 ) {
: mReg( hReg ), mKey( key ), mEnum( slot ){
NS_INIT_REFCNT();
mregLock = PR_NewLock();
return;
}
nsRegistryNode::~nsRegistryNode()
{
if (mregLock) {
PR_DestroyLock(mregLock);
}
}
/*-------------------------- nsRegistryNode::GetName ---------------------------
| If we haven't fetched it yet, get the name of the corresponding subkey now, |
| using NR_RegEnumSubkeys. |
------------------------------------------------------------------------------*/
y------------------------------------------------------------------------------*/
NS_IMETHODIMP nsRegistryNode::GetName( char **result ) {
REGERR err = REGERR_OK;
nsresult rv = NS_OK;
// Make sure there is a place to put the result.
if( result ) {
// Test whether we haven't tried to get it yet.
if( mErr == -1 ) {
if( err == -1 ) {
REGENUM temp = mEnum;
// Get name.
mErr = NR_RegEnumSubkeys( mReg, mKey, &temp, mName, sizeof mName, PR_FALSE );
PR_Lock(mregLock);
err = NR_RegEnumSubkeys( mReg, mKey, &temp, mName, sizeof mName, PR_FALSE );
PR_Unlock(mregLock);
}
// Convert result from prior libreg call.
rv = regerr2nsresult( mErr );
rv = regerr2nsresult( err );
if( rv == NS_OK || rv == NS_ERROR_REG_NO_MORE ) {
// worked, return actual result.
*result = PR_strdup( mName );
@ -1218,11 +1257,19 @@ NS_IMETHODIMP nsRegistryNode::GetName( char **result ) {
| Implemented the same way as the nsRegistryNode ctor. |
------------------------------------------------------------------------------*/
nsRegistryValue::nsRegistryValue( HREG hReg, RKEY key, REGENUM slot )
: mReg( hReg ), mKey( key ), mEnum( slot ), mErr( -1 ) {
: mReg( hReg ), mKey( key ), mEnum( slot ) {
NS_INIT_REFCNT();
mregLock = PR_NewLock();
return;
}
nsRegistryValue::~nsRegistryValue()
{
if (mregLock) {
PR_DestroyLock(mregLock);
}
}
/*------------------------- nsRegistryValue::GetName ---------------------------
| See nsRegistryNode::GetName; we use NR_RegEnumEntries in this case. |
------------------------------------------------------------------------------*/
@ -1295,14 +1342,17 @@ NS_IMETHODIMP nsRegistryValue::GetValueLength( uint32 *result ) {
| Call NR_RegEnumEntries to set the mInfo/mName data members. |
------------------------------------------------------------------------------*/
nsresult nsRegistryValue::getInfo() {
REGERR err = REGERR_OK;
nsresult rv = NS_OK;
// Test whether we haven't tried to get it yet.
if( mErr == -1 ) {
if( err == -1 ) {
REGENUM temp = mEnum;
// Get name and info.
mErr = NR_RegEnumEntries( mReg, mKey, &temp, mName, sizeof mName, &mInfo );
PR_Lock(mregLock);
err = NR_RegEnumEntries( mReg, mKey, &temp, mName, sizeof mName, &mInfo );
PR_Unlock(mregLock);
// Convert result.
rv = regerr2nsresult( mErr );
rv = regerr2nsresult( err );
}
return rv;
}