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