_src/Test/tools/feq/clib.h

   1 /* The header file was composed by module mixer */ \r
   2 #ifdef _MSC_VER\r
   3  #if  showIncludes\r
   4   #pragma message( "start of #include  \"" __FILE__ "\"" )\r
   5  #endif\r
   6 #endif\r
   7 \r
   8 #ifndef  __CLIB_H\r
   9 #define  __CLIB_H\r
  10 \r
  11 \r
  12  \r
  13 /*=================================================================*/\r
  14 /* <<< [Error4_Type/Error4_Type.h] >>> */ \r
  15 /*=================================================================*/\r
  16  \r
  17 /***********************************************************************\r
  18 * Type: errnum_t\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
  22 \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
  25 #endif\r
  26 \r
  27 enum { E_CATEGORY_MASK = 0xFFFFFF00 };  /* E_CATEGORY_* */\r
  28 enum { E_OFFSET_MASK   = 0x000000FF };\r
  29 \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
  33 #endif\r
  34 \r
  35 #ifndef  E_OTHERS\r
  36         #define  E_OTHERS  E_OTHERS\r
  37         enum { E_OTHERS = 1 };\r
  38 #endif\r
  39 \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
  67 \r
  68 enum { NOT_FOUND_INDEX = -1 };\r
  69 \r
  70  \r
  71 /*=================================================================*/\r
  72 /* <<< [CRT/CRT.h] >>> */ \r
  73 /*=================================================================*/\r
  74  \r
  75 #include  <stdio.h> \r
  76 #ifdef  __linux__\r
  77         #define  _tfopen_s( out_File, Path, Mode ) \\r
  78                 ( *(out_File) = fopen( Path, Mode ),  (*(out_File) == NULL) ? (1) : (0) )\r
  79 #endif\r
  80  \r
  81 #include  <stdlib.h> \r
  82  \r
  83 #include  <string.h> \r
  84  \r
  85 #include  <stdarg.h> \r
  86 #ifdef  __linux__\r
  87         #define  _vsnprintf  vsnprintf\r
  88 #endif\r
  89  \r
  90 #ifndef  __linux__\r
  91         #include  <tchar.h> \r
  92 #else\r
  93         #define  _T(x)  x\r
  94         typedef  char  TCHAR;\r
  95         #define  _tcschr   strchr\r
  96         #define  _tprintf  printf\r
  97 #endif\r
  98  \r
  99 #include  <locale.h> \r
 100 \r
 101 #if UNDER_CE\r
 102   #define  setlocale( x, y )\r
 103 #endif\r
 104  \r
 105 #include  <errno.h> \r
 106 #ifdef  __linux__\r
 107         typedef  int  errno_t;  // CERT DCL09-C\r
 108 #endif\r
 109  \r
 110 #include  <assert.h> \r
 111  \r
 112 #include  <direct.h> \r
 113  \r
 114 #include  <malloc.h> \r
 115  \r
 116 /*=================================================================*/\r
 117 /* <<< [CRT_plus_1/CRT_plus_1.h] >>> */ \r
 118 /*=================================================================*/\r
 119  \r
 120 /***********************************************************************\r
 121   <<< [C99Type] >>> \r
 122 ************************************************************************/\r
 123 typedef  int             int_t;      /* MISRA-C:1998 No.13 */\r
 124 typedef  signed int      int32_t;    /* For 32bit compiler */\r
 125 typedef  signed short    int16_t;\r
 126 typedef  signed char     int8_t;\r
 127 typedef  unsigned int    uint_t;     /* MISRA-C:1998 No.13 */  /* This is not C99 */\r
 128 typedef  unsigned int    uint32_t;   /* For 32bit compiler */\r
 129 typedef  unsigned short  uint16_t;\r
 130 typedef  unsigned char   uint8_t;\r
 131 typedef  unsigned char   byte_t;     /* This is not C99 */\r
 132 typedef  float           float32_t;  /* This is not C99 */\r
 133 typedef  double          float64_t;  /* This is not C99 */\r
 134 typedef  unsigned int    bool_t;     /* MISRA-C:1998 No.13 */  /* This is not C99 */\r
 135 typedef  unsigned int    bool32_t;   /* For 32bit compiler */\r
 136 typedef  unsigned short  bool16_t;\r
 137 typedef  unsigned char   bool8_t;\r
 138 typedef  int             int_fast32_t;\r
 139 typedef  int             int_fast16_t;\r
 140 typedef  int             int_fast8_t;\r
 141 typedef  unsigned int    uint_fast32_t;\r
 142 typedef  unsigned int    uint_fast16_t;\r
 143 typedef  unsigned int    uint_fast8_t;\r
 144 \r
 145 #define  INT_FAST32_MAX  INT_MAX\r
 146 \r
 147 \r
 148  \r
 149 /*********************************************************************************************\r
 150   <<< [bit_flags32_t] [bit_flags_fast32_t] >>> \r
 151   <<< [BitField] [BIT_FIELD_ENDIAN] [BIT_FIELD_LITTLE_ENDIAN] [BIT_FIELD_BIG_ENDIAN] >>> \r
 152 **********************************************************************************************/\r
 153 typedef  uint32_t      bit_flags32_t; \r
 154 typedef  uint_fast32_t bit_flags_fast32_t;\r
 155 typedef  unsigned int  BitField; \r
 156 typedef  uint32_t      BitField32;\r
 157 #define  BIT_FIELD_ENDIAN           BIT_FIELD_LITTLE_ENDIAN\r
 158 #define  BIT_FIELD_LITTLE_ENDIAN    1\r
 159 #define  BIT_FIELD_BIG_ENDIAN       2\r
 160 \r
 161 \r
 162  \r
 163 /***********************************************************************\r
 164   <<< [IsBitSet]        Check 1 bit >>> \r
 165   <<< [IsAnyBitsSet]    Check multiple bits >>> \r
 166   <<< [IsAllBitsSet]    Check multiple bits >>> \r
 167   <<< [IsBitNotSet]     Check 1 bit >>> \r
 168   <<< [IsAnyBitsNotSet] Check multiple bits >>> \r
 169   <<< [IsAllBitsNotSet] Check multiple bits >>> \r
 170 ************************************************************************/\r
 171 #define  IsBitSet( variable, const_value ) \\r
 172         ( ( (variable) & (const_value) ) != 0 )\r
 173 \r
 174 #define  IsAnyBitsSet( variable, or_const_value ) \\r
 175         ( ( (variable) & (or_const_value) ) != 0 )\r
 176 \r
 177 #define  IsAllBitsSet( variable, or_const_value ) \\r
 178         ( ( (variable) & (or_const_value) ) == (or_const_value) )\r
 179 \r
 180 #define  IsBitNotSet( variable, const_value ) \\r
 181         ( ( (variable) & (const_value) ) == 0 )\r
 182 \r
 183 #define  IsAnyBitsNotSet( variable, or_const_value ) \\r
 184         ( ( (variable) & (or_const_value) ) != (or_const_value) )\r
 185 \r
 186 #define  IsAllBitsNotSet( variable, or_const_value ) \\r
 187         ( ( (variable) & (or_const_value) ) == 0 )\r
 188 \r
 189 \r
 190  \r
 191 /***********************************************************************\r
 192   <<< [bool type] >>> \r
 193 ************************************************************************/\r
 194 #ifndef  __cplusplus\r
 195  #ifndef  BOOL_DEFINED\r
 196   typedef unsigned char   bool;\r
 197   enum  { true = 1, false = 0 };\r
 198  #define  BOOL_DEFINED\r
 199  #endif\r
 200 #endif\r
 201 \r
 202 \r
 203  \r
 204 /***********************************************************************\r
 205   <<< [FuncType] >>> \r
 206 ************************************************************************/\r
 207 typedef  int (*FuncType)( void* Param ); \r
 208 typedef  errnum_t (* InitializeFuncType )( void* self, void* Parameter );\r
 209 //typedef  int (*FinishFuncType)( void* m, int e );  /*[FinishFuncType]*/\r
 210 typedef  errnum_t (*FinalizeFuncType)( void* self, errnum_t e );  /*[FinalizeFuncType]*/\r
 211 \r
 212 \r
 213  \r
 214 /***********************************************************************\r
 215   <<< [fopen_ccs] >>> \r
 216 ************************************************************************/\r
 217 #if defined(_UNICODE) \r
 218   #define  fopen_ccs  ",ccs=UNICODE"\r
 219 #else\r
 220   #define  fopen_ccs  "t"\r
 221 #endif\r
 222 \r
 223 \r
 224  \r
 225 /***********************************************************************\r
 226   <<< [inline] [SUPPORT_INLINE_C_FUNC] [NOT_USE_INLINE_MACRO] >>> \r
 227 ************************************************************************/\r
 228 #ifndef  SUPPORT_INLINE_C_FUNC\r
 229   #define  SUPPORT_INLINE_C_FUNC  1\r
 230 #endif\r
 231 #ifndef  INLINE\r
 232   #if ! __cplusplus\r
 233     #if SUPPORT_INLINE_C_FUNC\r
 234       #define  inline  _inline     /* inline is specified under C99 */\r
 235     #endif\r
 236   #endif\r
 237 #endif\r
 238 \r
 239 #ifndef  NOT_USE_INLINE_MACRO\r
 240   #define  NOT_USE_INLINE_MACRO  0\r
 241 #endif\r
 242 \r
 243 \r
 244  \r
 245 /**************************************************************************\r
 246  <<< [ttoi_ex] >>> \r
 247 ***************************************************************************/\r
 248 int  ttoi_ex( const TCHAR* string,  bit_flags_fast32_t options );\r
 249 \r
 250 \r
 251  \r
 252 /***********************************************************************\r
 253   <<< [PointerType_plus] >>> \r
 254 ************************************************************************/\r
 255 inline void  PointerType_plus( const void* in_out_Element, int PlusMinusByte )\r
 256 {\r
 257         *(int8_t**) in_out_Element = *(int8_t**) in_out_Element + PlusMinusByte;\r
 258 }\r
 259 \r
 260 \r
 261  \r
 262 /***********************************************************************\r
 263   <<< [PointerType_diff] >>> \r
 264 ************************************************************************/\r
 265 inline ptrdiff_t  PointerType_diff( const void* PointerA, const void* PointerB )\r
 266 {\r
 267         return  (uintptr_t) PointerA - (uintptr_t) PointerB;\r
 268 }\r
 269 \r
 270 \r
 271  \r
 272 /*=================================================================*/\r
 273 /* <<< [Error4_Inline/Error4_Inline.h] >>> */ \r
 274 /*=================================================================*/\r
 275  \r
 276 /***********************************************************************\r
 277   <<< [UNREFERENCED_VARIABLE] >>> \r
 278   <<< [UNREFERENCED_VARIABLE_2] >>>\r
 279   <<< [UNREFERENCED_VARIABLE_3] >>>\r
 280   <<< [UNREFERENCED_VARIABLE_4] >>>\r
 281 ************************************************************************/\r
 282 #ifdef  __linux__\r
 283         #define  UNREFERENCED_VARIABLE( x )\r
 284         #define  UNREFERENCED_VARIABLES( x )\r
 285 #else\r
 286 \r
 287 #define  UNREFERENCED_VARIABLE( a1 )       UNREFERENCED_VARIABLE_Sub( &(a1) )\r
 288 #define  UNREFERENCED_VARIABLE_2( a1,a2 )  UNREFERENCED_VARIABLE_2_Sub( &(a1), &(a2) )\r
 289 #define  UNREFERENCED_VARIABLE_3( a1,a2,a3 )     UNREFERENCED_VARIABLE_3_Sub( &(a1), &(a2), &(a3) )\r
 290 #define  UNREFERENCED_VARIABLE_4( a1,a2,a3,a4 )  UNREFERENCED_VARIABLE_4_Sub( &(a1), &(a2), &(a3), &(a4) )\r
 291 \r
 292 inline void  UNREFERENCED_VARIABLE_Sub( const void* a1 ) { a1; }\r
 293 inline void  UNREFERENCED_VARIABLE_2_Sub( const void* a1, const void* a2 ) { a1,a2; }\r
 294 inline void  UNREFERENCED_VARIABLE_3_Sub( const void* a1, const void* a2, const void* a3 ) { a1,a2,a3; }\r
 295 inline void  UNREFERENCED_VARIABLE_4_Sub( const void* a1, const void* a2, const void* a3, const void* a4 ) { a1,a2,a3,a4; }\r
 296 \r
 297 #endif\r
 298 \r
 299 \r
 300  \r
 301 /*=================================================================*/\r
 302 /* <<< [Lock_1/Lock_1.h] >>> */ \r
 303 /*=================================================================*/\r
 304  \r
 305 /***********************************************************************\r
 306   <<< [SingletonInitializerClass] >>> \r
 307 ************************************************************************/\r
 308 typedef struct {\r
 309         volatile LONG  InitializeStep;\r
 310 } SingletonInitializerClass;\r
 311 \r
 312 #ifndef  SingletonInitializerClass_FailSleepTime\r
 313         #ifndef NDEBUG\r
 314                 #define  SingletonInitializerClass_FailSleepTime  60000\r
 315         #else\r
 316                 #define  SingletonInitializerClass_FailSleepTime  0\r
 317         #endif\r
 318 #endif\r
 319 \r
 320 bool  SingletonInitializerClass_isFirst( SingletonInitializerClass* self );\r
 321 void  SingletonInitializerClass_onFinishedInitialize( SingletonInitializerClass* self, int e );\r
 322 bool  SingletonInitializerClass_isInitialized( SingletonInitializerClass* self );\r
 323 \r
 324 \r
 325  \r
 326 /*=================================================================*/\r
 327 /* <<< [Print/Print2.h] >>> */ \r
 328 /*=================================================================*/\r
 329  \r
 330 #if  __cplusplus\r
 331  extern "C" {  /* Start of C Symbol */ \r
 332 #endif\r
 333  \r
 334 errnum_t  vsprintf_r( char* s, size_t s_size, const char* format, va_list va ); \r
 335  \r
 336 errnum_t  vswprintf_r( wchar_t* s, size_t s_size, const wchar_t* format, va_list va ); \r
 337  \r
 338 /*[vstprintf_r]*/\r
 339 #if defined(_UNICODE) \r
 340   #define  vstprintf_r  vswprintf_r\r
 341 #else\r
 342   #define  vstprintf_r  vsprintf_r\r
 343 #endif\r
 344  \r
 345 errnum_t  stprintf_r( TCHAR* s, size_t s_size, const TCHAR* format, ... ); \r
 346  \r
 347 errnum_t  stcpy_part_r( TCHAR* s, size_t s_size, TCHAR* s_start, TCHAR** p_s_last, \r
 348                    const TCHAR* src, const TCHAR* src_over );\r
 349 errnum_t  stprintf_part_r( TCHAR* s, size_t s_size, TCHAR* s_start, TCHAR** p_s_last,\r
 350                       const TCHAR* format, ... );\r
 351  \r
 352 #if  __cplusplus\r
 353  }    /* End of C Symbol */ \r
 354 #endif\r
 355 \r
 356  \r
 357 /*=================================================================*/\r
 358 /* <<< [SetX/SetX.h] >>> */ \r
 359 /*=================================================================*/\r
 360  \r
 361 #ifndef  __SETX_H \r
 362 #define  __SETX_H\r
 363 \r
 364 #ifdef  __cplusplus\r
 365  extern "C" {  /* Start of C Symbol */\r
 366 #endif\r
 367 \r
 368  \r
 369 /***********************************************************************\r
 370   <<< [Set2] >>> \r
 371 ************************************************************************/\r
 372 typedef  struct _Set2  Set2;\r
 373 struct _Set2 {\r
 374         void*  First;\r
 375         void*  Next;\r
 376         void*  Over;\r
 377 \r
 378         #ifdef _DEBUG\r
 379         void**   PointerOfDebugArray;  /* void<type> */\r
 380         #endif\r
 381 };\r
 382 \r
 383 //[Set2_IteratorClass]\r
 384 typedef struct _Set2_IteratorClass  Set2_IteratorClass;\r
 385 struct _Set2_IteratorClass {\r
 386         Set2*     Parent;\r
 387         int       ElementSize;\r
 388         uint8_t*  Current;\r
 389 };\r
 390 \r
 391 #define  Set2_initConst( m )  ( (m)->First = NULL, (m)->Next = NULL )\r
 392 errnum_t  Set2_init( Set2* m, int FirstSize );\r
 393 errnum_t  Set2_finish( Set2* m, errnum_t e );\r
 394 #define  Set2_isInited( m )  ( (m)->First != NULL )\r
 395 \r
 396 #define  Set2_allocate( m, pp ) \\r
 397         Set2_alloc_imp( m, (void*)(pp), sizeof(**(pp)) )\r
 398 \r
 399 #define  Set2_alloc( m, pp, type ) \\r
 400         Set2_alloc_imp( m, (void*)(pp), sizeof(type) )\r
 401 \r
 402 errnum_t  Set2_alloc_imp( Set2* m, void* pm, size_t size );\r
 403 \r
 404 #define  Set2_push( m, pp, type ) \\r
 405         Set2_alloc_imp( m, (void*)(pp), sizeof(type) )\r
 406 \r
 407 #define  Set2_pop( m, pp, type ) \\r
 408         Set2_pop_imp( m, (void*)(pp), sizeof(type) )\r
 409 \r
 410 errnum_t  Set2_pop_imp( Set2* m, void* pp, size_t size );\r
 411 \r
 412 #define  Set2_free( m, pp, e ) \\r
 413         Set2_free_imp( m, pp, sizeof(**(pp)), e )\r
 414 errnum_t  Set2_free_imp( Set2* self,  void* in_PointerOfPointer,  size_t  in_Size_ofElement,  errnum_t  e );\r
 415 \r
 416 #define  Set2_freeLast( m, p, type, e ) \\r
 417         ( ((char*)(m)->Next - sizeof(type) == (char*)(p)) ? \\r
 418                 (m)->Next = (p), (e) : \\r
 419                 ((e)?(e):E_OTHERS) )\r
 420 \r
 421 #define  Set2_toEmpty( m ) \\r
 422         ( (m)->Next = (m)->First, 0 )\r
 423 \r
 424 #define  Set2_expandIfOverByAddr( m, OverAddrBasedOnNowFirst ) \\r
 425         ( (void*)(OverAddrBasedOnNowFirst) <= (m)->Over ? 0 : \\r
 426                 Set2_expandIfOverByAddr_imp( m, OverAddrBasedOnNowFirst ) )\r
 427 \r
 428 #define  Set2_expandIfOverByOffset( m, Size ) \\r
 429         Set2_expandIfOverByAddr( m, (char*)(m)->First + (Size) )\r
 430 errnum_t  Set2_expandIfOverByAddr_imp( Set2* m, void* OverAddrBasedOnNowFirst );\r
 431 \r
 432 #define  Set2_allocMulti( m, out_pElem, ElemType, nElem ) \\r
 433         Set2_allocMulti_sub( m, (void*)(out_pElem), sizeof(ElemType) * (nElem) )\r
 434 errnum_t  Set2_allocMulti_sub( Set2* m, void* out_pElem, size_t ElemsSize );\r
 435 \r
 436 #define  Set2_forEach( self, Item, Item_Over, Type ) \\r
 437         *(Item) = (Type*)( (self)->First ),  *(Item_Over) = (Type*)( (self)->Next ); \\r
 438         *(Item) < *(Item_Over); \\r
 439         *(Item) += 1\r
 440 \r
 441 errnum_t  Set2_getIterator( Set2* self, Set2_IteratorClass* out_Iterator, int ElementSize );\r
 442 errnum_t  Set2_getDescendingIterator( Set2* self, Set2_IteratorClass* out_Iterator, int ElementSize );\r
 443 void*  Set2_IteratorClass_getNext( Set2_IteratorClass* self );\r
 444 void*  Set2_IteratorClass_getPrevious( Set2_IteratorClass* self );\r
 445 \r
 446 \r
 447 //[Set2_forEach2]\r
 448 #define  Set2_forEach2( self, Iterator, out_Element ) \\r
 449         Set2_forEach2_1( self, Iterator, out_Element, sizeof(**(out_Element)) ); \\r
 450         Set2_forEach2_2( self, Iterator, out_Element ); \\r
 451         Set2_forEach2_3( self, Iterator, out_Element )\r
 452 \r
 453 inline void  Set2_forEach2_1( Set2* self, Set2_IteratorClass* Iterator,  void* out_Element,\r
 454         size_t ElementSize )\r
 455 {\r
 456         Set2_getIterator( self, Iterator, ElementSize );\r
 457         *(void**) out_Element = Set2_IteratorClass_getNext( Iterator );\r
 458 }\r
 459 \r
 460 inline bool  Set2_forEach2_2( Set2* self,  Set2_IteratorClass* Iterator,  void* out_Element )\r
 461 {\r
 462         UNREFERENCED_VARIABLE_2( self, Iterator );\r
 463         return  ( *(void**) out_Element != NULL );\r
 464 }\r
 465 \r
 466 inline void  Set2_forEach2_3( Set2* self, Set2_IteratorClass* Iterator,  void* out_Element )\r
 467 {\r
 468         UNREFERENCED_VARIABLE( self );\r
 469         *(void**) out_Element = Set2_IteratorClass_getNext( Iterator );\r
 470 }\r
 471 \r
 472 \r
 473 #define  Set2_getArray( self, out_Array, out_Count ) \\r
 474         ( ( *(void**)(out_Array) = (self)->First, \\r
 475         *(out_Count) = ( (byte_t*) (self)->Next - (byte_t*) (self)->First ) / sizeof(**(out_Array))), 0 )\r
 476 \r
 477 #define  Set2_refer( m, iElem, out_pElem ) \\r
 478         Set2_ref_imp( m, iElem, out_pElem, sizeof(**(out_pElem)) )\r
 479 \r
 480 #define  Set2_ref( m, iElem, out_pElem, ElemType ) \\r
 481         Set2_ref_imp( m, iElem, out_pElem, sizeof(ElemType) )\r
 482 \r
 483 errnum_t  Set2_ref_imp( Set2* m, int iElem, void* out_pElem, size_t ElemSize );\r
 484 \r
 485 #define  Set2_isEmpty( m ) \\r
 486         ( (m)->Next == (m)->First )\r
 487 \r
 488 #define  Set2_getCount( m, Type ) \\r
 489         ( ( (byte_t*)(m)->Next - (byte_t*)(m)->First ) / sizeof(Type) )\r
 490 \r
 491 #define  Set2_getCountMax( m, Type ) \\r
 492         ( ( (byte_t*)(m)->Over - (byte_t*)(m)->First ) / sizeof(Type) )\r
 493 \r
 494 #define  Set2_checkPtrInArr( m, p ) \\r
 495         ( (m)->First <= (p) && (p) < (m)->Over ? 0 : E_NOT_FOUND_SYMBOL )\r
 496 \r
 497 errnum_t  Set2_separate( Set2* m, int NextSize, void** allocate_Array );\r
 498 \r
 499 #ifdef _DEBUG\r
 500 void  Set2_setDebug( Set2* m, void* PointerOfDebugArray );\r
 501 #endif\r
 502 \r
 503  \r
 504 #ifdef  __cplusplus\r
 505  }  /* End of C Symbol */ \r
 506 #endif\r
 507 #endif\r
 508  \r
 509 /*=================================================================*/\r
 510 /* <<< [DebugTools/DebugTools.h] >>> */ \r
 511 /*=================================================================*/\r
 512  \r
 513 #if  __cplusplus\r
 514  extern "C" {  /* Start of C Symbol */ \r
 515 #endif\r
 516 \r
 517 \r
 518 #ifndef NDEBUG\r
 519         #define  NDEBUG_ERROR\r
 520 #else\r
 521         #define  NDEBUG_ERROR  ___cut_NDEBUG_ERROR\r
 522 #endif\r
 523 \r
 524  \r
 525 /*[dll_global_g_DebugBreakCount]*/\r
 526 #ifndef  dll_global_g_DebugBreakCount\r
 527         #define  dll_global_g_DebugBreakCount\r
 528 #endif\r
 529  \r
 530 /***********************************************************************\r
 531   <<< [TestableDebugBreak] >>> \r
 532 ************************************************************************/\r
 533 #define  TestableDebugBreak()  ( TestableDebugBreak_Sub() ? (DebugBreakR(),0) : 0 )\r
 534 int      TestableDebugBreak_Sub(void);\r
 535 \r
 536 void     SetTestableDebugBreak( bool IsEnableBreak );\r
 537 int      GetDebugBreakCount(void);\r
 538 \r
 539 \r
 540  \r
 541 #if  __cplusplus\r
 542  }  /* End of C Symbol */ \r
 543 #endif\r
 544 \r
 545 \r
 546  \r
 547 /*=================================================================*/\r
 548 /* <<< [StrT/StrT.h] >>> */ \r
 549 /*=================================================================*/\r
 550  \r
 551 #if  __cplusplus\r
 552  extern "C" {  /* Start of C Symbol */ \r
 553 #endif\r
 554 \r
 555 errnum_t  StrT_cpy( TCHAR* Dst, size_t DstSize, const TCHAR* Src );\r
 556 errnum_t  StrT_cat( TCHAR* Dst, size_t DstSize, const TCHAR* Src );\r
 557 TCHAR*  StrT_chr( const TCHAR* String, TCHAR Key );\r
 558 TCHAR*  StrT_chrs( const TCHAR* s, const TCHAR* keys );\r
 559 TCHAR*  StrT_rstr( const TCHAR* String, const TCHAR* SearchStart, const TCHAR* Keyword,\r
 560         void* NullConfig );\r
 561 TCHAR*  StrT_chrNext( const TCHAR* in_Start, TCHAR in_KeyCharactor );\r
 562 TCHAR*  StrT_skip( const TCHAR* s, const TCHAR* keys );\r
 563 TCHAR*  StrT_rskip( const TCHAR* String, const TCHAR* SearchStart, const TCHAR* Keys,\r
 564         void* NullConfig );\r
 565 bool    StrT_isCIdentifier( TCHAR Character );\r
 566 TCHAR*  StrT_searchOverOfCIdentifier( const TCHAR* Text );\r
 567 TCHAR*  StrT_searchOverOfIdiom( const TCHAR* Text );\r
 568 int  StrT_cmp_part( const TCHAR* StringA_Start, const TCHAR* StringA_Over,\r
 569         const TCHAR* StringB );\r
 570 int  StrT_cmp_i_part( const TCHAR* StringA_Start, const TCHAR* StringA_Over,\r
 571         const TCHAR* StringB );\r
 572 int  StrT_cmp_part2( const TCHAR* StringA_Start, const TCHAR* StringA_Over,\r
 573         const TCHAR* StringB_Start, const TCHAR* StringB_Over );\r
 574 #define  TwoChar8( Character1, Character2 ) \\r
 575         ( (Character1) + ( (Character2) << 8 ) )\r
 576 #define  FourChar8( Character1, Character2, Character3, Character4 ) \\r
 577         ( (Character1) + ( (Character2) << 8 ) + ( (Character3) << 16 ) + ( (Character4) << 24 ) )\r
 578 \r
 579 inline errnum_t  StrT_cat( TCHAR* Dst, size_t DstSize, const TCHAR* Src )\r
 580 {\r
 581         return  stcpy_part_r( Dst, DstSize, _tcschr( Dst, _T('\0') ), NULL, Src, NULL );\r
 582 }\r
 583 \r
 584 \r
 585  \r
 586 //[GetStringSizeFromPointer]\r
 587 inline size_t  GetStringSizeFromPointer( void* String, size_t StringSize, void* Pointer )\r
 588 {\r
 589         return  (uintptr_t) String + StringSize - (uintptr_t) Pointer;\r
 590 }\r
 591 \r
 592  \r
 593 /***********************************************************************\r
 594   <<< [StrT_Malloc] >>> \r
 595 ************************************************************************/\r
 596 errnum_t  MallocAndCopyString( const TCHAR** out_NewString, const TCHAR* SourceString );\r
 597 errnum_t  MallocAndCopyString_char( const TCHAR** out_NewString, const char* SourceString );\r
 598 errnum_t  MallocAndCopyStringByLength( const TCHAR** out_NewString, const TCHAR* SourceString,\r
 599         unsigned CountOfCharacter );\r
 600 \r
 601 #ifndef _UNICODE\r
 602         #define  MallocAndCopyString_char  MallocAndCopyString\r
 603 #endif\r
 604 \r
 605 errnum_t  StrHS_insert( TCHAR**  in_out_WholeString,\r
 606         int  in_TargetIndexInWholeString,  int*  out_NextWholeInWholeString,\r
 607         const TCHAR*  in_InsertString );\r
 608 errnum_t  StrHS_printf( TCHAR**  in_out_String,  const TCHAR*  in_Format,  ... );\r
 609 errnum_t  StrHS_printfV( TCHAR**  in_out_String,  const TCHAR*  in_Format,  va_list  in_VaList );\r
 610 errnum_t  StrHS_printfPart( TCHAR**  in_out_String,\r
 611         int  in_IndexInString,  int*  out_NextIndexInString,\r
 612         const TCHAR*  in_Format,  ... );\r
 613 errnum_t  StrHS_printfPartV( TCHAR**  in_out_String,\r
 614         int  in_IndexInString,  int*  out_NextIndexInString,\r
 615         const TCHAR*  in_Format,  va_list  in_VaList );\r
 616 \r
 617 \r
 618  \r
 619 /***********************************************************************\r
 620   <<< [StrT_Edit] >>> \r
 621 ************************************************************************/\r
 622 errnum_t  StrT_cutPart( TCHAR*  in_out_String,  TCHAR*  in_StartOfCut,  TCHAR*  in_OverOfCut );\r
 623 errnum_t  StrT_trim( TCHAR* out_Str, size_t out_Str_Size, const TCHAR* in_Str );\r
 624 errnum_t  StrT_cutLastOf( TCHAR* in_out_Str, TCHAR Charactor );\r
 625 errnum_t  StrT_cutLineComment( TCHAR* out_Str, size_t out_Str_Size, const TCHAR* in_Str, const TCHAR* CommentSign );\r
 626 errnum_t  StrT_insert( TCHAR*  in_out_WholeString,  size_t  in_MaxSize_of_WholeString,\r
 627         TCHAR*  in_out_Target_in_WholeString,  TCHAR**  out_NextTarget_in_WholeString,\r
 628         const TCHAR*  in_InsertString );\r
 629 errnum_t  StrT_meltCmdLine( TCHAR* out_Str, size_t out_Str_Size, const TCHAR** pLine );\r
 630 errnum_t  StrT_getExistSymbols( unsigned* out, bool bCase, const TCHAR* Str, const TCHAR* Symbols, ... );\r
 631 errnum_t  StrT_replace1( TCHAR* in_out_String, TCHAR FromCharacter, TCHAR ToCharacter,\r
 632         unsigned Opt );\r
 633 \r
 634 \r
 635  \r
 636 /***********************************************************************\r
 637   <<< [W3CDTF] >>> \r
 638 ************************************************************************/\r
 639 enum { W3CDTF_MAX_LENGTH = 27+3 };  /* \8f¬\90\943\8c\85 */\r
 640 enum { W3CDTF_CURRENT_TIME_ZONE = 9999 };\r
 641 \r
 642 errnum_t  W3CDTF_fromSYSTEMTIME( TCHAR* out_W3CDTF, size_t W3CDTF_ByteSize,\r
 643         const SYSTEMTIME* Time, int TimeZoneMinute );\r
 644 errnum_t  W3CDTF_toSYSTEMTIME( const TCHAR* String, SYSTEMTIME* out_Time, int* out_BiasMinute );\r
 645 errnum_t  W3CDTF_getTimeZoneDesignator( TCHAR* out_TZD, size_t TZD_ByteSize,\r
 646         int  BiasMinute );\r
 647 \r
 648 \r
 649  \r
 650 /***********************************************************************\r
 651   <<< [StrT_Path] >>> \r
 652 ************************************************************************/\r
 653 enum { StrT_LocalPathMaxSize = 4096 };\r
 654 enum { MAX_LOCAL_PATH = 4096 };\r
 655 TCHAR*  StrT_refFName( const TCHAR* s );\r
 656 TCHAR*  StrT_refExt( const TCHAR* s );\r
 657 void  StrT_cutFragmentInPath( TCHAR* in_out_Path );\r
 658 bool  StrT_isFullPath( const TCHAR* s );\r
 659 \r
 660 errnum_t  StrT_getFullPath_part( TCHAR* Str, size_t StrSize, TCHAR* StrStart,\r
 661         TCHAR** out_StrLast, const TCHAR* StepPath, const TCHAR* BasePath );\r
 662 errnum_t  StrT_allocateFullPath( TCHAR** out_FullPath, const TCHAR* StepPath, TCHAR* BasePath );\r
 663 errnum_t  StrT_getStepPath( TCHAR* out_StepPath, size_t StepPathSize,\r
 664         const TCHAR* FullPath, const TCHAR* BasePath );\r
 665 errnum_t  StrT_getParentFullPath_part( TCHAR* Str, size_t StrSize, TCHAR* StrStart,\r
 666         TCHAR** out_StrLast, const TCHAR* StepPath, const TCHAR* BasePath );\r
 667 errnum_t  StrT_getBaseName_part( TCHAR* Str, size_t StrSize, TCHAR* StrStart,\r
 668         TCHAR** out_StrLast, const TCHAR* SrcPath );\r
 669 errnum_t  StrT_addLastOfFileName( TCHAR* out_Path, size_t PathSize,\r
 670                              const TCHAR* BasePath, const TCHAR* AddName );\r
 671 errnum_t  StrT_encodeToValidPath( TCHAR* out_Path,  size_t in_OutPathSize,  const TCHAR* in_Path,  bool  in_IsName );\r
 672 \r
 673 inline errnum_t  StrT_getFullPath( TCHAR* out_FullPath, size_t FullPathSize,\r
 674         const TCHAR* StepPath, const TCHAR* BasePath )\r
 675 {\r
 676         return  StrT_getFullPath_part( out_FullPath, FullPathSize, out_FullPath,\r
 677                 NULL, StepPath, BasePath );\r
 678 }\r
 679 \r
 680 inline errnum_t  StrT_getParentFullPath( TCHAR* Str, size_t StrSize,\r
 681         const TCHAR* SrcPath, const TCHAR* BasePath )\r
 682 {\r
 683         return StrT_getParentFullPath_part( Str, StrSize, Str, NULL, SrcPath, BasePath );\r
 684 }\r
 685 \r
 686 inline errnum_t  StrT_getBaseName( TCHAR* Str, size_t StrSize, const TCHAR* SrcPath )\r
 687 {\r
 688         return  StrT_getBaseName_part( Str, StrSize, Str, NULL, SrcPath );\r
 689 }\r
 690 \r
 691 \r
 692  \r
 693 /**************************************************************************\r
 694   <<< [Strs] >>> \r
 695 ***************************************************************************/\r
 696 typedef  struct _Strs  Strs;\r
 697 struct _Strs {\r
 698         byte_t*  MemoryAddress;   /* first memory = [ TCHAR* FirstStr | elem[] ],  other memory = [ elem[] ] */\r
 699         byte_t*  MemoryOver;\r
 700         byte_t*  NextElem;        /* elem = [ TCHAR* NextStr | TCHAR[] ] */\r
 701         TCHAR**  PointerToNextStrInPrevElem;  /* first = &FirstStr,  other = &NextStr */\r
 702         TCHAR**  Prev_PointerToNextStrInPrevElem;\r
 703 \r
 704         Strs*   FirstOfStrs;\r
 705         Strs*   NextStrs;\r
 706 };\r
 707 \r
 708 void Strs_initConst( Strs* m );\r
 709 errnum_t  Strs_init( Strs* m );\r
 710 errnum_t  Strs_finish( Strs* m, errnum_t e );\r
 711 errnum_t  Strs_toEmpty( Strs* m );\r
 712 bool Strs_isInited( Strs* m );\r
 713 errnum_t  Strs_add( Strs* m, const TCHAR* Str, const TCHAR** out_pAlloc );\r
 714 errnum_t  Strs_addBinary( Strs* m, const TCHAR* Str, const TCHAR* StrOver, const TCHAR** out_AllocStr );\r
 715 errnum_t  Strs_freeLast( Strs* m, TCHAR* AllocStr );\r
 716 errnum_t  Strs_toEmpty( Strs* m );\r
 717 /* for ( Strs_forEach( Strs* m, TCHAR** in_out_Str ) ); */\r
 718 TCHAR*  Strx_getFirst( Strs* m );\r
 719 TCHAR*  Strx_getNext( Strs* m, TCHAR* Str );\r
 720 \r
 721 \r
 722 #define  Strs_initConst( m )  ( (m)->MemoryAddress =  NULL )\r
 723 #define  Strs_isInited( m )    ( (m)->MemoryAddress != NULL )\r
 724 \r
 725 #define  Strs_forEach( m, pStr ) \\r
 726         *(pStr) = Strs_getFirst( m ); \\r
 727         *(pStr) != NULL; \\r
 728         *(pStr) = Strs_getNext( m, *(pStr) )\r
 729 \r
 730 #define  Strs_getFirst( m ) \\r
 731         ( *(TCHAR**) (m)->FirstOfStrs->MemoryAddress )\r
 732 \r
 733 #define  Strs_getNext( m, p ) \\r
 734         ( *( (TCHAR**)(p) - 1 ) )\r
 735 \r
 736 #define  Strs_getFreeAddr( m )  ( (TCHAR*)( (m)->NextElem + sizeof(TCHAR*) ) )\r
 737 #define  Strs_getFreeSize( m )  ( (m)->MemoryOver - (byte_t*)(m)->NextElem - sizeof(TCHAR*) )\r
 738 #define  Strs_getFreeCount( m ) ( Strs_getFreeSize( m ) / sizeof(TCHAR) )\r
 739 #define  Strs_expandCount( m, c )  ( Strs_expandSize( (m), (c) * sizeof(TCHAR) ) )\r
 740 errnum_t  Strs_expandSize( Strs* m, size_t FreeSize );\r
 741 errnum_t  Strs_commit( Strs* m, TCHAR* StrOver );\r
 742 errnum_t  Strs_allocateArray( Strs* self,  TCHAR*** out_PointerArray,  int* out_Count );\r
 743 \r
 744 \r
 745  \r
 746 /***********************************************************************\r
 747   <<< [StrArr] >>> \r
 748 ************************************************************************/\r
 749 typedef struct _StrArr  StrArr;\r
 750 struct _StrArr {\r
 751         Set2  Array;  // array of TCHAR*\r
 752         Strs  Chars;\r
 753 };\r
 754 \r
 755 errnum_t  StrArr_init( StrArr* m );\r
 756 errnum_t  StrArr_finish( StrArr* m, errnum_t e );\r
 757 \r
 758 errnum_t  StrArr_add( StrArr* m, const TCHAR* Str, int* out_I );\r
 759 errnum_t  StrArr_commit( StrArr* m );\r
 760 errnum_t  StrArr_fillTo( StrArr* m, int n, const TCHAR* Str );\r
 761 errnum_t  StrArr_toEmpty( StrArr* m );\r
 762 \r
 763 #define  StrArr_initConst( m )   Set2_initConst( &(m)->Array )\r
 764 #define  StrArr_getFreeAddr( m )  Strs_getFreeAddr( &(m)->Chars )\r
 765 #define  StrArr_getFreeSize( m )  Strs_getFreeSize( &(m)->Chars )\r
 766 #define  StrArr_getFreeCount( m ) Strs_getFreeCount( &(m)->Chars )\r
 767 #define  StrArr_expandSize( m, sz )  Strs_expandSize( &(m)->Chars, sz )\r
 768 #define  StrArr_expandCount( m, c )  Strs_expandCount( &(m)->Chars, c )\r
 769 #define  StrArr_getArray( m )     ((TCHAR**)(m)->Array.First)\r
 770 //#define  StrArr_getN( m )          Set2_getCount( &(m)->Array, TCHAR* )\r
 771 #define  StrArr_getCount( m )        Set2_getCount( &(m)->Array, TCHAR* )\r
 772 \r
 773 \r
 774  \r
 775 /***********************************************************************\r
 776   <<< [StrArr_forEach] >>> \r
 777 ************************************************************************/\r
 778 #define  StrArr_forEach( self, Iterator, out_String ) \\r
 779         StrArr_forEach_1( self, Iterator, out_String ); \\r
 780         StrArr_forEach_2( Iterator ); \\r
 781         StrArr_forEach_3( Iterator, out_String )\r
 782 \r
 783 /*[StrArrIterator]*/\r
 784 typedef struct _StrArrIterator  StrArrIterator;\r
 785 struct _StrArrIterator {\r
 786         const TCHAR**  Pointer;\r
 787         const TCHAR**  PointerOver;\r
 788 };\r
 789 \r
 790 inline void  StrArr_forEach_1( StrArr* self, StrArrIterator* Iterator, const TCHAR** out_String )\r
 791 {\r
 792         Iterator->Pointer = (const TCHAR**) self->Array.First;\r
 793         Iterator->PointerOver = (const TCHAR**) self->Array.Next;\r
 794         *out_String = *Iterator->Pointer;\r
 795 }\r
 796 \r
 797 inline bool  StrArr_forEach_2( StrArrIterator* Iterator )\r
 798 {\r
 799         return  Iterator->Pointer < Iterator->PointerOver;\r
 800 }\r
 801 \r
 802 inline void  StrArr_forEach_3( StrArrIterator* Iterator, const TCHAR** out_String )\r
 803 {\r
 804         Iterator->Pointer += 1;\r
 805         *out_String = *Iterator->Pointer;\r
 806 }\r
 807 \r
 808 \r
 809  \r
 810 /***********************************************************************\r
 811   <<< [CSV] >>> \r
 812 ************************************************************************/\r
 813 errnum_t  StrT_meltCSV( TCHAR* out_Str, size_t out_Str_Size, const TCHAR** pCSV );\r
 814 errnum_t  StrArr_parseCSV( StrArr* m, const TCHAR* CSVLine );\r
 815 errnum_t  StrT_parseCSV_f( const TCHAR* StringOfCSV, bit_flags32_t* out_ReadFlags, const TCHAR* Types, ... );\r
 816 \r
 817 \r
 818  \r
 819 #if  __cplusplus\r
 820  }  /* End of C Symbol */ \r
 821 #endif\r
 822 \r
 823  \r
 824 /*=================================================================*/\r
 825 /* <<< [CRT_plus_2/CRT_plus_2.h] >>> */ \r
 826 /*=================================================================*/\r
 827  \r
 828 /***********************************************************************\r
 829   <<< [HeapMemory_allocate] >>> \r
 830   <<< [HeapMemory_allocateArray] >>> \r
 831 ************************************************************************/\r
 832 \r
 833 #define  HeapMemory_allocate( out_Pointer ) \\r
 834     HeapMemory_allocateBytes( out_Pointer, sizeof( **(out_Pointer) ) )\r
 835 \r
 836 #define  HeapMemory_allocateArray( out_Pointer, Count ) \\r
 837     HeapMemory_allocateBytes( out_Pointer, sizeof( **(out_Pointer) ) * (Count) )\r
 838 \r
 839 inline errnum_t  HeapMemory_allocateBytes( void* out_Pointer, size_t MemorySize )\r
 840 {\r
 841         void**  out = (void**) out_Pointer;\r
 842 \r
 843         *out = malloc( MemorySize );\r
 844 \r
 845         if ( *out == NULL )\r
 846                 { return  E_FEW_MEMORY; }\r
 847         else\r
 848                 { return  0; }\r
 849 }\r
 850 \r
 851 \r
 852 /*[MallocMemory]*/\r
 853 inline errnum_t  MallocMemory( void* out_MemoryAddress, size_t MemorySize )\r
 854 {\r
 855         return  HeapMemory_allocateBytes( out_MemoryAddress, MemorySize );\r
 856 }\r
 857 \r
 858 \r
 859  \r
 860 /***********************************************************************\r
 861   <<< [HeapMemory_free] >>> \r
 862 ************************************************************************/\r
 863 inline errnum_t  HeapMemory_free( const void* in_out_MemoryAddress, errnum_t e )\r
 864 {\r
 865         void*  address = *(void**) in_out_MemoryAddress;\r
 866 \r
 867         if ( address != NULL )\r
 868                 { free( address ); }\r
 869 \r
 870         *(void**) in_out_MemoryAddress = NULL;\r
 871 \r
 872         return  e;\r
 873 }\r
 874 \r
 875 \r
 876 /*[FreeMemory]*/\r
 877 inline errnum_t  FreeMemory( const void* in_out_MemoryAddress, errnum_t e )\r
 878 {\r
 879         return  HeapMemory_free( in_out_MemoryAddress, e );\r
 880 }\r
 881 \r
 882 \r
 883  \r
 884 /*=================================================================*/\r
 885 /* <<< [Error4/Error4.h] >>> */ \r
 886 /*=================================================================*/\r
 887  \r
 888 #if  __cplusplus\r
 889  extern "C" {  /* Start of C Symbol */ \r
 890 #endif\r
 891 \r
 892 \r
 893  \r
 894 /***********************************************************************\r
 895   <<< [SetBreakErrorID] >>> \r
 896 ************************************************************************/\r
 897 #ifndef  ENABLE_ERROR_BREAK_IN_ERROR_CLASS\r
 898         #if ! NDEBUG\r
 899                 #define  ENABLE_ERROR_BREAK_IN_ERROR_CLASS  1\r
 900         #else\r
 901                 #define  ENABLE_ERROR_BREAK_IN_ERROR_CLASS  0\r
 902         #endif\r
 903 #endif\r
 904 \r
 905 #ifndef  ENABLE_DEBUG_ERROR_BREAK_IN_ERROR_CLASS\r
 906         #if ! NDEBUG\r
 907                 #define  ENABLE_DEBUG_ERROR_BREAK_IN_ERROR_CLASS  1\r
 908         #else\r
 909                 #define  ENABLE_DEBUG_ERROR_BREAK_IN_ERROR_CLASS  0\r
 910         #endif\r
 911 #endif\r
 912 \r
 913 #ifndef  IS_MULTI_THREAD_ERROR_CLASS\r
 914  \r
 915         #define  IS_MULTI_THREAD_ERROR_CLASS  0  /*[IS_MULTI_THREAD_ERROR_CLASS]:single*/\r
 916  \r
 917 #endif\r
 918 \r
 919 #ifndef  NDEBUG\r
 920         #define  ERR2_ENABLE_ERROR_LOG  1\r
 921 #else\r
 922         #define  ERR2_ENABLE_ERROR_LOG  0\r
 923 #endif\r
 924 \r
 925 /*[dll_global_g_Error]*/\r
 926 #ifndef  dll_global_g_Error\r
 927         #define  dll_global_g_Error\r
 928 #endif\r
 929 \r
 930 \r
 931 #if ENABLE_ERROR_BREAK_IN_ERROR_CLASS\r
 932         /*[IF][IF_D][ASSERT_R][ASSERT_D]*/\r
 933         /* "IF" is able to break at nearest code raising error */\r
 934         #define  IF_D(x)  IF(x)\r
 935         #define  IF(x) \\r
 936                 if( (x) && ( OnRaisingError_Sub((const char*)__FILE__,__LINE__) ? (DebugBreakR(),1) : (1) ) )\r
 937 \r
 938         #define  ASSERT_R( x, goto_err_or_Statement ) \\r
 939                 __pragma(warning(push)) \\r
 940                 __pragma(warning(disable:4127)) \\r
 941                         do{  IF(!(x)) { goto_err_or_Statement; } }  while(0)   /* do-while is CERT standard PRE10-C */ \\r
 942                 __pragma(warning(pop))\r
 943 \r
 944         #define  ASSERT_D( x, goto_err_or_Statement )  ASSERT_R( x, goto_err_or_Statement )\r
 945 #else\r
 946         #define  IF(x)  if(x)\r
 947         #define  IF_D(x) \\r
 948                 __pragma(warning(push)) \\r
 949                 __pragma(warning(disable:4127)) \\r
 950                         if(0) \\r
 951                 __pragma(warning(pop))\r
 952 \r
 953         #define  ASSERT_R( x, goto_err_or_Statement ) \\r
 954                 __pragma(warning(push)) \\r
 955                 __pragma(warning(disable:4127)) \\r
 956                         do{  if(!(x)) { goto_err_or_Statement; } }while(0)   /* do-while is CERT standard PRE10-C */ \\r
 957                 __pragma(warning(pop))\r
 958 \r
 959         #define  ASSERT_D( x, goto_err_or_Statement )\r
 960 #endif\r
 961 \r
 962 \r
 963 void  DebugBreakR(void);\r
 964 #if ! ENABLE_ERROR_BREAK_IN_ERROR_CLASS\r
 965         inline void  SetBreakErrorID( int ID ) { ID=ID; /* avoid warning */ }\r
 966         inline void  ClearError() {}\r
 967         inline void  IfErrThenBreak() {}\r
 968         typedef  int  ErrStackAreaClass;  // dummy type\r
 969         inline void  PushErr( ErrStackAreaClass* ErrStackArea )  { UNREFERENCED_VARIABLE( ErrStackArea ); }\r
 970         inline void  PopErr(  ErrStackAreaClass* ErrStackArea )  { UNREFERENCED_VARIABLE( ErrStackArea ); }\r
 971 #else\r
 972         void  SetBreakErrorID( int ID );\r
 973         void  ClearError(void);\r
 974         void  IfErrThenBreak(void);\r
 975         typedef  struct _ErrorClass  ErrStackAreaClass;\r
 976         void  PushErr( ErrStackAreaClass* ErrStackArea );\r
 977         void  PopErr(  ErrStackAreaClass* ErrStackArea );\r
 978 \r
 979         bool  OnRaisingError_Sub( const char* FilePath, int LineNum );\r
 980 \r
 981         typedef  struct _ErrorClass  ErrorClass;  /*[ErrorClass]*/\r
 982         struct _ErrorClass {\r
 983                 bool         IsError;\r
 984                 #if  ENABLE_DEBUG_ERROR_BREAK_IN_ERROR_CLASS\r
 985                         int     ErrorID;\r
 986                 #endif\r
 987                 int          BreakErrorID;\r
 988                 const char*  FilePath;\r
 989                 int          LineNum;\r
 990 \r
 991                 #if IS_MULTI_THREAD_ERROR_CLASS\r
 992                         FinalizerClass  Finalizer;\r
 993                         #if  ENABLE_DEBUG_ERROR_BREAK_IN_ERROR_CLASS\r
 994                                 DWORD  ThreadID;\r
 995                                 int    GlobalErrorID;\r
 996                         #endif\r
 997                 #endif\r
 998         };\r
 999         errnum_t  ErrorClass_finalize( ErrorClass* self, errnum_t e );\r
1000 \r
1001         #if ! IS_MULTI_THREAD_ERROR_CLASS\r
1002                 dll_global_g_Error extern  ErrorClass  g_Error;\r
1003         #endif\r
1004 #endif\r
1005 \r
1006 errnum_t  MergeError( errnum_t e, errnum_t ee );\r
1007 void  ErrorLog_add( errnum_t e );\r
1008 \r
1009 \r
1010  \r
1011 /***********************************************************************\r
1012   <<< [ErrorMessage] >>> \r
1013 ************************************************************************/\r
1014 void  Error4_printf( const TCHAR* format, ... );\r
1015 void  Error4_getErrStr( int ErrNum, TCHAR* out_ErrStr, size_t ErrStrSize );\r
1016 void  Error4_clear( int err_num );\r
1017 errnum_t  SaveWindowsLastError(void);\r
1018 \r
1019 \r
1020  \r
1021 /***********************************************************************\r
1022   <<< [stdio] >>> \r
1023 ************************************************************************/\r
1024 void  Error4_showToStdErr( int err_num );\r
1025 void  Error4_showToStdIO( FILE* out, int err_num );\r
1026 \r
1027 \r
1028  \r
1029 /***********************************************************************\r
1030   <<< [errno] >>> \r
1031 ************************************************************************/\r
1032 int  Error4_raiseErrno(void);\r
1033 \r
1034  \r
1035 /***********************************************************************\r
1036   <<< [DEBUG_TRUE, DEBUG_FALSE] >>> \r
1037 ************************************************************************/\r
1038 #if ! NDEBUG\r
1039  #define  DEBUG_TRUE   1\r
1040  #define  DEBUG_FALSE  0\r
1041 #else\r
1042  #define  DEBUG_TRUE   __cut_on_debug =\r
1043  #define  DEBUG_FALSE  0\r
1044 #endif\r
1045 \r
1046 \r
1047  \r
1048 /***********************************************************************\r
1049   <<< [DEBUG_CODE] >>> \r
1050 ************************************************************************/\r
1051 #if ! NDEBUG\r
1052         #define  DEBUG_CODE( expression ) \\r
1053                 __pragma(warning(push)) \\r
1054                 __pragma(warning(disable:4127)) \\r
1055                         do { expression; } while(0)   /* do-while is CERT standard PRE10-C */ \\r
1056                 __pragma(warning(pop))\r
1057 #else\r
1058         #define  DEBUG_CODE( expression )  /* no execute */\r
1059 #endif\r
1060 \r
1061 \r
1062  \r
1063 /***********************************************************************\r
1064   <<< [CHECK_ARG] >>> \r
1065 ************************************************************************/\r
1066 #ifndef  CHECK_ARG\r
1067   #define  CHECK_ARG  1\r
1068 #endif\r
1069 \r
1070 /*[GetIsCheckArg][SetIsCheckArg]*/\r
1071 #if CHECK_ARG\r
1072 extern bool  g_IsCheckArg;\r
1073 inline bool  GetIsCheckArg(void)  { return  g_IsCheckArg; }\r
1074 inline void  SetIsCheckArg( bool IsCheckArg )  { g_IsCheckArg = IsCheckArg; }\r
1075 #endif\r
1076 \r
1077 \r
1078  \r
1079 /***********************************************************************\r
1080   <<< [INVALID_VALUE] >>> \r
1081 ************************************************************************/\r
1082 enum { INVALID_VALUE = 0xDEDEDEDE };\r
1083 \r
1084 \r
1085  \r
1086 /***********************************************************************\r
1087   <<< [DUMMY_INITIAL_VALUE] >>> \r
1088 ************************************************************************/\r
1089 #ifndef NDEBUG\r
1090         enum { DUMMY_INITIAL_VALUE = 0xDEDEDEDE };\r
1091         enum { DUMMY_INITIAL_VALUE_8BIT  = 0xDE };\r
1092         enum { DUMMY_INITIAL_VALUE_16BIT = 0xDEDE };\r
1093         #ifdef _UNICODE\r
1094                 enum { DUMMY_INITIAL_VALUE_TCHAR = 0xDEDE };\r
1095         #else\r
1096                 enum { DUMMY_INITIAL_VALUE_TCHAR = 0xDE - 0x100 };  /* 0x100 is to change to signed type */\r
1097         #endif\r
1098         /* Disable VC++ warning C4701 : local variable may be used without having been initialized */\r
1099         /* 0xDEDEDEDE means "not initialized" */\r
1100 #else\r
1101         enum { DUMMY_INITIAL_VALUE = 0 };\r
1102         enum { DUMMY_INITIAL_VALUE_8BIT  = 0 };\r
1103         enum { DUMMY_INITIAL_VALUE_16BIT = 0 };\r
1104         enum { DUMMY_INITIAL_VALUE_TCHAR = 0 };\r
1105         /* 0 reduces code size */\r
1106 #endif\r
1107 \r
1108 \r
1109  \r
1110 /***********************************************************************\r
1111   <<< [DISCARD_STRUCT] >>> \r
1112   <<< [DISCARD_ARRAY] >>> \r
1113   <<< [DISCARD_BYTES] >>> \r
1114   <<< [MEMSET_TO_NOT_INIT] >>> \r
1115 ************************************************************************/\r
1116 #ifndef  ENABLE_DISCARD_STRUCT\r
1117  #if ! NDEBUG\r
1118   #define  ENABLE_DISCARD_STRUCT  1\r
1119  #else\r
1120   #define  ENABLE_DISCARD_STRUCT  0\r
1121  #endif\r
1122 #endif\r
1123 \r
1124 #if  USE_MEMSET_TO_NOT_INIT\r
1125         #define  DISCARD_STRUCT( TypedAddress ) \\r
1126                 memset( TypedAddress, 0xDE, sizeof(*(TypedAddress)) )\r
1127         #define  DISCARD_ARRAY( TypedAddress, Count ) \\r
1128                 memset( TypedAddress, 0xDE, sizeof(*(TypedAddress)) * (Count) )\r
1129         #define  DISCARD_BYTES( Address, ByteSize )  memset( Address, 0xDE, ByteSize )\r
1130 //      #define  MEMSET_TO_NOT_INIT( Address, ByteSize )  memset( Address, 0xDE, ByteSize )\r
1131 #else\r
1132         #define  DISCARD_STRUCT( Address )                __noop()\r
1133         #define  DISCARD_ARRAY( Address, Count )          __noop()\r
1134         #define  DISCARD_BYTES( Address, ByteSize )       __noop()\r
1135 //      #define  MEMSET_TO_NOT_INIT( Address, ByteSize )  __noop()\r
1136 #endif\r
1137 \r
1138 \r
1139  \r
1140 /***********************************************************************\r
1141   <<< [NAME_STR] >>> \r
1142 ************************************************************************/\r
1143 #ifndef  NAME_STR\r
1144  #if ! NDEBUG\r
1145   #define  NAME_STR  1\r
1146  #else\r
1147   #define  NAME_STR  0\r
1148  #endif\r
1149 #endif\r
1150 \r
1151  \r
1152 /***********************************************************************\r
1153   <<< [Error4_VariablesClass] >>> \r
1154 ************************************************************************/\r
1155 typedef struct _Error4_VariablesClass  Error4_VariablesClass;\r
1156 struct _Error4_VariablesClass {\r
1157         DWORD  WindowsLastError;\r
1158 };\r
1159 \r
1160 Error4_VariablesClass*  Get_Error4_Variables(void);\r
1161 \r
1162 #ifdef _DEBUG\r
1163         extern Error4_VariablesClass*  g_Error4_Variables;\r
1164 #endif\r
1165 \r
1166 \r
1167  \r
1168 #if  __cplusplus\r
1169  }  /* End of C Symbol */ \r
1170 #endif\r
1171  \r
1172 /*=================================================================*/\r
1173 /* <<< [FileT/FileT.h] >>> */ \r
1174 /*=================================================================*/\r
1175  \r
1176 #if  __cplusplus\r
1177  extern "C" {  /* Start of C Symbol */ \r
1178 #endif\r
1179 \r
1180 #define  FileT_isExistWildcard  1\r
1181 bool  FileT_isExist( const TCHAR* path );\r
1182 bool  FileT_isFile( const TCHAR* path );\r
1183 bool  FileT_isDir( const TCHAR* path );\r
1184 int   FileT_isDiff( const TCHAR* Path1, const TCHAR* Path2, bool* bDiff );\r
1185 int   FileT_isSameText( TCHAR* Path1, TCHAR* Path2, int Format1, int Format2, bool* out_bSame );\r
1186 int   FileT_isSameBinaryFile( const TCHAR* PathA, const TCHAR* PathB, int Flags, bool* out_IsSame );\r
1187 \r
1188 \r
1189  \r
1190 /* FileT_CallByNestFindData */ \r
1191 typedef struct {\r
1192         void*     CallerArgument;\r
1193         TCHAR*    FullPath;  // abstruct path\r
1194         TCHAR*    StepPath;\r
1195         TCHAR*    FileName;\r
1196         DWORD     FileAttributes;\r
1197 } FileT_CallByNestFindData;\r
1198 \r
1199 int  FileT_callByNestFind( const TCHAR* Path, BitField Flags, void* Obj, FuncType Callback );\r
1200 \r
1201 enum { FileT_FolderBeforeFiles = 1 };\r
1202 enum { FileT_FolderAfterFiles  = 2 };\r
1203 enum { FileT_Folder = FILE_ATTRIBUTE_DIRECTORY };\r
1204 \r
1205  \r
1206 /***********************************************************************\r
1207   <<< [FileT_Read] >>> \r
1208 ************************************************************************/\r
1209 int  FileT_openForRead( FILE** out_pFile, const TCHAR* path );\r
1210 // int  FileT_close( FILE* File, int e );\r
1211 errnum_t  FileT_closeAndNULL( FILE** in_out_File, errnum_t e );\r
1212 \r
1213 \r
1214  \r
1215 /***********************************************************************\r
1216 * Class: ViewOfFileClass\r
1217 ************************************************************************/\r
1218 typedef struct _ViewOfFileClass  ViewOfFileClass;\r
1219 struct _ViewOfFileClass {\r
1220         byte_t* Data;\r
1221         size_t  Size;\r
1222         HANDLE  File;\r
1223         HANDLE  Memory;\r
1224 };\r
1225 void      ViewOfFileClass_initConst( ViewOfFileClass* self );\r
1226 errnum_t  ViewOfFileClass_initializeFromBinaryFile( ViewOfFileClass* self,  const TCHAR* Path );\r
1227 errnum_t  ViewOfFileClass_finalize( ViewOfFileClass* self,  errnum_t e );\r
1228 \r
1229 \r
1230  \r
1231 #if  __cplusplus\r
1232  }  /* End of C Symbol */ \r
1233 #endif\r
1234  \r
1235 /*=================================================================*/\r
1236 /* <<< [Locale/Locale.h] >>> */ \r
1237 /*=================================================================*/\r
1238  \r
1239 #if  __cplusplus\r
1240  extern "C" {  /* Start of C Symbol */ \r
1241 #endif\r
1242 \r
1243 \r
1244  \r
1245 /***********************************************************************\r
1246   <<< [Locale] >>> \r
1247 ************************************************************************/\r
1248 extern char*  g_LocaleSymbol;\r
1249 int  Locale_init(void);\r
1250 int  Locale_isInited(void);\r
1251 \r
1252 \r
1253  \r
1254 #if  __cplusplus\r
1255  }  /* End of C Symbol */ \r
1256 #endif\r
1257 \r
1258 \r
1259  \r
1260 /*=================================================================*/\r
1261 /* <<< [PlatformSDK_plus/PlatformSDK_plus.h] >>> */ \r
1262 /*=================================================================*/\r
1263  \r
1264 int  GetCommandLineUnnamed( int Index1, TCHAR* out_AParam, size_t AParamSize ); \r
1265 int  GetCommandLineNamed( const TCHAR* Name, bool bCase, TCHAR* out_Value, size_t ValueSize );\r
1266 int  GetCommandLineNamedC8( const TCHAR* Name, bool bCase, char* out_Value, size_t ValueSize );\r
1267 int  GetCommandLineNamedI( const TCHAR* Name, bool bCase, int* out_Value );\r
1268 bool GetCommandLineExist( const TCHAR* Name, bool bCase );\r
1269 \r
1270 #if ! _UNICODE\r
1271         #define  GetCommandLineNamedC8  GetCommandLineNamed\r
1272 #endif\r
1273 \r
1274  \r
1275 /*=================================================================*/\r
1276 /* <<< [Global0/Global0.h] >>> */ \r
1277 /*=================================================================*/\r
1278  \r
1279 #if  __cplusplus\r
1280  extern "C" {  /* Start of C Symbol */ \r
1281 #endif\r
1282 \r
1283 \r
1284  \r
1285 /***********************************************************************\r
1286   <<< [Globals] >>> \r
1287 ************************************************************************/\r
1288 #define  USE_GLOBALS  1\r
1289 \r
1290 void Globals_initConst(void);\r
1291 int  Globals_initialize(void);\r
1292 int  Globals_finalize( int e );\r
1293 \r
1294 #if NDEBUG\r
1295   #define  get_InitedObject( m, isInited )  (m)\r
1296 #else\r
1297   #define  get_InitedObject( m, isInited )  ( isInited( m ) ? (m) : (DebugBreakR(), (m)) )\r
1298 #endif\r
1299 \r
1300 \r
1301  \r
1302 #if  __cplusplus\r
1303  }  /* End of C Symbol */ \r
1304 #endif\r
1305  \r
1306 #endif  // __CLIB_H \r
1307 \r
1308 #ifdef _MSC_VER\r
1309  #if  showIncludes\r
1310   #pragma message( "end of #include  \"" __FILE__ "\"" )\r
1311  #endif\r
1312 #endif\r
1313  \r