--- /dev/null
+/* Character Code Encoding: "WHITE SQUARE" is \81 */\r
+/* The source file was composed by module mixer */ \r
+\r
+#include "include_c.h"\r
+\r
+\r
+ \r
+/*=================================================================*/\r
+/* <<< [Global0/Global0.c] >>> */ \r
+/*=================================================================*/\r
+ \r
+/***********************************************************************\r
+ <<< [Globals_initConst] >>> \r
+************************************************************************/\r
+\r
+void Globals_initConst()\r
+{\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Globals_initialize] >>> \r
+************************************************************************/\r
+int Globals_initialize()\r
+{\r
+ int e;\r
+\r
+ e= Locale_init(); IF(e)goto fin;\r
+\r
+ e=0;\r
+ goto fin; // for avoid warning of no goto fin\r
+fin:\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Globals_finalize] >>> \r
+************************************************************************/\r
+int Globals_finalize( int e )\r
+{\r
+\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/*=================================================================*/\r
+/* <<< [PlatformSDK_plus/PlatformSDK_plus.c] >>> */ \r
+/*=================================================================*/\r
+ \r
+/***********************************************************************\r
+ <<< [GetCommandLineUnnamed] >>> \r
+************************************************************************/\r
+int GetCommandLineUnnamed( int Index1, TCHAR* out_AParam, size_t AParamSize )\r
+{\r
+ TCHAR* line = GetCommandLine();\r
+ int index;\r
+ TCHAR* p;\r
+ TCHAR* p2;\r
+ TCHAR c;\r
+\r
+ #if UNDER_CE\r
+ Index1 --;\r
+ #endif\r
+ IF( Index1 < 0 ) goto err_nf;\r
+ index = Index1;\r
+\r
+ p = line;\r
+\r
+ for (;;) {\r
+ while ( *p == _T(' ') ) p++;\r
+\r
+ c = *p;\r
+\r
+ if ( c == _T('\0') ) goto err_nf; // Here is not decided to error or not\r
+\r
+\r
+ //=== Skip named option\r
+ else if ( c == _T('/') ) {\r
+ p++;\r
+ for (;;) {\r
+ c = *p;\r
+ if ( c == _T('"') || c == _T(' ') || c == _T('\0') ) break;\r
+ p++;\r
+ }\r
+\r
+ if ( c == _T('"') ) {\r
+ p++;\r
+ while ( *p != _T('"') && *p != _T('\0') ) p++;\r
+ if ( *p == _T('"') ) p++;\r
+ }\r
+ }\r
+\r
+ //=== Skip or Get unnamed parameter\r
+ else {\r
+ while ( *p == _T(' ') ) p++;\r
+\r
+ c = *p;\r
+ p2 = p + 1;\r
+\r
+ if ( c == _T('"') ) {\r
+ p ++;\r
+ while ( *p2 != _T('"') && *p2 != _T('\0') ) p2++;\r
+ }\r
+ else {\r
+ while ( *p2 != _T(' ') && *p2 != _T('\0') ) p2++;\r
+ }\r
+\r
+ if ( index == 0 ) {\r
+ int e;\r
+\r
+ e= stcpy_part_r( out_AParam, AParamSize, out_AParam, NULL, p, p2 );\r
+ ASSERT_D( !e, __noop() );\r
+ return e;\r
+ }\r
+ else {\r
+ p = ( *p2 == _T('"') ) ? p2+1 : p2;\r
+ index --;\r
+ }\r
+ }\r
+ }\r
+\r
+err_nf:\r
+ if ( AParamSize >= sizeof(TCHAR) ) *out_AParam = _T('\0');\r
+ IF ( Index1 >= 2 ) return E_NOT_FOUND_SYMBOL;\r
+ return 0;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [GetCommandLineNamed] >>> \r
+************************************************************************/\r
+int GetCommandLineNamed_sub( const TCHAR* Name, bool bCase, bool* out_IsExist, TCHAR* out_Value, size_t ValueSize );\r
+\r
+int GetCommandLineNamed( const TCHAR* Name, bool bCase, TCHAR* out_Value, size_t ValueSize )\r
+{\r
+ bool is_exist;\r
+ return GetCommandLineNamed_sub( Name, bCase, &is_exist, out_Value, ValueSize );\r
+}\r
+\r
+\r
+int GetCommandLineNamed_sub( const TCHAR* Name, bool bCase, bool* out_IsExist, TCHAR* out_Value, size_t ValueSize )\r
+{\r
+ TCHAR* line = GetCommandLine();\r
+ TCHAR* p;\r
+ TCHAR* p2;\r
+ TCHAR c;\r
+ const size_t name_len = _tcslen( Name );\r
+ bool bMatch;\r
+\r
+ *out_IsExist = true;\r
+\r
+ p = line;\r
+ for (;;) {\r
+ c = *p;\r
+\r
+ //=== Compare option name\r
+ if ( c == _T('/') ) {\r
+ p++;\r
+ p2 = p;\r
+ for (;;) {\r
+ c = *p2;\r
+ if ( c == _T(':') || c == _T(' ') || c == _T('\0') ) break;\r
+ p2++;\r
+ }\r
+ if ( bCase )\r
+ bMatch = ( p2-p == (int)name_len && _tcsncmp( p, Name, p2-p ) == 0 );\r
+ else\r
+ bMatch = ( p2-p == (int)name_len && _tcsnicmp( p, Name, p2-p ) == 0 );\r
+\r
+\r
+ //=== Get the value\r
+ if ( c == _T(':') ) {\r
+ p = p2 + 1;\r
+ if ( *p == _T('"') ) {\r
+ p++;\r
+ p2 = p;\r
+ while ( *p2 != _T('"') && *p2 != _T('\0') ) p2++;\r
+ if ( bMatch )\r
+ return stcpy_part_r( out_Value, ValueSize, out_Value, NULL, p, p2 );\r
+ else\r
+ p = p2+1;\r
+ }\r
+ else {\r
+ p2 = p;\r
+ while ( *p2 != _T(' ') && *p2 != _T('\0') ) p2++;\r
+ if ( bMatch )\r
+ return stcpy_part_r( out_Value, ValueSize, out_Value, NULL, p, p2 );\r
+ else\r
+ p = p2;\r
+ }\r
+ }\r
+ else {\r
+ IF( bMatch ) return E_NOT_FOUND_SYMBOL; // no value error\r
+ }\r
+ }\r
+\r
+ else if ( c == _T('\0') ) break;\r
+\r
+ //=== Skip\r
+ else if ( c == _T('"') ) {\r
+ p++;\r
+ while ( *p != _T('"') && *p != _T('\0') ) p++;\r
+ while ( *p != _T(' ') && *p != _T('\0') ) p++;\r
+ }\r
+ else {\r
+ while ( *p != _T(' ') && *p != _T('\0') ) p++;\r
+ }\r
+ while ( *p == _T(' ') ) p++;\r
+ }\r
+\r
+ *out_IsExist = false;\r
+ return E_NOT_FOUND_SYMBOL;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [GetCommandLineNamedI] >>> \r
+************************************************************************/\r
+int GetCommandLineNamedI( const TCHAR* Name, bool bCase, int* out_Value )\r
+{\r
+ int e;\r
+ bool is_exist;\r
+ TCHAR s[20];\r
+\r
+ e= GetCommandLineNamed_sub( Name, bCase, &is_exist, s, sizeof(s) ); IF(e)goto fin; //[out] s\r
+ if ( s[0] == _T('0') && s[1] == _T('x') )\r
+ *out_Value = _tcstoul( s, NULL, 16 );\r
+ else\r
+ *out_Value = _ttoi( s );\r
+ //e=0;\r
+fin:\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [GetCommandLineNamedC8] >>> \r
+************************************************************************/\r
+#if _UNICODE\r
+int GetCommandLineNamedC8( const TCHAR* Name, bool bCase, char* out_Value, size_t ValueSize )\r
+{\r
+ int e;\r
+ bool is_exist;\r
+ TCHAR* s = NULL;\r
+\r
+ s = (TCHAR*) malloc( ValueSize * sizeof(TCHAR) );\r
+ e= GetCommandLineNamed_sub( Name, bCase, &is_exist, (TCHAR*) s, ValueSize * sizeof(TCHAR) ); IF(e)goto fin;\r
+\r
+ sprintf_s( out_Value, ValueSize, "%S", s );\r
+fin:\r
+ if ( s != NULL ) free( s );\r
+ return e;\r
+}\r
+#endif\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [GetCommandLineExist] >>> \r
+************************************************************************/\r
+bool GetCommandLineExist( const TCHAR* Name, bool bCase )\r
+{\r
+ int e;\r
+ bool is_exist;\r
+ TCHAR v[1];\r
+\r
+ e = GetCommandLineNamed_sub( Name, bCase, &is_exist, v, sizeof(v) );\r
+ if ( e == E_NOT_FOUND_SYMBOL ) ClearError();\r
+ return is_exist;\r
+}\r
+\r
+\r
+ \r
+/*=================================================================*/\r
+/* <<< [Locale/Locale.c] >>> */ \r
+/*=================================================================*/\r
+ \r
+/***********************************************************************\r
+ <<< [g_LocaleSymbol] >>> \r
+************************************************************************/\r
+char* g_LocaleSymbol = "";\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Locale_init] >>> \r
+************************************************************************/\r
+int Locale_init()\r
+{\r
+ g_LocaleSymbol = ".OCP";\r
+ setlocale( LC_ALL, ".OCP" );\r
+ return 0;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Locale_isInited] >>> \r
+************************************************************************/\r
+int Locale_isInited()\r
+{\r
+ return ( g_LocaleSymbol[0] != '\0' );\r
+ // \82±\82±\82ª false \82ð\95Ô\82·\82Æ\82«\82Ì\91Î\8f\88\96@\82Í\81ALocale_isInited \82Ì\83w\83\8b\83v\82ð\8eQ\8fÆ\82µ\82Ä\82\82¾\82³\82¢\81B\r
+}\r
+\r
+\r
+ \r
+/*=================================================================*/\r
+/* <<< [IniFile2/IniFile2.c] >>> */ \r
+/*=================================================================*/\r
+ \r
+/***********************************************************************\r
+ <<< [IniStr_isLeft] >>> \r
+************************************************************************/\r
+bool IniStr_isLeft( const TCHAR* line, const TCHAR* symbol )\r
+{\r
+ const TCHAR* p;\r
+ size_t symbol_len = _tcslen( symbol );\r
+\r
+ /* Skip spaces at the top of line */\r
+ for ( p = line; *p == _T(' ') || *p == _T('\t'); p++ );\r
+\r
+ /* Compare symbol */\r
+ if ( _tcsnicmp( p, symbol, symbol_len ) != 0 ) return false;\r
+\r
+ switch ( *(p + symbol_len) ) {\r
+ case _T(' '): case _T('\t'): case _T('='): return true;\r
+ default: return false;\r
+ }\r
+}\r
+\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [IniStr_refRight] >>> \r
+************************************************************************/\r
+TCHAR* IniStr_refRight( const TCHAR* line, bool bTrimRight )\r
+{\r
+ const TCHAR* p;\r
+\r
+ for ( p = line; *p != _T('\0') && *p != _T('='); p++ );\r
+ if ( *p == _T('=') ) {\r
+\r
+ //=== Skip spaces at the right of equal. Trim the left of value\r
+ for ( p++ ; *p == _T(' ') || *p == _T('\t'); p++ );\r
+\r
+ //=== Trim the right of value\r
+ if ( bTrimRight ) {\r
+ const TCHAR* t;\r
+ TCHAR c;\r
+\r
+ t = StrT_chr( p, _T('\0') );\r
+ if ( t != p ) {\r
+ for ( t--; ; t-- ) {\r
+ if ( t < p )\r
+ { p = StrT_chr( p, _T('\0') ); break; }\r
+\r
+ c = *t;\r
+ if ( c != ' ' && c != '\t' && c != '\n' && c != '\r' )\r
+ { *(TCHAR*)(t+1) = _T('\0'); break; }\r
+ }\r
+ }\r
+ }\r
+ }\r
+ return (TCHAR*) p;\r
+}\r
+\r
+\r
+ \r
+/*=================================================================*/\r
+/* <<< [FileT/FileT.c] >>> */ \r
+/*=================================================================*/\r
+ \r
+/***********************************************************************\r
+ <<< [FileT_isExist] >>> \r
+************************************************************************/\r
+bool FileT_isExist( const TCHAR* path )\r
+{\r
+ #if ! FileT_isExistWildcard\r
+\r
+ DWORD r;\r
+\r
+ if ( path[0] == _T('\0') ) return false;\r
+ r = GetFileAttributes( path );\r
+ return r != (DWORD)-1;\r
+\r
+ #else\r
+\r
+ HANDLE find;\r
+ WIN32_FIND_DATA data;\r
+\r
+ find = FindFirstFileEx( path, FindExInfoStandard, &data,\r
+ FindExSearchNameMatch, NULL, 0 );\r
+\r
+ if ( find == INVALID_HANDLE_VALUE ) {\r
+ return false;\r
+ }\r
+ else {\r
+ FindClose( find );\r
+ return true;\r
+ }\r
+\r
+ #endif\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [FileT_isFile] >>> \r
+************************************************************************/\r
+bool FileT_isFile( const TCHAR* path )\r
+{\r
+ DWORD r = GetFileAttributes( path );\r
+ return ( r & (FILE_ATTRIBUTE_DIRECTORY | 0x80000000) ) == 0;\r
+ // 0x80000000 \82Í\81A\83t\83@\83C\83\8b\82â\83t\83H\83\8b\83_\82ª\91¶\8dÝ\82µ\82È\82¢\82±\82Æ\82ð\94»\92è\82·\82é\82½\82ß\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [FileT_isDir] >>> \r
+************************************************************************/\r
+bool FileT_isDir( const TCHAR* path )\r
+{\r
+ DWORD r = GetFileAttributes( path );\r
+ return ( r & (FILE_ATTRIBUTE_DIRECTORY | 0x80000000) ) == FILE_ATTRIBUTE_DIRECTORY;\r
+ // 0x80000000 \82Í\81A\83t\83@\83C\83\8b\82â\83t\83H\83\8b\83_\82ª\91¶\8dÝ\82µ\82È\82¢\82±\82Æ\82ð\94»\92è\82·\82é\82½\82ß\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [FileT_callByNestFind] \83T\83u\83t\83H\83\8b\83_\82à\8aÜ\82ß\82Ä\8ae\83t\83@\83C\83\8b\82Ì\83p\83X\82ð\93n\82· >>> \r
+************************************************************************/\r
+typedef struct {\r
+ /*--- inherit from FileT_CallByNestFindData */\r
+ void* CallerArgument;\r
+ TCHAR* FullPath; // abstruct path\r
+ TCHAR* StepPath;\r
+ TCHAR* FileName;\r
+ DWORD FileAttributes;\r
+\r
+ /*---*/\r
+ BitField Flags;\r
+ FuncType CallbackFromNestFind;\r
+ TCHAR FullPathMem[4096];\r
+} FileT_CallByNestFindDataIn;\r
+\r
+int FileT_callByNestFind_sub( FileT_CallByNestFindDataIn* m );\r
+\r
+\r
+int FileT_callByNestFind( const TCHAR* Path, BitField Flags, void* Argument, FuncType Callback )\r
+{\r
+ int e;\r
+ FileT_CallByNestFindDataIn data;\r
+\r
+ {\r
+ TCHAR* p;\r
+\r
+ e= StrT_cpy( data.FullPathMem, sizeof(data.FullPathMem), Path ); IF(e)goto fin;\r
+\r
+\r
+ /* FullPathMem \82Ì\8dÅ\8cã\82É \ \82ª\96³\82¢\82È\82ç\92Ç\89Á\82·\82é */\r
+ p = StrT_chr( data.FullPathMem, _T('\0') );\r
+ p--;\r
+ if ( *p != _T('\\') ) {\r
+ p++;\r
+ IF( p >= data.FullPathMem + (sizeof(data.FullPathMem) / sizeof(TCHAR)) - 1 )goto err_fa;\r
+ *p = _T('\\');\r
+ }\r
+\r
+\r
+ /* data \82ð\8f\89\8aú\89»\82·\82é */\r
+ data.CallerArgument = Argument;\r
+ data.FullPath = data.FullPathMem;\r
+ data.StepPath = p + 1;\r
+ data.FileName = p + 1;\r
+ data.Flags = Flags;\r
+ data.CallbackFromNestFind = Callback;\r
+ }\r
+\r
+ /* \8dÄ\8bN\8cÄ\82Ñ\8fo\82µ\8aÖ\90\94\82Ö */\r
+ e= FileT_callByNestFind_sub( &data ); IF(e)goto fin;\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+err_fa: e= E_FEW_ARRAY; goto fin;\r
+}\r
+\r
+\r
+int FileT_callByNestFind_sub( FileT_CallByNestFindDataIn* m )\r
+{\r
+ int e;\r
+ HANDLE find;\r
+ WIN32_FIND_DATA data;\r
+ TCHAR* p;\r
+ int done;\r
+\r
+\r
+ /* Path \82É\8ew\92è\82µ\82½\83t\83H\83\8b\83_\82É\91Î\82µ\82Ä\83R\81[\83\8b\83o\83b\83N\82·\82é */\r
+ if ( m->Flags & FileT_FolderBeforeFiles ) {\r
+ *( m->FileName - 1 ) = _T('\0'); // m->FullPath \82Ì\8dÅ\8cã\82Ì \ \82ð\88ê\8e\9e\93I\82É\83J\83b\83g\r
+ *( m->FileName ) = _T('\0'); // m->FileName, m->StepPath \82ð "" \82É\82·\82é\r
+ m->FileAttributes = FILE_ATTRIBUTE_DIRECTORY;\r
+\r
+ if ( m->StepPath[0] == _T('\0') ) {\r
+ TCHAR* step_path = m->StepPath;\r
+ TCHAR* fname = m->FileName;\r
+\r
+ m->StepPath = _T(".");\r
+ m->FileName = StrT_refFName( m->FullPath );\r
+ e= m->CallbackFromNestFind( m ); IF(e)goto fin;\r
+ m->StepPath = step_path;\r
+ m->FileName = fname;\r
+ }\r
+ else if ( m->FileName[0] == _T('\0') ) {\r
+ TCHAR* fname = m->FileName;\r
+\r
+ m->FileName = StrT_refFName( m->FullPath );\r
+ e= m->CallbackFromNestFind( m ); IF(e)goto fin;\r
+ m->FileName = fname;\r
+ }\r
+ else {\r
+ e= m->CallbackFromNestFind( m ); IF(e)goto fin;\r
+ }\r
+ *( m->FileName - 1 ) = _T('\\');\r
+ }\r
+\r
+\r
+ /* * \82ð\92Ç\89Á */\r
+ p = m->FileName;\r
+ IF( p >= m->FullPathMem + (sizeof(m->FullPathMem) / sizeof(TCHAR)) - 2 )goto err_fa;\r
+ *p = _T('*'); *(p+1) = _T('\0');\r
+\r
+\r
+ /* \83t\83@\83C\83\8b\82©\83t\83H\83\8b\83_\82ð\97ñ\8b\93\82µ\82Ü\82· */\r
+ find = FindFirstFileEx( m->FullPathMem, FindExInfoStandard, &data,\r
+ FindExSearchNameMatch, NULL, 0 );\r
+ done = ( find == INVALID_HANDLE_VALUE );\r
+\r
+ while (!done)\r
+ {\r
+ if ( _tcscmp( data.cFileName, _T(".") ) == 0 ||\r
+ _tcscmp( data.cFileName, _T("..") ) == 0 ) {\r
+ done = ! FindNextFile( find, &data );\r
+ continue;\r
+ }\r
+\r
+ StrT_cpy( m->FileName,\r
+ sizeof(m->FullPathMem) - ( (char*)m->FileName - (char*)m->FullPathMem ),\r
+ data.cFileName );\r
+ m->FileAttributes = data.dwFileAttributes;\r
+\r
+ if ( data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) {\r
+ TCHAR* prev_fname = m->FileName;\r
+\r
+ p = StrT_chr( m->FileName, _T('\0') );\r
+\r
+ IF( p >= m->FullPathMem + (sizeof(m->FullPathMem) / sizeof(TCHAR)) - 2 )goto err_fa;\r
+ *p = _T('\\'); *(p+1) = _T('\0');\r
+ m->FileName = p + 1;\r
+\r
+ e= FileT_callByNestFind_sub( m ); IF(e)goto fin; /* \8dÄ\8bN\8cÄ\82Ñ\8fo\82µ */\r
+\r
+ m->FileName = prev_fname;\r
+ }\r
+ else {\r
+ e= m->CallbackFromNestFind( m ); IF(e)goto fin;\r
+ }\r
+\r
+ done = ! FindNextFile( find, &data );\r
+ }\r
+ FindClose( find );\r
+\r
+\r
+ /* Path \82É\8ew\92è\82µ\82½\83t\83H\83\8b\83_\82É\91Î\82µ\82Ä\83R\81[\83\8b\83o\83b\83N\82·\82é */\r
+ if ( m->Flags & FileT_FolderAfterFiles ) {\r
+ TCHAR* step_path = m->StepPath;\r
+ TCHAR* fname = m->FileName;\r
+\r
+ *( m->FileName - 1 ) = _T('\0');\r
+ m->FileAttributes = FILE_ATTRIBUTE_DIRECTORY;\r
+ if ( ( *( m->StepPath - 1 ) == _T('\0') ) && ( m->StepPath > m->FullPath ) ) {\r
+ m->StepPath = _T(".");\r
+ }\r
+ m->FileName = StrT_refFName( m->FullPath );\r
+\r
+ e= m->CallbackFromNestFind( m ); IF(e)goto fin;\r
+\r
+ m->StepPath = step_path;\r
+ m->FileName = fname;\r
+ }\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+err_fa: e= E_FEW_ARRAY; goto fin;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [FileT_openForRead] >>> \r
+************************************************************************/\r
+int FileT_openForRead( FILE** out_pFile, const TCHAR* Path )\r
+{\r
+ errno_t en;\r
+\r
+ assert( Locale_isInited() );\r
+\r
+ #if DEBUGTOOLS_USES\r
+ { int e= Debug_onOpen( Path ); if(e) return e; }\r
+ #endif\r
+\r
+ en = _tfopen_s( out_pFile, Path, _T("r")_T(fopen_ccs) );\r
+ if ( en == ENOENT ) {\r
+ #ifndef UNDER_CE\r
+ {\r
+ TCHAR cwd[512];\r
+\r
+ if ( _tgetcwd( cwd, _countof(cwd) ) == NULL ) {\r
+ cwd[0] = _T('\0');\r
+ }\r
+ Error4_printf( _T("<ERROR msg=\"Not found\" path=\"%s\" current=\"%s\"/>"),\r
+ Path, cwd );\r
+ }\r
+ #else\r
+ Error4_printf( _T("<ERROR msg=\"Not found\" path=\"%s\"/>"), Path );\r
+ #endif\r
+\r
+ return E_PATH_NOT_FOUND;\r
+ }\r
+ if ( en == EACCES ) {\r
+ Error4_printf( _T("access denied \"%s\"\n"), Path );\r
+ return E_ACCESS_DENIED;\r
+ }\r
+ IF(en)return E_OTHERS;\r
+\r
+ return 0;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [FileT_close] >>> \r
+************************************************************************/\r
+int FileT_close( FILE* File, int e )\r
+{\r
+ if ( File != NULL ) {\r
+ int r = fclose( File );\r
+ IF(r&&!e)e=E_ERRNO;\r
+ }\r
+ return e;\r
+}\r
+\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [FileT_closeAndNULL] >>> \r
+************************************************************************/\r
+errnum_t FileT_closeAndNULL( FILE** in_out_File, errnum_t e )\r
+{\r
+ FILE* file = *in_out_File;\r
+\r
+ if ( file != NULL ) {\r
+ int r = fclose( file );\r
+ IF ( r && e == 0 ) { e = E_ERRNO; }\r
+ *in_out_File = NULL;\r
+ }\r
+\r
+ return e;\r
+}\r
+\r
+\r
+\r
+ \r
+/*=================================================================*/\r
+/* <<< [Error4/Error4.c] >>> */ \r
+/*=================================================================*/\r
+ \r
+/***********************************************************************\r
+ <<< [Get_Error4_Variables] >>> \r
+************************************************************************/\r
+static Error4_VariablesClass gs;\r
+#ifdef _DEBUG\r
+ extern Error4_VariablesClass* g_Error4_Variables = &gs;\r
+#endif\r
+\r
+Error4_VariablesClass* Get_Error4_Variables()\r
+{\r
+ return &gs;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< (SetBreakErrorID) >>> \r
+************************************************************************/\r
+\r
+/*[DebugBreakR]*/\r
+void DebugBreakR()\r
+{\r
+ printf( "\83u\83\8c\81[\83N\82µ\82Ü\82·\81B\82à\82µ\83f\83o\83b\83K\81[\82ª\90Ú\91±\82³\82ê\82Ä\82¢\82È\82¯\82ê\82Î\8b\90§\8fI\97¹\82µ\82Ü\82·\81B\n" );\r
+ DebugBreak();\r
+ // Visual Studio 2008 \82Å\82Í\81A\82±\82±\82Å [ \83f\83o\83b\83O > \83X\83e\83b\83v \83A\83E\83g ] \82µ\82È\82¢\82Æ\r
+ // \8cÄ\82Ñ\8fo\82µ\97\9a\97ð\82â\83E\83H\83b\83`\82Ì\93à\97e\82ª\90³\82µ\82\82È\82è\82Ü\82¹\82ñ\81B\r
+}\r
+\r
+\r
+#if ENABLE_ERROR_BREAK_IN_ERROR_CLASS\r
+\r
+\r
+#if ! IS_MULTI_THREAD_ERROR_CLASS\r
+ dll_global_g_DebugBreakCount ErrorClass g_Error; /* \8f\89\8aú\92l\82Í\82·\82×\82Ä\83[\83\8d */\r
+#else\r
+ dll_global_g_DebugBreakCount GlobalErrorClass g_GlobalError;\r
+\r
+ static errnum_t ErrorClass_initializeIfNot_Sub( ErrorClass** out_Error );\r
+ static errnum_t ErrorClass_initializeIfNot_Sub2(void);\r
+#endif\r
+\r
+\r
+#define IF_ if /* Error check for in "IF" macro */\r
+\r
+\r
+/*[SetBreakErrorID]*/\r
+void SetBreakErrorID( int ErrorID )\r
+{\r
+#if ! IS_MULTI_THREAD_ERROR_CLASS\r
+\r
+ ErrorClass* err = &g_Error;\r
+ bool is_print;\r
+\r
+ is_print = ( err->BreakErrorID != ErrorID );\r
+\r
+ err->BreakErrorID = ErrorID;\r
+ /* printf \82Ì\92\86\82Å\94\90¶\82·\82é\83G\83\89\81[\82Å\8e~\82ß\82é\82½\82ß */\r
+\r
+ if ( is_print )\r
+ { printf( ">SetBreakErrorID( %d );\n", ErrorID ); }\r
+\r
+#else\r
+\r
+ GlobalErrorClass* err_global = &g_GlobalError;\r
+\r
+ if ( err_global->BreakGlobalErrorID != ErrorID )\r
+ { printf( ">SetBreakErrorID( %d );\n", ErrorID ); }\r
+ err_global->BreakGlobalErrorID = ErrorID;\r
+\r
+#endif\r
+}\r
+\r
+\r
+\r
+bool OnRaisingError_Sub( const char* FilePath, int LineNum )\r
+ // \96{\8aÖ\90\94\82Í\81AIF \83}\83N\83\8d\82Ì\92\86\82©\82ç\8cÄ\82Î\82ê\82Ü\82·\r
+ // \95Ô\82è\92l\82Í\81A\83u\83\8c\81[\83N\82·\82é\82©\82Ç\82¤\82©\r
+{\r
+#if ! IS_MULTI_THREAD_ERROR_CLASS\r
+\r
+ ErrorClass* err = &g_Error;\r
+ bool is_break;\r
+\r
+ /* \83G\83\89\81[\8e\9e\82Ì\92\86\92f\8f\88\97\9d\81i\83W\83\83\83\93\83v\81j\82ð\82µ\82Ä\82¢\82é\82Æ\82«\81i\8d\82\91¬\83\8a\83^\81[\83\93\81j */\r
+ if ( err->IsError ) {\r
+ return false;\r
+ }\r
+\r
+ /* \83G\83\89\81[\82ª\94\90¶\82µ\82½\92¼\8cã\82Ì\82Æ\82« */\r
+ err->ErrorID += 1;\r
+ err->IsError = true;\r
+ err->FilePath = FilePath;\r
+ err->LineNum = LineNum;\r
+\r
+ #if ERR2_ENABLE_ERROR_LOG\r
+ printf( "<ERROR_LOG msg=\"raised\" ErrorID=\"%d\" ErrorObject=\"0x%08X\"/>\n",\r
+ err->ErrorID, (int) err );\r
+ #endif\r
+\r
+ is_break = ( err->ErrorID == err->BreakErrorID );\r
+\r
+ if ( is_break ) {\r
+ printf( "Break in (%d) %s\n", LineNum, FilePath );\r
+ }\r
+ return ( err->ErrorID == err->BreakErrorID );\r
+\r
+#else /* IS_MULTI_THREAD_ERROR_CLASS */\r
+\r
+ errnum_t e;\r
+ bool is_break = false;\r
+ ErrorClass* err;\r
+\r
+ e= ErrorClass_initializeIfNot_Sub( &err ); IF_(e){goto fin;}\r
+\r
+\r
+ /* \83G\83\89\81[\8e\9e\82Ì\92\86\92f\8f\88\97\9d\81i\83W\83\83\83\93\83v\81j\82ð\82µ\82Ä\82¢\82é\82Æ\82«\81i\8d\82\91¬\83\8a\83^\81[\83\93\81j */\r
+ if ( err->IsError ) {\r
+ return false;\r
+ }\r
+\r
+ /* \83G\83\89\81[\82ª\94\90¶\82µ\82½\92¼\8cã\82Ì\82Æ\82« */\r
+ else {\r
+ GlobalErrorClass* err_global = &g_GlobalError;\r
+\r
+ EnterCriticalSection( &err_global->CriticalSection );\r
+\r
+\r
+ err_global->ErrorThreadCount += 1;\r
+ err_global->RaisedGlobalErrorID += 1;\r
+ err->GlobalErrorID = err_global->RaisedGlobalErrorID;\r
+\r
+ err->ErrorID += 1;\r
+ err->IsError = true;\r
+ err->FilePath = FilePath;\r
+ err->LineNum = LineNum;\r
+\r
+ is_break = ( err->ErrorID == err->BreakErrorID ) ||\r
+ ( err->GlobalErrorID == err_global->BreakGlobalErrorID );\r
+\r
+\r
+ /* \82±\82±\82æ\82è\88È\8d~\82Í\81AIF \83}\83N\83\8d\82È\82Ç\82ð\8cÄ\82Ñ\8fo\82µ\89Â\94\\81i\83\8a\83G\83\93\83g\83\89\83\93\83g\89Â\94\\81j */\r
+ /* \8fã\8bL\82Ì if ( err->IsError ) \82Å\81A\82·\82®\96ß\82é\82½\82ß */\r
+\r
+\r
+ #if ERR2_ENABLE_ERROR_LOG\r
+ printf( "<ERROR_LOG msg=\"raised\" ErrorID=\"%d\" ErrorObject=\"0x%08X\"/>\n",\r
+ err->GlobalErrorID, (int) err );\r
+ #endif\r
+\r
+\r
+ if ( err->ErrorID == 1 ) {\r
+ FinalizerClass_initConst( &err->Finalizer, err, ErrorClass_finalize );\r
+ e= AddThreadLocalFinalizer( &err->Finalizer );\r
+ }\r
+ else {\r
+ e = 0;\r
+ }\r
+ LeaveCriticalSection( &err_global->CriticalSection );\r
+ IF(e){goto fin;}\r
+ }\r
+\r
+ e=0;\r
+fin:\r
+ if ( is_break ) {\r
+ printf( "Break in (%d) %s\n", LineNum, FilePath );\r
+ }\r
+ return is_break;\r
+\r
+#endif /* IS_MULTI_THREAD_ERROR_CLASS */\r
+}\r
+\r
+\r
+//[ClearError]\r
+void ClearError()\r
+{\r
+#if ! IS_MULTI_THREAD_ERROR_CLASS\r
+\r
+ ErrorClass* err = &g_Error;\r
+\r
+ #if ERR2_ENABLE_ERROR_LOG\r
+ if ( err->IsError ) {\r
+ printf( "<ERROR_LOG msg=\"cleared\" ErrorID=\"%d\" ErrorObject=\"0x%08X\"/>\n",\r
+ err->ErrorID, (int) err );\r
+ }\r
+ #endif\r
+\r
+ err->IsError = false;\r
+\r
+#else /* IS_MULTI_THREAD_ERROR_CLASS */\r
+\r
+ errnum_t e;\r
+ ErrorClass* err;\r
+\r
+ e= ErrorClass_initializeIfNot_Sub( &err );\r
+ if ( e == 0 ) {\r
+ #if ERR2_ENABLE_ERROR_LOG\r
+ if ( err->IsError )\r
+ printf( "<ERROR_LOG msg=\"cleared\" ErrorID=\"%d\" ErrorObject=\"0x%08X\"/>\n",\r
+ err->GlobalErrorID, (int) err );\r
+ #endif\r
+\r
+ if ( err->IsError ) {\r
+ GlobalErrorClass* err_global = &g_GlobalError;\r
+\r
+ EnterCriticalSection( &err_global->CriticalSection );\r
+ err_global->ErrorThreadCount -= 1;\r
+ LeaveCriticalSection( &err_global->CriticalSection );\r
+\r
+ err->IsError = false;\r
+ }\r
+ }\r
+ else {\r
+ #if ERR2_ENABLE_ERROR_LOG\r
+ printf( "<ERROR_LOG msg=\"clear_miss\"/>\n" );\r
+ #endif\r
+ }\r
+\r
+#endif /* IS_MULTI_THREAD_ERROR_CLASS */\r
+}\r
+\r
+\r
+//[IfErrThenBreak]\r
+void IfErrThenBreak()\r
+{\r
+#if ! IS_MULTI_THREAD_ERROR_CLASS\r
+\r
+ ErrorClass* err = &g_Error;\r
+\r
+ if ( err->IsError &&\r
+ ( err->ErrorID != err->BreakErrorID || err->BreakErrorID == 0 )\r
+ ) {\r
+ printf( "in IfErrThenBreak\n" );\r
+ DebugBreakR();\r
+\r
+ // \83E\83H\83b\83`\82Å\81Aerr->ErrorID \82Ì\92l(N\82Æ\82·\82é)\82ð\8am\94F\82µ\82Ä\81A\r
+ // \83\81\83C\83\93\8aÖ\90\94\82Å SetBreakErrorID( N ); \82ð\8cÄ\82Ñ\8fo\82µ\82Ä\82\82¾\82³\82¢\81B\r
+ // \83G\83\89\81[\82ª\94\90¶\82µ\82½\8fê\8f\8a\82Í\81Aerr->FilePath, err->LineNum \82Å\82·\81B\r
+ // \90³\8fí\8fI\97¹\82µ\82Ä\82¢\82é\82Â\82à\82è\82È\82Ì\82É\82±\82±\82Å\83u\83\8c\81[\83N\82·\82é\82Æ\82«\82Í\81A\r
+ // ClearError() \82ð\96Y\82ê\82Ä\82¢\82é\89Â\94\\90«\82ª\82 \82è\82Ü\82·\81B\r
+ #if ERR2_ENABLE_ERROR_LOG\r
+ printf( "<ERROR_LOG msg=\"IfErrThenBreak\" ErrorID=\"%d\" BreakErrorID=\"%d\"/>\n",\r
+ err->ErrorID, err->BreakErrorID );\r
+ #endif\r
+\r
+ {\r
+ char str[512];\r
+ sprintf_s( str, _countof(str), "<ERROR file=\"%s(%d)\"/>\n",\r
+ err->FilePath, err->LineNum );\r
+ OutputDebugStringA( str );\r
+ }\r
+ }\r
+ ClearError();\r
+\r
+#else /* IS_MULTI_THREAD_ERROR_CLASS */\r
+\r
+ errnum_t e;\r
+ GlobalErrorClass* err_global = &g_GlobalError;\r
+ ErrorClass* err;\r
+\r
+ e= ErrorClass_initializeIfNot_Sub( &err );\r
+ if ( e ) { DebugBreakR(); ClearError(); return; } /* \93à\95\94\83G\83\89\81[ */\r
+\r
+ if ( err_global->ErrorThreadCount != 0 &&\r
+ ( err->GlobalErrorID != err_global->BreakGlobalErrorID || err_global->BreakGlobalErrorID == 0 )\r
+ ) {\r
+ printf( "in IfErrThenBreak\n" );\r
+ DebugBreakR();\r
+\r
+ // \83E\83H\83b\83`\82Å\81Aerr->GlobalErrorID \82Ì\92l(N\82Æ\82·\82é)\82ð\8am\94F\82µ\82Ä\81A\r
+ // \83\81\83C\83\93\8aÖ\90\94\82Å SetBreakErrorID( N ); \82ð\8cÄ\82Ñ\8fo\82µ\82Ä\82\82¾\82³\82¢\81B\r
+ // \83G\83\89\81[\82ª\94\90¶\82µ\82½\8fê\8f\8a\82Í\81Aerr->FilePath, err->LineNum \82Å\82·\81B\r
+ // \90³\8fí\8fI\97¹\82µ\82Ä\82¢\82é\82Â\82à\82è\82È\82Ì\82É\82±\82±\82Å\83u\83\8c\81[\83N\82·\82é\82Æ\82«\82Í\81A\r
+ // ClearError() \82ð\96Y\82ê\82Ä\82¢\82é\89Â\94\\90«\82ª\82 \82è\82Ü\82·\81B\r
+ #if ERR2_ENABLE_ERROR_LOG\r
+ printf( "<ERROR_LOG msg=\"IfErrThenBreak\" ErrorID=\"%d\" BreakErrorID=\"%d\"/>\n",\r
+ err->ErrorID, err->BreakErrorID );\r
+ #endif\r
+\r
+ {\r
+ char str[512];\r
+ sprintf_s( str, _countof(str), "<ERROR file=\"%s(%d)\"/>\n",\r
+ err->FilePath, err->LineNum );\r
+ OutputDebugStringA( str );\r
+ }\r
+ }\r
+ ClearError();\r
+\r
+#endif /* IS_MULTI_THREAD_ERROR_CLASS */\r
+}\r
+\r
+\r
+//[PushErr]\r
+void PushErr( ErrStackAreaClass* ErrStackArea )\r
+{\r
+#if ! IS_MULTI_THREAD_ERROR_CLASS\r
+\r
+ ErrorClass* err = &g_Error;\r
+\r
+ ErrStackArea->ErrorID = err->ErrorID;\r
+ ErrStackArea->IsError = err->IsError;\r
+ err->IsError = false;\r
+\r
+#else /* IS_MULTI_THREAD_ERROR_CLASS */\r
+\r
+ errnum_t e;\r
+ ErrorClass* err;\r
+\r
+ e= ErrorClass_initializeIfNot_Sub( &err );\r
+ if ( e == 0 ) {\r
+ ErrStackArea->ErrorID = err->ErrorID;\r
+ ErrStackArea->IsError = err->IsError;\r
+ err->IsError = false;\r
+ }\r
+\r
+#endif /* IS_MULTI_THREAD_ERROR_CLASS */\r
+}\r
+\r
+//[PopErr]\r
+void PopErr( ErrStackAreaClass* ErrStackArea )\r
+{\r
+#if ! IS_MULTI_THREAD_ERROR_CLASS\r
+\r
+ ErrorClass* err = &g_Error;\r
+\r
+ if ( ErrStackArea->IsError )\r
+ { err->IsError = true; }\r
+\r
+#else /* IS_MULTI_THREAD_ERROR_CLASS */\r
+\r
+ errnum_t e;\r
+ ErrorClass* err;\r
+\r
+ e= ErrorClass_initializeIfNot_Sub( &err );\r
+ if ( e == 0 ) {\r
+ if ( ErrStackArea->IsError )\r
+ { err->IsError = true; }\r
+ }\r
+\r
+#endif /* IS_MULTI_THREAD_ERROR_CLASS */\r
+}\r
+\r
+\r
+ \r
+/*[SetBreakErrorID:2]*/\r
+#undef IF_\r
+\r
+\r
+#endif // ENABLE_ERROR_BREAK_IN_ERROR_CLASS\r
+\r
+\r
+//[MergeError]\r
+errnum_t MergeError( errnum_t e, errnum_t ee )\r
+{\r
+ if ( e == 0 ) { return ee; }\r
+ else { /* ErrorLog_add( ee ); */ return e; }\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [g_Error4_String] >>> \r
+************************************************************************/\r
+TCHAR g_Error4_String[4096];\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Error4_printf] >>> \r
+************************************************************************/\r
+void Error4_printf( const TCHAR* format, ... )\r
+{\r
+ va_list va;\r
+ va_start( va, format );\r
+ vstprintf_r( g_Error4_String, sizeof(g_Error4_String), format, va );\r
+ va_end( va );\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Error4_getErrStr] >>> \r
+************************************************************************/\r
+void Error4_getErrStr( int ErrNum, TCHAR* out_ErrStr, size_t ErrStrSize )\r
+{\r
+ switch ( ErrNum ) {\r
+\r
+ case 0:\r
+ stprintf_r( out_ErrStr, ErrStrSize, _T("no error") );\r
+ break;\r
+\r
+ case E_FEW_ARRAY:\r
+ stprintf_r( out_ErrStr, ErrStrSize,\r
+ _T("<ERROR msg=\"\83v\83\8d\83O\83\89\83\80\93à\95\94\82Ì\94z\97ñ\83\81\83\82\83\8a\81[\82ª\95s\91«\82µ\82Ü\82µ\82½\81B\"/>") );\r
+ break;\r
+\r
+ case E_FEW_MEMORY:\r
+ stprintf_r( out_ErrStr, ErrStrSize,\r
+ _T("<ERROR msg=\"\83q\81[\83v\81E\83\81\83\82\83\8a\81[\82ª\95s\91«\82µ\82Ü\82µ\82½\81B\"/>") );\r
+ break;\r
+\r
+ #ifndef __linux__\r
+ case E_GET_LAST_ERROR: {\r
+ DWORD err_win;\r
+ TCHAR* str_pointer;\r
+\r
+ err_win = gs.WindowsLastError;\r
+ if ( err_win == 0 ) { err_win = GetLastError(); }\r
+\r
+ stprintf_part_r( out_ErrStr, ErrStrSize, out_ErrStr, &str_pointer,\r
+ _T("<ERROR GetLastError=\"0x%08X\" GetLastErrorStr=\""), err_win );\r
+ FormatMessage( FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM,\r
+ NULL, err_win, LANG_USER_DEFAULT,\r
+ str_pointer, (TCHAR*)( (char*)out_ErrStr + ErrStrSize ) - str_pointer, NULL );\r
+ str_pointer = StrT_chr( str_pointer, _T('\0') );\r
+ if ( *( str_pointer - 2 ) == _T('\r') && *( str_pointer - 1 ) == _T('\n') )\r
+ str_pointer -= 2;\r
+ stcpy_part_r( out_ErrStr, ErrStrSize, str_pointer, NULL, _T("\"/>"), NULL );\r
+ break;\r
+ }\r
+ #endif\r
+\r
+ default:\r
+ if ( g_Error4_String[0] != '\0' )\r
+ stprintf_r( out_ErrStr, ErrStrSize, _T("%s"), g_Error4_String );\r
+ else\r
+ stprintf_r( out_ErrStr, ErrStrSize, _T("<ERROR errnum=\"%d\"/>"), ErrNum );\r
+ break;\r
+ }\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [SaveWindowsLastError] >>> \r
+************************************************************************/\r
+errnum_t SaveWindowsLastError()\r
+{\r
+ gs.WindowsLastError = GetLastError();\r
+ return E_GET_LAST_ERROR;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Error4_showToStdErr] >>> \r
+************************************************************************/\r
+void Error4_showToStdErr( int err_num )\r
+{\r
+ Error4_showToStdIO( stderr, err_num );\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Error4_showToStdIO] >>> \r
+************************************************************************/\r
+void Error4_showToStdIO( FILE* out, int err_num )\r
+{\r
+ TCHAR msg[1024];\r
+ #if _UNICODE\r
+ char msg2[1024];\r
+ #endif\r
+\r
+ if ( err_num != 0 ) {\r
+ Error4_getErrStr( err_num, msg, sizeof(msg) );\r
+ #if _UNICODE\r
+ setlocale( LC_ALL, ".OCP" );\r
+ sprintf_s( msg2, sizeof(msg2), "%S", msg );\r
+ fprintf( out, "%s\n", msg2 ); // _ftprintf_s \82Å\82Í\93ú\96{\8cê\82ª\8fo\82Ü\82¹\82ñ\r
+ #else\r
+ fprintf( out, "%s\n", msg );\r
+ #endif\r
+\r
+ #if ERR2_ENABLE_ERROR_BREAK\r
+ fprintf( out, "\81i\8aJ\94\8eÒ\82Ö\81j\83\81\83C\83\93\8aÖ\90\94\82Å SetBreakErrorID( %d ); \82ð\8cÄ\82Ñ\8fo\82µ\82Ä\82\82¾\82³\82¢\81B\n",\r
+ g_Err2.ErrID );\r
+ #else\r
+#if 0\r
+ if ( err_num == E_FEW_MEMORY || gs.WindowsLastError == ERROR_NOT_ENOUGH_MEMORY ) {\r
+ /* Not show the message for developper */\r
+ }\r
+ else {\r
+ fprintf( out, "\81i\8aJ\94\8eÒ\82Ö\81jERR2_ENABLE_ERROR_BREAK \82ð\92è\8b`\82µ\82Ä\8dÄ\83R\83\93\83p\83C\83\8b\82µ\82Ä\82\82¾\82³\82¢\81B\n" );\r
+ }\r
+#endif\r
+ #endif\r
+ }\r
+ IfErrThenBreak();\r
+}\r
+\r
+\r
+ \r
+/*=================================================================*/\r
+/* <<< [StrT/StrT.c] >>> */ \r
+/*=================================================================*/\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_cpy] >>> \r
+- _tcscpy is raising exception, if E_FEW_ARRAY\r
+************************************************************************/\r
+errnum_t StrT_cpy( TCHAR* Dst, size_t DstSize, const TCHAR* Src )\r
+{\r
+ size_t size;\r
+\r
+ size = ( _tcslen( Src ) + 1 ) * sizeof(TCHAR);\r
+ if ( size <= DstSize ) {\r
+ memcpy( Dst, Src, size );\r
+ return 0;\r
+ }\r
+ else {\r
+ memcpy( Dst, Src, DstSize - sizeof(TCHAR) );\r
+ *(TCHAR*)( (char*) Dst + DstSize ) = _T('\0');\r
+ return E_FEW_ARRAY;\r
+ }\r
+}\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_chr] >>> \r
+************************************************************************/\r
+TCHAR* StrT_chr( const TCHAR* String, TCHAR Key )\r
+{\r
+ const TCHAR* return_value = _tcschr( String, Key );\r
+\r
+ if ( return_value == NULL && Key == _T('\0') ) {\r
+ return_value = String + _tcslen( String );\r
+ }\r
+\r
+ return (TCHAR*) return_value;\r
+}\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_chrNext] >>> \r
+************************************************************************/\r
+TCHAR* StrT_chrNext( const TCHAR* in_Start, TCHAR in_KeyCharactor )\r
+{\r
+ const TCHAR* p = _tcschr( in_Start, in_KeyCharactor );\r
+\r
+ if ( p != NULL )\r
+ { p += 1; }\r
+\r
+ return (TCHAR*) p;\r
+}\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [MallocAndCopyString] >>> \r
+************************************************************************/\r
+errnum_t MallocAndCopyString( const TCHAR** out_NewString, const TCHAR* SourceString )\r
+{\r
+ TCHAR* str;\r
+ size_t size = ( _tcslen( SourceString ) + 1 ) * sizeof(TCHAR);\r
+\r
+ ASSERT_D( *out_NewString == NULL, __noop() );\r
+\r
+ str = (TCHAR*) malloc( size );\r
+ if ( str == NULL ) { return E_FEW_MEMORY; }\r
+\r
+ memcpy( str, SourceString, size );\r
+\r
+ *out_NewString = str;\r
+ return 0;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [MallocAndCopyString_char] >>> \r
+************************************************************************/\r
+#ifdef _UNICODE\r
+errnum_t MallocAndCopyString_char( const TCHAR** out_NewString, const char* SourceString )\r
+{\r
+ TCHAR* str;\r
+ size_t size = ( strlen( SourceString ) + 1 ) * sizeof(TCHAR);\r
+ int r;\r
+\r
+ str = (TCHAR*) malloc( size );\r
+ if ( str == NULL ) { return E_FEW_MEMORY; }\r
+\r
+ r = MultiByteToWideChar( CP_OEMCP, MB_PRECOMPOSED, SourceString, -1, str, size / sizeof(TCHAR) );\r
+ IF ( r == 0 ) {\r
+ free( str );\r
+ return E_GET_LAST_ERROR;\r
+ }\r
+ *out_NewString = str;\r
+ return 0;\r
+}\r
+#endif\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [MallocAndCopyStringByLength] >>> \r
+************************************************************************/\r
+errnum_t MallocAndCopyStringByLength( const TCHAR** out_NewString, const TCHAR* SourceString,\r
+ unsigned CountOfCharacter )\r
+{\r
+ TCHAR* str;\r
+ size_t size = ( CountOfCharacter + 1 ) * sizeof(TCHAR);\r
+\r
+ ASSERT_D( *out_NewString == NULL, __noop() );\r
+ ASSERT_D( CountOfCharacter < 0x7FFFFFFF, __noop() );\r
+\r
+ str = (TCHAR*) malloc( size );\r
+ if ( str == NULL ) { return E_FEW_MEMORY; }\r
+\r
+ memcpy( str, SourceString, size - sizeof(TCHAR) );\r
+ str[ CountOfCharacter ] = _T('\0');\r
+\r
+ *out_NewString = str;\r
+ return 0;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_chrs] >>> \r
+************************************************************************/\r
+TCHAR* StrT_chrs( const TCHAR* s, const TCHAR* keys )\r
+{\r
+ if ( *keys == _T('\0') ) return NULL;\r
+\r
+ for ( ; *s != _T('\0'); s++ ) {\r
+ if ( _tcschr( keys, *s ) != NULL )\r
+ return (TCHAR*) s;\r
+ }\r
+ return NULL;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_rstr] >>> \r
+************************************************************************/\r
+TCHAR* StrT_rstr( const TCHAR* String, const TCHAR* SearchStart, const TCHAR* Keyword,\r
+ void* NullConfig )\r
+{\r
+ const TCHAR* p;\r
+ int keyword_length = _tcslen( Keyword );\r
+ TCHAR keyword_first = Keyword[0];\r
+\r
+ UNREFERENCED_VARIABLE( NullConfig );\r
+\r
+ p = SearchStart;\r
+ while ( p >= String ) {\r
+ if ( *p == keyword_first ) {\r
+ if ( _tcsncmp( p, Keyword, keyword_length ) == 0 ) {\r
+ return (TCHAR*) p;\r
+ }\r
+ }\r
+ p -= 1;\r
+ }\r
+\r
+ return NULL;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_skip] >>> \r
+************************************************************************/\r
+TCHAR* StrT_skip( const TCHAR* String, const TCHAR* Keys )\r
+{\r
+ if ( *Keys == _T('\0') ) { return (TCHAR*) String; }\r
+\r
+ for ( ; *String != _T('\0'); String += 1 ) {\r
+ if ( _tcschr( Keys, *String ) == NULL )\r
+ break;\r
+ }\r
+ return (TCHAR*) String;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_rskip] >>> \r
+************************************************************************/\r
+TCHAR* StrT_rskip( const TCHAR* String, const TCHAR* SearchStart, const TCHAR* Keys,\r
+ void* NullConfig )\r
+{\r
+ const TCHAR* pointer;\r
+\r
+ UNREFERENCED_VARIABLE( NullConfig );\r
+\r
+ if ( *Keys == _T('\0') ) { return (TCHAR*) SearchStart; }\r
+\r
+ for ( pointer = SearchStart; pointer >= String; pointer -= 1 ) {\r
+ if ( _tcschr( Keys, *pointer ) == NULL )\r
+ { return (TCHAR*) pointer; }\r
+ }\r
+ return NULL;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_isCIdentifier] >>> \r
+************************************************************************/\r
+bool StrT_isCIdentifier( TCHAR Character )\r
+{\r
+ const TCHAR c = Character;\r
+\r
+ return (\r
+ ( c >= _T('A') && c <= _T('Z') ) ||\r
+ ( c >= _T('a') && c <= _T('z') ) ||\r
+ ( c >= _T('0') && c <= _T('9') ) ||\r
+ c == _T('_') );\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_searchOverOfCIdentifier] >>> \r
+************************************************************************/\r
+TCHAR* StrT_searchOverOfCIdentifier( const TCHAR* Text )\r
+{\r
+ const TCHAR* p;\r
+\r
+ for ( p = Text;\r
+ StrT_isCIdentifier( *p );\r
+ p += 1 )\r
+ {\r
+ }\r
+ return (TCHAR*) p;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_searchOverOfIdiom] >>> \r
+************************************************************************/\r
+TCHAR* StrT_searchOverOfIdiom( const TCHAR* Text )\r
+{\r
+ const TCHAR* p;\r
+\r
+ p = Text;\r
+ for ( p = Text;\r
+ StrT_isCIdentifier( *p ) || *p == _T(' ');\r
+ p += 1 )\r
+ {\r
+ }\r
+\r
+ for ( p -= 1;\r
+ *p == _T(' ') && p >= Text;\r
+ p -= 1 )\r
+ {\r
+ }\r
+\r
+ return (TCHAR*) p + 1;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_cmp_part] >>> \r
+************************************************************************/\r
+int StrT_cmp_part( const TCHAR* in_StringA_Start, const TCHAR* in_StringA_Over,\r
+ const TCHAR* in_StringB )\r
+{\r
+ const TCHAR* a;\r
+ const TCHAR* b;\r
+ TCHAR aa;\r
+ TCHAR bb;\r
+\r
+ a = in_StringA_Start;\r
+ b = in_StringB;\r
+\r
+ for (;;) {\r
+ if ( a >= in_StringA_Over ) {\r
+ bb = *b;\r
+ if ( bb == _T('\0') )\r
+ { return 0; }\r
+ else\r
+ { return -bb; }\r
+ }\r
+\r
+ aa = *a;\r
+ bb = *b;\r
+\r
+ if ( bb == _T('\0') )\r
+ { return aa; }\r
+\r
+ if ( aa != bb )\r
+ { return aa - bb; }\r
+\r
+ a += 1;\r
+ b += 1;\r
+ }\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_cmp_i_part] >>> \r
+************************************************************************/\r
+int StrT_cmp_i_part( const TCHAR* in_StringA_Start, const TCHAR* in_StringA_Over,\r
+ const TCHAR* in_StringB )\r
+{\r
+ const TCHAR* a;\r
+ const TCHAR* b;\r
+ TCHAR aa;\r
+ TCHAR bb;\r
+\r
+ a = in_StringA_Start;\r
+ b = in_StringB;\r
+\r
+ for (;;) {\r
+ if ( a >= in_StringA_Over ) {\r
+ bb = *b;\r
+ if ( bb == _T('\0') )\r
+ { return 0; }\r
+ else\r
+ { return -bb; }\r
+ }\r
+\r
+ aa = *a;\r
+ bb = *b;\r
+\r
+ if ( bb == _T('\0') )\r
+ { return aa; }\r
+\r
+ if ( aa != bb ) {\r
+ if ( _totlower( aa ) != _totlower( bb ) )\r
+ { return aa - bb; }\r
+ }\r
+\r
+ a += 1;\r
+ b += 1;\r
+ }\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_cmp_part2] >>> \r
+************************************************************************/\r
+int StrT_cmp_part2( const TCHAR* in_StringA_Start, const TCHAR* in_StringA_Over,\r
+ const TCHAR* in_StringB_Start, const TCHAR* in_StringB_Over )\r
+{\r
+ int length_A = in_StringA_Over - in_StringA_Start;\r
+ int length_B = in_StringB_Over - in_StringB_Start;\r
+\r
+ if ( length_A != length_B ) {\r
+ return length_A - length_B;\r
+ }\r
+ else {\r
+ return _tcsncmp( in_StringA_Start, in_StringB_Start, length_A );\r
+ }\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_refFName] >>> \r
+************************************************************************/\r
+TCHAR* StrT_refFName( const TCHAR* s )\r
+{\r
+ const TCHAR* p;\r
+ TCHAR c;\r
+\r
+ p = StrT_chr( s, _T('\0') );\r
+\r
+ if ( p == s ) return (TCHAR*) s;\r
+\r
+ for ( p--; p>s; p-- ) {\r
+ c = *p;\r
+ if ( c == _T('\\') || c == _T('/') ) return (TCHAR*) p+1;\r
+ }\r
+ if ( *p == _T('\\') || *p == _T('/') ) return (TCHAR*) p+1;\r
+\r
+ return (TCHAR*) s;\r
+}\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_refExt] >>> \r
+************************************************************************/\r
+TCHAR* StrT_refExt( const TCHAR* s )\r
+{\r
+ const TCHAR* p;\r
+\r
+ p = StrT_chr( s, _T('\0') );\r
+\r
+ if ( p == s ) { return (TCHAR*) s; }\r
+\r
+ for ( p--; p>s; p-- ) {\r
+ if ( *p == _T('.') ) return (TCHAR*) p+1;\r
+ if ( *p == _T('/') || *p == _T('\\') )\r
+ { return (TCHAR*) StrT_chr( p, _T('\0') ); }\r
+ }\r
+ if ( *p == _T('.') ) return (TCHAR*) p+1;\r
+\r
+ return (TCHAR*) StrT_chr( s, _T('\0') );\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+* Function: StrT_cutFragmentInPath\r
+************************************************************************/\r
+void StrT_cutFragmentInPath( TCHAR* in_out_Path )\r
+{\r
+ TCHAR* p;\r
+\r
+ p = _tcschr( in_out_Path, _T('#') );\r
+ if ( p != NULL ) {\r
+ *p = _T('\0');\r
+ }\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_replace] >>> \r
+************************************************************************/\r
+errnum_t StrT_replace( TCHAR* Out, size_t OutSize, const TCHAR* In,\r
+ const TCHAR* FromStr, const TCHAR* ToStr, unsigned Opt )\r
+{\r
+ errnum_t e;\r
+ unsigned from_size = _tcslen( FromStr ) * sizeof(TCHAR);\r
+ unsigned to_size = _tcslen( ToStr ) * sizeof(TCHAR);\r
+ const TCHAR* p_in = In;\r
+ TCHAR* p_out = Out;\r
+ const TCHAR* p_in_from;\r
+ size_t copy_size;\r
+ int out_size = OutSize - 1;\r
+\r
+\r
+ /* \92u\8a·\82µ\82Ä\8f¬\82³\82\82È\82é\82Æ\82«\82Í\81A\8d¶\82©\82ç\89E\82Ö\91\96\8d¸\82·\82é */\r
+ if ( to_size <= from_size ) {\r
+\r
+ for (;;) {\r
+\r
+ /* In \82Ì\92\86\82Ì FromStr \82Ì\90æ\93ª\88Ê\92u\82ð p_in_from \82Ö */\r
+ p_in_from = _tcsstr( p_in, FromStr );\r
+ if ( p_in_from == NULL ) break;\r
+\r
+ /* In \82Ì\92\86\82Ì FromStr \82Ì\91O\82Ü\82Å In \82©\82ç Out \82Ö\83R\83s\81[\82·\82é */\r
+ copy_size = (char*)p_in_from - (char*)p_in;\r
+ out_size -= copy_size + to_size;\r
+ IF( out_size < 0 ) goto err_fa;\r
+\r
+ if ( p_out != p_in )\r
+ memcpy( p_out, p_in, copy_size );\r
+ p_in = (TCHAR*)( (char*)p_in + copy_size );\r
+ p_out = (TCHAR*)( (char*)p_out + copy_size );\r
+\r
+ /* FromStr \82ð ToStr \82É\92u\82«\8a·\82¦\82é */\r
+ memcpy( p_out, ToStr, to_size );\r
+ p_in = (TCHAR*)( (char*)p_in + from_size );\r
+ p_out = (TCHAR*)( (char*)p_out + to_size );\r
+\r
+ /* "STR_1TIME" */\r
+ if ( Opt & STR_1TIME )\r
+ { break; }\r
+ }\r
+\r
+ /* \8ec\82è\82ð In \82©\82ç Out \82Ö\83R\83s\81[\82·\82é */\r
+ #pragma warning(push)\r
+ #pragma warning(disable:4996)\r
+ if ( p_out != p_in )\r
+ _tcscpy( p_out, p_in );\r
+ p_out = NULL;\r
+ #pragma warning(pop)\r
+ }\r
+\r
+\r
+ /* \92u\8a·\82µ\82Ä\91å\82«\82\82È\82é\82Æ\82«\82Í\81A\89E\82©\82ç\8d¶\82Ö\91\96\8d¸\82·\82é */\r
+ else {\r
+\r
+ /* In \82Ì\92\86\82Ì FromStr \82ª\96³\82¢\82Æ\82«\82Í\91S\95\94\83R\83s\81[\82·\82é */\r
+ p_in_from = _tcsstr( p_in, FromStr );\r
+ if ( p_in_from == NULL ) {\r
+ if ( p_out != p_in )\r
+ StrT_cpy( Out, OutSize, In );\r
+ p_out = NULL;\r
+ }\r
+ else {\r
+ Set2a froms;\r
+ TCHAR* froms_X[10];\r
+ const TCHAR** pp_froms;\r
+ size_t plus_from_to;\r
+\r
+ Set2a_initConst( &froms, froms_X );\r
+ e= Set2a_init( &froms, froms_X, sizeof(froms_X) ); IF(e)goto fin2;\r
+\r
+\r
+ /* In \82Ì\92\86\82Ì FromStr \82Ì\91O\82Ü\82Å\83R\83s\81[\82·\82é */\r
+ copy_size = (char*)p_in_from - (char*)p_in;\r
+ out_size -= copy_size;\r
+ IF( out_size < 0 ) goto err_fa2;\r
+\r
+ memcpy( p_out, p_in, copy_size );\r
+ // p_in = (TCHAR*)( (char*)p_in + copy_size ); // \8cã\82Å\8eg\82í\82ê\82È\82¢\r
+ p_out = (TCHAR*)( (char*)p_out + copy_size );\r
+\r
+\r
+ /* In \82Ì\92\86\82Ì FromStr \82Ì\88Ê\92u\82ð froms \82Ö\8fW\82ß\82é */\r
+ for (;;) {\r
+\r
+ e= Set2a_expandIfOverByAddr( &froms, froms_X, (TCHAR**)froms.Next + 1 ); IF(e)goto fin2;\r
+ pp_froms = (const TCHAR**)froms.Next; froms.Next = (void*)( pp_froms + 1 );\r
+\r
+ *pp_froms = p_in_from;\r
+\r
+ if ( Opt & STR_1TIME )\r
+ { break; }\r
+\r
+ p_in = (const TCHAR*)( (char*)p_in_from + from_size );\r
+ p_in_from = _tcsstr( p_in, FromStr );\r
+ if ( p_in_from == NULL ) break;\r
+ }\r
+\r
+ plus_from_to = ( (TCHAR**)froms.Next - (TCHAR**)froms.First ) * (to_size - from_size);\r
+\r
+\r
+ /* In \82Ì\96\96\94ö\82Ì '\0' \82Ì\88Ê\92u\82à froms \82Ö */\r
+ e= Set2a_expandIfOverByAddr( &froms, froms_X, (TCHAR**)froms.Next + 1 ); IF(e)goto fin2;\r
+ pp_froms = (const TCHAR**)froms.Next; froms.Next = (void*)( pp_froms + 1 );\r
+ p_in = StrT_chr( p_in, _T('\0') );\r
+ *pp_froms = p_in;\r
+\r
+ copy_size = ( (char*)p_in - (char*)In ) + plus_from_to;\r
+ IF( copy_size >= OutSize ) goto err_fa2;\r
+ p_out = (TCHAR*)( (char*)Out + copy_size );\r
+ plus_from_to -= to_size - from_size;\r
+\r
+\r
+ /* \89E\82©\82ç\8d¶\82Ö\91\96\8d¸\82·\82é */\r
+ for ( pp_froms = (TCHAR**)froms.Next - 1;\r
+ pp_froms > (TCHAR**)froms.First;\r
+ pp_froms -- ) {\r
+\r
+ const TCHAR* p_in_from = *(pp_froms - 1);\r
+ const TCHAR* p_in_other = (const TCHAR*)( (char*)p_in_from + from_size );\r
+ const TCHAR* p_in_other_over = *pp_froms;\r
+ TCHAR* p_out_to = (TCHAR*)( (char*)Out + ( (char*)p_in_from - (char*)In ) + plus_from_to );\r
+ TCHAR* p_out_other = (TCHAR*)( (char*)p_out_to + to_size );\r
+\r
+ memmove( p_out_other, p_in_other, (char*)p_in_other_over - (char*)p_in_other );\r
+ memcpy( p_out_to, ToStr, to_size );\r
+\r
+ plus_from_to -= to_size - from_size;\r
+ }\r
+\r
+ goto fin2;\r
+ err_fa2: e = E_FEW_ARRAY; goto fin2;\r
+ fin2:\r
+ e= Set2a_finish( &froms, froms_X, e );\r
+ if ( e ) goto fin;\r
+ }\r
+ }\r
+\r
+ e=0;\r
+fin:\r
+ if ( p_out != NULL ) *p_out = _T('\0');\r
+ return e;\r
+\r
+err_fa: e = E_FEW_ARRAY; goto fin;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_replace1] >>> \r
+************************************************************************/\r
+errnum_t StrT_replace1( TCHAR* in_out_String, TCHAR FromCharacter, TCHAR ToCharacter,\r
+ unsigned Opt )\r
+{\r
+ TCHAR* p;\r
+\r
+ UNREFERENCED_VARIABLE( Opt );\r
+\r
+ IF ( FromCharacter == _T('\0') ) { return E_OTHERS; }\r
+\r
+ p = in_out_String;\r
+ for (;;) {\r
+ p = _tcschr( p, FromCharacter );\r
+ if ( p == NULL ) { break; }\r
+ *p = ToCharacter;\r
+ p += 1;\r
+ }\r
+\r
+ return 0;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_trim] >>> \r
+************************************************************************/\r
+errnum_t StrT_trim( TCHAR* out_Str, size_t out_Str_Size, const TCHAR* in_Str )\r
+{\r
+ const TCHAR* p1;\r
+ const TCHAR* p2;\r
+ TCHAR c;\r
+\r
+ p1 = in_Str; while ( *p1 == _T(' ') || *p1 == _T('\t') ) p1++;\r
+ for ( p2 = StrT_chr( p1, _T('\0') ) - 1; p2 >= p1; p2-- ) {\r
+ c = *p2;\r
+ if ( c != _T(' ') && c != _T('\t') && c != _T('\n') && c != _T('\r') )\r
+ break;\r
+ }\r
+ return stcpy_part_r( out_Str, out_Str_Size, out_Str, NULL, p1, p2+1 );\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_cutPart] >>> \r
+************************************************************************/\r
+errnum_t StrT_cutPart( TCHAR* in_out_String, TCHAR* in_StartOfCut, TCHAR* in_OverOfCut )\r
+{\r
+ errnum_t e;\r
+ TCHAR* over_of_cut = StrT_chr( in_StartOfCut, _T('\0') );\r
+\r
+#ifndef NDEBUG\r
+ TCHAR* over_of_string = StrT_chr( in_out_String, _T('\0') );\r
+\r
+ ASSERT_D( over_of_cut == over_of_string, e=E_OTHERS; goto fin );\r
+ ASSERT_D( in_StartOfCut >= in_out_String, e=E_OTHERS; goto fin );\r
+ ASSERT_D( in_StartOfCut <= over_of_string, e=E_OTHERS; goto fin );\r
+ ASSERT_D( in_OverOfCut >= in_out_String, e=E_OTHERS; goto fin );\r
+ ASSERT_D( in_OverOfCut <= over_of_string, e=E_OTHERS; goto fin );\r
+ ASSERT_D( in_StartOfCut <= in_OverOfCut, e=E_OTHERS; goto fin );\r
+#endif\r
+ UNREFERENCED_VARIABLE( in_out_String );\r
+\r
+ memmove( in_StartOfCut, in_OverOfCut,\r
+ PointerType_diff( over_of_cut + 1, in_OverOfCut ) );\r
+\r
+ e=0;\r
+#ifndef NDEBUG\r
+fin:\r
+#endif\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_cutLastOf] >>> \r
+************************************************************************/\r
+errnum_t StrT_cutLastOf( TCHAR* in_out_Str, TCHAR Charactor )\r
+{\r
+ TCHAR* last = StrT_chr( in_out_Str, _T('\0') );\r
+\r
+ if ( last > in_out_Str ) {\r
+ if ( *( last - 1 ) == Charactor )\r
+ { *( last - 1 ) = _T('\0'); }\r
+ }\r
+ return 0;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_cutLineComment] >>> \r
+************************************************************************/\r
+errnum_t StrT_cutLineComment( TCHAR* out_Str, size_t out_Str_Size, const TCHAR* in_Str, const TCHAR* CommentSign )\r
+{\r
+ const TCHAR* p1;\r
+ const TCHAR* p2;\r
+ TCHAR c;\r
+\r
+ p1 = in_Str; while ( *p1 == _T(' ') || *p1 == _T('\t') ) p1++;\r
+\r
+ p2 = _tcsstr( p1, CommentSign );\r
+ if ( p2 == NULL ) p2 = StrT_chr( p1, _T('\0') );\r
+\r
+ for ( p2 = p2 - 1; p2 >= p1; p2-- ) {\r
+ c = *p2;\r
+ if ( c != _T(' ') && c != _T('\t') && c != _T('\n') && c != _T('\r') )\r
+ break;\r
+ }\r
+ return stcpy_part_r( out_Str, out_Str_Size, out_Str, NULL, p1, p2+1 );\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_insert] >>> \r
+************************************************************************/\r
+errnum_t StrT_insert( TCHAR* in_out_WholeString, size_t in_MaxSize_of_WholeString,\r
+ TCHAR* in_out_Target_in_WholeString, TCHAR** out_NextTarget_in_WholeString,\r
+ const TCHAR* in_InsertString )\r
+{\r
+ errnum_t e;\r
+ TCHAR* over_of_whole_string = StrT_chr( in_out_WholeString, _T('\0') );\r
+ size_t insert_length = _tcslen( in_InsertString );\r
+\r
+ ASSERT_D( in_out_Target_in_WholeString >= in_out_WholeString, e=E_OTHERS; goto fin );\r
+ ASSERT_D( in_out_Target_in_WholeString <= over_of_whole_string, e=E_OTHERS; goto fin );\r
+\r
+ ASSERT_R( PointerType_diff( over_of_whole_string + 1, in_out_WholeString ) + ( insert_length * sizeof(TCHAR) )\r
+ <= in_MaxSize_of_WholeString, e=E_FEW_ARRAY; goto fin );\r
+\r
+ memmove( in_out_Target_in_WholeString + insert_length, in_out_Target_in_WholeString,\r
+ PointerType_diff( over_of_whole_string + 1, in_out_Target_in_WholeString ) );\r
+\r
+ memcpy( in_out_Target_in_WholeString, in_InsertString, insert_length * sizeof(TCHAR) );\r
+\r
+ if ( out_NextTarget_in_WholeString != NULL ) {\r
+ *out_NextTarget_in_WholeString = in_out_Target_in_WholeString + insert_length;\r
+ }\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrHS_insert] >>> \r
+************************************************************************/\r
+errnum_t StrHS_insert( TCHAR** in_out_WholeString,\r
+ int in_TargetIndexInWholeString, int* out_NextWholeInWholeString,\r
+ const TCHAR* in_InsertString )\r
+{\r
+ errnum_t e;\r
+ TCHAR* string = *in_out_WholeString;\r
+ size_t target_length = _tcslen( string );\r
+ size_t insert_length = _tcslen( in_InsertString );\r
+ size_t max_size = _msize( string ) / sizeof( TCHAR );\r
+ size_t new_max_size = target_length + insert_length + 1;\r
+ TCHAR* next_target;\r
+\r
+\r
+ if ( max_size < new_max_size ) {\r
+ TCHAR* new_string = (TCHAR*) realloc( string, new_max_size * sizeof( TCHAR ) );\r
+\r
+ IF ( new_string == NULL ) { e=E_FEW_MEMORY; goto fin; }\r
+ max_size = new_max_size;\r
+ string = new_string;\r
+ }\r
+\r
+ e= StrT_insert( string, max_size * sizeof( TCHAR ),\r
+ string + in_TargetIndexInWholeString, &next_target,\r
+ in_InsertString ); IF(e){goto fin;}\r
+\r
+ if ( out_NextWholeInWholeString != NULL ) {\r
+ *out_NextWholeInWholeString = next_target - string;\r
+ }\r
+\r
+ e=0;\r
+fin:\r
+ *in_out_WholeString = string;\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrHS_printfPartV] >>> \r
+************************************************************************/\r
+errnum_t StrHS_printfPartV( TCHAR** in_out_String,\r
+ int in_IndexInString, int* out_NextIndexInString,\r
+ const TCHAR* in_Format, va_list in_VaList )\r
+{\r
+ enum { first_max_size = 40 };\r
+ enum { size_times = 4 };\r
+\r
+ errnum_t e;\r
+ size_t max_size;\r
+ TCHAR* string = *in_out_String;\r
+\r
+\r
+ if ( string == NULL ) {\r
+ max_size = 0;\r
+\r
+ ASSERT_R( in_IndexInString == 0, e=E_OTHERS; goto fin );\r
+ }\r
+ else {\r
+ max_size = _msize( string ) / sizeof( TCHAR );\r
+\r
+ ASSERT_R( in_IndexInString >= 0 && (size_t) in_IndexInString < max_size,\r
+ e=E_OTHERS; goto fin );\r
+ ASSERT_D( (size_t) in_IndexInString <= _tcslen( string ), __noop() );\r
+ }\r
+\r
+\r
+ if ( string == NULL ) {\r
+ string = (TCHAR*) malloc( first_max_size * sizeof( TCHAR ) );\r
+ max_size = first_max_size;\r
+ }\r
+\r
+\r
+ for (;;) {\r
+\r
+ #if _MSC_VER\r
+ #pragma warning(push)\r
+ #pragma warning(disable: 4996)\r
+ #endif\r
+\r
+ #ifdef _UNICODE\r
+ int r = _vsnwprintf( string + in_IndexInString, max_size - in_IndexInString,\r
+ in_Format, in_VaList );\r
+ #else\r
+ int r = _vsnprintf( string + in_IndexInString, max_size - in_IndexInString,\r
+ in_Format, in_VaList );\r
+ #endif\r
+\r
+ #if _MSC_VER\r
+ #pragma warning(pop)\r
+ #endif\r
+\r
+ if ( r >= 0 ) {\r
+ if ( out_NextIndexInString != NULL ) {\r
+ *out_NextIndexInString = in_IndexInString + r;\r
+ }\r
+\r
+ break;\r
+ }\r
+\r
+ {\r
+ size_t new_max_size = max_size * size_times + first_max_size;\r
+ TCHAR* new_string = (TCHAR*) realloc( string, new_max_size * sizeof( TCHAR ) );\r
+\r
+ IF ( new_string == NULL ) { e=E_FEW_MEMORY; goto fin; }\r
+ max_size = new_max_size;\r
+ string = new_string;\r
+ }\r
+ }\r
+\r
+ e=0;\r
+fin:\r
+ *in_out_String = string;\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrHS_printfPart] >>> \r
+************************************************************************/\r
+errnum_t StrHS_printfPart( TCHAR** in_out_String,\r
+ int in_IndexInString, int* out_NextIndexInString,\r
+ const TCHAR* in_Format, ... )\r
+{\r
+ errnum_t e;\r
+ va_list va;\r
+ va_start( va, in_Format );\r
+\r
+ e = StrHS_printfPartV( in_out_String, in_IndexInString, out_NextIndexInString, in_Format, va );\r
+\r
+ va_end( va );\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrHS_printfV] >>> \r
+************************************************************************/\r
+errnum_t StrHS_printfV( TCHAR** in_out_String,\r
+ const TCHAR* in_Format, va_list in_VaList )\r
+{\r
+ return StrHS_printfPartV( in_out_String, 0, NULL, in_Format, in_VaList );\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrHS_printf] >>> \r
+************************************************************************/\r
+errnum_t StrHS_printf( TCHAR** in_out_String,\r
+ const TCHAR* in_Format, ... )\r
+{\r
+ errnum_t e;\r
+ va_list va;\r
+ va_start( va, in_Format );\r
+\r
+ e = StrHS_printfPartV( in_out_String, 0, NULL, in_Format, va );\r
+\r
+ va_end( va );\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/**************************************************************************\r
+ <<< [StrT_meltCSV] >>> \r
+*************************************************************************/\r
+errnum_t StrT_meltCSV( TCHAR* out_Str, size_t out_Str_Size, const TCHAR** pCSV )\r
+{\r
+ errnum_t e = 0;\r
+ TCHAR* t;\r
+ TCHAR* t_last = (TCHAR*)( (char*)out_Str + out_Str_Size - sizeof(TCHAR) );\r
+ const TCHAR* s;\r
+ TCHAR dummy[2];\r
+ TCHAR c;\r
+\r
+ t = out_Str;\r
+ s = *pCSV;\r
+ if ( out_Str_Size <= 1 ) { t = dummy; t_last = dummy; }\r
+\r
+ if ( s == NULL ) { *t = _T('\0'); return 0; }\r
+\r
+\r
+ /* \93ª\82Ì\8bó\94\92\82ð\8f\9c\82 */\r
+ while ( *s == _T(' ') || *s == _T('\t') ) s++;\r
+\r
+ switch ( *s ) {\r
+\r
+ /* "" \82Å\88Í\82Ü\82ê\82Ä\82¢\82é\8fê\8d\87 */\r
+ case _T('"'):\r
+ s++;\r
+ c = *s;\r
+ while ( c != _T('"') || *(s+1) == _T('"') ) { /* " \95¶\8e\9a\82Ü\82Å */\r
+ if ( t == t_last ) { e = E_FEW_ARRAY; t = dummy; t_last = dummy + 1; }\r
+ if ( c == *(s+1) && c == _T('"') ) s++; /* " \95¶\8e\9a\8e©\91Ì */\r
+ if ( c == _T('\0') ) break;\r
+ *t = c; t++; s++; c = *s;\r
+ }\r
+ *t = _T('\0');\r
+\r
+ s++;\r
+ for (;;) {\r
+ if ( *s == _T(',') ) { s = s+1; break; }\r
+ if ( *s == _T('\0') ) { s = NULL; break; }\r
+ s++;\r
+ }\r
+ *pCSV = s;\r
+ return e;\r
+\r
+ /* \8bó\82Ì\8d\80\96Ú\82Ì\8fê\8d\87 */\r
+ case ',':\r
+ *t = _T('\0');\r
+ *pCSV = s+1;\r
+ return 0;\r
+\r
+ case '\0':\r
+ *t = _T('\0');\r
+ *pCSV = NULL;\r
+ return 0;\r
+\r
+ /* "" \82Å\88Í\82Ü\82ê\82Ä\82¢\82È\82¢\8fê\8d\87 */\r
+ default: {\r
+ TCHAR* sp = NULL; /* \8dÅ\8cã\82Ì\98A\91±\82µ\82½\8bó\94\92\82Ì\90æ\93ª */\r
+\r
+ c = *s;\r
+ while ( c != _T(',') && c != _T('\0') && c != _T('\r') && c != _T('\n') ) { /* , \95¶\8e\9a\82Ü\82Å */\r
+\r
+ /* sp \82ð\90Ý\92è\82·\82é */\r
+ if ( c == ' ' ) {\r
+ if ( sp == NULL ) sp = t;\r
+ }\r
+ else sp = NULL;\r
+\r
+ if ( t == t_last ) { e = E_FEW_ARRAY; t = dummy; t_last = dummy + 1; }\r
+\r
+ /* \83R\83s\81[\82·\82é */\r
+ *t = c; t++; s++; c = *s;\r
+ }\r
+\r
+ /* \95Ô\82è\92l\82ð\8c\88\92è\82·\82é */\r
+ if ( c == _T(',') ) s = s + 1;\r
+ else s = NULL;\r
+\r
+ /* \96\96\94ö\82Ì\8bó\94\92\82ð\8eæ\82è\8f\9c\82 */\r
+ if ( sp != NULL ) *sp = '\0';\r
+ else *t = _T('\0');\r
+\r
+ *pCSV = s;\r
+ return e;\r
+ }\r
+ }\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_parseCSV_f] >>> \r
+************************************************************************/\r
+errnum_t StrT_parseCSV_f( const TCHAR* StringOfCSV, bit_flags32_t* out_ReadFlags, const TCHAR* Types, ... )\r
+{\r
+ errnum_t e;\r
+ TCHAR type;\r
+ int types_index;\r
+ va_list va;\r
+ bool is_next_omittable;\r
+ bool is_next_omit;\r
+ const TCHAR* column_pointer;\r
+ TCHAR a_char;\r
+ TCHAR column[ 32 ];\r
+ bit_flags32_t read_flags;\r
+ bit_flags32_t next_read_flag;\r
+ TCHAR* out_str;\r
+ size_t str_size = SIZE_MAX; /* SIZE_MAX = Avoid warning */\r
+\r
+\r
+ va_start( va, Types );\r
+ types_index = 0;\r
+ is_next_omittable = false;\r
+ column_pointer = StringOfCSV;\r
+ read_flags = 0;\r
+ next_read_flag = 1;\r
+ while ( column_pointer != NULL ) {\r
+ out_str = NULL;\r
+\r
+ type = Types[ types_index ];\r
+ switch ( type ) {\r
+ case _T('\0'):\r
+ goto exit_for;\r
+\r
+ case _T('+'):\r
+ is_next_omittable = true;\r
+ break;\r
+\r
+ case _T('s'):\r
+ out_str = va_arg( va, TCHAR* );\r
+ str_size = va_arg( va, size_t );\r
+ ASSERT_D( str_size >= 1, e=E_OTHERS; goto fin );\r
+ break;\r
+\r
+ default:\r
+ out_str = column;\r
+ str_size = sizeof( column );\r
+ break;\r
+ }\r
+\r
+ if ( out_str != NULL ) {\r
+\r
+ // Set "out_str" : Column string in CSV\r
+ column_pointer = StrT_skip( column_pointer, _T(" \t") );\r
+ a_char = *column_pointer;\r
+ if ( is_next_omittable && ( a_char == _T('\0') || a_char == _T(',') ) ) {\r
+ column_pointer = StrT_chrs( column_pointer, _T(",") );\r
+ if ( column_pointer != NULL ) { column_pointer += 1; }\r
+ is_next_omit = true;\r
+ } else {\r
+ e= StrT_meltCSV( out_str, str_size, &column_pointer ); IF(e){goto fin;}\r
+\r
+ is_next_omit = false;\r
+ read_flags |= next_read_flag;\r
+ }\r
+\r
+ switch ( type ) {\r
+ case _T('s'):\r
+ /* "va_arg" was already called */\r
+ break;\r
+\r
+ case _T('i'): {\r
+ int* pointer_of_int = va_arg( va, int* );\r
+\r
+ if ( ! is_next_omit ) {\r
+ *pointer_of_int = ttoi_ex( column, 0 );\r
+ }\r
+ break;\r
+ }\r
+ case _T('f'): {\r
+ double* pointer_of_double = va_arg( va, double* );\r
+\r
+ if ( ! is_next_omit ) {\r
+ *pointer_of_double = _tstof( column );\r
+ }\r
+ break;\r
+ }\r
+ case _T('b'): {\r
+ bool* pointer_of_bool = va_arg( va, bool* );\r
+ int strings_index;\r
+ static const TCHAR* strings[] = {\r
+ _T("1"), _T("true"), _T("yes"),\r
+ };\r
+\r
+ if ( ! is_next_omit ) {\r
+ *pointer_of_bool = false;\r
+ for ( strings_index = 0;\r
+ strings_index < _countof( strings );\r
+ strings_index += 1 )\r
+ {\r
+ if ( _tcsicmp( column, strings[ strings_index ] ) == 0 ) {\r
+ *pointer_of_bool = true;\r
+ break;\r
+ }\r
+ }\r
+ }\r
+ break;\r
+ }\r
+ case _T('t'): {\r
+ SYSTEMTIME* pointer_of_time = va_arg( va, SYSTEMTIME* );\r
+ int* pointer_of_bias = va_arg( va, int* );\r
+\r
+ if ( ! is_next_omit ) {\r
+ e= W3CDTF_toSYSTEMTIME( column, pointer_of_time, pointer_of_bias );\r
+ IF(e){goto fin;}\r
+ }\r
+ break;\r
+ }\r
+\r
+ default:\r
+ ASSERT_R( false, e=E_OTHERS; goto fin );\r
+ }\r
+\r
+ is_next_omittable = false;\r
+ next_read_flag <<= 1;\r
+ }\r
+\r
+ types_index += 1;\r
+ }\r
+exit_for:\r
+ if ( out_ReadFlags != NULL ) {\r
+ *out_ReadFlags = read_flags;\r
+ }\r
+\r
+ e=0;\r
+fin:\r
+ va_end( va );\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/**************************************************************************\r
+ <<< [StrT_changeToXML_Attribute] >>> \r
+*************************************************************************/\r
+errnum_t StrT_changeToXML_Attribute( TCHAR* out_Str, size_t Str_Size, const TCHAR* InputStr )\r
+{\r
+ errnum_t e;\r
+\r
+ e= StrT_replace( out_Str, Str_Size, InputStr, _T("&"), _T("&"), 0 ); IF(e)goto fin;\r
+ e= StrT_replace( out_Str, Str_Size, out_Str, _T("\""), _T("""), 0 ); IF(e)goto fin;\r
+ e= StrT_replace( out_Str, Str_Size, out_Str, _T("<"), _T("<"), 0 ); IF(e)goto fin;\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/**************************************************************************\r
+ <<< [StrT_resumeFromXML_Attribute] >>> \r
+*************************************************************************/\r
+errnum_t StrT_resumeFromXML_Attribute( TCHAR* out_Str, size_t Str_Size, const TCHAR* XML_Attr )\r
+{\r
+ errnum_t e;\r
+\r
+ e= StrT_replace( out_Str, Str_Size, XML_Attr, _T("""), _T("\""), 0 ); IF(e)goto fin;\r
+ e= StrT_replace( out_Str, Str_Size, out_Str, _T("<"), _T("<"), 0 ); IF(e)goto fin;\r
+ e= StrT_replace( out_Str, Str_Size, out_Str, _T("&"), _T("&"), 0 ); IF(e)goto fin;\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/**************************************************************************\r
+ <<< [StrT_changeToXML_Text] >>> \r
+*************************************************************************/\r
+errnum_t StrT_changeToXML_Text( TCHAR* out_Str, size_t Str_Size, const TCHAR* InputStr )\r
+{\r
+ errnum_t e;\r
+\r
+ e= StrT_replace( out_Str, Str_Size, InputStr, _T("&"), _T("&"), 0 ); IF(e)goto fin;\r
+ e= StrT_replace( out_Str, Str_Size, out_Str, _T("<"), _T("<"), 0 ); IF(e)goto fin;\r
+ e= StrT_replace( out_Str, Str_Size, out_Str, _T(">"), _T(">"), 0 ); IF(e)goto fin;\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_getExistSymbols] >>> \r
+************************************************************************/\r
+errnum_t StrT_getExistSymbols( unsigned* out, bool bCase, const TCHAR* Str, const TCHAR* Symbols, ... )\r
+{\r
+ errnum_t e;\r
+ int i;\r
+ bool* syms_exists = NULL;\r
+ bool b_nosym = false;\r
+ TCHAR* sym = NULL;\r
+ size_t sym_size = ( _tcslen( Symbols ) + 1 ) * sizeof(TCHAR);\r
+ int n_sym = 0;\r
+ const TCHAR** syms = NULL;\r
+ const TCHAR* p;\r
+\r
+ UNREFERENCED_VARIABLE( bCase );\r
+\r
+ sym = (TCHAR*) malloc( sym_size ); IF(sym==NULL)goto err_fm;\r
+\r
+\r
+ //=== Get Symbols\r
+ p = Symbols;\r
+ do {\r
+ e= StrT_meltCSV( sym, sym_size, &p ); IF(e)goto fin;\r
+ if ( sym[0] != _T('\0') ) n_sym ++;\r
+ } while ( p != NULL );\r
+\r
+ syms = (const TCHAR**) malloc( n_sym * sizeof(TCHAR*) ); IF(syms==NULL)goto err_fm;\r
+ memset( (TCHAR**) syms, 0, n_sym * sizeof(TCHAR*) );\r
+ syms_exists = (bool*) malloc( n_sym * sizeof(bool) ); IF(syms_exists==NULL)goto err_fm;\r
+ memset( syms_exists, 0, n_sym * sizeof(bool) );\r
+\r
+ p = Symbols; i = 0;\r
+ do {\r
+ e= StrT_meltCSV( sym, sym_size, &p ); IF(e)goto fin;\r
+ if ( sym[0] != _T('\0') ) {\r
+ e= MallocAndCopyString( &syms[i], sym ); IF(e)goto fin;\r
+ i++;\r
+ }\r
+ } while ( p != NULL );\r
+\r
+\r
+ //=== Check Str whether having Symbols\r
+ p = Str;\r
+ do {\r
+ e= StrT_meltCSV( sym, sym_size, &p ); IF(e)goto fin;\r
+ if ( sym[0] != _T('\0') ) {\r
+ for ( i = 0; i < n_sym; i++ ) {\r
+ if ( _tcscmp( sym, syms[i] ) == 0 ) { syms_exists[i] = true; break; }\r
+ }\r
+ if ( i == n_sym ) b_nosym = true;\r
+ }\r
+ } while ( p != NULL );\r
+\r
+\r
+ //=== Sum numbers\r
+ {\r
+ va_list va;\r
+ unsigned num;\r
+\r
+ va_start( va, Symbols );\r
+ *out = 0;\r
+ for ( i = 0; i < n_sym; i++ ) {\r
+ num = va_arg( va, unsigned );\r
+ if ( syms_exists[i] ) *out |= num;\r
+ }\r
+ va_end( va );\r
+ }\r
+\r
+ e = ( b_nosym ? E_NOT_FOUND_SYMBOL : 0 );\r
+fin:\r
+ if ( syms != NULL ) {\r
+ for ( i = 0; i < n_sym; i++ ) {\r
+ e= HeapMemory_free( &syms[i], e );\r
+ }\r
+ free( (TCHAR**) syms );\r
+ }\r
+ e= HeapMemory_free( &syms_exists, e );\r
+ e= HeapMemory_free( &sym, e );\r
+ return e;\r
+err_fm: e= E_FEW_MEMORY; goto fin;\r
+}\r
+\r
+ \r
+/**************************************************************************\r
+ <<< [StrT_meltCmdLine] >>> \r
+*************************************************************************/\r
+errnum_t StrT_meltCmdLine( TCHAR* out_Str, size_t out_Str_Size, const TCHAR** pLine )\r
+{\r
+ errnum_t e = 0;\r
+ TCHAR* t;\r
+ TCHAR* t_last = (TCHAR*)( (char*)out_Str + out_Str_Size - sizeof(TCHAR) );\r
+ const TCHAR* s;\r
+ TCHAR dummy;\r
+ TCHAR c;\r
+\r
+ t = out_Str;\r
+ s = *pLine;\r
+ if ( out_Str_Size <= 1 ) { t = &dummy; t_last = &dummy; }\r
+\r
+ if ( s == NULL ) { *t = _T('\0'); return 0; }\r
+\r
+\r
+ /* \93ª\82Ì\8bó\94\92\82ð\8f\9c\82 */\r
+ while ( *s == _T(' ') || *s == _T('\t') ) s++;\r
+\r
+ switch ( *s ) {\r
+\r
+ /* "" \82Å\88Í\82Ü\82ê\82Ä\82¢\82é\8fê\8d\87 */\r
+ case _T('"'):\r
+ s++;\r
+ c = *s;\r
+ while ( c != _T('"') || *(s+1) == _T('"') ) { /* " \95¶\8e\9a\82Ü\82Å */\r
+ if ( t == t_last ) { e = E_FEW_ARRAY; t = &dummy; t_last = &dummy + 1; }\r
+ if ( c == *(s+1) && c == _T('"') ) s++; /* " \95¶\8e\9a\8e©\91Ì */\r
+ if ( c == _T('\0') ) break;\r
+ *t = c; t++; s++; c = *s;\r
+ }\r
+ *t = _T('\0');\r
+\r
+ s++;\r
+ for (;;) {\r
+ if ( *s == _T(' ') ) { s = s+1; break; }\r
+ if ( *s == _T('\0') ) { s = NULL; break; }\r
+ s++;\r
+ }\r
+ *pLine = s;\r
+ return e;\r
+\r
+ case '\0':\r
+ *t = _T('\0');\r
+ *pLine = NULL;\r
+ return 0;\r
+\r
+ /* "" \82Å\88Í\82Ü\82ê\82Ä\82¢\82È\82¢\8fê\8d\87 */\r
+ default: {\r
+ c = *s;\r
+ while ( c != _T(' ') && c != _T('\0') && c != _T('\r') && c != _T('\n') ) { /* \8bó\94\92\95¶\8e\9a\82Ü\82Å */\r
+\r
+ if ( t == t_last ) { e = E_FEW_ARRAY; t = &dummy; t_last = &dummy + 1; }\r
+\r
+ /* \83R\83s\81[\82·\82é */\r
+ *t = c; t++; s++; c = *s;\r
+ }\r
+\r
+ /* *pLine\82ð\8c\88\92è\82·\82é */\r
+ while ( *s == _T(' ') ) s = s + 1;\r
+ if ( *s == _T('\0') ) s = NULL;\r
+\r
+ /* \96\96\94ö */\r
+ *t = _T('\0');\r
+\r
+ *pLine = s;\r
+ return e;\r
+ }\r
+ }\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [W3CDTF_fromSYSTEMTIME] >>> \r
+************************************************************************/\r
+errnum_t W3CDTF_fromSYSTEMTIME( TCHAR* out_W3CDTF, size_t W3CDTF_ByteSize,\r
+ const SYSTEMTIME* Time, int TimeZoneMinute )\r
+{\r
+ errnum_t e;\r
+ TCHAR* char_pointer = out_W3CDTF;\r
+\r
+ e= stprintf_part_r( out_W3CDTF, W3CDTF_ByteSize, char_pointer, &char_pointer,\r
+ _T("%04d-%02d-%02dT%02d:%02d:%02d.%03d"),\r
+ Time->wYear, Time->wMonth, Time->wDay,\r
+ Time->wHour, Time->wMinute, Time->wSecond, Time->wMilliseconds );\r
+ IF(e){goto fin;}\r
+\r
+ e= W3CDTF_getTimeZoneDesignator( char_pointer,\r
+ GetStringSizeFromPointer( out_W3CDTF, W3CDTF_ByteSize, char_pointer ),\r
+ TimeZoneMinute ); IF(e){goto fin;}\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [W3CDTF_toSYSTEMTIME] >>> \r
+************************************************************************/\r
+errnum_t W3CDTF_toSYSTEMTIME( const TCHAR* String, SYSTEMTIME* out_Time, int* out_BiasMinute )\r
+{\r
+ errnum_t e;\r
+ size_t string_length = _tcslen( String );\r
+\r
+ /* 01234567890123456789012345678 */\r
+ /*"yyyy-mm-ddThh:mm:ss.sss+00:00"*/\r
+ /*"0000-00-00T00:00+00:00"*/\r
+\r
+ IF_D( out_BiasMinute == NULL ) { e=E_OTHERS; goto fin; }\r
+\r
+ /* With time */\r
+ if ( string_length >= 11 ) {\r
+ TCHAR a_char;\r
+ const TCHAR* time_zone;\r
+ int number;\r
+\r
+ IF ( String[10] != _T('T') ) { e=E_NOT_FOUND_SYMBOL; goto fin; }\r
+ IF ( String[4] != _T('-') || String[7] != _T('-') )\r
+ { e=E_NOT_FOUND_SYMBOL; goto fin; }\r
+\r
+ IF ( string_length < 16 ) { e=E_NOT_FOUND_SYMBOL; goto fin; }\r
+ IF ( String[13] != _T(':') ) { e=E_NOT_FOUND_SYMBOL; goto fin; }\r
+\r
+ out_Time->wYear = (WORD) _ttoi( &String[0] );\r
+ out_Time->wMonth = (WORD) _ttoi( &String[5] );\r
+ out_Time->wDayOfWeek = 0;\r
+ out_Time->wDay = (WORD) _ttoi( &String[8] );\r
+ out_Time->wHour = (WORD) _ttoi( &String[11] );\r
+ out_Time->wMinute = (WORD) _ttoi( &String[14] );\r
+\r
+ a_char = String[16];\r
+ if ( a_char == _T('+') || a_char == _T('-') || a_char == _T('Z') ) {\r
+ time_zone = &String[16];\r
+ out_Time->wSecond = 0;\r
+ out_Time->wMilliseconds = 0;\r
+ } else {\r
+ /* Second */\r
+ IF ( string_length < 19 ) { e=E_NOT_FOUND_SYMBOL; goto fin; }\r
+ IF ( a_char != _T(':') ) { e=E_NOT_FOUND_SYMBOL; goto fin; }\r
+ out_Time->wSecond = (WORD) _ttoi( &String[17] );\r
+\r
+\r
+ /* \8f¬\90\94\93_ */\r
+ a_char = String[19];\r
+ if ( a_char == _T('+') || a_char == _T('-') || a_char == _T('Z') ) {\r
+ time_zone = &String[19];\r
+ out_Time->wMilliseconds = 0;\r
+ }\r
+ else {\r
+ IF ( a_char != _T('.') ) { e=E_NOT_FOUND_SYMBOL; goto fin; }\r
+\r
+ out_Time->wMilliseconds = 0;\r
+\r
+ number = String[20] - _T('0');\r
+ if ( number < 0 || number > 9 ) {\r
+ time_zone = &String[20];\r
+ } else {\r
+ out_Time->wMilliseconds += (WORD)( number * 100 );\r
+\r
+ number = String[21] - _T('0');\r
+ if ( number < 0 || number > 9 ) {\r
+ time_zone = &String[21];\r
+ } else {\r
+ out_Time->wMilliseconds += (WORD)( number * 10 );\r
+\r
+ number = String[22] - _T('0');\r
+ if ( number < 0 || number > 9 ) {\r
+ time_zone = &String[22];\r
+ } else {\r
+ const TCHAR* pointer = &String[23];\r
+\r
+ out_Time->wMilliseconds += (WORD)( number * 1 );\r
+\r
+ for (;;) {\r
+ number = *pointer - _T('0');\r
+ if ( number < 0 || number > 9 )\r
+ { break; }\r
+\r
+ pointer += 1;\r
+ }\r
+ time_zone = pointer;\r
+ }\r
+ }\r
+ }\r
+\r
+ a_char = *time_zone;\r
+ IF ( ! ( a_char == _T('+') || a_char == _T('-') || a_char == _T('Z') ) )\r
+ { e=E_NOT_FOUND_SYMBOL; goto fin; }\r
+ }\r
+ }\r
+\r
+ /* Time zone */\r
+ if ( a_char == _T('Z') ) {\r
+ *out_BiasMinute = 0;\r
+ }\r
+ else {\r
+ size_t time_zone_length = string_length - ( time_zone - String );\r
+ int bias_minute;\r
+\r
+ IF ( time_zone_length < 6 ) { e=E_NOT_FOUND_SYMBOL; goto fin; }\r
+ IF ( time_zone[3] != _T(':') ) { e=E_NOT_FOUND_SYMBOL; goto fin; }\r
+\r
+ bias_minute = _ttoi( &time_zone[1] ) * 60 + _ttoi( &time_zone[4] );\r
+ if ( a_char == _T('-') ) { bias_minute = -bias_minute; }\r
+ *out_BiasMinute = bias_minute;\r
+ }\r
+ }\r
+\r
+ /* Without time */\r
+ else {\r
+ out_Time->wDayOfWeek = 0;\r
+ out_Time->wHour = 0;\r
+ out_Time->wMinute = 0;\r
+ out_Time->wSecond = 0;\r
+ out_Time->wMilliseconds = 0;\r
+ *out_BiasMinute = 0;\r
+\r
+ IF ( string_length < 4 ) { e=E_NOT_FOUND_SYMBOL; goto fin; }\r
+\r
+ /* Year */\r
+ out_Time->wYear = (WORD) _ttoi( &String[0] );\r
+\r
+ /* Month */\r
+ if ( string_length > 4 ) {\r
+ IF ( string_length < 7 ) { e=E_NOT_FOUND_SYMBOL; goto fin; }\r
+ IF ( String[4] != _T('-') ) { e=E_NOT_FOUND_SYMBOL; goto fin; }\r
+ out_Time->wMonth = (WORD) _ttoi( &String[5] );\r
+ } else {\r
+ out_Time->wMonth = 1;\r
+ }\r
+\r
+ /* Day */\r
+ if ( string_length > 7 ) {\r
+ IF ( string_length < 10 ) { e=E_NOT_FOUND_SYMBOL; goto fin; }\r
+ IF ( String[7] != _T('-') ) { e=E_NOT_FOUND_SYMBOL; goto fin; }\r
+ out_Time->wDay = (WORD) _ttoi( &String[8] );\r
+ } else {\r
+ out_Time->wDay = 1;\r
+ }\r
+ }\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [W3CDTF_getTimeZoneDesignator] >>> \r
+************************************************************************/\r
+errnum_t W3CDTF_getTimeZoneDesignator( TCHAR* out_TZD, size_t TZD_ByteSize,\r
+ int BiasMinute )\r
+{\r
+ errnum_t e;\r
+ TCHAR sign;\r
+ TIME_ZONE_INFORMATION time_zone;\r
+\r
+\r
+ /* Set "BiasMinute" */\r
+ if ( BiasMinute == W3CDTF_CURRENT_TIME_ZONE ) {\r
+ GetTimeZoneInformation( &time_zone );\r
+ BiasMinute = -time_zone.Bias;\r
+ }\r
+ else {\r
+ enum { minute_1day = 1440 };\r
+\r
+ IF_D ( BiasMinute < -minute_1day || BiasMinute > minute_1day )\r
+ { e=E_OTHERS; goto fin; }\r
+ }\r
+\r
+\r
+ /* Set "sign" */\r
+ if ( BiasMinute >= 0 ) {\r
+ sign = _T('+');\r
+ } else {\r
+ sign = _T('-');\r
+ BiasMinute = -BiasMinute;\r
+ }\r
+\r
+\r
+ /* Set "out_TZD" */\r
+ _stprintf_s( out_TZD, TZD_ByteSize / sizeof(TCHAR), _T("%c%02d:%02d"),\r
+ sign, BiasMinute / 60, BiasMinute % 60 );\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_isFullPath] >>> \r
+************************************************************************/\r
+bool StrT_isFullPath( const TCHAR* path )\r
+{\r
+ bool ret;\r
+\r
+ if ( path[0] == _T('\\') && path[1] == _T('\\') ) {\r
+ ret = true;\r
+ } else {\r
+ const TCHAR* back_slash = _tcschr( path, _T('\\') );\r
+ const TCHAR* slash = _tcschr( path, _T('/') );\r
+ const TCHAR* colon = _tcschr( path, _T(':') );\r
+\r
+ if ( colon != NULL ) {\r
+ const TCHAR* p;\r
+\r
+ for ( p = path; p < colon; p += 1 ) {\r
+ if ( ! _istalnum( *p ) ) {\r
+ colon = NULL;\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+ ret = ( colon != NULL ) &&\r
+ ( back_slash == colon + 1 || slash == colon + 1 );\r
+ }\r
+\r
+ return ret;\r
+}\r
+\r
+ \r
+/**************************************************************************\r
+ <<< [StrT_getFullPath_part] >>> \r
+*************************************************************************/\r
+errnum_t StrT_getFullPath_part( TCHAR* out_FullPath, size_t FullPathSize, TCHAR* OutStart,\r
+ TCHAR** out_OutLast, const TCHAR* StepPath, const TCHAR* BasePath )\r
+{\r
+ errnum_t e;\r
+ TCHAR separator = (TCHAR) DUMMY_INITIAL_VALUE_TCHAR;\r
+ const TCHAR* separator_path;\r
+ TCHAR* out_full_path_over = (TCHAR*)( (uint8_t*) out_FullPath + FullPathSize );\r
+ TCHAR* null_position = NULL;\r
+\r
+ #if CHECK_ARG\r
+ /* "BasePath" must be out of "out_FullPath" */\r
+ ASSERT_R( BasePath < out_FullPath ||\r
+ (uint8_t*) BasePath >= (uint8_t*) out_FullPath + FullPathSize,\r
+ goto err );\r
+ #endif\r
+\r
+\r
+ /* If "StepPath" == "", out_FullPath = "" */\r
+ if ( StepPath[0] == _T('\0') ) {\r
+ ASSERT_R( FullPathSize >= sizeof(TCHAR), goto err_fm );\r
+ out_FullPath[0] = _T('\0');\r
+ e=0; goto fin;\r
+ }\r
+\r
+\r
+ /* Set "OutStart" */\r
+ if ( OutStart == NULL )\r
+ { OutStart = out_FullPath; }\r
+\r
+\r
+ /* Set "separator" : \ or / from "BasePath" */\r
+ if ( StrT_isFullPath( StepPath ) ) {\r
+ separator_path = StepPath;\r
+ }\r
+ else if ( BasePath == NULL ) {\r
+ separator = _T('\\');\r
+ separator_path = NULL;\r
+ }\r
+ else {\r
+ separator_path = BasePath;\r
+ }\r
+ if ( separator_path != NULL ) {\r
+ const TCHAR* p;\r
+ const TCHAR* p2;\r
+\r
+ p = _tcschr( separator_path, _T('\\') );\r
+ p2 = _tcschr( separator_path, _T('/') );\r
+ if ( p == NULL ) {\r
+ if ( p2 == NULL )\r
+ { separator = _T('\\'); }\r
+ else\r
+ { separator = _T('/'); }\r
+ } else {\r
+ if ( p2 == NULL )\r
+ { separator = _T('\\'); }\r
+ else {\r
+ if ( p < p2 )\r
+ { separator = _T('\\'); }\r
+ else\r
+ { separator = _T('/'); }\r
+ }\r
+ }\r
+ }\r
+\r
+\r
+ /* Set "OutStart" : "BasePath" + / + "StepPath" */\r
+ if ( StrT_isFullPath( StepPath ) ) {\r
+ size_t step_path_length = _tcslen( StepPath );\r
+\r
+ IF( OutStart + step_path_length >= out_full_path_over ) goto err_fa;\r
+ memmove( OutStart, StepPath, ( step_path_length + 1 ) * sizeof(TCHAR) );\r
+\r
+ /* Set "null_position" */\r
+ null_position = OutStart + step_path_length;\r
+ }\r
+ else {\r
+ TCHAR c;\r
+ TCHAR* p;\r
+ size_t base_path_length;\r
+ size_t step_path_length = _tcslen( StepPath );\r
+\r
+ if ( BasePath == NULL ) {\r
+ base_path_length = GetCurrentDirectory( 0, NULL ) - 1;\r
+ }\r
+ else {\r
+ base_path_length = _tcslen( BasePath );\r
+ c = BasePath[ base_path_length - 1 ];\r
+ if ( c == _T('\\') || c == _T('/') )\r
+ { base_path_length -= 1; }\r
+ }\r
+\r
+ p = OutStart + base_path_length + 1;\r
+ IF( p + step_path_length >= out_full_path_over ) goto err_fa;\r
+ memmove( p, StepPath, ( step_path_length + 1 ) * sizeof(TCHAR) );\r
+ /* memmove is for "out_FullPath" == "StepPath" */\r
+\r
+ if ( BasePath == NULL ) {\r
+ GetCurrentDirectory( base_path_length + 1, OutStart );\r
+ if ( OutStart[ base_path_length - 1 ] == _T('\\') )\r
+ { base_path_length -= 1; }\r
+ } else {\r
+ memcpy( OutStart, BasePath, base_path_length * sizeof(TCHAR) );\r
+ }\r
+ OutStart[ base_path_length ] = separator;\r
+\r
+\r
+ /* Set "null_position" */\r
+ null_position = p + step_path_length;\r
+ }\r
+\r
+\r
+ /* Replace \ and / to "separator" in "OutStart" */\r
+ {\r
+ TCHAR other_separator;\r
+\r
+ if ( separator == _T('/') )\r
+ { other_separator = _T('\\'); }\r
+ else\r
+ { other_separator = _T('/'); }\r
+\r
+ e= StrT_replace1( OutStart, other_separator, separator, 0 ); IF(e)goto fin;\r
+ }\r
+\r
+\r
+ /* Replace \*\..\ to \ */\r
+ {\r
+ enum { length = 4 };\r
+ TCHAR parent[ length + 1 ]; /* \..\ or /../ */\r
+ TCHAR* parent_position;\r
+ TCHAR* p;\r
+\r
+ parent[0] = separator;\r
+ parent[1] = _T('.');\r
+ parent[2] = _T('.');\r
+ parent[3] = separator;\r
+ parent[4] = _T('\0');\r
+\r
+ for (;;) {\r
+ parent_position = _tcsstr( OutStart, parent );\r
+ if ( parent_position == NULL ) { break; }\r
+\r
+ p = parent_position - 1;\r
+ for (;;) {\r
+ IF( p < OutStart ) {goto err;} /* "../" are too many */\r
+ if ( *p == separator ) { break; }\r
+ p -= 1;\r
+ }\r
+\r
+ memmove( p + 1,\r
+ parent_position + length,\r
+ ( null_position - ( parent_position + length ) + 1 ) * sizeof(TCHAR) );\r
+\r
+ null_position -= ( parent_position + length ) - ( p + 1 );\r
+ }\r
+ }\r
+\r
+\r
+ /* Cut last \*\.. */\r
+ {\r
+ enum { length = 3 };\r
+ TCHAR* p;\r
+\r
+ while ( null_position - length >= OutStart ) {\r
+ if ( *( null_position - 3 ) != separator ||\r
+ *( null_position - 2 ) != _T('.') ||\r
+ *( null_position - 1 ) != _T('.') )\r
+ { break; }\r
+\r
+ p = null_position - 4;\r
+ for (;;) {\r
+ IF( p < OutStart ) {goto err;} /* "../" are too many */\r
+ if ( *p == separator ) { break; }\r
+ p -= 1;\r
+ }\r
+\r
+ *p = _T('\0');\r
+\r
+ null_position = p;\r
+ }\r
+ }\r
+\r
+\r
+ /* Replace \.\ to \ */\r
+ {\r
+ enum { length = 3 };\r
+ TCHAR current[ length + 1 ]; /* \.\ or /./ */\r
+ TCHAR* current_position;\r
+\r
+ current[0] = separator;\r
+ current[1] = _T('.');\r
+ current[2] = separator;\r
+ current[3] = _T('\0');\r
+\r
+ for (;;) {\r
+ current_position = _tcsstr( OutStart, current );\r
+ if ( current_position == NULL ) { break; }\r
+\r
+ memmove( current_position + 1,\r
+ current_position + length,\r
+ ( null_position - ( current_position + length ) + 1 ) * sizeof(TCHAR) );\r
+\r
+ null_position -= length - 1;\r
+ }\r
+ }\r
+\r
+\r
+ /* Cut last \. */\r
+ {\r
+ TCHAR* over = StrT_chr( OutStart, _T('\0') );\r
+\r
+ while ( over - 2 >= OutStart &&\r
+ *( over - 1 ) == _T('.') && *( over - 2 ) == separator ) {\r
+ over -= 2;\r
+ *over = _T('\0');\r
+ }\r
+ }\r
+\r
+\r
+ /* Add root / */\r
+ if ( null_position - 1 >= OutStart ) {\r
+ if ( *( null_position - 1 ) == _T(':') ) {\r
+ IF( null_position + 1 >= out_full_path_over ) goto err_fa;\r
+\r
+ *( null_position + 0 ) = separator;\r
+ *( null_position + 1 ) = _T('\0');\r
+ null_position += 1;\r
+ }\r
+ }\r
+\r
+\r
+ /* Set "*out_OutLast" */\r
+ if ( out_OutLast != NULL )\r
+ { *out_OutLast = null_position; }\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+\r
+err: e = E_OTHERS; goto fin;\r
+err_fa: e = E_FEW_ARRAY; goto fin;\r
+err_fm: e = E_FEW_MEMORY; goto fin;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_allocateFullPath] >>> \r
+************************************************************************/\r
+errnum_t StrT_allocateFullPath( TCHAR** out_FullPath, const TCHAR* StepPath, TCHAR* BasePath )\r
+{\r
+ errnum_t e;\r
+ int step_path_length = _tcslen( StepPath );\r
+ int base_path_length;\r
+ int full_path_size;\r
+\r
+ if ( BasePath == NULL ) {\r
+ base_path_length = GetCurrentDirectory( 0, NULL ) - 1;\r
+ } else {\r
+ base_path_length = _tcslen( BasePath );\r
+ }\r
+\r
+ full_path_size = ( step_path_length + 1 + base_path_length + 1 ) * sizeof(TCHAR);\r
+\r
+ e= HeapMemory_allocateBytes( out_FullPath, full_path_size ); IF(e){goto fin;}\r
+ e= StrT_getFullPath( *out_FullPath, full_path_size, StepPath, BasePath ); IF(e){goto fin;}\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_getParentFullPath_part] >>> \r
+************************************************************************/\r
+errnum_t StrT_getParentFullPath_part( TCHAR* Str, size_t StrSize, TCHAR* StrStart,\r
+ TCHAR** out_StrLast, const TCHAR* StepPath, const TCHAR* BasePath )\r
+{\r
+ errnum_t e;\r
+ TCHAR* p;\r
+\r
+ IF_D( StrStart < Str || (char*) StrStart >= (char*)Str + StrSize ){goto err;}\r
+\r
+ if ( StepPath[0] == _T('\0') ) {\r
+ *StrStart = _T('\0');\r
+ return 0;\r
+ }\r
+\r
+ /* \90â\91Î\83p\83X\82É\82·\82é */\r
+ e= StrT_getFullPath( StrStart,\r
+ StrSize - ( (char*)StrStart - (char*)Str ),\r
+ StepPath, BasePath ); IF(e)goto fin;\r
+\r
+\r
+ /* Cut last \ */\r
+ p = StrT_chr( StrStart, _T('\0') );\r
+ if ( p > StrStart ) {\r
+ TCHAR c = *( p - 1 );\r
+ if ( c == _T('\\') || c == _T('/') )\r
+ { *( p - 1 ) = _T('\0'); }\r
+ }\r
+\r
+\r
+ /* \90e\82Ö */\r
+ p = StrT_refFName( StrStart );\r
+ if ( p > StrStart ) p--;\r
+ *p = _T('\0');\r
+\r
+\r
+ /* \83\8b\81[\83g\82È\82ç \ \82ð\95t\82¯\82é */\r
+ if ( p == StrStart + 2 ) {\r
+ *p = _T('\\'); p++; *p = _T('\0');\r
+ }\r
+\r
+ if ( out_StrLast != NULL ) *out_StrLast = p;\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+\r
+err: e = E_OTHERS; goto fin;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_isOverOfFileName] >>> \r
+- "" or "\" or "/"\r
+************************************************************************/\r
+inline bool StrT_isOverOfFileName( const TCHAR* PointerInPath )\r
+{\r
+ return PointerInPath == NULL ||\r
+ *PointerInPath == _T('\0') ||\r
+ ( ( *PointerInPath == _T('\\') || *PointerInPath == _T('/') ) &&\r
+ *(PointerInPath + 1) == _T('\0') );\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_getStepPath] >>> \r
+************************************************************************/\r
+errnum_t StrT_getStepPath( TCHAR* out_StepPath, size_t StepPathSize,\r
+ const TCHAR* FullPath, const TCHAR* BasePath )\r
+{\r
+ errnum_t e;\r
+ const TCHAR* abs_pointer;\r
+ const TCHAR* base_pointer;\r
+ TCHAR abs_char;\r
+ TCHAR base_char;\r
+ TCHAR separator;\r
+ const TCHAR* abs_separator_pointer = (const TCHAR*) DUMMY_INITIAL_VALUE;\r
+ const TCHAR* base_separator_pointer = (const TCHAR*) DUMMY_INITIAL_VALUE;\r
+ TCHAR* step_pointer;\r
+ TCHAR parent_symbol[4] = { _T('.'), _T('.'), _T('\\'), _T('\0') };\r
+ TCHAR base_path_2[ MAX_PATH ];\r
+\r
+\r
+ ASSERT_D( out_StepPath != FullPath, goto err );\r
+\r
+ abs_pointer = FullPath;\r
+\r
+\r
+ /* Set "base_pointer" */\r
+ if ( BasePath == NULL ) {\r
+ base_pointer = _tgetcwd( base_path_2, _countof(base_path_2) );\r
+ IF( base_pointer == NULL ) {goto err;}\r
+ }\r
+ else {\r
+ base_pointer = BasePath;\r
+ }\r
+\r
+\r
+ /* Set "abs_separator_pointer", "base_separator_pointer" : after same parent folder path */\r
+ separator = 0;\r
+ for (;;) { /* while abs_char == base_char */\r
+ abs_char = *abs_pointer;\r
+ base_char = *base_pointer;\r
+\r
+ abs_char = (TCHAR) _totlower( abs_char );\r
+ base_char = (TCHAR) _totlower( base_char );\r
+\r
+ if ( abs_char == _T('\0') ) {\r
+\r
+ /* out_StepPath = ".", if FullPath == BasePath */\r
+ if ( base_char == _T('\0') ) {\r
+ e= StrT_cpy( out_StepPath, StepPathSize, _T(".") ); IF(e)goto fin;\r
+ e=0; goto fin;\r
+ }\r
+ break;\r
+ }\r
+ if ( base_char == _T('\0') ) { break; }\r
+\r
+ if ( abs_char != base_char ) {\r
+ if ( ( abs_char == _T('/') || abs_char == _T('\\') ) &&\r
+ ( base_char == _T('/') || base_char == _T('\\') ) )\r
+ { /* Do nothing */ }\r
+ else\r
+ { break; }\r
+ }\r
+\r
+ /* Set "separator", "abs_separator_pointer", "base_separator_pointer" */\r
+ if ( base_char == _T('/') || base_char == _T('\\') ) {\r
+ if ( separator == 0 )\r
+ { separator = base_char; }\r
+\r
+ abs_separator_pointer = abs_pointer;\r
+ base_separator_pointer = base_pointer;\r
+ }\r
+\r
+ abs_pointer += 1;\r
+ base_pointer += 1;\r
+ }\r
+\r
+\r
+ /* FullPath \82Æ BasePath \82Ì\8aÖ\8cW\82ª\81A\95Ð\95û\82Ì\88ê\95\94\82ª\82à\82¤\95Ð\95û\82Ì\91S\91Ì\82Å\82 \82é\82Æ\82« */\r
+ if ( ( ( abs_char == _T('/') || abs_char == _T('\\') ) && base_char == _T('\0') ) ||\r
+ ( base_char == _T('/') || base_char == _T('\\') ) && abs_char == _T('\0') ) {\r
+\r
+ if ( separator == 0 )\r
+ { separator = abs_char; }\r
+\r
+ abs_separator_pointer = abs_pointer;\r
+ base_separator_pointer = base_pointer;\r
+ }\r
+\r
+\r
+ /* out_StepPath = FullPath, if there is not same folder */\r
+ if ( separator == 0 ) {\r
+ e= StrT_cpy( out_StepPath, StepPathSize, FullPath ); IF(e)goto fin;\r
+ e=0; goto fin;\r
+ }\r
+\r
+\r
+ /* Add "..\" to "out_StepPath" */\r
+ parent_symbol[2] = separator;\r
+ step_pointer = out_StepPath;\r
+ for (;;) {\r
+ const TCHAR* p1;\r
+ const TCHAR* p2;\r
+\r
+ if ( StrT_isOverOfFileName( base_separator_pointer ) )\r
+ { break; }\r
+\r
+\r
+ /* Set "base_separator_pointer" : next separator */\r
+ p1 = _tcschr( base_separator_pointer + 1, _T('/') );\r
+ p2 = _tcschr( base_separator_pointer + 1, _T('\\') );\r
+\r
+ if ( p1 == NULL ) {\r
+ if ( p2 == NULL )\r
+ { base_separator_pointer = NULL; }\r
+ else\r
+ { base_separator_pointer = p2; }\r
+ }\r
+ else {\r
+ if ( p2 == NULL ) {\r
+ base_separator_pointer = p1;\r
+ } else {\r
+ if ( p1 < p2 )\r
+ { base_separator_pointer = p1; }\r
+ else\r
+ { base_separator_pointer = p2; }\r
+ }\r
+ }\r
+\r
+\r
+ /* Add "..\" to "out_StepPath" */\r
+ e= stcpy_part_r( out_StepPath, StepPathSize, step_pointer, &step_pointer,\r
+ parent_symbol, NULL ); IF(e)goto fin;\r
+ }\r
+\r
+\r
+ /* Copy a part of "FullPath" to "out_StepPath" */\r
+ if ( StrT_isOverOfFileName( abs_separator_pointer ) ) {\r
+ ASSERT_D( step_pointer > out_StepPath, goto err );\r
+ *( step_pointer - 1 ) = _T('\0');\r
+ }\r
+ else {\r
+ e= stcpy_part_r( out_StepPath, StepPathSize, step_pointer, NULL,\r
+ abs_separator_pointer + 1, NULL ); IF(e)goto fin;\r
+ }\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+\r
+err: e = E_OTHERS; goto fin;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_getBaseName_part] >>> \r
+************************************************************************/\r
+errnum_t StrT_getBaseName_part( TCHAR* Str, size_t StrSize, TCHAR* StrStart,\r
+ TCHAR** out_StrLast, const TCHAR* SrcPath )\r
+{\r
+ const TCHAR* p1;\r
+ const TCHAR* p2;\r
+ const TCHAR* p3;\r
+ const TCHAR* ps;\r
+\r
+ p1 = StrT_refFName( SrcPath );\r
+\r
+\r
+ //=== # \82ª\96³\82¢\82Æ\82«\81A\8dÅ\8cã\82Ì\83s\83\8a\83I\83h\82Ì\91O\82Ü\82Å\82ª\81ABaseName\r
+ ps = _tcschr( p1, _T('#') );\r
+ if ( ps == NULL ) {\r
+ p2 = _tcsrchr( p1, _T('.') );\r
+ if ( p2 == NULL ) p2 = _tcsrchr( p1, _T('\0') );\r
+ }\r
+\r
+ //=== # \82ª\82 \82é\82Æ\82«\81A# \82æ\82è\91O\82Å\81A\8dÅ\8cã\82Ì\83s\83\8a\83I\83h\82Ì\91O\82Ü\82Å\82ª\81ABaseName\r
+ else {\r
+ p2 = ps;\r
+\r
+ p3 = p1;\r
+ for (;;) {\r
+ p3 = _tcschr( p3, _T('.') );\r
+ if ( p3 == NULL || p3 > ps ) break;\r
+ p2 = p3;\r
+ p3 ++;\r
+ }\r
+ }\r
+\r
+ return stcpy_part_r( Str, StrSize, StrStart, out_StrLast, p1, p2 );\r
+}\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_addLastOfFileName] >>> \r
+************************************************************************/\r
+errnum_t StrT_addLastOfFileName( TCHAR* out_Path, size_t PathSize,\r
+ const TCHAR* BasePath, const TCHAR* AddName )\r
+{\r
+ TCHAR c;\r
+ size_t copy_size;\r
+ size_t free_size;\r
+ char* out_pos;\r
+ const TCHAR* last_pos_in_base = StrT_chr( BasePath, _T('\0') );\r
+ const TCHAR* term_pos_in_base;\r
+ const TCHAR* add_pos_in_base;\r
+ const TCHAR* period_pos_in_base = _tcsrchr( BasePath, _T('.') ); // > term_pos_in_base\r
+ const TCHAR* last_pos_in_add = StrT_chr( AddName, _T('\0') );\r
+ const TCHAR* term_pos_in_add;\r
+ const TCHAR* period_pos_in_add = _tcsrchr( AddName, _T('.') ); // > term_pos_in_add\r
+\r
+\r
+ DISCARD_BYTES( out_Path, PathSize );\r
+\r
+\r
+ //=== term_pos_in_base\r
+ for ( term_pos_in_base = last_pos_in_base; term_pos_in_base >= BasePath; term_pos_in_base -- ) {\r
+ c = *term_pos_in_base;\r
+ if ( c == _T('/') || c == _T('\\') ) break;\r
+ }\r
+\r
+\r
+ //=== term_pos_in_add\r
+ for ( term_pos_in_add = last_pos_in_add; term_pos_in_add >= AddName; term_pos_in_add -- ) {\r
+ c = *term_pos_in_add;\r
+ if ( c == _T('/') || c == _T('\\') ) break;\r
+ }\r
+\r
+\r
+ //=== add_pos_in_base\r
+ if ( term_pos_in_base < period_pos_in_base ) {\r
+ add_pos_in_base = period_pos_in_base;\r
+ }\r
+ else {\r
+ if ( term_pos_in_base < BasePath )\r
+ add_pos_in_base = StrT_chr( BasePath, _T('\0') );\r
+ else\r
+ add_pos_in_base = StrT_chr( term_pos_in_base, _T('\0') );\r
+ }\r
+\r
+\r
+ //=== setup output parameters\r
+ out_pos = (char*) out_Path;\r
+ free_size = PathSize;\r
+\r
+\r
+ //=== copy BasePath .. add_pos_in_base\r
+ copy_size = (char*)add_pos_in_base - (char*)BasePath;\r
+ if ( copy_size > free_size ) goto err_fa;\r
+ memcpy( out_pos, BasePath, copy_size );\r
+ out_pos += copy_size;\r
+ free_size -= copy_size;\r
+\r
+\r
+ //=== copy AddName .. last_pos_in_add\r
+ copy_size = (char*)last_pos_in_add - (char*)AddName;\r
+ if ( copy_size > free_size ) goto err_fa;\r
+ memcpy( out_pos, AddName, copy_size );\r
+ out_pos += copy_size;\r
+ free_size -= copy_size;\r
+\r
+\r
+ //=== add name and not change extension\r
+ if ( period_pos_in_add == NULL ) {\r
+\r
+ //=== copy period_pos_in_base .. last_pos_in_base\r
+ if ( period_pos_in_base > term_pos_in_base ) {\r
+ copy_size = (char*)last_pos_in_base - (char*)period_pos_in_base + sizeof(TCHAR);\r
+ if ( copy_size > free_size ) goto err_fa;\r
+ memcpy( out_pos, period_pos_in_base, copy_size );\r
+ }\r
+ else {\r
+ *(TCHAR*)out_pos = _T('\0');\r
+ }\r
+ }\r
+\r
+\r
+ //=== add name and change extension\r
+ else {\r
+\r
+ if ( *(period_pos_in_add + 1) == _T('\0') )\r
+ *( (TCHAR*)out_pos - 1 ) = _T('\0');\r
+ else\r
+ *(TCHAR*)out_pos = _T('\0');\r
+ }\r
+\r
+ return 0;\r
+\r
+err_fa:\r
+ return E_FEW_ARRAY;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_encodeToValidPath] >>> \r
+************************************************************************/\r
+errnum_t StrT_encodeToValidPath( TCHAR* out_Path, size_t in_OutPathSize, const TCHAR* in_Path, bool in_IsName )\r
+{\r
+ errnum_t e;\r
+\r
+ int i_in; /* index of "in_Path" */\r
+ int i_out = 0; /* index of "out_Path" */\r
+ int i_out_over = (int)( in_OutPathSize / sizeof(TCHAR) );\r
+ bool is_colon = in_IsName;\r
+\r
+ ASSERT_R( in_Path != out_Path, e=E_OTHERS; goto fin );\r
+\r
+ for ( i_in = 0; ; i_in += 1 ) {\r
+ bool is_percent;\r
+ int chara = in_Path[ i_in ]; /* a character */\r
+\r
+ if ( chara == _T('\0') )\r
+ { break; }\r
+\r
+\r
+ /* Set "is_percent" */\r
+ switch ( chara ) {\r
+ case _T(','): case _T(';'): case _T('*'): case _T('?'): case _T('"'):\r
+ case _T('<'): case _T('>'): case _T('|'): case _T('%'):\r
+ is_percent = true;\r
+ break;\r
+ case _T(':'):\r
+ is_percent = is_colon;\r
+ is_colon = true;\r
+ break;\r
+ case _T('\\'): case _T('/'):\r
+ is_percent = in_IsName;\r
+ is_colon = true;\r
+ break;\r
+ default:\r
+ is_percent = false;\r
+ break;\r
+ }\r
+\r
+\r
+ /* Set "out_Path[ i_out ]" */\r
+ if ( is_percent ) {\r
+ int high = chara / 0x10;\r
+ int low = chara & 0xF;\r
+\r
+ if ( high <= 9 ) {\r
+ high += _T('0');\r
+ } else {\r
+ high = ( high - 0xA ) + _T('a');\r
+ }\r
+\r
+ if ( low <= 9 ) {\r
+ low += _T('0');\r
+ } else {\r
+ low = ( low - 0xA ) + _T('a');\r
+ }\r
+\r
+ ASSERT_R( i_out + 3 < i_out_over, e=E_FEW_ARRAY; goto fin );\r
+\r
+ out_Path[ i_out + 0 ] = _T('%');\r
+ out_Path[ i_out + 1 ] = (TCHAR) high;\r
+ out_Path[ i_out + 2 ] = (TCHAR) low;\r
+ i_out += 3;\r
+ }\r
+ else {\r
+ ASSERT_R( i_out + 1 < i_out_over, e=E_FEW_ARRAY; goto fin );\r
+\r
+ out_Path[ i_out ] = (TCHAR) chara;\r
+ i_out += 1;\r
+ }\r
+ }\r
+\r
+ e=0;\r
+fin:\r
+ out_Path[ i_out ] = _T('\0');\r
+\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_Mul_init] >>> \r
+************************************************************************/\r
+enum { StrT_Mul_FirstSize = 0x0F00 };\r
+\r
+errnum_t StrT_Mul_init( StrT_Mul* self )\r
+{\r
+ TCHAR* p;\r
+\r
+ self->First = NULL;\r
+\r
+ p = (TCHAR*) malloc( StrT_Mul_FirstSize );\r
+ IF( p == NULL ) return E_FEW_MEMORY;\r
+\r
+ self->First = p;\r
+ self->Size = StrT_Mul_FirstSize;\r
+ self->Next = p;\r
+ p[0] = _T('\0'); p[1] = _T('\0');\r
+\r
+ #if ! NDEBUG\r
+ self->BreakOffset = -1;\r
+ #endif\r
+\r
+ return 0;\r
+}\r
+\r
+\r
+/***********************************************************************\r
+ <<< [StrT_Mul_toEmpty] >>>\r
+************************************************************************/\r
+errnum_t StrT_Mul_toEmpty( StrT_Mul* self )\r
+{\r
+ free( self->First );\r
+ return StrT_Mul_init( self );\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_Mul_add] >>> \r
+************************************************************************/\r
+errnum_t StrT_Mul_add( StrT_Mul* self, const TCHAR* Str, unsigned* out_Offset )\r
+{\r
+ errnum_t e;\r
+ const TCHAR* p1;\r
+ const TCHAR* p2;\r
+ TCHAR* p3;\r
+ enum { plus = 0x1000 };\r
+\r
+ p1 = Str;\r
+ p2 = StrT_chr( Str, _T('\0') );\r
+ while ( (char*) self->Next + ( (char*) p2 - (char*) p1 + sizeof(TCHAR)*2 ) >\r
+ (char*) self->First + self->Size ) {\r
+ p3 = (TCHAR*) realloc( self->First, self->Size + plus );\r
+ IF( p3 == NULL )goto err_fm;\r
+ self->Next = p3 + ( self->Next - self->First );\r
+ self->First = p3;\r
+ self->Size += plus;\r
+ }\r
+\r
+ #if ! NDEBUG\r
+ if ( ( (char*)self->Next - (char*)self->First ) == self->BreakOffset )\r
+ { TestableDebugBreak(); }\r
+ #endif\r
+\r
+ memcpy( self->Next, Str, (char*) p2 - (char*) p1 + sizeof(TCHAR) );\r
+\r
+ p3 = ( self->Next + ( (TCHAR*) p2 - (TCHAR*) p1 + 1 ) );\r
+ *p3 = _T('\0'); // '\0'x2\r
+ if ( out_Offset != NULL ) *out_Offset = (char*)self->Next - (char*)self->First;\r
+ self->Next = p3;\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+err_fm: e= E_FEW_MEMORY; goto fin;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_Mul_freeLast] >>> \r
+************************************************************************/\r
+errnum_t StrT_Mul_freeLast( StrT_Mul* self, TCHAR* AllocStr )\r
+{\r
+ errnum_t e;\r
+ TCHAR* p;\r
+ TCHAR* prev_p;\r
+\r
+ prev_p = NULL;\r
+ for ( StrT_Mul_forEach( self, &p ) ) {\r
+ prev_p = p;\r
+ }\r
+ IF( prev_p == NULL ) {goto err;}\r
+ IF( AllocStr != prev_p ) goto err_nf;\r
+\r
+ *prev_p = _T('\0'); // '\0'x2\r
+ self->Next = prev_p;\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+\r
+err: e = E_OTHERS; goto fin;\r
+err_nf: e = E_NOT_FOUND_SYMBOL; goto fin;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrT_Mul_expandSize] >>> \r
+************************************************************************/\r
+errnum_t StrT_Mul_expandSize( StrT_Mul* self, size_t FreeSize )\r
+{\r
+ size_t filled_size = ((char*) self->Next) - ((char*) self->First);\r
+ size_t total_size = filled_size + FreeSize + 1;\r
+ errnum_t e;\r
+ void* p;\r
+\r
+ if ( total_size <= self->Size ) return 0;\r
+\r
+ p = realloc( self->First, total_size ); IF(p==NULL)goto err_fm;\r
+ self->Next = (TCHAR*)( ((char*) p ) + filled_size );\r
+ self->First = p;\r
+ self->Size = total_size;\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+\r
+err_fm: e = E_FEW_MEMORY; goto fin;\r
+}\r
+\r
+\r
+errnum_t StrT_Mul_commit( StrT_Mul* self )\r
+{\r
+ TCHAR* p = StrT_chr( self->Next, _T('\0') ) + 1;\r
+\r
+ IF_D( (char*)p >= (char*)self->First + self->Size ) return E_FEW_ARRAY;\r
+\r
+ self->Next = p;\r
+ *p = _T('\0');\r
+ return 0;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Strs_init] >>> \r
+************************************************************************/\r
+enum { Strs_FirstSize = 0x0F00 };\r
+\r
+errnum_t Strs_init( Strs* self )\r
+{\r
+ byte_t* p;\r
+\r
+ self->MemoryAddress = NULL;\r
+\r
+ p = (byte_t*) malloc( Strs_FirstSize );\r
+ IF( p == NULL ) return E_FEW_MEMORY;\r
+\r
+ self->MemoryAddress = p;\r
+ self->MemoryOver = p + Strs_FirstSize;\r
+ self->NextElem = p + sizeof(TCHAR*);\r
+ self->PointerToNextStrInPrevElem = (TCHAR**) p;\r
+ self->Prev_PointerToNextStrInPrevElem = NULL;\r
+ *(TCHAR**) p = NULL;\r
+\r
+ self->FirstOfStrs = self;\r
+ self->NextStrs = NULL;\r
+\r
+ return 0;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Strs_finish] >>> \r
+************************************************************************/\r
+errnum_t Strs_finish( Strs* self, errnum_t e )\r
+{\r
+ Strs* mp;\r
+ Strs* next_mp;\r
+\r
+ if ( self->MemoryAddress == NULL ) return 0;\r
+\r
+ mp = self->FirstOfStrs;\r
+ for (;;) {\r
+ free( mp->MemoryAddress );\r
+ if ( mp == self ) break;\r
+\r
+ next_mp = mp->NextStrs;\r
+ free( mp );\r
+ mp = next_mp;\r
+ }\r
+ self->MemoryAddress = NULL;\r
+\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Strs_toEmpty] >>> \r
+************************************************************************/\r
+errnum_t Strs_toEmpty( Strs* self )\r
+{\r
+ Strs_finish( self, 0 );\r
+ return Strs_init( self );\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Strs_add] >>> \r
+************************************************************************/\r
+errnum_t Strs_add( Strs* self, const TCHAR* Str, const TCHAR** out_AllocStr )\r
+{\r
+ return Strs_addBinary( self, Str, StrT_chr( Str, _T('\0') ) + 1, out_AllocStr );\r
+}\r
+\r
+\r
+errnum_t Strs_addBinary( Strs* self, const TCHAR* Str, const TCHAR* StrOver, const TCHAR** out_AllocStr )\r
+{\r
+ errnum_t e;\r
+ size_t str_size;\r
+ size_t elem_size;\r
+\r
+ str_size = ( (byte_t*) StrOver - (byte_t*) Str );\r
+ elem_size = ( sizeof(TCHAR*) + str_size + ( sizeof(void*) - 1 ) ) & ~(sizeof(void*) - 1);\r
+\r
+ if ( self->NextElem + elem_size > self->MemoryOver )\r
+ { e= Strs_expandSize( self, str_size ); IF(e)goto fin; }\r
+\r
+\r
+ // [ NULL | ... ]\r
+ // [ FirstStr | NULL | TCHAR[] | ... ]\r
+ // [ FirstStr | NextStr | TCHAR[] | NULL | TCHAR[] | ... ]\r
+ // [ FirstStr | NextStr | TCHAR[] | NextStr | TCHAR[] ], [ NULL | TCHAR[] | ... ]\r
+\r
+ if ( out_AllocStr != NULL ) *out_AllocStr = (TCHAR*)( self->NextElem + sizeof(TCHAR*) );\r
+\r
+ //=== fill elem\r
+ *(TCHAR**) self->NextElem = NULL;\r
+ memcpy( self->NextElem + sizeof(TCHAR*), Str, str_size );\r
+\r
+ //=== link to elem from previous elem\r
+ *self->PointerToNextStrInPrevElem = (TCHAR*)( self->NextElem + sizeof(TCHAR*) );\r
+\r
+ //=== update self\r
+ self->Prev_PointerToNextStrInPrevElem = self->PointerToNextStrInPrevElem;\r
+ self->PointerToNextStrInPrevElem = (TCHAR**) self->NextElem;\r
+ self->NextElem = self->NextElem + elem_size;\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Strs_freeLast] >>> \r
+************************************************************************/\r
+errnum_t Strs_freeLast( Strs* self, TCHAR* AllocStr )\r
+{\r
+ errnum_t e;\r
+ TCHAR* str;\r
+ TCHAR* last_str;\r
+ TCHAR* prev_of_last_str;\r
+ Strs* mp;\r
+ Strs* prev_of_last_mp;\r
+\r
+ if ( self->Prev_PointerToNextStrInPrevElem == NULL ) {\r
+ prev_of_last_str = NULL;\r
+ last_str = NULL;\r
+ for ( Strs_forEach( self, &str ) ) {\r
+ prev_of_last_str = last_str;\r
+ last_str = str;\r
+ }\r
+ }\r
+ else {\r
+ prev_of_last_str = (TCHAR*)( self->Prev_PointerToNextStrInPrevElem + 1 );\r
+ last_str = (TCHAR*)( self->PointerToNextStrInPrevElem + 1 );\r
+ }\r
+\r
+ // [ NULL | ... ]\r
+ IF( last_str != AllocStr ) {goto err;}\r
+\r
+ // [ FirstStr | NULL | TCHAR[] | ... ]\r
+ if ( prev_of_last_str == NULL ) {\r
+ self->NextElem = self->MemoryAddress + sizeof(TCHAR*);\r
+ self->PointerToNextStrInPrevElem = (TCHAR**) self->MemoryAddress;\r
+ }\r
+\r
+ // [ FirstStr | NextStr | TCHAR[] | NULL | TCHAR[] | ... ]\r
+ else if ( (byte_t*) prev_of_last_str >= self->MemoryAddress &&\r
+ (byte_t*) prev_of_last_str < self->MemoryOver ) {\r
+ self->NextElem = (byte_t*)last_str - sizeof(TCHAR*);\r
+ self->PointerToNextStrInPrevElem = (TCHAR**)( (byte_t*)prev_of_last_str - sizeof(TCHAR*) );\r
+ }\r
+\r
+ // [ FirstStr | NextStr | TCHAR[] | NextStr | TCHAR[] ], [ NULL | TCHAR[] | ... ]\r
+ else {\r
+ prev_of_last_mp = NULL;\r
+ for ( mp = self->FirstOfStrs; mp->NextStrs != self; mp = mp->NextStrs ) {\r
+ prev_of_last_mp = mp;\r
+ }\r
+\r
+ free( self->MemoryAddress );\r
+\r
+ *self = *mp;\r
+\r
+ if ( prev_of_last_mp == NULL ) {\r
+ self->FirstOfStrs = self;\r
+ self->NextStrs = NULL;\r
+ }\r
+ else {\r
+ prev_of_last_mp->NextStrs = self;\r
+ }\r
+\r
+ free( mp );\r
+ }\r
+ *self->PointerToNextStrInPrevElem = NULL;\r
+ self->Prev_PointerToNextStrInPrevElem = NULL;\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+\r
+err: e = E_OTHERS; goto fin;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Strs_expandSize] >>> \r
+************************************************************************/\r
+errnum_t Strs_expandSize( Strs* self, size_t FreeSize )\r
+{\r
+ Strs* mp;\r
+ Strs* mp2;\r
+ size_t elem_size = ( sizeof(TCHAR*) + FreeSize + sizeof(void*) - 1 ) & ~(sizeof(void*) - 1);\r
+ size_t memory_size;\r
+ byte_t* new_memory;\r
+\r
+ // [ NULL | ... ]\r
+ // [ FirstStr | NULL | TCHAR[] | ... ]\r
+ // [ FirstStr | NextStr | TCHAR[] | NULL | TCHAR[] | ... ]\r
+ // [ FirstStr | NextStr | TCHAR[] | NextStr | TCHAR[] ], [ NULL | TCHAR[] | ... ]\r
+\r
+ while ( self->NextElem + elem_size > self->MemoryOver ) {\r
+\r
+ //=== alloc\r
+ mp = (Strs*) malloc( sizeof(Strs) ); IF(mp==NULL) goto err_fm;\r
+ memory_size = ( self->MemoryOver - self->MemoryAddress ) * 2;\r
+ new_memory = (byte_t*) malloc( memory_size );\r
+ IF( new_memory == NULL ) { free( mp ); goto err_fm; }\r
+\r
+ //=== move old memory\r
+ if ( self->FirstOfStrs == self ) {\r
+ self->FirstOfStrs = mp;\r
+ }\r
+ else {\r
+ for ( mp2 = self->FirstOfStrs; mp2->NextStrs != self; mp2 = mp2->NextStrs );\r
+ mp2->NextStrs = mp;\r
+ }\r
+ *mp = *self;\r
+ mp->NextStrs = self;\r
+\r
+ //=== setup new memory\r
+ self->MemoryAddress = new_memory;\r
+ self->MemoryOver = new_memory + memory_size;\r
+ self->NextElem = new_memory;\r
+ // self->PointerToNextStrInPrevElem is same value\r
+ // self->FirstOfStrs is same value\r
+ // self->NextStrs is always NULL\r
+ }\r
+ return 0;\r
+\r
+err_fm: return E_FEW_ARRAY;\r
+}\r
+\r
+\r
+/***********************************************************************\r
+ <<< [Strs_commit] >>>\r
+************************************************************************/\r
+errnum_t Strs_commit( Strs* self, TCHAR* StrOver )\r
+{\r
+ size_t elem_size;\r
+\r
+ if ( StrOver == NULL )\r
+ { StrOver = StrT_chr( (TCHAR*)( self->NextElem + sizeof(TCHAR*) ), _T('\0') ) + 1; }\r
+ elem_size = ( ( (byte_t*)StrOver - self->NextElem ) + sizeof(void*) - 1 ) & ~(sizeof(void*) - 1);\r
+\r
+ //=== fill elem\r
+ *(TCHAR**) self->NextElem = NULL;\r
+\r
+ //=== link to elem from previous elem\r
+ *self->PointerToNextStrInPrevElem = (TCHAR*)( self->NextElem + sizeof(TCHAR*) );\r
+\r
+ //=== update self\r
+ self->PointerToNextStrInPrevElem = (TCHAR**) self->NextElem;\r
+ self->NextElem = self->NextElem + elem_size;\r
+\r
+ return 0;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Strs_allocateArray] >>> \r
+************************************************************************/\r
+errnum_t Strs_allocateArray( Strs* self, TCHAR*** out_PointerArray, int* out_Count )\r
+{\r
+ errnum_t e;\r
+ TCHAR* p;\r
+ TCHAR** pp;\r
+ int count;\r
+\r
+ count = 0;\r
+ for ( Strs_forEach( self, &p ) ) {\r
+ count += 1;\r
+ }\r
+\r
+ e= HeapMemory_allocateArray( &pp, count ); IF(e){goto fin;}\r
+\r
+ count = 0;\r
+ for ( Strs_forEach( self, &p ) ) {\r
+ pp[ count ] = p;\r
+ count += 1;\r
+ }\r
+\r
+ *out_PointerArray = pp;\r
+ *out_Count = count;\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrArr] >>> \r
+************************************************************************/\r
+\r
+/*[StrArr_init]*/\r
+errnum_t StrArr_init( StrArr* self )\r
+{\r
+ errnum_t e;\r
+\r
+ Set2_initConst( &self->Array );\r
+ Strs_initConst( &self->Chars );\r
+\r
+ e= Set2_init( &self->Array, 0x100 ); IF(e)goto cancel;\r
+ e= Strs_init( &self->Chars ); IF(e)goto cancel;\r
+ return 0;\r
+\r
+cancel: StrArr_finish( self, e ); return e;\r
+}\r
+\r
+\r
+/*[StrArr_finish]*/\r
+errnum_t StrArr_finish( StrArr* self, errnum_t e )\r
+{\r
+ if ( ! Set2_isInited( &self->Array ) ) return e;\r
+\r
+ e= Set2_finish( &self->Array, e );\r
+ e= Strs_finish( &self->Chars, e );\r
+ return e;\r
+}\r
+\r
+\r
+/*[StrArr_add]*/\r
+errnum_t StrArr_add( StrArr* self, const TCHAR* Str, int* out_I )\r
+{\r
+ errnum_t e;\r
+\r
+ e= StrArr_expandCount( self, _tcslen( Str ) ); IF(e)goto fin;\r
+ _tcscpy_s( StrArr_getFreeAddr( self ), StrArr_getFreeCount( self ), Str );\r
+ e= StrArr_commit( self ); IF(e)goto fin;\r
+ if ( out_I != NULL ) *out_I = Set2_getCount( &self->Array, TCHAR* ) - 1;\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+}\r
+\r
+\r
+/*[StrArr_commit]*/\r
+errnum_t StrArr_commit( StrArr* self )\r
+{\r
+ errnum_t e;\r
+ TCHAR* p;\r
+ TCHAR** pp = NULL;\r
+ Set2* arr = &self->Array;\r
+ Strs* ss = &self->Chars;\r
+\r
+ p = Strs_getFreeAddr( ss );\r
+ e= Set2_alloc( arr, &pp, TCHAR* ); IF(e)goto fin;\r
+ e= Strs_commit( ss, NULL ); IF(e)goto fin;\r
+ *pp = p;\r
+\r
+ e=0;\r
+fin:\r
+ if ( e && pp != NULL ) e= Set2_freeLast( arr, pp, TCHAR*, e );\r
+ return e;\r
+}\r
+\r
+\r
+/*[StrArr_fillTo]*/\r
+errnum_t StrArr_fillTo( StrArr* self, int n, const TCHAR* Str )\r
+{\r
+ errnum_t e;\r
+ const TCHAR* p;\r
+ const TCHAR** pp;\r
+ const TCHAR** pp_over;\r
+\r
+ n -= Set2_getCount( &self->Array, TCHAR* );\r
+ if ( n <= 0 ) return 0;\r
+\r
+ if ( Str == NULL ) {\r
+ p = NULL;\r
+ }\r
+ else {\r
+ e= Strs_add( &self->Chars, Str, &p ); IF(e)goto fin;\r
+ }\r
+\r
+ e= Set2_allocMulti( &self->Array, &pp, TCHAR*, n ); IF(e)goto fin;\r
+ pp_over = pp + n;\r
+ for ( ; pp < pp_over; pp++ )\r
+ *pp = p;\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+}\r
+\r
+\r
+/*[StrArr_toEmpty]*/\r
+errnum_t StrArr_toEmpty( StrArr* self )\r
+{\r
+ errnum_t e, ee;\r
+\r
+ e=0;\r
+ ee= Set2_toEmpty( &self->Array ); IF(ee&&!e)e=ee;\r
+ ee= Strs_toEmpty( &self->Chars ); IF(ee&&!e)e=ee;\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrArr_parseCSV] >>> \r
+************************************************************************/\r
+errnum_t StrArr_parseCSV( StrArr* self, const TCHAR* CSVLine )\r
+{\r
+ errnum_t e;\r
+ const TCHAR* p = CSVLine;\r
+\r
+ e= StrArr_toEmpty( self ); IF(e)goto fin;\r
+\r
+ do {\r
+ e= StrT_meltCSV( StrArr_getFreeAddr( self ), StrArr_getFreeSize( self ), &p );\r
+ if ( e == E_FEW_ARRAY ) {\r
+ e= StrArr_expandSize( self, StrArr_getFreeSize( self ) * 2 ); IF(e)goto fin;\r
+ continue;\r
+ }\r
+ IF(e)goto fin;\r
+\r
+ e = StrArr_commit( self ); IF(e)goto fin;\r
+ } while ( p != NULL );\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/*-------------------------------------------------------------------------*/\r
+/* <<<< ### (StrMatchKey) Class implement >>>> */ \r
+/*-------------------------------------------------------------------------*/\r
+\r
+void StrMatchKey_initConst( StrMatchKey* self )\r
+{\r
+ self->Keyword = NULL;\r
+ self->WildcardLeftStr = NULL;\r
+ self->WildcardRightStr = NULL;\r
+}\r
+\r
+errnum_t StrMatchKey_init( StrMatchKey* self, const TCHAR* Keyword )\r
+{\r
+ errnum_t e;\r
+ TCHAR* p;\r
+\r
+ e= MallocAndCopyString( &self->Keyword, Keyword ); IF(e)goto fin;\r
+ p = _tcschr( Keyword, _T('*') );\r
+ if ( p == NULL ) {\r
+ e= MallocAndCopyString( &self->WildcardLeftStr, Keyword ); IF(e)goto fin;\r
+ self->WildcardLeftLength = _tcslen( Keyword );\r
+\r
+ self->WildcardRightLength = 0;\r
+ }\r
+ else {\r
+ IF( _tcschr( p+1, _T('*') ) != NULL ) goto err_aa;\r
+\r
+ e= MallocAndCopyString( &self->WildcardLeftStr, Keyword ); IF(e)goto fin;\r
+ self->WildcardLeftLength = p - Keyword;\r
+ self->WildcardLeftStr[ self->WildcardLeftLength ] = _T('\0');\r
+\r
+ e= MallocAndCopyString( &self->WildcardRightStr, p+1 ); IF(e)goto fin;\r
+ self->WildcardRightLength = _tcslen( p+1 );\r
+ }\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+\r
+err_aa: e = E_OTHERS; Error4_printf( _T("<ERROR msg=\"* \82ð\95¡\90\94\8ew\92è\82·\82é\82±\82Æ\82Í\82Å\82«\82Ü\82¹\82ñ\"/>") ); goto resume;\r
+resume: StrMatchKey_finish( self, 0 ); goto fin;\r
+}\r
+\r
+errnum_t StrMatchKey_finish( StrMatchKey* self, errnum_t e )\r
+{\r
+ if ( self->Keyword != NULL ) free( self->Keyword );\r
+ if ( self->WildcardLeftStr != NULL ) free( self->WildcardLeftStr );\r
+ if ( self->WildcardRightStr != NULL ) free( self->WildcardRightStr );\r
+ StrMatchKey_initConst( self );\r
+ return e;\r
+}\r
+\r
+bool StrMatchKey_isMatch( StrMatchKey* self, const TCHAR* String )\r
+{\r
+ if ( _tcsnicmp( String, self->WildcardLeftStr, self->WildcardLeftLength ) != 0 )\r
+ return false;\r
+\r
+ if ( _tcsnicmp( StrT_chr( String + self->WildcardLeftLength,\r
+ _T('\0') ) - self->WildcardRightLength,\r
+ self->WildcardRightStr, self->WildcardRightLength ) != 0 )\r
+ return false;\r
+\r
+ return true;\r
+}\r
+\r
+\r
+ \r
+/*=================================================================*/\r
+/* <<< [DebugTools/DebugTools.c] >>> */ \r
+/*=================================================================*/\r
+ \r
+/***********************************************************************\r
+ <<< [TestableDebugBreak] >>> \r
+************************************************************************/\r
+typedef struct _TestableDebugBreakClass TestableDebugBreakClass;\r
+struct _TestableDebugBreakClass {\r
+ bool IsDisableTestableDebugBreak;\r
+ volatile int DebugBreakCount;\r
+ CRITICAL_SECTION Critical;\r
+ SingletonInitializerClass Initializer;\r
+};\r
+static TestableDebugBreakClass gs_TestableDebugBreak = { false, 0 };\r
+\r
+\r
+/*[SetTestableDebugBreak]*/\r
+void SetTestableDebugBreak( bool IsEnableBreak )\r
+{\r
+ TestableDebugBreakClass* self = &gs_TestableDebugBreak;\r
+ self->IsDisableTestableDebugBreak = ! IsEnableBreak;\r
+}\r
+\r
+/*[TestableDebugBreak_Sub]*/\r
+int TestableDebugBreak_Sub()\r
+{\r
+ TestableDebugBreakClass* self = &gs_TestableDebugBreak;\r
+\r
+ if ( ! SingletonInitializerClass_isInitialized( &self->Initializer ) ) {\r
+ if ( SingletonInitializerClass_isFirst( &self->Initializer ) ) {\r
+\r
+ InitializeCriticalSection( &self->Critical );\r
+\r
+ SingletonInitializerClass_onFinishedInitialize( &self->Initializer, 0 );\r
+ }\r
+ }\r
+\r
+ EnterCriticalSection( &self->Critical );\r
+ self->DebugBreakCount += 1;\r
+ LeaveCriticalSection( &self->Critical );\r
+\r
+ return ! self->IsDisableTestableDebugBreak;\r
+}\r
+\r
+/*[GetDebugBreakCount]*/\r
+int GetDebugBreakCount()\r
+{\r
+ TestableDebugBreakClass* self = &gs_TestableDebugBreak;\r
+ return self->DebugBreakCount;\r
+}\r
+\r
+\r
+ \r
+/*=================================================================*/\r
+/* <<< [SetX/SetX.c] >>> */ \r
+/*=================================================================*/\r
+ \r
+/***********************************************************************\r
+ <<< [Set2_init] >>> \r
+************************************************************************/\r
+errnum_t Set2_init( Set2* m, int FirstSize )\r
+{\r
+ m->First = malloc( FirstSize );\r
+ if ( m->First == NULL ) return E_FEW_MEMORY;\r
+ m->Next = m->First;\r
+ m->Over = (char*)m->First + FirstSize;\r
+\r
+ #ifdef _DEBUG\r
+ m->PointerOfDebugArray = NULL;\r
+ #endif\r
+\r
+ return 0;\r
+}\r
+ \r
+/***********************************************************************\r
+ <<< [Set2_finish] >>> \r
+************************************************************************/\r
+errnum_t Set2_finish( Set2* m, errnum_t e )\r
+{\r
+ if ( m->First != NULL ) { free( m->First ); m->First = NULL; }\r
+ return e;\r
+}\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Set2_ref_imp] >>> \r
+************************************************************************/\r
+errnum_t Set2_ref_imp( Set2* m, int iElem, void* out_pElem, size_t ElemSize )\r
+{\r
+ int e;\r
+ char* p;\r
+\r
+ IF( iElem < 0 ) goto err_ns;\r
+ p = (char*) m->First + ( (unsigned)iElem * ElemSize );\r
+ IF( p >= (char*)m->Next ) goto err_ns;\r
+ *(char**)out_pElem = p;\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+\r
+err_ns: e = E_NOT_FOUND_SYMBOL; goto fin;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Set2_getIterator] >>> \r
+************************************************************************/\r
+errnum_t Set2_getIterator( Set2* self, Set2_IteratorClass* out_Iterator, int ElementSize )\r
+{\r
+ out_Iterator->Parent = self;\r
+ out_Iterator->ElementSize = ElementSize;\r
+ out_Iterator->Current = (uint8_t*) self->First - ElementSize;\r
+ return 0;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Set2_getDescendingIterator] >>> \r
+************************************************************************/\r
+errnum_t Set2_getDescendingIterator( Set2* self, Set2_IteratorClass* out_Iterator, int ElementSize )\r
+{\r
+ out_Iterator->Parent = self;\r
+ out_Iterator->ElementSize = ElementSize;\r
+ out_Iterator->Current = (uint8_t*) self->Next;\r
+ return 0;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Set2_IteratorClass_getNext] >>> \r
+************************************************************************/\r
+void* Set2_IteratorClass_getNext( Set2_IteratorClass* self )\r
+{\r
+ uint8_t* next = self->Current + self->ElementSize;\r
+\r
+ if ( next >= (uint8_t*) self->Parent->Next ) {\r
+ return NULL;\r
+ } else {\r
+ self->Current = next;\r
+ return next;\r
+ }\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Set2_IteratorClass_getPrevious] >>> \r
+************************************************************************/\r
+void* Set2_IteratorClass_getPrevious( Set2_IteratorClass* self )\r
+{\r
+ uint8_t* previous = self->Current - self->ElementSize;\r
+\r
+ if ( previous < (uint8_t*) self->Parent->First ) {\r
+ return NULL;\r
+ } else {\r
+ self->Current = previous;\r
+ return previous;\r
+ }\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Set2_alloc_imp] >>> \r
+************************************************************************/\r
+errnum_t Set2_alloc_imp( Set2* m, void* pp, size_t size )\r
+{\r
+ errnum_t e;\r
+\r
+ e= Set2_expandIfOverByAddr( m, (char*) m->Next + size ); IF(e)goto fin;\r
+ *(void**)pp = m->Next;\r
+ m->Next = (char*) m->Next + size;\r
+\r
+ DISCARD_BYTES( *(void**)pp, size );\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+}\r
+\r
+\r
+/***********************************************************************\r
+ <<< [Set2_allocMulti_sub] >>> \r
+************************************************************************/\r
+errnum_t Set2_allocMulti_sub( Set2* m, void* out_pElem, size_t ElemsSize )\r
+{\r
+ errnum_t e;\r
+ char* p;\r
+\r
+ e= Set2_expandIfOverByAddr( m, (char*) m->Next + ElemsSize ); IF(e)goto fin;\r
+ p = (char*) m->Next;\r
+ m->Next = p + ElemsSize;\r
+ *(char**)out_pElem = p;\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Set2_expandIfOverByAddr_imp] >>> \r
+************************************************************************/\r
+errnum_t Set2_expandIfOverByAddr_imp( Set2* m, void* OverAddrBasedOnNowFirst )\r
+{\r
+ errnum_t e;\r
+ void* new_first;\r
+ unsigned offset_of_over;\r
+ unsigned offset_of_next;\r
+\r
+ if ( OverAddrBasedOnNowFirst <= m->Over ) { e=E_OTHERS; goto fin; }\r
+\r
+ offset_of_next = (unsigned)( (char*)OverAddrBasedOnNowFirst - (char*)m->First );\r
+ offset_of_over = (unsigned)( ( (char*)m->Over - (char*)m->First ) ) * 2;\r
+ IF_D( offset_of_next >= 0x80000000 ) { e=E_OTHERS; goto fin; }\r
+ if ( offset_of_over == 0 ) { offset_of_over = 0x100; }\r
+ while ( offset_of_over < offset_of_next ) { offset_of_over *= 2; }\r
+ IF( offset_of_over >= 0x10000000 ) { e=E_OTHERS; goto fin; }\r
+\r
+ new_first = realloc( m->First, offset_of_over * 2 );\r
+ IF( new_first == NULL ) { e=E_FEW_MEMORY; goto fin; }\r
+\r
+ m->Next = (char*) new_first + ( (char*)m->Next - (char*)m->First );\r
+ m->Over = (char*) new_first + offset_of_over * 2;\r
+ m->First = new_first;\r
+\r
+ #ifdef _DEBUG\r
+ if ( m->PointerOfDebugArray != NULL )\r
+ { *m->PointerOfDebugArray = m->First; }\r
+ #endif\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Set2_free_imp] >>> \r
+************************************************************************/\r
+errnum_t Set2_free_imp( Set2* self, void* in_PointerOfPointer, size_t in_Size_ofElement, errnum_t e )\r
+{\r
+ void* element;\r
+\r
+ element = *(void**) in_PointerOfPointer;\r
+\r
+ if ( element != NULL ) {\r
+ if ( element != ( (byte_t*) self->Next - in_Size_ofElement ) ) {\r
+ if ( e == 0 ) { e=E_OTHERS; }\r
+ }\r
+ else {\r
+ #ifndef NDEBUG\r
+ memset( element, 0xFE, in_Size_ofElement );\r
+ #endif\r
+\r
+ self->Next = element;\r
+\r
+ *(void**) in_PointerOfPointer = NULL;\r
+ }\r
+ }\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Set2_separate] >>> \r
+************************************************************************/\r
+errnum_t Set2_separate( Set2* m, int NextSize, void** allocate_Array )\r
+{\r
+ errnum_t e;\r
+ void* p = m->First;\r
+\r
+ if ( NextSize == 0 ) {\r
+ m->First = NULL;\r
+ m->Next = NULL;\r
+ m->Over = NULL;\r
+ }\r
+ else {\r
+ e= Set2_init( m, NextSize ); IF(e)goto fin;\r
+ }\r
+ *allocate_Array = p;\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Set2_pop_imp] >>> \r
+************************************************************************/\r
+errnum_t Set2_pop_imp( Set2* m, void* pp, size_t size )\r
+{\r
+ errnum_t e;\r
+ void* p;\r
+\r
+ p = (char*) m->Next - size;\r
+\r
+ IF ( p < m->First ) { e=E_OTHERS; goto fin; }\r
+\r
+ m->Next = p;\r
+ *(void**)pp = p;\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Set2_setDebug] >>> \r
+************************************************************************/\r
+#ifdef _DEBUG\r
+void Set2_setDebug( Set2* m, void* PointerOfDebugArray )\r
+{\r
+ m->PointerOfDebugArray = (void**) PointerOfDebugArray;\r
+ *m->PointerOfDebugArray = m->First;\r
+}\r
+#endif\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Set2a_init] >>> \r
+************************************************************************/\r
+int Set2a_init( Set2a* m, void* ArrInStack, size_t ArrInStack_Size )\r
+{\r
+ int e;\r
+\r
+ /* "m->First" is initialized in "Set2a_initConst" */\r
+\r
+ m->Next = m->First;\r
+ m->Over = (char*)m->First + ArrInStack_Size;\r
+\r
+ ASSERT_D( m->First == ArrInStack, e=E_OTHERS; goto fin );\r
+\r
+ #ifdef _DEBUG\r
+ m->PointerOfDebugArray = NULL;\r
+ #endif\r
+\r
+ e=0;\r
+#ifdef _DEBUG\r
+fin:\r
+#else\r
+ UNREFERENCED_VARIABLE( ArrInStack );\r
+#endif\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Set2a_alloc_imp] >>> \r
+************************************************************************/\r
+int Set2a_alloc_imp( Set2a* m, void* ArrInStack, void* out_Pointer, size_t ElemSize )\r
+{\r
+ int e;\r
+\r
+ e= Set2a_expandIfOverByAddr_imp( m, ArrInStack, (char*)m->Next + ElemSize ); IF(e)goto fin;\r
+ *(void**)out_Pointer = m->Next;\r
+ m->Next = (char*) m->Next + ElemSize;\r
+\r
+ e=0;\r
+fin:\r
+ return e;\r
+}\r
+\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Set2a_expandIfOverByAddr_imp] >>> \r
+************************************************************************/\r
+int Set2a_expandIfOverByAddr_imp( Set2a* m, void* ArrInStack, void* OverAddrBasedOnNowFirst )\r
+{\r
+ void* new_memory;\r
+ unsigned ofs;\r
+\r
+ if ( m->First == ArrInStack ) {\r
+ ofs = (char*)m->Over - (char*)m->First;\r
+ new_memory = malloc( ofs * 2 );\r
+ IF( new_memory == NULL ) return E_FEW_MEMORY;\r
+\r
+ memcpy( new_memory, m->First, ofs * 2 );\r
+\r
+ m->First = new_memory;\r
+ m->Over = (char*)new_memory + ofs * 2;\r
+ m->Next = (char*)new_memory + ofs;\r
+ return 0;\r
+ }\r
+ else {\r
+ return Set2_expandIfOverByAddr_imp( (Set2*) m, OverAddrBasedOnNowFirst );\r
+ }\r
+}\r
+\r
+\r
+ \r
+/*=================================================================*/\r
+/* <<< [Print/Print2.c] >>> */ \r
+/*=================================================================*/\r
+ \r
+/***********************************************************************\r
+ <<< [vsprintf_r] >>> \r
+************************************************************************/\r
+errnum_t vsprintf_r( char* s, size_t s_size, const char* format, va_list va )\r
+{\r
+ #if _MSC_VER\r
+ #pragma warning(push)\r
+ #pragma warning(disable: 4996)\r
+ #endif\r
+\r
+ int r = _vsnprintf( s, s_size, format, va );\r
+\r
+ #if _MSC_VER\r
+ #pragma warning(pop)\r
+ #endif\r
+\r
+ IF( r == (int) s_size )\r
+ { s[s_size-1] = '\0'; return E_FEW_ARRAY; }\r
+ IF( r == -1 )\r
+ { return E_NOT_FOUND_SYMBOL; } /* Bad character code */\r
+\r
+ return 0;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [vswprintf_r] >>> \r
+************************************************************************/\r
+#ifndef __linux__\r
+errnum_t vswprintf_r( wchar_t* s, size_t s_size, const wchar_t* format, va_list va )\r
+{\r
+ size_t tsize = s_size / sizeof(wchar_t);\r
+\r
+ #if _MSC_VER\r
+ #pragma warning(push)\r
+ #pragma warning(disable: 4996)\r
+ #endif\r
+\r
+ int r = _vsnwprintf( s, tsize, format, va );\r
+\r
+ #if _MSC_VER\r
+ #pragma warning(pop)\r
+ #endif\r
+\r
+ if ( r == (int) tsize || r == -1 ) { s[tsize-1] = '\0'; return E_FEW_ARRAY; }\r
+ else return 0;\r
+}\r
+#endif\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [stprintf_r] >>> \r
+************************************************************************/\r
+errnum_t stprintf_r( TCHAR* s, size_t s_size, const TCHAR* format, ... )\r
+{\r
+ errnum_t e;\r
+ va_list va;\r
+\r
+ va_start( va, format );\r
+ e = vstprintf_r( s, s_size, format, va );\r
+ va_end( va );\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [stcpy_part_r] >>> \r
+************************************************************************/\r
+errnum_t stcpy_part_r( TCHAR* s, size_t s_size, TCHAR* s_start, TCHAR** p_s_last,\r
+ const TCHAR* src, const TCHAR* src_over )\r
+{\r
+ size_t s_space = (char*)s + s_size - (char*)s_start;\r
+ size_t src_size;\r
+\r
+ IF_D( s_start < s || (char*)s_start >= (char*)s + s_size ) { return 1; }\r
+\r
+ if ( src_over == NULL ) { src_over = StrT_chr( src, _T('\0') ); }\r
+ IF_D( src > src_over ) { return 1; }\r
+ src_size = (char*)src_over - (char*)src;\r
+ IF ( src_size >= s_space ) {\r
+ s_space -= sizeof(TCHAR);\r
+ memcpy( s, src, s_space );\r
+\r
+ s_start = (TCHAR*)((char*)s_start + s_space );\r
+ *s_start = '\0';\r
+\r
+ if ( p_s_last != NULL ) { *p_s_last=s_start; }\r
+ return E_FEW_ARRAY;\r
+ }\r
+\r
+ memcpy( s_start, src, src_size + sizeof(TCHAR) );\r
+ s_start = (TCHAR*)((char*)s_start + src_size); *s_start = _T('\0');\r
+ if ( p_s_last != NULL ) { *p_s_last = s_start; }\r
+\r
+ return 0;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [stprintf_part_r] >>> \r
+************************************************************************/\r
+errnum_t stprintf_part_r( TCHAR* s, size_t s_size, TCHAR* s_start, TCHAR** p_s_last,\r
+ const TCHAR* format, ... )\r
+{\r
+ errnum_t e;\r
+ va_list va;\r
+ va_start( va, format );\r
+\r
+ IF_D( s_start < s || (char*)s_start >= (char*)s + s_size ) {return E_OTHERS;}\r
+\r
+ e = vstprintf_r( s_start, s_size - ( (char*)s_start - (char*)s), format, va );\r
+ va_end( va ); if ( p_s_last != NULL ) *p_s_last = StrT_chr( s_start, '\0' );\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/*=================================================================*/\r
+/* <<< [Lock_1/Lock_1.c] >>> */ \r
+/*=================================================================*/\r
+ \r
+/*-------------------------------------------------------------------------*/\r
+/* <<<< ### (SingletonInitializerClass) implement >>>> */ \r
+/*-------------------------------------------------------------------------*/\r
+\r
+\r
+volatile int g_SingletonInitializerClass_FailSleepTime = SingletonInitializerClass_FailSleepTime;\r
+\r
+\r
+/*[SingletonInitializerClass_isFirst]*/\r
+bool SingletonInitializerClass_isFirst( SingletonInitializerClass* self )\r
+{\r
+ for (;;) {\r
+ if ( InterlockedCompareExchange( &self->InitializeStep, 1, 0 ) == 0 ) {\r
+ return true;\r
+ }\r
+ else {\r
+ while ( self->InitializeStep == 1 ) {\r
+ Sleep( 0 ); /* Wait for initialized by other thread. */\r
+ }\r
+\r
+ if ( self->InitializeStep == 2 ) {\r
+ return false;\r
+ }\r
+\r
+ Sleep( g_SingletonInitializerClass_FailSleepTime );\r
+ g_SingletonInitializerClass_FailSleepTime = 0;\r
+ }\r
+ }\r
+}\r
+\r
+\r
+/*[SingletonInitializerClass_onFinishedInitialize]*/\r
+void SingletonInitializerClass_onFinishedInitialize( SingletonInitializerClass* self, errnum_t e )\r
+{\r
+ if ( e == 0 )\r
+ { self->InitializeStep = 2; }\r
+ else\r
+ { self->InitializeStep = 0; }\r
+}\r
+\r
+\r
+/*[SingletonInitializerClass_isInitialized]*/\r
+bool SingletonInitializerClass_isInitialized( SingletonInitializerClass* self )\r
+{\r
+ return ( self->InitializeStep == 2 );\r
+}\r
+\r
+\r
+/*-------------------------------------------------------------------------*/\r
+/* <<< End of Class implement >>> */ \r
+/*-------------------------------------------------------------------------*/\r
+\r
+\r
+ \r
+/*=================================================================*/\r
+/* <<< [CRT_plus_1/CRT_plus_1.c] >>> */ \r
+/*=================================================================*/\r
+ \r
+/***********************************************************************\r
+ <<< [ttoi_ex] >>> \r
+************************************************************************/\r
+int ttoi_ex( const TCHAR* string, bit_flags_fast32_t options )\r
+{\r
+ int return_value;\r
+\r
+ UNREFERENCED_VARIABLE( options);\r
+\r
+ if ( string[0] == _T('0') &&\r
+ ( string[1] == _T('x') || string[1] == _T('X') ) )\r
+ {\r
+ return_value = (int) _tcstoul( &string[2], NULL, 16 );\r
+ }\r
+ else {\r
+ return_value = _ttoi( string );\r
+ }\r
+\r
+ return return_value;\r
+}\r
+\r
+\r
+ \r
OSDN Git Service
