_src/Test/tools/vbslib_helper_src/_setup_generated/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 #include  <stddef.h> \r
  89  \r
  90 #include  <crtdbg.h> \r
  91  \r
  92 #ifndef  __linux__\r
  93         #include  <tchar.h> \r
  94 #else\r
  95         #define  _T(x)  x\r
  96         typedef  char  TCHAR;\r
  97         #define  _tcschr   strchr\r
  98         #define  _tprintf  printf\r
  99 #endif\r
 100  \r
 101 #include  <locale.h> \r
 102 \r
 103 #if UNDER_CE\r
 104   #define  setlocale( x, y )\r
 105 #endif\r
 106  \r
 107 #include  <errno.h> \r
 108 #ifdef  __linux__\r
 109         typedef  int  errno_t;  // CERT DCL09-C\r
 110 #endif\r
 111  \r
 112 #include  <assert.h> \r
 113  \r
 114 #include  <direct.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  float           float32_t;  /* This is not C99 */\r
 132 typedef  double          float64_t;  /* This is not C99 */\r
 133 typedef  unsigned int    bool_t;     /* MISRA-C:1998 No.13 */  /* This is not C99 */\r
 134 typedef  unsigned int    bool32_t;   /* For 32bit compiler */\r
 135 typedef  unsigned short  bool16_t;\r
 136 typedef  unsigned char   bool8_t;\r
 137 typedef  int             int_fast32_t;\r
 138 typedef  int             int_fast16_t;\r
 139 typedef  int             int_fast8_t;\r
 140 typedef  unsigned int    uint_fast32_t;\r
 141 typedef  unsigned int    uint_fast16_t;\r
 142 typedef  unsigned int    uint_fast8_t;\r
 143 \r
 144 #define  INT_FAST32_MAX  INT_MAX\r
 145 \r
 146 \r
 147  \r
 148 /*********************************************************************************************\r
 149   <<< [bit_flags32_t] [bit_flags_fast32_t] >>> \r
 150   <<< [BitField] [BIT_FIELD_ENDIAN] [BIT_FIELD_LITTLE_ENDIAN] [BIT_FIELD_BIG_ENDIAN] >>> \r
 151 **********************************************************************************************/\r
 152 typedef  uint32_t      bit_flags32_t; \r
 153 typedef  uint_fast32_t bit_flags_fast32_t;\r
 154 typedef  unsigned int  BitField; \r
 155 typedef  uint32_t      BitField32;\r
 156 #define  BIT_FIELD_ENDIAN           BIT_FIELD_LITTLE_ENDIAN\r
 157 #define  BIT_FIELD_LITTLE_ENDIAN    1\r
 158 #define  BIT_FIELD_BIG_ENDIAN       2\r
 159 \r
 160 \r
 161  \r
 162 /***********************************************************************\r
 163   <<< [IsBitSet]        Check 1 bit >>> \r
 164   <<< [IsAnyBitsSet]    Check multiple bits >>> \r
 165   <<< [IsAllBitsSet]    Check multiple bits >>> \r
 166   <<< [IsBitNotSet]     Check 1 bit >>> \r
 167   <<< [IsAnyBitsNotSet] Check multiple bits >>> \r
 168   <<< [IsAllBitsNotSet] Check multiple bits >>> \r
 169 ************************************************************************/\r
 170 #define  IsBitSet( variable, const_value ) \\r
 171         ( ( (variable) & (const_value) ) != 0 )\r
 172 \r
 173 #define  IsAnyBitsSet( variable, or_const_value ) \\r
 174         ( ( (variable) & (or_const_value) ) != 0 )\r
 175 \r
 176 #define  IsAllBitsSet( variable, or_const_value ) \\r
 177         ( ( (variable) & (or_const_value) ) == (or_const_value) )\r
 178 \r
 179 #define  IsBitNotSet( variable, const_value ) \\r
 180         ( ( (variable) & (const_value) ) == 0 )\r
 181 \r
 182 #define  IsAnyBitsNotSet( variable, or_const_value ) \\r
 183         ( ( (variable) & (or_const_value) ) != (or_const_value) )\r
 184 \r
 185 #define  IsAllBitsNotSet( variable, or_const_value ) \\r
 186         ( ( (variable) & (or_const_value) ) == 0 )\r
 187 \r
 188 \r
 189  \r
 190 /***********************************************************************\r
 191   <<< [bool type] >>> \r
 192 ************************************************************************/\r
 193 #ifndef  __cplusplus\r
 194  #ifndef  BOOL_DEFINED\r
 195   typedef unsigned char   bool;\r
 196   enum  { true = 1, false = 0 };\r
 197  #define  BOOL_DEFINED\r
 198  #endif\r
 199 #endif\r
 200 \r
 201 \r
 202  \r
 203 /***********************************************************************\r
 204   <<< [FuncType] >>> \r
 205 ************************************************************************/\r
 206 typedef  int (*FuncType)( void* Param ); \r
 207 typedef  errnum_t (* InitializeFuncType )( void* self, void* Parameter );\r
 208 //typedef  int (*FinishFuncType)( void* m, int e );  /*[FinishFuncType]*/\r
 209 typedef  errnum_t (*FinalizeFuncType)( void* self, errnum_t e );  /*[FinalizeFuncType]*/\r
 210 \r
 211 \r
 212  \r
 213 /***********************************************************************\r
 214   <<< [InterfaceID_Class] >>> \r
 215   <<< [InterfaceToVTableClass] >>> \r
 216 - const InterfaceID_Class  g_SampleInterface_ID;\r
 217 ************************************************************************/\r
 218 typedef struct _InterfaceID_Class  InterfaceID_Class;\r
 219 struct _InterfaceID_Class {\r
 220         char*  InterfaceName;\r
 221 };\r
 222 \r
 223 typedef struct _InterfaceToVTableClass  InterfaceToVTableClass;\r
 224 struct _InterfaceToVTableClass {\r
 225         const InterfaceID_Class*  InterfaceID;\r
 226         const void*               VTable;\r
 227 };\r
 228 \r
 229 \r
 230  \r
 231 /***********************************************************************\r
 232   <<< [ClassID_Class] >>> \r
 233 - const ClassID_Class  g_SampleClass_ID;\r
 234 ************************************************************************/\r
 235 typedef struct _ClassID_Class  ClassID_Class;\r
 236 struct _ClassID_Class {\r
 237         char*                          ClassName;\r
 238         const ClassID_Class**          SuperClassID_Array;\r
 239         int                            SuperClassID_Array_Count;\r
 240         size_t                         Size;\r
 241         InitializeFuncType             InitializeFunction;\r
 242         const InterfaceToVTableClass*  InterfaceToVTable_Array;\r
 243         int                            InterfaceToVTable_Array_Conut;\r
 244 };\r
 245 \r
 246 bool      ClassID_Class_isSuperClass( const ClassID_Class* ClassID, const ClassID_Class* SuperClassID );\r
 247 errnum_t  ClassID_Class_createObject( const ClassID_Class* ClassID, void* out_Object, void* Parameter );\r
 248 void*     ClassID_Class_getVTable( const ClassID_Class* ClassID, const InterfaceID_Class* InterfaceID );\r
 249 \r
 250 \r
 251  \r
 252 /***********************************************************************\r
 253   <<< [ClassID_SuperClass] >>> \r
 254 ************************************************************************/\r
 255 typedef struct _ClassID_SuperClass  ClassID_SuperClass;\r
 256 struct _ClassID_SuperClass {\r
 257         const ClassID_Class*  ClassID;  /* &g_(ClassName)_ID */\r
 258 };\r
 259 extern const ClassID_Class  g_ClassID_SuperClass_ID;\r
 260 \r
 261 \r
 262  \r
 263 /***********************************************************************\r
 264   <<< [g_FinalizerInterface_ID] >>> \r
 265 ************************************************************************/\r
 266 \r
 267 extern const InterfaceID_Class  g_FinalizerInterface_ID;\r
 268 \r
 269 /*[FinalizerVTableClass]*/\r
 270 typedef struct _FinalizerVTableClass  FinalizerVTableClass;\r
 271 struct _FinalizerVTableClass {\r
 272         int               OffsetToSelf;\r
 273         FinalizeFuncType  Finalize;\r
 274 };\r
 275 \r
 276 \r
 277  \r
 278 /***********************************************************************\r
 279   <<< [g_PrintXML_Interface_ID] >>> \r
 280 ************************************************************************/\r
 281 \r
 282 extern const InterfaceID_Class  g_PrintXML_Interface_ID;\r
 283 \r
 284 typedef errnum_t (* PrintXML_FuncType )( void* self, FILE* OutputStream );\r
 285 \r
 286 \r
 287 /*[PrintXML_VTableClass]*/\r
 288 typedef struct _PrintXML_VTableClass  PrintXML_VTableClass;\r
 289 struct _PrintXML_VTableClass {\r
 290         int                OffsetToSelf;\r
 291         PrintXML_FuncType  PrintXML;\r
 292 };\r
 293 \r
 294 \r
 295  \r
 296 /***********************************************************************\r
 297   <<< [fopen_ccs] >>> \r
 298 ************************************************************************/\r
 299 #if defined(_UNICODE) \r
 300   #define  fopen_ccs  ",ccs=UNICODE"\r
 301 #else\r
 302   #define  fopen_ccs  "t"\r
 303 #endif\r
 304 \r
 305 \r
 306  \r
 307 /***********************************************************************\r
 308   <<< [NameOnlyClass] >>> \r
 309 ************************************************************************/\r
 310 typedef struct _NameOnlyClass  NameOnlyClass;\r
 311 struct _NameOnlyClass {\r
 312         const TCHAR*  Name;\r
 313         const void*   Delegate;\r
 314 };\r
 315 \r
 316  \r
 317 /***********************************************************************\r
 318   <<< [NameAndNumClass] >>> \r
 319 ************************************************************************/\r
 320 typedef struct _NameAndNumClass  NameAndNumClass;  /* Like NameOnlyClass */\r
 321 struct _NameAndNumClass {\r
 322         TCHAR*  Name;\r
 323         int     Number;\r
 324 };\r
 325 \r
 326 \r
 327  \r
 328 /***********************************************************************\r
 329   <<< [inline] [SUPPORT_INLINE_C_FUNC] [NOT_USE_INLINE_MACRO] >>> \r
 330 ************************************************************************/\r
 331 #ifndef  SUPPORT_INLINE_C_FUNC\r
 332   #define  SUPPORT_INLINE_C_FUNC  1\r
 333 #endif\r
 334 #ifndef  INLINE\r
 335   #if ! __cplusplus\r
 336     #if SUPPORT_INLINE_C_FUNC\r
 337       #define  inline  _inline     /* inline is specified under C99 */\r
 338     #endif\r
 339   #endif\r
 340 #endif\r
 341 \r
 342 #ifndef  NOT_USE_INLINE_MACRO\r
 343   #define  NOT_USE_INLINE_MACRO  0\r
 344 #endif\r
 345 \r
 346 \r
 347  \r
 348 /**************************************************************************\r
 349  <<< [ttoi_ex] >>> \r
 350 ***************************************************************************/\r
 351 int  ttoi_ex( const TCHAR* string,  bit_flags_fast32_t options );\r
 352 \r
 353 \r
 354  \r
 355 /*=================================================================*/\r
 356 /* <<< [Error4_Inline/Error4_Inline.h] >>> */ \r
 357 /*=================================================================*/\r
 358  \r
 359 /***********************************************************************\r
 360   <<< [UNREFERENCED_VARIABLE] >>> \r
 361   <<< [UNREFERENCED_VARIABLE_2] >>>\r
 362   <<< [UNREFERENCED_VARIABLE_3] >>>\r
 363   <<< [UNREFERENCED_VARIABLE_4] >>>\r
 364 ************************************************************************/\r
 365 #ifdef  __linux__\r
 366         #define  UNREFERENCED_VARIABLE( x )\r
 367         #define  UNREFERENCED_VARIABLES( x )\r
 368 #else\r
 369 \r
 370 #define  UNREFERENCED_VARIABLE( a1 )       UNREFERENCED_VARIABLE_Sub( &(a1) )\r
 371 #define  UNREFERENCED_VARIABLE_2( a1,a2 )  UNREFERENCED_VARIABLE_2_Sub( &(a1), &(a2) )\r
 372 #define  UNREFERENCED_VARIABLE_3( a1,a2,a3 )     UNREFERENCED_VARIABLE_3_Sub( &(a1), &(a2), &(a3) )\r
 373 #define  UNREFERENCED_VARIABLE_4( a1,a2,a3,a4 )  UNREFERENCED_VARIABLE_4_Sub( &(a1), &(a2), &(a3), &(a4) )\r
 374 \r
 375 inline void  UNREFERENCED_VARIABLE_Sub( const void* a1 ) { a1; }\r
 376 inline void  UNREFERENCED_VARIABLE_2_Sub( const void* a1, const void* a2 ) { a1,a2; }\r
 377 inline void  UNREFERENCED_VARIABLE_3_Sub( const void* a1, const void* a2, const void* a3 ) { a1,a2,a3; }\r
 378 inline void  UNREFERENCED_VARIABLE_4_Sub( const void* a1, const void* a2, const void* a3, const void* a4 ) { a1,a2,a3,a4; }\r
 379 \r
 380 #endif\r
 381 \r
 382 \r
 383  \r
 384 /*=================================================================*/\r
 385 /* <<< [Lock_1/Lock_1.h] >>> */ \r
 386 /*=================================================================*/\r
 387  \r
 388 /***********************************************************************\r
 389   <<< [SingletonInitializerClass] >>> \r
 390 ************************************************************************/\r
 391 typedef struct {\r
 392         volatile LONG  InitializeStep;\r
 393 } SingletonInitializerClass;\r
 394 \r
 395 #ifndef  SingletonInitializerClass_FailSleepTime\r
 396         #ifndef NDEBUG\r
 397                 #define  SingletonInitializerClass_FailSleepTime  60000\r
 398         #else\r
 399                 #define  SingletonInitializerClass_FailSleepTime  0\r
 400         #endif\r
 401 #endif\r
 402 \r
 403 bool  SingletonInitializerClass_isFirst( SingletonInitializerClass* self );\r
 404 void  SingletonInitializerClass_onFinishedInitialize( SingletonInitializerClass* self, int e );\r
 405 bool  SingletonInitializerClass_isInitialized( SingletonInitializerClass* self );\r
 406 \r
 407 \r
 408  \r
 409 /*=================================================================*/\r
 410 /* <<< [Print/Print2.h] >>> */ \r
 411 /*=================================================================*/\r
 412  \r
 413 #if  __cplusplus\r
 414  extern "C" {  /* Start of C Symbol */ \r
 415 #endif\r
 416  \r
 417 /***********************************************************************\r
 418   <<< [USE_printf_to] >>> \r
 419 ************************************************************************/\r
 420 #define  USE_printf_to_stdout    1\r
 421 #define  USE_printf_to_debugger  2\r
 422 #define  USE_printf_to_file      3\r
 423 \r
 424 \r
 425  \r
 426 /***********************************************************************\r
 427   <<< [PrintfCounterClass] >>> \r
 428 ************************************************************************/\r
 429 #if USE_PRINTF_COUNTER\r
 430 \r
 431 typedef struct _PrintfCounterClass  PrintfCounterClass;\r
 432 struct _PrintfCounterClass {\r
 433         int  Count;\r
 434         int  BreakCount;\r
 435         int  BreakIndent;\r
 436 };\r
 437 extern PrintfCounterClass  g_PrintfCounter;\r
 438 \r
 439 #endif\r
 440 \r
 441 \r
 442  \r
 443 /***********************************************************************\r
 444   <<< [printf_to_debugger] >>> \r
 445 ************************************************************************/\r
 446 void   printf_to_debugger( const char* fmt, ... );\r
 447 void  wprintf_to_debugger( const wchar_t* fmt, ... );\r
 448 \r
 449 #ifndef   USE_printf_to\r
 450  #ifdef __linux__\r
 451   #define  USE_printf_to  USE_printf_to_stdout\r
 452  #else\r
 453   #define  USE_printf_to  USE_printf_to_debugger\r
 454  #endif\r
 455 #endif\r
 456 \r
 457 #if  USE_printf_to == USE_printf_to_debugger\r
 458  #define  printf   printf_to_debugger\r
 459  #define  wprintf  wprintf_to_debugger\r
 460 \r
 461  #undef    _tprintf\r
 462  #if UNICODE\r
 463   #define  _tprintf  wprintf_to_debugger\r
 464  #else\r
 465   #define  _tprintf  printf_to_debugger\r
 466  #endif\r
 467 #endif\r
 468 \r
 469  \r
 470 errnum_t  vsprintf_r( char* s, size_t s_size, const char* format, va_list va ); \r
 471  \r
 472 errnum_t  vswprintf_r( wchar_t* s, size_t s_size, const wchar_t* format, va_list va ); \r
 473  \r
 474 /*[vstprintf_r]*/\r
 475 #if defined(_UNICODE) \r
 476   #define  vstprintf_r  vswprintf_r\r
 477 #else\r
 478   #define  vstprintf_r  vsprintf_r\r
 479 #endif\r
 480  \r
 481 errnum_t  stprintf_r( TCHAR* s, size_t s_size, const TCHAR* format, ... ); \r
 482  \r
 483 errnum_t  stcpy_part_r( TCHAR* s, size_t s_size, TCHAR* s_start, TCHAR** p_s_last, \r
 484                    const TCHAR* src, const TCHAR* src_over );\r
 485 errnum_t  stprintf_part_r( TCHAR* s, size_t s_size, TCHAR* s_start, TCHAR** p_s_last,\r
 486                       const TCHAR* format, ... );\r
 487  \r
 488 #if  __cplusplus\r
 489  }    /* End of C Symbol */ \r
 490 #endif\r
 491 \r
 492  \r
 493 /*=================================================================*/\r
 494 /* <<< [SetX/SetX.h] >>> */ \r
 495 /*=================================================================*/\r
 496  \r
 497 #ifndef  __SETX_H \r
 498 #define  __SETX_H\r
 499 \r
 500 #ifdef  __cplusplus\r
 501  extern "C" {  /* Start of C Symbol */\r
 502 #endif\r
 503 \r
 504  \r
 505 /***********************************************************************\r
 506   <<< [Set2] >>> \r
 507 ************************************************************************/\r
 508 typedef  struct _Set2  Set2;\r
 509 struct _Set2 {\r
 510         void*  First;\r
 511         void*  Next;\r
 512         void*  Over;\r
 513 \r
 514         #ifdef _DEBUG\r
 515         void**   PointerOfDebugArray;  /* void<type> */\r
 516         #endif\r
 517 };\r
 518 \r
 519 //[Set2_IteratorClass]\r
 520 typedef struct _Set2_IteratorClass  Set2_IteratorClass;\r
 521 struct _Set2_IteratorClass {\r
 522         Set2*     Parent;\r
 523         int       ElementSize;\r
 524         uint8_t*  Current;\r
 525 };\r
 526 \r
 527 #define  Set2_initConst( m )  ( (m)->First = NULL, (m)->Next = NULL )\r
 528 int  Set2_init( Set2* m, int FirstSize );\r
 529 int  Set2_finish( Set2* m, int e );\r
 530 #define  Set2_isInited( m )  ( (m)->First != NULL )\r
 531 \r
 532 #define  Set2_alloc( m, pp, type ) \\r
 533         Set2_alloc_imp( m, (void*)(pp), sizeof(type) )\r
 534 \r
 535 int  Set2_alloc_imp( Set2* m, void* pm, size_t size );\r
 536 \r
 537 #define  Set2_push( m, pp, type ) \\r
 538         Set2_alloc_imp( m, (void*)(pp), sizeof(type) )\r
 539 \r
 540 #define  Set2_pop( m, pp, type ) \\r
 541         Set2_pop_imp( m, (void*)(pp), sizeof(type) )\r
 542 \r
 543 int  Set2_pop_imp( Set2* m, void* pp, size_t size );\r
 544 \r
 545 #define  Set2_freeLast( m, p, type, e ) \\r
 546         ( ((char*)(m)->Next - sizeof(type) == (char*)(p)) ? \\r
 547                 (m)->Next = (p), (e) : \\r
 548                 ((e)?(e):E_OTHERS) )\r
 549 \r
 550 #define  Set2_toEmpty( m ) \\r
 551         ( (m)->Next = (m)->First, 0 )\r
 552 \r
 553 #define  Set2_expandIfOverByAddr( m, OverAddrBasedOnNowFirst ) \\r
 554         ( (void*)(OverAddrBasedOnNowFirst) <= (m)->Over ? 0 : \\r
 555                 Set2_expandIfOverByAddr_imp( m, OverAddrBasedOnNowFirst ) )\r
 556 \r
 557 #define  Set2_expandIfOverByOffset( m, Size ) \\r
 558         Set2_expandIfOverByAddr( m, (char*)(m)->First + (Size) )\r
 559 int  Set2_expandIfOverByAddr_imp( Set2* m, void* OverAddrBasedOnNowFirst );\r
 560 \r
 561 #define  Set2_allocMulti( m, out_pElem, ElemType, nElem ) \\r
 562         Set2_allocMulti_sub( m, (void*)(out_pElem), sizeof(ElemType) * (nElem) )\r
 563 int  Set2_allocMulti_sub( Set2* m, void* out_pElem, size_t ElemsSize );\r
 564 \r
 565 #define  Set2_forEach( self, Item, Item_Over, Type ) \\r
 566         *(Item) = (Type*)( (self)->First ),  *(Item_Over) = (Type*)( (self)->Next ); \\r
 567         *(Item) < *(Item_Over); \\r
 568         *(Item) += 1\r
 569 \r
 570 errnum_t  Set2_getIterator( Set2* self, Set2_IteratorClass* out_Iterator, int ElementSize );\r
 571 errnum_t  Set2_getDescendingIterator( Set2* self, Set2_IteratorClass* out_Iterator, int ElementSize );\r
 572 void*  Set2_IteratorClass_getNext( Set2_IteratorClass* self );\r
 573 void*  Set2_IteratorClass_getPrevious( Set2_IteratorClass* self );\r
 574 \r
 575 \r
 576 //[Set2_forEach2]\r
 577 #define  Set2_forEach2( self, Iterator, out_Element ) \\r
 578         Set2_forEach2_1( self, Iterator, out_Element, sizeof(**(out_Element)) ); \\r
 579         Set2_forEach2_2( self, Iterator, out_Element ); \\r
 580         Set2_forEach2_3( self, Iterator, out_Element )\r
 581 \r
 582 inline void  Set2_forEach2_1( Set2* self, Set2_IteratorClass* Iterator,  void* out_Element,\r
 583         size_t ElementSize )\r
 584 {\r
 585         Set2_getIterator( self, Iterator, ElementSize );\r
 586         *(void**) out_Element = Set2_IteratorClass_getNext( Iterator );\r
 587 }\r
 588 \r
 589 inline bool  Set2_forEach2_2( Set2* self,  Set2_IteratorClass* Iterator,  void* out_Element )\r
 590 {\r
 591         UNREFERENCED_VARIABLE_2( self, Iterator );\r
 592         return  ( *(void**) out_Element != NULL );\r
 593 }\r
 594 \r
 595 inline void  Set2_forEach2_3( Set2* self, Set2_IteratorClass* Iterator,  void* out_Element )\r
 596 {\r
 597         UNREFERENCED_VARIABLE( self );\r
 598         *(void**) out_Element = Set2_IteratorClass_getNext( Iterator );\r
 599 }\r
 600 \r
 601 \r
 602 #define  Set2_ref( m, iElem, out_pElem, ElemType ) \\r
 603         Set2_ref_imp( m, iElem, out_pElem, sizeof(ElemType) )\r
 604 \r
 605 int  Set2_ref_imp( Set2* m, int iElem, void* out_pElem, size_t ElemSize );\r
 606 \r
 607 #define  Set2_getCount( m, Type ) \\r
 608         ( (Type*)(m)->Next - (Type*)(m)->First )\r
 609 \r
 610 #define  Set2_checkPtrInArr( m, p ) \\r
 611         ( (m)->First <= (p) && (p) < (m)->Over ? 0 : E_NOT_FOUND_SYMBOL )\r
 612 \r
 613 int  Set2_separate( Set2* m, int NextSize, void** allocate_Array );\r
 614 \r
 615 #ifdef _DEBUG\r
 616 void  Set2_setDebug( Set2* m, void* PointerOfDebugArray );\r
 617 #endif\r
 618 \r
 619  \r
 620 /***********************************************************************\r
 621   <<< [Variant_SuperClass] >>>\r
 622 ************************************************************************/\r
 623 \r
 624 typedef struct _VariantClass  VariantClass;\r
 625 \r
 626 typedef struct _Variant_SuperClass  Variant_SuperClass;\r
 627 struct _Variant_SuperClass {\r
 628 \r
 629         /* <Inherit parent="ClassID_SuperClass"> */\r
 630         const ClassID_Class*   ClassID;\r
 631         /* </Inherit> */\r
 632 \r
 633         FinalizerVTableClass*  FinalizerVTable;\r
 634         VariantClass*          StaticAddress;\r
 635 };\r
 636 \r
 637 extern const ClassID_Class  g_Variant_SuperClass_ID;\r
 638 errnum_t  Variant_SuperClass_initialize( Variant_SuperClass* self, void* Parameter );\r
 639 errnum_t  Variant_SuperClass_overwrite( Variant_SuperClass* self,\r
 640         Variant_SuperClass* AddingElement );\r
 641 \r
 642 \r
 643  \r
 644 /***********************************************************************\r
 645   <<< [VariantClass] >>>\r
 646 - VariantClass* == Variant_SuperClass**\r
 647 ************************************************************************/\r
 648 typedef struct _VariantClass  VariantClass;\r
 649  \r
 650 #ifdef  __cplusplus\r
 651  }  /* End of C Symbol */ \r
 652 #endif\r
 653 #endif\r
 654  \r
 655 /*=================================================================*/\r
 656 /* <<< [DebugTools/DebugTools.h] >>> */ \r
 657 /*=================================================================*/\r
 658  \r
 659 #if  __cplusplus\r
 660  extern "C" {  /* Start of C Symbol */ \r
 661 #endif\r
 662 \r
 663 \r
 664 #ifndef NDEBUG\r
 665         #define  NDEBUG_ERROR\r
 666 #else\r
 667         #define  NDEBUG_ERROR  ___cut_NDEBUG_ERROR\r
 668 #endif\r
 669 \r
 670  \r
 671 /*[dll_global_g_DebugBreakCount]*/\r
 672 #ifndef  dll_global_g_DebugBreakCount\r
 673         #define  dll_global_g_DebugBreakCount\r
 674 #endif\r
 675  \r
 676 /***********************************************************************\r
 677   <<< [TestableDebugBreak] >>> \r
 678 ************************************************************************/\r
 679 #define  TestableDebugBreak()  ( TestableDebugBreak_Sub() ? (DebugBreakR(),0) : 0 )\r
 680 int      TestableDebugBreak_Sub(void);\r
 681 \r
 682 void     SetTestableDebugBreak( bool IsEnableBreak );\r
 683 int      GetDebugBreakCount(void);\r
 684 \r
 685 \r
 686  \r
 687 #if  __cplusplus\r
 688  }  /* End of C Symbol */ \r
 689 #endif\r
 690 \r
 691 \r
 692  \r
 693 /*=================================================================*/\r
 694 /* <<< [StrT/StrT.h] >>> */ \r
 695 /*=================================================================*/\r
 696  \r
 697 #if  __cplusplus\r
 698  extern "C" {  /* Start of C Symbol */ \r
 699 #endif\r
 700 \r
 701 errnum_t  StrT_cpy( TCHAR* Dst, size_t DstSize, const TCHAR* Src );\r
 702 errnum_t  StrT_cat( TCHAR* Dst, size_t DstSize, const TCHAR* Src );\r
 703 TCHAR*  StrT_chrs( const TCHAR* s, const TCHAR* keys );\r
 704 TCHAR*  StrT_rstr( const TCHAR* String, const TCHAR* SearchStart, const TCHAR* Keyword,\r
 705         void* NullConfig );\r
 706 TCHAR*  StrT_skip( const TCHAR* s, const TCHAR* keys );\r
 707 TCHAR*  StrT_rskip( const TCHAR* String, const TCHAR* SearchStart, const TCHAR* Keys,\r
 708         void* NullConfig );\r
 709 bool    StrT_isCIdentifier( TCHAR Character );\r
 710 TCHAR*  StrT_searchOverOfCIdentifier( const TCHAR* Text );\r
 711 int  StrT_cmp_part( const TCHAR* StringA_Start, const TCHAR* StringA_Over,\r
 712         const TCHAR* StringB );\r
 713 int  StrT_cmp_part2( const TCHAR* StringA_Start, const TCHAR* StringA_Over,\r
 714         const TCHAR* StringB_Start, const TCHAR* StringB_Over );\r
 715 #define  TwoChar8( Character1, Character2 ) \\r
 716         ( (Character1) + ( (Character2) << 8 ) )\r
 717 #define  FourChar8( Character1, Character2, Character3, Character4 ) \\r
 718         ( (Character1) + ( (Character2) << 8 ) + ( (Character3) << 16 ) + ( (Character4) << 24 ) )\r
 719 \r
 720 inline errnum_t  StrT_cat( TCHAR* Dst, size_t DstSize, const TCHAR* Src )\r
 721 {\r
 722         return  stcpy_part_r( Dst, DstSize, _tcschr( Dst, _T('\0') ), NULL, Src, NULL );\r
 723 }\r
 724 \r
 725 \r
 726  \r
 727 errnum_t  StrT_convStrToId( const TCHAR* str, const TCHAR** strs, const int* ids, int n, int default_id ); \r
 728 errnum_t  StrT_convStrLeftToId( const TCHAR* Str, const TCHAR** Strs, const size_t* Lens, const int* Ids,\r
 729                            int CountOfStrs, TCHAR* Separeters, int DefaultId, TCHAR** out_PosOfLastOfStr );\r
 730 void*  StrT_convPartStrToPointer( const TCHAR* StringStart, const TCHAR* StringOver,\r
 731         const NameOnlyClass* Table, size_t TableSize, void* Default );\r
 732 TCHAR*  StrT_convertNumToStr( int Number, const NameAndNumClass* Table, int TableCount,\r
 733         const TCHAR* DefaultStr );\r
 734  \r
 735 //[GetStringSizeFromPointer]\r
 736 inline size_t  GetStringSizeFromPointer( void* String, size_t StringSize, void* Pointer )\r
 737 {\r
 738         return  (uintptr_t) String + StringSize - (uintptr_t) Pointer;\r
 739 }\r
 740 \r
 741  \r
 742 /***********************************************************************\r
 743   <<< [StrT_Malloc] >>> \r
 744 ************************************************************************/\r
 745 errnum_t  MallocAndCopyString( const TCHAR** out_NewString, const TCHAR* SourceString );\r
 746 errnum_t  MallocAndCopyString_char( const TCHAR** out_NewString, const char* SourceString );\r
 747 errnum_t  MallocAndCopyStringByLength( const TCHAR** out_NewString, const TCHAR* SourceString,\r
 748         unsigned CountOfCharacter );\r
 749 \r
 750 #ifndef _UNICODE\r
 751         #define  MallocAndCopyString_char  MallocAndCopyString\r
 752 #endif\r
 753 \r
 754  \r
 755 /***********************************************************************\r
 756   <<< [StrT_Edit] >>> \r
 757 ************************************************************************/\r
 758 errnum_t  StrT_trim( TCHAR* out_Str, size_t out_Str_Size, const TCHAR* in_Str );\r
 759 errnum_t  StrT_cutLastOf( TCHAR* in_out_Str, TCHAR Charactor );\r
 760 errnum_t  StrT_cutLineComment( TCHAR* out_Str, size_t out_Str_Size, const TCHAR* in_Str, const TCHAR* CommentSign );\r
 761 errnum_t  StrT_meltCmdLine( TCHAR* out_Str, size_t out_Str_Size, const TCHAR** pLine );\r
 762 errnum_t  StrT_getExistSymbols( unsigned* out, bool bCase, const TCHAR* Str, const TCHAR* Symbols, ... );\r
 763 errnum_t  StrT_replace1( TCHAR* in_out_String, TCHAR FromCharacter, TCHAR ToCharacter,\r
 764         unsigned Opt );\r
 765 \r
 766 \r
 767  \r
 768 /***********************************************************************\r
 769   <<< [W3CDTF] >>> \r
 770 ************************************************************************/\r
 771 enum { W3CDTF_MAX_LENGTH = 27+3 };  /* \8f¬\90\943\8c\85 */\r
 772 enum { W3CDTF_CURRENT_TIME_ZONE = 9999 };\r
 773 \r
 774 errnum_t  W3CDTF_fromSYSTEMTIME( TCHAR* out_W3CDTF, size_t W3CDTF_ByteSize,\r
 775         const SYSTEMTIME* Time, int TimeZoneMinute );\r
 776 errnum_t  W3CDTF_toSYSTEMTIME( const TCHAR* String, SYSTEMTIME* out_Time, int* out_BiasMinute );\r
 777 errnum_t  W3CDTF_getTimeZoneDesignator( TCHAR* out_TZD, size_t TZD_ByteSize,\r
 778         int  BiasMinute );\r
 779 \r
 780 \r
 781  \r
 782 /***********************************************************************\r
 783   <<< [StrT_Path] >>> \r
 784 ************************************************************************/\r
 785 enum { StrT_LocalPathMaxSize = 4096 };\r
 786 enum { MAX_LOCAL_PATH = 4096 };\r
 787 TCHAR*  StrT_refFName( const TCHAR* s );\r
 788 TCHAR*  StrT_refExt( const TCHAR* s );\r
 789 bool  StrT_isFullPath( const TCHAR* s );\r
 790 \r
 791 errnum_t  StrT_getFullPath_part( TCHAR* Str, size_t StrSize, TCHAR* StrStart,\r
 792         TCHAR** out_StrLast, const TCHAR* StepPath, const TCHAR* BasePath );\r
 793 errnum_t  StrT_allocateFullPath( TCHAR** out_FullPath, const TCHAR* StepPath, TCHAR* BasePath );\r
 794 errnum_t  StrT_getStepPath( TCHAR* out_StepPath, size_t StepPathSize,\r
 795         const TCHAR* FullPath, const TCHAR* BasePath );\r
 796 errnum_t  StrT_getParentFullPath_part( TCHAR* Str, size_t StrSize, TCHAR* StrStart,\r
 797         TCHAR** out_StrLast, const TCHAR* StepPath, const TCHAR* BasePath );\r
 798 errnum_t  StrT_getBaseName_part( TCHAR* Str, size_t StrSize, TCHAR* StrStart,\r
 799         TCHAR** out_StrLast, const TCHAR* SrcPath );\r
 800 errnum_t  StrT_addLastOfFileName( TCHAR* out_Path, size_t PathSize,\r
 801                              const TCHAR* BasePath, const TCHAR* AddName );\r
 802 \r
 803 inline errnum_t  StrT_getFullPath( TCHAR* out_FullPath, size_t FullPathSize,\r
 804         const TCHAR* StepPath, const TCHAR* BasePath )\r
 805 {\r
 806         return  StrT_getFullPath_part( out_FullPath, FullPathSize, out_FullPath,\r
 807                 NULL, StepPath, BasePath );\r
 808 }\r
 809 \r
 810 inline errnum_t  StrT_getParentFullPath( TCHAR* Str, size_t StrSize,\r
 811         const TCHAR* SrcPath, const TCHAR* BasePath )\r
 812 {\r
 813         return StrT_getParentFullPath_part( Str, StrSize, Str, NULL, SrcPath, BasePath );\r
 814 }\r
 815 \r
 816 inline errnum_t  StrT_getBaseName( TCHAR* Str, size_t StrSize, const TCHAR* SrcPath )\r
 817 {\r
 818         return  StrT_getBaseName_part( Str, StrSize, Str, NULL, SrcPath );\r
 819 }\r
 820 \r
 821 \r
 822  \r
 823 /**************************************************************************\r
 824   <<< [Strs] >>> \r
 825 ***************************************************************************/\r
 826 typedef  struct _Strs  Strs;\r
 827 struct _Strs {\r
 828         char*   MemoryAddress;   /* first memory = [ TCHAR* FirstStr | elem[] ],  other memory = [ elem[] ] */\r
 829         char*   MemoryOver;\r
 830         char*   NextElem;        /* elem = [ TCHAR* NextStr | TCHAR[] ] */\r
 831         TCHAR** PointerToNextStrInPrevElem;  /* first = &FirstStr,  other = &NextStr */\r
 832         TCHAR** Prev_PointerToNextStrInPrevElem;\r
 833 \r
 834         Strs*   FirstOfStrs;\r
 835         Strs*   NextStrs;\r
 836 };\r
 837 \r
 838 void Strs_initConst( Strs* m );\r
 839 errnum_t  Strs_init( Strs* m );\r
 840 errnum_t  Strs_finish( Strs* m, errnum_t e );\r
 841 errnum_t  Strs_toEmpty( Strs* m );\r
 842 bool Strs_isInited( Strs* m );\r
 843 errnum_t  Strs_add( Strs* m, const TCHAR* Str, const TCHAR** out_pAlloc );\r
 844 errnum_t  Strs_addBinary( Strs* m, const TCHAR* Str, const TCHAR* StrOver, const TCHAR** out_AllocStr );\r
 845 errnum_t  Strs_freeLast( Strs* m, TCHAR* AllocStr );\r
 846 errnum_t  Strs_toEmpty( Strs* m );\r
 847 /* for ( Strs_forEach( Strs* m, TCHAR** in_out_Str ) ); */\r
 848 TCHAR*  Strx_getFirst( Strs* m );\r
 849 TCHAR*  Strx_getNext( Strs* m, TCHAR* Str );\r
 850 \r
 851 \r
 852 #define  Strs_initConst( m )  ( (m)->MemoryAddress =  NULL )\r
 853 #define  Strs_isInited( m )    ( (m)->MemoryAddress != NULL )\r
 854 \r
 855 #define  Strs_forEach( m, pStr ) \\r
 856         *(pStr) = Strs_getFirst( m ); \\r
 857         *(pStr) != NULL; \\r
 858         *(pStr) = Strs_getNext( m, *(pStr) )\r
 859 \r
 860 #define  Strs_getFirst( m ) \\r
 861         ( *(TCHAR**) (m)->FirstOfStrs->MemoryAddress )\r
 862 \r
 863 #define  Strs_getNext( m, p ) \\r
 864         ( *( (TCHAR**)(p) - 1 ) )\r
 865 \r
 866 #define  Strs_getFreeAddr( m )  ( (TCHAR*)( (m)->NextElem + sizeof(TCHAR*) ) )\r
 867 #define  Strs_getFreeSize( m )  ( (m)->MemoryOver - (char*)(m)->NextElem - sizeof(TCHAR*) )\r
 868 #define  Strs_getFreeCount( m ) ( Strs_getFreeSize( m ) / sizeof(TCHAR) )\r
 869 #define  Strs_expandCount( m, c )  ( Strs_expandSize( (m), (c) * sizeof(TCHAR) ) )\r
 870 errnum_t  Strs_expandSize( Strs* m, size_t FreeSize );\r
 871 errnum_t  Strs_commit( Strs* m, TCHAR* StrOver );\r
 872 \r
 873  \r
 874 /***********************************************************************\r
 875   <<< [StrArr] >>> \r
 876 ************************************************************************/\r
 877 typedef struct _StrArr  StrArr;\r
 878 struct _StrArr {\r
 879         Set2  Array;  // array of TCHAR*\r
 880         Strs  Chars;\r
 881 };\r
 882 \r
 883 errnum_t  StrArr_init( StrArr* m );\r
 884 errnum_t  StrArr_finish( StrArr* m, errnum_t e );\r
 885 \r
 886 errnum_t  StrArr_add( StrArr* m, const TCHAR* Str, int* out_I );\r
 887 errnum_t  StrArr_commit( StrArr* m );\r
 888 errnum_t  StrArr_fillTo( StrArr* m, int n, const TCHAR* Str );\r
 889 errnum_t  StrArr_toEmpty( StrArr* m );\r
 890 \r
 891 #define  StrArr_initConst( m )   Set2_initConst( &(m)->Array )\r
 892 #define  StrArr_getFreeAddr( m )  Strs_getFreeAddr( &(m)->Chars )\r
 893 #define  StrArr_getFreeSize( m )  Strs_getFreeSize( &(m)->Chars )\r
 894 #define  StrArr_getFreeCount( m ) Strs_getFreeCount( &(m)->Chars )\r
 895 #define  StrArr_expandSize( m, sz )  Strs_expandSize( &(m)->Chars, sz )\r
 896 #define  StrArr_expandCount( m, c )  Strs_expandCount( &(m)->Chars, c )\r
 897 #define  StrArr_getArray( m )     ((TCHAR**)(m)->Array.First)\r
 898 //#define  StrArr_getN( m )          Set2_getCount( &(m)->Array, TCHAR* )\r
 899 #define  StrArr_getCount( m )        Set2_getCount( &(m)->Array, TCHAR* )\r
 900 \r
 901 \r
 902  \r
 903 /***********************************************************************\r
 904   <<< [StrArr_forEach] >>> \r
 905 ************************************************************************/\r
 906 #define  StrArr_forEach( self, Iterator, out_String ) \\r
 907         StrArr_forEach_1( self, Iterator, out_String ); \\r
 908         StrArr_forEach_2( Iterator ); \\r
 909         StrArr_forEach_3( Iterator, out_String )\r
 910 \r
 911 /*[StrArrIterator]*/\r
 912 typedef struct _StrArrIterator  StrArrIterator;\r
 913 struct _StrArrIterator {\r
 914         const TCHAR**  Pointer;\r
 915         const TCHAR**  PointerOver;\r
 916 };\r
 917 \r
 918 inline void  StrArr_forEach_1( StrArr* self, StrArrIterator* Iterator, const TCHAR** out_String )\r
 919 {\r
 920         Iterator->Pointer = (const TCHAR**) self->Array.First;\r
 921         Iterator->PointerOver = (const TCHAR**) self->Array.Next;\r
 922         *out_String = *Iterator->Pointer;\r
 923 }\r
 924 \r
 925 inline bool  StrArr_forEach_2( StrArrIterator* Iterator )\r
 926 {\r
 927         return  Iterator->Pointer < Iterator->PointerOver;\r
 928 }\r
 929 \r
 930 inline void  StrArr_forEach_3( StrArrIterator* Iterator, const TCHAR** out_String )\r
 931 {\r
 932         Iterator->Pointer += 1;\r
 933         *out_String = *Iterator->Pointer;\r
 934 }\r
 935 \r
 936 \r
 937  \r
 938 /***********************************************************************\r
 939   <<< [CSV] >>> \r
 940 ************************************************************************/\r
 941 errnum_t  StrT_meltCSV( TCHAR* out_Str, size_t out_Str_Size, const TCHAR** pCSV );\r
 942 errnum_t  StrArr_parseCSV( StrArr* m, const TCHAR* CSVLine );\r
 943 errnum_t  StrT_parseCSV_f( const TCHAR* StringOfCSV, bit_flags32_t* out_ReadFlags, const TCHAR* Types, ... );\r
 944 \r
 945 \r
 946  \r
 947 #if  __cplusplus\r
 948  }  /* End of C Symbol */ \r
 949 #endif\r
 950 \r
 951  \r
 952 /*=================================================================*/\r
 953 /* <<< [CRT_plus_2/CRT_plus_2.h] >>> */ \r
 954 /*=================================================================*/\r
 955  \r
 956 /***********************************************************************\r
 957   <<< [HeapMemory_allocate] >>> \r
 958   <<< [HeapMemory_allocateArray] >>> \r
 959 ************************************************************************/\r
 960 \r
 961 #define  HeapMemory_allocate( out_Pointer ) \\r
 962     HeapMemory_allocateBytes( out_Pointer, sizeof( **(out_Pointer) ) )\r
 963 \r
 964 #define  HeapMemory_allocateArray( out_Pointer, Count ) \\r
 965     HeapMemory_allocateBytes( out_Pointer, sizeof( **(out_Pointer) ) * (Count) )\r
 966 \r
 967 inline errnum_t  HeapMemory_allocateBytes( void* out_Pointer, size_t MemorySize )\r
 968 {\r
 969         void**  out = (void**) out_Pointer;\r
 970 \r
 971         *out = malloc( MemorySize );\r
 972 \r
 973         if ( *out == NULL )\r
 974                 { return  E_FEW_MEMORY; }\r
 975         else\r
 976                 { return  0; }\r
 977 }\r
 978 \r
 979 \r
 980 /*[MallocMemory]*/\r
 981 inline errnum_t  MallocMemory( void* out_MemoryAddress, size_t MemorySize )\r
 982 {\r
 983         return  HeapMemory_allocateBytes( out_MemoryAddress, MemorySize );\r
 984 }\r
 985 \r
 986 \r
 987  \r
 988 /***********************************************************************\r
 989   <<< [HeapMemory_free] >>> \r
 990 ************************************************************************/\r
 991 inline errnum_t  HeapMemory_free( const void* in_out_MemoryAddress, errnum_t e )\r
 992 {\r
 993         void*  address = *(void**) in_out_MemoryAddress;\r
 994 \r
 995         if ( address != NULL )\r
 996                 { free( address ); }\r
 997 \r
 998         *(void**) in_out_MemoryAddress = NULL;\r
 999 \r
1000         return  e;\r
1001 }\r
1002 \r
1003 \r
1004 /*[FreeMemory]*/\r
1005 inline errnum_t  FreeMemory( const void* in_out_MemoryAddress, errnum_t e )\r
1006 {\r
1007         return  HeapMemory_free( in_out_MemoryAddress, e );\r
1008 }\r
1009 \r
1010 \r
1011  \r
1012 /**************************************************************************\r
1013  <<< [Interface] >>> \r
1014 ***************************************************************************/\r
1015 typedef struct _VTableDefine  VTableDefine;  /*[VTableDefine]*/\r
1016 struct _VTableDefine {\r
1017   int    m_IMethod;\r
1018   void*  m_method;\r
1019 };\r
1020 \r
1021 #define  VTable_Obj( i )  ( (void*) ( (char*)(i) - (*(i))->m_Offset ) )  /*[VTable_Obj]*/\r
1022 #define  VTable_Method( i, m_method )  (*(i))->m_method  /*[VTable_Method]*/\r
1023 \r
1024 #ifdef  __cplusplus\r
1025 extern "C" {\r
1026 #endif\r
1027 \r
1028 errnum_t  DefaultFunction( void* a );\r
1029 errnum_t  DefaultFunction_NotImplementYet( void* a );\r
1030 //errnum_t  DefaultFunction_Finish( void* a, errnum_t e );\r
1031 errnum_t  DefaultFunction_Finalize( void* a, errnum_t e );\r
1032 \r
1033 errnum_t  VTableDefine_overwrite( VTableDefine* aVTable, size_t aVTable_ByteSize, int iMethod, void* Func );\r
1034 \r
1035 #ifdef  __cplusplus\r
1036 }\r
1037 #endif\r
1038 \r
1039 \r
1040  \r
1041 /*=================================================================*/\r
1042 /* <<< [Error4/Error4.h] >>> */ \r
1043 /*=================================================================*/\r
1044  \r
1045 #if  __cplusplus\r
1046  extern "C" {  /* Start of C Symbol */ \r
1047 #endif\r
1048 \r
1049 \r
1050  \r
1051 /***********************************************************************\r
1052   <<< [SetBreakErrorID] >>> \r
1053 ************************************************************************/\r
1054 #ifndef  ENABLE_ERROR_BREAK_IN_ERROR_CLASS\r
1055         #if ! NDEBUG\r
1056                 #define  ENABLE_ERROR_BREAK_IN_ERROR_CLASS  1\r
1057         #else\r
1058                 #define  ENABLE_ERROR_BREAK_IN_ERROR_CLASS  0\r
1059         #endif\r
1060 #endif\r
1061 \r
1062 #ifndef  ENABLE_DEBUG_ERROR_BREAK_IN_ERROR_CLASS\r
1063         #if ! NDEBUG\r
1064                 #define  ENABLE_DEBUG_ERROR_BREAK_IN_ERROR_CLASS  1\r
1065         #else\r
1066                 #define  ENABLE_DEBUG_ERROR_BREAK_IN_ERROR_CLASS  0\r
1067         #endif\r
1068 #endif\r
1069 \r
1070 #ifndef  IS_MULTI_THREAD_ERROR_CLASS\r
1071  \r
1072         #define  IS_MULTI_THREAD_ERROR_CLASS  0  /*[IS_MULTI_THREAD_ERROR_CLASS]:single*/\r
1073  \r
1074 #endif\r
1075 \r
1076 /*[dll_global_g_Error]*/\r
1077 #ifndef  dll_global_g_Error\r
1078         #define  dll_global_g_Error\r
1079 #endif\r
1080 \r
1081 \r
1082 #if ENABLE_ERROR_BREAK_IN_ERROR_CLASS\r
1083         /*[IF][IF_D][ASSERT_R][ASSERT_D]*/\r
1084         /* "IF" is able to break at nearest code raising error */\r
1085         #define  IF_D(x)  IF(x)\r
1086         #define  IF(x) \\r
1087                 if( (x) && ( OnRaisingError_Sub((const char*)__FILE__,__LINE__) ? (DebugBreakR(),1) : (1) ) )\r
1088 \r
1089         #define  ASSERT_R( x, goto_err_or_Statement ) \\r
1090                 __pragma(warning(push)) \\r
1091                 __pragma(warning(disable:4127)) \\r
1092                         do{  IF(!(x)) { goto_err_or_Statement; } }  while(0)   /* do-while is CERT standard PRE10-C */ \\r
1093                 __pragma(warning(pop))\r
1094 \r
1095         #define  ASSERT_D( x, goto_err_or_Statement )  ASSERT_R( x, goto_err_or_Statement )\r
1096 #else\r
1097         #define  IF(x)  if(x)\r
1098         #define  IF_D(x) \\r
1099                 __pragma(warning(push)) \\r
1100                 __pragma(warning(disable:4127)) \\r
1101                         if(0) \\r
1102                 __pragma(warning(pop))\r
1103 \r
1104         #define  ASSERT_R( x, goto_err_or_Statement ) \\r
1105                 __pragma(warning(push)) \\r
1106                 __pragma(warning(disable:4127)) \\r
1107                         do{  if(!(x)) { goto_err_or_Statement; } }while(0)   /* do-while is CERT standard PRE10-C */ \\r
1108                 __pragma(warning(pop))\r
1109 \r
1110         #define  ASSERT_D( x, goto_err_or_Statement )\r
1111 #endif\r
1112 \r
1113 \r
1114 void  DebugBreakR(void);\r
1115 #if ! ENABLE_ERROR_BREAK_IN_ERROR_CLASS\r
1116         inline void  SetBreakErrorID( int ID ) { ID=ID; /* avoid warning */ }\r
1117         inline void  ClearError() {}\r
1118         inline void  IfErrThenBreak() {}\r
1119         typedef  int  ErrStackAreaClass;  // dummy type\r
1120         inline void  PushErr( ErrStackAreaClass* ErrStackArea )  { UNREFERENCED_VARIABLE( ErrStackArea ); }\r
1121         inline void  PopErr(  ErrStackAreaClass* ErrStackArea )  { UNREFERENCED_VARIABLE( ErrStackArea ); }\r
1122 #else\r
1123         void  SetBreakErrorID( int ID );\r
1124         void  ClearError(void);\r
1125         void  IfErrThenBreak(void);\r
1126         typedef  struct _ErrorClass  ErrStackAreaClass;\r
1127         void  PushErr( ErrStackAreaClass* ErrStackArea );\r
1128         void  PopErr(  ErrStackAreaClass* ErrStackArea );\r
1129 \r
1130         bool  OnRaisingError_Sub( const char* FilePath, int LineNum );\r
1131 \r
1132         typedef  struct _ErrorClass  ErrorClass;  /*[ErrorClass]*/\r
1133         struct _ErrorClass {\r
1134                 bool         IsError;\r
1135                 #if  ENABLE_DEBUG_ERROR_BREAK_IN_ERROR_CLASS\r
1136                         int     ErrorID;\r
1137                 #endif\r
1138                 int          BreakErrorID;\r
1139                 const char*  FilePath;\r
1140                 int          LineNum;\r
1141 \r
1142                 #if IS_MULTI_THREAD_ERROR_CLASS\r
1143                         FinalizerClass  Finalizer;\r
1144                         #if  ENABLE_DEBUG_ERROR_BREAK_IN_ERROR_CLASS\r
1145                                 DWORD  ThreadID;\r
1146                                 int    GlobalErrorID;\r
1147                         #endif\r
1148                 #endif\r
1149         };\r
1150         errnum_t  ErrorClass_finalize( ErrorClass* self, errnum_t e );\r
1151 \r
1152         #if ! IS_MULTI_THREAD_ERROR_CLASS\r
1153                 dll_global_g_Error extern  ErrorClass  g_Error;\r
1154         #endif\r
1155 #endif\r
1156 \r
1157 errnum_t  MergeError( errnum_t e, errnum_t ee );\r
1158 void  ErrorLog_add( errnum_t e );\r
1159 \r
1160 \r
1161  \r
1162 /***********************************************************************\r
1163   <<< [ErrorMessage] >>> \r
1164 ************************************************************************/\r
1165 void  Error4_printf( const TCHAR* format, ... );\r
1166 void  Error4_getErrStr( int ErrNum, TCHAR* out_ErrStr, size_t ErrStrSize );\r
1167 void  Error4_clear( int err_num );\r
1168 errnum_t  SaveWindowsLastError(void);\r
1169 \r
1170 \r
1171  \r
1172 /***********************************************************************\r
1173   <<< [DEBUG_TRUE, DEBUG_FALSE] >>> \r
1174 ************************************************************************/\r
1175 #if ! NDEBUG\r
1176  #define  DEBUG_TRUE   1\r
1177  #define  DEBUG_FALSE  0\r
1178 #else\r
1179  #define  DEBUG_TRUE   __cut_on_debug =\r
1180  #define  DEBUG_FALSE  0\r
1181 #endif\r
1182 \r
1183 \r
1184  \r
1185 /***********************************************************************\r
1186   <<< [DEBUG_CODE] >>> \r
1187 ************************************************************************/\r
1188 #if ! NDEBUG\r
1189         #define  DEBUG_CODE( expression ) \\r
1190                 __pragma(warning(push)) \\r
1191                 __pragma(warning(disable:4127)) \\r
1192                         do { expression; } while(0)   /* do-while is CERT standard PRE10-C */ \\r
1193                 __pragma(warning(pop))\r
1194 #else\r
1195         #define  DEBUG_CODE( expression )  /* no execute */\r
1196 #endif\r
1197 \r
1198 \r
1199  \r
1200 /***********************************************************************\r
1201   <<< [CHECK_ARG] >>> \r
1202 ************************************************************************/\r
1203 #ifndef  CHECK_ARG\r
1204   #define  CHECK_ARG  1\r
1205 #endif\r
1206 \r
1207 /*[GetIsCheckArg][SetIsCheckArg]*/\r
1208 #if CHECK_ARG\r
1209 extern bool  g_IsCheckArg;\r
1210 inline bool  GetIsCheckArg(void)  { return  g_IsCheckArg; }\r
1211 inline void  SetIsCheckArg( bool IsCheckArg )  { g_IsCheckArg = IsCheckArg; }\r
1212 #endif\r
1213 \r
1214 \r
1215  \r
1216 /***********************************************************************\r
1217   <<< [INVALID_VALUE] >>> \r
1218 ************************************************************************/\r
1219 enum { INVALID_VALUE = 0xDEDEDEDE };\r
1220 \r
1221 \r
1222  \r
1223 /***********************************************************************\r
1224   <<< [DUMMY_INITIAL_VALUE] >>> \r
1225 ************************************************************************/\r
1226 #ifndef NDEBUG\r
1227         enum { DUMMY_INITIAL_VALUE = 0xDEDEDEDE };\r
1228         enum { DUMMY_INITIAL_VALUE_8BIT  = 0xDE };\r
1229         enum { DUMMY_INITIAL_VALUE_16BIT = 0xDEDE };\r
1230         #ifdef _UNICODE\r
1231                 enum { DUMMY_INITIAL_VALUE_TCHAR = 0xDEDE };\r
1232         #else\r
1233                 enum { DUMMY_INITIAL_VALUE_TCHAR = 0xDE - 0x100 };  /* 0x100 is to change to signed type */\r
1234         #endif\r
1235         /* Disable VC++ warning C4701 : local variable may be used without having been initialized */\r
1236         /* 0xDEDEDEDE means "not initialized" */\r
1237 #else\r
1238         enum { DUMMY_INITIAL_VALUE = 0 };\r
1239         enum { DUMMY_INITIAL_VALUE_8BIT  = 0 };\r
1240         enum { DUMMY_INITIAL_VALUE_16BIT = 0 };\r
1241         enum { DUMMY_INITIAL_VALUE_TCHAR = 0 };\r
1242         /* 0 reduces code size */\r
1243 #endif\r
1244 \r
1245 \r
1246  \r
1247 /***********************************************************************\r
1248   <<< [DISCARD_STRUCT] >>> \r
1249   <<< [DISCARD_ARRAY] >>> \r
1250   <<< [DISCARD_BYTES] >>> \r
1251   <<< [MEMSET_TO_NOT_INIT] >>> \r
1252 ************************************************************************/\r
1253 #ifndef  ENABLE_DISCARD_STRUCT\r
1254  #if ! NDEBUG\r
1255   #define  ENABLE_DISCARD_STRUCT  1\r
1256  #else\r
1257   #define  ENABLE_DISCARD_STRUCT  0\r
1258  #endif\r
1259 #endif\r
1260 \r
1261 #if  USE_MEMSET_TO_NOT_INIT\r
1262         #define  DISCARD_STRUCT( TypedAddress ) \\r
1263                 memset( TypedAddress, 0xDE, sizeof(*(TypedAddress)) )\r
1264         #define  DISCARD_ARRAY( TypedAddress, Count ) \\r
1265                 memset( TypedAddress, 0xDE, sizeof(*(TypedAddress)) * (Count) )\r
1266         #define  DISCARD_BYTES( Address, ByteSize )  memset( Address, 0xDE, ByteSize )\r
1267 //      #define  MEMSET_TO_NOT_INIT( Address, ByteSize )  memset( Address, 0xDE, ByteSize )\r
1268 #else\r
1269         #define  DISCARD_STRUCT( Address )                __noop()\r
1270         #define  DISCARD_ARRAY( Address, Count )          __noop()\r
1271         #define  DISCARD_BYTES( Address, ByteSize )       __noop()\r
1272 //      #define  MEMSET_TO_NOT_INIT( Address, ByteSize )  __noop()\r
1273 #endif\r
1274 \r
1275 \r
1276  \r
1277 /***********************************************************************\r
1278   <<< [NAME_STR] >>> \r
1279 ************************************************************************/\r
1280 #ifndef  NAME_STR\r
1281  #if ! NDEBUG\r
1282   #define  NAME_STR  1\r
1283  #else\r
1284   #define  NAME_STR  0\r
1285  #endif\r
1286 #endif\r
1287 \r
1288  \r
1289 /***********************************************************************\r
1290   <<< [Error4_VariablesClass] >>> \r
1291 ************************************************************************/\r
1292 typedef struct _Error4_VariablesClass  Error4_VariablesClass;\r
1293 struct _Error4_VariablesClass {\r
1294         DWORD  WindowsLastError;\r
1295 };\r
1296 \r
1297 Error4_VariablesClass*  Get_Error4_Variables(void);\r
1298 \r
1299 #ifdef _DEBUG\r
1300         extern Error4_VariablesClass*  g_Error4_Variables;\r
1301 #endif\r
1302 \r
1303 \r
1304  \r
1305 #if  __cplusplus\r
1306  }  /* End of C Symbol */ \r
1307 #endif\r
1308  \r
1309 /*=================================================================*/\r
1310 /* <<< [FileT/FileT.h] >>> */ \r
1311 /*=================================================================*/\r
1312  \r
1313 #if  __cplusplus\r
1314  extern "C" {  /* Start of C Symbol */ \r
1315 #endif\r
1316 \r
1317 #define  FileT_isExistWildcard  1\r
1318 bool  FileT_isExist( const TCHAR* path );\r
1319 bool  FileT_isFile( const TCHAR* path );\r
1320 bool  FileT_isDir( const TCHAR* path );\r
1321 int   FileT_isDiff( const TCHAR* Path1, const TCHAR* Path2, bool* bDiff );\r
1322 int   FileT_isSameText( TCHAR* Path1, TCHAR* Path2, int Format1, int Format2, bool* out_bSame );\r
1323 int   FileT_isSameBinaryFile( const TCHAR* PathA, const TCHAR* PathB, int Flags, bool* out_IsSame );\r
1324 \r
1325 \r
1326  \r
1327 /* FileT_CallByNestFindData */ \r
1328 typedef struct {\r
1329         void*     CallerArgument;\r
1330         TCHAR*    FullPath;  // abstruct path\r
1331         TCHAR*    StepPath;\r
1332         TCHAR*    FileName;\r
1333         DWORD     FileAttributes;\r
1334 } FileT_CallByNestFindData;\r
1335 \r
1336 int  FileT_callByNestFind( const TCHAR* Path, BitField Flags, void* Obj, FuncType Callback );\r
1337 \r
1338 enum { FileT_FolderBeforeFiles = 1 };\r
1339 enum { FileT_FolderAfterFiles  = 2 };\r
1340 enum { FileT_Folder = FILE_ATTRIBUTE_DIRECTORY };\r
1341 \r
1342  \r
1343 /***********************************************************************\r
1344   <<< [FileT_Read] >>> \r
1345 ************************************************************************/\r
1346 int  FileT_openForRead( FILE** out_pFile, const TCHAR* path );\r
1347 // int  FileT_close( FILE* File, int e );\r
1348 errnum_t  FileT_closeAndNULL( FILE** in_out_File, errnum_t e );\r
1349 \r
1350 \r
1351  \r
1352 errnum_t  FileT_readAll( FILE* File, TCHAR** out_Text, size_t* out_TextLength );\r
1353 \r
1354 \r
1355  \r
1356 /***********************************************************************\r
1357   <<< [FileT_Write] >>> \r
1358 ************************************************************************/\r
1359 int  FileT_openForWrite( FILE** out_pFile, const TCHAR* Path, int Flags );\r
1360 \r
1361 enum { F_Unicode = 1,  F_Append = 2 };\r
1362 \r
1363 int  FileT_copy( const TCHAR* SrcPath, const TCHAR* DstPath );\r
1364 int  FileT_mkdir( const TCHAR* Path );\r
1365 int  FileT_del( const TCHAR* Path );\r
1366 int  FileT_writePart( FILE* File, const TCHAR* Start, TCHAR* Over );\r
1367 \r
1368 \r
1369  \r
1370 /***********************************************************************\r
1371   <<< [Writables] >>> \r
1372 ************************************************************************/\r
1373 #ifndef  Uses_AppKey\r
1374 #define  Uses_AppKey  1\r
1375 #endif\r
1376 \r
1377 typedef void*  AppKey;\r
1378 typedef struct _Writables  Writables;\r
1379 \r
1380 errnum_t  AppKey_newWritable( AppKey** in_out_m,  Writables** out_Writable,  ... );\r
1381 void      AppKey_initGlobal_const(void);\r
1382 errnum_t  AppKey_finishGlobal( errnum_t e );\r
1383 errnum_t  AppKey_addNewWritableFolder( const TCHAR* Path );\r
1384 errnum_t  AppKey_checkWritable( const TCHAR* Path );\r
1385 \r
1386 \r
1387 struct _Writables {\r
1388         TCHAR**   m_Paths;  // array of array of TCHAR\r
1389         int       m_nPath;  // -1= not inited\r
1390 };\r
1391 \r
1392 errnum_t   Writables_delete( Writables* m, errnum_t e );\r
1393 \r
1394 errnum_t   Writables_add( Writables* m, AppKey* Key, TCHAR* Path );\r
1395 errnum_t   Writables_remove( Writables* m, TCHAR* Path );\r
1396 \r
1397 errnum_t   Writables_enable( Writables* m );\r
1398 errnum_t   Writables_disable( Writables* m, errnum_t e );\r
1399 \r
1400 extern  Writables  g_CurrentWritables;\r
1401 \r
1402 \r
1403  \r
1404 #if  __cplusplus\r
1405  }  /* End of C Symbol */ \r
1406 #endif\r
1407  \r
1408 /*=================================================================*/\r
1409 /* <<< [Locale/Locale.h] >>> */ \r
1410 /*=================================================================*/\r
1411  \r
1412 #if  __cplusplus\r
1413  extern "C" {  /* Start of C Symbol */ \r
1414 #endif\r
1415 \r
1416 \r
1417  \r
1418 /***********************************************************************\r
1419   <<< [Locale] >>> \r
1420 ************************************************************************/\r
1421 extern char*  g_LocaleSymbol;\r
1422 int  Locale_init(void);\r
1423 int  Locale_isInited(void);\r
1424 \r
1425 \r
1426  \r
1427 #if  __cplusplus\r
1428  }  /* End of C Symbol */ \r
1429 #endif\r
1430 \r
1431 \r
1432  \r
1433 /*=================================================================*/\r
1434 /* <<< [Parse2/Parse2.h] >>> */ \r
1435 /*=================================================================*/\r
1436  \r
1437 /***********************************************************************\r
1438   <<< [E_CATEGORY_PARSER2] >>> \r
1439 ************************************************************************/\r
1440 #ifndef  E_CATEGORY_PARSER2  /* If not duplicated */\r
1441         #define  E_CATEGORY_PARSER2  E_CATEGORY_PARSER2\r
1442         enum { E_CATEGORY_PARSER2 = 0x00000600 };\r
1443 #endif\r
1444 \r
1445 enum { E_NOT_FOUND_PARTNER_BRACKET = E_CATEGORY_PARSER2 | 0x01 };  /*[E_NOT_FOUND_PARTNER_BRACKET]*/\r
1446 \r
1447 \r
1448  \r
1449 /***********************************************************************\r
1450   <<< [ParsedRangeClass] >>> \r
1451 ************************************************************************/\r
1452 typedef struct _ParsedRangeClass  ParsedRangeClass;\r
1453 struct _ParsedRangeClass {\r
1454 \r
1455         /* <Inherit parent="Variant_SuperClass"> */\r
1456         const ClassID_Class*   ClassID;\r
1457         FinalizerVTableClass*  FinalizerVTable;\r
1458         VariantClass*          StaticAddress;\r
1459         /* </Inherit> */\r
1460 \r
1461         const TCHAR*  Start;\r
1462         const TCHAR*  Over;\r
1463 };\r
1464 extern const ClassID_Class  g_ParsedRangeClass_ID;\r
1465 \r
1466 void  ParsedRangeClass_initConst( ParsedRangeClass* self );\r
1467 \r
1468 int  ParsedRanges_compareByStart( const void* _a1, const void* _a2 );\r
1469 \r
1470 #ifndef NDEBUG\r
1471 void  ParsedRangeClass_onInitializedForDebug( ParsedRangeClass* self );\r
1472 #else\r
1473 inline void  ParsedRangeClass_onInitializedForDebug( ParsedRangeClass* self )\r
1474 {\r
1475         UNREFERENCED_VARIABLE( self );\r
1476 }\r
1477 #endif\r
1478 \r
1479 \r
1480  \r
1481 errnum_t  ParsedRanges_write_by_Cut(\r
1482         Set2* /*<ParsedRangeClass>*/ CutRanges,\r
1483         const TCHAR* Text, FILE* OutFile );\r
1484 \r
1485 \r
1486  \r
1487 /***********************************************************************\r
1488   <<< [PP_DirectiveClass] >>> \r
1489 ************************************************************************/\r
1490 \r
1491 typedef struct _PP_DirectiveClass  PP_DirectiveClass;\r
1492 typedef struct _PP_SharpIfClass  PP_SharpIfClass;\r
1493 typedef struct _PP_SharpElseClass  PP_SharpElseClass;\r
1494 typedef struct _PP_SharpEndifClass  PP_SharpEndifClass;\r
1495 typedef struct _PP_SharpIfdefClass  PP_SharpIfdefClass;\r
1496 typedef struct _PP_SharpIfndefClass  PP_SharpIfndefClass;\r
1497 \r
1498 \r
1499 typedef struct _PP_DirectiveClass  PP_DirectiveClass;\r
1500 struct _PP_DirectiveClass {\r
1501 \r
1502         /* <Inherit parent="ParsedRangeClass"> */\r
1503         const ClassID_Class*   ClassID;\r
1504         FinalizerVTableClass*  FinalizerVTable;\r
1505         VariantClass*          StaticAddress;\r
1506         const TCHAR*           Start;  /* Left of a line having the direvtive */\r
1507         const TCHAR*           Over;\r
1508         /* </Inherit> */\r
1509 \r
1510         const TCHAR*  DirectiveName_Start;\r
1511         const TCHAR*  DirectiveName_Over;\r
1512 };\r
1513 extern const ClassID_Class  g_PP_DirectiveClass_ID;\r
1514 \r
1515 \r
1516 errnum_t  Parse_PP_Directive( const TCHAR* Text,\r
1517         Set2* /*<PP_DirectiveClass*>*/ DirectivePointerArray );\r
1518 errnum_t  Delete_PP_Directive( Set2* DirectivePointerArray, errnum_t e );\r
1519 \r
1520 \r
1521 void  PP_DirectiveClass_initConst( PP_DirectiveClass* self );\r
1522 \r
1523 \r
1524  \r
1525 errnum_t  ParsedRanges_getCut_by_PP_Directive(\r
1526         Set2* /*<ParsedRangeClass>*/    CutRanges,\r
1527         Set2* /*<PP_DirectiveClass*>*/  DirectivePointerArray,\r
1528         const TCHAR* Symbol,  bool IsCutDefine );\r
1529 \r
1530 \r
1531  \r
1532 /***********************************************************************\r
1533   <<< [PP_SharpDefineClass] >>> \r
1534 ************************************************************************/\r
1535 typedef struct _PP_SharpDefineClass_IDClass  PP_SharpDefineClass_IDClass;\r
1536 \r
1537 typedef struct _PP_SharpDefineClass  PP_SharpDefineClass;\r
1538 struct _PP_SharpDefineClass {\r
1539 \r
1540         /* <Inherit parent="PP_DirectiveClass"> */\r
1541         const ClassID_Class*   ClassID;\r
1542         FinalizerVTableClass*  FinalizerVTable;\r
1543         VariantClass*          StaticAddress;\r
1544         const TCHAR*           Start;\r
1545         const TCHAR*           Over;\r
1546         const TCHAR*           DirectiveName_Start;\r
1547         const TCHAR*           DirectiveName_Over;\r
1548         /* </Inherit> */\r
1549 \r
1550         const TCHAR*  Symbol_Start;\r
1551         const TCHAR*  Symbol_Over;\r
1552 };\r
1553 \r
1554 extern const ClassID_Class  g_PP_SharpDefineClass_ID;\r
1555 \r
1556 \r
1557  \r
1558 /***********************************************************************\r
1559   <<< [PP_SharpIncludeClass] >>> \r
1560 ************************************************************************/\r
1561 typedef struct _PP_SharpIncludeClass_IDClass  PP_SharpIncludeClass_IDClass;\r
1562 \r
1563 typedef struct _PP_SharpIncludeClass  PP_SharpIncludeClass;\r
1564 struct _PP_SharpIncludeClass {\r
1565 \r
1566         /* <Inherit parent="PP_DirectiveClass"> */\r
1567         const ClassID_Class*   ClassID;\r
1568         FinalizerVTableClass*  FinalizerVTable;\r
1569         VariantClass*          StaticAddress;\r
1570         const TCHAR*           Start;\r
1571         const TCHAR*           Over;\r
1572         const TCHAR*           DirectiveName_Start;\r
1573         const TCHAR*           DirectiveName_Over;\r
1574         /* </Inherit> */\r
1575 \r
1576         const TCHAR*  Path_Start;\r
1577         const TCHAR*  Path_Over;\r
1578         TCHAR         PathBracket;  /* _T('<') or _T('"') */\r
1579 };\r
1580 \r
1581 extern const ClassID_Class  g_PP_SharpIncludeClass_ID;\r
1582 \r
1583 \r
1584  \r
1585 /***********************************************************************\r
1586   <<< [PP_SharpIfClass] >>> \r
1587 ************************************************************************/\r
1588 typedef struct _PP_SharpIfClass_IDClass  PP_SharpIfClass_IDClass;\r
1589 \r
1590 typedef struct _PP_SharpIfClass  PP_SharpIfClass;\r
1591 struct _PP_SharpIfClass {\r
1592 \r
1593         /* <Inherit parent="PP_DirectiveClass"> */\r
1594         const ClassID_Class*   ClassID;\r
1595         FinalizerVTableClass*  FinalizerVTable;\r
1596         VariantClass*          StaticAddress;\r
1597         const TCHAR*           Start;\r
1598         const TCHAR*           Over;\r
1599         const TCHAR*           DirectiveName_Start;\r
1600         const TCHAR*           DirectiveName_Over;\r
1601         /* </Inherit> */\r
1602 \r
1603         PP_DirectiveClass*   NextDirective;\r
1604         PP_SharpEndifClass*  EndDirective;\r
1605 };\r
1606 \r
1607 extern const ClassID_Class  g_PP_SharpIfClass_ID;\r
1608 \r
1609 \r
1610  \r
1611 /***********************************************************************\r
1612   <<< [PP_SharpElseClass] >>> \r
1613 ************************************************************************/\r
1614 typedef struct _PP_SharpElseClass  PP_SharpElseClass;\r
1615 struct _PP_SharpElseClass {\r
1616 \r
1617         /* <Inherit parent="PP_DirectiveClass"> */\r
1618         const ClassID_Class*   ClassID;\r
1619         FinalizerVTableClass*  FinalizerVTable;\r
1620         VariantClass*          StaticAddress;\r
1621         const TCHAR*           Start;\r
1622         const TCHAR*           Over;\r
1623         const TCHAR*           DirectiveName_Start;\r
1624         const TCHAR*           DirectiveName_Over;\r
1625         /* </Inherit> */\r
1626 \r
1627         PP_SharpIfClass*     StartDirective;\r
1628         PP_SharpEndifClass*  EndDirective;\r
1629 };\r
1630 extern const ClassID_Class  g_PP_SharpElseClass_ID;\r
1631 \r
1632 \r
1633  \r
1634 /***********************************************************************\r
1635   <<< [PP_SharpEndifClass] >>> \r
1636 ************************************************************************/\r
1637 typedef struct _PP_SharpEndifClass  PP_SharpEndifClass;\r
1638 struct _PP_SharpEndifClass {\r
1639 \r
1640         /* <Inherit parent="PP_DirectiveClass"> */\r
1641         const ClassID_Class*   ClassID;\r
1642         FinalizerVTableClass*  FinalizerVTable;\r
1643         VariantClass*          StaticAddress;\r
1644         const TCHAR*           Start;\r
1645         const TCHAR*           Over;\r
1646         const TCHAR*           DirectiveName_Start;\r
1647         const TCHAR*           DirectiveName_Over;\r
1648         /* </Inherit> */\r
1649 \r
1650         PP_SharpIfClass*    StartDirective;\r
1651         PP_DirectiveClass*  PreviousDirective;\r
1652 };\r
1653 extern const ClassID_Class  g_PP_SharpEndifClass_ID;\r
1654 \r
1655 \r
1656  \r
1657 /***********************************************************************\r
1658   <<< [PP_SharpIfdefClass] >>> \r
1659 ************************************************************************/\r
1660 typedef struct _PP_SharpIfdefClass  PP_SharpIfdefClass;\r
1661 struct _PP_SharpIfdefClass {\r
1662 \r
1663         /* <Inherit parent="PP_SharpIfClass"> */\r
1664         const ClassID_Class*   ClassID;\r
1665         FinalizerVTableClass*  FinalizerVTable;\r
1666         VariantClass*          StaticAddress;\r
1667         const TCHAR*           Start;\r
1668         const TCHAR*           Over;\r
1669         const TCHAR*           DirectiveName_Start;\r
1670         const TCHAR*           DirectiveName_Over;\r
1671         PP_DirectiveClass*     NextDirective;\r
1672         PP_SharpEndifClass*    EndDirective;\r
1673         /* </Inherit> */\r
1674 \r
1675         const TCHAR*  Symbol_Start;\r
1676         const TCHAR*  Symbol_Over;\r
1677 };\r
1678 extern const ClassID_Class  g_PP_SharpIfdefClass_ID;\r
1679 \r
1680 \r
1681  \r
1682 /***********************************************************************\r
1683   <<< [PP_SharpIfndefClass] >>> \r
1684 ************************************************************************/\r
1685 typedef struct _PP_SharpIfndefClass  PP_SharpIfndefClass;\r
1686 struct _PP_SharpIfndefClass {\r
1687 \r
1688         /* <Inherit parent="PP_SharpIfdefClass"> */\r
1689         const ClassID_Class*   ClassID;\r
1690         FinalizerVTableClass*  FinalizerVTable;\r
1691         VariantClass*          StaticAddress;\r
1692         const TCHAR*           Start;\r
1693         const TCHAR*           Over;\r
1694         const TCHAR*           DirectiveName_Start;\r
1695         const TCHAR*           DirectiveName_Over;\r
1696         PP_DirectiveClass*     NextDirective;\r
1697         PP_SharpEndifClass*    EndDirective;\r
1698         const TCHAR*           Symbol_Start;\r
1699         const TCHAR*           Symbol_Over;\r
1700         /* </Inherit> */\r
1701 };\r
1702 extern const ClassID_Class  g_PP_SharpIfndefClass_ID;\r
1703 \r
1704 \r
1705  \r
1706 /*=================================================================*/\r
1707 /* <<< [PlatformSDK_plus/PlatformSDK_plus.h] >>> */ \r
1708 /*=================================================================*/\r
1709  \r
1710 #if  __cplusplus\r
1711  extern "C" {  /* Start of C Symbol */ \r
1712 #endif\r
1713 \r
1714 \r
1715  \r
1716 int  GetCommandLineUnnamed( int Index1, TCHAR* out_AParam, size_t AParamSize ); \r
1717 int  GetCommandLineNamed( const TCHAR* Name, bool bCase, TCHAR* out_Value, size_t ValueSize );\r
1718 int  GetCommandLineNamedC8( const TCHAR* Name, bool bCase, char* out_Value, size_t ValueSize );\r
1719 int  GetCommandLineNamedI( const TCHAR* Name, bool bCase, int* out_Value );\r
1720 bool GetCommandLineExist( const TCHAR* Name, bool bCase );\r
1721 \r
1722 #if ! _UNICODE\r
1723         #define  GetCommandLineNamedC8  GetCommandLineNamed\r
1724 #endif\r
1725 \r
1726  \r
1727 /* [CloseHandleInFin] */ \r
1728 #if ENABLE_ERROR_BREAK_IN_ERROR_CLASS\r
1729         #define  CloseHandleInFin( h, e ) \\r
1730                 ( \\r
1731                         ( (h) == INVALID_HANDLE_VALUE || (h) == NULL ||  CloseHandle( h ) )  ? \\r
1732                         (e)  : \\r
1733                         ( \\r
1734                                 ( OnRaisingError_Sub((const char*)__FILE__,__LINE__) )  ? \\r
1735                                 (DebugBreakR(), E_OTHERS)  : \\r
1736                                 (E_OTHERS) \\r
1737                         ) \\r
1738                 )\r
1739 #else\r
1740         #define  CloseHandleInFin( h, e ) \\r
1741                 ( \\r
1742                         ( (h) == INVALID_HANDLE_VALUE || (h) == NULL ||  CloseHandle( h ) )  ? \\r
1743                         (e)  : \\r
1744                         (E_OTHERS) \\r
1745                 )\r
1746 #endif\r
1747 \r
1748 \r
1749  \r
1750 /* [env] */ \r
1751 #define  env( Str, StrSize, Input ) \\r
1752         env_part( Str, StrSize, Str, NULL, Input )\r
1753 int  env_part( TCHAR* Str,  unsigned StrSize,  TCHAR* StrStart, TCHAR** out_StrLast,\r
1754          const TCHAR* Input );\r
1755 int  env_malloc( TCHAR** out_Value, size_t* out_ValueLen, const TCHAR* Name );\r
1756 \r
1757 \r
1758  \r
1759 #if  __cplusplus\r
1760  }  /* End of C Symbol */ \r
1761 #endif\r
1762  \r
1763 /*=================================================================*/\r
1764 /* <<< [Global0/Global0.h] >>> */ \r
1765 /*=================================================================*/\r
1766  \r
1767 #if  __cplusplus\r
1768  extern "C" {  /* Start of C Symbol */ \r
1769 #endif\r
1770 \r
1771 \r
1772  \r
1773 /***********************************************************************\r
1774   <<< [Globals] >>> \r
1775 ************************************************************************/\r
1776 #define  USE_GLOBALS  1\r
1777 \r
1778 void Globals_initConst(void);\r
1779 int  Globals_initialize(void);\r
1780 int  Globals_finalize( int e );\r
1781 \r
1782 #if NDEBUG\r
1783   #define  get_InitedObject( m, isInited )  (m)\r
1784 #else\r
1785   #define  get_InitedObject( m, isInited )  ( isInited( m ) ? (m) : (DebugBreakR(), (m)) )\r
1786 #endif\r
1787 \r
1788 \r
1789  \r
1790 #if  __cplusplus\r
1791  }  /* End of C Symbol */ \r
1792 #endif\r
1793  \r
1794 #endif  // __CLIB_H \r
1795 \r
1796 #ifdef _MSC_VER\r
1797  #if  showIncludes\r
1798   #pragma message( "end of #include  \"" __FILE__ "\"" )\r
1799  #endif\r
1800 #endif\r
1801  \r