bool RegistryAccess::GetRegValue( const RString &sKey, const RString &sName, RString &sVal )
{
HKEY hKey = OpenRegKey( sKey, READ );
if( hKey == NULL )
return false;
char sBuffer[MAX_PATH];
DWORD iSize = sizeof(sBuffer);
DWORD iType;
LONG iRet = RegQueryValueEx( hKey, sName, NULL, &iType, (LPBYTE)sBuffer, &iSize );
RegCloseKey( hKey );
if( iRet != ERROR_SUCCESS )
return false;
/* Actually, CStrings are 8-bit clean, so we can accept any type of data. Remove
* this if that becomes useful. */
if( iType != REG_SZ && iType != REG_MULTI_SZ && iType != REG_EXPAND_SZ && iType != REG_BINARY )
return false; /* type mismatch */
if( iSize && (iType == REG_SZ || iType == REG_MULTI_SZ || iType == REG_EXPAND_SZ) )
--iSize; /* remove nul terminator */
sVal = RString( sBuffer, iSize );
return true;
}
Shortcuts::Shortcuts()
{
HKEY hNewKey = OpenRegKey(FolderShortcutsKeyTest);
if (hNewKey == NULL)
{
for(size_t i = 0; i < KeyCount; i++)
{
FormatString ValueName;
ValueName << RecTypeName[PSCR_RT_SHORTCUT] << i;
string strValue;
if(!GetRegKey(OldFolderShortcutsKey, ValueName, strValue, L""))
continue;
ValueName.Clear();
ShortcutItem* Item = Items[i].Push();
Item->strFolder = strValue;
ValueName << RecTypeName[PSCR_RT_PLUGINMODULE] << i;
GetRegKey(OldFolderShortcutsKey, ValueName, Item->strPluginModule, L"");
ValueName.Clear();
ValueName << RecTypeName[PSCR_RT_PLUGINFILE] << i;
GetRegKey(OldFolderShortcutsKey, ValueName, Item->strPluginFile, L"");
ValueName.Clear();
ValueName << RecTypeName[PSCR_RT_PLUGINDATA] << i;
GetRegKey(OldFolderShortcutsKey, ValueName, Item->strPluginData, L"");
ValueName.Clear();
}
return;
}
for(size_t i = 0; i < KeyCount; i++)
{
FormatString strFolderShortcuts;
strFolderShortcuts << FolderShortcutsKey << i;
if (!CheckRegKey(strFolderShortcuts))
continue;
for(size_t j=0; ; j++)
{
FormatString ValueName;
ValueName << RecTypeName[PSCR_RT_SHORTCUT] << j;
string strValue;
if(!GetRegKey(strFolderShortcuts, ValueName, strValue, L""))
break;
ValueName.Clear();
ShortcutItem* Item = Items[i].Push();
Item->strFolder = strValue;
ValueName << RecTypeName[PSCR_RT_PLUGINMODULE] << j;
GetRegKey(strFolderShortcuts, ValueName, Item->strPluginModule, L"");
ValueName.Clear();
ValueName << RecTypeName[PSCR_RT_PLUGINFILE] << j;
GetRegKey(strFolderShortcuts, ValueName, Item->strPluginFile, L"");
ValueName.Clear();
ValueName << RecTypeName[PSCR_RT_PLUGINDATA] << j;
GetRegKey(strFolderShortcuts, ValueName, Item->strPluginData, L"");
ValueName.Clear();
}
}
}
// проверить существование ключа
BOOL CheckRegKey(HKEY hRoot,TCHAR *Key)
{
HKEY hKey=OpenRegKey(hRoot,Key);
if(hKey!=NULL)
RegCloseKey(hKey);
return(hKey!=NULL);
}
bool RegistryRW::KeyExist(const std::string& path ,long &ret) const
{
HKEY key;
ret = OpenRegKey(path,key);
if (ret == ERROR_SUCCESS)
{
RegCloseKey(key);
return true;
}
return false;
}
BOOL DeleteRegValue(HKEY hkBase, char *szKeyName, char *szValueName) {
HKEY hkey;
BOOL success;
if (!(hkey = OpenRegKey(hkBase, szKeyName)))
return FALSE;
success = (RegDeleteValue(hkey, szValueName) == ERROR_SUCCESS);
RegCloseKey(hkey);
return success;
}
bool CStartupInfo::QueryRegKeyValue(HKEY parentKey, const CSysString &keyName,
LPCTSTR valueName, bool valueDefault) const
{
NRegistry::CKey regKey;
if (OpenRegKey(parentKey, keyName, regKey) != ERROR_SUCCESS)
return valueDefault;
bool value;
if(regKey.QueryValue(valueName, value) != ERROR_SUCCESS)
return valueDefault;
return value;
}
int GetRegKey(HKEY hRoot,const char *Key,const char *ValueName,int &ValueData,DWORD Default)
{
HKEY hKey=OpenRegKey(hRoot,Key);
DWORD Type,Size=sizeof(ValueData);
int ExitCode=RegQueryValueEx(hKey,ValueName,0,&Type,(BYTE *)&ValueData,&Size);
RegCloseKey(hKey);
if (hKey==NULL || ExitCode!=ERROR_SUCCESS)
{
ValueData=Default;
return FALSE;
}
return TRUE;
}
BOOL GetRegKey(const char *ValueName,int *ValueData,DWORD Default)
{
hKey=OpenRegKey();
DWORD Type,Size=sizeof(*ValueData);
int ExitCode=RegQueryValueEx(hKey,ValueName,0,&Type,(BYTE *)ValueData,&Size);
RegCloseKey(hKey);
if (hKey==NULL || ExitCode!=ERROR_SUCCESS)
{
*ValueData=Default;
return(FALSE);
}
return(TRUE);
}
int GetRegKeyStr(HKEY hRoot, wchar_t *Key, wchar_t *ValueName, wchar_t *ValueData, wchar_t *Default, DWORD DataSize)
{
HKEY hKey=OpenRegKey(hRoot, Key);
DWORD Type;
int ExitCode=RegQueryValueExW(hKey, ValueName, 0, &Type, (BYTE*)ValueData, &DataSize);
RegCloseKey(hKey);
if (hKey==NULL || ExitCode!=ERROR_SUCCESS)
{
wcscpy(ValueData, Default);
return(FALSE);
}
return(TRUE);
}
int GetRegKeyInt(HKEY hRoot, wchar_t *Key, wchar_t *ValueName, int *ValueData, DWORD Default)
{
HKEY hKey=OpenRegKey(hRoot, Key);
DWORD Type, Size=sizeof(ValueData);
int ExitCode=RegQueryValueExW(hKey, ValueName, 0, &Type, (BYTE *)ValueData, &Size);
RegCloseKey(hKey);
if (hKey==NULL || ExitCode!=ERROR_SUCCESS)
{
*ValueData=Default;
return(FALSE);
}
return(TRUE);
}
int GetRegKey(HKEY hRoot,const char *Key,const char *ValueName,char *ValueData,const char *Default,DWORD DataSize)
{
HKEY hKey=OpenRegKey(hRoot,Key);
DWORD Type;
int ExitCode=RegQueryValueEx(hKey,ValueName,0,&Type,(BYTE*)ValueData,&DataSize);
RegCloseKey(hKey);
if (hKey==NULL || ExitCode!=ERROR_SUCCESS)
{
lstrcpy(ValueData,Default);
return FALSE;
}
return TRUE;
}
BOOL QueryRegString(HKEY hkBase, char *szKeyName, char *szValueName, char *lpBuffer, int cbBuffer) {
HKEY hkey;
BOOL success;
DWORD type;
if (!(hkey = OpenRegKey(hkBase, szKeyName)))
return FALSE;
success = (ERROR_SUCCESS == RegQueryValueEx(hkey, szValueName, 0, &type, (LPBYTE)lpBuffer, (LPDWORD)&cbBuffer));
RegCloseKey(hkey);
return success;
}
long RegistryRW::DeleteKey(const std::string& path,const std::string& subKey) const
{
HKEY key;
long
ret = OpenRegKey(path,key);
if (ret!=ERROR_SUCCESS) return ret;
#ifdef _WIN32
ret =RegDeleteKeyEx(key, subKey.c_str(), KEY_WOW64_32KEY, 0);
#else
ret= RegDeleteKeyEx(key, subKey.c_str(), KEY_WOW64_64KEY, 0);
#endif
return ret;
}
int RegistryRW::Get_numKeyItems(const std::string& path) const
{
HKEY hkey;
DWORD numItems = 0;
DWORD biggest;
long ret ;
ret = OpenRegKey(path,hkey);
if (ret != ERROR_SUCCESS)
{
CreateErrorMsg(ret,true);
return -1; //error
}
GetInfoKey(hkey,numItems,biggest);
return numItems;
}
int GetRegKey(HKEY hRoot, BOOL bEx, const TCHAR *Key,const TCHAR *ValueName,CString &ValueData,TCHAR *Default)
{
HKEY hKey=OpenRegKey(hRoot, bEx, Key);
DWORD Type;
DWORD DataSize = 1000;
int ExitCode=RegQueryValueEx(hKey,ValueName,0,&Type,(LPBYTE)ValueData.GetBuffer(1000),&DataSize);
ValueData.ReleaseBuffer();
RegCloseKey(hKey);
if (hKey==NULL || ExitCode!=ERROR_SUCCESS)
{
ValueData = Default;
return(FALSE);
}
return(TRUE);
}
bool RegistryAccess::SetRegValue( const RString &sKey, const RString &sName, bool bVal )
{
HKEY hKey = OpenRegKey( sKey, WRITE );
if( hKey == NULL )
return false;
bool bSuccess = true;
if (::RegSetValueEx(hKey, LPCTSTR(sName), 0,
REG_BINARY, (LPBYTE)&bVal, sizeof(bVal))
!= ERROR_SUCCESS)
bSuccess = false;
::RegCloseKey(hKey);
return bSuccess;
}
int GetRegKeyArr(HKEY hRoot, wchar_t *Key, wchar_t *ValueName, BYTE *ValueData, BYTE *Default, DWORD DataSize)
{
HKEY hKey=OpenRegKey(hRoot, Key);
DWORD Type;
int ExitCode=RegQueryValueExW(hKey, ValueName, 0, &Type, ValueData, &DataSize);
RegCloseKey(hKey);
if (hKey==NULL || ExitCode!=ERROR_SUCCESS)
{
if (Default!=NULL)
memcpy(ValueData, Default, DataSize);
else
memset(ValueData, 0, DataSize);
return(FALSE);
}
return(TRUE);
}
int GetRegKey(HKEY hRoot, BOOL bEx, const TCHAR *Key,const TCHAR *ValueName,BYTE *ValueData,BYTE *Default,DWORD DataSize)
{
HKEY hKey=OpenRegKey(hRoot, bEx, Key);
DWORD Type,Required=DataSize;
int ExitCode=RegQueryValueEx(hKey,ValueName,0,&Type,ValueData,&Required);
RegCloseKey(hKey);
if (hKey==NULL || ExitCode!=ERROR_SUCCESS)
{
if (Default!=NULL)
my_memcpy(ValueData,Default,DataSize);
else
my_memset(ValueData,0,DataSize);
return(FALSE);
}
return(DataSize);
}
// получить данные типа char*
int GetRegKey(HKEY hRoot,TCHAR *Key,TCHAR *ValueName,TCHAR *ValueData,TCHAR *Default,DWORD DataSize)
{
HKEY hKey=OpenRegKey(hRoot,Key);
DWORD Type;
DWORD Size = DataSize * sizeof(TCHAR);
int ExitCode=RegQueryValueEx(hKey,ValueName,0,&Type,(LPBYTE)ValueData,&Size);
ValueData[DataSize - 1] = 0;
RegCloseKey(hKey);
if(hKey==NULL || ExitCode!=ERROR_SUCCESS)
{
StringCchCopy(ValueData,DataSize,Default);
return(FALSE);
}
return(TRUE);
}
BOOL
CRegistryCfg::DeleteValue(LPCTSTR szContainer, LPCTSTR szValueName)
{
BOOL bCreate(FALSE);
HKEY hKey = OpenRegKey(m_hCfgRootKey, szContainer, KEY_SET_VALUE);
if (INVALID_HANDLE_VALUE == hKey) {
return FALSE;
}
LONG lResult = ::RegDeleteValue(hKey, szValueName);
if (ERROR_SUCCESS != lResult) {
::SetLastError(lResult);
::RegCloseKey(hKey);
return FALSE;
}
::RegCloseKey(hKey);
return TRUE;
}
int GetRegKey(const wchar_t *Key,const wchar_t *ValueName,BYTE *ValueData,const BYTE *Default,DWORD DataSize,DWORD *pType)
{
int ExitCode=!ERROR_SUCCESS;
HKEY hKey=OpenRegKey(Key);
DWORD Required=DataSize;
if (hKey)
{
DWORD Type;
ExitCode=RegQueryValueEx(hKey,ValueName,0,&Type,ValueData,&Required);
if (ExitCode == ERROR_MORE_DATA) // если размер не подходящие...
{
char *TempBuffer=new char[Required+1]; // ...то выделим сколько надо
if (TempBuffer) // Если с памятью все нормально...
{
if ((ExitCode=RegQueryValueEx(hKey,ValueName,0,&Type,(unsigned char *)TempBuffer,&Required)) == ERROR_SUCCESS)
memcpy(ValueData,TempBuffer,DataSize); // скопируем сколько надо.
delete[] TempBuffer;
}
}
if (pType)
*pType=Type;
CloseRegKey(hKey);
}
if (ExitCode!=ERROR_SUCCESS)
{
if (Default)
memcpy(ValueData,Default,DataSize);
else
memset(ValueData,0,DataSize);
return 0;
}
return(Required);
}
bool RegistryAccess::GetRegValue( const RString &sKey, const RString &sName, int &iVal, bool bWarnOnError )
{
HKEY hKey = OpenRegKey( sKey, READ, bWarnOnError );
if( hKey == NULL )
return false;
DWORD iValue;
DWORD iSize = sizeof(iValue);
DWORD iType;
LONG iRet = RegQueryValueEx( hKey, sName, NULL, &iType, (LPBYTE) &iValue, &iSize );
RegCloseKey( hKey );
if( iRet != ERROR_SUCCESS )
return false;
if( iType != REG_DWORD )
return false; /* type mismatch */
iVal = iValue;
return true;
}
int GetRegKey(const wchar_t *Key,const wchar_t *ValueName,int &ValueData,DWORD Default)
{
int ExitCode=!ERROR_SUCCESS;
HKEY hKey=OpenRegKey(Key);
if (hKey)
{
DWORD Type,Size=sizeof(ValueData);
ExitCode=RegQueryValueEx(hKey,ValueName,0,&Type,(BYTE *)&ValueData,&Size);
CloseRegKey(hKey);
}
if (ExitCode!=ERROR_SUCCESS)
{
ValueData=Default;
return FALSE;
}
return TRUE;
}
bool RegistryAccess::SetRegValue( const RString &sKey, const RString &sName, const RString &sVal )
{
HKEY hKey = OpenRegKey( sKey, WRITE );
if( hKey == NULL )
return false;
bool bSuccess = true;
TCHAR sz[255];
if( sVal.size() > 254 )
return false;
strcpy( sz, sVal.c_str() );
LONG lResult = ::RegSetValueEx(hKey, LPCTSTR(sName), 0, REG_SZ, (LPBYTE)sz, strlen(sz) + 1);
if( lResult != ERROR_SUCCESS )
bSuccess = false;
::RegCloseKey(hKey);
return bSuccess;
}
int GetRegKey(const wchar_t *Key,const wchar_t *ValueName,string &strValueData,const wchar_t *Default,DWORD *pType)
{
int ExitCode=!ERROR_SUCCESS;
HKEY hKey=OpenRegKey(Key);
if (hKey) // надобно проверить!
{
DWORD Type,QueryDataSize=0;
if ((ExitCode = RegQueryValueEx(
hKey,
ValueName,
0,
&Type,
nullptr,
&QueryDataSize
)) == ERROR_SUCCESS)
{
wchar_t *TempBuffer = strValueData.GetBuffer(QueryDataSize/sizeof(wchar_t)+1); // ...то выделим сколько надо
ExitCode = RegQueryValueEx(hKey,ValueName,0,&Type,(unsigned char *)TempBuffer,&QueryDataSize);
strValueData.ReleaseBuffer(QueryDataSize/sizeof(wchar_t));
if (strValueData.GetLength() > 0 && !strValueData.At(strValueData.GetLength()-1))
strValueData.SetLength(strValueData.GetLength()-1);
}
if (pType)
*pType=Type;
CloseRegKey(hKey);
}
if (ExitCode!=ERROR_SUCCESS)
{
strValueData = Default;
return FALSE;
}
return TRUE;
}
bool RegistryAccess::GetRegSubKeys( const RString &sKey, vector<RString> &lst, const RString ®ex, bool bReturnPathToo )
{
HKEY hKey = OpenRegKey( sKey, READ );
if( hKey == NULL )
return false;
Regex re(regex);
bool bError = false;
for( int index = 0; ; ++index )
{
FILETIME ft;
char szBuffer[MAX_PATH];
DWORD iSize = sizeof(szBuffer);
LONG iRet = RegEnumKeyEx( hKey, index, szBuffer, &iSize, NULL, NULL, NULL, &ft);
if( iRet == ERROR_NO_MORE_ITEMS )
break;
if( iRet != ERROR_SUCCESS )
{
LOG->Warn( werr_ssprintf(iRet, "GetRegSubKeys(%p,%i) error", hKey, index) );
bError = true;
break;
}
RString sStr( szBuffer, iSize );
if( re.Compare(sStr) )
{
if( bReturnPathToo )
sStr = sKey + "\\" + sStr;
lst.push_back( sStr );
}
}
RegCloseKey( hKey );
return !bError;
}
void KillRegVal( const char *Key, const char *ValueName )
{
HKEY hKey = OpenRegKey( Key );
RegDeleteValue( hKey, ValueName );
RegCloseKey( hKey );
}
// ValueData, DataType = GetRegKey (Root, Key, ValueName [, samDesired])
// Root: [string], one of "HKLM", "HKCC", "HKCR", "HKCU", "HKU"
// Key: registry key, [string]
// ValueName: registry value name, [string]
// samDesired: access mask, [flag] ("KEY_WOW64_32KEY" or "KEY_WOW64_64KEY"; the default is 0)
// Returns:
// ValueData: registry value data, [string | number | lstring]
// DataType: "string", "expandstring", "multistring", "dword" or "binary", [string]
static int win_GetRegKey(lua_State *L)
{
HKEY hKey;
DWORD datatype, datasize;
char *data;
LONG ret;
HKEY hRoot = CheckHKey(L, 1);
wchar_t* Key = (wchar_t*)check_utf8_string(L, 2, NULL);
const wchar_t* ValueName = check_utf8_string(L, 3, NULL);
REGSAM samDesired = (REGSAM) OptFlags(L, 4, 0);
hKey = OpenRegKey(hRoot, Key, samDesired);
if(hKey == NULL)
{
lua_pushnil(L);
lua_pushstring(L, "OpenRegKey failed.");
return 2;
}
RegQueryValueExW(hKey, ValueName, NULL, &datatype, NULL, &datasize);
data = (char*) malloc(datasize);
ret = RegQueryValueExW(hKey, ValueName, NULL, &datatype, (BYTE*)data, &datasize);
RegCloseKey(hKey);
if(ret != ERROR_SUCCESS)
{
lua_pushnil(L);
lua_pushstring(L, "RegQueryValueEx failed.");
}
else
{
switch(datatype)
{
case REG_BINARY:
lua_pushlstring(L, data, datasize);
lua_pushstring(L, "binary");
break;
case REG_DWORD:
lua_pushinteger(L, *(int*)data);
lua_pushstring(L, "dword");
break;
case REG_SZ:
push_utf8_string(L, (wchar_t*)data, -1);
lua_pushstring(L, "string");
break;
case REG_EXPAND_SZ:
push_utf8_string(L, (wchar_t*)data, -1);
lua_pushstring(L, "expandstring");
break;
case REG_MULTI_SZ:
push_utf8_string(L, (wchar_t*)data, datasize/sizeof(wchar_t));
lua_pushstring(L, "multistring");
break;
default:
lua_pushnil(L);
lua_pushstring(L, "unsupported value type");
break;
}
}
free(data);
return 2;
}
bool History::ReadHistory(bool bOnlyLines)
{
HKEY hKey=OpenRegKey(strRegKey);
if (!hKey)
return false;
bool ret = false;
wchar_t *TypesBuffer=nullptr;
wchar_t *LocksBuffer=nullptr;
FILETIME *TimesBuffer=nullptr;
wchar_t *Buffer=nullptr;
int Position=-1;
DWORD Size=sizeof(Position);
DWORD Type;
if (!bOnlyLines)
RegQueryValueEx(hKey,L"Position",0,&Type,(BYTE *)&Position,&Size);
bool NeedReadType=false;
bool NeedReadLock=false;
bool NeedReadTime=false;
Size=0;
if (!bOnlyLines && SaveType && RegQueryValueEx(hKey,L"Types",0,&Type,nullptr,&Size)==ERROR_SUCCESS && Size>0)
{
NeedReadType=true;
Size=Max(Size,(DWORD)((HistoryCount+2)*sizeof(wchar_t)));
TypesBuffer=(wchar_t *)xf_malloc(Size);
if (TypesBuffer)
{
memset(TypesBuffer,0,Size);
if (RegQueryValueEx(hKey,L"Types",0,&Type,(BYTE *)TypesBuffer,&Size)!=ERROR_SUCCESS)
goto end;
}
else
goto end;
}
Size=0;
if (!bOnlyLines && RegQueryValueEx(hKey,L"Locks",0,&Type,nullptr,&Size)==ERROR_SUCCESS && Size>0)
{
NeedReadLock=true;
Size=Max(Size,(DWORD)((HistoryCount+2)*sizeof(wchar_t)));
LocksBuffer=(wchar_t *)xf_malloc(Size);
if (LocksBuffer)
{
memset(LocksBuffer,0,Size);
if (RegQueryValueEx(hKey,L"Locks",0,&Type,(BYTE *)LocksBuffer,&Size)!=ERROR_SUCCESS)
goto end;
}
else
goto end;
}
Size=0;
if (!bOnlyLines && RegQueryValueEx(hKey,L"Times",0,&Type,nullptr,&Size)==ERROR_SUCCESS && Size>0)
{
NeedReadTime=true;
Size=Max(Size,(DWORD)((HistoryCount+2)*sizeof(FILETIME)));
TimesBuffer=(FILETIME *)xf_malloc(Size);
if (TimesBuffer)
{
memset(TimesBuffer,0,Size);
if (RegQueryValueEx(hKey,L"Times",0,&Type,(BYTE *)TimesBuffer,&Size)!=ERROR_SUCCESS)
goto end;
}
else
goto end;
}
Size=0;
if (RegQueryValueEx(hKey,L"Lines",0,&Type,nullptr,&Size)!=ERROR_SUCCESS || !Size) // Нету ничерта
{
ret = true;
goto end;
}
if (!(Buffer=(wchar_t*)xf_malloc(Size)))
goto end;
if (RegQueryValueEx(hKey,L"Lines",0,&Type,(unsigned char *)Buffer,&Size)==ERROR_SUCCESS)
{
CurrentItem=nullptr;
wchar_t *TypesBuf=TypesBuffer;
wchar_t *LockBuf=LocksBuffer;
FILETIME *TimeBuf=TimesBuffer;
size_t StrPos=0;
wchar_t *Buf=Buffer;
Size/=sizeof(wchar_t);
Buf[Size-1]=0; //safety
while (Size > 1 && StrPos < HistoryCount)
{
int Length=StrLength(Buf)+1;
HistoryRecord AddRecord;
AddRecord.strName = Buf;
Buf+=Length;
Size-=Length;
if (NeedReadType)
{
if (iswdigit(*TypesBuf))
{
AddRecord.Type = *TypesBuf-L'0';
TypesBuf++;
}
}
if (NeedReadLock)
{
if (iswdigit(*LockBuf))
{
AddRecord.Lock = (*LockBuf-L'0')? true:false;
LockBuf++;
}
}
if (NeedReadTime)
{
AddRecord.Timestamp.dwLowDateTime=TimeBuf->dwLowDateTime;
AddRecord.Timestamp.dwHighDateTime=TimeBuf->dwHighDateTime;
TimeBuf++;
}
if (AddRecord.strName.GetLength())
{
HistoryList.Unshift(&AddRecord);
if (StrPos == static_cast<size_t>(Position))
CurrentItem=HistoryList.First();
}
StrPos++;
}
}
else
goto end;
ret=true;
end:
RegCloseKey(hKey);
if (TypesBuffer)
xf_free(TypesBuffer);
if (Buffer)
xf_free(Buffer);
if (LocksBuffer)
xf_free(LocksBuffer);
if (TimesBuffer)
xf_free(TimesBuffer);
//if (!ret)
//clear();
return ret;
}
