1068 lines
No EOL
25 KiB
C++
1068 lines
No EOL
25 KiB
C++
#include "StdAfx.h"
|
||
#include "SundriesFunc.h"
|
||
#include "Stream.h"
|
||
#include <stdarg.h>
|
||
#include <Windows.h>
|
||
#include <./boost/algorithm/string.hpp>
|
||
|
||
#ifdef _DEBUG
|
||
#define new new(_NORMAL_BLOCK,__FILE__,__LINE__)
|
||
#endif
|
||
|
||
#ifdef _CHECK_D3D_LEAK
|
||
struct ResStruct {
|
||
std::map<void*, std::string > resourceList;
|
||
~ResStruct() {
|
||
_ASSERT( resourceList.empty() );
|
||
}
|
||
}resStruct;
|
||
|
||
void __ADD_D3D_RES( void *pPtr , char *szFile, int nLine )
|
||
{
|
||
static std::map<std::string, int > mapLineCounter;
|
||
|
||
char szStr[4096]={0,}, szOut[4096]={0,};
|
||
sprintf(szStr, "%s -(%d)", szFile, nLine );
|
||
int nCount = mapLineCounter[ szStr ];
|
||
mapLineCounter[ szStr ]++;
|
||
|
||
int nFindKey = GetHashCode(szStr)^nCount;
|
||
|
||
//if( nFindKey == 70356109 ||
|
||
// nFindKey == 254840137 ||
|
||
// nFindKey == 120819530 ||
|
||
// nFindKey == 120819529
|
||
// )
|
||
//{
|
||
// int df = 3;
|
||
//}
|
||
|
||
sprintf(szOut, "%s - [%d]", szStr, nFindKey);
|
||
|
||
ASSERT ( resStruct.resourceList.count(pPtr ) == 0 );
|
||
resStruct.resourceList.insert( std::make_pair(pPtr, szOut) );
|
||
//OutputDebug("%X Res Add %s %d \n", pPtr, szOut, resStruct.resourceList.size() );
|
||
|
||
}
|
||
|
||
|
||
void REMOVE_D3D_RES( void *pPtr )
|
||
{
|
||
ASSERT ( resStruct.resourceList.count(pPtr ) != 0 );
|
||
std::string szTypeName = "Null";
|
||
if( resStruct.resourceList.count(pPtr ) != 0 ) {
|
||
szTypeName = resStruct.resourceList[ pPtr ];
|
||
}
|
||
resStruct.resourceList.erase( pPtr );
|
||
//OutputDebug("%X Res Remove %s %d\n", pPtr, szTypeName.c_str(), resStruct.resourceList.size() );
|
||
}
|
||
#endif
|
||
|
||
const char* _GetPath(char* pBuffer, const char* pPath)
|
||
{
|
||
strcpy_s( pBuffer, (int)strlen(pPath) + 1, pPath );
|
||
|
||
int i = (int ) strlen(pPath) - 1;
|
||
|
||
while (i >= 0) {
|
||
if (pPath[i] == '\\' || pPath[i] == '/') {
|
||
pBuffer[i + 1] = 0;
|
||
return pBuffer;
|
||
}
|
||
i--;
|
||
}
|
||
|
||
pBuffer[ 0 ] = 0;
|
||
|
||
return pBuffer;
|
||
}
|
||
|
||
|
||
const char *_GetFullFileName( char *pBuffer, const char *pString )
|
||
{
|
||
int i = (int ) strlen(pString) - 1;
|
||
|
||
int nSize = i;
|
||
while (i >= 0) {
|
||
if ( pString[i] == '\\' || pString[i] == '/') {
|
||
memcpy( pBuffer, pString + i + 1, nSize - i );
|
||
pBuffer[nSize - i] = 0;
|
||
return pBuffer;
|
||
}
|
||
|
||
i--;
|
||
}
|
||
strcpy_s( pBuffer, (int)strlen(pString)+1, pString );
|
||
|
||
return pBuffer;
|
||
|
||
}
|
||
|
||
const char *_GetExt( char *pBuffer, const char *pString )
|
||
{
|
||
int i = (int ) strlen(pString) - 1;
|
||
|
||
int nSize = i;
|
||
while (i >= 0) {
|
||
if ( pString[i] == '.' ) {
|
||
memcpy( pBuffer, pString + i + 1, nSize - i );
|
||
pBuffer[nSize - i] = 0;
|
||
return pBuffer;
|
||
}
|
||
|
||
i--;
|
||
}
|
||
pBuffer[0] = 0;
|
||
|
||
return pBuffer;
|
||
}
|
||
|
||
const char *_GetFileName( char *pBuffer, const char *pString )
|
||
{
|
||
int i = (int ) strlen(pString) - 1;
|
||
|
||
int nSize = i;
|
||
int nExtPos = -1;
|
||
while (i >= 0) {
|
||
if ( pString[i] == '\\' || pString[i] == '/') {
|
||
memcpy( pBuffer, pString + i + 1, nExtPos - i - 1 );
|
||
pBuffer[nExtPos - i - 1] = 0;
|
||
return pBuffer;
|
||
}
|
||
else if( pString[i] == '.' && nExtPos == -1 ) {
|
||
nExtPos = i;
|
||
}
|
||
|
||
i--;
|
||
}
|
||
if( nExtPos > 0 ) {
|
||
memcpy( pBuffer, pString, nExtPos );
|
||
pBuffer[nExtPos] = 0;
|
||
}
|
||
else pBuffer[0] = 0;
|
||
return pBuffer;
|
||
}
|
||
|
||
char *_CopyString( const char *szStr )
|
||
{
|
||
if( szStr == NULL ) return NULL;
|
||
int nLength = (int)strlen(szStr);
|
||
char *pResult = new char[nLength+1];
|
||
memcpy( pResult, szStr, nLength );
|
||
pResult[nLength] = 0;
|
||
|
||
return pResult;
|
||
}
|
||
|
||
std::string _GetParsePipeSafe( int nCount, char *szSor, char cCharacter )
|
||
{
|
||
// Parsing
|
||
std::string strValue(szSor);
|
||
std::vector<std::string> vSplit;
|
||
char seps[] = { cCharacter, 0 };
|
||
|
||
boost::algorithm::split( vSplit, strValue, boost::algorithm::is_any_of(seps) );
|
||
|
||
if( static_cast<int>(vSplit.size()) <= nCount )
|
||
return std::string("");
|
||
|
||
return vSplit[nCount];
|
||
}
|
||
|
||
|
||
char *_GetParsePipe( int nCount, char *szSor, char cCharacter )
|
||
{
|
||
char szStr[65535];
|
||
strcpy( szStr, szSor );
|
||
static char szResult[65535];
|
||
int nSize = (int)strlen( szStr );
|
||
|
||
int nCurCount = 0;
|
||
int nStrCount = 0;
|
||
BOOL bFlag = FALSE;
|
||
memset( szResult, 0, sizeof(szResult) );
|
||
for( int i=0; i<=nSize; i++ ) {
|
||
if( szStr[i] == cCharacter || i == nSize ) {
|
||
if( nCurCount == nCount ) {
|
||
szResult[nStrCount] = 0;
|
||
bFlag = TRUE;
|
||
break;
|
||
}
|
||
else {
|
||
nStrCount = 0;
|
||
nCurCount++;
|
||
continue;
|
||
}
|
||
}
|
||
szResult[nStrCount] = szStr[i];
|
||
nStrCount++;
|
||
}
|
||
if( bFlag == TRUE )
|
||
return szResult;
|
||
|
||
return NULL;
|
||
}
|
||
|
||
int _GetParsePipeCount( char *szSor, char cCharacter )
|
||
{
|
||
char szStr[65535];
|
||
strcpy( szStr, szSor );
|
||
int nSize = (int)strlen( szStr );
|
||
|
||
int nCurCount = 0;
|
||
for( int i=0; i<=nSize; i++ ) {
|
||
if( szStr[i] == cCharacter ) {
|
||
nCurCount++;
|
||
}
|
||
}
|
||
return nCurCount;
|
||
}
|
||
|
||
|
||
const char *_GetOriginalRandomBaseName( char *pBuffer, const char *pString )
|
||
{
|
||
char szTempName[256] = { 0, };
|
||
int nLength = (int)strlen(pString);
|
||
bool bModifyName = false;
|
||
for( int i=nLength - 1; i>=0; i-- ) {
|
||
if( pString[i] == '.' ) {
|
||
if( pString[i-2] == '_' &&
|
||
( ( pString[i-1] >= 'a' && pString[i-1] <= 'z' ) ||
|
||
( pString[i-1] >= 'A' && pString[i-1] <= 'Z' ) ) ) {
|
||
memcpy( szTempName, pString, i - 2 );
|
||
memcpy( szTempName + ( i - 2 ), pString + i, nLength - i );
|
||
szTempName[ ( i - 2 ) + nLength - i ] = 0;
|
||
bModifyName = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if( !bModifyName ) sprintf_s( pBuffer, nLength + 1, pString );
|
||
else sprintf_s( pBuffer, strlen(szTempName) + 1, szTempName );
|
||
|
||
return pBuffer;
|
||
}
|
||
|
||
void OutputDebugFunc( const char *szString, ... )
|
||
{
|
||
if( !s_pDefaultOutputDebugFunc ) return;
|
||
va_list list;
|
||
char szTemp[65535];
|
||
|
||
va_start( list, szString );
|
||
vsprintf_s( szTemp, szString, list );
|
||
s_pDefaultOutputDebugFunc( szTemp );
|
||
va_end( list );
|
||
}
|
||
|
||
void _OutputDebug( const char *szString, ... )
|
||
{
|
||
va_list list;
|
||
static char szTemp[65535];
|
||
|
||
va_start( list, szString );
|
||
vsprintf_s( szTemp, szString, list );
|
||
OutputDebugString( szTemp );
|
||
va_end( list );
|
||
}
|
||
|
||
|
||
void SetOutputDebugFuncPtr( void (__stdcall *Func)(const char*, ...) )
|
||
{
|
||
s_pDefaultOutputDebugFunc = Func;
|
||
}
|
||
|
||
int NavigateDirectory( const char *pDir, const char *pFileName, char *pTargetBuffer )
|
||
{
|
||
char szFindFile[ _MAX_PATH ], szReturn[ _MAX_PATH ];
|
||
WIN32_FIND_DATA FindFileData;
|
||
HANDLE hFind;
|
||
|
||
strcpy( szFindFile, pDir );
|
||
strcat( szFindFile, pFileName );
|
||
|
||
hFind = FindFirstFile( szFindFile, &FindFileData );
|
||
if( hFind != INVALID_HANDLE_VALUE )
|
||
{
|
||
if( pTargetBuffer ) {
|
||
strcpy( pTargetBuffer, pDir );
|
||
strcat( pTargetBuffer, FindFileData.cFileName );
|
||
}
|
||
FindClose( hFind );
|
||
return 1;
|
||
}
|
||
|
||
strcpy( szReturn, pDir );
|
||
strcat( szReturn, "*.*" );
|
||
hFind = FindFirstFile( szReturn, &FindFileData );
|
||
while( hFind != INVALID_HANDLE_VALUE )
|
||
{
|
||
if( ( FindFileData.cFileName[ 0 ] != '.' ) && ( FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) )
|
||
{
|
||
strcpy( szReturn, pDir );
|
||
strcat( szReturn, FindFileData.cFileName );
|
||
strcat( szReturn, "\\" );
|
||
if( NavigateDirectory( szReturn, pFileName, pTargetBuffer ) )
|
||
{
|
||
return 1;
|
||
}
|
||
}
|
||
if( !FindNextFile( hFind, &FindFileData ) )
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
if( hFind != INVALID_HANDLE_VALUE )
|
||
{
|
||
FindClose( hFind );
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
int FindFileInDirectory( const char *pFindDir, const char *pFileName, char *pTargetBuffer )
|
||
{
|
||
const char *pFindPtr;
|
||
|
||
pFindPtr = strrchr( pFileName, '\\' );
|
||
if( pFindPtr == NULL )
|
||
{
|
||
pFindPtr = pFileName;
|
||
}
|
||
else
|
||
{
|
||
pFindPtr++;
|
||
}
|
||
|
||
return NavigateDirectory( pFindDir, pFindPtr, pTargetBuffer );
|
||
}
|
||
|
||
LONG GetRegistryNumber(HKEY hKey, char *pSubKey, char *pValueName, DWORD &dwValue)
|
||
{
|
||
HKEY hReg;
|
||
DWORD dwType=REG_DWORD, dwOption=REG_CREATED_NEW_KEY;
|
||
LONG lRet;
|
||
DWORD dwSize=sizeof(DWORD);
|
||
|
||
lRet=RegOpenKeyEx(hKey, pSubKey, NULL, KEY_ALL_ACCESS, &hReg);
|
||
if(lRet!=ERROR_SUCCESS){
|
||
lRet=RegCreateKeyEx(hKey, pSubKey, NULL, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hReg, &dwOption);
|
||
if(lRet!=ERROR_SUCCESS){
|
||
return lRet;
|
||
}
|
||
}
|
||
lRet=RegQueryValueEx(hReg, pValueName, NULL, &dwType, (unsigned char*)&dwValue, &dwSize);
|
||
RegCloseKey(hReg);
|
||
|
||
return lRet;
|
||
}
|
||
|
||
LONG SetRegistryNumber(HKEY hKey, char *pSubKey, char *pValueName, DWORD dwValue)
|
||
{
|
||
HKEY hReg;
|
||
DWORD dwType=REG_DWORD, dwOption=REG_CREATED_NEW_KEY;
|
||
LONG lRet;
|
||
DWORD dwSize=sizeof(DWORD);
|
||
|
||
lRet=RegOpenKeyEx(hKey, pSubKey, NULL, KEY_ALL_ACCESS, &hReg);
|
||
if(lRet!=ERROR_SUCCESS){
|
||
lRet=RegCreateKeyEx(hKey, pSubKey, NULL, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hReg, &dwOption);
|
||
if(lRet!=ERROR_SUCCESS){
|
||
return lRet;
|
||
}
|
||
}
|
||
lRet=RegSetValueEx(hReg, pValueName, NULL, dwType, (unsigned char*)&dwValue, dwSize);
|
||
RegCloseKey(hReg);
|
||
|
||
return lRet;
|
||
}
|
||
|
||
|
||
LONG GetRegistryString(HKEY hKey, char *pSubKey, char *pValueName, char *pValue, int nMaxLength )
|
||
{
|
||
HKEY hReg;
|
||
DWORD dwType=REG_SZ, dwOption=REG_CREATED_NEW_KEY;
|
||
LONG lRet;
|
||
DWORD dwSize = nMaxLength ? nMaxLength : 512;
|
||
|
||
lRet=RegOpenKeyEx(hKey, pSubKey, NULL, KEY_ALL_ACCESS, &hReg);
|
||
if(lRet!=ERROR_SUCCESS){
|
||
lRet=RegCreateKeyEx(hKey, pSubKey, NULL, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hReg, &dwOption);
|
||
if(lRet!=ERROR_SUCCESS){
|
||
return lRet;
|
||
}
|
||
}
|
||
lRet=RegQueryValueEx(hReg, pValueName, NULL, &dwType, (unsigned char*)pValue, &dwSize);
|
||
RegCloseKey(hReg);
|
||
|
||
return lRet;
|
||
}
|
||
|
||
LONG SetRegistryString(HKEY hKey, char *pSubKey, char *pValueName, char *pValue )
|
||
{
|
||
HKEY hReg;
|
||
DWORD dwType=REG_SZ, dwOption=REG_CREATED_NEW_KEY;
|
||
LONG lRet;
|
||
DWORD dwSize = (DWORD)strlen( pValue );
|
||
|
||
lRet=RegOpenKeyEx(hKey, pSubKey, NULL, KEY_ALL_ACCESS, &hReg);
|
||
if(lRet!=ERROR_SUCCESS){
|
||
lRet=RegCreateKeyEx(hKey, pSubKey, NULL, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hReg, &dwOption);
|
||
if(lRet!=ERROR_SUCCESS){
|
||
return lRet;
|
||
}
|
||
}
|
||
lRet=RegSetValueEx(hReg, pValueName, NULL, dwType, (unsigned char*)pValue, dwSize);
|
||
RegCloseKey(hReg);
|
||
|
||
return lRet;
|
||
}
|
||
|
||
LONG GetRegistryBinary(HKEY hKey, char *pSubKey, char *pValueName, void *pValue, int &nSize )
|
||
{
|
||
HKEY hReg;
|
||
DWORD dwType=REG_BINARY, dwOption=REG_CREATED_NEW_KEY;
|
||
LONG lRet;
|
||
|
||
lRet=RegOpenKeyEx(hKey, pSubKey, NULL, KEY_ALL_ACCESS, &hReg);
|
||
if(lRet!=ERROR_SUCCESS){
|
||
lRet=RegCreateKeyEx(hKey, pSubKey, NULL, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hReg, &dwOption);
|
||
if(lRet!=ERROR_SUCCESS){
|
||
return lRet;
|
||
}
|
||
}
|
||
lRet=RegQueryValueEx(hReg, pValueName, NULL, &dwType, (unsigned char*)pValue, (DWORD*)&nSize);
|
||
RegCloseKey(hReg);
|
||
|
||
return lRet;
|
||
}
|
||
|
||
LONG SetRegistryBinary(HKEY hKey, char *pSubKey, char *pValueName, void *pValue, int nSize )
|
||
{
|
||
HKEY hReg;
|
||
DWORD dwType=REG_BINARY, dwOption=REG_CREATED_NEW_KEY;
|
||
LONG lRet;
|
||
|
||
lRet=RegOpenKeyEx(hKey, pSubKey, NULL, KEY_ALL_ACCESS, &hReg);
|
||
if(lRet!=ERROR_SUCCESS){
|
||
lRet=RegCreateKeyEx(hKey, pSubKey, NULL, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &hReg, &dwOption);
|
||
if(lRet!=ERROR_SUCCESS){
|
||
return lRet;
|
||
}
|
||
}
|
||
lRet=RegSetValueEx(hReg, pValueName, NULL, dwType, (unsigned char*)pValue, nSize);
|
||
RegCloseKey(hReg);
|
||
|
||
return lRet;
|
||
}
|
||
|
||
LONG DeleteRegistry( HKEY hKey, char *pSubKey )
|
||
{
|
||
HKEY newKey;
|
||
char newSubKey[MAX_PATH];
|
||
LONG Result;
|
||
DWORD Size;
|
||
FILETIME FileTime;
|
||
|
||
RegOpenKeyEx(hKey, pSubKey, 0, KEY_ALL_ACCESS, &newKey);
|
||
Result = ERROR_SUCCESS;
|
||
while(TRUE) {
|
||
Size = MAX_PATH;
|
||
Result = RegEnumKeyEx(newKey, 0, newSubKey, &Size, NULL, NULL, NULL, &FileTime);
|
||
if (Result != ERROR_SUCCESS) break;
|
||
Result = DeleteRegistry(newKey, newSubKey);
|
||
if (Result != ERROR_SUCCESS) break;
|
||
|
||
}
|
||
RegCloseKey(newKey);
|
||
return RegDeleteKey(hKey, pSubKey);
|
||
}
|
||
|
||
LONG AddRegistryKey( HKEY hKey, char *pSubKey, char *pValueName )
|
||
{
|
||
HKEY newKey;
|
||
char newSubKey[MAX_PATH];
|
||
DWORD dwDisp;
|
||
sprintf_s( newSubKey, "%s\\%s", pSubKey, pValueName );
|
||
LONG Result = RegCreateKeyEx( hKey, newSubKey, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, &newKey, &dwDisp );
|
||
|
||
return Result;
|
||
}
|
||
|
||
void FindFileListInDirectory( const char *szFolderName, const char *szExt, std::vector<CFileNameString> &szVecResult, bool bIncludeFolder, bool bSearchSubDir, bool bIncludeFolderName )
|
||
{
|
||
WIN32_FIND_DATA FindFileData;
|
||
HANDLE hFind;
|
||
char szFindFile[512];
|
||
|
||
sprintf_s( szFindFile, "%s\\%s", szFolderName, szExt );
|
||
|
||
hFind = FindFirstFile( szFindFile, &FindFileData );
|
||
while( hFind != INVALID_HANDLE_VALUE ) {
|
||
if( !( FindFileData.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN ) ) {
|
||
if( !( FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) || bIncludeFolder == true ) {
|
||
if( bIncludeFolderName )
|
||
{
|
||
char szFullName[ _MAX_PATH ];
|
||
sprintf_s( szFullName, "%s\\%s", szFolderName, FindFileData.cFileName );
|
||
szVecResult.push_back( szFullName );
|
||
}
|
||
else
|
||
{
|
||
szVecResult.push_back( CFileNameString( FindFileData.cFileName ) );
|
||
}
|
||
}
|
||
if( ( FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) && bSearchSubDir == true ) {
|
||
if( strcmp( FindFileData.cFileName, "." ) && strcmp( FindFileData.cFileName, ".." ) ) {
|
||
char szFolder[512] = { 0, };
|
||
sprintf_s( szFolder, "%s\\%s", szFolderName, FindFileData.cFileName );
|
||
FindFileListInDirectory( szFolder, szExt, szVecResult, bIncludeFolder, bSearchSubDir, bIncludeFolderName );
|
||
}
|
||
}
|
||
}
|
||
if( !FindNextFile( hFind, &FindFileData ) ) break;
|
||
|
||
}
|
||
|
||
FindClose( hFind );
|
||
}
|
||
|
||
void FindFileListInDirectory( const char *szFolderName, const char *szExt, std::vector<std::string> &szVecResult, bool bIncludeFolder, bool bSearchSubDir, bool bIncludeFolderName )
|
||
{
|
||
WIN32_FIND_DATA FindFileData;
|
||
HANDLE hFind;
|
||
char szFindFile[512];
|
||
|
||
sprintf_s( szFindFile, "%s\\%s", szFolderName, szExt );
|
||
|
||
hFind = FindFirstFile( szFindFile, &FindFileData );
|
||
while( hFind != INVALID_HANDLE_VALUE ) {
|
||
if( !( FindFileData.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN ) ) {
|
||
if( !( FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) || bIncludeFolder == true ) {
|
||
if( bIncludeFolderName )
|
||
{
|
||
char szFullName[ _MAX_PATH ];
|
||
sprintf_s( szFullName, "%s\\%s", szFolderName, FindFileData.cFileName );
|
||
szVecResult.push_back( szFullName );
|
||
}
|
||
else
|
||
{
|
||
szVecResult.push_back( std::string( FindFileData.cFileName ) );
|
||
}
|
||
}
|
||
if( ( FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) && bSearchSubDir == true ) {
|
||
if( strcmp( FindFileData.cFileName, "." ) && strcmp( FindFileData.cFileName, ".." ) ) {
|
||
char szFolder[512] = { 0, };
|
||
sprintf_s( szFolder, "%s\\%s", szFolderName, FindFileData.cFileName );
|
||
FindFileListInDirectory( szFolder, szExt, szVecResult, bIncludeFolder, bSearchSubDir, bIncludeFolderName );
|
||
}
|
||
}
|
||
}
|
||
if( !FindNextFile( hFind, &FindFileData ) ) break;
|
||
|
||
}
|
||
|
||
FindClose( hFind );
|
||
}
|
||
|
||
void _FindFolder( const char *szFolderName, std::vector<CFileNameString> &szVecResult, bool bSearchSubDir, char *szRootPathName )
|
||
{
|
||
WIN32_FIND_DATA FindFileData;
|
||
HANDLE hFind;
|
||
char szFindFile[512];
|
||
|
||
sprintf_s( szFindFile, "%s\\*.*", szFolderName );
|
||
|
||
hFind = FindFirstFile( szFindFile, &FindFileData );
|
||
while( hFind != INVALID_HANDLE_VALUE ) {
|
||
if( FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) {
|
||
if( !( FindFileData.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN ) && strcmp( ".", FindFileData.cFileName ) && strcmp( "..", FindFileData.cFileName ) ) {
|
||
if( bSearchSubDir && szRootPathName && strcmp( szFolderName, szRootPathName ) ) {
|
||
char szTemp[512];
|
||
int nOffset = (int)strlen( szRootPathName ) + 1;
|
||
sprintf_s( szTemp, "%s\\%s", szFolderName + nOffset, FindFileData.cFileName );
|
||
szVecResult.push_back( szTemp );
|
||
}
|
||
else szVecResult.push_back( FindFileData.cFileName );
|
||
|
||
if( bSearchSubDir ) {
|
||
char szTemp[512];
|
||
sprintf_s( szTemp, "%s\\%s", szFolderName, FindFileData.cFileName );
|
||
_FindFolder( szTemp, szVecResult, bSearchSubDir, szRootPathName );
|
||
}
|
||
}
|
||
}
|
||
|
||
if( !FindNextFile( hFind, &FindFileData ) ) break;
|
||
}
|
||
|
||
FindClose( hFind );
|
||
}
|
||
|
||
void _FindFolder( const char *szFolderName, std::vector<std::string> &szVecResult, bool bSearchSubDir, char *szRootPathName )
|
||
{
|
||
WIN32_FIND_DATA FindFileData;
|
||
HANDLE hFind;
|
||
char szFindFile[512];
|
||
|
||
sprintf_s( szFindFile, "%s\\*.*", szFolderName );
|
||
|
||
hFind = FindFirstFile( szFindFile, &FindFileData );
|
||
while( hFind != INVALID_HANDLE_VALUE ) {
|
||
if( FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) {
|
||
if( !( FindFileData.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN ) && strcmp( ".", FindFileData.cFileName ) && strcmp( "..", FindFileData.cFileName ) ) {
|
||
if( bSearchSubDir && szRootPathName && strcmp( szFolderName, szRootPathName ) ) {
|
||
char szTemp[512];
|
||
int nOffset = (int)strlen( szRootPathName ) + 1;
|
||
sprintf_s( szTemp, "%s\\%s", szFolderName + nOffset, FindFileData.cFileName );
|
||
szVecResult.push_back( szTemp );
|
||
}
|
||
else szVecResult.push_back( FindFileData.cFileName );
|
||
|
||
if( bSearchSubDir ) {
|
||
char szTemp[512];
|
||
sprintf_s( szTemp, "%s\\%s", szFolderName, FindFileData.cFileName );
|
||
_FindFolder( szTemp, szVecResult, bSearchSubDir, szRootPathName );
|
||
}
|
||
}
|
||
}
|
||
|
||
if( !FindNextFile( hFind, &FindFileData ) ) break;
|
||
}
|
||
|
||
FindClose( hFind );
|
||
}
|
||
|
||
bool _CopyFile( const char *pSource, const char *pTarget, bool bExistOverwrite, bool bMoveFile )
|
||
{
|
||
char szSorPath[512] = { 0, };
|
||
char szSorExt[256] = { 0, };
|
||
|
||
_GetPath( szSorPath, pSource );
|
||
_GetFullFileName( szSorExt, pSource );
|
||
|
||
std::vector<CFileNameString> szVecList;
|
||
FindFileListInDirectory( szSorPath, szSorExt, szVecList, false );
|
||
|
||
char szStr[512] = { 0, };
|
||
char szStr2[512] = { 0, };
|
||
bool bResult = true;
|
||
for( DWORD i=0; i<szVecList.size(); i++ ) {
|
||
sprintf_s( szStr, "%s%s", szSorPath, szVecList[i].c_str() );
|
||
sprintf_s( szStr2, "%s\\%s", pTarget, szVecList[i].c_str() );
|
||
if( CopyFile( szStr, szStr2, !bExistOverwrite ) == false ) bResult = false;
|
||
else {
|
||
if( bMoveFile ) DeleteFile( szStr );
|
||
}
|
||
}
|
||
return bResult;
|
||
}
|
||
|
||
void DeleteFolder( const char *pFolder )
|
||
{
|
||
char szFindFile[ _MAX_PATH ];
|
||
WIN32_FIND_DATA FindData;
|
||
HANDLE hFind;
|
||
|
||
strcpy_s( szFindFile, _MAX_PATH, pFolder );
|
||
strcat_s( szFindFile, _MAX_PATH, "\\*.*" );
|
||
hFind = FindFirstFile( szFindFile, &FindData );
|
||
while( hFind != INVALID_HANDLE_VALUE )
|
||
{
|
||
if( FindData.cFileName[ 0 ] != '.' )
|
||
{
|
||
char szFullName[ _MAX_PATH ];
|
||
strcpy_s( szFullName, _MAX_PATH, pFolder );
|
||
strcat_s( szFullName, _MAX_PATH, "\\" );
|
||
strcat_s( szFullName, _MAX_PATH, FindData.cFileName );
|
||
if( FindData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )
|
||
{
|
||
DeleteFolder( szFullName );
|
||
}
|
||
else
|
||
{
|
||
DeleteFile( szFullName );
|
||
}
|
||
}
|
||
if( !FindNextFile( hFind, &FindData ) )
|
||
{
|
||
FindClose( hFind );
|
||
RemoveDirectory( pFolder );
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
void CreateFolder( const char *pFolder )
|
||
{
|
||
char szPath[ _MAX_PATH ], *pFindPtr;
|
||
|
||
strcpy_s( szPath, _MAX_PATH, pFolder );
|
||
if( szPath[ strlen( szPath ) -1 ] != '\\' )
|
||
{
|
||
strcat_s( szPath, _MAX_PATH, "\\" );
|
||
}
|
||
pFindPtr = szPath;
|
||
while( 1 )
|
||
{
|
||
pFindPtr = strchr( pFindPtr, '\\' );
|
||
if( pFindPtr == NULL )
|
||
{
|
||
break;
|
||
}
|
||
if( *( pFindPtr - 1 ) != ':' )
|
||
{
|
||
*pFindPtr = 0;
|
||
CreateDirectory( szPath, NULL );
|
||
*pFindPtr = '\\';
|
||
}
|
||
pFindPtr++;
|
||
}
|
||
}
|
||
|
||
void GetFullPath( const char *pSource, char *pTarget )
|
||
{
|
||
strcpy( pTarget, pSource );
|
||
if( pTarget[ strlen( pTarget ) - 1 ] != '\\' )
|
||
{
|
||
strcat( pTarget, "\\" );
|
||
}
|
||
}
|
||
|
||
const char *FindFileName( const char *pFullName )
|
||
{
|
||
const char *pFindPtr;
|
||
|
||
pFindPtr = strrchr( pFullName, '\\' );
|
||
if( pFindPtr )
|
||
{
|
||
return pFindPtr + 1;
|
||
}
|
||
else
|
||
{
|
||
return pFullName;
|
||
}
|
||
}
|
||
|
||
bool IsFullName( const char *pFileName )
|
||
{
|
||
if( pFileName[ 1 ] == ':' )
|
||
{
|
||
return true;
|
||
}
|
||
else if( pFileName[0] == '\\' && pFileName[1] == '\\' )
|
||
{
|
||
return true;
|
||
}
|
||
else
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
#ifndef WIN64
|
||
void SSE_memcpy(void *pDest,void *pSrc,long nCnt)
|
||
{
|
||
__asm
|
||
{
|
||
mov ecx , nCnt
|
||
shr ecx , 4
|
||
|
||
mov edi , pDest
|
||
mov esi , pSrc
|
||
|
||
Loop_S2 :
|
||
movdqu xmm0 , [esi]
|
||
movdqu [edi] , xmm0
|
||
add edi,16
|
||
add esi,16
|
||
loop Loop_S2
|
||
|
||
// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD> ó<><C3B3>
|
||
mov ecx, nCnt
|
||
and ecx, 15
|
||
rep movsb
|
||
}
|
||
}
|
||
#endif
|
||
|
||
void ReadStdString( std::string &szStr, CStream *pStream )
|
||
{
|
||
int nSize;
|
||
char szBuf[4096] = {0,};
|
||
pStream->Read( &nSize, sizeof(int) );
|
||
if( nSize )
|
||
{
|
||
if( nSize >= 4096 ) nSize = 4095;
|
||
pStream->Read( szBuf, nSize );
|
||
szBuf[ nSize ] = '\0';
|
||
}
|
||
|
||
szStr.clear();
|
||
szStr = szBuf;
|
||
}
|
||
|
||
void WriteStdString( std::string &szStr, CStream *pStream )
|
||
{
|
||
int nSize;
|
||
|
||
nSize = ( int )szStr.size();
|
||
if( nSize )
|
||
{
|
||
nSize++;
|
||
pStream->Write( &nSize, sizeof( int ) );
|
||
pStream->Write( szStr.c_str(), nSize );
|
||
}
|
||
else
|
||
{
|
||
pStream->Write( &nSize, sizeof( int ) );
|
||
}
|
||
}
|
||
|
||
|
||
int GetOSVersionType()
|
||
{
|
||
OSVERSIONINFOEX osvi;
|
||
ZeroMemory(&osvi, sizeof(OSVERSIONINFOEX));
|
||
osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
|
||
|
||
BOOL bOsVersionInfoEx;
|
||
if( !(bOsVersionInfoEx = GetVersionEx ((OSVERSIONINFO *) &osvi)) )
|
||
{
|
||
osvi.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
|
||
if (! GetVersionEx ( (OSVERSIONINFO *) &osvi) )
|
||
return -1;
|
||
}
|
||
|
||
UINT nOSVersion(-1);
|
||
|
||
switch (osvi.dwPlatformId)
|
||
{
|
||
case VER_PLATFORM_WIN32_WINDOWS:
|
||
if (osvi.dwMajorVersion == 4 )
|
||
{
|
||
switch( osvi.dwMinorVersion )
|
||
{
|
||
case 0: nOSVersion = 1; break;
|
||
case 10: nOSVersion = 2; break;
|
||
case 90: nOSVersion = 3; break;
|
||
}
|
||
}
|
||
break;
|
||
case VER_PLATFORM_WIN32_NT:
|
||
{
|
||
if( osvi.dwMajorVersion <= 4 )
|
||
{
|
||
nOSVersion = 4;
|
||
}
|
||
else if( osvi.dwMajorVersion == 5 )
|
||
{
|
||
switch( osvi.dwMinorVersion )
|
||
{
|
||
case 0: nOSVersion = 5; break;
|
||
case 1: nOSVersion = 6; break;
|
||
case 2: nOSVersion = 7; break;
|
||
}
|
||
}
|
||
else if( osvi.dwMajorVersion == 6 )
|
||
{
|
||
switch(osvi.dwMinorVersion)
|
||
{
|
||
case 0: nOSVersion = 8; break;
|
||
case 1: nOSVersion = 9; break;
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
}
|
||
|
||
return nOSVersion;
|
||
}
|
||
|
||
unsigned long GetHashCode( const char* String )
|
||
{
|
||
unsigned long i,len;
|
||
unsigned long ch;
|
||
unsigned long result;
|
||
unsigned long XOR;
|
||
|
||
len = ( long )strlen( String );
|
||
result = 0;
|
||
XOR = 0;
|
||
for( i=0; i<len; i++ )
|
||
{
|
||
ch = (unsigned long)String[i];
|
||
result = ( ( result << 8 ) | ch ) % 16777213UL; // 16777213UL
|
||
XOR ^= ch;
|
||
}
|
||
|
||
return result | ( XOR << 24 );
|
||
}
|
||
|
||
INT64 GetHashCode64( const char* String )
|
||
{
|
||
unsigned long i,len;
|
||
INT64 ch;
|
||
INT64 result;
|
||
INT64 XOR;
|
||
INT64 temp = 0;
|
||
|
||
len = ( long )strlen( String );
|
||
result = 0;
|
||
XOR = 0;
|
||
for( i=0; i<len; i++ )
|
||
{
|
||
ch = (INT64)( String[i] * String[i] );
|
||
temp += ch;
|
||
result = ( ( result << 8 ) | ch ) % 0x00fffffffffffffd; // 16777213UL
|
||
XOR ^= ch;
|
||
}
|
||
|
||
return ( result | ( XOR << 48 ) ) + temp;
|
||
}
|
||
|
||
bool ExecCommand( char *pCommand, std::string *pszOutput )
|
||
{
|
||
HANDLE hReadPipe, hWritePipe;
|
||
SECURITY_ATTRIBUTES SecurityAttr;
|
||
|
||
memset( &SecurityAttr, 0, sizeof( SECURITY_ATTRIBUTES ) );
|
||
SecurityAttr.nLength = sizeof( SECURITY_ATTRIBUTES );
|
||
SecurityAttr.bInheritHandle = TRUE;
|
||
|
||
if( pszOutput )
|
||
{
|
||
CreatePipe( &hReadPipe, &hWritePipe, &SecurityAttr, 0 );
|
||
}
|
||
|
||
STARTUPINFO sInfo;
|
||
PROCESS_INFORMATION pInfo;
|
||
memset( &sInfo, 0, sizeof( sInfo ) );
|
||
memset( &pInfo, 0, sizeof( pInfo ) );
|
||
sInfo.cb = sizeof( sInfo );
|
||
if( pszOutput )
|
||
{
|
||
sInfo.dwFlags=STARTF_USESTDHANDLES;
|
||
sInfo.hStdInput=NULL;
|
||
sInfo.hStdOutput=hWritePipe;
|
||
sInfo.hStdError=hWritePipe;
|
||
}
|
||
DWORD dwFlags = NORMAL_PRIORITY_CLASS;
|
||
if( pszOutput ) dwFlags |= CREATE_NO_WINDOW;
|
||
if( CreateProcess( 0, pCommand, 0, 0, TRUE, dwFlags, 0, 0, &sInfo, &pInfo) )
|
||
{
|
||
if( pszOutput )
|
||
{
|
||
char cBuffer[ 65536 ];
|
||
DWORD dwReadSize;
|
||
*pszOutput = "";
|
||
CloseHandle( hWritePipe );
|
||
while( 1 )
|
||
{
|
||
memset( cBuffer, 0, 65536 );
|
||
::ReadFile( hReadPipe, cBuffer, 65535, &dwReadSize, 0 );
|
||
if( dwReadSize <= 0 )
|
||
{
|
||
break;
|
||
}
|
||
*pszOutput += cBuffer;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
void SetBitFlag( char *pBuffer, int nArrayIndex, bool bFlag )
|
||
{
|
||
int nBitSet = 7 - ( nArrayIndex % 8 );
|
||
if( bFlag ) pBuffer[nArrayIndex/8] |= ( (char)1<<nBitSet );
|
||
else pBuffer[nArrayIndex/8] &= ~( (char)1<<nBitSet );
|
||
}
|
||
|
||
bool GetBitFlag( char *pBuffer, int nArrayIndex )
|
||
{
|
||
int nBitSet = ( nArrayIndex % 8 );
|
||
return ( (char)( ( ( ( pBuffer[nArrayIndex/8] << nBitSet ) & 0xff ) >> 7 ) & 0xff ) == 1 ) ? true : false;
|
||
}
|
||
|
||
void (__stdcall *s_pDefaultOutputDebugFunc)(const char*, ...) = _OutputDebug;
|
||
|
||
int GetDateValue( int nYear, int nMonth, int nDay )
|
||
{
|
||
int nResult = 0;
|
||
for( int i=2009; i<nYear; i++ ) {
|
||
bool bLeapMonth = false;
|
||
// int nValue = ( i - 1583 ) + 1;
|
||
if( i % 4 == 0 ) bLeapMonth = true;
|
||
if( i % 100 == 0 ) bLeapMonth = false;
|
||
if( i % 400 == 0 ) bLeapMonth = true;
|
||
|
||
if( bLeapMonth ) nResult += 366;
|
||
else nResult += 365;
|
||
}
|
||
|
||
bool bLeapMonth = false;
|
||
// int nValue = ( nYear - 1583 ) + 1;
|
||
if( nYear % 4 == 0 ) bLeapMonth = true;
|
||
if( nYear % 100 == 0 ) bLeapMonth = false;
|
||
if( nYear % 400 == 0 ) bLeapMonth = true;
|
||
int nDayCount[12] = { 31, ( bLeapMonth == true ) ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
|
||
|
||
for( int i=0; i<nMonth - 1; i++ ) {
|
||
nResult += nDayCount[i];
|
||
}
|
||
nResult += nDay;
|
||
|
||
return nResult;
|
||
}
|
||
|
||
bool DnLocalTime_s( struct tm * _Tm, const time_t * _Time )
|
||
{
|
||
if( *_Time < 0 || *_Time > 0x793406fffi64 ) return false;
|
||
return ( localtime_s( _Tm, _Time ) ) ? false : true;
|
||
}
|
||
|
||
int GetValue2ExceptionSwap( int nValue, int nSwapValueCount, ... )
|
||
{
|
||
int nResult = nValue;
|
||
va_list marker;
|
||
|
||
va_start( marker, nSwapValueCount ); /* Initialize variable arguments. */
|
||
for( int i=0; i<nSwapValueCount; i++ ) {
|
||
int nValue1 = va_arg( marker, int );
|
||
int nValue2 = va_arg( marker, int );
|
||
|
||
if( nResult == nValue1 ) {
|
||
nResult = nValue2;
|
||
break;
|
||
}
|
||
else if( nResult == nValue2 ) {
|
||
nResult = nValue1;
|
||
break;
|
||
}
|
||
}
|
||
return nResult;
|
||
}
|
||
|
||
DWORD CalcDecreaseColor( DWORD OrigColor, DWORD DescColor )
|
||
{
|
||
int nOrigA = OrigColor >> 24;
|
||
int nOrigR = ( OrigColor << 8 ) >> 24;
|
||
int nOrigG = ( OrigColor << 16 ) >> 24;
|
||
int nOrigB = ( OrigColor << 24 ) >> 24;
|
||
|
||
int nA = DescColor >> 24;
|
||
int nR = ( DescColor << 8 ) >> 24;
|
||
int nG = ( DescColor << 16 ) >> 24;
|
||
int nB = ( DescColor << 24 ) >> 24;
|
||
|
||
nOrigA = max( nOrigA - nA, 0 );
|
||
nOrigR = max( nOrigR - nR, 0 );
|
||
nOrigG = max( nOrigG - nG, 0 );
|
||
nOrigB = max( nOrigB - nB, 0 );
|
||
|
||
return ((DWORD)((((nOrigA)&0xff)<<24)|(((nOrigG)&0xff)<<16)|(((nOrigG)&0xff)<<8)|((nOrigB)&0xff)));
|
||
} |