1 /* The header file was composed by module mixer */
\r
4 #pragma message( "start of #include \"" __FILE__ "\"" )
\r
13 /*=================================================================*/
\r
14 /* <<< [Error4_Type/Error4_Type.h] >>> */
\r
15 /*=================================================================*/
\r
17 /***********************************************************************
\r
19 *
\83G
\83\89\81[
\83R
\81[
\83h
\81A
\83G
\83\89\81[
\94Ô
\8d\86\r
20 ************************************************************************/
\r
21 typedef int errnum_t; /* [errnum_t] 0=no error */
\r
23 #ifndef NO_ERROR /* same as windows.h */
\r
24 enum { NO_ERROR = 0 }; /* NO_ERROR symbol is for magic code warning only */
\r
27 enum { E_CATEGORY_MASK = 0xFFFFFF00 }; /* E_CATEGORY_* */
\r
28 enum { E_OFFSET_MASK = 0x000000FF };
\r
30 #ifndef E_CATEGORY_COMMON /* If not duplicated */
\r
31 #define E_CATEGORY_COMMON E_CATEGORY_COMMON
\r
32 enum { E_CATEGORY_COMMON = 0x00000400 }; /* 0x001, 0x400 .. 0x4FF : Reseved meaning by clib */
\r
36 #define E_OTHERS E_OTHERS
\r
37 enum { E_OTHERS = 1 };
\r
40 enum { E_GET_LAST_ERROR = E_CATEGORY_COMMON | 0x01 }; /* 1025 */
\r
41 enum { E_HRESULT = E_CATEGORY_COMMON | 0x02 }; /* 1026 */
\r
42 enum { E_ERRNO = E_CATEGORY_COMMON | 0x03 }; /* 1027 */
\r
43 enum { E_UNKNOWN = E_CATEGORY_COMMON | 0x04 }; /* 1028 */
\r
44 enum { E_IN_ERROR = E_CATEGORY_COMMON | 0x05 }; /* 1029 */
\r
45 enum { E_IN_FINALLY = E_CATEGORY_COMMON | 0x06 }; /* 1030 */
\r
46 enum { E_INVALID_VALUE = E_CATEGORY_COMMON | 0x07 }; /* 1031 */
\r
47 enum { E_UNKNOWN_DATA_TYPE = E_CATEGORY_COMMON | 0x08 }; /* 1032 */
\r
48 enum { E_NOT_IMPLEMENT_YET = E_CATEGORY_COMMON | 0x09 }; /* 1033 */
\r
49 enum { E_ORIGINAL = E_CATEGORY_COMMON | 0x0A }; /* 1034 */
\r
50 enum { E_LIMITATION = E_CATEGORY_COMMON | 0x0F }; /* 1039 */
\r
51 enum { E_FEW_MEMORY = E_CATEGORY_COMMON | 0x10 }; /* 1040 */
\r
52 enum { E_FEW_ARRAY = E_CATEGORY_COMMON | 0x11 }; /* 1041 */
\r
53 enum { E_CANNOT_OPEN_FILE = E_CATEGORY_COMMON | 0x12 }; /* 1042 */
\r
54 enum { E_NOT_FOUND_DLL_FUNC = E_CATEGORY_COMMON | 0x13 }; /* 1043 */
\r
55 enum { E_BAD_COMMAND_ID = E_CATEGORY_COMMON | 0x14 }; /* 1044 */
\r
56 enum { E_NOT_FOUND_SYMBOL = E_CATEGORY_COMMON | 0x15 }; /* 1045 */
\r
57 enum { E_NO_NEXT = E_CATEGORY_COMMON | 0x16 }; /* 1046 */
\r
58 enum { E_ACCESS_DENIED = E_CATEGORY_COMMON | 0x17 }; /* 1047 */
\r
59 enum { E_PATH_NOT_FOUND = E_CATEGORY_COMMON | 0x18 }; /* 1048 */
\r
60 enum { E_OUT_OF_WRITABLE = E_CATEGORY_COMMON | 0x25 }; /* 1061 */
\r
61 enum { E_NOT_INIT_GLOBAL = E_CATEGORY_COMMON | 0x6B }; /* 1131 */
\r
62 enum { E_TIME_OUT = E_CATEGORY_COMMON | 0x70 }; /* 1136 */
\r
63 enum { E_BINARY_FILE = E_CATEGORY_COMMON | 0xBF }; /* 1215 */
\r
64 enum { E_DEBUG_BREAK = E_CATEGORY_COMMON | 0xDB }; /* 1243 */
\r
65 enum { E_EXIT_TEST = E_CATEGORY_COMMON | 0xE7 }; /* 1255 */
\r
66 enum { E_FIFO_OVER = E_CATEGORY_COMMON | 0xF0 }; /* 1264 */
\r
68 enum { NOT_FOUND_INDEX = -1 };
\r
71 /*=================================================================*/
\r
72 /* <<< [CRT/CRT.h] >>> */
\r
73 /*=================================================================*/
\r
77 #define _tfopen_s( out_File, Path, Mode ) \
\r
78 ( *(out_File) = fopen( Path, Mode ), (*(out_File) == NULL) ? (1) : (0) )
\r
81 #include <stdlib.h>
\r
83 #include <string.h>
\r
85 #include <stdarg.h>
\r
87 #define _vsnprintf vsnprintf
\r
90 #include <stddef.h>
\r
92 #include <crtdbg.h>
\r
99 #define _tcschr strchr
\r
100 #define _tprintf printf
\r
103 #include <locale.h>
\r
106 #define setlocale( x, y )
\r
109 #include <errno.h>
\r
111 typedef int errno_t; // CERT DCL09-C
\r
114 #include <assert.h>
\r
116 #include <direct.h>
\r
118 #include <malloc.h>
\r
122 #include <fcntl.h>
\r
124 #include <tlhelp32.h>
\r
126 /*=================================================================*/
\r
127 /* <<< [CRT_plus_1/CRT_plus_1.h] >>> */
\r
128 /*=================================================================*/
\r
131 extern "C" { /* Start of C Symbol */
\r
136 /***********************************************************************
\r
138 ************************************************************************/
\r
139 typedef int int_t; /* MISRA-C:1998 No.13 */
\r
140 typedef signed int int32_t; /* For 32bit compiler */
\r
141 typedef signed short int16_t;
\r
142 typedef signed char int8_t;
\r
143 typedef unsigned int uint_t; /* MISRA-C:1998 No.13 */ /* This is not C99 */
\r
144 typedef unsigned int uint32_t; /* For 32bit compiler */
\r
145 typedef unsigned short uint16_t;
\r
146 typedef unsigned char uint8_t;
\r
147 typedef unsigned char byte_t; /* This is not C99 */
\r
148 typedef float float32_t; /* This is not C99 */
\r
149 typedef double float64_t; /* This is not C99 */
\r
150 typedef unsigned int bool_t; /* MISRA-C:1998 No.13 */ /* This is not C99 */
\r
151 typedef unsigned int bool32_t; /* For 32bit compiler */
\r
152 typedef unsigned short bool16_t;
\r
153 typedef unsigned char bool8_t;
\r
154 typedef int int_fast32_t;
\r
155 typedef int int_fast16_t;
\r
156 typedef int int_fast8_t;
\r
157 typedef unsigned int uint_fast32_t;
\r
158 typedef unsigned int uint_fast16_t;
\r
159 typedef unsigned int uint_fast8_t;
\r
161 #define INT_FAST32_MAX INT_MAX
\r
165 /***********************************************************************
\r
166 <<< [INVALID_ARRAY_INDEX] >>>
\r
167 ************************************************************************/
\r
168 enum { INVALID_ARRAY_INDEX = -1 };
\r
172 /*********************************************************************************************
\r
173 <<< [bit_flags32_t] [bit_flags_fast32_t] >>>
\r
174 <<< [BitField] [BIT_FIELD_ENDIAN] [BIT_FIELD_LITTLE_ENDIAN] [BIT_FIELD_BIG_ENDIAN] >>>
\r
175 **********************************************************************************************/
\r
176 typedef uint32_t bit_flags32_t;
\r
177 typedef uint_fast32_t bit_flags_fast32_t;
\r
178 typedef unsigned int BitField;
\r
179 typedef uint32_t BitField32;
\r
180 #define BIT_FIELD_ENDIAN BIT_FIELD_LITTLE_ENDIAN
\r
181 #define BIT_FIELD_LITTLE_ENDIAN 1
\r
182 #define BIT_FIELD_BIG_ENDIAN 2
\r
186 /***********************************************************************
\r
187 <<< [IsBitSet] Check 1 bit >>>
\r
188 <<< [IsAnyBitsSet] Check multiple bits >>>
\r
189 <<< [IsAllBitsSet] Check multiple bits >>>
\r
190 <<< [IsBitNotSet] Check 1 bit >>>
\r
191 <<< [IsAnyBitsNotSet] Check multiple bits >>>
\r
192 <<< [IsAllBitsNotSet] Check multiple bits >>>
\r
193 ************************************************************************/
\r
194 #define IsBitSet( variable, const_value ) \
\r
195 ( ( (variable) & (const_value) ) != 0 )
\r
197 #define IsAnyBitsSet( variable, or_const_value ) \
\r
198 ( ( (variable) & (or_const_value) ) != 0 )
\r
200 #define IsAllBitsSet( variable, or_const_value ) \
\r
201 ( ( (variable) & (or_const_value) ) == (or_const_value) )
\r
203 #define IsBitNotSet( variable, const_value ) \
\r
204 ( ( (variable) & (const_value) ) == 0 )
\r
206 #define IsAnyBitsNotSet( variable, or_const_value ) \
\r
207 ( ( (variable) & (or_const_value) ) != (or_const_value) )
\r
209 #define IsAllBitsNotSet( variable, or_const_value ) \
\r
210 ( ( (variable) & (or_const_value) ) == 0 )
\r
214 /***********************************************************************
\r
215 <<< [bool type] >>>
\r
216 ************************************************************************/
\r
217 #ifndef __cplusplus
\r
218 #ifndef BOOL_DEFINED
\r
219 typedef unsigned char bool;
\r
220 enum { true = 1, false = 0 };
\r
221 #define BOOL_DEFINED
\r
227 /***********************************************************************
\r
228 <<< (malloc_redirected) >>>
\r
229 ************************************************************************/
\r
230 #define malloc malloc_redirected
\r
231 #define realloc realloc_redirected
\r
232 #define calloc calloc_redirected
\r
233 void* malloc_redirected( size_t in_Size );
\r
234 void* realloc_redirected( void* in_Address, size_t in_Size );
\r
235 void* calloc_redirected( size_t in_Count, size_t in_Size );
\r
236 void* malloc_no_redirected( size_t in_Size );
\r
237 void* realloc_no_redirected( void* in_Address, size_t in_Size );
\r
238 void* calloc_no_redirected( size_t in_Count, size_t in_Size );
\r
242 /***********************************************************************
\r
243 <<< [FuncType] >>>
\r
244 ************************************************************************/
\r
245 typedef int (*FuncType)( void* Param );
\r
246 typedef errnum_t (* InitializeFuncType )( void* self, void* Parameter );
\r
247 //typedef int (*FinishFuncType)( void* m, int e ); /*[FinishFuncType]*/
\r
248 typedef errnum_t (*FinalizeFuncType)( void* self, errnum_t e ); /*[FinalizeFuncType]*/
\r
252 /***********************************************************************
\r
253 <<< [InterfaceID_Class] >>>
\r
254 <<< [InterfaceToVTableClass] >>>
\r
255 - const InterfaceID_Class g_SampleInterface_ID;
\r
256 ************************************************************************/
\r
257 typedef struct _InterfaceID_Class InterfaceID_Class;
\r
258 struct _InterfaceID_Class {
\r
259 char* InterfaceName;
\r
262 typedef struct _InterfaceToVTableClass InterfaceToVTableClass;
\r
263 struct _InterfaceToVTableClass {
\r
264 const InterfaceID_Class* InterfaceID;
\r
265 const void* VTable;
\r
270 /***********************************************************************
\r
271 <<< [ClassID_Class] >>>
\r
272 - const ClassID_Class g_SampleClass_ID;
\r
273 ************************************************************************/
\r
274 typedef struct _ClassID_Class ClassID_Class;
\r
275 struct _ClassID_Class {
\r
277 const ClassID_Class** SuperClassID_Array;
\r
278 int SuperClassID_Array_Count;
\r
280 InitializeFuncType InitializeFunction;
\r
281 const InterfaceToVTableClass* InterfaceToVTable_Array;
\r
282 int InterfaceToVTable_Array_Conut;
\r
285 bool ClassID_Class_isSuperClass( const ClassID_Class* ClassID, const ClassID_Class* SuperClassID );
\r
286 errnum_t ClassID_Class_createObject( const ClassID_Class* ClassID, void* out_Object, void* Parameter );
\r
287 void* ClassID_Class_getVTable( const ClassID_Class* ClassID, const InterfaceID_Class* InterfaceID );
\r
291 /***********************************************************************
\r
292 <<< [ClassID_SuperClass] >>>
\r
293 ************************************************************************/
\r
294 typedef struct _ClassID_SuperClass ClassID_SuperClass;
\r
295 struct _ClassID_SuperClass {
\r
296 const ClassID_Class* ClassID; /* &g_(ClassName)_ID */
\r
298 extern const ClassID_Class g_ClassID_SuperClass_ID;
\r
302 /***********************************************************************
\r
303 <<< [g_FinalizerInterface_ID] >>>
\r
304 ************************************************************************/
\r
306 extern const InterfaceID_Class g_FinalizerInterface_ID;
\r
308 /*[FinalizerVTableClass]*/
\r
309 typedef struct _FinalizerVTableClass FinalizerVTableClass;
\r
310 struct _FinalizerVTableClass {
\r
312 FinalizeFuncType Finalize;
\r
317 /***********************************************************************
\r
318 <<< [g_PrintXML_Interface_ID] >>>
\r
319 ************************************************************************/
\r
321 extern const InterfaceID_Class g_PrintXML_Interface_ID;
\r
323 typedef errnum_t (* PrintXML_FuncType )( void* self, FILE* OutputStream );
\r
326 /*[PrintXML_VTableClass]*/
\r
327 typedef struct _PrintXML_VTableClass PrintXML_VTableClass;
\r
328 struct _PrintXML_VTableClass {
\r
330 PrintXML_FuncType PrintXML;
\r
335 /***********************************************************************
\r
336 <<< [fopen_ccs] >>>
\r
337 ************************************************************************/
\r
338 #if defined(_UNICODE)
\r
339 #define fopen_ccs ",ccs=UNICODE"
\r
341 #define fopen_ccs "t"
\r
346 /***********************************************************************
\r
347 <<< [SizedStruct] >>>
\r
348 ************************************************************************/
\r
349 typedef struct _SizedStruct SizedStruct;
\r
350 struct _SizedStruct {
\r
351 size_t ThisStructSize;
\r
357 /***********************************************************************
\r
358 <<< [NameOnlyClass] >>>
\r
359 ************************************************************************/
\r
360 typedef struct _NameOnlyClass NameOnlyClass;
\r
361 struct _NameOnlyClass {
\r
363 const void* Delegate;
\r
367 /***********************************************************************
\r
368 <<< [NameAndNumClass] >>>
\r
369 ************************************************************************/
\r
370 typedef struct _NameAndNumClass NameAndNumClass; /* Like NameOnlyClass */
\r
371 struct _NameAndNumClass {
\r
378 /***********************************************************************
\r
379 <<< [inline] [SUPPORT_INLINE_C_FUNC] [NOT_USE_INLINE_MACRO] >>>
\r
380 ************************************************************************/
\r
381 #ifndef SUPPORT_INLINE_C_FUNC
\r
382 #define SUPPORT_INLINE_C_FUNC 1
\r
386 #if SUPPORT_INLINE_C_FUNC
\r
387 #define inline _inline /* inline is specified under C99 */
\r
392 #ifndef NOT_USE_INLINE_MACRO
\r
393 #define NOT_USE_INLINE_MACRO 0
\r
398 /**************************************************************************
\r
400 ***************************************************************************/
\r
401 int ttoi_ex( const TCHAR* string, bit_flags_fast32_t options );
\r
405 /***********************************************************************
\r
406 <<< [PointerType_plus] >>>
\r
407 ************************************************************************/
\r
408 inline void PointerType_plus( const void* in_out_Element, int PlusMinusByte )
\r
410 *(int8_t**) in_out_Element = *(int8_t**) in_out_Element + PlusMinusByte;
\r
415 /***********************************************************************
\r
416 <<< [PointerType_diff] >>>
\r
417 ************************************************************************/
\r
418 inline ptrdiff_t PointerType_diff( const void* PointerA, const void* PointerB )
\r
420 return (uintptr_t) PointerA - (uintptr_t) PointerB;
\r
425 /**************************************************************************
\r
426 <<< [JOIN_SYMBOL] >>>
\r
427 ***************************************************************************/
\r
428 #define JOIN_SYMBOL(x, y) JOIN_SYMBOL_AGAIN(x, y)
\r
429 #define JOIN_SYMBOL_AGAIN(x, y) x##y
\r
430 /* CERT secure coding standard PRE05-C */
\r
434 /**************************************************************************
\r
435 <<< [static_assert] >>>
\r
436 ***************************************************************************/
\r
437 #define static_assert( ConstantExpression, StringLiteral ) \
\r
438 __pragma(warning(push)) \
\r
439 __pragma(warning(disable:4127)) \
\r
440 do { typedef char JOIN_SYMBOL( AssertionFailed_, __LINE__ )[(ConstantExpression) ? 1 : -1]; } while(0) \
\r
441 __pragma(warning(pop))
\r
443 #define static_assert_global( ConstantExpression, StringLiteral ) \
\r
444 __pragma(warning(push)) \
\r
445 __pragma(warning(disable:4127)) \
\r
446 typedef char JOIN_SYMBOL( AssertionFailed_, __LINE__ )[(ConstantExpression) ? 1 : -1] \
\r
447 __pragma(warning(pop))
\r
449 /* CERT secure coding standard DCL03-C */
\r
450 /* If "ConstantExpression" is false, illegal array size error will be raised. */
\r
455 } /* End of C Symbol */
\r
458 /*=================================================================*/
\r
459 /* <<< [Error4_Inline/Error4_Inline.h] >>> */
\r
460 /*=================================================================*/
\r
462 /***********************************************************************
\r
463 <<< [UNREFERENCED_VARIABLE] >>>
\r
464 <<< [UNREFERENCED_VARIABLE_2] >>>
\r
465 <<< [UNREFERENCED_VARIABLE_3] >>>
\r
466 <<< [UNREFERENCED_VARIABLE_4] >>>
\r
467 ************************************************************************/
\r
469 #define UNREFERENCED_VARIABLE( x )
\r
470 #define UNREFERENCED_VARIABLES( x )
\r
473 #define UNREFERENCED_VARIABLE( a1 ) UNREFERENCED_VARIABLE_Sub( &(a1) )
\r
474 #define UNREFERENCED_VARIABLE_2( a1,a2 ) UNREFERENCED_VARIABLE_2_Sub( &(a1), &(a2) )
\r
475 #define UNREFERENCED_VARIABLE_3( a1,a2,a3 ) UNREFERENCED_VARIABLE_3_Sub( &(a1), &(a2), &(a3) )
\r
476 #define UNREFERENCED_VARIABLE_4( a1,a2,a3,a4 ) UNREFERENCED_VARIABLE_4_Sub( &(a1), &(a2), &(a3), &(a4) )
\r
478 inline void UNREFERENCED_VARIABLE_Sub( const void* a1 ) { a1; }
\r
479 inline void UNREFERENCED_VARIABLE_2_Sub( const void* a1, const void* a2 ) { a1,a2; }
\r
480 inline void UNREFERENCED_VARIABLE_3_Sub( const void* a1, const void* a2, const void* a3 ) { a1,a2,a3; }
\r
481 inline void UNREFERENCED_VARIABLE_4_Sub( const void* a1, const void* a2, const void* a3, const void* a4 ) { a1,a2,a3,a4; }
\r
487 /*=================================================================*/
\r
488 /* <<< [Lock_1/Lock_1.h] >>> */
\r
489 /*=================================================================*/
\r
491 /***********************************************************************
\r
492 <<< [SingletonInitializerClass] >>>
\r
493 ************************************************************************/
\r
495 volatile LONG InitializeStep;
\r
496 } SingletonInitializerClass;
\r
498 #ifndef SingletonInitializerClass_FailSleepTime
\r
500 #define SingletonInitializerClass_FailSleepTime 60000
\r
502 #define SingletonInitializerClass_FailSleepTime 0
\r
506 bool SingletonInitializerClass_isFirst( SingletonInitializerClass* self );
\r
507 void SingletonInitializerClass_onFinishedInitialize( SingletonInitializerClass* self, int e );
\r
508 bool SingletonInitializerClass_isInitialized( SingletonInitializerClass* self );
\r
512 /*=================================================================*/
\r
513 /* <<< [Print/Print2.h] >>> */
\r
514 /*=================================================================*/
\r
517 extern "C" { /* Start of C Symbol */
\r
520 /***********************************************************************
\r
521 <<< [USE_printf_to] >>>
\r
522 ************************************************************************/
\r
523 #define USE_printf_to_stdout 1
\r
524 #define USE_printf_to_debugger 2
\r
525 #define USE_printf_to_file 3
\r
529 /***********************************************************************
\r
530 <<< [PrintfCounterClass] >>>
\r
531 ************************************************************************/
\r
532 #if USE_PRINTF_COUNTER
\r
534 typedef struct _PrintfCounterClass PrintfCounterClass;
\r
535 struct _PrintfCounterClass {
\r
540 extern PrintfCounterClass g_PrintfCounter;
\r
546 errnum_t vsprintf_r( char* s, size_t s_size, const char* format, va_list va );
\r
548 errnum_t vswprintf_r( wchar_t* s, size_t s_size, const wchar_t* format, va_list va );
\r
551 #if defined(_UNICODE)
\r
552 #define vstprintf_r vswprintf_r
\r
554 #define vstprintf_r vsprintf_r
\r
557 errnum_t stprintf_r( TCHAR* s, size_t s_size, const TCHAR* format, ... );
\r
559 errnum_t stcpy_part_r( TCHAR* s, size_t s_size, TCHAR* s_start, TCHAR** p_s_last,
\r
560 const TCHAR* src, const TCHAR* src_over );
\r
561 errnum_t stprintf_part_r( TCHAR* s, size_t s_size, TCHAR* s_start, TCHAR** p_s_last,
\r
562 const TCHAR* format, ... );
\r
564 errnum_t ftcopy_part_r( FILE* OutputStream, const TCHAR* Str, const TCHAR* StrOver );
\r
566 errnum_t OpenConsole( bool in_OpenIfNoConsole, bool* out_IsExistOrNewConsole );
\r
570 } /* End of C Symbol */
\r
574 /*=================================================================*/
\r
575 /* <<< [StrT_typedef/StrT_typedef.h] >>> */
\r
576 /*=================================================================*/
\r
578 /***********************************************************************
\r
579 <<< [NewStringsEnum] >>>
\r
580 ************************************************************************/
\r
581 typedef enum _NewStringsEnum NewStringsEnum;
\r
582 enum _NewStringsEnum {
\r
583 NewStringsEnum_NewPointersAndLinkCharacters = 0x06,
\r
584 NewStringsEnum_NewPointersAndNewCharacters = 0x03,
\r
585 NewStringsEnum_LinkCharacters = 0x04,
\r
586 NewStringsEnum_NewPointers = 0x02,
\r
587 NewStringsEnum_NewCharacters = 0x01,
\r
588 NewStringsEnum_NoAllocate = 0x00
\r
593 /*=================================================================*/
\r
594 /* <<< [SetX/SetX.h] >>> */
\r
595 /*=================================================================*/
\r
601 extern "C" { /* Start of C Symbol */
\r
605 /******************************************************************
\r
606 <<< Set4_typedef >>>
\r
607 *******************************************************************/
\r
609 typedef struct _Set4 Set4;
\r
610 typedef struct _Set4Iter Set4Iter;
\r
612 typedef int (*FuncType_create_in_set4)( void** pm, Set4* Set );
\r
614 /***********************************************************************
\r
616 ************************************************************************/
\r
617 typedef struct _Set2 Set2;
\r
624 void** PointerOfDebugArray; /* void<type> */
\r
628 //[Set2_IteratorClass]
\r
629 typedef struct _Set2_IteratorClass Set2_IteratorClass;
\r
630 struct _Set2_IteratorClass {
\r
636 #define Set2_initConst( m ) ( (m)->First = NULL, (m)->Next = NULL )
\r
637 errnum_t Set2_init( Set2* m, int FirstSize );
\r
638 errnum_t Set2_finish( Set2* m, errnum_t e );
\r
639 #define Set2_isInited( m ) ( (m)->First != NULL )
\r
641 #define Set2_allocate( m, pp ) \
\r
642 Set2_alloc_imp( m, (void*)(pp), sizeof(**(pp)) )
\r
644 #define Set2_alloc( m, pp, type ) \
\r
645 Set2_alloc_imp( m, (void*)(pp), sizeof(type) )
\r
647 errnum_t Set2_alloc_imp( Set2* m, void* pm, size_t size );
\r
649 #define Set2_push( m, pp, type ) \
\r
650 Set2_alloc_imp( m, (void*)(pp), sizeof(type) )
\r
652 #define Set2_pop( m, pp, type ) \
\r
653 Set2_pop_imp( m, (void*)(pp), sizeof(type) )
\r
655 errnum_t Set2_pop_imp( Set2* m, void* pp, size_t size );
\r
657 #define Set2_free( m, pp, e ) \
\r
658 Set2_free_imp( m, pp, sizeof(**(pp)), e )
\r
659 errnum_t Set2_free_imp( Set2* self, void* in_PointerOfPointer, size_t in_Size_ofElement, errnum_t e );
\r
661 #define Set2_freeLast( m, p, type, e ) \
\r
662 ( ((char*)(m)->Next - sizeof(type) == (char*)(p)) ? \
\r
663 (m)->Next = (p), (e) : \
\r
664 ((e)?(e):E_OTHERS) )
\r
666 #define Set2_toEmpty( m ) \
\r
667 ( (m)->Next = (m)->First, 0 )
\r
669 #define Set2_expandIfOverByAddr( m, OverAddrBasedOnNowFirst ) \
\r
670 ( (void*)(OverAddrBasedOnNowFirst) <= (m)->Over ? 0 : \
\r
671 Set2_expandIfOverByAddr_imp( m, OverAddrBasedOnNowFirst ) )
\r
673 #define Set2_expandIfOverByOffset( m, Size ) \
\r
674 Set2_expandIfOverByAddr( m, (char*)(m)->First + (Size) )
\r
675 errnum_t Set2_expandIfOverByAddr_imp( Set2* m, void* OverAddrBasedOnNowFirst );
\r
677 #define Set2_allocMulti( m, out_pElem, ElemType, nElem ) \
\r
678 Set2_allocMulti_sub( m, (void*)(out_pElem), sizeof(ElemType) * (nElem) )
\r
679 errnum_t Set2_allocMulti_sub( Set2* m, void* out_pElem, size_t ElemsSize );
\r
681 #define Set2_forEach( self, Item, Item_Over, Type ) \
\r
682 *(Item) = (Type*)( (self)->First ), *(Item_Over) = (Type*)( (self)->Next ); \
\r
683 *(Item) < *(Item_Over); \
\r
686 errnum_t Set2_getIterator( Set2* self, Set2_IteratorClass* out_Iterator, int ElementSize );
\r
687 errnum_t Set2_getDescendingIterator( Set2* self, Set2_IteratorClass* out_Iterator, int ElementSize );
\r
688 void* Set2_IteratorClass_getNext( Set2_IteratorClass* self );
\r
689 void* Set2_IteratorClass_getPrevious( Set2_IteratorClass* self );
\r
693 #define Set2_forEach2( self, Iterator, out_Element ) \
\r
694 Set2_forEach2_1( self, Iterator, out_Element, sizeof(**(out_Element)) ); \
\r
695 Set2_forEach2_2( self, Iterator, out_Element ); \
\r
696 Set2_forEach2_3( self, Iterator, out_Element )
\r
698 inline void Set2_forEach2_1( Set2* self, Set2_IteratorClass* Iterator, void* out_Element,
\r
699 size_t ElementSize )
\r
701 Set2_getIterator( self, Iterator, ElementSize );
\r
702 *(void**) out_Element = Set2_IteratorClass_getNext( Iterator );
\r
705 inline bool Set2_forEach2_2( Set2* self, Set2_IteratorClass* Iterator, void* out_Element )
\r
707 UNREFERENCED_VARIABLE_2( self, Iterator );
\r
708 return ( *(void**) out_Element != NULL );
\r
711 inline void Set2_forEach2_3( Set2* self, Set2_IteratorClass* Iterator, void* out_Element )
\r
713 UNREFERENCED_VARIABLE( self );
\r
714 *(void**) out_Element = Set2_IteratorClass_getNext( Iterator );
\r
718 #define Set2_getArray( self, out_Array, out_Count ) \
\r
719 ( ( *(void**)(out_Array) = (self)->First, \
\r
720 *(out_Count) = ( (byte_t*) (self)->Next - (byte_t*) (self)->First ) / sizeof(**(out_Array))), 0 )
\r
722 #define Set2_refer( m, iElem, out_pElem ) \
\r
723 Set2_ref_imp( m, iElem, out_pElem, sizeof(**(out_pElem)) )
\r
725 #define Set2_ref( m, iElem, out_pElem, ElemType ) \
\r
726 Set2_ref_imp( m, iElem, out_pElem, sizeof(ElemType) )
\r
728 errnum_t Set2_ref_imp( Set2* m, int iElem, void* out_pElem, size_t ElemSize );
\r
730 #define Set2_isEmpty( m ) \
\r
731 ( (m)->Next == (m)->First )
\r
733 #define Set2_getCount( m, Type ) \
\r
734 ( ( (byte_t*)(m)->Next - (byte_t*)(m)->First ) / sizeof(Type) )
\r
736 #define Set2_getCountMax( m, Type ) \
\r
737 ( ( (byte_t*)(m)->Over - (byte_t*)(m)->First ) / sizeof(Type) )
\r
739 #define Set2_checkPtrInArr( m, p ) \
\r
740 ( (m)->First <= (p) && (p) < (m)->Over ? 0 : E_NOT_FOUND_SYMBOL )
\r
742 errnum_t Set2_separate( Set2* m, int NextSize, void** allocate_Array );
\r
745 void Set2_setDebug( Set2* m, void* PointerOfDebugArray );
\r
749 /***********************************************************************
\r
751 ************************************************************************/
\r
752 typedef struct _Set2 Set2a;
\r
754 void Set2a_initConst( Set2a* m, void* ArrInStack );
\r
755 int Set2a_init( Set2a* m, void* ArrInStack, size_t ArrInStack_Size );
\r
756 int Set2a_finish( Set2a* m, void* ArrInStack, int e );
\r
757 int Set2a_toEmpty( Set2a* m );
\r
758 //int Set2a_alloc( Set2a* m, void* ArrInStack, ClassA** out_p, Type ClassA );
\r
759 int Set2a_expandIfOverByAddr( Set2a* m, void* OverAddrBasedOnNowFirst );
\r
765 #define Set2a_initConst( m, ArrInStack ) \
\r
766 ( (m)->First = (ArrInStack) )
\r
768 #define Set2a_finish( m, ArrInStack, e ) \
\r
769 ( (m)->First == (ArrInStack) ? (e) : ( free( (m)->First ), (e) ) )
\r
771 #define Set2a_toEmpty( m ) \
\r
774 #define Set2a_alloc( m, ArrInStack, out_Pointer, ClassA ) \
\r
775 ( (void*)( (ClassA*)((m)->Next) + 1 ) <= (m)->Over ? \
\r
776 ( *(out_Pointer) = (ClassA*)(m)->Next, (m)->Next = (ClassA*)((m)->Next) + 1, 0 ) : \
\r
777 Set2a_alloc_imp( m, ArrInStack, out_Pointer, sizeof(ClassA) ) )
\r
779 int Set2a_alloc_imp( Set2a* m, void* ArrInStack, void* out_Pointer, size_t ElemSize );
\r
781 #define Set2a_expandIfOverByAddr( m, ArrInStack, OverAddrBasedOnNowFirst ) \
\r
782 ( (void*)(OverAddrBasedOnNowFirst) <= (m)->Over ? 0 : \
\r
783 Set2a_expandIfOverByAddr_imp( m, ArrInStack, OverAddrBasedOnNowFirst ) )
\r
785 int Set2a_expandIfOverByAddr_imp( Set2a* m, void* ArrInStack, void* OverAddrBasedOnNowFirst );
\r
789 /******************************************************************
\r
791 *******************************************************************/
\r
793 byte_t* FirstBlock;
\r
794 byte_t* CurrentBlockFirst;
\r
795 byte_t* CurrentBlockNext;
\r
797 byte_t* CurrentBlockOver;
\r
798 byte_t** NextBlock;
\r
801 size_t ElementSize;
\r
809 /* errnum_t Set4_init( Set4* self, Type, int FirstHeapSize ); */
\r
810 /* errnum_t Set4_allocate( Set4* self, Type** out_ElementPointer ); */
\r
811 /* errnum_t Set4_free( Set4* self, Type** in_out_ElementPointer ); */
\r
812 /* Type* Set4_ref( Set4* self, int i, Type ); */
\r
816 errnum_t Set4_init_imp( Set4* self, size_t in_ElementSize, size_t FirstHeapSize );
\r
817 errnum_t Set4_finish2_imp2( Set4* self );
\r
818 errnum_t Set4_finish2_imp( Set4* self, errnum_t e, size_t in_ElementSize, FinalizeFuncType in_Type_Finalize );
\r
819 errnum_t Set4_alloc_imp( Set4* self, void* out_ElementPointer, size_t in_ElementSize );
\r
820 errnum_t Set4_free_imp( Set4* self, void* in_out_ElementPointer, size_t in_ElementSize, errnum_t e );
\r
821 void* Set4_ref_imp( Set4* self, int i, int size );
\r
822 int Set4_getCount_imp( Set4* self, int size );
\r
823 void Set4_forEach_imp2( Set4* self, Set4Iter* p, int size );
\r
827 /**************************************************************************
\r
828 <<< [ListClass] Linked List >>>
\r
829 ***************************************************************************/
\r
830 typedef struct _ListClass ListClass;
\r
831 typedef struct _ListElementClass ListElementClass;
\r
832 typedef struct _ListIteratorClass ListIteratorClass;
\r
834 /*[ListElementClass]*/
\r
835 struct _ListElementClass { /* This struct can be menbers of Data */
\r
836 void* Data; /* Element Data */
\r
837 ListClass* List; /* NULL = Not in a list */
\r
838 ListElementClass* Next;
\r
839 ListElementClass* Previous;
\r
842 struct _ListClass {
\r
843 void* Data; /* List owner. ListClass does not set this */
\r
844 ListElementClass Terminator;
\r
848 /*[ListIteratorClass]*/
\r
849 struct _ListIteratorClass {
\r
850 ListElementClass* Element;
\r
851 ListElementClass ModifiedElement;
\r
854 void ListClass_initConst( ListClass* self );
\r
855 inline errnum_t ListClass_add( ListClass* self, ListElementClass* Element ); /* addFirst */
\r
856 errnum_t ListClass_addAtIndex( ListClass* self, int Index, ListElementClass* Element );
\r
857 inline errnum_t ListClass_addFirst( ListClass* self, ListElementClass* Element );
\r
858 inline errnum_t ListClass_addLast( ListClass* self, ListElementClass* Element );
\r
859 inline int ListClass_getCount( ListClass* self );
\r
860 inline errnum_t ListClass_getData( ListClass* self, int Index, void* out_Data );
\r
861 errnum_t ListClass_get( ListClass* self, int Index, ListElementClass** out_Element );
\r
862 errnum_t ListClass_set( ListClass* self, int Index, ListElementClass* Element );
\r
863 errnum_t ListClass_replace( ListClass* self, ListElementClass* RemovingElement, ListElementClass* AddingElement );
\r
864 inline errnum_t ListClass_getFirstData( ListClass* self, void* out_Data );
\r
865 inline errnum_t ListClass_getLastData( ListClass* self, void* out_Data );
\r
866 inline errnum_t ListClass_getFirst( ListClass* self, ListElementClass** out_Element );
\r
867 inline errnum_t ListClass_getLast( ListClass* self, ListElementClass** out_Element );
\r
868 int ListClass_getIndexOfData( ListClass* self, void* Data );
\r
869 int ListClass_getIndexOf( ListClass* self, ListElementClass* Element );
\r
870 int ListClass_getLastIndexOfData( ListClass* self, void* Data );
\r
871 errnum_t ListClass_getArray( ListClass* self, void* DataArray, size_t DataArraySize );
\r
872 errnum_t ListClass_removeByIndex( ListClass* self, int Index );
\r
873 errnum_t ListClass_remove( ListClass* self, ListElementClass* Element );
\r
874 inline errnum_t ListClass_removeFirst( ListClass* self );
\r
875 inline errnum_t ListClass_removeLast( ListClass* self );
\r
876 errnum_t ListClass_clear( ListClass* self );
\r
877 inline errnum_t ListClass_push( ListClass* self, ListElementClass* Element );
\r
878 inline void* ListClass_popData( ListClass* self );
\r
879 inline ListElementClass* ListClass_pop( ListClass* self );
\r
880 inline errnum_t ListClass_enqueue( ListClass* self, ListElementClass* Element );
\r
881 inline void* ListClass_dequeueData( ListClass* self );
\r
882 inline ListElementClass* ListClass_dequeue( ListClass* self );
\r
883 inline errnum_t ListClass_getListIterator( ListClass* self, ListIteratorClass* out_Iterator );
\r
884 inline errnum_t ListClass_getDescendingListIterator( ListClass* self, ListIteratorClass* out_Iterator );
\r
886 inline void ListElementClass_initConst( ListElementClass* self, void* Data );
\r
888 void* ListIteratorClass_getNext( ListIteratorClass* self );
\r
889 void* ListIteratorClass_getPrevious( ListIteratorClass* self );
\r
890 errnum_t ListIteratorClass_replace( ListIteratorClass* self, ListElementClass* AddingElement );
\r
891 errnum_t ListIteratorClass_remove( ListIteratorClass* self );
\r
895 /* Implements of ListClass */
\r
896 errnum_t ListClass_addAt_Sub( ListElementClass* AddingElement, ListElementClass* Target );
\r
899 /*[ListClass_add]*/
\r
900 inline errnum_t ListClass_add( ListClass* self, ListElementClass* Element )
\r
902 return ListClass_addFirst( self, Element );
\r
906 /*[ListClass_addFirst]*/
\r
907 inline errnum_t ListClass_addFirst( ListClass* self, ListElementClass* Element )
\r
909 return ListClass_addAt_Sub( Element, self->Terminator.Next );
\r
913 /*[ListClass_addLast]*/
\r
914 inline errnum_t ListClass_addLast( ListClass* self, ListElementClass* Element )
\r
916 return ListClass_addAt_Sub( Element, &self->Terminator );
\r
920 /*[ListClass_getCount]*/
\r
921 inline int ListClass_getCount( ListClass* self )
\r
923 return self->Count;
\r
927 /*[ListClass_getData]*/
\r
928 inline errnum_t ListClass_getData( ListClass* self, int Index, void* out_Data )
\r
931 ListElementClass* target;
\r
933 e= ListClass_get( self, Index, &target );
\r
935 { *(void**) out_Data = target->Data; }
\r
940 /*[ListClass_getFirstData]*/
\r
941 inline errnum_t ListClass_getFirstData( ListClass* self, void* out_Data )
\r
943 if ( self->Count == 0 ) {
\r
944 return E_NOT_FOUND_SYMBOL;
\r
947 *(void**) out_Data = self->Terminator.Next->Data;
\r
953 /*[ListClass_getLastData]*/
\r
954 inline errnum_t ListClass_getLastData( ListClass* self, void* out_Data )
\r
956 if ( self->Count == 0 ) {
\r
957 return E_NOT_FOUND_SYMBOL;
\r
960 *(void**) out_Data = self->Terminator.Previous->Data;
\r
966 /*[ListClass_getFirst]*/
\r
967 inline errnum_t ListClass_getFirst( ListClass* self, ListElementClass** out_Element )
\r
969 if ( self->Count == 0 ) {
\r
970 return E_NOT_FOUND_SYMBOL;
\r
973 *out_Element = self->Terminator.Next;
\r
979 /*[ListClass_getLast]*/
\r
980 inline errnum_t ListClass_getLast( ListClass* self, ListElementClass** out_Element )
\r
982 if ( self->Count == 0 ) {
\r
983 return E_NOT_FOUND_SYMBOL;
\r
986 *out_Element = self->Terminator.Previous;
\r
992 /*[ListClass_isExistData]*/
\r
993 inline bool ListClass_isExistData( ListClass* self, void* Data )
\r
995 return ( ListClass_getIndexOfData( self, Data ) != INVALID_ARRAY_INDEX );
\r
999 /*[ListClass_removeFirst]*/
\r
1000 inline errnum_t ListClass_removeFirst( ListClass* self )
\r
1002 if ( self->Count == 0 ) {
\r
1003 return E_NOT_FOUND_SYMBOL;
\r
1006 return ListClass_remove( self, self->Terminator.Next );
\r
1011 /*[ListClass_removeLast]*/
\r
1012 inline errnum_t ListClass_removeLast( ListClass* self )
\r
1014 if ( self->Count == 0 ) {
\r
1015 return E_NOT_FOUND_SYMBOL;
\r
1018 return ListClass_remove( self, self->Terminator.Previous );
\r
1023 /*[ListClass_push]*/
\r
1024 inline errnum_t ListClass_push( ListClass* self, ListElementClass* Element )
\r
1026 return ListClass_addFirst( self, Element );
\r
1030 /*[ListClass_popData]*/
\r
1031 inline void* ListClass_popData( ListClass* self )
\r
1033 if ( self->Count == 0 ) {
\r
1037 ListElementClass* element = self->Terminator.Next;
\r
1039 ListClass_remove( self, element );
\r
1040 return element->Data;
\r
1045 /*[ListClass_pop]*/
\r
1046 inline ListElementClass* ListClass_pop( ListClass* self )
\r
1048 if ( self->Count == 0 ) {
\r
1052 ListElementClass* element = self->Terminator.Next;
\r
1054 ListClass_remove( self, element );
\r
1060 /*[ListClass_enqueue]*/
\r
1061 inline errnum_t ListClass_enqueue( ListClass* self, ListElementClass* Element )
\r
1063 return ListClass_addLast( self, Element );
\r
1067 /*[ListClass_dequeueData]*/
\r
1068 inline void* ListClass_dequeueData( ListClass* self )
\r
1070 return ListClass_popData( self );
\r
1074 /*[ListClass_dequeue]*/
\r
1075 inline ListElementClass* ListClass_dequeue( ListClass* self )
\r
1077 return ListClass_pop( self );
\r
1081 /*[ListClass_getListIterator]*/
\r
1082 inline errnum_t ListClass_getListIterator( ListClass* self, ListIteratorClass* out_Iterator )
\r
1084 out_Iterator->Element = &self->Terminator;
\r
1085 out_Iterator->ModifiedElement.List = NULL;
\r
1090 /*[ListClass_getDescendingListIterator]*/
\r
1091 inline errnum_t ListClass_getDescendingListIterator( ListClass* self, ListIteratorClass* out_Iterator )
\r
1093 out_Iterator->Element = &self->Terminator;
\r
1094 out_Iterator->ModifiedElement.List = NULL;
\r
1099 /*[ListElementClass_initConst]*/
\r
1100 inline void ListElementClass_initConst( ListElementClass* self, void* Data )
\r
1102 self->Data = Data;
\r
1103 self->List = NULL;
\r
1106 self->Next = NULL;
\r
1107 self->Previous = NULL;
\r
1113 /***********************************************************************
\r
1114 <<< [ListClass_forEach] >>>
\r
1115 ************************************************************************/
\r
1116 #define ListClass_forEach( self, iterator, out_Element ) \
\r
1117 ListClass_forEach_1( self, iterator, out_Element ); \
\r
1118 ListClass_forEach_2( self, iterator, out_Element ); \
\r
1119 ListClass_forEach_3( self, iterator, out_Element )
\r
1122 inline void ListClass_forEach_1( ListClass* self, ListIteratorClass* iterator, void* out_Element )
\r
1124 ListClass_getListIterator( self, iterator );
\r
1125 *(void**) out_Element = ListIteratorClass_getNext( iterator );
\r
1129 inline bool ListClass_forEach_2( ListClass* self, ListIteratorClass* iterator, void* out_Element )
\r
1131 UNREFERENCED_VARIABLE_2( self, iterator );
\r
1132 return ( *(void**) out_Element != NULL );
\r
1136 inline void ListClass_forEach_3( ListClass* self, ListIteratorClass* iterator, void* out_Element )
\r
1138 UNREFERENCED_VARIABLE( self );
\r
1139 *(void**) out_Element = ListIteratorClass_getNext( iterator );
\r
1144 /**************************************************************************
\r
1145 <<< [ListClass:ClassID] >>>
\r
1146 ***************************************************************************/
\r
1147 errnum_t ListClass_finalizeWithVTable( ListClass* self, bool IsFreeElements, errnum_t e );
\r
1148 errnum_t ListClass_printXML( ListClass* self, FILE* OutputStream );
\r
1152 /***********************************************************************
\r
1153 <<< [Variant_SuperClass] >>>
\r
1154 ************************************************************************/
\r
1156 typedef struct _VariantClass VariantClass;
\r
1158 typedef struct _Variant_SuperClass Variant_SuperClass;
\r
1159 struct _Variant_SuperClass {
\r
1161 /* <Inherit parent="ClassID_SuperClass"> */
\r
1162 const ClassID_Class* ClassID;
\r
1165 FinalizerVTableClass* FinalizerVTable;
\r
1166 VariantClass* StaticAddress;
\r
1169 extern const ClassID_Class g_Variant_SuperClass_ID;
\r
1170 errnum_t Variant_SuperClass_initialize( Variant_SuperClass* self, void* Parameter );
\r
1171 errnum_t Variant_SuperClass_overwrite( Variant_SuperClass* self,
\r
1172 Variant_SuperClass* AddingElement );
\r
1176 /***********************************************************************
\r
1177 <<< [VariantClass] >>>
\r
1178 - VariantClass* == Variant_SuperClass**
\r
1179 ************************************************************************/
\r
1180 typedef struct _VariantClass VariantClass;
\r
1182 struct _VariantClass {
\r
1183 Variant_SuperClass* Object;
\r
1184 ListElementClass ListElement;
\r
1189 /***********************************************************************
\r
1190 <<< [VariantListClass] >>>
\r
1191 ************************************************************************/
\r
1192 typedef struct _VariantListIteratorClass VariantListIteratorClass;
\r
1193 typedef struct _Variant_SuperClass Variant_SuperClass;
\r
1194 typedef struct _VariantListIteratorClass VariantListIteratorClass;
\r
1196 typedef struct _VariantListClass VariantListClass;
\r
1197 struct _VariantListClass {
\r
1198 ListClass /*<VariantClass>*/ List;
\r
1201 void VariantListClass_initConst( VariantListClass* self );
\r
1202 /* VariantListClass_initialize is not exist */
\r
1203 errnum_t VariantListClass_finalize( VariantListClass* self, errnum_t e );
\r
1205 errnum_t VariantListClass_createElement( VariantListClass* self,
\r
1206 void* /*<Variant_SuperClass**>*/ out_ElementObject,
\r
1207 const ClassID_Class* ClassID, void* Parameter );
\r
1209 errnum_t VariantListClass_destroyElement( VariantListClass* self,
\r
1210 void* /*<Variant_SuperClass**>*/ in_out_ElementObject, errnum_t e );
\r
1212 errnum_t VariantListClass_getListIterator( VariantListClass* self,
\r
1213 VariantListIteratorClass* out_Iterator );
\r
1217 /***********************************************************************
\r
1218 <<< [VariantListIteratorClass] >>>
\r
1219 ************************************************************************/
\r
1220 typedef struct _VariantListIteratorClass VariantListIteratorClass;
\r
1221 struct _VariantListIteratorClass {
\r
1222 ListIteratorClass Iterator;
\r
1224 Variant_SuperClass* VariantListIteratorClass_getNext( VariantListIteratorClass* self );
\r
1227 /*[VariantListClass_getListIterator]*/
\r
1228 inline errnum_t VariantListClass_getListIterator( VariantListClass* self,
\r
1229 VariantListIteratorClass* out_Iterator )
\r
1231 return ListClass_getListIterator( &self->List, &out_Iterator->Iterator );
\r
1236 /***********************************************************************
\r
1237 <<< [VariantListClass_forEach] >>>
\r
1238 ************************************************************************/
\r
1239 #define VariantListClass_forEach( self, Iterator, out_Pointer ) \
\r
1240 VariantListClass_forEach_Sub1( self, Iterator, out_Pointer ); \
\r
1241 *(out_Pointer) != NULL; \
\r
1242 VariantListClass_forEach_Sub3( Iterator, out_Pointer )
\r
1244 inline void VariantListClass_forEach_Sub1( VariantListClass* self,
\r
1245 VariantListIteratorClass* Iterator, void* out_Pointer )
\r
1247 VariantListClass_getListIterator( self, Iterator );
\r
1248 *(void**) out_Pointer = VariantListIteratorClass_getNext( Iterator );
\r
1251 inline void VariantListClass_forEach_Sub3( \
\r
1252 VariantListIteratorClass* Iterator, void* out_Pointer )
\r
1254 *(void**) out_Pointer = VariantListIteratorClass_getNext( Iterator );
\r
1259 /***********************************************************************
\r
1261 ************************************************************************/
\r
1262 typedef errnum_t (* CompareFuncType )( const void* ppLeft, const void* ppRight, const void* Param,
\r
1263 int* out_Result );
\r
1265 int PArray_setFromArray( void* PointerArray, size_t PointerArraySize, void* out_ppRight,
\r
1266 void* SrcArray, size_t SrcArraySize, size_t SrcArrayElemSize );
\r
1270 errnum_t PArray_doShakerSort( const void* PointerArray, size_t PointerArraySize,
\r
1271 const void* ppLeft, const void* ppRight, CompareFuncType Compare, const void* Param );
\r
1275 errnum_t PArray_doBinarySearch( const void* PointerArray, size_t PointerArraySize,
\r
1276 const void* Key, CompareFuncType Compare, const void* Param,
\r
1277 int* out_FoundOrLeftIndex, int* out_CompareResult );
\r
1281 /***********************************************************************
\r
1282 <<< [DictionaryAA_Class] Dictionary using AA tree >>>
\r
1283 ************************************************************************/
\r
1284 typedef struct _DictionaryAA_Class DictionaryAA_Class;
\r
1285 typedef struct _DictionaryAA_NodeClass DictionaryAA_NodeClass;
\r
1287 struct _DictionaryAA_Class {
\r
1288 DictionaryAA_NodeClass* Root;
\r
1292 /*[DictionaryAA_TraverseFuncType]*/
\r
1293 typedef errnum_t (* DictionaryAA_TraverseFuncType )(
\r
1294 DictionaryAA_NodeClass* Node, void* UserParameter );
\r
1296 void DictionaryAA_Class_initConst( DictionaryAA_Class* self );
\r
1297 errnum_t DictionaryAA_Class_finalize( DictionaryAA_Class* self, errnum_t e );
\r
1298 errnum_t DictionaryAA_Class_finalize2( DictionaryAA_Class* self, errnum_t e,
\r
1299 bool in_IsFreeItem, FinalizeFuncType in_Type_Finalize );
\r
1300 /*errnum_t DictionaryAA_Class_freeAllKeysHeap( DictionaryAA_Class* self, errnum_t e );*/
\r
1302 errnum_t DictionaryAA_Class_insert( DictionaryAA_Class* self, const TCHAR* Key,
\r
1303 DictionaryAA_NodeClass** out_Node );
\r
1304 errnum_t DictionaryAA_Class_remove( DictionaryAA_Class* self, const TCHAR* Key );
\r
1305 errnum_t DictionaryAA_Class_search( DictionaryAA_Class* self, const TCHAR* Key,
\r
1306 DictionaryAA_NodeClass** out_Node );
\r
1307 bool DictionaryAA_Class_isExist( DictionaryAA_Class* self, const TCHAR* Key );
\r
1308 errnum_t DictionaryAA_Class_traverse( DictionaryAA_Class* self,
\r
1309 DictionaryAA_TraverseFuncType Function, void* UserParameter );
\r
1310 errnum_t DictionaryAA_Class_toEmpty( DictionaryAA_Class* self );
\r
1311 errnum_t DictionaryAA_Class_getArray( DictionaryAA_Class* self,
\r
1312 TCHAR*** in_out_Strings, int* in_out_StringCount, NewStringsEnum in_HowToAllocate );
\r
1313 errnum_t DictionaryAA_Class_print( DictionaryAA_Class* self, FILE* OutputStream );
\r
1316 /*[DictionaryAA_Class_forEach]*/
\r
1317 #define DictionaryAA_Class_forEach( in_out_Iterator, out_Node ) \
\r
1318 *(out_Node) = DictionaryAA_IteratorClass_getNext( in_out_Iterator ); \
\r
1319 *(out_Node) != NULL; \
\r
1320 *(out_Node) = DictionaryAA_IteratorClass_getNext( in_out_Iterator )
\r
1324 /***********************************************************************
\r
1325 <<< [DictionaryAA_NodeClass] >>>
\r
1326 ************************************************************************/
\r
1327 struct _DictionaryAA_NodeClass {
\r
1328 void* Item; /* User defined */
\r
1330 const TCHAR* Key; /* This is had by DictionaryAA_Class */
\r
1332 DictionaryAA_NodeClass* Left;
\r
1333 DictionaryAA_NodeClass* Right;
\r
1336 extern DictionaryAA_NodeClass g_DictionaryAA_NullNode;
\r
1340 /***********************************************************************
\r
1341 <<< [DictionaryAA_IteratorClass] >>>
\r
1342 ************************************************************************/
\r
1343 typedef struct _DictionaryAA_IteratorClass DictionaryAA_IteratorClass;
\r
1344 struct _DictionaryAA_IteratorClass {
\r
1345 Set2 /*<DictionaryAA_NodeClass*>*/ Nodes;
\r
1346 DictionaryAA_NodeClass** NextNode;
\r
1349 void DictionaryAA_IteratorClass_initConst( DictionaryAA_IteratorClass* self );
\r
1350 errnum_t DictionaryAA_IteratorClass_initialize( DictionaryAA_IteratorClass* self,
\r
1351 DictionaryAA_Class* Collection );
\r
1352 errnum_t DictionaryAA_IteratorClass_finalize( DictionaryAA_IteratorClass* self, errnum_t e );
\r
1354 DictionaryAA_NodeClass* DictionaryAA_IteratorClass_getNext(
\r
1355 DictionaryAA_IteratorClass* self );
\r
1358 /*[DictionaryAA_IteratorClass_initConst]*/
\r
1359 inline void DictionaryAA_IteratorClass_initConst( DictionaryAA_IteratorClass* self )
\r
1361 Set2_initConst( &self->Nodes );
\r
1365 /*[DictionaryAA_IteratorClass_finalize]*/
\r
1366 inline errnum_t DictionaryAA_IteratorClass_finalize( DictionaryAA_IteratorClass* self, errnum_t e )
\r
1368 return Set2_finish( &self->Nodes, e );
\r
1373 /*-------------------------------------------------------------------------*/
\r
1374 /* <<<< ### (Set4) Class >>>> */
\r
1375 /*-------------------------------------------------------------------------*/
\r
1379 /****************************************************************
\r
1380 <<< [Set4_initConst] >>>
\r
1381 *****************************************************************/
\r
1382 #define Set4_initConst( self ) \
\r
1383 ( (self)->FirstBlock = NULL )
\r
1386 /****************************************************************
\r
1387 <<< [Set4_init] >>>
\r
1388 *****************************************************************/
\r
1389 #define Set4_init( self, type, HeapSize ) \
\r
1390 Set4_init_imp( self, sizeof(type), HeapSize )
\r
1394 /****************************************************************
\r
1395 <<< [Set4_finish] >>>
\r
1396 *****************************************************************/
\r
1397 #define Set4_finish( self, e, type, in_Type_Finalize ) \
\r
1398 ( (in_Type_Finalize) == NULL ? Set4_finish2_imp2( self ), e : \
\r
1399 ( Set4_finish2_imp( self, e, sizeof(type), in_Type_Finalize ), Set4_finish2_imp2( self ), e ) )
\r
1403 /****************************************************************
\r
1404 <<< [Set4_allocate] >>>
\r
1405 *****************************************************************/
\r
1406 #define Set4_allocate( self, out_ElementPointer ) \
\r
1407 Set4_alloc_imp( self, out_ElementPointer, sizeof(**(out_ElementPointer)) )
\r
1411 /****************************************************************
\r
1412 <<< [Set4_alloc] >>>
\r
1413 *****************************************************************/
\r
1415 #define Set4_alloc( self, pp, type ) \
\r
1416 Set4_alloc_imp( self, pp, sizeof(type) )
\r
1421 /****************************************************************
\r
1422 <<< [Set4_free] >>>
\r
1423 *****************************************************************/
\r
1424 #define Set4_free( self, in_out_ElementPointer, e ) \
\r
1425 Set4_free_imp( self, in_out_ElementPointer, sizeof(**(in_out_ElementPointer)), e )
\r
1429 /****************************************************************
\r
1430 <<< [Set4_toEmpty] >>>
\r
1431 *****************************************************************/
\r
1432 #define Set4_toEmpty( self, type, type_finish ) \
\r
1433 ( Set4_finish2( self, type, type_finish ), \
\r
1434 (self)->FirstBlock = NULL, \
\r
1435 (self)->Next = (self)->CurrentBlockOver = &(self)->FirstBlock )
\r
1439 /****************************************************************
\r
1440 <<< [Set4_ref] >>>
\r
1441 *****************************************************************/
\r
1442 #define Set4_ref( self, i, type ) \
\r
1443 ( (type*) Set4_ref_imp( self, i, sizeof(type) ) )
\r
1447 /****************************************************************
\r
1448 <<< [Set4_getCount] >>>
\r
1449 *****************************************************************/
\r
1450 #define Set4_getCount( self, type ) \
\r
1451 Set4_getCount_imp( self, sizeof(type) )
\r
1454 #define Set4_getN( self, type ) \
\r
1455 Set4_getCount_imp( self, sizeof(type) )
\r
1460 /****************************************************************
\r
1461 <<< [Set4_forEach] >>>
\r
1462 *****************************************************************/
\r
1463 #define Set4_forEach( self, iter, ptr ) \
\r
1464 (iter)->p = NULL, Set4_forEach_imp2( self, iter, sizeof(**(ptr)) ); \
\r
1465 *(void**)(ptr) = (iter)->p, (iter)->p != NULL; \
\r
1466 Set4_forEach_imp2( self, iter, sizeof(**(ptr)) )
\r
1469 #define Set4_forEach( self, iter, ptr, type ) \
\r
1470 (iter)->p = NULL, Set4_forEach_imp2( self, iter, sizeof(type) ); \
\r
1471 *(ptr) = (type*)(iter)->p, (iter)->p != NULL; \
\r
1472 Set4_forEach_imp2( self, iter, sizeof(type) )
\r
1475 #define Set4_forEach_imp( self, ptr, size ) \
\r
1476 (ptr)->p = NULL, Set4_forEach_imp2( self, ptr, size ); \
\r
1477 (ptr)->p != NULL; \
\r
1478 Set4_forEach_imp2( self, ptr, size )
\r
1482 /****************************************************************
\r
1483 <<< [Set4Iter_init] >>>
\r
1484 *****************************************************************/
\r
1485 #define Set4Iter_init( self, Set, pptr, type ) \
\r
1486 ( (self)->p = NULL, Set4_forEach_imp2( Set, self, sizeof(type) ), \
\r
1487 *(pptr) = (type*)((self)->p), ( (self)->p == NULL ? E_NO_NEXT : 0 ) )
\r
1491 /****************************************************************
\r
1492 <<< [Set4Iter_next] >>>
\r
1493 *****************************************************************/
\r
1494 #define Set4Iter_next( self, Set, pptr, type ) \
\r
1495 ( Set4_forEach_imp2( Set, self, sizeof(type) ), \
\r
1496 *(pptr) = (type*)((self)->p), ( (self)->p == NULL ? E_NO_NEXT : 0 ) )
\r
1500 #ifdef __cplusplus
\r
1501 } /* End of C Symbol */
\r
1505 /*=================================================================*/
\r
1506 /* <<< [DebugTools/DebugTools.h] >>> */
\r
1507 /*=================================================================*/
\r
1510 extern "C" { /* Start of C Symbol */
\r
1515 #define NDEBUG_ERROR
\r
1517 #define NDEBUG_ERROR ___cut_NDEBUG_ERROR
\r
1521 /**************************************************************************
\r
1522 <<< [DebugTools] >>>
\r
1523 ***************************************************************************/
\r
1525 #define DEBUGTOOLS_USES 1
\r
1527 #define DEBUGTOOLS_USES 0
\r
1531 #if DEBUGTOOLS_USES
\r
1532 typedef struct _DebugTools DebugTools;
\r
1533 struct _DebugTools {
\r
1535 int m_DisableBreakExceptID_plus1;
\r
1536 int m_ReturnValueOnBreak_minus1;
\r
1537 TCHAR* m_BreakByFName;
\r
1539 int Debug_setReturnValueOnBreak( int ID );
\r
1540 int Debug_disableBreak( int iExceptID );
\r
1541 int Debug_setBreakByFName( const TCHAR* Path );
\r
1542 int Debug_onOpen( const TCHAR* Path );
\r
1546 /***********************************************************************
\r
1547 <<< [HeapLogClass] >>>
\r
1548 ************************************************************************/
\r
1549 void HeapLogClass_log( void* in_Address, size_t in_Size );
\r
1550 int HeapLogClass_getID( const void* in_Address );
\r
1551 void HeapLogClass_printID( const void* in_Address );
\r
1552 void HeapLogClass_addWatch( int in_IndexNum, int in_AllocatedID, ptrdiff_t in_Offset,
\r
1553 uint32_t in_BreakValue, bool in_IsPrintf );
\r
1554 void HeapLogClass_watch( int in_IndexNum );
\r
1555 void* HeapLogClass_getWatchingAddress( int in_IndexNum );
\r
1556 void HeapLogClass_finalize(void);
\r
1558 enum { HeapLogClass_NotAllocatedID = -1 };
\r
1562 /**************************************************************************
\r
1563 <<< [g_DebugVar] >>>
\r
1564 ***************************************************************************/
\r
1565 extern int g_DebugVar[10];
\r
1569 /*[dll_global_g_DebugBreakCount]*/
\r
1570 #ifndef dll_global_g_DebugBreakCount
\r
1571 #define dll_global_g_DebugBreakCount
\r
1574 /***********************************************************************
\r
1575 <<< [TestableDebugBreak] >>>
\r
1576 ************************************************************************/
\r
1577 #define TestableDebugBreak() ( TestableDebugBreak_Sub() ? (DebugBreakR(),0) : 0 )
\r
1578 int TestableDebugBreak_Sub(void);
\r
1580 void SetTestableDebugBreak( bool IsEnableBreak );
\r
1581 int GetDebugBreakCount(void);
\r
1586 } /* End of C Symbol */
\r
1591 /*=================================================================*/
\r
1592 /* <<< [StrT/StrT.h] >>> */
\r
1593 /*=================================================================*/
\r
1596 extern "C" { /* Start of C Symbol */
\r
1599 errnum_t StrT_cpy( TCHAR* Dst, size_t DstSize, const TCHAR* Src );
\r
1600 errnum_t StrT_cat( TCHAR* Dst, size_t DstSize, const TCHAR* Src );
\r
1601 TCHAR* StrT_chr( const TCHAR* String, TCHAR Key );
\r
1602 TCHAR* StrT_chrs( const TCHAR* s, const TCHAR* keys );
\r
1603 TCHAR* StrT_rstr( const TCHAR* String, const TCHAR* SearchStart, const TCHAR* Keyword,
\r
1604 void* NullConfig );
\r
1605 TCHAR* StrT_chrNext( const TCHAR* in_Start, TCHAR in_KeyCharactor );
\r
1606 TCHAR* StrT_skip( const TCHAR* s, const TCHAR* keys );
\r
1607 TCHAR* StrT_rskip( const TCHAR* String, const TCHAR* SearchStart, const TCHAR* Keys,
\r
1608 void* NullConfig );
\r
1609 bool StrT_isCIdentifier( TCHAR Character );
\r
1610 TCHAR* StrT_searchOverOfCIdentifier( const TCHAR* Text );
\r
1611 TCHAR* StrT_searchOverOfIdiom( const TCHAR* Text );
\r
1612 int StrT_cmp_part( const TCHAR* StringA_Start, const TCHAR* StringA_Over,
\r
1613 const TCHAR* StringB );
\r
1614 int StrT_cmp_i_part( const TCHAR* StringA_Start, const TCHAR* StringA_Over,
\r
1615 const TCHAR* StringB );
\r
1616 int StrT_cmp_part2( const TCHAR* StringA_Start, const TCHAR* StringA_Over,
\r
1617 const TCHAR* StringB_Start, const TCHAR* StringB_Over );
\r
1618 #define TwoChar8( Character1, Character2 ) \
\r
1619 ( (Character1) + ( (Character2) << 8 ) )
\r
1620 #define FourChar8( Character1, Character2, Character3, Character4 ) \
\r
1621 ( (Character1) + ( (Character2) << 8 ) + ( (Character3) << 16 ) + ( (Character4) << 24 ) )
\r
1623 inline errnum_t StrT_cat( TCHAR* Dst, size_t DstSize, const TCHAR* Src )
\r
1625 return stcpy_part_r( Dst, DstSize, _tcschr( Dst, _T('\0') ), NULL, Src, NULL );
\r
1630 int StrT_searchPartStringIndex( const TCHAR* in_String, const TCHAR* in_StringOver,
\r
1631 const TCHAR** in_StringsArray, uint_fast32_t in_StringsArrayLength,
\r
1632 int in_DefaultIndex );
\r
1634 int StrT_searchPartStringIndexI( const TCHAR* in_String, const TCHAR* in_StringOver,
\r
1635 const TCHAR** in_StringsArray, uint_fast32_t in_StringsArrayLength,
\r
1636 int in_DefaultIndex );
\r
1638 errnum_t StrT_convStrToId( const TCHAR* str, const TCHAR** strs, const int* ids, int n, int default_id );
\r
1639 errnum_t StrT_convStrLeftToId( const TCHAR* Str, const TCHAR** Strs, const size_t* Lens, const int* Ids,
\r
1640 int CountOfStrs, TCHAR* Separeters, int DefaultId, TCHAR** out_PosOfLastOfStr );
\r
1641 void* StrT_convPartStrToPointer( const TCHAR* StringStart, const TCHAR* StringOver,
\r
1642 const NameOnlyClass* Table, size_t TableSize, void* Default );
\r
1643 TCHAR* StrT_convertNumToStr( int Number, const NameAndNumClass* Table, int TableCount,
\r
1644 const TCHAR* DefaultStr );
\r
1646 //[GetStringSizeFromPointer]
\r
1647 inline size_t GetStringSizeFromPointer( void* String, size_t StringSize, void* Pointer )
\r
1649 return (uintptr_t) String + StringSize - (uintptr_t) Pointer;
\r
1653 /***********************************************************************
\r
1654 <<< [StrT_Malloc] >>>
\r
1655 ************************************************************************/
\r
1656 errnum_t MallocAndCopyString( const TCHAR** out_NewString, const TCHAR* SourceString );
\r
1657 errnum_t MallocAndCopyString_char( const TCHAR** out_NewString, const char* SourceString );
\r
1658 errnum_t MallocAndCopyStringByLength( const TCHAR** out_NewString, const TCHAR* SourceString,
\r
1659 unsigned CountOfCharacter );
\r
1662 #define MallocAndCopyString_char MallocAndCopyString
\r
1665 errnum_t StrHS_insert( TCHAR** in_out_WholeString,
\r
1666 int in_TargetIndexInWholeString, int* out_NextWholeInWholeString,
\r
1667 const TCHAR* in_InsertString );
\r
1668 errnum_t StrHS_printf( TCHAR** in_out_String, const TCHAR* in_Format, ... );
\r
1669 errnum_t StrHS_printfV( TCHAR** in_out_String, const TCHAR* in_Format, va_list in_VaList );
\r
1670 errnum_t StrHS_printfPart( TCHAR** in_out_String,
\r
1671 int in_IndexInString, int* out_NextIndexInString,
\r
1672 const TCHAR* in_Format, ... );
\r
1673 errnum_t StrHS_printfPartV( TCHAR** in_out_String,
\r
1674 int in_IndexInString, int* out_NextIndexInString,
\r
1675 const TCHAR* in_Format, va_list in_VaList );
\r
1679 /***********************************************************************
\r
1680 <<< [StrT_Edit] >>>
\r
1681 ************************************************************************/
\r
1682 errnum_t StrT_cutPart( TCHAR* in_out_String, TCHAR* in_StartOfCut, TCHAR* in_OverOfCut );
\r
1683 errnum_t StrT_trim( TCHAR* out_Str, size_t out_Str_Size, const TCHAR* in_Str );
\r
1684 errnum_t StrT_cutLastOf( TCHAR* in_out_Str, TCHAR Charactor );
\r
1685 errnum_t StrT_cutLineComment( TCHAR* out_Str, size_t out_Str_Size, const TCHAR* in_Str, const TCHAR* CommentSign );
\r
1686 errnum_t StrT_insert( TCHAR* in_out_WholeString, size_t in_MaxSize_of_WholeString,
\r
1687 TCHAR* in_out_Target_in_WholeString, TCHAR** out_NextTarget_in_WholeString,
\r
1688 const TCHAR* in_InsertString );
\r
1689 errnum_t StrT_meltCmdLine( TCHAR* out_Str, size_t out_Str_Size, const TCHAR** pLine );
\r
1690 errnum_t StrT_getExistSymbols( unsigned* out, bool bCase, const TCHAR* Str, const TCHAR* Symbols, ... );
\r
1691 errnum_t StrT_replace1( TCHAR* in_out_String, TCHAR FromCharacter, TCHAR ToCharacter,
\r
1696 /***********************************************************************
\r
1697 <<< [StrT_Edit2] >>>
\r
1698 ************************************************************************/
\r
1699 errnum_t StrT_replace( TCHAR* Out, size_t OutSize, const TCHAR* In,
\r
1700 const TCHAR* FromStr, const TCHAR* ToStr, unsigned Opt );
\r
1701 errnum_t StrT_changeToXML_Attribute( TCHAR* out_Str, size_t StrSize, const TCHAR* InputStr );
\r
1702 errnum_t StrT_resumeFromXML_Attribute( TCHAR* out_Str, size_t out_Str_Size, const TCHAR* XML_Attr );
\r
1703 errnum_t StrT_changeToXML_Text( TCHAR* out_Str, size_t StrSize, const TCHAR* InputStr );
\r
1705 enum { STR_1TIME = 1 };
\r
1709 /***********************************************************************
\r
1711 ************************************************************************/
\r
1712 enum { W3CDTF_MAX_LENGTH = 27+3 }; /*
\8f¬
\90\943
\8c\85 */
\r
1713 enum { W3CDTF_CURRENT_TIME_ZONE = 9999 };
\r
1715 errnum_t W3CDTF_fromSYSTEMTIME( TCHAR* out_W3CDTF, size_t W3CDTF_ByteSize,
\r
1716 const SYSTEMTIME* Time, int TimeZoneMinute );
\r
1717 errnum_t W3CDTF_toSYSTEMTIME( const TCHAR* String, SYSTEMTIME* out_Time, int* out_BiasMinute );
\r
1718 errnum_t W3CDTF_getTimeZoneDesignator( TCHAR* out_TZD, size_t TZD_ByteSize,
\r
1723 /***********************************************************************
\r
1724 <<< [StrT_Path] >>>
\r
1725 ************************************************************************/
\r
1726 enum { StrT_LocalPathMaxSize = 4096 };
\r
1727 enum { MAX_LOCAL_PATH = 4096 };
\r
1728 TCHAR* StrT_refFName( const TCHAR* s );
\r
1729 TCHAR* StrT_refExt( const TCHAR* s );
\r
1730 void StrT_cutFragmentInPath( TCHAR* in_out_Path );
\r
1731 bool StrT_isFullPath( const TCHAR* s );
\r
1733 errnum_t StrT_getFullPath_part( TCHAR* Str, size_t StrSize, TCHAR* StrStart,
\r
1734 TCHAR** out_StrLast, const TCHAR* StepPath, const TCHAR* BasePath );
\r
1735 errnum_t StrT_allocateFullPath( TCHAR** out_FullPath, const TCHAR* StepPath, TCHAR* BasePath );
\r
1736 errnum_t StrT_getStepPath( TCHAR* out_StepPath, size_t StepPathSize,
\r
1737 const TCHAR* FullPath, const TCHAR* BasePath );
\r
1738 errnum_t StrT_getParentFullPath_part( TCHAR* Str, size_t StrSize, TCHAR* StrStart,
\r
1739 TCHAR** out_StrLast, const TCHAR* StepPath, const TCHAR* BasePath );
\r
1740 errnum_t StrT_getBaseName_part( TCHAR* Str, size_t StrSize, TCHAR* StrStart,
\r
1741 TCHAR** out_StrLast, const TCHAR* SrcPath );
\r
1742 errnum_t StrT_addLastOfFileName( TCHAR* out_Path, size_t PathSize,
\r
1743 const TCHAR* BasePath, const TCHAR* AddName );
\r
1744 errnum_t StrT_encodeToValidPath( TCHAR* out_Path, size_t in_OutPathSize, const TCHAR* in_Path, bool in_IsName );
\r
1746 inline errnum_t StrT_getFullPath( TCHAR* out_FullPath, size_t FullPathSize,
\r
1747 const TCHAR* StepPath, const TCHAR* BasePath )
\r
1749 return StrT_getFullPath_part( out_FullPath, FullPathSize, out_FullPath,
\r
1750 NULL, StepPath, BasePath );
\r
1753 inline errnum_t StrT_getParentFullPath( TCHAR* Str, size_t StrSize,
\r
1754 const TCHAR* SrcPath, const TCHAR* BasePath )
\r
1756 return StrT_getParentFullPath_part( Str, StrSize, Str, NULL, SrcPath, BasePath );
\r
1759 inline errnum_t StrT_getBaseName( TCHAR* Str, size_t StrSize, const TCHAR* SrcPath )
\r
1761 return StrT_getBaseName_part( Str, StrSize, Str, NULL, SrcPath );
\r
1766 /**************************************************************************
\r
1768 ***************************************************************************/
\r
1769 typedef struct _Strs Strs;
\r
1771 byte_t* MemoryAddress; /* first memory = [ TCHAR* FirstStr | elem[] ], other memory = [ elem[] ] */
\r
1772 byte_t* MemoryOver;
\r
1773 byte_t* NextElem; /* elem = [ TCHAR* NextStr | TCHAR[] ] */
\r
1774 TCHAR** PointerToNextStrInPrevElem; /* first = &FirstStr, other = &NextStr */
\r
1775 TCHAR** Prev_PointerToNextStrInPrevElem;
\r
1777 Strs* FirstOfStrs;
\r
1781 void Strs_initConst( Strs* m );
\r
1782 errnum_t Strs_init( Strs* m );
\r
1783 errnum_t Strs_finish( Strs* m, errnum_t e );
\r
1784 errnum_t Strs_toEmpty( Strs* m );
\r
1785 bool Strs_isInited( Strs* m );
\r
1786 errnum_t Strs_add( Strs* m, const TCHAR* Str, const TCHAR** out_pAlloc );
\r
1787 errnum_t Strs_addBinary( Strs* m, const TCHAR* Str, const TCHAR* StrOver, const TCHAR** out_AllocStr );
\r
1788 errnum_t Strs_freeLast( Strs* m, TCHAR* AllocStr );
\r
1789 errnum_t Strs_toEmpty( Strs* m );
\r
1790 /* for ( Strs_forEach( Strs* m, TCHAR** in_out_Str ) ); */
\r
1791 TCHAR* Strx_getFirst( Strs* m );
\r
1792 TCHAR* Strx_getNext( Strs* m, TCHAR* Str );
\r
1795 #define Strs_initConst( m ) ( (m)->MemoryAddress = NULL )
\r
1796 #define Strs_isInited( m ) ( (m)->MemoryAddress != NULL )
\r
1798 #define Strs_forEach( m, pStr ) \
\r
1799 *(pStr) = Strs_getFirst( m ); \
\r
1800 *(pStr) != NULL; \
\r
1801 *(pStr) = Strs_getNext( m, *(pStr) )
\r
1803 #define Strs_getFirst( m ) \
\r
1804 ( *(TCHAR**) (m)->FirstOfStrs->MemoryAddress )
\r
1806 #define Strs_getNext( m, p ) \
\r
1807 ( *( (TCHAR**)(p) - 1 ) )
\r
1809 #define Strs_getFreeAddr( m ) ( (TCHAR*)( (m)->NextElem + sizeof(TCHAR*) ) )
\r
1810 #define Strs_getFreeSize( m ) ( (m)->MemoryOver - (byte_t*)(m)->NextElem - sizeof(TCHAR*) )
\r
1811 #define Strs_getFreeCount( m ) ( Strs_getFreeSize( m ) / sizeof(TCHAR) )
\r
1812 #define Strs_expandCount( m, c ) ( Strs_expandSize( (m), (c) * sizeof(TCHAR) ) )
\r
1813 errnum_t Strs_expandSize( Strs* m, size_t FreeSize );
\r
1814 errnum_t Strs_commit( Strs* m, TCHAR* StrOver );
\r
1815 errnum_t Strs_allocateArray( Strs* self, TCHAR*** out_PointerArray, int* out_Count );
\r
1819 /***********************************************************************
\r
1821 ************************************************************************/
\r
1822 typedef struct _StrArr StrArr;
\r
1824 Set2 Array; // array of TCHAR*
\r
1828 errnum_t StrArr_init( StrArr* m );
\r
1829 errnum_t StrArr_finish( StrArr* m, errnum_t e );
\r
1831 errnum_t StrArr_add( StrArr* m, const TCHAR* Str, int* out_I );
\r
1832 errnum_t StrArr_commit( StrArr* m );
\r
1833 errnum_t StrArr_fillTo( StrArr* m, int n, const TCHAR* Str );
\r
1834 errnum_t StrArr_toEmpty( StrArr* m );
\r
1836 #define StrArr_initConst( m ) Set2_initConst( &(m)->Array )
\r
1837 #define StrArr_getFreeAddr( m ) Strs_getFreeAddr( &(m)->Chars )
\r
1838 #define StrArr_getFreeSize( m ) Strs_getFreeSize( &(m)->Chars )
\r
1839 #define StrArr_getFreeCount( m ) Strs_getFreeCount( &(m)->Chars )
\r
1840 #define StrArr_expandSize( m, sz ) Strs_expandSize( &(m)->Chars, sz )
\r
1841 #define StrArr_expandCount( m, c ) Strs_expandCount( &(m)->Chars, c )
\r
1842 #define StrArr_getArray( m ) ((TCHAR**)(m)->Array.First)
\r
1843 //#define StrArr_getN( m ) Set2_getCount( &(m)->Array, TCHAR* )
\r
1844 #define StrArr_getCount( m ) Set2_getCount( &(m)->Array, TCHAR* )
\r
1848 /***********************************************************************
\r
1849 <<< [StrArr_forEach] >>>
\r
1850 ************************************************************************/
\r
1851 #define StrArr_forEach( self, Iterator, out_String ) \
\r
1852 StrArr_forEach_1( self, Iterator, out_String ); \
\r
1853 StrArr_forEach_2( Iterator ); \
\r
1854 StrArr_forEach_3( Iterator, out_String )
\r
1856 /*[StrArrIterator]*/
\r
1857 typedef struct _StrArrIterator StrArrIterator;
\r
1858 struct _StrArrIterator {
\r
1859 const TCHAR** Pointer;
\r
1860 const TCHAR** PointerOver;
\r
1863 inline void StrArr_forEach_1( StrArr* self, StrArrIterator* Iterator, const TCHAR** out_String )
\r
1865 Iterator->Pointer = (const TCHAR**) self->Array.First;
\r
1866 Iterator->PointerOver = (const TCHAR**) self->Array.Next;
\r
1867 *out_String = *Iterator->Pointer;
\r
1870 inline bool StrArr_forEach_2( StrArrIterator* Iterator )
\r
1872 return Iterator->Pointer < Iterator->PointerOver;
\r
1875 inline void StrArr_forEach_3( StrArrIterator* Iterator, const TCHAR** out_String )
\r
1877 Iterator->Pointer += 1;
\r
1878 *out_String = *Iterator->Pointer;
\r
1883 /***********************************************************************
\r
1885 ************************************************************************/
\r
1886 errnum_t StrT_meltCSV( TCHAR* out_Str, size_t out_Str_Size, const TCHAR** pCSV );
\r
1887 errnum_t StrArr_parseCSV( StrArr* m, const TCHAR* CSVLine );
\r
1888 errnum_t StrT_parseCSV_f( const TCHAR* StringOfCSV, bit_flags32_t* out_ReadFlags, const TCHAR* Types, ... );
\r
1892 /***********************************************************************
\r
1893 <<< [StrFile] Read Class >>>
\r
1894 ************************************************************************/
\r
1896 typedef struct _StrFile StrFile;
\r
1899 size_t BufferSize;
\r
1900 bool IsBufferInHeap;
\r
1902 int OffsetToHeapBlockFirst;
\r
1904 void* Pointer; // (void*)0xFFFFFFFF = EOF
\r
1907 #define StrFile StrFile_BlackBox
\r
1909 typedef struct _StrFile_BlackBox StrFile;
\r
1910 struct _StrFile_BlackBox {
\r
1911 uint8_t BlackBox[24];
\r
1915 static_assert_global( sizeof(StrFile) == sizeof(StrFile_BlackBox), "" );
\r
1918 STR_FILE_READ = 0,
\r
1920 STR_FILE_CHAR = 0x00,
\r
1921 STR_FILE_WCHAR = 0x10,
\r
1923 STR_FILE_TCHAR = 0x10,
\r
1925 STR_FILE_TCHAR = 0x00,
\r
1928 STR_FILE_TEXT = 0x00,
\r
1929 STR_FILE_BINARY = 0x01,
\r
1932 void StrFile_initConst( StrFile* self );
\r
1933 errnum_t StrFile_init_fromStr( StrFile* self, TCHAR* LinkStr );
\r
1934 errnum_t StrFile_init_fromSizedStructInStream( StrFile* self, HANDLE* Stream );
\r
1935 errnum_t StrFile_init_withBuf( StrFile* self, void* LinkBuffer, size_t LinkBufferSize, int Flags );
\r
1936 errnum_t StrFile_finish( StrFile* self, errnum_t e );
\r
1937 errnum_t StrFile_isInited( StrFile* self );
\r
1939 errnum_t StrFile_readLine( StrFile* self, TCHAR* out_Line, size_t LineSize );
\r
1940 bool StrFile_isAtEndOfStream( StrFile* self );
\r
1944 /***********************************************************************
\r
1945 <<< [StrFile] Write Class >>>
\r
1946 ************************************************************************/
\r
1948 errnum_t StrFile_init_toHeap( StrFile* self, int Flags );
\r
1949 errnum_t StrFile_write( StrFile* self, const TCHAR* Text );
\r
1950 errnum_t StrFile_writeBinary( StrFile* self, const void* Data, size_t DataSize );
\r
1951 errnum_t StrFile_expandIfOver( StrFile* self, size_t DataSize );
\r
1952 errnum_t StrFile_peekWrittenString( StrFile* self, TCHAR** out_String );
\r
1953 errnum_t StrFile_peekWrittenStringW( StrFile* self, wchar_t** out_String );
\r
1954 errnum_t StrFile_peekWrittenStringA( StrFile* self, char** out_String );
\r
1955 errnum_t StrFile_pickupSizedStruct( StrFile* m, SizedStruct** out_Struct );
\r
1956 errnum_t StrFile_moveSizedStructToStream( StrFile* self, HANDLE Stream );
\r
1957 errnum_t StrFile_setPointer( StrFile* self, int OffsetOfPointer );
\r
1958 errnum_t StrFile_getPointer( StrFile* self, int* out_OffsetOfPointer );
\r
1962 #define StrFile_peekWrittenString StrFile_peekWrittenStringW
\r
1964 #define StrFile_peekWrittenString StrFile_peekWrittenStringA
\r
1969 /***********************************************************************
\r
1970 <<< [SearchStringByBM_Class] >>>
\r
1971 ************************************************************************/
\r
1972 typedef struct _SearchStringByBM_Class SearchStringByBM_Class;
\r
1973 struct _SearchStringByBM_Class {
\r
1974 const TCHAR* TextString;
\r
1975 int TextStringLength;
\r
1976 const TCHAR* Keyword;
\r
1977 int KeywordLastIndex;
\r
1978 int KeywordLastPosition; /* Index of TextString */
\r
1980 TCHAR SkipArray_MinCharacter;
\r
1981 TCHAR SkipArray_MaxCharacter;
\r
1984 void SearchStringByBM_Class_initConst( SearchStringByBM_Class* self );
\r
1985 errnum_t SearchStringByBM_Class_initialize( SearchStringByBM_Class* self,
\r
1986 const TCHAR* TextString, const TCHAR* Keyword );
\r
1987 errnum_t SearchStringByBM_Class_initializeFromPart( SearchStringByBM_Class* self,
\r
1988 const TCHAR* TextString, size_t TextString_Length, const TCHAR* Keyword );
\r
1989 errnum_t SearchStringByBM_Class_finalize( SearchStringByBM_Class* self, errnum_t e );
\r
1990 errnum_t SearchStringByBM_Class_search( SearchStringByBM_Class* self, int* out_KeywordIndex );
\r
1993 enum { SearchString_NotFound = -1 }; /*[SearchString_NotFound]*/
\r
1997 /***********************************************************************
\r
1998 <<< [SearchStringByAC_Class] >>>
\r
1999 ************************************************************************/
\r
2000 enum { SearchStringByAC_Fail = 0 }; /*[SearchStringByAC_Fail]*/
\r
2001 enum { SearchStringByAC_RootState = 0 }; /*[SearchStringByAC_RootState]*/
\r
2003 enum { SearchStringByAC_MaxCharacterCode = 0xFFFF }; /*[SearchStringByAC_MaxCharacterCode]*/
\r
2005 enum { SearchStringByAC_MaxCharacterCode = 0xFF }; /*[SearchStringByAC_MaxCharacterCode]*/
\r
2007 typedef int16_t (* AC_GotoFunctionType )[ SearchStringByAC_MaxCharacterCode + 1 ];
\r
2008 /* Array of next_state[state][character] */
\r
2010 typedef struct _SearchStringByAC_Class SearchStringByAC_Class;
\r
2011 struct _SearchStringByAC_Class {
\r
2013 const TCHAR* TextString;
\r
2014 unsigned TextStringLength;
\r
2015 int TextStringIndex;
\r
2016 const TCHAR** FoundKeywords;
\r
2017 int FoundKeywordsCount;
\r
2018 int FoundKeywordIndex;
\r
2020 Set2 GoToFunction; /* <AC_GotoFunctionType> Next state[ state ][ character ] */
\r
2021 int* FailureFunction; /* Next state[ state ] */
\r
2022 const TCHAR*** OutputFunction; /* TCHAR* OutputFunction.Keyword[ state ][ count ] */
\r
2023 int* OutputCount; /* int OutputFunction.Count[ state ] */
\r
2024 int16_t StateCount; /* newstate + 1 */
\r
2027 void SearchStringByAC_Class_initConst( SearchStringByAC_Class* self );
\r
2028 errnum_t SearchStringByAC_Class_initialize( SearchStringByAC_Class* self,
\r
2029 const TCHAR* TextString, const TCHAR** KeywordArray, size_t KeywordArrayCount );
\r
2030 errnum_t SearchStringByAC_Class_initializeFromPart( SearchStringByAC_Class* self,
\r
2031 const TCHAR* TextString, size_t TextString_Length,
\r
2032 const TCHAR** KeywordArray, size_t KeywordArrayCount );
\r
2033 errnum_t SearchStringByAC_Class_finalize( SearchStringByAC_Class* self, errnum_t e );
\r
2034 errnum_t SearchStringByAC_Class_search( SearchStringByAC_Class* self,
\r
2035 int* out_TextStringIndex, TCHAR** out_Keyword );
\r
2036 errnum_t SearchStringByAC_Class_setTextString( SearchStringByAC_Class* self,
\r
2037 const TCHAR* TextString );
\r
2038 errnum_t SearchStringByAC_Class_setTextStringFromPart( SearchStringByAC_Class* self,
\r
2039 const TCHAR* TextString, size_t TextString_Length );
\r
2040 inline const TCHAR* SearchStringByAC_Class_getTextString( SearchStringByAC_Class* self )
\r
2041 { return self->TextString; }
\r
2046 } /* End of C Symbol */
\r
2050 /*=================================================================*/
\r
2051 /* <<< [CRT_plus_2/CRT_plus_2.h] >>> */
\r
2052 /*=================================================================*/
\r
2054 /***********************************************************************
\r
2055 <<< [HeapMemory_allocate] >>>
\r
2056 <<< [HeapMemory_allocateArray] >>>
\r
2057 ************************************************************************/
\r
2059 #define HeapMemory_allocate( out_Pointer ) \
\r
2060 HeapMemory_allocateBytes( out_Pointer, sizeof( **(out_Pointer) ) )
\r
2062 #define HeapMemory_allocateArray( out_Pointer, Count ) \
\r
2063 HeapMemory_allocateBytes( out_Pointer, sizeof( **(out_Pointer) ) * (Count) )
\r
2065 inline errnum_t HeapMemory_allocateBytes( void* out_Pointer, size_t MemorySize )
\r
2067 void** out = (void**) out_Pointer;
\r
2069 *out = malloc( MemorySize );
\r
2071 if ( *out == NULL )
\r
2072 { return E_FEW_MEMORY; }
\r
2078 /*[MallocMemory]*/
\r
2079 inline errnum_t MallocMemory( void* out_MemoryAddress, size_t MemorySize )
\r
2081 return HeapMemory_allocateBytes( out_MemoryAddress, MemorySize );
\r
2086 /***********************************************************************
\r
2087 <<< [HeapMemory_free] >>>
\r
2088 ************************************************************************/
\r
2089 inline errnum_t HeapMemory_free( const void* in_out_MemoryAddress, errnum_t e )
\r
2091 void* address = *(void**) in_out_MemoryAddress;
\r
2093 if ( address != NULL )
\r
2094 { free( address ); }
\r
2096 *(void**) in_out_MemoryAddress = NULL;
\r
2103 inline errnum_t FreeMemory( const void* in_out_MemoryAddress, errnum_t e )
\r
2105 return HeapMemory_free( in_out_MemoryAddress, e );
\r
2110 /**************************************************************************
\r
2111 <<< [Interface] >>>
\r
2112 ***************************************************************************/
\r
2113 typedef struct _VTableDefine VTableDefine; /*[VTableDefine]*/
\r
2114 struct _VTableDefine {
\r
2119 #define VTable_Obj( i ) ( (void*) ( (char*)(i) - (*(i))->m_Offset ) ) /*[VTable_Obj]*/
\r
2120 #define VTable_Method( i, m_method ) (*(i))->m_method /*[VTable_Method]*/
\r
2122 #ifdef __cplusplus
\r
2126 errnum_t DefaultFunction( void* a );
\r
2127 errnum_t DefaultFunction_NotImplementYet( void* a );
\r
2128 //errnum_t DefaultFunction_Finish( void* a, errnum_t e );
\r
2129 errnum_t DefaultFunction_Finalize( void* a, errnum_t e );
\r
2131 errnum_t VTableDefine_overwrite( VTableDefine* aVTable, size_t aVTable_ByteSize, int iMethod, void* Func );
\r
2133 #ifdef __cplusplus
\r
2139 /*=================================================================*/
\r
2140 /* <<< [Error4/Error4.h] >>> */
\r
2141 /*=================================================================*/
\r
2144 extern "C" { /* Start of C Symbol */
\r
2149 /***********************************************************************
\r
2150 <<< [SetBreakErrorID] >>>
\r
2151 ************************************************************************/
\r
2152 #ifndef ENABLE_ERROR_BREAK_IN_ERROR_CLASS
\r
2154 #define ENABLE_ERROR_BREAK_IN_ERROR_CLASS 1
\r
2156 #define ENABLE_ERROR_BREAK_IN_ERROR_CLASS 0
\r
2160 #ifndef ENABLE_DEBUG_ERROR_BREAK_IN_ERROR_CLASS
\r
2162 #define ENABLE_DEBUG_ERROR_BREAK_IN_ERROR_CLASS 1
\r
2164 #define ENABLE_DEBUG_ERROR_BREAK_IN_ERROR_CLASS 0
\r
2168 #ifndef IS_MULTI_THREAD_ERROR_CLASS
\r
2170 #define IS_MULTI_THREAD_ERROR_CLASS 0 /*[IS_MULTI_THREAD_ERROR_CLASS]:single*/
\r
2175 #define ERR2_ENABLE_ERROR_LOG 1
\r
2177 #define ERR2_ENABLE_ERROR_LOG 0
\r
2180 /*[dll_global_g_Error]*/
\r
2181 #ifndef dll_global_g_Error
\r
2182 #define dll_global_g_Error
\r
2186 #if ENABLE_ERROR_BREAK_IN_ERROR_CLASS
\r
2187 /*[IF][IF_D][ASSERT_R][ASSERT_D]*/
\r
2188 /* "IF" is able to break at nearest code raising error */
\r
2189 #define IF_D(x) IF(x)
\r
2191 if( (x) && ( OnRaisingError_Sub((const char*)__FILE__,__LINE__) ? (DebugBreakR(),1) : (1) ) )
\r
2193 #define ASSERT_R( x, goto_err_or_Statement ) \
\r
2194 __pragma(warning(push)) \
\r
2195 __pragma(warning(disable:4127)) \
\r
2196 do{ IF(!(x)) { goto_err_or_Statement; } } while(0) /* do-while is CERT standard PRE10-C */ \
\r
2197 __pragma(warning(pop))
\r
2199 #define ASSERT_D( x, goto_err_or_Statement ) ASSERT_R( x, goto_err_or_Statement )
\r
2201 #define IF(x) if(x)
\r
2203 __pragma(warning(push)) \
\r
2204 __pragma(warning(disable:4127)) \
\r
2206 __pragma(warning(pop))
\r
2208 #define ASSERT_R( x, goto_err_or_Statement ) \
\r
2209 __pragma(warning(push)) \
\r
2210 __pragma(warning(disable:4127)) \
\r
2211 do{ if(!(x)) { goto_err_or_Statement; } }while(0) /* do-while is CERT standard PRE10-C */ \
\r
2212 __pragma(warning(pop))
\r
2214 #define ASSERT_D( x, goto_err_or_Statement )
\r
2218 void DebugBreakR(void);
\r
2219 #if ! ENABLE_ERROR_BREAK_IN_ERROR_CLASS
\r
2220 inline void SetBreakErrorID( int ID ) { ID=ID; /* avoid warning */ }
\r
2221 inline void ClearError() {}
\r
2222 inline void IfErrThenBreak() {}
\r
2223 typedef int ErrStackAreaClass; // dummy type
\r
2224 inline void PushErr( ErrStackAreaClass* ErrStackArea ) { UNREFERENCED_VARIABLE( ErrStackArea ); }
\r
2225 inline void PopErr( ErrStackAreaClass* ErrStackArea ) { UNREFERENCED_VARIABLE( ErrStackArea ); }
\r
2227 void SetBreakErrorID( int ID );
\r
2228 void ClearError(void);
\r
2229 void IfErrThenBreak(void);
\r
2230 typedef struct _ErrorClass ErrStackAreaClass;
\r
2231 void PushErr( ErrStackAreaClass* ErrStackArea );
\r
2232 void PopErr( ErrStackAreaClass* ErrStackArea );
\r
2234 bool OnRaisingError_Sub( const char* FilePath, int LineNum );
\r
2236 typedef struct _ErrorClass ErrorClass; /*[ErrorClass]*/
\r
2237 struct _ErrorClass {
\r
2239 #if ENABLE_DEBUG_ERROR_BREAK_IN_ERROR_CLASS
\r
2243 const char* FilePath;
\r
2246 #if IS_MULTI_THREAD_ERROR_CLASS
\r
2247 FinalizerClass Finalizer;
\r
2248 #if ENABLE_DEBUG_ERROR_BREAK_IN_ERROR_CLASS
\r
2250 int GlobalErrorID;
\r
2254 errnum_t ErrorClass_finalize( ErrorClass* self, errnum_t e );
\r
2256 #if ! IS_MULTI_THREAD_ERROR_CLASS
\r
2257 dll_global_g_Error extern ErrorClass g_Error;
\r
2261 errnum_t MergeError( errnum_t e, errnum_t ee );
\r
2262 void ErrorLog_add( errnum_t e );
\r
2266 /***********************************************************************
\r
2267 <<< [ErrorMessage] >>>
\r
2268 ************************************************************************/
\r
2269 void Error4_printf( const TCHAR* format, ... );
\r
2270 void Error4_getErrStr( int ErrNum, TCHAR* out_ErrStr, size_t ErrStrSize );
\r
2271 void Error4_clear( int err_num );
\r
2272 errnum_t SaveWindowsLastError(void);
\r
2276 /***********************************************************************
\r
2278 ************************************************************************/
\r
2279 void Error4_showToStdErr( int err_num );
\r
2280 void Error4_showToStdIO( FILE* out, int err_num );
\r
2284 /***********************************************************************
\r
2285 <<< [DEBUG_TRUE, DEBUG_FALSE] >>>
\r
2286 ************************************************************************/
\r
2288 #define DEBUG_TRUE 1
\r
2289 #define DEBUG_FALSE 0
\r
2291 #define DEBUG_TRUE __cut_on_debug =
\r
2292 #define DEBUG_FALSE 0
\r
2297 /***********************************************************************
\r
2298 <<< [DEBUG_CODE] >>>
\r
2299 ************************************************************************/
\r
2301 #define DEBUG_CODE( expression ) \
\r
2302 __pragma(warning(push)) \
\r
2303 __pragma(warning(disable:4127)) \
\r
2304 do { expression; } while(0) /* do-while is CERT standard PRE10-C */ \
\r
2305 __pragma(warning(pop))
\r
2307 #define DEBUG_CODE( expression ) /* no execute */
\r
2312 /***********************************************************************
\r
2313 <<< [CHECK_ARG] >>>
\r
2314 ************************************************************************/
\r
2316 #define CHECK_ARG 1
\r
2319 /*[GetIsCheckArg][SetIsCheckArg]*/
\r
2321 extern bool g_IsCheckArg;
\r
2322 inline bool GetIsCheckArg(void) { return g_IsCheckArg; }
\r
2323 inline void SetIsCheckArg( bool IsCheckArg ) { g_IsCheckArg = IsCheckArg; }
\r
2328 /***********************************************************************
\r
2329 <<< [INVALID_VALUE] >>>
\r
2330 ************************************************************************/
\r
2331 enum { INVALID_VALUE = 0xDEDEDEDE };
\r
2335 /***********************************************************************
\r
2336 <<< [DUMMY_INITIAL_VALUE] >>>
\r
2337 ************************************************************************/
\r
2339 enum { DUMMY_INITIAL_VALUE = 0xDEDEDEDE };
\r
2340 enum { DUMMY_INITIAL_VALUE_8BIT = 0xDE };
\r
2341 enum { DUMMY_INITIAL_VALUE_16BIT = 0xDEDE };
\r
2343 enum { DUMMY_INITIAL_VALUE_TCHAR = 0xDEDE };
\r
2345 enum { DUMMY_INITIAL_VALUE_TCHAR = 0xDE - 0x100 }; /* 0x100 is to change to signed type */
\r
2347 /* Disable VC++ warning C4701 : local variable may be used without having been initialized */
\r
2348 /* 0xDEDEDEDE means "not initialized" */
\r
2350 enum { DUMMY_INITIAL_VALUE = 0 };
\r
2351 enum { DUMMY_INITIAL_VALUE_8BIT = 0 };
\r
2352 enum { DUMMY_INITIAL_VALUE_16BIT = 0 };
\r
2353 enum { DUMMY_INITIAL_VALUE_TCHAR = 0 };
\r
2354 /* 0 reduces code size */
\r
2359 /***********************************************************************
\r
2360 <<< [DISCARD_STRUCT] >>>
\r
2361 <<< [DISCARD_ARRAY] >>>
\r
2362 <<< [DISCARD_BYTES] >>>
\r
2363 <<< [MEMSET_TO_NOT_INIT] >>>
\r
2364 ************************************************************************/
\r
2365 #ifndef ENABLE_DISCARD_STRUCT
\r
2367 #define ENABLE_DISCARD_STRUCT 1
\r
2369 #define ENABLE_DISCARD_STRUCT 0
\r
2373 #if USE_MEMSET_TO_NOT_INIT
\r
2374 #define DISCARD_STRUCT( TypedAddress ) \
\r
2375 memset( TypedAddress, 0xDE, sizeof(*(TypedAddress)) )
\r
2376 #define DISCARD_ARRAY( TypedAddress, Count ) \
\r
2377 memset( TypedAddress, 0xDE, sizeof(*(TypedAddress)) * (Count) )
\r
2378 #define DISCARD_BYTES( Address, ByteSize ) memset( Address, 0xDE, ByteSize )
\r
2379 // #define MEMSET_TO_NOT_INIT( Address, ByteSize ) memset( Address, 0xDE, ByteSize )
\r
2381 #define DISCARD_STRUCT( Address ) __noop()
\r
2382 #define DISCARD_ARRAY( Address, Count ) __noop()
\r
2383 #define DISCARD_BYTES( Address, ByteSize ) __noop()
\r
2384 // #define MEMSET_TO_NOT_INIT( Address, ByteSize ) __noop()
\r
2389 /***********************************************************************
\r
2390 <<< [NAME_STR] >>>
\r
2391 ************************************************************************/
\r
2394 #define NAME_STR 1
\r
2396 #define NAME_STR 0
\r
2401 /***********************************************************************
\r
2402 <<< [Error4_VariablesClass] >>>
\r
2403 ************************************************************************/
\r
2404 typedef struct _Error4_VariablesClass Error4_VariablesClass;
\r
2405 struct _Error4_VariablesClass {
\r
2406 DWORD WindowsLastError;
\r
2409 Error4_VariablesClass* Get_Error4_Variables(void);
\r
2412 extern Error4_VariablesClass* g_Error4_Variables;
\r
2418 } /* End of C Symbol */
\r
2421 /*=================================================================*/
\r
2422 /* <<< [Expat/Expat_incude.h] >>> */
\r
2423 /*=================================================================*/
\r
2428 #define XML_STATIC /* [SETTING] define or not define. if not define, deploy libexpat(w).dll */
\r
2431 // reference: README.txt : * Special note about MS VC++ and runtime libraries
\r
2433 #define XML_UNICODE_WCHAR_T
\r
2434 #if defined(XML_STATIC)
\r
2436 #if _DLL // Visual C++ /MD option, MSVCP**.DLL
\r
2437 #pragma comment(lib, "libexpatwMD.lib") // not supplied
\r
2438 #else // Visual C++ /MT option
\r
2440 #pragma comment(lib, "libexpatwMT.lib")
\r
2443 #pragma comment(linker,"/NODEFAULTLIB:LIBCMT" )
\r
2447 #pragma comment(lib, "libexpatwML.lib") // not supplied
\r
2449 #else // DLL version
\r
2451 #pragma comment(lib, "libexpatw.lib") // libexpatw.dll, including multi thread static runtime library
\r
2455 #if defined(XML_STATIC)
\r
2457 #if _DLL // Visual C++ /MD option, MSVCP**.DLL
\r
2458 #pragma comment(lib, "libexpatMD.lib") // not supplied
\r
2459 #else // Visual C++ /MT option
\r
2461 #pragma comment(lib, "libexpatMT.lib")
\r
2464 # pragma comment(linker,"/NODEFAULTLIB:LIBCMT" )
\r
2468 #pragma comment(lib, "libexpatML.lib") // not supplied
\r
2470 #else // DLL version
\r
2472 #pragma comment(lib, "libexpat.lib") // libexpat.dll, including multi thread static runtime library
\r
2477 #include <expat.h>
\r
2482 /*=================================================================*/
\r
2483 /* <<< [FileT/FileT.h] >>> */
\r
2484 /*=================================================================*/
\r
2487 extern "C" { /* Start of C Symbol */
\r
2490 #define FileT_isExistWildcard 1
\r
2491 bool FileT_isExist( const TCHAR* path );
\r
2492 bool FileT_isFile( const TCHAR* path );
\r
2493 bool FileT_isDir( const TCHAR* path );
\r
2494 int FileT_isDiff( const TCHAR* Path1, const TCHAR* Path2, bool* bDiff );
\r
2495 int FileT_isSameText( TCHAR* Path1, TCHAR* Path2, int Format1, int Format2, bool* out_bSame );
\r
2496 int FileT_isSameBinaryFile( const TCHAR* PathA, const TCHAR* PathB, int Flags, bool* out_IsSame );
\r
2500 /* FileT_CallByNestFindData */
\r
2502 void* CallerArgument;
\r
2503 TCHAR* FullPath; // abstruct path
\r
2506 DWORD FileAttributes;
\r
2507 } FileT_CallByNestFindData;
\r
2509 int FileT_callByNestFind( const TCHAR* Path, BitField Flags, void* Obj, FuncType Callback );
\r
2511 enum { FileT_FolderBeforeFiles = 1 };
\r
2512 enum { FileT_FolderAfterFiles = 2 };
\r
2513 enum { FileT_Folder = FILE_ATTRIBUTE_DIRECTORY };
\r
2516 /***********************************************************************
\r
2517 <<< [FileT_Read] >>>
\r
2518 ************************************************************************/
\r
2519 int FileT_openForRead( FILE** out_pFile, const TCHAR* path );
\r
2520 // int FileT_close( FILE* File, int e );
\r
2521 errnum_t FileT_closeAndNULL( FILE** in_out_File, errnum_t e );
\r
2525 errnum_t FileT_readAll( FILE* File, TCHAR** out_Text, size_t* out_TextLength );
\r
2529 /***********************************************************************
\r
2530 <<< [FileT_Write] >>>
\r
2531 ************************************************************************/
\r
2532 int FileT_openForWrite( FILE** out_pFile, const TCHAR* Path, bit_flags_fast32_t Flags );
\r
2534 enum { F_Unicode = 1, F_Append = 2 };
\r
2536 int FileT_copy( const TCHAR* SrcPath, const TCHAR* DstPath );
\r
2537 int FileT_mkdir( const TCHAR* Path );
\r
2538 int FileT_del( const TCHAR* Path );
\r
2539 int FileT_writePart( FILE* File, const TCHAR* Start, TCHAR* Over );
\r
2543 /***********************************************************************
\r
2544 <<< [FileT_WinAPI] >>>
\r
2545 ************************************************************************/
\r
2546 int FileT_readSizedStruct_WinAPI( HANDLE* Stream, void** out_SizedStruct );
\r
2547 int FileT_writeSizedStruct_WinAPI( HANDLE* Stream, SizedStruct* OutputSizedStruct );
\r
2551 /***********************************************************************
\r
2552 <<< [FileFormatEnum] >>>
\r
2553 ************************************************************************/
\r
2555 FILE_FORMAT_NOT_EXIST = 0, /* File does not exist */
\r
2556 FILE_FORMAT_NO_BOM = 1,
\r
2557 FILE_FORMAT_UNICODE = 2,
\r
2558 FILE_FORMAT_UTF_8 = 3,
\r
2563 /***********************************************************************
\r
2564 * Function: FileT_readUnicodeFileBOM
\r
2565 ************************************************************************/
\r
2566 errnum_t FileT_readUnicodeFileBOM( const TCHAR* Path, FileFormatEnum* out_Format );
\r
2570 /***********************************************************************
\r
2571 * Function: FileT_cutFFFE
\r
2572 ************************************************************************/
\r
2573 errnum_t FileT_cutFFFE( const TCHAR* in_InputPath, const TCHAR* in_OutputPath, bool in_IsAppend );
\r
2577 /***********************************************************************
\r
2578 <<< [ParseXML2] >>>
\r
2579 ************************************************************************/
\r
2580 typedef struct _ParseXML2_ConfigClass ParseXML2_ConfigClass;
\r
2581 typedef struct _ParseXML2_StatusClass ParseXML2_StatusClass;
\r
2582 typedef errnum_t (* ParseXML2_CallbackType )( ParseXML2_StatusClass* Status );
\r
2584 struct _ParseXML2_ConfigClass {
\r
2585 BitField Flags; /* F_ParseXML2_Delegate | F_ParseXML2_OnStartElement ... */
\r
2586 void* Delegate; /* Flags|= F_ParseXML2_Delegate, if enabled */
\r
2587 ParseXML2_CallbackType OnStartElement; /* Flags|= F_ParseXML2_OnStartElement, if enabled */
\r
2588 ParseXML2_CallbackType OnEndElement; /* Flags|= F_ParseXML2_OnEndElement, if enabled */
\r
2589 ParseXML2_CallbackType OnText; /* Flags|= F_ParseXML2_OnText, if enabled */
\r
2592 F_ParseXML2_Delegate = 0x0001,
\r
2593 F_ParseXML2_OnStartElement = 0x0004,
\r
2594 F_ParseXML2_OnEndElement = 0x0008,
\r
2595 F_ParseXML2_OnText = 0x0010,
\r
2598 struct _ParseXML2_StatusClass {
\r
2601 int Depth; /* Root XML element is 0 */
\r
2602 int PreviousCallbackType; /* e.g.) F_ParseXML2_OnStartElement. Initial value is 0 */
\r
2608 const XML_Char** Attributes; /* for ParseXML2_StatusClass_getAttribute */
\r
2611 struct { /* for ParseXML2_StatusClass_mallocCopyText */
\r
2612 const TCHAR* Text; /* not NULL terminated */
\r
2618 errnum_t ParseXML2( const TCHAR* XML_Path, ParseXML2_ConfigClass* in_out_Config );
\r
2619 errnum_t ParseXML2_StatusClass_getAttribute( ParseXML2_StatusClass* self,
\r
2620 const TCHAR* AttributeName, TCHAR** out_AttribyteValue );
\r
2621 errnum_t ParseXML2_StatusClass_mallocCopyText( ParseXML2_StatusClass* self,
\r
2622 TCHAR** out_Text );
\r
2624 enum { E_XML_PARSER = 0x3101 };
\r
2628 /***********************************************************************
\r
2629 <<< [Writables] >>>
\r
2630 ************************************************************************/
\r
2631 #ifndef Uses_AppKey
\r
2632 #define Uses_AppKey 1
\r
2635 typedef void* AppKey;
\r
2636 typedef struct _Writables Writables;
\r
2638 errnum_t AppKey_newWritable( AppKey** in_out_m, Writables** out_Writable, ... );
\r
2639 errnum_t AppKey_newWritable_byArray( AppKey** in_out_m, Writables** out_Writable,
\r
2640 TCHAR** in_Paths, int in_PathCount );
\r
2641 void AppKey_initGlobal_const(void);
\r
2642 errnum_t AppKey_finishGlobal( errnum_t e );
\r
2643 errnum_t AppKey_addNewWritableFolder( const TCHAR* Path );
\r
2644 errnum_t AppKey_addWritableFolder( AppKey* m, const TCHAR* Path );
\r
2645 errnum_t AppKey_checkWritable( const TCHAR* Path );
\r
2648 struct _Writables {
\r
2649 TCHAR** m_Paths; // array of array of TCHAR
\r
2650 int m_nPath; // -1= not inited
\r
2653 errnum_t Writables_delete( Writables* m, errnum_t e );
\r
2655 errnum_t Writables_add( Writables* m, AppKey* Key, const TCHAR* Path );
\r
2656 errnum_t Writables_remove( Writables* m, const TCHAR* Path );
\r
2658 errnum_t Writables_enable( Writables* m );
\r
2659 errnum_t Writables_disable( Writables* m, errnum_t e );
\r
2661 extern Writables g_CurrentWritables;
\r
2666 } /* End of C Symbol */
\r
2669 /*=================================================================*/
\r
2670 /* <<< [IniFile2/IniFile2.h] >>> */
\r
2671 /*=================================================================*/
\r
2674 extern "C" { /* Start of C Symbol */
\r
2677 bool IniStr_isLeft( const TCHAR* line, const TCHAR* symbol );
\r
2679 TCHAR* IniStr_refRight( const TCHAR* line, bool bTrimRight );
\r
2682 } /* End of C Symbol */
\r
2686 /*=================================================================*/
\r
2687 /* <<< [Locale/Locale.h] >>> */
\r
2688 /*=================================================================*/
\r
2691 extern "C" { /* Start of C Symbol */
\r
2696 /***********************************************************************
\r
2698 ************************************************************************/
\r
2699 extern char* g_LocaleSymbol;
\r
2700 int Locale_init(void);
\r
2701 int Locale_isInited(void);
\r
2705 /***********************************************************************
\r
2706 <<< [FileTime] >>>
\r
2707 ************************************************************************/
\r
2709 #define FILETIME_addDays( pAnsTime, pBaseTime, plus ) \
\r
2710 ( *(ULONGLONG*)(pAnsTime) = *(ULONGLONG*)(pBaseTime) \
\r
2711 + (plus) * ((LONGLONG)(24*60*60)*(1000*1000*10)) )
\r
2713 #define FILETIME_addHours( pAnsTime, pBaseTime, plus ) \
\r
2714 ( *(ULONGLONG*)(pAnsTime) = *(ULONGLONG*)(pBaseTime) \
\r
2715 + (plus) * ((LONGLONG)(60*60)*(1000*1000*10)) )
\r
2717 #define FILETIME_addMinutes( pAnsTime, pBaseTime, plus ) \
\r
2718 ( *(ULONGLONG*)(pAnsTime) = *(ULONGLONG*)(pBaseTime) \
\r
2719 + (plus) * ((LONGLONG)(60)*(1000*1000*10)) )
\r
2721 #define FILETIME_addSeconds( pAnsTime, pBaseTime, plus ) \
\r
2722 ( *(ULONGLONG*)(pAnsTime) = *(ULONGLONG*)(pBaseTime) \
\r
2723 + (plus) * ((LONGLONG)(1000*1000*10)) )
\r
2725 #define FILETIME_sub( pLeftTime, pRightTime ) \
\r
2726 ( *(ULONGLONG*)(pLeftTime) - *(ULONGLONG*)(pRightTime) )
\r
2731 } /* End of C Symbol */
\r
2736 /*=================================================================*/
\r
2737 /* <<< [Parse2/Parse2.h] >>> */
\r
2738 /*=================================================================*/
\r
2740 /***********************************************************************
\r
2741 <<< [E_CATEGORY_PARSER2] >>>
\r
2742 ************************************************************************/
\r
2743 #ifndef E_CATEGORY_PARSER2 /* If not duplicated */
\r
2744 #define E_CATEGORY_PARSER2 E_CATEGORY_PARSER2
\r
2745 enum { E_CATEGORY_PARSER2 = 0x00000600 };
\r
2748 enum { E_NOT_FOUND_PARTNER_BRACKET = E_CATEGORY_PARSER2 | 0x01 }; /*[E_NOT_FOUND_PARTNER_BRACKET]*/
\r
2752 /***********************************************************************
\r
2753 <<< [ParsedRangeClass] >>>
\r
2754 ************************************************************************/
\r
2755 typedef struct _ParsedRangeClass ParsedRangeClass;
\r
2756 struct _ParsedRangeClass {
\r
2758 /* <Inherit parent="Variant_SuperClass"> */
\r
2759 const ClassID_Class* ClassID;
\r
2760 FinalizerVTableClass* FinalizerVTable;
\r
2761 VariantClass* StaticAddress;
\r
2764 const TCHAR* Start;
\r
2765 const TCHAR* Over;
\r
2767 extern const ClassID_Class g_ParsedRangeClass_ID;
\r
2769 void ParsedRangeClass_initConst( ParsedRangeClass* self );
\r
2771 int ParsedRanges_compareByStart( const void* _a1, const void* _a2 );
\r
2774 void ParsedRangeClass_onInitializedForDebug( ParsedRangeClass* self );
\r
2776 inline void ParsedRangeClass_onInitializedForDebug( ParsedRangeClass* self )
\r
2778 UNREFERENCED_VARIABLE( self );
\r
2784 errnum_t ParsedRanges_write_by_Cut(
\r
2785 Set2* /*<ParsedRangeClass>*/ CutRanges,
\r
2786 const TCHAR* Text, FILE* OutFile );
\r
2790 /***********************************************************************
\r
2791 <<< [LineNumberIndexClass] >>>
\r
2792 ************************************************************************/
\r
2793 typedef struct _LineNumberIndexClass LineNumberIndexClass;
\r
2794 struct _LineNumberIndexClass {
\r
2795 Set2 /*<const TCHAR*>*/ LeftsOfLine;
\r
2798 void LineNumberIndexClass_initConst( LineNumberIndexClass* self );
\r
2799 errnum_t LineNumberIndexClass_initialize( LineNumberIndexClass* self, const TCHAR* Text );
\r
2800 errnum_t LineNumberIndexClass_finalize( LineNumberIndexClass* self, errnum_t e );
\r
2801 errnum_t LineNumberIndexClass_searchLineNumber( LineNumberIndexClass* self, const TCHAR* Position,
\r
2802 int* out_LineNumber );
\r
2803 int LineNumberIndexClass_getCountOfLines( LineNumberIndexClass* self );
\r
2807 /***********************************************************************
\r
2808 <<< [SyntaxSubNodeClass] >>>
\r
2809 ************************************************************************/
\r
2810 typedef struct _SyntaxSubNodeClass_IDClass SyntaxSubNodeClass_IDClass;
\r
2811 typedef struct _SyntaxNodeClass SyntaxNodeClass;
\r
2814 typedef struct _SyntaxSubNodeClass SyntaxSubNodeClass;
\r
2815 struct _SyntaxSubNodeClass {
\r
2817 /* <Inherit parent="ParsedRangeClass"> */
\r
2818 const ClassID_Class* ClassID;
\r
2819 const FinalizerVTableClass* FinalizerVTable;
\r
2820 const TCHAR* Start;
\r
2821 const TCHAR* Over;
\r
2824 const PrintXML_VTableClass* PrintXML_VTable;
\r
2825 SyntaxNodeClass* Parent;
\r
2826 ListElementClass SubNodeListElement; /* for ".Parent" */
\r
2829 extern const ClassID_Class g_SyntaxSubNodeClass_ID;
\r
2830 errnum_t SyntaxSubNodeClass_printXML( SyntaxSubNodeClass* self, FILE* OutputStream );
\r
2834 /***********************************************************************
\r
2835 <<< [SyntaxNodeClass] >>>
\r
2836 ************************************************************************/
\r
2837 typedef struct _SyntaxNodeClass_IDClass SyntaxNodeClass_IDClass;
\r
2839 typedef struct _SyntaxNodeClass SyntaxNodeClass;
\r
2840 struct _SyntaxNodeClass {
\r
2842 /* <Inherit parent="SyntaxSubNodeClass"> */
\r
2843 const ClassID_Class* ClassID;
\r
2844 const FinalizerVTableClass* FinalizerVTable;
\r
2845 const TCHAR* Start;
\r
2846 const TCHAR* Over;
\r
2847 const PrintXML_VTableClass* PrintXML_VTable;
\r
2848 SyntaxNodeClass* Parent;
\r
2849 ListElementClass SubNodeListElement; /* for ".Parent" */
\r
2852 ListClass SubNodeList;
\r
2853 ListElementClass ListElement; /* Next and previous in source file */
\r
2856 errnum_t Delete_SyntaxNodeList( ListClass* /*<SyntaxNodeClass*>*/ NodeList, errnum_t e );
\r
2858 extern const ClassID_Class g_SyntaxNodeClass_ID;
\r
2859 void SyntaxNodeClass_initConst( SyntaxNodeClass* self );
\r
2860 errnum_t SyntaxNodeClass_printXML( SyntaxNodeClass* self, FILE* OutputStream );
\r
2861 errnum_t SyntaxNodeClass_addSubNode( SyntaxNodeClass* self, SyntaxSubNodeClass* SubNode );
\r
2865 /***********************************************************************
\r
2866 <<< [PP_DirectiveClass] >>>
\r
2867 ************************************************************************/
\r
2869 typedef struct _PP_DirectiveClass PP_DirectiveClass;
\r
2870 typedef struct _PP_SharpIfClass PP_SharpIfClass;
\r
2871 typedef struct _PP_SharpElseClass PP_SharpElseClass;
\r
2872 typedef struct _PP_SharpEndifClass PP_SharpEndifClass;
\r
2873 typedef struct _PP_SharpIfdefClass PP_SharpIfdefClass;
\r
2874 typedef struct _PP_SharpIfndefClass PP_SharpIfndefClass;
\r
2877 typedef struct _PP_DirectiveClass PP_DirectiveClass;
\r
2878 struct _PP_DirectiveClass {
\r
2880 /* <Inherit parent="ParsedRangeClass"> */
\r
2881 const ClassID_Class* ClassID;
\r
2882 FinalizerVTableClass* FinalizerVTable;
\r
2883 VariantClass* StaticAddress;
\r
2884 const TCHAR* Start; /* Left of a line having the direvtive */
\r
2885 const TCHAR* Over;
\r
2888 const TCHAR* DirectiveName_Start;
\r
2889 const TCHAR* DirectiveName_Over;
\r
2891 extern const ClassID_Class g_PP_DirectiveClass_ID;
\r
2894 errnum_t Parse_PP_Directive( const TCHAR* Text,
\r
2895 Set2* /*<PP_DirectiveClass*>*/ DirectivePointerArray );
\r
2896 errnum_t Delete_PP_Directive( Set2* DirectivePointerArray, errnum_t e );
\r
2899 void PP_DirectiveClass_initConst( PP_DirectiveClass* self );
\r
2903 errnum_t ParsedRanges_getCut_by_PP_Directive(
\r
2904 Set2* /*<ParsedRangeClass>*/ CutRanges,
\r
2905 Set2* /*<PP_DirectiveClass*>*/ DirectivePointerArray,
\r
2906 const TCHAR* Symbol, bool IsCutDefine );
\r
2910 errnum_t CutPreprocessorDirectives_from_C_LanguageToken(
\r
2911 ListClass* /*<C_LanguageTokenClass*>*/ TokenList,
\r
2912 Set2* /*<PP_DirectiveClass*>*/ Directives );
\r
2916 /***********************************************************************
\r
2917 <<< [PP_SharpDefineClass] >>>
\r
2918 ************************************************************************/
\r
2919 typedef struct _PP_SharpDefineClass_IDClass PP_SharpDefineClass_IDClass;
\r
2921 typedef struct _PP_SharpDefineClass PP_SharpDefineClass;
\r
2922 struct _PP_SharpDefineClass {
\r
2924 /* <Inherit parent="PP_DirectiveClass"> */
\r
2925 const ClassID_Class* ClassID;
\r
2926 FinalizerVTableClass* FinalizerVTable;
\r
2927 VariantClass* StaticAddress;
\r
2928 const TCHAR* Start;
\r
2929 const TCHAR* Over;
\r
2930 const TCHAR* DirectiveName_Start;
\r
2931 const TCHAR* DirectiveName_Over;
\r
2934 const TCHAR* Symbol_Start;
\r
2935 const TCHAR* Symbol_Over;
\r
2938 extern const ClassID_Class g_PP_SharpDefineClass_ID;
\r
2942 /***********************************************************************
\r
2943 <<< [PP_SharpIncludeClass] >>>
\r
2944 ************************************************************************/
\r
2945 typedef struct _PP_SharpIncludeClass_IDClass PP_SharpIncludeClass_IDClass;
\r
2947 typedef struct _PP_SharpIncludeClass PP_SharpIncludeClass;
\r
2948 struct _PP_SharpIncludeClass {
\r
2950 /* <Inherit parent="PP_DirectiveClass"> */
\r
2951 const ClassID_Class* ClassID;
\r
2952 FinalizerVTableClass* FinalizerVTable;
\r
2953 VariantClass* StaticAddress;
\r
2954 const TCHAR* Start;
\r
2955 const TCHAR* Over;
\r
2956 const TCHAR* DirectiveName_Start;
\r
2957 const TCHAR* DirectiveName_Over;
\r
2960 const TCHAR* Path_Start;
\r
2961 const TCHAR* Path_Over;
\r
2962 TCHAR PathBracket; /* _T('<') or _T('"') */
\r
2965 extern const ClassID_Class g_PP_SharpIncludeClass_ID;
\r
2969 /***********************************************************************
\r
2970 <<< [PP_SharpIfClass] >>>
\r
2971 ************************************************************************/
\r
2972 typedef struct _PP_SharpIfClass_IDClass PP_SharpIfClass_IDClass;
\r
2974 typedef struct _PP_SharpIfClass PP_SharpIfClass;
\r
2975 struct _PP_SharpIfClass {
\r
2977 /* <Inherit parent="PP_DirectiveClass"> */
\r
2978 const ClassID_Class* ClassID;
\r
2979 FinalizerVTableClass* FinalizerVTable;
\r
2980 VariantClass* StaticAddress;
\r
2981 const TCHAR* Start;
\r
2982 const TCHAR* Over;
\r
2983 const TCHAR* DirectiveName_Start;
\r
2984 const TCHAR* DirectiveName_Over;
\r
2987 PP_DirectiveClass* NextDirective;
\r
2988 PP_SharpEndifClass* EndDirective;
\r
2991 extern const ClassID_Class g_PP_SharpIfClass_ID;
\r
2995 /***********************************************************************
\r
2996 <<< [PP_SharpElseClass] >>>
\r
2997 ************************************************************************/
\r
2998 typedef struct _PP_SharpElseClass PP_SharpElseClass;
\r
2999 struct _PP_SharpElseClass {
\r
3001 /* <Inherit parent="PP_DirectiveClass"> */
\r
3002 const ClassID_Class* ClassID;
\r
3003 FinalizerVTableClass* FinalizerVTable;
\r
3004 VariantClass* StaticAddress;
\r
3005 const TCHAR* Start;
\r
3006 const TCHAR* Over;
\r
3007 const TCHAR* DirectiveName_Start;
\r
3008 const TCHAR* DirectiveName_Over;
\r
3011 PP_SharpIfClass* StartDirective;
\r
3012 PP_SharpEndifClass* EndDirective;
\r
3014 extern const ClassID_Class g_PP_SharpElseClass_ID;
\r
3018 /***********************************************************************
\r
3019 <<< [PP_SharpEndifClass] >>>
\r
3020 ************************************************************************/
\r
3021 typedef struct _PP_SharpEndifClass PP_SharpEndifClass;
\r
3022 struct _PP_SharpEndifClass {
\r
3024 /* <Inherit parent="PP_DirectiveClass"> */
\r
3025 const ClassID_Class* ClassID;
\r
3026 FinalizerVTableClass* FinalizerVTable;
\r
3027 VariantClass* StaticAddress;
\r
3028 const TCHAR* Start;
\r
3029 const TCHAR* Over;
\r
3030 const TCHAR* DirectiveName_Start;
\r
3031 const TCHAR* DirectiveName_Over;
\r
3034 PP_SharpIfClass* StartDirective;
\r
3035 PP_DirectiveClass* PreviousDirective;
\r
3037 extern const ClassID_Class g_PP_SharpEndifClass_ID;
\r
3041 /***********************************************************************
\r
3042 <<< [PP_SharpIfdefClass] >>>
\r
3043 ************************************************************************/
\r
3044 typedef struct _PP_SharpIfdefClass PP_SharpIfdefClass;
\r
3045 struct _PP_SharpIfdefClass {
\r
3047 /* <Inherit parent="PP_SharpIfClass"> */
\r
3048 const ClassID_Class* ClassID;
\r
3049 FinalizerVTableClass* FinalizerVTable;
\r
3050 VariantClass* StaticAddress;
\r
3051 const TCHAR* Start;
\r
3052 const TCHAR* Over;
\r
3053 const TCHAR* DirectiveName_Start;
\r
3054 const TCHAR* DirectiveName_Over;
\r
3055 PP_DirectiveClass* NextDirective;
\r
3056 PP_SharpEndifClass* EndDirective;
\r
3059 const TCHAR* Symbol_Start;
\r
3060 const TCHAR* Symbol_Over;
\r
3062 extern const ClassID_Class g_PP_SharpIfdefClass_ID;
\r
3066 /***********************************************************************
\r
3067 <<< [PP_SharpIfndefClass] >>>
\r
3068 ************************************************************************/
\r
3069 typedef struct _PP_SharpIfndefClass PP_SharpIfndefClass;
\r
3070 struct _PP_SharpIfndefClass {
\r
3072 /* <Inherit parent="PP_SharpIfdefClass"> */
\r
3073 const ClassID_Class* ClassID;
\r
3074 FinalizerVTableClass* FinalizerVTable;
\r
3075 VariantClass* StaticAddress;
\r
3076 const TCHAR* Start;
\r
3077 const TCHAR* Over;
\r
3078 const TCHAR* DirectiveName_Start;
\r
3079 const TCHAR* DirectiveName_Over;
\r
3080 PP_DirectiveClass* NextDirective;
\r
3081 PP_SharpEndifClass* EndDirective;
\r
3082 const TCHAR* Symbol_Start;
\r
3083 const TCHAR* Symbol_Over;
\r
3086 extern const ClassID_Class g_PP_SharpIfndefClass_ID;
\r
3090 /***********************************************************************
\r
3091 <<< [C_LanguageTokenEnum] >>>
\r
3092 ************************************************************************/
\r
3093 typedef enum _C_LanguageTokenEnum C_LanguageTokenEnum;
\r
3094 enum _C_LanguageTokenEnum {
\r
3095 gc_TokenOfOther = 0,
\r
3096 gc_TokenOfNumber = 0xA1,
\r
3097 gc_TokenOfCIdentifier = 0xA2,
\r
3098 gc_TokenOfString = 0xA3,
\r
3099 gc_TokenOfChar = 0xA4,
\r
3101 gc_TokenOf_28 = '(',
\r
3102 gc_TokenOf_29 = ')',
\r
3103 gc_TokenOf_7B = '{',
\r
3104 gc_TokenOf_7D = '}',
\r
3105 gc_TokenOf_5B = '[',
\r
3106 gc_TokenOf_5D = ']',
\r
3107 gc_TokenOf_3A = ':',
\r
3108 gc_TokenOf_3B = ';',
\r
3109 gc_TokenOf_2A = '*',
\r
3110 gc_TokenOf_0A = '\n',
\r
3111 gc_TokenOf_3D = '=',
\r
3112 gc_TokenOf_2E = '.',
\r
3113 gc_TokenOf_26 = '&',
\r
3114 gc_TokenOf_2B = '+',
\r
3115 gc_TokenOf_2D = '-',
\r
3116 gc_TokenOf_7E = '~',
\r
3117 gc_TokenOf_21 = '!',
\r
3118 gc_TokenOf_2F = '/',
\r
3119 gc_TokenOf_25 = '%',
\r
3120 gc_TokenOf_3E = '>',
\r
3121 gc_TokenOf_3C = '<',
\r
3122 gc_TokenOf_5E = '^',
\r
3123 gc_TokenOf_7C = '|',
\r
3124 gc_TokenOf_3F = '?',
\r
3125 gc_TokenOf_2C = ',',
\r
3126 gc_TokenOf_2A2F = TwoChar8( '/', '*' ),
\r
3127 gc_TokenOf_2F2A = TwoChar8( '*', '/' ),
\r
3128 gc_TokenOf_2F2F = TwoChar8( '/', '/' ),
\r
3129 gc_TokenOf_3E2D = TwoChar8( '-', '>' ),
\r
3130 gc_TokenOf_2B2B = TwoChar8( '+', '+' ),
\r
3131 gc_TokenOf_2D2D = TwoChar8( '-', '-' ),
\r
3132 gc_TokenOf_3C3C = TwoChar8( '<', '<' ),
\r
3133 gc_TokenOf_3E3E = TwoChar8( '>', '>' ),
\r
3134 gc_TokenOf_3D3E = TwoChar8( '>', '=' ),
\r
3135 gc_TokenOf_3D3C = TwoChar8( '<', '=' ),
\r
3136 gc_TokenOf_3D3D = TwoChar8( '=', '=' ),
\r
3137 gc_TokenOf_3D21 = TwoChar8( '!', '=' ),
\r
3138 gc_TokenOf_2626 = TwoChar8( '&', '&' ),
\r
3139 gc_TokenOf_7C7C = TwoChar8( '|', '|' ),
\r
3140 gc_TokenOf_3D2B = TwoChar8( '+', '=' ),
\r
3141 gc_TokenOf_3D2D = TwoChar8( '-', '=' ),
\r
3142 gc_TokenOf_3D2A = TwoChar8( '*', '=' ),
\r
3143 gc_TokenOf_3D2F = TwoChar8( '/', '=' ),
\r
3144 gc_TokenOf_3D25 = TwoChar8( '%', '=' ),
\r
3147 gc_TokenOf_3D26 = TwoChar8( '&', '=' ),
\r
3148 gc_TokenOf_3D7C = TwoChar8( '|', '=' ),
\r
3149 gc_TokenOf_3D5E = TwoChar8( '^', '=' ),
\r
3152 TCHAR* C_LanguageTokenEnum_convertToStr( C_LanguageTokenEnum Value );
\r
3156 /***********************************************************************
\r
3157 <<< [C_LanguageTokenClass] >>>
\r
3158 ************************************************************************/
\r
3159 typedef struct _C_LanguageTokenClass_IDClass C_LanguageTokenClass_IDClass;
\r
3161 typedef struct _C_LanguageTokenClass C_LanguageTokenClass;
\r
3162 struct _C_LanguageTokenClass {
\r
3164 /* <Inherit parent="SyntaxSubNodeClass"> */
\r
3165 const ClassID_Class* ClassID;
\r
3166 const FinalizerVTableClass* FinalizerVTable;
\r
3167 const TCHAR* Start;
\r
3168 const TCHAR* Over;
\r
3169 const PrintXML_VTableClass* PrintXML_VTable;
\r
3170 SyntaxNodeClass* Parent;
\r
3171 ListElementClass SubNodeListElement; /* for ".Parent" */
\r
3174 C_LanguageTokenEnum TokenType;
\r
3175 ListElementClass ListElement; /* Next and previous in source file */
\r
3176 SyntaxNodeClass* ParentBlock;
\r
3179 extern const ClassID_Class g_C_LanguageTokenClass_ID;
\r
3180 void C_LanguageTokenClass_initConst( C_LanguageTokenClass* self );
\r
3181 errnum_t C_LanguageTokenClass_printXML( C_LanguageTokenClass* self, FILE* OutputStream );
\r
3185 /***********************************************************************
\r
3186 <<< [NaturalDocsDefinitionClass] >>>
\r
3187 ************************************************************************/
\r
3188 typedef struct _NaturalDocsDefinitionClass NaturalDocsDefinitionClass;
\r
3189 struct _NaturalDocsDefinitionClass {
\r
3190 const TCHAR* Name; /* Has */
\r
3191 const TCHAR* NameStart;
\r
3192 const TCHAR* NameOver;
\r
3194 const TCHAR* Brief; /* Has */
\r
3195 const TCHAR* BriefStart;
\r
3196 const TCHAR* BriefOver;
\r
3199 void NaturalDocsDefinitionClass_initConst( NaturalDocsDefinitionClass* self );
\r
3200 errnum_t NaturalDocsDefinitionClass_finalize( NaturalDocsDefinitionClass* self, errnum_t e );
\r
3204 /***********************************************************************
\r
3205 <<< [NaturalDocsDescriptionTypeEnum] >>>
\r
3206 ************************************************************************/
\r
3207 typedef enum _NaturalDocsDescriptionTypeEnum NaturalDocsDescriptionTypeEnum;
\r
3208 enum _NaturalDocsDescriptionTypeEnum {
\r
3209 NaturalDocsDescriptionType_Unknown,
\r
3210 NaturalDocsDescriptionType_SubTitle,
\r
3211 NaturalDocsDescriptionType_Paragraph,
\r
3212 NaturalDocsDescriptionType_Code,
\r
3213 NaturalDocsDescriptionType_DefinitionList,
\r
3215 NaturalDocsDescriptionType_Count
\r
3218 const TCHAR* NaturalDocsDescriptionTypeEnum_to_String( int in, const TCHAR* in_OutOfRange );
\r
3222 /***********************************************************************
\r
3223 <<< [NaturalDocsDescriptionClass] >>>
\r
3224 ************************************************************************/
\r
3225 typedef struct _NaturalDocsDescriptionClass NaturalDocsDescriptionClass;
\r
3226 struct _NaturalDocsDescriptionClass {
\r
3227 NaturalDocsDescriptionTypeEnum Type;
\r
3229 const TCHAR* Start;
\r
3230 const TCHAR* Over;
\r
3234 NaturalDocsDefinitionClass* Definition;
\r
3238 void NaturalDocsDescriptionClass_initConst( NaturalDocsDescriptionClass* self );
\r
3239 errnum_t NaturalDocsDescriptionClass_finalize( NaturalDocsDescriptionClass* self, errnum_t e );
\r
3243 /***********************************************************************
\r
3244 <<< [NaturalDocsParserConfigClass] >>>
\r
3245 ************************************************************************/
\r
3246 typedef struct _NaturalDocsParserConfigClass NaturalDocsParserConfigClass;
\r
3247 struct _NaturalDocsParserConfigClass {
\r
3248 bit_flags_fast32_t Flags; /*<NaturalDocsParserConfigEnum>*/
\r
3249 TCHAR** AdditionalKeywords;
\r
3250 int AdditionalKeywordsLength;
\r
3251 int AdditionalKeywordsEndsScopesFirstIndex;
\r
3252 int AdditionalKeywordsEndsScopesLength;
\r
3254 typedef enum _NaturalDocsParserConfigEnum NaturalDocsParserConfigEnum;
\r
3255 enum _NaturalDocsParserConfigEnum {
\r
3256 NaturalDocsParserConfig_AdditionalKeywords = 0x0001,
\r
3257 NaturalDocsParserConfig_AdditionalKeywordsLength = 0x0002,
\r
3258 NaturalDocsParserConfig_AdditionalKeywordsEndsScopesFirstIndex = 0x0004,
\r
3259 NaturalDocsParserConfig_AdditionalKeywordsEndsScopesLength = 0x0008,
\r
3264 /***********************************************************************
\r
3265 <<< [NaturalDocsHeaderClass] >>>
\r
3266 ************************************************************************/
\r
3267 typedef struct _NaturalDocsHeaderClass NaturalDocsHeaderClass;
\r
3268 struct _NaturalDocsHeaderClass {
\r
3269 const TCHAR* Keyword; /* Has */
\r
3270 const TCHAR* KeywordStart;
\r
3271 const TCHAR* KeywordOver;
\r
3273 const TCHAR* Name; /* Has */
\r
3274 const TCHAR* NameStart;
\r
3275 const TCHAR* NameOver;
\r
3277 const TCHAR* BriefNoIndent;
\r
3278 const TCHAR* Brief; /* Has */
\r
3279 const TCHAR* BriefStart;
\r
3280 const TCHAR* BriefOver;
\r
3282 const TCHAR* ArgumentsLabel;
\r
3283 Set2 Arguments; /*<NaturalDocsDefinitionClass>*/ /* Has */
\r
3285 const TCHAR* ReturnValueLabel;
\r
3286 const TCHAR* ReturnValue; /* Has */
\r
3287 const TCHAR* ReturnValueStart;
\r
3288 const TCHAR* ReturnValueOver;
\r
3290 const TCHAR* Descriptions; /* Has */
\r
3291 const TCHAR* DescriptionsStart;
\r
3292 const TCHAR* DescriptionsOver;
\r
3294 Set2 DescriptionItems; /*<NaturalDocsDescriptionClass>*/ /* Has */
\r
3297 void NaturalDocsHeaderClass_initConst( NaturalDocsHeaderClass* self );
\r
3298 errnum_t NaturalDocsHeaderClass_finalize( NaturalDocsHeaderClass* self, errnum_t e );
\r
3300 errnum_t ParseNaturalDocsComment( const TCHAR* in_SourceStart, const TCHAR* in_SourceOver,
\r
3301 NaturalDocsHeaderClass** out_NaturalDocsHeader, NaturalDocsParserConfigClass* config );
\r
3305 /***********************************************************************
\r
3306 <<< [NaturalCommentClass] >>>
\r
3307 ************************************************************************/
\r
3308 typedef struct _NaturalCommentClass NaturalCommentClass;
\r
3309 struct _NaturalCommentClass {
\r
3311 /* <Inherit parent="SyntaxNodeClass"> */
\r
3312 const ClassID_Class* ClassID;
\r
3313 const FinalizerVTableClass* FinalizerVTable;
\r
3314 const TCHAR* Start;
\r
3315 const TCHAR* Over;
\r
3316 const PrintXML_VTableClass* PrintXML_VTable;
\r
3317 SyntaxNodeClass* Parent;
\r
3318 ListElementClass SubNodeListElement; /* for ".Parent" */
\r
3319 ListClass SubNodeList;
\r
3320 ListElementClass ListElement; /* Next and previous in source file */
\r
3325 NaturalDocsHeaderClass* NaturalDocsHeader;
\r
3326 NaturalCommentClass* ParentComment;
\r
3329 extern const ClassID_Class g_NaturalCommentClass_ID;
\r
3330 void NaturalCommentClass_initConst( NaturalCommentClass* self );
\r
3331 errnum_t NaturalCommentClass_finalize( NaturalCommentClass* self, errnum_t e );
\r
3332 errnum_t NaturalCommentClass_printXML( NaturalCommentClass* self, FILE* OutputStream );
\r
3335 errnum_t MakeNaturalComments_C_Language( ListClass* /*<C_LanguageTokenClass*>*/ TokenList,
\r
3336 LineNumberIndexClass* LineNumbers,
\r
3337 ListClass* /*<NaturalCommentClass*>*/ TopSyntaxNodeList,
\r
3338 NaturalDocsParserConfigClass* config );
\r
3342 /***********************************************************************
\r
3343 <<< [Parse_C_Language] >>>
\r
3344 ************************************************************************/
\r
3345 errnum_t LexicalAnalize_C_Language( const TCHAR* Text,
\r
3346 ListClass* /*<C_LanguageTokenClass*>*/ TokenList );
\r
3347 errnum_t CutComment_C_LanguageToken( ListClass* /*<C_LanguageTokenClass*>*/ TokenList );
\r
3348 errnum_t Delete_C_LanguageToken( ListClass* /*<C_LanguageTokenClass*>*/ TokenList, errnum_t e );
\r
3350 errnum_t CutCommentC_1( const TCHAR* in_InputPath, const TCHAR* in_OutputPath );
\r
3351 errnum_t CopyWithoutComment_C_Language( ListClass* in_Tokens, TCHAR* in_Text, FILE* in_OutStream );
\r
3353 /*=================================================================*/
\r
3354 /* <<< [PlatformSDK_plus/PlatformSDK_plus.h] >>> */
\r
3355 /*=================================================================*/
\r
3358 extern "C" { /* Start of C Symbol */
\r
3363 int GetCommandLineUnnamed( int Index1, TCHAR* out_AParam, size_t AParamSize );
\r
3364 int GetCommandLineNamed( const TCHAR* Name, bool bCase, TCHAR* out_Value, size_t ValueSize );
\r
3365 int GetCommandLineNamedC8( const TCHAR* Name, bool bCase, char* out_Value, size_t ValueSize );
\r
3366 int GetCommandLineNamedI( const TCHAR* Name, bool bCase, int* out_Value );
\r
3367 bool GetCommandLineExist( const TCHAR* Name, bool bCase );
\r
3370 #define GetCommandLineNamedC8 GetCommandLineNamed
\r
3374 errnum_t GetProcessInformation( DWORD in_ProcessID, PROCESSENTRY32* out_Info );
\r
3376 /* [CloseHandleInFin] */
\r
3377 #if ENABLE_ERROR_BREAK_IN_ERROR_CLASS
\r
3378 #define CloseHandleInFin( h, e ) \
\r
3380 ( (h) == INVALID_HANDLE_VALUE || (h) == NULL || CloseHandle( h ) ) ? \
\r
3383 ( OnRaisingError_Sub((const char*)__FILE__,__LINE__) ) ? \
\r
3384 (DebugBreakR(), E_OTHERS) : \
\r
3389 #define CloseHandleInFin( h, e ) \
\r
3391 ( (h) == INVALID_HANDLE_VALUE || (h) == NULL || CloseHandle( h ) ) ? \
\r
3400 #define env( Str, StrSize, Input ) \
\r
3401 env_part( Str, StrSize, Str, NULL, Input )
\r
3402 int env_part( TCHAR* Str, unsigned StrSize, TCHAR* StrStart, TCHAR** out_StrLast,
\r
3403 const TCHAR* Input );
\r
3404 int env_malloc( TCHAR** out_Value, size_t* out_ValueLen, const TCHAR* Name );
\r
3409 } /* End of C Symbol */
\r
3412 /*=================================================================*/
\r
3413 /* <<< [Global0/Global0.h] >>> */
\r
3414 /*=================================================================*/
\r
3417 extern "C" { /* Start of C Symbol */
\r
3422 /***********************************************************************
\r
3423 <<< [Globals] >>>
\r
3424 ************************************************************************/
\r
3425 #define USE_GLOBALS 1
\r
3427 void Globals_initConst(void);
\r
3428 int Globals_initialize(void);
\r
3429 int Globals_finalize( int e );
\r
3432 #define get_InitedObject( m, isInited ) (m)
\r
3434 #define get_InitedObject( m, isInited ) ( isInited( m ) ? (m) : (DebugBreakR(), (m)) )
\r
3440 } /* End of C Symbol */
\r
3443 #endif // __CLIB_H
\r
3447 #pragma message( "end of #include \"" __FILE__ "\"" )
\r