_src/Test/tools/scriptlib/vbslib/CheckEnglishOnly/CheckEnglishOnly_src/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 /***********************************************************************\r
 505   <<< [Set2a] >>> \r
 506 ************************************************************************/\r
 507 typedef  struct _Set2  Set2a;\r
 508 \r
 509 void  Set2a_initConst( Set2a* m, void* ArrInStack );\r
 510 int   Set2a_init( Set2a* m, void* ArrInStack, size_t ArrInStack_Size );\r
 511 int   Set2a_finish( Set2a* m, void* ArrInStack, int e );\r
 512 int   Set2a_toEmpty( Set2a* m );\r
 513 //int Set2a_alloc( Set2a* m, void* ArrInStack, ClassA** out_p, Type ClassA );\r
 514 int   Set2a_expandIfOverByAddr( Set2a* m, void* OverAddrBasedOnNowFirst );\r
 515 \r
 516 \r
 517 \r
 518 // for inside\r
 519 \r
 520 #define  Set2a_initConst( m, ArrInStack ) \\r
 521         ( (m)->First = (ArrInStack) )\r
 522 \r
 523 #define  Set2a_finish( m, ArrInStack, e ) \\r
 524         ( (m)->First == (ArrInStack) ? (e) : ( free( (m)->First ), (e) ) )\r
 525 \r
 526 #define  Set2a_toEmpty( m ) \\r
 527         Set2_toEmpty( m )\r
 528 \r
 529 #define  Set2a_alloc( m, ArrInStack, out_Pointer, ClassA ) \\r
 530         ( (void*)( (ClassA*)((m)->Next) + 1 ) <= (m)->Over ? \\r
 531                 ( *(out_Pointer) = (ClassA*)(m)->Next,  (m)->Next = (ClassA*)((m)->Next) + 1, 0 ) : \\r
 532                 Set2a_alloc_imp( m, ArrInStack, out_Pointer, sizeof(ClassA) ) )\r
 533 \r
 534 int  Set2a_alloc_imp( Set2a* m, void* ArrInStack, void* out_Pointer, size_t ElemSize );\r
 535 \r
 536 #define  Set2a_expandIfOverByAddr( m, ArrInStack, OverAddrBasedOnNowFirst ) \\r
 537         ( (void*)(OverAddrBasedOnNowFirst) <= (m)->Over ? 0 : \\r
 538                 Set2a_expandIfOverByAddr_imp( m, ArrInStack, OverAddrBasedOnNowFirst ) )\r
 539 \r
 540 int  Set2a_expandIfOverByAddr_imp( Set2a* m, void* ArrInStack, void* OverAddrBasedOnNowFirst );\r
 541 \r
 542 \r
 543  \r
 544 #ifdef  __cplusplus\r
 545  }  /* End of C Symbol */ \r
 546 #endif\r
 547 #endif\r
 548  \r
 549 /*=================================================================*/\r
 550 /* <<< [DebugTools/DebugTools.h] >>> */ \r
 551 /*=================================================================*/\r
 552  \r
 553 #if  __cplusplus\r
 554  extern "C" {  /* Start of C Symbol */ \r
 555 #endif\r
 556 \r
 557 \r
 558 #ifndef NDEBUG\r
 559         #define  NDEBUG_ERROR\r
 560 #else\r
 561         #define  NDEBUG_ERROR  ___cut_NDEBUG_ERROR\r
 562 #endif\r
 563 \r
 564  \r
 565 /*[dll_global_g_DebugBreakCount]*/\r
 566 #ifndef  dll_global_g_DebugBreakCount\r
 567         #define  dll_global_g_DebugBreakCount\r
 568 #endif\r
 569  \r
 570 /***********************************************************************\r
 571   <<< [TestableDebugBreak] >>> \r
 572 ************************************************************************/\r
 573 #define  TestableDebugBreak()  ( TestableDebugBreak_Sub() ? (DebugBreakR(),0) : 0 )\r
 574 int      TestableDebugBreak_Sub(void);\r
 575 \r
 576 void     SetTestableDebugBreak( bool IsEnableBreak );\r
 577 int      GetDebugBreakCount(void);\r
 578 \r
 579 \r
 580  \r
 581 #if  __cplusplus\r
 582  }  /* End of C Symbol */ \r
 583 #endif\r
 584 \r
 585 \r
 586  \r
 587 /*=================================================================*/\r
 588 /* <<< [StrT/StrT.h] >>> */ \r
 589 /*=================================================================*/\r
 590  \r
 591 #if  __cplusplus\r
 592  extern "C" {  /* Start of C Symbol */ \r
 593 #endif\r
 594 \r
 595 errnum_t  StrT_cpy( TCHAR* Dst, size_t DstSize, const TCHAR* Src );\r
 596 errnum_t  StrT_cat( TCHAR* Dst, size_t DstSize, const TCHAR* Src );\r
 597 TCHAR*  StrT_chr( const TCHAR* String, TCHAR Key );\r
 598 TCHAR*  StrT_chrs( const TCHAR* s, const TCHAR* keys );\r
 599 TCHAR*  StrT_rstr( const TCHAR* String, const TCHAR* SearchStart, const TCHAR* Keyword,\r
 600         void* NullConfig );\r
 601 TCHAR*  StrT_chrNext( const TCHAR* in_Start, TCHAR in_KeyCharactor );\r
 602 TCHAR*  StrT_skip( const TCHAR* s, const TCHAR* keys );\r
 603 TCHAR*  StrT_rskip( const TCHAR* String, const TCHAR* SearchStart, const TCHAR* Keys,\r
 604         void* NullConfig );\r
 605 bool    StrT_isCIdentifier( TCHAR Character );\r
 606 TCHAR*  StrT_searchOverOfCIdentifier( const TCHAR* Text );\r
 607 TCHAR*  StrT_searchOverOfIdiom( const TCHAR* Text );\r
 608 int  StrT_cmp_part( const TCHAR* StringA_Start, const TCHAR* StringA_Over,\r
 609         const TCHAR* StringB );\r
 610 int  StrT_cmp_i_part( const TCHAR* StringA_Start, const TCHAR* StringA_Over,\r
 611         const TCHAR* StringB );\r
 612 int  StrT_cmp_part2( const TCHAR* StringA_Start, const TCHAR* StringA_Over,\r
 613         const TCHAR* StringB_Start, const TCHAR* StringB_Over );\r
 614 #define  TwoChar8( Character1, Character2 ) \\r
 615         ( (Character1) + ( (Character2) << 8 ) )\r
 616 #define  FourChar8( Character1, Character2, Character3, Character4 ) \\r
 617         ( (Character1) + ( (Character2) << 8 ) + ( (Character3) << 16 ) + ( (Character4) << 24 ) )\r
 618 \r
 619 inline errnum_t  StrT_cat( TCHAR* Dst, size_t DstSize, const TCHAR* Src )\r
 620 {\r
 621         return  stcpy_part_r( Dst, DstSize, _tcschr( Dst, _T('\0') ), NULL, Src, NULL );\r
 622 }\r
 623 \r
 624 \r
 625  \r
 626 //[GetStringSizeFromPointer]\r
 627 inline size_t  GetStringSizeFromPointer( void* String, size_t StringSize, void* Pointer )\r
 628 {\r
 629         return  (uintptr_t) String + StringSize - (uintptr_t) Pointer;\r
 630 }\r
 631 \r
 632  \r
 633 /***********************************************************************\r
 634   <<< [StrT_Malloc] >>> \r
 635 ************************************************************************/\r
 636 errnum_t  MallocAndCopyString( const TCHAR** out_NewString, const TCHAR* SourceString );\r
 637 errnum_t  MallocAndCopyString_char( const TCHAR** out_NewString, const char* SourceString );\r
 638 errnum_t  MallocAndCopyStringByLength( const TCHAR** out_NewString, const TCHAR* SourceString,\r
 639         unsigned CountOfCharacter );\r
 640 \r
 641 #ifndef _UNICODE\r
 642         #define  MallocAndCopyString_char  MallocAndCopyString\r
 643 #endif\r
 644 \r
 645 errnum_t  StrHS_insert( TCHAR**  in_out_WholeString,\r
 646         int  in_TargetIndexInWholeString,  int*  out_NextWholeInWholeString,\r
 647         const TCHAR*  in_InsertString );\r
 648 errnum_t  StrHS_printf( TCHAR**  in_out_String,  const TCHAR*  in_Format,  ... );\r
 649 errnum_t  StrHS_printfV( TCHAR**  in_out_String,  const TCHAR*  in_Format,  va_list  in_VaList );\r
 650 errnum_t  StrHS_printfPart( TCHAR**  in_out_String,\r
 651         int  in_IndexInString,  int*  out_NextIndexInString,\r
 652         const TCHAR*  in_Format,  ... );\r
 653 errnum_t  StrHS_printfPartV( TCHAR**  in_out_String,\r
 654         int  in_IndexInString,  int*  out_NextIndexInString,\r
 655         const TCHAR*  in_Format,  va_list  in_VaList );\r
 656 \r
 657 \r
 658  \r
 659 /***********************************************************************\r
 660   <<< [StrT_Edit] >>> \r
 661 ************************************************************************/\r
 662 errnum_t  StrT_cutPart( TCHAR*  in_out_String,  TCHAR*  in_StartOfCut,  TCHAR*  in_OverOfCut );\r
 663 errnum_t  StrT_trim( TCHAR* out_Str, size_t out_Str_Size, const TCHAR* in_Str );\r
 664 errnum_t  StrT_cutLastOf( TCHAR* in_out_Str, TCHAR Charactor );\r
 665 errnum_t  StrT_cutLineComment( TCHAR* out_Str, size_t out_Str_Size, const TCHAR* in_Str, const TCHAR* CommentSign );\r
 666 errnum_t  StrT_insert( TCHAR*  in_out_WholeString,  size_t  in_MaxSize_of_WholeString,\r
 667         TCHAR*  in_out_Target_in_WholeString,  TCHAR**  out_NextTarget_in_WholeString,\r
 668         const TCHAR*  in_InsertString );\r
 669 errnum_t  StrT_meltCmdLine( TCHAR* out_Str, size_t out_Str_Size, const TCHAR** pLine );\r
 670 errnum_t  StrT_getExistSymbols( unsigned* out, bool bCase, const TCHAR* Str, const TCHAR* Symbols, ... );\r
 671 errnum_t  StrT_replace1( TCHAR* in_out_String, TCHAR FromCharacter, TCHAR ToCharacter,\r
 672         unsigned Opt );\r
 673 \r
 674 \r
 675  \r
 676 /***********************************************************************\r
 677   <<< [StrT_Edit2] >>> \r
 678 ************************************************************************/\r
 679 errnum_t  StrT_replace( TCHAR* Out, size_t OutSize, const TCHAR* In,\r
 680                    const TCHAR* FromStr, const TCHAR* ToStr, unsigned Opt );\r
 681 errnum_t  StrT_changeToXML_Attribute( TCHAR* out_Str, size_t StrSize, const TCHAR* InputStr );\r
 682 errnum_t  StrT_resumeFromXML_Attribute( TCHAR* out_Str, size_t out_Str_Size, const TCHAR* XML_Attr );\r
 683 errnum_t  StrT_changeToXML_Text( TCHAR* out_Str, size_t StrSize, const TCHAR* InputStr );\r
 684 \r
 685 enum { STR_1TIME = 1 };\r
 686 \r
 687 \r
 688  \r
 689 /***********************************************************************\r
 690   <<< [W3CDTF] >>> \r
 691 ************************************************************************/\r
 692 enum { W3CDTF_MAX_LENGTH = 27+3 };  /* \8f¬\90\943\8c\85 */\r
 693 enum { W3CDTF_CURRENT_TIME_ZONE = 9999 };\r
 694 \r
 695 errnum_t  W3CDTF_fromSYSTEMTIME( TCHAR* out_W3CDTF, size_t W3CDTF_ByteSize,\r
 696         const SYSTEMTIME* Time, int TimeZoneMinute );\r
 697 errnum_t  W3CDTF_toSYSTEMTIME( const TCHAR* String, SYSTEMTIME* out_Time, int* out_BiasMinute );\r
 698 errnum_t  W3CDTF_getTimeZoneDesignator( TCHAR* out_TZD, size_t TZD_ByteSize,\r
 699         int  BiasMinute );\r
 700 \r
 701 \r
 702  \r
 703 /***********************************************************************\r
 704   <<< [StrT_Path] >>> \r
 705 ************************************************************************/\r
 706 enum { StrT_LocalPathMaxSize = 4096 };\r
 707 enum { MAX_LOCAL_PATH = 4096 };\r
 708 TCHAR*  StrT_refFName( const TCHAR* s );\r
 709 TCHAR*  StrT_refExt( const TCHAR* s );\r
 710 void  StrT_cutFragmentInPath( TCHAR* in_out_Path );\r
 711 bool  StrT_isFullPath( const TCHAR* s );\r
 712 \r
 713 errnum_t  StrT_getFullPath_part( TCHAR* Str, size_t StrSize, TCHAR* StrStart,\r
 714         TCHAR** out_StrLast, const TCHAR* StepPath, const TCHAR* BasePath );\r
 715 errnum_t  StrT_allocateFullPath( TCHAR** out_FullPath, const TCHAR* StepPath, TCHAR* BasePath );\r
 716 errnum_t  StrT_getStepPath( TCHAR* out_StepPath, size_t StepPathSize,\r
 717         const TCHAR* FullPath, const TCHAR* BasePath );\r
 718 errnum_t  StrT_getParentFullPath_part( TCHAR* Str, size_t StrSize, TCHAR* StrStart,\r
 719         TCHAR** out_StrLast, const TCHAR* StepPath, const TCHAR* BasePath );\r
 720 errnum_t  StrT_getBaseName_part( TCHAR* Str, size_t StrSize, TCHAR* StrStart,\r
 721         TCHAR** out_StrLast, const TCHAR* SrcPath );\r
 722 errnum_t  StrT_addLastOfFileName( TCHAR* out_Path, size_t PathSize,\r
 723                              const TCHAR* BasePath, const TCHAR* AddName );\r
 724 errnum_t  StrT_encodeToValidPath( TCHAR* out_Path,  size_t in_OutPathSize,  const TCHAR* in_Path,  bool  in_IsName );\r
 725 \r
 726 inline errnum_t  StrT_getFullPath( TCHAR* out_FullPath, size_t FullPathSize,\r
 727         const TCHAR* StepPath, const TCHAR* BasePath )\r
 728 {\r
 729         return  StrT_getFullPath_part( out_FullPath, FullPathSize, out_FullPath,\r
 730                 NULL, StepPath, BasePath );\r
 731 }\r
 732 \r
 733 inline errnum_t  StrT_getParentFullPath( TCHAR* Str, size_t StrSize,\r
 734         const TCHAR* SrcPath, const TCHAR* BasePath )\r
 735 {\r
 736         return StrT_getParentFullPath_part( Str, StrSize, Str, NULL, SrcPath, BasePath );\r
 737 }\r
 738 \r
 739 inline errnum_t  StrT_getBaseName( TCHAR* Str, size_t StrSize, const TCHAR* SrcPath )\r
 740 {\r
 741         return  StrT_getBaseName_part( Str, StrSize, Str, NULL, SrcPath );\r
 742 }\r
 743 \r
 744 \r
 745  \r
 746 /**************************************************************************\r
 747   <<< [StrT_Mul] >>> \r
 748 ***************************************************************************/\r
 749 typedef  struct _StrT_Mul  StrT_Mul;\r
 750 struct _StrT_Mul {\r
 751         TCHAR*  First;\r
 752         size_t  Size;  /* byte */\r
 753         TCHAR*  Next;\r
 754 \r
 755         #if ! NDEBUG\r
 756                 int  BreakOffset;\r
 757         #endif\r
 758 };\r
 759 \r
 760 #define  StrT_Mul_initConst( m )  ( (m)->First = NULL )\r
 761 errnum_t  StrT_Mul_init( StrT_Mul* m );\r
 762 #define  StrT_Mul_finish( m, e )  ( (m)->First != NULL ? free( (m)->First ), (e) : (e) )\r
 763 #define  StrT_Mul_isInited( m )  ( (m)->First != NULL )\r
 764 errnum_t  StrT_Mul_add( StrT_Mul* m, const TCHAR* Str, unsigned* out_Offset );\r
 765 errnum_t  StrT_Mul_toEmpty( StrT_Mul* m );\r
 766 #define  StrT_Mul_forEach( m, pStr ) \\r
 767         *(pStr) = StrT_Mul_getFirst( m ); \\r
 768         *(pStr) != NULL; \\r
 769         *(pStr) = StrT_Mul_getNext( m, *(pStr) )\r
 770 #define  StrT_Mul_getFirst( m )  ((m)->First == (m)->Next ? NULL : (m)->First )\r
 771 #define  StrT_Mul_getNext( m, p ) \\r
 772          ( (p) = _tcschr( p, _T('\0') ) + 1, (p) == (m)->Next ? NULL : (p) )\r
 773 errnum_t  StrT_Mul_freeLast( StrT_Mul* m, TCHAR* AllocStr );\r
 774 inline errnum_t  StrT_Mul_getFromOffset( StrT_Mul* m, unsigned Offset, TCHAR** out_Str );\r
 775 \r
 776 #define  StrT_Mul_getFreeAddr( m )  ((m)->Next)\r
 777 #define  StrT_Mul_getFreeSize( m )  ( (m)->Size - ((char*)(m)->Next - (char*)(m)->First) - sizeof(TCHAR) )\r
 778 #define  StrT_Mul_getFreeCount( m ) ( StrT_Mul_getFreeSize( m ) / sizeof(TCHAR) )\r
 779 #define  StrT_Mul_expandCount( m, c )  ( StrT_Mul_expandSize( (m), (c) * sizeof(TCHAR) ) )\r
 780 errnum_t  StrT_Mul_expandSize( StrT_Mul* m, size_t FreeSize );\r
 781 errnum_t  StrT_Mul_commit( StrT_Mul* m );\r
 782 \r
 783 \r
 784 \r
 785 // implements\r
 786 \r
 787 //[StrT_Mul_getFromOffset]\r
 788 inline errnum_t  StrT_Mul_getFromOffset( StrT_Mul* m, unsigned Offset, TCHAR** out_Str )\r
 789 {\r
 790         TCHAR*  str = (TCHAR*)( (char*)m->First + Offset );\r
 791 \r
 792         if ( (int)Offset < 0 )  return  E_NOT_FOUND_SYMBOL;\r
 793         if ( str > m->Next )    return  E_NOT_FOUND_SYMBOL;\r
 794 \r
 795         *out_Str = str;\r
 796         return  0;\r
 797 }\r
 798 \r
 799 \r
 800  \r
 801 /**************************************************************************\r
 802   <<< [Strs] >>> \r
 803 ***************************************************************************/\r
 804 typedef  struct _Strs  Strs;\r
 805 struct _Strs {\r
 806         byte_t*  MemoryAddress;   /* first memory = [ TCHAR* FirstStr | elem[] ],  other memory = [ elem[] ] */\r
 807         byte_t*  MemoryOver;\r
 808         byte_t*  NextElem;        /* elem = [ TCHAR* NextStr | TCHAR[] ] */\r
 809         TCHAR**  PointerToNextStrInPrevElem;  /* first = &FirstStr,  other = &NextStr */\r
 810         TCHAR**  Prev_PointerToNextStrInPrevElem;\r
 811 \r
 812         Strs*   FirstOfStrs;\r
 813         Strs*   NextStrs;\r
 814 };\r
 815 \r
 816 void Strs_initConst( Strs* m );\r
 817 errnum_t  Strs_init( Strs* m );\r
 818 errnum_t  Strs_finish( Strs* m, errnum_t e );\r
 819 errnum_t  Strs_toEmpty( Strs* m );\r
 820 bool Strs_isInited( Strs* m );\r
 821 errnum_t  Strs_add( Strs* m, const TCHAR* Str, const TCHAR** out_pAlloc );\r
 822 errnum_t  Strs_addBinary( Strs* m, const TCHAR* Str, const TCHAR* StrOver, const TCHAR** out_AllocStr );\r
 823 errnum_t  Strs_freeLast( Strs* m, TCHAR* AllocStr );\r
 824 errnum_t  Strs_toEmpty( Strs* m );\r
 825 /* for ( Strs_forEach( Strs* m, TCHAR** in_out_Str ) ); */\r
 826 TCHAR*  Strx_getFirst( Strs* m );\r
 827 TCHAR*  Strx_getNext( Strs* m, TCHAR* Str );\r
 828 \r
 829 \r
 830 #define  Strs_initConst( m )  ( (m)->MemoryAddress =  NULL )\r
 831 #define  Strs_isInited( m )    ( (m)->MemoryAddress != NULL )\r
 832 \r
 833 #define  Strs_forEach( m, pStr ) \\r
 834         *(pStr) = Strs_getFirst( m ); \\r
 835         *(pStr) != NULL; \\r
 836         *(pStr) = Strs_getNext( m, *(pStr) )\r
 837 \r
 838 #define  Strs_getFirst( m ) \\r
 839         ( *(TCHAR**) (m)->FirstOfStrs->MemoryAddress )\r
 840 \r
 841 #define  Strs_getNext( m, p ) \\r
 842         ( *( (TCHAR**)(p) - 1 ) )\r
 843 \r
 844 #define  Strs_getFreeAddr( m )  ( (TCHAR*)( (m)->NextElem + sizeof(TCHAR*) ) )\r
 845 #define  Strs_getFreeSize( m )  ( (m)->MemoryOver - (byte_t*)(m)->NextElem - sizeof(TCHAR*) )\r
 846 #define  Strs_getFreeCount( m ) ( Strs_getFreeSize( m ) / sizeof(TCHAR) )\r
 847 #define  Strs_expandCount( m, c )  ( Strs_expandSize( (m), (c) * sizeof(TCHAR) ) )\r
 848 errnum_t  Strs_expandSize( Strs* m, size_t FreeSize );\r
 849 errnum_t  Strs_commit( Strs* m, TCHAR* StrOver );\r
 850 errnum_t  Strs_allocateArray( Strs* self,  TCHAR*** out_PointerArray,  int* out_Count );\r
 851 \r
 852 \r
 853  \r
 854 /***********************************************************************\r
 855   <<< [StrArr] >>> \r
 856 ************************************************************************/\r
 857 typedef struct _StrArr  StrArr;\r
 858 struct _StrArr {\r
 859         Set2  Array;  // array of TCHAR*\r
 860         Strs  Chars;\r
 861 };\r
 862 \r
 863 errnum_t  StrArr_init( StrArr* m );\r
 864 errnum_t  StrArr_finish( StrArr* m, errnum_t e );\r
 865 \r
 866 errnum_t  StrArr_add( StrArr* m, const TCHAR* Str, int* out_I );\r
 867 errnum_t  StrArr_commit( StrArr* m );\r
 868 errnum_t  StrArr_fillTo( StrArr* m, int n, const TCHAR* Str );\r
 869 errnum_t  StrArr_toEmpty( StrArr* m );\r
 870 \r
 871 #define  StrArr_initConst( m )   Set2_initConst( &(m)->Array )\r
 872 #define  StrArr_getFreeAddr( m )  Strs_getFreeAddr( &(m)->Chars )\r
 873 #define  StrArr_getFreeSize( m )  Strs_getFreeSize( &(m)->Chars )\r
 874 #define  StrArr_getFreeCount( m ) Strs_getFreeCount( &(m)->Chars )\r
 875 #define  StrArr_expandSize( m, sz )  Strs_expandSize( &(m)->Chars, sz )\r
 876 #define  StrArr_expandCount( m, c )  Strs_expandCount( &(m)->Chars, c )\r
 877 #define  StrArr_getArray( m )     ((TCHAR**)(m)->Array.First)\r
 878 //#define  StrArr_getN( m )          Set2_getCount( &(m)->Array, TCHAR* )\r
 879 #define  StrArr_getCount( m )        Set2_getCount( &(m)->Array, TCHAR* )\r
 880 \r
 881 \r
 882  \r
 883 /***********************************************************************\r
 884   <<< [StrArr_forEach] >>> \r
 885 ************************************************************************/\r
 886 #define  StrArr_forEach( self, Iterator, out_String ) \\r
 887         StrArr_forEach_1( self, Iterator, out_String ); \\r
 888         StrArr_forEach_2( Iterator ); \\r
 889         StrArr_forEach_3( Iterator, out_String )\r
 890 \r
 891 /*[StrArrIterator]*/\r
 892 typedef struct _StrArrIterator  StrArrIterator;\r
 893 struct _StrArrIterator {\r
 894         const TCHAR**  Pointer;\r
 895         const TCHAR**  PointerOver;\r
 896 };\r
 897 \r
 898 inline void  StrArr_forEach_1( StrArr* self, StrArrIterator* Iterator, const TCHAR** out_String )\r
 899 {\r
 900         Iterator->Pointer = (const TCHAR**) self->Array.First;\r
 901         Iterator->PointerOver = (const TCHAR**) self->Array.Next;\r
 902         *out_String = *Iterator->Pointer;\r
 903 }\r
 904 \r
 905 inline bool  StrArr_forEach_2( StrArrIterator* Iterator )\r
 906 {\r
 907         return  Iterator->Pointer < Iterator->PointerOver;\r
 908 }\r
 909 \r
 910 inline void  StrArr_forEach_3( StrArrIterator* Iterator, const TCHAR** out_String )\r
 911 {\r
 912         Iterator->Pointer += 1;\r
 913         *out_String = *Iterator->Pointer;\r
 914 }\r
 915 \r
 916 \r
 917  \r
 918 /***********************************************************************\r
 919   <<< [CSV] >>> \r
 920 ************************************************************************/\r
 921 errnum_t  StrT_meltCSV( TCHAR* out_Str, size_t out_Str_Size, const TCHAR** pCSV );\r
 922 errnum_t  StrArr_parseCSV( StrArr* m, const TCHAR* CSVLine );\r
 923 errnum_t  StrT_parseCSV_f( const TCHAR* StringOfCSV, bit_flags32_t* out_ReadFlags, const TCHAR* Types, ... );\r
 924 \r
 925 \r
 926  \r
 927 /***********************************************************************\r
 928   <<< [StrMatchKey] >>> \r
 929 ************************************************************************/\r
 930 typedef struct _StrMatchKey  StrMatchKey;\r
 931 struct _StrMatchKey {\r
 932         TCHAR*  Keyword;\r
 933         TCHAR*  WildcardLeftStr;\r
 934         size_t  WildcardLeftLength;\r
 935         TCHAR*  WildcardRightStr;\r
 936         size_t  WildcardRightLength;\r
 937 };\r
 938 void      StrMatchKey_initConst( StrMatchKey* m );\r
 939 errnum_t  StrMatchKey_init( StrMatchKey* m, const TCHAR* Keyword );\r
 940 errnum_t  StrMatchKey_finish( StrMatchKey* m, errnum_t e );\r
 941 bool      StrMatchKey_isMatch( StrMatchKey* m, const TCHAR* String );\r
 942 \r
 943 \r
 944  \r
 945 #if  __cplusplus\r
 946  }  /* End of C Symbol */ \r
 947 #endif\r
 948 \r
 949  \r
 950 /*=================================================================*/\r
 951 /* <<< [CRT_plus_2/CRT_plus_2.h] >>> */ \r
 952 /*=================================================================*/\r
 953  \r
 954 /***********************************************************************\r
 955   <<< [HeapMemory_allocate] >>> \r
 956   <<< [HeapMemory_allocateArray] >>> \r
 957 ************************************************************************/\r
 958 \r
 959 #define  HeapMemory_allocate( out_Pointer ) \\r
 960     HeapMemory_allocateBytes( out_Pointer, sizeof( **(out_Pointer) ) )\r
 961 \r
 962 #define  HeapMemory_allocateArray( out_Pointer, Count ) \\r
 963     HeapMemory_allocateBytes( out_Pointer, sizeof( **(out_Pointer) ) * (Count) )\r
 964 \r
 965 inline errnum_t  HeapMemory_allocateBytes( void* out_Pointer, size_t MemorySize )\r
 966 {\r
 967         void**  out = (void**) out_Pointer;\r
 968 \r
 969         *out = malloc( MemorySize );\r
 970 \r
 971         if ( *out == NULL )\r
 972                 { return  E_FEW_MEMORY; }\r
 973         else\r
 974                 { return  0; }\r
 975 }\r
 976 \r
 977 \r
 978 /*[MallocMemory]*/\r
 979 inline errnum_t  MallocMemory( void* out_MemoryAddress, size_t MemorySize )\r
 980 {\r
 981         return  HeapMemory_allocateBytes( out_MemoryAddress, MemorySize );\r
 982 }\r
 983 \r
 984 \r
 985  \r
 986 /***********************************************************************\r
 987   <<< [HeapMemory_free] >>> \r
 988 ************************************************************************/\r
 989 inline errnum_t  HeapMemory_free( const void* in_out_MemoryAddress, errnum_t e )\r
 990 {\r
 991         void*  address = *(void**) in_out_MemoryAddress;\r
 992 \r
 993         if ( address != NULL )\r
 994                 { free( address ); }\r
 995 \r
 996         *(void**) in_out_MemoryAddress = NULL;\r
 997 \r
 998         return  e;\r
 999 }\r
1000 \r
1001 \r
1002 /*[FreeMemory]*/\r
1003 inline errnum_t  FreeMemory( const void* in_out_MemoryAddress, errnum_t e )\r
1004 {\r
1005         return  HeapMemory_free( in_out_MemoryAddress, e );\r
1006 }\r
1007 \r
1008 \r
1009  \r
1010 /*=================================================================*/\r
1011 /* <<< [Error4/Error4.h] >>> */ \r
1012 /*=================================================================*/\r
1013  \r
1014 #if  __cplusplus\r
1015  extern "C" {  /* Start of C Symbol */ \r
1016 #endif\r
1017 \r
1018 \r
1019  \r
1020 /***********************************************************************\r
1021   <<< [SetBreakErrorID] >>> \r
1022 ************************************************************************/\r
1023 #ifndef  ENABLE_ERROR_BREAK_IN_ERROR_CLASS\r
1024         #if ! NDEBUG\r
1025                 #define  ENABLE_ERROR_BREAK_IN_ERROR_CLASS  1\r
1026         #else\r
1027                 #define  ENABLE_ERROR_BREAK_IN_ERROR_CLASS  0\r
1028         #endif\r
1029 #endif\r
1030 \r
1031 #ifndef  ENABLE_DEBUG_ERROR_BREAK_IN_ERROR_CLASS\r
1032         #if ! NDEBUG\r
1033                 #define  ENABLE_DEBUG_ERROR_BREAK_IN_ERROR_CLASS  1\r
1034         #else\r
1035                 #define  ENABLE_DEBUG_ERROR_BREAK_IN_ERROR_CLASS  0\r
1036         #endif\r
1037 #endif\r
1038 \r
1039 #ifndef  IS_MULTI_THREAD_ERROR_CLASS\r
1040  \r
1041         #define  IS_MULTI_THREAD_ERROR_CLASS  0  /*[IS_MULTI_THREAD_ERROR_CLASS]:single*/\r
1042  \r
1043 #endif\r
1044 \r
1045 #ifndef  NDEBUG\r
1046         #define  ERR2_ENABLE_ERROR_LOG  1\r
1047 #else\r
1048         #define  ERR2_ENABLE_ERROR_LOG  0\r
1049 #endif\r
1050 \r
1051 /*[dll_global_g_Error]*/\r
1052 #ifndef  dll_global_g_Error\r
1053         #define  dll_global_g_Error\r
1054 #endif\r
1055 \r
1056 \r
1057 #if ENABLE_ERROR_BREAK_IN_ERROR_CLASS\r
1058         /*[IF][IF_D][ASSERT_R][ASSERT_D]*/\r
1059         /* "IF" is able to break at nearest code raising error */\r
1060         #define  IF_D(x)  IF(x)\r
1061         #define  IF(x) \\r
1062                 if( (x) && ( OnRaisingError_Sub((const char*)__FILE__,__LINE__) ? (DebugBreakR(),1) : (1) ) )\r
1063 \r
1064         #define  ASSERT_R( x, goto_err_or_Statement ) \\r
1065                 __pragma(warning(push)) \\r
1066                 __pragma(warning(disable:4127)) \\r
1067                         do{  IF(!(x)) { goto_err_or_Statement; } }  while(0)   /* do-while is CERT standard PRE10-C */ \\r
1068                 __pragma(warning(pop))\r
1069 \r
1070         #define  ASSERT_D( x, goto_err_or_Statement )  ASSERT_R( x, goto_err_or_Statement )\r
1071 #else\r
1072         #define  IF(x)  if(x)\r
1073         #define  IF_D(x) \\r
1074                 __pragma(warning(push)) \\r
1075                 __pragma(warning(disable:4127)) \\r
1076                         if(0) \\r
1077                 __pragma(warning(pop))\r
1078 \r
1079         #define  ASSERT_R( x, goto_err_or_Statement ) \\r
1080                 __pragma(warning(push)) \\r
1081                 __pragma(warning(disable:4127)) \\r
1082                         do{  if(!(x)) { goto_err_or_Statement; } }while(0)   /* do-while is CERT standard PRE10-C */ \\r
1083                 __pragma(warning(pop))\r
1084 \r
1085         #define  ASSERT_D( x, goto_err_or_Statement )\r
1086 #endif\r
1087 \r
1088 \r
1089 void  DebugBreakR(void);\r
1090 #if ! ENABLE_ERROR_BREAK_IN_ERROR_CLASS\r
1091         inline void  SetBreakErrorID( int ID ) { ID=ID; /* avoid warning */ }\r
1092         inline void  ClearError() {}\r
1093         inline void  IfErrThenBreak() {}\r
1094         typedef  int  ErrStackAreaClass;  // dummy type\r
1095         inline void  PushErr( ErrStackAreaClass* ErrStackArea )  { UNREFERENCED_VARIABLE( ErrStackArea ); }\r
1096         inline void  PopErr(  ErrStackAreaClass* ErrStackArea )  { UNREFERENCED_VARIABLE( ErrStackArea ); }\r
1097 #else\r
1098         void  SetBreakErrorID( int ID );\r
1099         void  ClearError(void);\r
1100         void  IfErrThenBreak(void);\r
1101         typedef  struct _ErrorClass  ErrStackAreaClass;\r
1102         void  PushErr( ErrStackAreaClass* ErrStackArea );\r
1103         void  PopErr(  ErrStackAreaClass* ErrStackArea );\r
1104 \r
1105         bool  OnRaisingError_Sub( const char* FilePath, int LineNum );\r
1106 \r
1107         typedef  struct _ErrorClass  ErrorClass;  /*[ErrorClass]*/\r
1108         struct _ErrorClass {\r
1109                 bool         IsError;\r
1110                 #if  ENABLE_DEBUG_ERROR_BREAK_IN_ERROR_CLASS\r
1111                         int     ErrorID;\r
1112                 #endif\r
1113                 int          BreakErrorID;\r
1114                 const char*  FilePath;\r
1115                 int          LineNum;\r
1116 \r
1117                 #if IS_MULTI_THREAD_ERROR_CLASS\r
1118                         FinalizerClass  Finalizer;\r
1119                         #if  ENABLE_DEBUG_ERROR_BREAK_IN_ERROR_CLASS\r
1120                                 DWORD  ThreadID;\r
1121                                 int    GlobalErrorID;\r
1122                         #endif\r
1123                 #endif\r
1124         };\r
1125         errnum_t  ErrorClass_finalize( ErrorClass* self, errnum_t e );\r
1126 \r
1127         #if ! IS_MULTI_THREAD_ERROR_CLASS\r
1128                 dll_global_g_Error extern  ErrorClass  g_Error;\r
1129         #endif\r
1130 #endif\r
1131 \r
1132 errnum_t  MergeError( errnum_t e, errnum_t ee );\r
1133 void  ErrorLog_add( errnum_t e );\r
1134 \r
1135 \r
1136  \r
1137 /***********************************************************************\r
1138   <<< [ErrorMessage] >>> \r
1139 ************************************************************************/\r
1140 void  Error4_printf( const TCHAR* format, ... );\r
1141 void  Error4_getErrStr( int ErrNum, TCHAR* out_ErrStr, size_t ErrStrSize );\r
1142 void  Error4_clear( int err_num );\r
1143 errnum_t  SaveWindowsLastError(void);\r
1144 \r
1145 \r
1146  \r
1147 /***********************************************************************\r
1148   <<< [stdio] >>> \r
1149 ************************************************************************/\r
1150 void  Error4_showToStdErr( int err_num );\r
1151 void  Error4_showToStdIO( FILE* out, int err_num );\r
1152 \r
1153 \r
1154  \r
1155 /***********************************************************************\r
1156   <<< [DEBUG_TRUE, DEBUG_FALSE] >>> \r
1157 ************************************************************************/\r
1158 #if ! NDEBUG\r
1159  #define  DEBUG_TRUE   1\r
1160  #define  DEBUG_FALSE  0\r
1161 #else\r
1162  #define  DEBUG_TRUE   __cut_on_debug =\r
1163  #define  DEBUG_FALSE  0\r
1164 #endif\r
1165 \r
1166 \r
1167  \r
1168 /***********************************************************************\r
1169   <<< [DEBUG_CODE] >>> \r
1170 ************************************************************************/\r
1171 #if ! NDEBUG\r
1172         #define  DEBUG_CODE( expression ) \\r
1173                 __pragma(warning(push)) \\r
1174                 __pragma(warning(disable:4127)) \\r
1175                         do { expression; } while(0)   /* do-while is CERT standard PRE10-C */ \\r
1176                 __pragma(warning(pop))\r
1177 #else\r
1178         #define  DEBUG_CODE( expression )  /* no execute */\r
1179 #endif\r
1180 \r
1181 \r
1182  \r
1183 /***********************************************************************\r
1184   <<< [CHECK_ARG] >>> \r
1185 ************************************************************************/\r
1186 #ifndef  CHECK_ARG\r
1187   #define  CHECK_ARG  1\r
1188 #endif\r
1189 \r
1190 /*[GetIsCheckArg][SetIsCheckArg]*/\r
1191 #if CHECK_ARG\r
1192 extern bool  g_IsCheckArg;\r
1193 inline bool  GetIsCheckArg(void)  { return  g_IsCheckArg; }\r
1194 inline void  SetIsCheckArg( bool IsCheckArg )  { g_IsCheckArg = IsCheckArg; }\r
1195 #endif\r
1196 \r
1197 \r
1198  \r
1199 /***********************************************************************\r
1200   <<< [INVALID_VALUE] >>> \r
1201 ************************************************************************/\r
1202 enum { INVALID_VALUE = 0xDEDEDEDE };\r
1203 \r
1204 \r
1205  \r
1206 /***********************************************************************\r
1207   <<< [DUMMY_INITIAL_VALUE] >>> \r
1208 ************************************************************************/\r
1209 #ifndef NDEBUG\r
1210         enum { DUMMY_INITIAL_VALUE = 0xDEDEDEDE };\r
1211         enum { DUMMY_INITIAL_VALUE_8BIT  = 0xDE };\r
1212         enum { DUMMY_INITIAL_VALUE_16BIT = 0xDEDE };\r
1213         #ifdef _UNICODE\r
1214                 enum { DUMMY_INITIAL_VALUE_TCHAR = 0xDEDE };\r
1215         #else\r
1216                 enum { DUMMY_INITIAL_VALUE_TCHAR = 0xDE - 0x100 };  /* 0x100 is to change to signed type */\r
1217         #endif\r
1218         /* Disable VC++ warning C4701 : local variable may be used without having been initialized */\r
1219         /* 0xDEDEDEDE means "not initialized" */\r
1220 #else\r
1221         enum { DUMMY_INITIAL_VALUE = 0 };\r
1222         enum { DUMMY_INITIAL_VALUE_8BIT  = 0 };\r
1223         enum { DUMMY_INITIAL_VALUE_16BIT = 0 };\r
1224         enum { DUMMY_INITIAL_VALUE_TCHAR = 0 };\r
1225         /* 0 reduces code size */\r
1226 #endif\r
1227 \r
1228 \r
1229  \r
1230 /***********************************************************************\r
1231   <<< [DISCARD_STRUCT] >>> \r
1232   <<< [DISCARD_ARRAY] >>> \r
1233   <<< [DISCARD_BYTES] >>> \r
1234   <<< [MEMSET_TO_NOT_INIT] >>> \r
1235 ************************************************************************/\r
1236 #ifndef  ENABLE_DISCARD_STRUCT\r
1237  #if ! NDEBUG\r
1238   #define  ENABLE_DISCARD_STRUCT  1\r
1239  #else\r
1240   #define  ENABLE_DISCARD_STRUCT  0\r
1241  #endif\r
1242 #endif\r
1243 \r
1244 #if  USE_MEMSET_TO_NOT_INIT\r
1245         #define  DISCARD_STRUCT( TypedAddress ) \\r
1246                 memset( TypedAddress, 0xDE, sizeof(*(TypedAddress)) )\r
1247         #define  DISCARD_ARRAY( TypedAddress, Count ) \\r
1248                 memset( TypedAddress, 0xDE, sizeof(*(TypedAddress)) * (Count) )\r
1249         #define  DISCARD_BYTES( Address, ByteSize )  memset( Address, 0xDE, ByteSize )\r
1250 //      #define  MEMSET_TO_NOT_INIT( Address, ByteSize )  memset( Address, 0xDE, ByteSize )\r
1251 #else\r
1252         #define  DISCARD_STRUCT( Address )                __noop()\r
1253         #define  DISCARD_ARRAY( Address, Count )          __noop()\r
1254         #define  DISCARD_BYTES( Address, ByteSize )       __noop()\r
1255 //      #define  MEMSET_TO_NOT_INIT( Address, ByteSize )  __noop()\r
1256 #endif\r
1257 \r
1258 \r
1259  \r
1260 /***********************************************************************\r
1261   <<< [NAME_STR] >>> \r
1262 ************************************************************************/\r
1263 #ifndef  NAME_STR\r
1264  #if ! NDEBUG\r
1265   #define  NAME_STR  1\r
1266  #else\r
1267   #define  NAME_STR  0\r
1268  #endif\r
1269 #endif\r
1270 \r
1271  \r
1272 /***********************************************************************\r
1273   <<< [Error4_VariablesClass] >>> \r
1274 ************************************************************************/\r
1275 typedef struct _Error4_VariablesClass  Error4_VariablesClass;\r
1276 struct _Error4_VariablesClass {\r
1277         DWORD  WindowsLastError;\r
1278 };\r
1279 \r
1280 Error4_VariablesClass*  Get_Error4_Variables(void);\r
1281 \r
1282 #ifdef _DEBUG\r
1283         extern Error4_VariablesClass*  g_Error4_Variables;\r
1284 #endif\r
1285 \r
1286 \r
1287  \r
1288 #if  __cplusplus\r
1289  }  /* End of C Symbol */ \r
1290 #endif\r
1291  \r
1292 /*=================================================================*/\r
1293 /* <<< [FileT/FileT.h] >>> */ \r
1294 /*=================================================================*/\r
1295  \r
1296 #if  __cplusplus\r
1297  extern "C" {  /* Start of C Symbol */ \r
1298 #endif\r
1299 \r
1300 #define  FileT_isExistWildcard  1\r
1301 bool  FileT_isExist( const TCHAR* path );\r
1302 bool  FileT_isFile( const TCHAR* path );\r
1303 bool  FileT_isDir( const TCHAR* path );\r
1304 int   FileT_isDiff( const TCHAR* Path1, const TCHAR* Path2, bool* bDiff );\r
1305 int   FileT_isSameText( TCHAR* Path1, TCHAR* Path2, int Format1, int Format2, bool* out_bSame );\r
1306 int   FileT_isSameBinaryFile( const TCHAR* PathA, const TCHAR* PathB, int Flags, bool* out_IsSame );\r
1307 \r
1308 \r
1309  \r
1310 /* FileT_CallByNestFindData */ \r
1311 typedef struct {\r
1312         void*     CallerArgument;\r
1313         TCHAR*    FullPath;  // abstruct path\r
1314         TCHAR*    StepPath;\r
1315         TCHAR*    FileName;\r
1316         DWORD     FileAttributes;\r
1317 } FileT_CallByNestFindData;\r
1318 \r
1319 int  FileT_callByNestFind( const TCHAR* Path, BitField Flags, void* Obj, FuncType Callback );\r
1320 \r
1321 enum { FileT_FolderBeforeFiles = 1 };\r
1322 enum { FileT_FolderAfterFiles  = 2 };\r
1323 enum { FileT_Folder = FILE_ATTRIBUTE_DIRECTORY };\r
1324 \r
1325  \r
1326 /***********************************************************************\r
1327   <<< [FileT_Read] >>> \r
1328 ************************************************************************/\r
1329 int  FileT_openForRead( FILE** out_pFile, const TCHAR* path );\r
1330 // int  FileT_close( FILE* File, int e );\r
1331 errnum_t  FileT_closeAndNULL( FILE** in_out_File, errnum_t e );\r
1332 \r
1333 \r
1334  \r
1335 #if  __cplusplus\r
1336  }  /* End of C Symbol */ \r
1337 #endif\r
1338  \r
1339 /*=================================================================*/\r
1340 /* <<< [IniFile2/IniFile2.h] >>> */ \r
1341 /*=================================================================*/\r
1342  \r
1343 #if  __cplusplus\r
1344  extern "C" {  /* Start of C Symbol */ \r
1345 #endif\r
1346  \r
1347 bool  IniStr_isLeft( const TCHAR* line, const TCHAR* symbol ); \r
1348  \r
1349 TCHAR*  IniStr_refRight( const TCHAR* line, bool bTrimRight ); \r
1350  \r
1351 #if  __cplusplus\r
1352  }    /* End of C Symbol */ \r
1353 #endif\r
1354 \r
1355  \r
1356 /*=================================================================*/\r
1357 /* <<< [Locale/Locale.h] >>> */ \r
1358 /*=================================================================*/\r
1359  \r
1360 #if  __cplusplus\r
1361  extern "C" {  /* Start of C Symbol */ \r
1362 #endif\r
1363 \r
1364 \r
1365  \r
1366 /***********************************************************************\r
1367   <<< [Locale] >>> \r
1368 ************************************************************************/\r
1369 extern char*  g_LocaleSymbol;\r
1370 int  Locale_init(void);\r
1371 int  Locale_isInited(void);\r
1372 \r
1373 \r
1374  \r
1375 #if  __cplusplus\r
1376  }  /* End of C Symbol */ \r
1377 #endif\r
1378 \r
1379 \r
1380  \r
1381 /*=================================================================*/\r
1382 /* <<< [PlatformSDK_plus/PlatformSDK_plus.h] >>> */ \r
1383 /*=================================================================*/\r
1384  \r
1385 int  GetCommandLineUnnamed( int Index1, TCHAR* out_AParam, size_t AParamSize ); \r
1386 int  GetCommandLineNamed( const TCHAR* Name, bool bCase, TCHAR* out_Value, size_t ValueSize );\r
1387 int  GetCommandLineNamedC8( const TCHAR* Name, bool bCase, char* out_Value, size_t ValueSize );\r
1388 int  GetCommandLineNamedI( const TCHAR* Name, bool bCase, int* out_Value );\r
1389 bool GetCommandLineExist( const TCHAR* Name, bool bCase );\r
1390 \r
1391 #if ! _UNICODE\r
1392         #define  GetCommandLineNamedC8  GetCommandLineNamed\r
1393 #endif\r
1394 \r
1395  \r
1396 /*=================================================================*/\r
1397 /* <<< [Global0/Global0.h] >>> */ \r
1398 /*=================================================================*/\r
1399  \r
1400 #if  __cplusplus\r
1401  extern "C" {  /* Start of C Symbol */ \r
1402 #endif\r
1403 \r
1404 \r
1405  \r
1406 /***********************************************************************\r
1407   <<< [Globals] >>> \r
1408 ************************************************************************/\r
1409 #define  USE_GLOBALS  1\r
1410 \r
1411 void Globals_initConst(void);\r
1412 int  Globals_initialize(void);\r
1413 int  Globals_finalize( int e );\r
1414 \r
1415 #if NDEBUG\r
1416   #define  get_InitedObject( m, isInited )  (m)\r
1417 #else\r
1418   #define  get_InitedObject( m, isInited )  ( isInited( m ) ? (m) : (DebugBreakR(), (m)) )\r
1419 #endif\r
1420 \r
1421 \r
1422  \r
1423 #if  __cplusplus\r
1424  }  /* End of C Symbol */ \r
1425 #endif\r
1426  \r
1427 #endif  // __CLIB_H \r
1428 \r
1429 #ifdef _MSC_VER\r
1430  #if  showIncludes\r
1431   #pragma message( "end of #include  \"" __FILE__ "\"" )\r
1432  #endif\r
1433 #endif\r
1434  \r