+/* Character Code Encoding: "WHITE SQUARE" is \81 */\r
/* The source file was composed by module mixer */ \r
\r
#include "include_c.h"\r
/***********************************************************************\r
<<< [FileT_isSameBinaryFile] >>> \r
************************************************************************/\r
-int FileT_isSameBinaryFile( const TCHAR* PathA, const TCHAR* PathB, int Flags, bool* out_IsSame )\r
+errnum_t FileT_isSameBinaryFile( const TCHAR* PathA, const TCHAR* PathB, int Flags, bool* out_IsSame )\r
{\r
- int e;\r
+ errnum_t e;\r
HANDLE file_a = INVALID_HANDLE_VALUE;\r
HANDLE file_b = INVALID_HANDLE_VALUE;\r
HANDLE mem_a = INVALID_HANDLE_VALUE;\r
\r
// file_a, file_b : open PathA, PathB\r
file_a = CreateFile( PathA, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,\r
- FILE_ATTRIBUTE_NORMAL, 0 );\r
+ FILE_ATTRIBUTE_NORMAL, 0 );\r
IF( file_a == INVALID_HANDLE_VALUE ) goto err_gt;\r
\r
file_b = CreateFile( PathB, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,\r
- FILE_ATTRIBUTE_NORMAL, 0 );\r
+ FILE_ATTRIBUTE_NORMAL, 0 );\r
IF( file_b == INVALID_HANDLE_VALUE ) goto err_gt;\r
\r
// size_a, size_b : size of file_a, file_b\r
\r
\r
/* FullPathMem \82Ì\8dÅ\8cã\82É \ \82ª\96³\82¢\82È\82ç\92Ç\89Á\82·\82é */\r
- p = _tcschr( data.FullPathMem, _T('\0') );\r
+ p = StrT_chr( data.FullPathMem, _T('\0') );\r
p--;\r
if ( *p != _T('\\') ) {\r
p++;\r
if ( data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) {\r
TCHAR* prev_fname = m->FileName;\r
\r
- p = _tcschr( m->FileName, _T('\0') );\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
\r
\r
\r
+/***********************************************************************\r
+* Class: ViewOfFileClass\r
+************************************************************************/\r
+\r
+/***********************************************************************\r
+* Function: ViewOfFileClass_initConst\r
+************************************************************************/\r
+void ViewOfFileClass_initConst( ViewOfFileClass* self )\r
+{\r
+ self->Data = NULL;\r
+ self->File = INVALID_HANDLE_VALUE;\r
+ self->Memory = INVALID_HANDLE_VALUE;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+* Function: ViewOfFileClass_initializeFromBinaryFile\r
+************************************************************************/\r
+errnum_t ViewOfFileClass_initializeFromBinaryFile( ViewOfFileClass* self,\r
+ const TCHAR* Path )\r
+{\r
+ errnum_t e;\r
+\r
+\r
+ self->File = CreateFile( Path, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,\r
+ FILE_ATTRIBUTE_NORMAL, 0 );\r
+ IF( self->File == INVALID_HANDLE_VALUE ) { e=E_GET_LAST_ERROR; goto fin; }\r
+\r
+ self->Size = GetFileSize( self->File, NULL );\r
+\r
+ self->Memory = CreateFileMapping( self->File, NULL, PAGE_READONLY, 0, self->Size, NULL );\r
+ IF( self->Memory == INVALID_HANDLE_VALUE ) { e=E_GET_LAST_ERROR; goto fin; }\r
+\r
+ self->Data = MapViewOfFile( self->Memory, FILE_MAP_READ, 0, 0, 0 );\r
+ IF ( self->Data == NULL ) { e=E_GET_LAST_ERROR; goto fin; }\r
+\r
+\r
+ e=0;\r
+fin:\r
+ if ( e != 0 ) {\r
+ e= ViewOfFileClass_finalize( self, e );\r
+ }\r
+ return e;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+* Function: ViewOfFileClass_finalize\r
+************************************************************************/\r
+errnum_t ViewOfFileClass_finalize( ViewOfFileClass* self, errnum_t e )\r
+{\r
+ BOOL b;\r
+\r
+ if ( self->Data != NULL ) { b= UnmapViewOfFile( self->Data ); IF(!b&&!e) e=SaveWindowsLastError(); }\r
+ if ( self->Memory != INVALID_HANDLE_VALUE ) { b= CloseHandle( self->Memory ); IF(!b&&!e) e=SaveWindowsLastError(); }\r
+ if ( self->File != INVALID_HANDLE_VALUE ) { b= CloseHandle( self->File ); IF(!b&&!e) e=SaveWindowsLastError(); }\r
+ self->Data = NULL;\r
+ self->File = INVALID_HANDLE_VALUE;\r
+ self->Memory = INVALID_HANDLE_VALUE;\r
+\r
+ return e;\r
+}\r
+\r
+\r
+/* Section: Global */\r
+ \r
/*=================================================================*/\r
/* <<< [Error4/Error4.c] >>> */ \r
/*=================================================================*/\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 = _tcschr( str_pointer, _T('\0') );\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
************************************************************************/\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
#if _UNICODE\r
setlocale( LC_ALL, ".OCP" );\r
sprintf_s( msg2, sizeof(msg2), "%S", msg );\r
- fprintf( stderr, "%s\n", msg2 ); // _ftprintf_s \82Å\82Í\93ú\96{\8cê\82ª\8fo\82Ü\82¹\82ñ\r
+ fprintf( out, "%s\n", msg2 ); // _ftprintf_s \82Å\82Í\93ú\96{\8cê\82ª\8fo\82Ü\82¹\82ñ\r
#else\r
- fprintf( stderr, "%s\n", msg );\r
+ fprintf( out, "%s\n", msg );\r
#endif\r
\r
#if ERR2_ENABLE_ERROR_BREAK\r
- fprintf( stderr, "\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
+ 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
/* Not show the message for developper */\r
}\r
else {\r
- fprintf( stderr, "\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
+ 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
\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
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
TCHAR* StrT_searchOverOfCIdentifier( const TCHAR* Text )\r
{\r
const TCHAR* p;\r
- TCHAR c;\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
- c = *p;\r
- for (;;) {\r
- if ( StrT_isCIdentifier( c ) ) {\r
- p += 1;\r
- c = *p;\r
- }\r
- else {\r
- return (TCHAR*) p;\r
- }\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
<<< [StrT_cmp_part] >>> \r
************************************************************************/\r
-int StrT_cmp_part( const TCHAR* StringA_Start, const TCHAR* StringA_Over,\r
- const TCHAR* StringB )\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 = StringA_Start;\r
- b = StringB;\r
+ a = in_StringA_Start;\r
+ b = in_StringB;\r
\r
for (;;) {\r
- if ( a >= StringA_Over ) {\r
+ if ( a >= in_StringA_Over ) {\r
bb = *b;\r
if ( bb == _T('\0') )\r
{ return 0; }\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* StringA_Start, const TCHAR* StringA_Over,\r
- const TCHAR* StringB_Start, const TCHAR* StringB_Over )\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 = StringA_Over - StringA_Start;\r
- int length_B = StringB_Over - StringB_Start;\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( StringA_Start, StringB_Start, length_A );\r
+ return _tcsncmp( in_StringA_Start, in_StringB_Start, length_A );\r
}\r
}\r
\r
const TCHAR* p;\r
TCHAR c;\r
\r
- p = _tcschr( s, _T('\0') );\r
+ p = StrT_chr( s, _T('\0') );\r
\r
if ( p == s ) return (TCHAR*) s;\r
\r
{\r
const TCHAR* p;\r
\r
- p = _tcschr( s, _T('\0') );\r
+ p = StrT_chr( s, _T('\0') );\r
\r
- if ( p == s ) return (TCHAR*) s;\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('\\') ) return (TCHAR*) _tcschr( p, _T('\0') );\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*) _tcschr( s, _T('\0') );\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
TCHAR c;\r
\r
p1 = in_Str; while ( *p1 == _T(' ') || *p1 == _T('\t') ) p1++;\r
- for ( p2 = _tcschr( p1, _T('\0') ) - 1; p2 >= p1; p2-- ) {\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
\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 = _tcschr( in_out_Str, _T('\0') );\r
+ TCHAR* last = StrT_chr( in_out_Str, _T('\0') );\r
\r
if ( last > in_out_Str ) {\r
if ( *( last - 1 ) == Charactor )\r
p1 = in_Str; while ( *p1 == _T(' ') || *p1 == _T('\t') ) p1++;\r
\r
p2 = _tcsstr( p1, CommentSign );\r
- if ( p2 == NULL ) p2 = _tcschr( p1, _T('\0') );\r
+ if ( p2 == NULL ) p2 = StrT_chr( p1, _T('\0') );\r
\r
for ( p2 = p2 - 1; p2 >= p1; p2-- ) {\r
c = *p2;\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
bit_flags32_t read_flags;\r
bit_flags32_t next_read_flag;\r
TCHAR* out_str;\r
- size_t str_size;\r
+ size_t str_size = SIZE_MAX; /* SIZE_MAX = Avoid warning */\r
\r
\r
va_start( va, Types );\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
TCHAR* out_full_path_over = (TCHAR*)( (uint8_t*) out_FullPath + FullPathSize );\r
TCHAR* null_position = NULL;\r
\r
-\r
#if CHECK_ARG\r
/* "BasePath" must be out of "out_FullPath" */\r
ASSERT_R( BasePath < out_FullPath ||\r
\r
/* Cut last \. */\r
{\r
- TCHAR* over = _tcschr( OutStart, _T('\0') );\r
+ TCHAR* over = StrT_chr( OutStart, _T('\0') );\r
\r
while ( over - 2 >= OutStart &&\r
*( over - 1 ) == _T('.') && *( over - 2 ) == separator ) {\r
\r
\r
/* Cut last \ */\r
- p = _tcschr( StrStart, _T('\0') );\r
+ p = StrT_chr( StrStart, _T('\0') );\r
if ( p > StrStart ) {\r
TCHAR c = *( p - 1 );\r
if ( c == _T('\\') || c == _T('/') )\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('\\') ||\r
- base_char == _T('/') || base_char == _T('\\') ) {\r
- /* other character is '\0' */\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
size_t copy_size;\r
size_t free_size;\r
char* out_pos;\r
- const TCHAR* last_pos_in_base = _tcschr( BasePath, _T('\0') );\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 = _tcschr( AddName, _T('\0') );\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
else {\r
if ( term_pos_in_base < BasePath )\r
- add_pos_in_base = _tcschr( BasePath, _T('\0') );\r
+ add_pos_in_base = StrT_chr( BasePath, _T('\0') );\r
else\r
- add_pos_in_base = _tcschr( term_pos_in_base, _T('\0') );\r
+ add_pos_in_base = StrT_chr( term_pos_in_base, _T('\0') );\r
}\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
<<< [Strs_init] >>> \r
************************************************************************/\r
enum { Strs_FirstSize = 0x0F00 };\r
\r
errnum_t Strs_init( Strs* self )\r
{\r
- char* p;\r
+ byte_t* p;\r
\r
self->MemoryAddress = NULL;\r
\r
- p = (char*) malloc( Strs_FirstSize );\r
+ p = (byte_t*) malloc( Strs_FirstSize );\r
IF( p == NULL ) return E_FEW_MEMORY;\r
\r
self->MemoryAddress = p;\r
************************************************************************/\r
errnum_t Strs_add( Strs* self, const TCHAR* Str, const TCHAR** out_AllocStr )\r
{\r
- return Strs_addBinary( self, Str, _tcschr( Str, _T('\0') ) + 1, out_AllocStr );\r
+ return Strs_addBinary( self, Str, StrT_chr( Str, _T('\0') ) + 1, out_AllocStr );\r
}\r
\r
\r
size_t str_size;\r
size_t elem_size;\r
\r
- str_size = ( (char*) StrOver - (char*) Str );\r
- elem_size = ( sizeof(TCHAR*) + str_size + sizeof(void*) - 1 ) & ~(sizeof(void*) - 1);\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
// [ FirstStr | NextStr | TCHAR[] | NULL | TCHAR[] | ... ]\r
- else if ( (char*) prev_of_last_str >= self->MemoryAddress &&\r
- (char*) prev_of_last_str < self->MemoryOver ) {\r
- self->NextElem = (char*)last_str - sizeof(TCHAR*);\r
- self->PointerToNextStrInPrevElem = (TCHAR**)( (char*)prev_of_last_str - sizeof(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
Strs* mp2;\r
size_t elem_size = ( sizeof(TCHAR*) + FreeSize + sizeof(void*) - 1 ) & ~(sizeof(void*) - 1);\r
size_t memory_size;\r
- char* new_memory;\r
+ byte_t* new_memory;\r
\r
// [ NULL | ... ]\r
// [ FirstStr | NULL | TCHAR[] | ... ]\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 = (char*) malloc( memory_size );\r
+ new_memory = (byte_t*) malloc( memory_size );\r
IF( new_memory == NULL ) { free( mp ); goto err_fm; }\r
\r
//=== move old memory\r
size_t elem_size;\r
\r
if ( StrOver == NULL )\r
- { StrOver = _tcschr( (TCHAR*)( self->NextElem + sizeof(TCHAR*) ), _T('\0') ) + 1; }\r
- elem_size = ( ( (char*)StrOver - self->NextElem ) + sizeof(void*) - 1 ) & ~(sizeof(void*) - 1);\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
\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
/***********************************************************************\r
<<< [Set2_init] >>> \r
************************************************************************/\r
-int Set2_init( Set2* m, int FirstSize )\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
/***********************************************************************\r
<<< [Set2_finish] >>> \r
************************************************************************/\r
-int Set2_finish( Set2* m, int e )\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
<<< [Set2_ref_imp] >>> \r
************************************************************************/\r
-int Set2_ref_imp( Set2* m, int iElem, void* out_pElem, size_t ElemSize )\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
<<< [Set2_alloc_imp] >>> \r
************************************************************************/\r
-int Set2_alloc_imp( Set2* m, void* pp, size_t size )\r
+errnum_t Set2_alloc_imp( Set2* m, void* pp, size_t size )\r
{\r
- int e;\r
+ errnum_t e;\r
\r
e= Set2_expandIfOverByAddr( m, (char*) m->Next + size ); IF(e)goto fin;\r
*(void**)pp = m->Next;\r
}\r
\r
\r
-int Set2_allocMulti_sub( Set2* m, void* out_pElem, size_t ElemsSize )\r
+/***********************************************************************\r
+ <<< [Set2_allocMulti_sub] >>> \r
+************************************************************************/\r
+errnum_t Set2_allocMulti_sub( Set2* m, void* out_pElem, size_t ElemsSize )\r
{\r
- int e;\r
- char* p;\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
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_D( offset_of_over == 0 ) { 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
\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
-int Set2_separate( Set2* m, int NextSize, void** allocate_Array )\r
+errnum_t Set2_separate( Set2* m, int NextSize, void** allocate_Array )\r
{\r
- int e;\r
- void* p = m->First;\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
<<< [Set2_pop_imp] >>> \r
************************************************************************/\r
-int Set2_pop_imp( Set2* m, void* pp, size_t size )\r
+errnum_t Set2_pop_imp( Set2* m, void* pp, size_t size )\r
{\r
- int e;\r
- void* p;\r
+ errnum_t e;\r
+ void* p;\r
\r
p = (char*) m->Next - size;\r
\r
{\r
size_t tsize = s_size / sizeof(wchar_t);\r
\r
- #pragma warning(push)\r
- #pragma warning(disable: 4996)\r
- int r = _vsnwprintf( s, tsize, format, va );\r
- #pragma warning(pop)\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
IF_D( s_start < s || (char*)s_start >= (char*)s + s_size ) { return 1; }\r
\r
- if ( src_over == NULL ) { src_over = _tcschr( src, _T('\0') ); }\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
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 = _tcschr( s_start, '\0' );\r
+ va_end( va ); if ( p_s_last != NULL ) *p_s_last = StrT_chr( s_start, '\0' );\r
return e;\r
}\r
\r
OSDN Git Service
