enum { E_IN_ERROR = E_CATEGORY_COMMON | 0x05 }; /* 1029 */\r
enum { E_IN_FINALLY = E_CATEGORY_COMMON | 0x06 }; /* 1030 */\r
enum { E_INVALID_VALUE = E_CATEGORY_COMMON | 0x07 }; /* 1031 */\r
+enum { E_UNKNOWN_DATA_TYPE = E_CATEGORY_COMMON | 0x08 }; /* 1032 */\r
enum { E_NOT_IMPLEMENT_YET = E_CATEGORY_COMMON | 0x09 }; /* 1033 */\r
enum { E_ORIGINAL = E_CATEGORY_COMMON | 0x0A }; /* 1034 */\r
enum { E_LIMITATION = E_CATEGORY_COMMON | 0x0F }; /* 1039 */\r
enum { E_EXIT_TEST = E_CATEGORY_COMMON | 0xE7 }; /* 1255 */\r
enum { E_FIFO_OVER = E_CATEGORY_COMMON | 0xF0 }; /* 1264 */\r
\r
+enum { NOT_FOUND_INDEX = -1 };\r
\r
\r
/*=================================================================*/\r
\r
#include <direct.h> \r
\r
+#include <malloc.h> \r
+ \r
+#include <io.h> \r
+ \r
+#include <fcntl.h> \r
+ \r
+#include <tlhelp32.h> \r
+ \r
/*=================================================================*/\r
/* <<< [CRT_plus_1/CRT_plus_1.h] >>> */ \r
/*=================================================================*/\r
\r
+#if __cplusplus\r
+ extern "C" { /* Start of C Symbol */ \r
+#endif\r
+\r
+\r
+ \r
/***********************************************************************\r
<<< [C99Type] >>> \r
************************************************************************/\r
typedef unsigned int uint32_t; /* For 32bit compiler */\r
typedef unsigned short uint16_t;\r
typedef unsigned char uint8_t;\r
+typedef unsigned char byte_t; /* This is not C99 */\r
typedef float float32_t; /* This is not C99 */\r
typedef double float64_t; /* This is not C99 */\r
typedef unsigned int bool_t; /* MISRA-C:1998 No.13 */ /* This is not C99 */\r
\r
\r
\r
+/***********************************************************************\r
+ <<< [INVALID_ARRAY_INDEX] >>> \r
+************************************************************************/\r
+enum { INVALID_ARRAY_INDEX = -1 };\r
+\r
+\r
+ \r
/*********************************************************************************************\r
<<< [bit_flags32_t] [bit_flags_fast32_t] >>> \r
<<< [BitField] [BIT_FIELD_ENDIAN] [BIT_FIELD_LITTLE_ENDIAN] [BIT_FIELD_BIG_ENDIAN] >>> \r
\r
\r
/***********************************************************************\r
+ <<< (malloc_redirected) >>> \r
+************************************************************************/\r
+#define malloc malloc_redirected\r
+#define realloc realloc_redirected\r
+#define calloc calloc_redirected\r
+void* malloc_redirected( size_t in_Size );\r
+void* realloc_redirected( void* in_Address, size_t in_Size );\r
+void* calloc_redirected( size_t in_Count, size_t in_Size );\r
+void* malloc_no_redirected( size_t in_Size );\r
+void* realloc_no_redirected( void* in_Address, size_t in_Size );\r
+void* calloc_no_redirected( size_t in_Count, size_t in_Size );\r
+\r
+\r
+ \r
+/***********************************************************************\r
<<< [FuncType] >>> \r
************************************************************************/\r
typedef int (*FuncType)( void* Param ); \r
\r
\r
/***********************************************************************\r
+ <<< [SizedStruct] >>> \r
+************************************************************************/\r
+typedef struct _SizedStruct SizedStruct;\r
+struct _SizedStruct {\r
+ size_t ThisStructSize;\r
+ int OthersData;\r
+};\r
+\r
+\r
+ \r
+/***********************************************************************\r
<<< [NameOnlyClass] >>> \r
************************************************************************/\r
typedef struct _NameOnlyClass NameOnlyClass;\r
\r
\r
\r
+/***********************************************************************\r
+ <<< [PointerType_plus] >>> \r
+************************************************************************/\r
+inline void PointerType_plus( const void* in_out_Element, int PlusMinusByte )\r
+{\r
+ *(int8_t**) in_out_Element = *(int8_t**) in_out_Element + PlusMinusByte;\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [PointerType_diff] >>> \r
+************************************************************************/\r
+inline ptrdiff_t PointerType_diff( const void* PointerA, const void* PointerB )\r
+{\r
+ return (uintptr_t) PointerA - (uintptr_t) PointerB;\r
+}\r
+\r
+\r
+ \r
+/**************************************************************************\r
+ <<< [JOIN_SYMBOL] >>> \r
+***************************************************************************/\r
+#define JOIN_SYMBOL(x, y) JOIN_SYMBOL_AGAIN(x, y)\r
+#define JOIN_SYMBOL_AGAIN(x, y) x##y\r
+ /* CERT secure coding standard PRE05-C */\r
+\r
+\r
+ \r
+/**************************************************************************\r
+ <<< [static_assert] >>> \r
+***************************************************************************/\r
+#define static_assert( ConstantExpression, StringLiteral ) \\r
+ __pragma(warning(push)) \\r
+ __pragma(warning(disable:4127)) \\r
+ do { typedef char JOIN_SYMBOL( AssertionFailed_, __LINE__ )[(ConstantExpression) ? 1 : -1]; } while(0) \\r
+ __pragma(warning(pop))\r
+\r
+#define static_assert_global( ConstantExpression, StringLiteral ) \\r
+ __pragma(warning(push)) \\r
+ __pragma(warning(disable:4127)) \\r
+ typedef char JOIN_SYMBOL( AssertionFailed_, __LINE__ )[(ConstantExpression) ? 1 : -1] \\r
+ __pragma(warning(pop))\r
+\r
+ /* CERT secure coding standard DCL03-C */\r
+ /* If "ConstantExpression" is false, illegal array size error will be raised. */\r
+\r
+\r
+ \r
+#if __cplusplus\r
+ } /* End of C Symbol */ \r
+#endif\r
+ \r
/*=================================================================*/\r
/* <<< [Error4_Inline/Error4_Inline.h] >>> */ \r
/*=================================================================*/\r
\r
\r
\r
-/***********************************************************************\r
- <<< [printf_to_debugger] >>> \r
-************************************************************************/\r
-void printf_to_debugger( const char* fmt, ... );\r
-void wprintf_to_debugger( const wchar_t* fmt, ... );\r
-\r
-#ifndef USE_printf_to\r
- #ifdef __linux__\r
- #define USE_printf_to USE_printf_to_stdout\r
- #else\r
- #define USE_printf_to USE_printf_to_debugger\r
- #endif\r
-#endif\r
-\r
-#if USE_printf_to == USE_printf_to_debugger\r
- #define printf printf_to_debugger\r
- #define wprintf wprintf_to_debugger\r
-\r
- #undef _tprintf\r
- #if UNICODE\r
- #define _tprintf wprintf_to_debugger\r
- #else\r
- #define _tprintf printf_to_debugger\r
- #endif\r
-#endif\r
-\r
- \r
errnum_t vsprintf_r( char* s, size_t s_size, const char* format, va_list va ); \r
\r
errnum_t vswprintf_r( wchar_t* s, size_t s_size, const wchar_t* format, va_list va ); \r
errnum_t stprintf_part_r( TCHAR* s, size_t s_size, TCHAR* s_start, TCHAR** p_s_last,\r
const TCHAR* format, ... );\r
\r
+errnum_t ftcopy_part_r( FILE* OutputStream, const TCHAR* Str, const TCHAR* StrOver );\r
+ \r
+errnum_t OpenConsole( bool in_OpenIfNoConsole, bool* out_IsExistOrNewConsole );\r
+\r
+ \r
#if __cplusplus\r
} /* End of C Symbol */ \r
#endif\r
\r
\r
/*=================================================================*/\r
+/* <<< [StrT_typedef/StrT_typedef.h] >>> */ \r
+/*=================================================================*/\r
+ \r
+/***********************************************************************\r
+ <<< [NewStringsEnum] >>> \r
+************************************************************************/\r
+typedef enum _NewStringsEnum NewStringsEnum;\r
+enum _NewStringsEnum {\r
+ NewStringsEnum_NewPointersAndLinkCharacters = 0x06,\r
+ NewStringsEnum_NewPointersAndNewCharacters = 0x03,\r
+ NewStringsEnum_LinkCharacters = 0x04,\r
+ NewStringsEnum_NewPointers = 0x02,\r
+ NewStringsEnum_NewCharacters = 0x01,\r
+ NewStringsEnum_NoAllocate = 0x00\r
+};\r
+\r
+\r
+ \r
+/*=================================================================*/\r
/* <<< [SetX/SetX.h] >>> */ \r
/*=================================================================*/\r
\r
#endif\r
\r
\r
+/******************************************************************\r
+ <<< Set4_typedef >>> \r
+*******************************************************************/\r
+\r
+typedef struct _Set4 Set4;\r
+typedef struct _Set4Iter Set4Iter;\r
+\r
+typedef int (*FuncType_create_in_set4)( void** pm, Set4* Set );\r
+ \r
/***********************************************************************\r
<<< [Set2] >>> \r
************************************************************************/\r
};\r
\r
#define Set2_initConst( m ) ( (m)->First = NULL, (m)->Next = NULL )\r
-int Set2_init( Set2* m, int FirstSize );\r
-int Set2_finish( Set2* m, int e );\r
+errnum_t Set2_init( Set2* m, int FirstSize );\r
+errnum_t Set2_finish( Set2* m, errnum_t e );\r
#define Set2_isInited( m ) ( (m)->First != NULL )\r
\r
+#define Set2_allocate( m, pp ) \\r
+ Set2_alloc_imp( m, (void*)(pp), sizeof(**(pp)) )\r
+\r
#define Set2_alloc( m, pp, type ) \\r
Set2_alloc_imp( m, (void*)(pp), sizeof(type) )\r
\r
-int Set2_alloc_imp( Set2* m, void* pm, size_t size );\r
+errnum_t Set2_alloc_imp( Set2* m, void* pm, size_t size );\r
\r
#define Set2_push( m, pp, type ) \\r
Set2_alloc_imp( m, (void*)(pp), sizeof(type) )\r
#define Set2_pop( m, pp, type ) \\r
Set2_pop_imp( m, (void*)(pp), sizeof(type) )\r
\r
-int Set2_pop_imp( Set2* m, void* pp, size_t size );\r
+errnum_t Set2_pop_imp( Set2* m, void* pp, size_t size );\r
+\r
+#define Set2_free( m, pp, e ) \\r
+ Set2_free_imp( m, pp, sizeof(**(pp)), e )\r
+errnum_t Set2_free_imp( Set2* self, void* in_PointerOfPointer, size_t in_Size_ofElement, errnum_t e );\r
\r
#define Set2_freeLast( m, p, type, e ) \\r
( ((char*)(m)->Next - sizeof(type) == (char*)(p)) ? \\r
\r
#define Set2_expandIfOverByOffset( m, Size ) \\r
Set2_expandIfOverByAddr( m, (char*)(m)->First + (Size) )\r
-int Set2_expandIfOverByAddr_imp( Set2* m, void* OverAddrBasedOnNowFirst );\r
+errnum_t Set2_expandIfOverByAddr_imp( Set2* m, void* OverAddrBasedOnNowFirst );\r
\r
#define Set2_allocMulti( m, out_pElem, ElemType, nElem ) \\r
Set2_allocMulti_sub( m, (void*)(out_pElem), sizeof(ElemType) * (nElem) )\r
-int Set2_allocMulti_sub( Set2* m, void* out_pElem, size_t ElemsSize );\r
+errnum_t Set2_allocMulti_sub( Set2* m, void* out_pElem, size_t ElemsSize );\r
\r
#define Set2_forEach( self, Item, Item_Over, Type ) \\r
*(Item) = (Type*)( (self)->First ), *(Item_Over) = (Type*)( (self)->Next ); \\r
}\r
\r
\r
+#define Set2_getArray( self, out_Array, out_Count ) \\r
+ ( ( *(void**)(out_Array) = (self)->First, \\r
+ *(out_Count) = ( (byte_t*) (self)->Next - (byte_t*) (self)->First ) / sizeof(**(out_Array))), 0 )\r
+\r
+#define Set2_refer( m, iElem, out_pElem ) \\r
+ Set2_ref_imp( m, iElem, out_pElem, sizeof(**(out_pElem)) )\r
+\r
#define Set2_ref( m, iElem, out_pElem, ElemType ) \\r
Set2_ref_imp( m, iElem, out_pElem, sizeof(ElemType) )\r
\r
-int Set2_ref_imp( Set2* m, int iElem, void* out_pElem, size_t ElemSize );\r
+errnum_t Set2_ref_imp( Set2* m, int iElem, void* out_pElem, size_t ElemSize );\r
+\r
+#define Set2_isEmpty( m ) \\r
+ ( (m)->Next == (m)->First )\r
\r
#define Set2_getCount( m, Type ) \\r
- ( (Type*)(m)->Next - (Type*)(m)->First )\r
+ ( ( (byte_t*)(m)->Next - (byte_t*)(m)->First ) / sizeof(Type) )\r
+\r
+#define Set2_getCountMax( m, Type ) \\r
+ ( ( (byte_t*)(m)->Over - (byte_t*)(m)->First ) / sizeof(Type) )\r
\r
#define Set2_checkPtrInArr( m, p ) \\r
( (m)->First <= (p) && (p) < (m)->Over ? 0 : E_NOT_FOUND_SYMBOL )\r
\r
-int Set2_separate( Set2* m, int NextSize, void** allocate_Array );\r
+errnum_t Set2_separate( Set2* m, int NextSize, void** allocate_Array );\r
\r
#ifdef _DEBUG\r
void Set2_setDebug( Set2* m, void* PointerOfDebugArray );\r
\r
\r
/***********************************************************************\r
+ <<< [Set2a] >>> \r
+************************************************************************/\r
+typedef struct _Set2 Set2a;\r
+\r
+void Set2a_initConst( Set2a* m, void* ArrInStack );\r
+int Set2a_init( Set2a* m, void* ArrInStack, size_t ArrInStack_Size );\r
+int Set2a_finish( Set2a* m, void* ArrInStack, int e );\r
+int Set2a_toEmpty( Set2a* m );\r
+//int Set2a_alloc( Set2a* m, void* ArrInStack, ClassA** out_p, Type ClassA );\r
+int Set2a_expandIfOverByAddr( Set2a* m, void* OverAddrBasedOnNowFirst );\r
+\r
+\r
+\r
+// for inside\r
+\r
+#define Set2a_initConst( m, ArrInStack ) \\r
+ ( (m)->First = (ArrInStack) )\r
+\r
+#define Set2a_finish( m, ArrInStack, e ) \\r
+ ( (m)->First == (ArrInStack) ? (e) : ( free( (m)->First ), (e) ) )\r
+\r
+#define Set2a_toEmpty( m ) \\r
+ Set2_toEmpty( m )\r
+\r
+#define Set2a_alloc( m, ArrInStack, out_Pointer, ClassA ) \\r
+ ( (void*)( (ClassA*)((m)->Next) + 1 ) <= (m)->Over ? \\r
+ ( *(out_Pointer) = (ClassA*)(m)->Next, (m)->Next = (ClassA*)((m)->Next) + 1, 0 ) : \\r
+ Set2a_alloc_imp( m, ArrInStack, out_Pointer, sizeof(ClassA) ) )\r
+\r
+int Set2a_alloc_imp( Set2a* m, void* ArrInStack, void* out_Pointer, size_t ElemSize );\r
+\r
+#define Set2a_expandIfOverByAddr( m, ArrInStack, OverAddrBasedOnNowFirst ) \\r
+ ( (void*)(OverAddrBasedOnNowFirst) <= (m)->Over ? 0 : \\r
+ Set2a_expandIfOverByAddr_imp( m, ArrInStack, OverAddrBasedOnNowFirst ) )\r
+\r
+int Set2a_expandIfOverByAddr_imp( Set2a* m, void* ArrInStack, void* OverAddrBasedOnNowFirst );\r
+\r
+\r
+ \r
+/******************************************************************\r
+ <<< [Set4] >>> \r
+*******************************************************************/\r
+struct _Set4 {\r
+ byte_t* FirstBlock;\r
+ byte_t* CurrentBlockFirst;\r
+ byte_t* CurrentBlockNext;\r
+ union {\r
+ byte_t* CurrentBlockOver;\r
+ byte_t** NextBlock;\r
+ } u;\r
+ size_t HeapSize;\r
+ size_t ElementSize;\r
+};\r
+\r
+struct _Set4Iter {\r
+ void* p;\r
+ void* Over;\r
+};\r
+\r
+/* errnum_t Set4_init( Set4* self, Type, int FirstHeapSize ); */\r
+/* errnum_t Set4_allocate( Set4* self, Type** out_ElementPointer ); */\r
+/* errnum_t Set4_free( Set4* self, Type** in_out_ElementPointer ); */\r
+/* Type* Set4_ref( Set4* self, int i, Type ); */\r
+\r
+\r
+/* Private */\r
+errnum_t Set4_init_imp( Set4* self, size_t in_ElementSize, size_t FirstHeapSize );\r
+errnum_t Set4_finish2_imp2( Set4* self );\r
+errnum_t Set4_finish2_imp( Set4* self, errnum_t e, size_t in_ElementSize, FinalizeFuncType in_Type_Finalize );\r
+errnum_t Set4_alloc_imp( Set4* self, void* out_ElementPointer, size_t in_ElementSize );\r
+errnum_t Set4_free_imp( Set4* self, void* in_out_ElementPointer, size_t in_ElementSize, errnum_t e );\r
+void* Set4_ref_imp( Set4* self, int i, int size );\r
+int Set4_getCount_imp( Set4* self, int size );\r
+void Set4_forEach_imp2( Set4* self, Set4Iter* p, int size );\r
+\r
+\r
+ \r
+/**************************************************************************\r
+ <<< [ListClass] Linked List >>> \r
+***************************************************************************/\r
+typedef struct _ListClass ListClass;\r
+typedef struct _ListElementClass ListElementClass;\r
+typedef struct _ListIteratorClass ListIteratorClass;\r
+\r
+/*[ListElementClass]*/\r
+struct _ListElementClass { /* This struct can be menbers of Data */\r
+ void* Data; /* Element Data */\r
+ ListClass* List; /* NULL = Not in a list */\r
+ ListElementClass* Next;\r
+ ListElementClass* Previous;\r
+};\r
+\r
+struct _ListClass {\r
+ void* Data; /* List owner. ListClass does not set this */\r
+ ListElementClass Terminator;\r
+ int Count;\r
+};\r
+\r
+/*[ListIteratorClass]*/\r
+struct _ListIteratorClass {\r
+ ListElementClass* Element;\r
+ ListElementClass ModifiedElement;\r
+};\r
+\r
+ void ListClass_initConst( ListClass* self );\r
+inline errnum_t ListClass_add( ListClass* self, ListElementClass* Element ); /* addFirst */\r
+ errnum_t ListClass_addAtIndex( ListClass* self, int Index, ListElementClass* Element );\r
+inline errnum_t ListClass_addFirst( ListClass* self, ListElementClass* Element );\r
+inline errnum_t ListClass_addLast( ListClass* self, ListElementClass* Element );\r
+inline int ListClass_getCount( ListClass* self );\r
+inline errnum_t ListClass_getData( ListClass* self, int Index, void* out_Data );\r
+ errnum_t ListClass_get( ListClass* self, int Index, ListElementClass** out_Element );\r
+ errnum_t ListClass_set( ListClass* self, int Index, ListElementClass* Element );\r
+ errnum_t ListClass_replace( ListClass* self, ListElementClass* RemovingElement, ListElementClass* AddingElement );\r
+inline errnum_t ListClass_getFirstData( ListClass* self, void* out_Data );\r
+inline errnum_t ListClass_getLastData( ListClass* self, void* out_Data );\r
+inline errnum_t ListClass_getFirst( ListClass* self, ListElementClass** out_Element );\r
+inline errnum_t ListClass_getLast( ListClass* self, ListElementClass** out_Element );\r
+ int ListClass_getIndexOfData( ListClass* self, void* Data );\r
+ int ListClass_getIndexOf( ListClass* self, ListElementClass* Element );\r
+ int ListClass_getLastIndexOfData( ListClass* self, void* Data );\r
+ errnum_t ListClass_getArray( ListClass* self, void* DataArray, size_t DataArraySize );\r
+ errnum_t ListClass_removeByIndex( ListClass* self, int Index );\r
+ errnum_t ListClass_remove( ListClass* self, ListElementClass* Element );\r
+inline errnum_t ListClass_removeFirst( ListClass* self );\r
+inline errnum_t ListClass_removeLast( ListClass* self );\r
+ errnum_t ListClass_clear( ListClass* self );\r
+inline errnum_t ListClass_push( ListClass* self, ListElementClass* Element );\r
+inline void* ListClass_popData( ListClass* self );\r
+inline ListElementClass* ListClass_pop( ListClass* self );\r
+inline errnum_t ListClass_enqueue( ListClass* self, ListElementClass* Element );\r
+inline void* ListClass_dequeueData( ListClass* self );\r
+inline ListElementClass* ListClass_dequeue( ListClass* self );\r
+inline errnum_t ListClass_getListIterator( ListClass* self, ListIteratorClass* out_Iterator );\r
+inline errnum_t ListClass_getDescendingListIterator( ListClass* self, ListIteratorClass* out_Iterator );\r
+\r
+inline void ListElementClass_initConst( ListElementClass* self, void* Data );\r
+\r
+void* ListIteratorClass_getNext( ListIteratorClass* self );\r
+void* ListIteratorClass_getPrevious( ListIteratorClass* self );\r
+errnum_t ListIteratorClass_replace( ListIteratorClass* self, ListElementClass* AddingElement );\r
+errnum_t ListIteratorClass_remove( ListIteratorClass* self );\r
+\r
+\r
+\r
+/* Implements of ListClass */\r
+errnum_t ListClass_addAt_Sub( ListElementClass* AddingElement, ListElementClass* Target );\r
+\r
+\r
+/*[ListClass_add]*/\r
+inline errnum_t ListClass_add( ListClass* self, ListElementClass* Element )\r
+{\r
+ return ListClass_addFirst( self, Element );\r
+}\r
+\r
+\r
+/*[ListClass_addFirst]*/\r
+inline errnum_t ListClass_addFirst( ListClass* self, ListElementClass* Element )\r
+{\r
+ return ListClass_addAt_Sub( Element, self->Terminator.Next );\r
+}\r
+\r
+\r
+/*[ListClass_addLast]*/\r
+inline errnum_t ListClass_addLast( ListClass* self, ListElementClass* Element )\r
+{\r
+ return ListClass_addAt_Sub( Element, &self->Terminator );\r
+}\r
+\r
+\r
+/*[ListClass_getCount]*/\r
+inline int ListClass_getCount( ListClass* self )\r
+{\r
+ return self->Count;\r
+}\r
+\r
+\r
+/*[ListClass_getData]*/\r
+inline errnum_t ListClass_getData( ListClass* self, int Index, void* out_Data )\r
+{\r
+ errnum_t e;\r
+ ListElementClass* target;\r
+\r
+ e= ListClass_get( self, Index, &target );\r
+ if ( e == 0 )\r
+ { *(void**) out_Data = target->Data; }\r
+ return e;\r
+}\r
+\r
+\r
+/*[ListClass_getFirstData]*/\r
+inline errnum_t ListClass_getFirstData( ListClass* self, void* out_Data )\r
+{\r
+ if ( self->Count == 0 ) {\r
+ return E_NOT_FOUND_SYMBOL;\r
+ }\r
+ else {\r
+ *(void**) out_Data = self->Terminator.Next->Data;\r
+ return 0;\r
+ }\r
+}\r
+\r
+\r
+/*[ListClass_getLastData]*/\r
+inline errnum_t ListClass_getLastData( ListClass* self, void* out_Data )\r
+{\r
+ if ( self->Count == 0 ) {\r
+ return E_NOT_FOUND_SYMBOL;\r
+ }\r
+ else {\r
+ *(void**) out_Data = self->Terminator.Previous->Data;\r
+ return 0;\r
+ }\r
+}\r
+\r
+\r
+/*[ListClass_getFirst]*/\r
+inline errnum_t ListClass_getFirst( ListClass* self, ListElementClass** out_Element )\r
+{\r
+ if ( self->Count == 0 ) {\r
+ return E_NOT_FOUND_SYMBOL;\r
+ }\r
+ else {\r
+ *out_Element = self->Terminator.Next;\r
+ return 0;\r
+ }\r
+}\r
+\r
+\r
+/*[ListClass_getLast]*/\r
+inline errnum_t ListClass_getLast( ListClass* self, ListElementClass** out_Element )\r
+{\r
+ if ( self->Count == 0 ) {\r
+ return E_NOT_FOUND_SYMBOL;\r
+ }\r
+ else {\r
+ *out_Element = self->Terminator.Previous;\r
+ return 0;\r
+ }\r
+}\r
+\r
+\r
+/*[ListClass_isExistData]*/\r
+inline bool ListClass_isExistData( ListClass* self, void* Data )\r
+{\r
+ return ( ListClass_getIndexOfData( self, Data ) != INVALID_ARRAY_INDEX );\r
+}\r
+\r
+\r
+/*[ListClass_removeFirst]*/\r
+inline errnum_t ListClass_removeFirst( ListClass* self )\r
+{\r
+ if ( self->Count == 0 ) {\r
+ return E_NOT_FOUND_SYMBOL;\r
+ }\r
+ else {\r
+ return ListClass_remove( self, self->Terminator.Next );\r
+ }\r
+}\r
+\r
+\r
+/*[ListClass_removeLast]*/\r
+inline errnum_t ListClass_removeLast( ListClass* self )\r
+{\r
+ if ( self->Count == 0 ) {\r
+ return E_NOT_FOUND_SYMBOL;\r
+ }\r
+ else {\r
+ return ListClass_remove( self, self->Terminator.Previous );\r
+ }\r
+}\r
+\r
+\r
+/*[ListClass_push]*/\r
+inline errnum_t ListClass_push( ListClass* self, ListElementClass* Element )\r
+{\r
+ return ListClass_addFirst( self, Element );\r
+}\r
+\r
+\r
+/*[ListClass_popData]*/\r
+inline void* ListClass_popData( ListClass* self )\r
+{\r
+ if ( self->Count == 0 ) {\r
+ return NULL;\r
+ }\r
+ else {\r
+ ListElementClass* element = self->Terminator.Next;\r
+\r
+ ListClass_remove( self, element );\r
+ return element->Data;\r
+ }\r
+}\r
+\r
+\r
+/*[ListClass_pop]*/\r
+inline ListElementClass* ListClass_pop( ListClass* self )\r
+{\r
+ if ( self->Count == 0 ) {\r
+ return NULL;\r
+ }\r
+ else {\r
+ ListElementClass* element = self->Terminator.Next;\r
+\r
+ ListClass_remove( self, element );\r
+ return element;\r
+ }\r
+}\r
+\r
+\r
+/*[ListClass_enqueue]*/\r
+inline errnum_t ListClass_enqueue( ListClass* self, ListElementClass* Element )\r
+{\r
+ return ListClass_addLast( self, Element );\r
+}\r
+\r
+\r
+/*[ListClass_dequeueData]*/\r
+inline void* ListClass_dequeueData( ListClass* self )\r
+{\r
+ return ListClass_popData( self );\r
+}\r
+\r
+\r
+/*[ListClass_dequeue]*/\r
+inline ListElementClass* ListClass_dequeue( ListClass* self )\r
+{\r
+ return ListClass_pop( self );\r
+}\r
+\r
+\r
+/*[ListClass_getListIterator]*/\r
+inline errnum_t ListClass_getListIterator( ListClass* self, ListIteratorClass* out_Iterator )\r
+{\r
+ out_Iterator->Element = &self->Terminator;\r
+ out_Iterator->ModifiedElement.List = NULL;\r
+ return 0;\r
+}\r
+\r
+\r
+/*[ListClass_getDescendingListIterator]*/\r
+inline errnum_t ListClass_getDescendingListIterator( ListClass* self, ListIteratorClass* out_Iterator )\r
+{\r
+ out_Iterator->Element = &self->Terminator;\r
+ out_Iterator->ModifiedElement.List = NULL;\r
+ return 0;\r
+}\r
+\r
+\r
+/*[ListElementClass_initConst]*/\r
+inline void ListElementClass_initConst( ListElementClass* self, void* Data )\r
+{\r
+ self->Data = Data;\r
+ self->List = NULL;\r
+\r
+ #ifndef NDEBUG\r
+ self->Next = NULL;\r
+ self->Previous = NULL;\r
+ #endif\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [ListClass_forEach] >>> \r
+************************************************************************/\r
+#define ListClass_forEach( self, iterator, out_Element ) \\r
+ ListClass_forEach_1( self, iterator, out_Element ); \\r
+ ListClass_forEach_2( self, iterator, out_Element ); \\r
+ ListClass_forEach_3( self, iterator, out_Element )\r
+\r
+\r
+inline void ListClass_forEach_1( ListClass* self, ListIteratorClass* iterator, void* out_Element )\r
+{\r
+ ListClass_getListIterator( self, iterator );\r
+ *(void**) out_Element = ListIteratorClass_getNext( iterator );\r
+}\r
+\r
+\r
+inline bool ListClass_forEach_2( ListClass* self, ListIteratorClass* iterator, void* out_Element )\r
+{\r
+ UNREFERENCED_VARIABLE_2( self, iterator );\r
+ return ( *(void**) out_Element != NULL );\r
+}\r
+\r
+\r
+inline void ListClass_forEach_3( ListClass* self, ListIteratorClass* iterator, void* out_Element )\r
+{\r
+ UNREFERENCED_VARIABLE( self );\r
+ *(void**) out_Element = ListIteratorClass_getNext( iterator );\r
+}\r
+\r
+\r
+ \r
+/**************************************************************************\r
+ <<< [ListClass:ClassID] >>> \r
+***************************************************************************/\r
+errnum_t ListClass_finalizeWithVTable( ListClass* self, bool IsFreeElements, errnum_t e );\r
+errnum_t ListClass_printXML( ListClass* self, FILE* OutputStream );\r
+\r
+\r
+ \r
+/***********************************************************************\r
<<< [Variant_SuperClass] >>>\r
************************************************************************/\r
\r
************************************************************************/\r
typedef struct _VariantClass VariantClass;\r
\r
+struct _VariantClass {\r
+ Variant_SuperClass* Object;\r
+ ListElementClass ListElement;\r
+};\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [VariantListClass] >>>\r
+************************************************************************/\r
+typedef struct _VariantListIteratorClass VariantListIteratorClass;\r
+typedef struct _Variant_SuperClass Variant_SuperClass;\r
+typedef struct _VariantListIteratorClass VariantListIteratorClass;\r
+\r
+typedef struct _VariantListClass VariantListClass;\r
+struct _VariantListClass {\r
+ ListClass /*<VariantClass>*/ List;\r
+};\r
+\r
+void VariantListClass_initConst( VariantListClass* self );\r
+/* VariantListClass_initialize is not exist */\r
+errnum_t VariantListClass_finalize( VariantListClass* self, errnum_t e );\r
+\r
+errnum_t VariantListClass_createElement( VariantListClass* self,\r
+ void* /*<Variant_SuperClass**>*/ out_ElementObject,\r
+ const ClassID_Class* ClassID, void* Parameter );\r
+\r
+errnum_t VariantListClass_destroyElement( VariantListClass* self,\r
+ void* /*<Variant_SuperClass**>*/ in_out_ElementObject, errnum_t e );\r
+\r
+errnum_t VariantListClass_getListIterator( VariantListClass* self,\r
+ VariantListIteratorClass* out_Iterator );\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [VariantListIteratorClass] >>>\r
+************************************************************************/\r
+typedef struct _VariantListIteratorClass VariantListIteratorClass;\r
+struct _VariantListIteratorClass {\r
+ ListIteratorClass Iterator;\r
+};\r
+Variant_SuperClass* VariantListIteratorClass_getNext( VariantListIteratorClass* self );\r
+\r
+\r
+/*[VariantListClass_getListIterator]*/\r
+inline errnum_t VariantListClass_getListIterator( VariantListClass* self,\r
+ VariantListIteratorClass* out_Iterator )\r
+{\r
+ return ListClass_getListIterator( &self->List, &out_Iterator->Iterator );\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [VariantListClass_forEach] >>>\r
+************************************************************************/\r
+#define VariantListClass_forEach( self, Iterator, out_Pointer ) \\r
+ VariantListClass_forEach_Sub1( self, Iterator, out_Pointer ); \\r
+ *(out_Pointer) != NULL; \\r
+ VariantListClass_forEach_Sub3( Iterator, out_Pointer )\r
+\r
+inline void VariantListClass_forEach_Sub1( VariantListClass* self,\r
+ VariantListIteratorClass* Iterator, void* out_Pointer )\r
+{\r
+ VariantListClass_getListIterator( self, Iterator );\r
+ *(void**) out_Pointer = VariantListIteratorClass_getNext( Iterator );\r
+}\r
+\r
+inline void VariantListClass_forEach_Sub3( \\r
+ VariantListIteratorClass* Iterator, void* out_Pointer )\r
+{\r
+ *(void**) out_Pointer = VariantListIteratorClass_getNext( Iterator );\r
+}\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [PArray] >>> \r
+************************************************************************/\r
+typedef errnum_t (* CompareFuncType )( const void* ppLeft, const void* ppRight, const void* Param,\r
+ int* out_Result );\r
+\r
+int PArray_setFromArray( void* PointerArray, size_t PointerArraySize, void* out_ppRight,\r
+ void* SrcArray, size_t SrcArraySize, size_t SrcArrayElemSize );\r
+\r
+\r
+ \r
+errnum_t PArray_doShakerSort( const void* PointerArray, size_t PointerArraySize,\r
+ const void* ppLeft, const void* ppRight, CompareFuncType Compare, const void* Param );\r
+\r
+\r
+ \r
+errnum_t PArray_doBinarySearch( const void* PointerArray, size_t PointerArraySize,\r
+ const void* Key, CompareFuncType Compare, const void* Param,\r
+ int* out_FoundOrLeftIndex, int* out_CompareResult );\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [DictionaryAA_Class] Dictionary using AA tree >>> \r
+************************************************************************/\r
+typedef struct _DictionaryAA_Class DictionaryAA_Class;\r
+typedef struct _DictionaryAA_NodeClass DictionaryAA_NodeClass;\r
+\r
+struct _DictionaryAA_Class {\r
+ DictionaryAA_NodeClass* Root;\r
+};\r
+\r
+\r
+/*[DictionaryAA_TraverseFuncType]*/\r
+typedef errnum_t (* DictionaryAA_TraverseFuncType )(\r
+ DictionaryAA_NodeClass* Node, void* UserParameter );\r
+\r
+void DictionaryAA_Class_initConst( DictionaryAA_Class* self );\r
+errnum_t DictionaryAA_Class_finalize( DictionaryAA_Class* self, errnum_t e );\r
+errnum_t DictionaryAA_Class_finalize2( DictionaryAA_Class* self, errnum_t e,\r
+ bool in_IsFreeItem, FinalizeFuncType in_Type_Finalize );\r
+/*errnum_t DictionaryAA_Class_freeAllKeysHeap( DictionaryAA_Class* self, errnum_t e );*/\r
+\r
+errnum_t DictionaryAA_Class_insert( DictionaryAA_Class* self, const TCHAR* Key,\r
+ DictionaryAA_NodeClass** out_Node );\r
+errnum_t DictionaryAA_Class_remove( DictionaryAA_Class* self, const TCHAR* Key );\r
+errnum_t DictionaryAA_Class_search( DictionaryAA_Class* self, const TCHAR* Key,\r
+ DictionaryAA_NodeClass** out_Node );\r
+bool DictionaryAA_Class_isExist( DictionaryAA_Class* self, const TCHAR* Key );\r
+errnum_t DictionaryAA_Class_traverse( DictionaryAA_Class* self,\r
+ DictionaryAA_TraverseFuncType Function, void* UserParameter );\r
+errnum_t DictionaryAA_Class_toEmpty( DictionaryAA_Class* self );\r
+errnum_t DictionaryAA_Class_getArray( DictionaryAA_Class* self,\r
+ TCHAR*** in_out_Strings, int* in_out_StringCount, NewStringsEnum in_HowToAllocate );\r
+errnum_t DictionaryAA_Class_print( DictionaryAA_Class* self, FILE* OutputStream );\r
+\r
+\r
+/*[DictionaryAA_Class_forEach]*/\r
+#define DictionaryAA_Class_forEach( in_out_Iterator, out_Node ) \\r
+ *(out_Node) = DictionaryAA_IteratorClass_getNext( in_out_Iterator ); \\r
+ *(out_Node) != NULL; \\r
+ *(out_Node) = DictionaryAA_IteratorClass_getNext( in_out_Iterator )\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [DictionaryAA_NodeClass] >>> \r
+************************************************************************/\r
+struct _DictionaryAA_NodeClass {\r
+ void* Item; /* User defined */\r
+\r
+ const TCHAR* Key; /* This is had by DictionaryAA_Class */\r
+ int Height;\r
+ DictionaryAA_NodeClass* Left;\r
+ DictionaryAA_NodeClass* Right;\r
+};\r
+\r
+extern DictionaryAA_NodeClass g_DictionaryAA_NullNode;\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [DictionaryAA_IteratorClass] >>> \r
+************************************************************************/\r
+typedef struct _DictionaryAA_IteratorClass DictionaryAA_IteratorClass;\r
+struct _DictionaryAA_IteratorClass {\r
+ Set2 /*<DictionaryAA_NodeClass*>*/ Nodes;\r
+ DictionaryAA_NodeClass** NextNode;\r
+};\r
+\r
+void DictionaryAA_IteratorClass_initConst( DictionaryAA_IteratorClass* self );\r
+errnum_t DictionaryAA_IteratorClass_initialize( DictionaryAA_IteratorClass* self,\r
+ DictionaryAA_Class* Collection );\r
+errnum_t DictionaryAA_IteratorClass_finalize( DictionaryAA_IteratorClass* self, errnum_t e );\r
+\r
+DictionaryAA_NodeClass* DictionaryAA_IteratorClass_getNext(\r
+ DictionaryAA_IteratorClass* self );\r
+\r
+\r
+/*[DictionaryAA_IteratorClass_initConst]*/\r
+inline void DictionaryAA_IteratorClass_initConst( DictionaryAA_IteratorClass* self )\r
+{\r
+ Set2_initConst( &self->Nodes );\r
+}\r
+\r
+\r
+/*[DictionaryAA_IteratorClass_finalize]*/\r
+inline errnum_t DictionaryAA_IteratorClass_finalize( DictionaryAA_IteratorClass* self, errnum_t e )\r
+{\r
+ return Set2_finish( &self->Nodes, e );\r
+}\r
+\r
+\r
+ \r
+/*-------------------------------------------------------------------------*/\r
+/* <<<< ### (Set4) Class >>>> */ \r
+/*-------------------------------------------------------------------------*/\r
+\r
+\r
+ \r
+/****************************************************************\r
+ <<< [Set4_initConst] >>> \r
+*****************************************************************/\r
+#define Set4_initConst( self ) \\r
+ ( (self)->FirstBlock = NULL )\r
+\r
+ \r
+/****************************************************************\r
+ <<< [Set4_init] >>> \r
+*****************************************************************/\r
+#define Set4_init( self, type, HeapSize ) \\r
+ Set4_init_imp( self, sizeof(type), HeapSize )\r
+\r
+\r
+ \r
+/****************************************************************\r
+ <<< [Set4_finish] >>> \r
+*****************************************************************/\r
+#define Set4_finish( self, e, type, in_Type_Finalize ) \\r
+ ( (in_Type_Finalize) == NULL ? Set4_finish2_imp2( self ), e : \\r
+ ( Set4_finish2_imp( self, e, sizeof(type), in_Type_Finalize ), Set4_finish2_imp2( self ), e ) )\r
+\r
+\r
+ \r
+/****************************************************************\r
+ <<< [Set4_allocate] >>> \r
+*****************************************************************/\r
+#define Set4_allocate( self, out_ElementPointer ) \\r
+ Set4_alloc_imp( self, out_ElementPointer, sizeof(**(out_ElementPointer)) )\r
+\r
+\r
+ \r
+/****************************************************************\r
+ <<< [Set4_alloc] >>> \r
+*****************************************************************/\r
+#if 0\r
+#define Set4_alloc( self, pp, type ) \\r
+ Set4_alloc_imp( self, pp, sizeof(type) )\r
+#endif\r
+\r
+\r
+ \r
+/****************************************************************\r
+ <<< [Set4_free] >>> \r
+*****************************************************************/\r
+#define Set4_free( self, in_out_ElementPointer, e ) \\r
+ Set4_free_imp( self, in_out_ElementPointer, sizeof(**(in_out_ElementPointer)), e )\r
+\r
+\r
+ \r
+/****************************************************************\r
+ <<< [Set4_toEmpty] >>> \r
+*****************************************************************/\r
+#define Set4_toEmpty( self, type, type_finish ) \\r
+ ( Set4_finish2( self, type, type_finish ), \\r
+ (self)->FirstBlock = NULL, \\r
+ (self)->Next = (self)->CurrentBlockOver = &(self)->FirstBlock )\r
+\r
+\r
+ \r
+/****************************************************************\r
+ <<< [Set4_ref] >>> \r
+*****************************************************************/\r
+#define Set4_ref( self, i, type ) \\r
+ ( (type*) Set4_ref_imp( self, i, sizeof(type) ) )\r
+\r
+\r
+ \r
+/****************************************************************\r
+ <<< [Set4_getCount] >>> \r
+*****************************************************************/\r
+#define Set4_getCount( self, type ) \\r
+ Set4_getCount_imp( self, sizeof(type) )\r
+\r
+#if 0\r
+#define Set4_getN( self, type ) \\r
+ Set4_getCount_imp( self, sizeof(type) )\r
+#endif\r
+\r
+\r
+ \r
+/****************************************************************\r
+ <<< [Set4_forEach] >>> \r
+*****************************************************************/\r
+#define Set4_forEach( self, iter, ptr ) \\r
+ (iter)->p = NULL, Set4_forEach_imp2( self, iter, sizeof(**(ptr)) ); \\r
+ *(void**)(ptr) = (iter)->p, (iter)->p != NULL; \\r
+ Set4_forEach_imp2( self, iter, sizeof(**(ptr)) )\r
+\r
+#if 0\r
+#define Set4_forEach( self, iter, ptr, type ) \\r
+ (iter)->p = NULL, Set4_forEach_imp2( self, iter, sizeof(type) ); \\r
+ *(ptr) = (type*)(iter)->p, (iter)->p != NULL; \\r
+ Set4_forEach_imp2( self, iter, sizeof(type) )\r
+#endif\r
+\r
+#define Set4_forEach_imp( self, ptr, size ) \\r
+ (ptr)->p = NULL, Set4_forEach_imp2( self, ptr, size ); \\r
+ (ptr)->p != NULL; \\r
+ Set4_forEach_imp2( self, ptr, size )\r
+\r
+\r
+ \r
+/****************************************************************\r
+ <<< [Set4Iter_init] >>> \r
+*****************************************************************/\r
+#define Set4Iter_init( self, Set, pptr, type ) \\r
+ ( (self)->p = NULL, Set4_forEach_imp2( Set, self, sizeof(type) ), \\r
+ *(pptr) = (type*)((self)->p), ( (self)->p == NULL ? E_NO_NEXT : 0 ) )\r
+\r
+\r
+ \r
+/****************************************************************\r
+ <<< [Set4Iter_next] >>> \r
+*****************************************************************/\r
+#define Set4Iter_next( self, Set, pptr, type ) \\r
+ ( Set4_forEach_imp2( Set, self, sizeof(type) ), \\r
+ *(pptr) = (type*)((self)->p), ( (self)->p == NULL ? E_NO_NEXT : 0 ) )\r
+\r
+\r
+ \r
#ifdef __cplusplus\r
} /* End of C Symbol */ \r
#endif\r
#endif\r
\r
\r
-#ifndef NDEBUG\r
- #define NDEBUG_ERROR\r
-#else\r
- #define NDEBUG_ERROR ___cut_NDEBUG_ERROR\r
-#endif\r
+#ifndef NDEBUG\r
+ #define NDEBUG_ERROR\r
+#else\r
+ #define NDEBUG_ERROR ___cut_NDEBUG_ERROR\r
+#endif\r
+\r
+ \r
+/**************************************************************************\r
+ <<< [DebugTools] >>> \r
+***************************************************************************/\r
+#ifndef NDEBUG\r
+ #define DEBUGTOOLS_USES 1\r
+#else\r
+ #define DEBUGTOOLS_USES 0\r
+#endif\r
+\r
+\r
+#if DEBUGTOOLS_USES\r
+typedef struct _DebugTools DebugTools;\r
+struct _DebugTools {\r
+ int m_BreakID;\r
+ int m_DisableBreakExceptID_plus1;\r
+ int m_ReturnValueOnBreak_minus1;\r
+ TCHAR* m_BreakByFName;\r
+};\r
+int Debug_setReturnValueOnBreak( int ID );\r
+int Debug_disableBreak( int iExceptID );\r
+int Debug_setBreakByFName( const TCHAR* Path );\r
+int Debug_onOpen( const TCHAR* Path );\r
+#endif\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [HeapLogClass] >>> \r
+************************************************************************/\r
+void HeapLogClass_log( void* in_Address, size_t in_Size );\r
+int HeapLogClass_getID( const void* in_Address );\r
+void HeapLogClass_printID( const void* in_Address );\r
+void HeapLogClass_addWatch( int in_IndexNum, int in_AllocatedID, ptrdiff_t in_Offset,\r
+ uint32_t in_BreakValue, bool in_IsPrintf );\r
+void HeapLogClass_watch( int in_IndexNum );\r
+void* HeapLogClass_getWatchingAddress( int in_IndexNum );\r
+void HeapLogClass_finalize(void);\r
+\r
+enum { HeapLogClass_NotAllocatedID = -1 };\r
+\r
+\r
+ \r
+/**************************************************************************\r
+ <<< [g_DebugVar] >>> \r
+***************************************************************************/\r
+extern int g_DebugVar[10];\r
+\r
\r
\r
/*[dll_global_g_DebugBreakCount]*/\r
\r
errnum_t StrT_cpy( TCHAR* Dst, size_t DstSize, const TCHAR* Src );\r
errnum_t StrT_cat( TCHAR* Dst, size_t DstSize, const TCHAR* Src );\r
+TCHAR* StrT_chr( const TCHAR* String, TCHAR Key );\r
TCHAR* StrT_chrs( const TCHAR* s, const TCHAR* keys );\r
TCHAR* StrT_rstr( const TCHAR* String, const TCHAR* SearchStart, const TCHAR* Keyword,\r
void* NullConfig );\r
+TCHAR* StrT_chrNext( const TCHAR* in_Start, TCHAR in_KeyCharactor );\r
TCHAR* StrT_skip( const TCHAR* s, const TCHAR* keys );\r
TCHAR* StrT_rskip( const TCHAR* String, const TCHAR* SearchStart, const TCHAR* Keys,\r
void* NullConfig );\r
bool StrT_isCIdentifier( TCHAR Character );\r
TCHAR* StrT_searchOverOfCIdentifier( const TCHAR* Text );\r
+TCHAR* StrT_searchOverOfIdiom( const TCHAR* Text );\r
int StrT_cmp_part( const TCHAR* StringA_Start, const TCHAR* StringA_Over,\r
const TCHAR* StringB );\r
+int StrT_cmp_i_part( const TCHAR* StringA_Start, const TCHAR* StringA_Over,\r
+ const TCHAR* StringB );\r
int StrT_cmp_part2( const TCHAR* StringA_Start, const TCHAR* StringA_Over,\r
const TCHAR* StringB_Start, const TCHAR* StringB_Over );\r
#define TwoChar8( Character1, Character2 ) \\r
\r
\r
\r
+int StrT_searchPartStringIndex( const TCHAR* in_String, const TCHAR* in_StringOver,\r
+ const TCHAR** in_StringsArray, uint_fast32_t in_StringsArrayLength,\r
+ int in_DefaultIndex );\r
+ \r
+int StrT_searchPartStringIndexI( const TCHAR* in_String, const TCHAR* in_StringOver,\r
+ const TCHAR** in_StringsArray, uint_fast32_t in_StringsArrayLength,\r
+ int in_DefaultIndex );\r
+ \r
errnum_t StrT_convStrToId( const TCHAR* str, const TCHAR** strs, const int* ids, int n, int default_id ); \r
errnum_t StrT_convStrLeftToId( const TCHAR* Str, const TCHAR** Strs, const size_t* Lens, const int* Ids,\r
int CountOfStrs, TCHAR* Separeters, int DefaultId, TCHAR** out_PosOfLastOfStr );\r
#define MallocAndCopyString_char MallocAndCopyString\r
#endif\r
\r
+errnum_t StrHS_insert( TCHAR** in_out_WholeString,\r
+ int in_TargetIndexInWholeString, int* out_NextWholeInWholeString,\r
+ const TCHAR* in_InsertString );\r
+errnum_t StrHS_printf( TCHAR** in_out_String, const TCHAR* in_Format, ... );\r
+errnum_t StrHS_printfV( TCHAR** in_out_String, const TCHAR* in_Format, va_list in_VaList );\r
+errnum_t StrHS_printfPart( TCHAR** in_out_String,\r
+ int in_IndexInString, int* out_NextIndexInString,\r
+ const TCHAR* in_Format, ... );\r
+errnum_t StrHS_printfPartV( TCHAR** in_out_String,\r
+ int in_IndexInString, int* out_NextIndexInString,\r
+ const TCHAR* in_Format, va_list in_VaList );\r
+\r
+\r
\r
/***********************************************************************\r
<<< [StrT_Edit] >>> \r
************************************************************************/\r
+errnum_t StrT_cutPart( TCHAR* in_out_String, TCHAR* in_StartOfCut, TCHAR* in_OverOfCut );\r
errnum_t StrT_trim( TCHAR* out_Str, size_t out_Str_Size, const TCHAR* in_Str );\r
errnum_t StrT_cutLastOf( TCHAR* in_out_Str, TCHAR Charactor );\r
errnum_t StrT_cutLineComment( TCHAR* out_Str, size_t out_Str_Size, const TCHAR* in_Str, const TCHAR* CommentSign );\r
+errnum_t StrT_insert( TCHAR* in_out_WholeString, size_t in_MaxSize_of_WholeString,\r
+ TCHAR* in_out_Target_in_WholeString, TCHAR** out_NextTarget_in_WholeString,\r
+ const TCHAR* in_InsertString );\r
errnum_t StrT_meltCmdLine( TCHAR* out_Str, size_t out_Str_Size, const TCHAR** pLine );\r
errnum_t StrT_getExistSymbols( unsigned* out, bool bCase, const TCHAR* Str, const TCHAR* Symbols, ... );\r
errnum_t StrT_replace1( TCHAR* in_out_String, TCHAR FromCharacter, TCHAR ToCharacter,\r
\r
\r
/***********************************************************************\r
+ <<< [StrT_Edit2] >>> \r
+************************************************************************/\r
+errnum_t StrT_replace( TCHAR* Out, size_t OutSize, const TCHAR* In,\r
+ const TCHAR* FromStr, const TCHAR* ToStr, unsigned Opt );\r
+errnum_t StrT_changeToXML_Attribute( TCHAR* out_Str, size_t StrSize, const TCHAR* InputStr );\r
+errnum_t StrT_resumeFromXML_Attribute( TCHAR* out_Str, size_t out_Str_Size, const TCHAR* XML_Attr );\r
+errnum_t StrT_changeToXML_Text( TCHAR* out_Str, size_t StrSize, const TCHAR* InputStr );\r
+\r
+enum { STR_1TIME = 1 };\r
+\r
+\r
+ \r
+/***********************************************************************\r
<<< [W3CDTF] >>> \r
************************************************************************/\r
enum { W3CDTF_MAX_LENGTH = 27+3 }; /* \8f¬\90\943\8c\85 */\r
enum { MAX_LOCAL_PATH = 4096 };\r
TCHAR* StrT_refFName( const TCHAR* s );\r
TCHAR* StrT_refExt( const TCHAR* s );\r
+void StrT_cutFragmentInPath( TCHAR* in_out_Path );\r
bool StrT_isFullPath( const TCHAR* s );\r
\r
errnum_t StrT_getFullPath_part( TCHAR* Str, size_t StrSize, TCHAR* StrStart,\r
TCHAR** out_StrLast, const TCHAR* SrcPath );\r
errnum_t StrT_addLastOfFileName( TCHAR* out_Path, size_t PathSize,\r
const TCHAR* BasePath, const TCHAR* AddName );\r
+errnum_t StrT_encodeToValidPath( TCHAR* out_Path, size_t in_OutPathSize, const TCHAR* in_Path, bool in_IsName );\r
\r
inline errnum_t StrT_getFullPath( TCHAR* out_FullPath, size_t FullPathSize,\r
const TCHAR* StepPath, const TCHAR* BasePath )\r
***************************************************************************/\r
typedef struct _Strs Strs;\r
struct _Strs {\r
- char* MemoryAddress; /* first memory = [ TCHAR* FirstStr | elem[] ], other memory = [ elem[] ] */\r
- char* MemoryOver;\r
- char* NextElem; /* elem = [ TCHAR* NextStr | TCHAR[] ] */\r
- TCHAR** PointerToNextStrInPrevElem; /* first = &FirstStr, other = &NextStr */\r
- TCHAR** Prev_PointerToNextStrInPrevElem;\r
+ byte_t* MemoryAddress; /* first memory = [ TCHAR* FirstStr | elem[] ], other memory = [ elem[] ] */\r
+ byte_t* MemoryOver;\r
+ byte_t* NextElem; /* elem = [ TCHAR* NextStr | TCHAR[] ] */\r
+ TCHAR** PointerToNextStrInPrevElem; /* first = &FirstStr, other = &NextStr */\r
+ TCHAR** Prev_PointerToNextStrInPrevElem;\r
\r
Strs* FirstOfStrs;\r
Strs* NextStrs;\r
( *( (TCHAR**)(p) - 1 ) )\r
\r
#define Strs_getFreeAddr( m ) ( (TCHAR*)( (m)->NextElem + sizeof(TCHAR*) ) )\r
-#define Strs_getFreeSize( m ) ( (m)->MemoryOver - (char*)(m)->NextElem - sizeof(TCHAR*) )\r
+#define Strs_getFreeSize( m ) ( (m)->MemoryOver - (byte_t*)(m)->NextElem - sizeof(TCHAR*) )\r
#define Strs_getFreeCount( m ) ( Strs_getFreeSize( m ) / sizeof(TCHAR) )\r
#define Strs_expandCount( m, c ) ( Strs_expandSize( (m), (c) * sizeof(TCHAR) ) )\r
errnum_t Strs_expandSize( Strs* m, size_t FreeSize );\r
errnum_t Strs_commit( Strs* m, TCHAR* StrOver );\r
+errnum_t Strs_allocateArray( Strs* self, TCHAR*** out_PointerArray, int* out_Count );\r
+\r
\r
\r
/***********************************************************************\r
\r
\r
\r
+/***********************************************************************\r
+ <<< [StrFile] Read Class >>> \r
+************************************************************************/\r
+ \r
+typedef struct _StrFile StrFile;\r
+struct _StrFile {\r
+ void* Buffer;\r
+ size_t BufferSize;\r
+ bool IsBufferInHeap;\r
+ bool IsTextMode;\r
+ int OffsetToHeapBlockFirst;\r
+ int CharSize;\r
+ void* Pointer; // (void*)0xFFFFFFFF = EOF\r
+};\r
+\r
+#define StrFile StrFile_BlackBox\r
+ \r
+typedef struct _StrFile_BlackBox StrFile;\r
+struct _StrFile_BlackBox {\r
+ uint8_t BlackBox[24];\r
+};\r
+ \r
+#undef StrFile\r
+static_assert_global( sizeof(StrFile) == sizeof(StrFile_BlackBox), "" );\r
+ \r
+enum {\r
+ STR_FILE_READ = 0,\r
+\r
+ STR_FILE_CHAR = 0x00,\r
+ STR_FILE_WCHAR = 0x10,\r
+#ifdef _UNICODE\r
+ STR_FILE_TCHAR = 0x10,\r
+#else\r
+ STR_FILE_TCHAR = 0x00,\r
+#endif\r
+\r
+ STR_FILE_TEXT = 0x00,\r
+ STR_FILE_BINARY = 0x01,\r
+};\r
+\r
+void StrFile_initConst( StrFile* self );\r
+errnum_t StrFile_init_fromStr( StrFile* self, TCHAR* LinkStr );\r
+errnum_t StrFile_init_fromSizedStructInStream( StrFile* self, HANDLE* Stream );\r
+errnum_t StrFile_init_withBuf( StrFile* self, void* LinkBuffer, size_t LinkBufferSize, int Flags );\r
+errnum_t StrFile_finish( StrFile* self, errnum_t e );\r
+errnum_t StrFile_isInited( StrFile* self );\r
+\r
+errnum_t StrFile_readLine( StrFile* self, TCHAR* out_Line, size_t LineSize );\r
+bool StrFile_isAtEndOfStream( StrFile* self );\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [StrFile] Write Class >>> \r
+************************************************************************/\r
+\r
+errnum_t StrFile_init_toHeap( StrFile* self, int Flags );\r
+errnum_t StrFile_write( StrFile* self, const TCHAR* Text );\r
+errnum_t StrFile_writeBinary( StrFile* self, const void* Data, size_t DataSize );\r
+errnum_t StrFile_expandIfOver( StrFile* self, size_t DataSize );\r
+errnum_t StrFile_peekWrittenString( StrFile* self, TCHAR** out_String );\r
+errnum_t StrFile_peekWrittenStringW( StrFile* self, wchar_t** out_String );\r
+errnum_t StrFile_peekWrittenStringA( StrFile* self, char** out_String );\r
+errnum_t StrFile_pickupSizedStruct( StrFile* m, SizedStruct** out_Struct );\r
+errnum_t StrFile_moveSizedStructToStream( StrFile* self, HANDLE Stream );\r
+errnum_t StrFile_setPointer( StrFile* self, int OffsetOfPointer );\r
+errnum_t StrFile_getPointer( StrFile* self, int* out_OffsetOfPointer );\r
+\r
+\r
+#ifdef _UNICODE\r
+#define StrFile_peekWrittenString StrFile_peekWrittenStringW\r
+#else\r
+#define StrFile_peekWrittenString StrFile_peekWrittenStringA\r
+#endif\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [SearchStringByBM_Class] >>> \r
+************************************************************************/\r
+typedef struct _SearchStringByBM_Class SearchStringByBM_Class;\r
+struct _SearchStringByBM_Class {\r
+ const TCHAR* TextString;\r
+ int TextStringLength;\r
+ const TCHAR* Keyword;\r
+ int KeywordLastIndex;\r
+ int KeywordLastPosition; /* Index of TextString */\r
+ int* SkipArray;\r
+ TCHAR SkipArray_MinCharacter;\r
+ TCHAR SkipArray_MaxCharacter;\r
+};\r
+\r
+void SearchStringByBM_Class_initConst( SearchStringByBM_Class* self );\r
+errnum_t SearchStringByBM_Class_initialize( SearchStringByBM_Class* self,\r
+ const TCHAR* TextString, const TCHAR* Keyword );\r
+errnum_t SearchStringByBM_Class_initializeFromPart( SearchStringByBM_Class* self,\r
+ const TCHAR* TextString, size_t TextString_Length, const TCHAR* Keyword );\r
+errnum_t SearchStringByBM_Class_finalize( SearchStringByBM_Class* self, errnum_t e );\r
+errnum_t SearchStringByBM_Class_search( SearchStringByBM_Class* self, int* out_KeywordIndex );\r
+\r
+\r
+enum { SearchString_NotFound = -1 }; /*[SearchString_NotFound]*/\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [SearchStringByAC_Class] >>> \r
+************************************************************************/\r
+enum { SearchStringByAC_Fail = 0 }; /*[SearchStringByAC_Fail]*/\r
+enum { SearchStringByAC_RootState = 0 }; /*[SearchStringByAC_RootState]*/\r
+#if 0\r
+enum { SearchStringByAC_MaxCharacterCode = 0xFFFF }; /*[SearchStringByAC_MaxCharacterCode]*/\r
+#else\r
+enum { SearchStringByAC_MaxCharacterCode = 0xFF }; /*[SearchStringByAC_MaxCharacterCode]*/\r
+#endif\r
+typedef int16_t (* AC_GotoFunctionType )[ SearchStringByAC_MaxCharacterCode + 1 ];\r
+ /* Array of next_state[state][character] */\r
+\r
+typedef struct _SearchStringByAC_Class SearchStringByAC_Class;\r
+struct _SearchStringByAC_Class {\r
+ int StateNum;\r
+ const TCHAR* TextString;\r
+ unsigned TextStringLength;\r
+ int TextStringIndex;\r
+ const TCHAR** FoundKeywords;\r
+ int FoundKeywordsCount;\r
+ int FoundKeywordIndex;\r
+\r
+ Set2 GoToFunction; /* <AC_GotoFunctionType> Next state[ state ][ character ] */\r
+ int* FailureFunction; /* Next state[ state ] */\r
+ const TCHAR*** OutputFunction; /* TCHAR* OutputFunction.Keyword[ state ][ count ] */\r
+ int* OutputCount; /* int OutputFunction.Count[ state ] */\r
+ int16_t StateCount; /* newstate + 1 */\r
+};\r
+\r
+void SearchStringByAC_Class_initConst( SearchStringByAC_Class* self );\r
+errnum_t SearchStringByAC_Class_initialize( SearchStringByAC_Class* self,\r
+ const TCHAR* TextString, const TCHAR** KeywordArray, size_t KeywordArrayCount );\r
+errnum_t SearchStringByAC_Class_initializeFromPart( SearchStringByAC_Class* self,\r
+ const TCHAR* TextString, size_t TextString_Length,\r
+ const TCHAR** KeywordArray, size_t KeywordArrayCount );\r
+errnum_t SearchStringByAC_Class_finalize( SearchStringByAC_Class* self, errnum_t e );\r
+errnum_t SearchStringByAC_Class_search( SearchStringByAC_Class* self,\r
+ int* out_TextStringIndex, TCHAR** out_Keyword );\r
+errnum_t SearchStringByAC_Class_setTextString( SearchStringByAC_Class* self,\r
+ const TCHAR* TextString );\r
+errnum_t SearchStringByAC_Class_setTextStringFromPart( SearchStringByAC_Class* self,\r
+ const TCHAR* TextString, size_t TextString_Length );\r
+inline const TCHAR* SearchStringByAC_Class_getTextString( SearchStringByAC_Class* self )\r
+ { return self->TextString; }\r
+\r
+\r
+ \r
#if __cplusplus\r
} /* End of C Symbol */ \r
#endif\r
\r
#endif\r
\r
+#ifndef NDEBUG\r
+ #define ERR2_ENABLE_ERROR_LOG 1\r
+#else\r
+ #define ERR2_ENABLE_ERROR_LOG 0\r
+#endif\r
+\r
/*[dll_global_g_Error]*/\r
#ifndef dll_global_g_Error\r
#define dll_global_g_Error\r
\r
\r
/***********************************************************************\r
+ <<< [stdio] >>> \r
+************************************************************************/\r
+void Error4_showToStdErr( int err_num );\r
+void Error4_showToStdIO( FILE* out, int err_num );\r
+\r
+\r
+ \r
+/***********************************************************************\r
<<< [DEBUG_TRUE, DEBUG_FALSE] >>> \r
************************************************************************/\r
#if ! NDEBUG\r
#endif\r
\r
/*=================================================================*/\r
+/* <<< [Expat/Expat_incude.h] >>> */ \r
+/*=================================================================*/\r
+ \r
+#ifndef __EXPAT_H\r
+#define __EXPAT_H\r
+\r
+#define XML_STATIC /* [SETTING] define or not define. if not define, deploy libexpat(w).dll */\r
+\r
+\r
+// reference: README.txt : * Special note about MS VC++ and runtime libraries\r
+#if _UNICODE\r
+ #define XML_UNICODE_WCHAR_T\r
+ #if defined(XML_STATIC)\r
+ #if _MT\r
+ #if _DLL // Visual C++ /MD option, MSVCP**.DLL\r
+ #pragma comment(lib, "libexpatwMD.lib") // not supplied\r
+ #else // Visual C++ /MT option\r
+\r
+ #pragma comment(lib, "libexpatwMT.lib")\r
+\r
+ #ifndef NDEBUG\r
+ #pragma comment(linker,"/NODEFAULTLIB:LIBCMT" )\r
+ #endif\r
+ #endif\r
+ #else\r
+ #pragma comment(lib, "libexpatwML.lib") // not supplied\r
+ #endif\r
+ #else // DLL version\r
+\r
+ #pragma comment(lib, "libexpatw.lib") // libexpatw.dll, including multi thread static runtime library\r
+\r
+ #endif\r
+#else\r
+ #if defined(XML_STATIC)\r
+ #if _MT\r
+ #if _DLL // Visual C++ /MD option, MSVCP**.DLL\r
+ #pragma comment(lib, "libexpatMD.lib") // not supplied\r
+ #else // Visual C++ /MT option\r
+\r
+ #pragma comment(lib, "libexpatMT.lib")\r
+\r
+ #ifndef NDEBUG\r
+ # pragma comment(linker,"/NODEFAULTLIB:LIBCMT" )\r
+ #endif\r
+ #endif\r
+ #else\r
+ #pragma comment(lib, "libexpatML.lib") // not supplied\r
+ #endif\r
+ #else // DLL version\r
+\r
+ #pragma comment(lib, "libexpat.lib") // libexpat.dll, including multi thread static runtime library\r
+\r
+ #endif\r
+#endif\r
+\r
+#include <expat.h> \r
+\r
+\r
+#endif\r
+ \r
+/*=================================================================*/\r
/* <<< [FileT/FileT.h] >>> */ \r
/*=================================================================*/\r
\r
/***********************************************************************\r
<<< [FileT_Write] >>> \r
************************************************************************/\r
-int FileT_openForWrite( FILE** out_pFile, const TCHAR* Path, int Flags );\r
+int FileT_openForWrite( FILE** out_pFile, const TCHAR* Path, bit_flags_fast32_t Flags );\r
\r
enum { F_Unicode = 1, F_Append = 2 };\r
\r
\r
\r
/***********************************************************************\r
+ <<< [FileT_WinAPI] >>> \r
+************************************************************************/\r
+int FileT_readSizedStruct_WinAPI( HANDLE* Stream, void** out_SizedStruct );\r
+int FileT_writeSizedStruct_WinAPI( HANDLE* Stream, SizedStruct* OutputSizedStruct );\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [FileFormatEnum] >>> \r
+************************************************************************/\r
+typedef enum {\r
+ FILE_FORMAT_NOT_EXIST = 0, /* File does not exist */\r
+ FILE_FORMAT_NO_BOM = 1,\r
+ FILE_FORMAT_UNICODE = 2,\r
+ FILE_FORMAT_UTF_8 = 3,\r
+} FileFormatEnum;\r
+\r
+\r
+ \r
+/***********************************************************************\r
+* Function: FileT_readUnicodeFileBOM\r
+************************************************************************/\r
+errnum_t FileT_readUnicodeFileBOM( const TCHAR* Path, FileFormatEnum* out_Format );\r
+\r
+\r
+ \r
+/***********************************************************************\r
+* Function: FileT_cutFFFE\r
+************************************************************************/\r
+errnum_t FileT_cutFFFE( const TCHAR* in_InputPath, const TCHAR* in_OutputPath, bool in_IsAppend );\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [ParseXML2] >>>\r
+************************************************************************/\r
+typedef struct _ParseXML2_ConfigClass ParseXML2_ConfigClass;\r
+typedef struct _ParseXML2_StatusClass ParseXML2_StatusClass;\r
+typedef errnum_t (* ParseXML2_CallbackType )( ParseXML2_StatusClass* Status );\r
+\r
+struct _ParseXML2_ConfigClass {\r
+ BitField Flags; /* F_ParseXML2_Delegate | F_ParseXML2_OnStartElement ... */\r
+ void* Delegate; /* Flags|= F_ParseXML2_Delegate, if enabled */\r
+ ParseXML2_CallbackType OnStartElement; /* Flags|= F_ParseXML2_OnStartElement, if enabled */\r
+ ParseXML2_CallbackType OnEndElement; /* Flags|= F_ParseXML2_OnEndElement, if enabled */\r
+ ParseXML2_CallbackType OnText; /* Flags|= F_ParseXML2_OnText, if enabled */\r
+};\r
+enum {\r
+ F_ParseXML2_Delegate = 0x0001,\r
+ F_ParseXML2_OnStartElement = 0x0004,\r
+ F_ParseXML2_OnEndElement = 0x0008,\r
+ F_ParseXML2_OnText = 0x0010,\r
+};\r
+\r
+struct _ParseXML2_StatusClass {\r
+ void* Delegate;\r
+ int LineNum;\r
+ int Depth; /* Root XML element is 0 */\r
+ int PreviousCallbackType; /* e.g.) F_ParseXML2_OnStartElement. Initial value is 0 */\r
+\r
+ TCHAR* XPath;\r
+ TCHAR* TagName;\r
+ union {\r
+ struct {\r
+ const XML_Char** Attributes; /* for ParseXML2_StatusClass_getAttribute */\r
+ } OnStartElement;\r
+\r
+ struct { /* for ParseXML2_StatusClass_mallocCopyText */\r
+ const TCHAR* Text; /* not NULL terminated */\r
+ int TextLength;\r
+ } OnText;\r
+ } u;\r
+};\r
+\r
+errnum_t ParseXML2( const TCHAR* XML_Path, ParseXML2_ConfigClass* in_out_Config );\r
+errnum_t ParseXML2_StatusClass_getAttribute( ParseXML2_StatusClass* self,\r
+ const TCHAR* AttributeName, TCHAR** out_AttribyteValue );\r
+errnum_t ParseXML2_StatusClass_mallocCopyText( ParseXML2_StatusClass* self,\r
+ TCHAR** out_Text );\r
+\r
+enum { E_XML_PARSER = 0x3101 };\r
+\r
+\r
+ \r
+/***********************************************************************\r
<<< [Writables] >>> \r
************************************************************************/\r
#ifndef Uses_AppKey\r
typedef struct _Writables Writables;\r
\r
errnum_t AppKey_newWritable( AppKey** in_out_m, Writables** out_Writable, ... );\r
+errnum_t AppKey_newWritable_byArray( AppKey** in_out_m, Writables** out_Writable,\r
+ TCHAR** in_Paths, int in_PathCount );\r
void AppKey_initGlobal_const(void);\r
errnum_t AppKey_finishGlobal( errnum_t e );\r
errnum_t AppKey_addNewWritableFolder( const TCHAR* Path );\r
+errnum_t AppKey_addWritableFolder( AppKey* m, const TCHAR* Path );\r
errnum_t AppKey_checkWritable( const TCHAR* Path );\r
\r
\r
\r
errnum_t Writables_delete( Writables* m, errnum_t e );\r
\r
-errnum_t Writables_add( Writables* m, AppKey* Key, TCHAR* Path );\r
-errnum_t Writables_remove( Writables* m, TCHAR* Path );\r
+errnum_t Writables_add( Writables* m, AppKey* Key, const TCHAR* Path );\r
+errnum_t Writables_remove( Writables* m, const TCHAR* Path );\r
\r
errnum_t Writables_enable( Writables* m );\r
errnum_t Writables_disable( Writables* m, errnum_t e );\r
#endif\r
\r
/*=================================================================*/\r
+/* <<< [IniFile2/IniFile2.h] >>> */ \r
+/*=================================================================*/\r
+ \r
+#if __cplusplus\r
+ extern "C" { /* Start of C Symbol */ \r
+#endif\r
+ \r
+bool IniStr_isLeft( const TCHAR* line, const TCHAR* symbol ); \r
+ \r
+TCHAR* IniStr_refRight( const TCHAR* line, bool bTrimRight ); \r
+ \r
+#if __cplusplus\r
+ } /* End of C Symbol */ \r
+#endif\r
+\r
+ \r
+/*=================================================================*/\r
/* <<< [Locale/Locale.h] >>> */ \r
/*=================================================================*/\r
\r
\r
\r
\r
+/***********************************************************************\r
+ <<< [FileTime] >>> \r
+************************************************************************/\r
+\r
+#define FILETIME_addDays( pAnsTime, pBaseTime, plus ) \\r
+ ( *(ULONGLONG*)(pAnsTime) = *(ULONGLONG*)(pBaseTime) \\r
+ + (plus) * ((LONGLONG)(24*60*60)*(1000*1000*10)) )\r
+\r
+#define FILETIME_addHours( pAnsTime, pBaseTime, plus ) \\r
+ ( *(ULONGLONG*)(pAnsTime) = *(ULONGLONG*)(pBaseTime) \\r
+ + (plus) * ((LONGLONG)(60*60)*(1000*1000*10)) )\r
+\r
+#define FILETIME_addMinutes( pAnsTime, pBaseTime, plus ) \\r
+ ( *(ULONGLONG*)(pAnsTime) = *(ULONGLONG*)(pBaseTime) \\r
+ + (plus) * ((LONGLONG)(60)*(1000*1000*10)) )\r
+\r
+#define FILETIME_addSeconds( pAnsTime, pBaseTime, plus ) \\r
+ ( *(ULONGLONG*)(pAnsTime) = *(ULONGLONG*)(pBaseTime) \\r
+ + (plus) * ((LONGLONG)(1000*1000*10)) )\r
+\r
+#define FILETIME_sub( pLeftTime, pRightTime ) \\r
+ ( *(ULONGLONG*)(pLeftTime) - *(ULONGLONG*)(pRightTime) )\r
+\r
+\r
+ \r
#if __cplusplus\r
} /* End of C Symbol */ \r
#endif\r
\r
\r
/***********************************************************************\r
+ <<< [LineNumberIndexClass] >>> \r
+************************************************************************/\r
+typedef struct _LineNumberIndexClass LineNumberIndexClass;\r
+struct _LineNumberIndexClass {\r
+ Set2 /*<const TCHAR*>*/ LeftsOfLine;\r
+};\r
+\r
+void LineNumberIndexClass_initConst( LineNumberIndexClass* self );\r
+errnum_t LineNumberIndexClass_initialize( LineNumberIndexClass* self, const TCHAR* Text );\r
+errnum_t LineNumberIndexClass_finalize( LineNumberIndexClass* self, errnum_t e );\r
+errnum_t LineNumberIndexClass_searchLineNumber( LineNumberIndexClass* self, const TCHAR* Position,\r
+ int* out_LineNumber );\r
+int LineNumberIndexClass_getCountOfLines( LineNumberIndexClass* self );\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [SyntaxSubNodeClass] >>> \r
+************************************************************************/\r
+typedef struct _SyntaxSubNodeClass_IDClass SyntaxSubNodeClass_IDClass;\r
+typedef struct _SyntaxNodeClass SyntaxNodeClass;\r
+\r
+\r
+typedef struct _SyntaxSubNodeClass SyntaxSubNodeClass;\r
+struct _SyntaxSubNodeClass {\r
+\r
+ /* <Inherit parent="ParsedRangeClass"> */\r
+ const ClassID_Class* ClassID;\r
+ const FinalizerVTableClass* FinalizerVTable;\r
+ const TCHAR* Start;\r
+ const TCHAR* Over;\r
+ /* </Inherit> */\r
+\r
+ const PrintXML_VTableClass* PrintXML_VTable;\r
+ SyntaxNodeClass* Parent;\r
+ ListElementClass SubNodeListElement; /* for ".Parent" */\r
+};\r
+\r
+extern const ClassID_Class g_SyntaxSubNodeClass_ID;\r
+errnum_t SyntaxSubNodeClass_printXML( SyntaxSubNodeClass* self, FILE* OutputStream );\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [SyntaxNodeClass] >>> \r
+************************************************************************/\r
+typedef struct _SyntaxNodeClass_IDClass SyntaxNodeClass_IDClass;\r
+\r
+typedef struct _SyntaxNodeClass SyntaxNodeClass;\r
+struct _SyntaxNodeClass {\r
+\r
+ /* <Inherit parent="SyntaxSubNodeClass"> */\r
+ const ClassID_Class* ClassID;\r
+ const FinalizerVTableClass* FinalizerVTable;\r
+ const TCHAR* Start;\r
+ const TCHAR* Over;\r
+ const PrintXML_VTableClass* PrintXML_VTable;\r
+ SyntaxNodeClass* Parent;\r
+ ListElementClass SubNodeListElement; /* for ".Parent" */\r
+ /* </Inherit> */\r
+\r
+ ListClass SubNodeList;\r
+ ListElementClass ListElement; /* Next and previous in source file */\r
+};\r
+\r
+errnum_t Delete_SyntaxNodeList( ListClass* /*<SyntaxNodeClass*>*/ NodeList, errnum_t e );\r
+\r
+extern const ClassID_Class g_SyntaxNodeClass_ID;\r
+void SyntaxNodeClass_initConst( SyntaxNodeClass* self );\r
+errnum_t SyntaxNodeClass_printXML( SyntaxNodeClass* self, FILE* OutputStream );\r
+errnum_t SyntaxNodeClass_addSubNode( SyntaxNodeClass* self, SyntaxSubNodeClass* SubNode );\r
+\r
+\r
+ \r
+/***********************************************************************\r
<<< [PP_DirectiveClass] >>> \r
************************************************************************/\r
\r
\r
\r
\r
+errnum_t CutPreprocessorDirectives_from_C_LanguageToken(\r
+ ListClass* /*<C_LanguageTokenClass*>*/ TokenList,\r
+ Set2* /*<PP_DirectiveClass*>*/ Directives );\r
+\r
+\r
+ \r
/***********************************************************************\r
<<< [PP_SharpDefineClass] >>> \r
************************************************************************/\r
\r
\r
\r
+/***********************************************************************\r
+ <<< [C_LanguageTokenEnum] >>> \r
+************************************************************************/\r
+typedef enum _C_LanguageTokenEnum C_LanguageTokenEnum;\r
+enum _C_LanguageTokenEnum {\r
+ gc_TokenOfOther = 0,\r
+ gc_TokenOfNumber = 0xA1,\r
+ gc_TokenOfCIdentifier = 0xA2,\r
+ gc_TokenOfString = 0xA3,\r
+ gc_TokenOfChar = 0xA4,\r
+\r
+ gc_TokenOf_28 = '(',\r
+ gc_TokenOf_29 = ')',\r
+ gc_TokenOf_7B = '{',\r
+ gc_TokenOf_7D = '}',\r
+ gc_TokenOf_5B = '[',\r
+ gc_TokenOf_5D = ']',\r
+ gc_TokenOf_3A = ':',\r
+ gc_TokenOf_3B = ';',\r
+ gc_TokenOf_2A = '*',\r
+ gc_TokenOf_0A = '\n',\r
+ gc_TokenOf_3D = '=',\r
+ gc_TokenOf_2E = '.',\r
+ gc_TokenOf_26 = '&',\r
+ gc_TokenOf_2B = '+',\r
+ gc_TokenOf_2D = '-',\r
+ gc_TokenOf_7E = '~',\r
+ gc_TokenOf_21 = '!',\r
+ gc_TokenOf_2F = '/',\r
+ gc_TokenOf_25 = '%',\r
+ gc_TokenOf_3E = '>',\r
+ gc_TokenOf_3C = '<',\r
+ gc_TokenOf_5E = '^',\r
+ gc_TokenOf_7C = '|',\r
+ gc_TokenOf_3F = '?',\r
+ gc_TokenOf_2C = ',',\r
+ gc_TokenOf_2A2F = TwoChar8( '/', '*' ),\r
+ gc_TokenOf_2F2A = TwoChar8( '*', '/' ),\r
+ gc_TokenOf_2F2F = TwoChar8( '/', '/' ),\r
+ gc_TokenOf_3E2D = TwoChar8( '-', '>' ),\r
+ gc_TokenOf_2B2B = TwoChar8( '+', '+' ),\r
+ gc_TokenOf_2D2D = TwoChar8( '-', '-' ),\r
+ gc_TokenOf_3C3C = TwoChar8( '<', '<' ),\r
+ gc_TokenOf_3E3E = TwoChar8( '>', '>' ),\r
+ gc_TokenOf_3D3E = TwoChar8( '>', '=' ),\r
+ gc_TokenOf_3D3C = TwoChar8( '<', '=' ),\r
+ gc_TokenOf_3D3D = TwoChar8( '=', '=' ),\r
+ gc_TokenOf_3D21 = TwoChar8( '!', '=' ),\r
+ gc_TokenOf_2626 = TwoChar8( '&', '&' ),\r
+ gc_TokenOf_7C7C = TwoChar8( '|', '|' ),\r
+ gc_TokenOf_3D2B = TwoChar8( '+', '=' ),\r
+ gc_TokenOf_3D2D = TwoChar8( '-', '=' ),\r
+ gc_TokenOf_3D2A = TwoChar8( '*', '=' ),\r
+ gc_TokenOf_3D2F = TwoChar8( '/', '=' ),\r
+ gc_TokenOf_3D25 = TwoChar8( '%', '=' ),\r
+ /* <<= */\r
+ /* >>= */\r
+ gc_TokenOf_3D26 = TwoChar8( '&', '=' ),\r
+ gc_TokenOf_3D7C = TwoChar8( '|', '=' ),\r
+ gc_TokenOf_3D5E = TwoChar8( '^', '=' ),\r
+};\r
+\r
+TCHAR* C_LanguageTokenEnum_convertToStr( C_LanguageTokenEnum Value );\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [C_LanguageTokenClass] >>> \r
+************************************************************************/\r
+typedef struct _C_LanguageTokenClass_IDClass C_LanguageTokenClass_IDClass;\r
+\r
+typedef struct _C_LanguageTokenClass C_LanguageTokenClass;\r
+struct _C_LanguageTokenClass {\r
+\r
+ /* <Inherit parent="SyntaxSubNodeClass"> */\r
+ const ClassID_Class* ClassID;\r
+ const FinalizerVTableClass* FinalizerVTable;\r
+ const TCHAR* Start;\r
+ const TCHAR* Over;\r
+ const PrintXML_VTableClass* PrintXML_VTable;\r
+ SyntaxNodeClass* Parent;\r
+ ListElementClass SubNodeListElement; /* for ".Parent" */\r
+ /* </Inherit> */\r
+\r
+ C_LanguageTokenEnum TokenType;\r
+ ListElementClass ListElement; /* Next and previous in source file */\r
+ SyntaxNodeClass* ParentBlock;\r
+};\r
+\r
+extern const ClassID_Class g_C_LanguageTokenClass_ID;\r
+void C_LanguageTokenClass_initConst( C_LanguageTokenClass* self );\r
+errnum_t C_LanguageTokenClass_printXML( C_LanguageTokenClass* self, FILE* OutputStream );\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [NaturalDocsDefinitionClass] >>> \r
+************************************************************************/\r
+typedef struct _NaturalDocsDefinitionClass NaturalDocsDefinitionClass;\r
+struct _NaturalDocsDefinitionClass {\r
+ const TCHAR* Name; /* Has */\r
+ const TCHAR* NameStart;\r
+ const TCHAR* NameOver;\r
+\r
+ const TCHAR* Brief; /* Has */\r
+ const TCHAR* BriefStart;\r
+ const TCHAR* BriefOver;\r
+};\r
+\r
+void NaturalDocsDefinitionClass_initConst( NaturalDocsDefinitionClass* self );\r
+errnum_t NaturalDocsDefinitionClass_finalize( NaturalDocsDefinitionClass* self, errnum_t e );\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [NaturalDocsDescriptionTypeEnum] >>> \r
+************************************************************************/\r
+typedef enum _NaturalDocsDescriptionTypeEnum NaturalDocsDescriptionTypeEnum;\r
+enum _NaturalDocsDescriptionTypeEnum {\r
+ NaturalDocsDescriptionType_Unknown,\r
+ NaturalDocsDescriptionType_SubTitle,\r
+ NaturalDocsDescriptionType_Paragraph,\r
+ NaturalDocsDescriptionType_Code,\r
+ NaturalDocsDescriptionType_DefinitionList,\r
+\r
+ NaturalDocsDescriptionType_Count\r
+};\r
+\r
+const TCHAR* NaturalDocsDescriptionTypeEnum_to_String( int in, const TCHAR* in_OutOfRange );\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [NaturalDocsDescriptionClass] >>> \r
+************************************************************************/\r
+typedef struct _NaturalDocsDescriptionClass NaturalDocsDescriptionClass;\r
+struct _NaturalDocsDescriptionClass {\r
+ NaturalDocsDescriptionTypeEnum Type;\r
+\r
+ const TCHAR* Start;\r
+ const TCHAR* Over;\r
+\r
+ union {\r
+ void* Unknown;\r
+ NaturalDocsDefinitionClass* Definition;\r
+ } u;\r
+};\r
+\r
+void NaturalDocsDescriptionClass_initConst( NaturalDocsDescriptionClass* self );\r
+errnum_t NaturalDocsDescriptionClass_finalize( NaturalDocsDescriptionClass* self, errnum_t e );\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [NaturalDocsParserConfigClass] >>> \r
+************************************************************************/\r
+typedef struct _NaturalDocsParserConfigClass NaturalDocsParserConfigClass;\r
+struct _NaturalDocsParserConfigClass {\r
+ bit_flags_fast32_t Flags; /*<NaturalDocsParserConfigEnum>*/\r
+ TCHAR** AdditionalKeywords;\r
+ int AdditionalKeywordsLength;\r
+ int AdditionalKeywordsEndsScopesFirstIndex;\r
+ int AdditionalKeywordsEndsScopesLength;\r
+};\r
+typedef enum _NaturalDocsParserConfigEnum NaturalDocsParserConfigEnum;\r
+enum _NaturalDocsParserConfigEnum {\r
+ NaturalDocsParserConfig_AdditionalKeywords = 0x0001,\r
+ NaturalDocsParserConfig_AdditionalKeywordsLength = 0x0002,\r
+ NaturalDocsParserConfig_AdditionalKeywordsEndsScopesFirstIndex = 0x0004,\r
+ NaturalDocsParserConfig_AdditionalKeywordsEndsScopesLength = 0x0008,\r
+};\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [NaturalDocsHeaderClass] >>> \r
+************************************************************************/\r
+typedef struct _NaturalDocsHeaderClass NaturalDocsHeaderClass;\r
+struct _NaturalDocsHeaderClass {\r
+ const TCHAR* Keyword; /* Has */\r
+ const TCHAR* KeywordStart;\r
+ const TCHAR* KeywordOver;\r
+\r
+ const TCHAR* Name; /* Has */\r
+ const TCHAR* NameStart;\r
+ const TCHAR* NameOver;\r
+\r
+ const TCHAR* BriefNoIndent;\r
+ const TCHAR* Brief; /* Has */\r
+ const TCHAR* BriefStart;\r
+ const TCHAR* BriefOver;\r
+\r
+ const TCHAR* ArgumentsLabel;\r
+ Set2 Arguments; /*<NaturalDocsDefinitionClass>*/ /* Has */\r
+\r
+ const TCHAR* ReturnValueLabel;\r
+ const TCHAR* ReturnValue; /* Has */\r
+ const TCHAR* ReturnValueStart;\r
+ const TCHAR* ReturnValueOver;\r
+\r
+ const TCHAR* Descriptions; /* Has */\r
+ const TCHAR* DescriptionsStart;\r
+ const TCHAR* DescriptionsOver;\r
+\r
+ Set2 DescriptionItems; /*<NaturalDocsDescriptionClass>*/ /* Has */\r
+};\r
+\r
+void NaturalDocsHeaderClass_initConst( NaturalDocsHeaderClass* self );\r
+errnum_t NaturalDocsHeaderClass_finalize( NaturalDocsHeaderClass* self, errnum_t e );\r
+\r
+errnum_t ParseNaturalDocsComment( const TCHAR* in_SourceStart, const TCHAR* in_SourceOver,\r
+ NaturalDocsHeaderClass** out_NaturalDocsHeader, NaturalDocsParserConfigClass* config );\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [NaturalCommentClass] >>> \r
+************************************************************************/\r
+typedef struct _NaturalCommentClass NaturalCommentClass;\r
+struct _NaturalCommentClass {\r
+\r
+ /* <Inherit parent="SyntaxNodeClass"> */\r
+ const ClassID_Class* ClassID;\r
+ const FinalizerVTableClass* FinalizerVTable;\r
+ const TCHAR* Start;\r
+ const TCHAR* Over;\r
+ const PrintXML_VTableClass* PrintXML_VTable;\r
+ SyntaxNodeClass* Parent;\r
+ ListElementClass SubNodeListElement; /* for ".Parent" */\r
+ ListClass SubNodeList;\r
+ ListElementClass ListElement; /* Next and previous in source file */\r
+ /* </Inherit> */\r
+\r
+ int StartLineNum;\r
+ int LastLineNum;\r
+ NaturalDocsHeaderClass* NaturalDocsHeader;\r
+ NaturalCommentClass* ParentComment;\r
+};\r
+\r
+extern const ClassID_Class g_NaturalCommentClass_ID;\r
+void NaturalCommentClass_initConst( NaturalCommentClass* self );\r
+errnum_t NaturalCommentClass_finalize( NaturalCommentClass* self, errnum_t e );\r
+errnum_t NaturalCommentClass_printXML( NaturalCommentClass* self, FILE* OutputStream );\r
+\r
+\r
+errnum_t MakeNaturalComments_C_Language( ListClass* /*<C_LanguageTokenClass*>*/ TokenList,\r
+ LineNumberIndexClass* LineNumbers,\r
+ ListClass* /*<NaturalCommentClass*>*/ TopSyntaxNodeList,\r
+ NaturalDocsParserConfigClass* config );\r
+\r
+\r
+ \r
+/***********************************************************************\r
+ <<< [Parse_C_Language] >>> \r
+************************************************************************/\r
+errnum_t LexicalAnalize_C_Language( const TCHAR* Text,\r
+ ListClass* /*<C_LanguageTokenClass*>*/ TokenList );\r
+errnum_t CutComment_C_LanguageToken( ListClass* /*<C_LanguageTokenClass*>*/ TokenList );\r
+errnum_t Delete_C_LanguageToken( ListClass* /*<C_LanguageTokenClass*>*/ TokenList, errnum_t e );\r
+ \r
+errnum_t CutCommentC_1( const TCHAR* in_InputPath, const TCHAR* in_OutputPath );\r
+errnum_t CopyWithoutComment_C_Language( ListClass* in_Tokens, TCHAR* in_Text, FILE* in_OutStream );\r
+ \r
/*=================================================================*/\r
/* <<< [PlatformSDK_plus/PlatformSDK_plus.h] >>> */ \r
/*=================================================================*/\r
#endif\r
\r
\r
+errnum_t GetProcessInformation( DWORD in_ProcessID, PROCESSENTRY32* out_Info );\r
+ \r
/* [CloseHandleInFin] */ \r
#if ENABLE_ERROR_BREAK_IN_ERROR_CLASS\r
#define CloseHandleInFin( h, e ) \\r
OSDN Git Service
