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