_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_UNKNOWN_DATA_TYPE  = E_CATEGORY_COMMON | 0x08 }; /* 1032 */\r
  48 enum { E_NOT_IMPLEMENT_YET  = E_CATEGORY_COMMON | 0x09 }; /* 1033 */\r
  49 enum { E_ORIGINAL           = E_CATEGORY_COMMON | 0x0A }; /* 1034 */\r
  50 enum { E_LIMITATION         = E_CATEGORY_COMMON | 0x0F }; /* 1039 */\r
  51 enum { E_FEW_MEMORY         = E_CATEGORY_COMMON | 0x10 }; /* 1040 */\r
  52 enum { E_FEW_ARRAY          = E_CATEGORY_COMMON | 0x11 }; /* 1041 */\r
  53 enum { E_CANNOT_OPEN_FILE   = E_CATEGORY_COMMON | 0x12 }; /* 1042 */\r
  54 enum { E_NOT_FOUND_DLL_FUNC = E_CATEGORY_COMMON | 0x13 }; /* 1043 */\r
  55 enum { E_BAD_COMMAND_ID     = E_CATEGORY_COMMON | 0x14 }; /* 1044 */\r
  56 enum { E_NOT_FOUND_SYMBOL   = E_CATEGORY_COMMON | 0x15 }; /* 1045 */\r
  57 enum { E_NO_NEXT            = E_CATEGORY_COMMON | 0x16 }; /* 1046 */\r
  58 enum { E_ACCESS_DENIED      = E_CATEGORY_COMMON | 0x17 }; /* 1047 */\r
  59 enum { E_PATH_NOT_FOUND     = E_CATEGORY_COMMON | 0x18 }; /* 1048 */\r
  60 enum { E_OUT_OF_WRITABLE    = E_CATEGORY_COMMON | 0x25 }; /* 1061 */\r
  61 enum { E_NOT_INIT_GLOBAL    = E_CATEGORY_COMMON | 0x6B }; /* 1131 */\r
  62 enum { E_TIME_OUT           = E_CATEGORY_COMMON | 0x70 }; /* 1136 */\r
  63 enum { E_BINARY_FILE        = E_CATEGORY_COMMON | 0xBF }; /* 1215 */\r
  64 enum { E_DEBUG_BREAK        = E_CATEGORY_COMMON | 0xDB }; /* 1243 */\r
  65 enum { E_EXIT_TEST          = E_CATEGORY_COMMON | 0xE7 }; /* 1255 */\r
  66 enum { E_FIFO_OVER          = E_CATEGORY_COMMON | 0xF0 }; /* 1264 */\r
  67 \r
  68 enum { NOT_FOUND_INDEX = -1 };\r
  69 \r
  70  \r
  71 /*=================================================================*/\r
  72 /* <<< [CRT/CRT.h] >>> */ \r
  73 /*=================================================================*/\r
  74  \r
  75 #include  <stdio.h> \r
  76 #ifdef  __linux__\r
  77         #define  _tfopen_s( out_File, Path, Mode ) \\r
  78                 ( *(out_File) = fopen( Path, Mode ),  (*(out_File) == NULL) ? (1) : (0) )\r
  79 #endif\r
  80  \r
  81 #include  <stdlib.h> \r
  82  \r
  83 #include  <string.h> \r
  84  \r
  85 #include  <stdarg.h> \r
  86 #ifdef  __linux__\r
  87         #define  _vsnprintf  vsnprintf\r
  88 #endif\r
  89  \r
  90 #include  <stddef.h> \r
  91  \r
  92 #include  <crtdbg.h> \r
  93  \r
  94 #ifndef  __linux__\r
  95         #include  <tchar.h> \r
  96 #else\r
  97         #define  _T(x)  x\r
  98         typedef  char  TCHAR;\r
  99         #define  _tcschr   strchr\r
 100         #define  _tprintf  printf\r
 101 #endif\r
 102  \r
 103 #include  <locale.h> \r
 104 \r
 105 #if UNDER_CE\r
 106   #define  setlocale( x, y )\r
 107 #endif\r
 108  \r
 109 #include  <errno.h> \r
 110 #ifdef  __linux__\r
 111         typedef  int  errno_t;  // CERT DCL09-C\r
 112 #endif\r
 113  \r
 114 #include  <assert.h> \r
 115  \r
 116 #include  <direct.h> \r
 117  \r
 118 #include  <malloc.h> \r
 119  \r
 120 #include  <io.h> \r
 121  \r
 122 #include  <fcntl.h> \r
 123  \r
 124 #include  <tlhelp32.h> \r
 125  \r
 126 /*=================================================================*/\r
 127 /* <<< [CRT_plus_1/CRT_plus_1.h] >>> */ \r
 128 /*=================================================================*/\r
 129  \r
 130 #if  __cplusplus\r
 131  extern "C" {  /* Start of C Symbol */ \r
 132 #endif\r
 133 \r
 134 \r
 135  \r
 136 /***********************************************************************\r
 137   <<< [C99Type] >>> \r
 138 ************************************************************************/\r
 139 typedef  int             int_t;      /* MISRA-C:1998 No.13 */\r
 140 typedef  signed int      int32_t;    /* For 32bit compiler */\r
 141 typedef  signed short    int16_t;\r
 142 typedef  signed char     int8_t;\r
 143 typedef  unsigned int    uint_t;     /* MISRA-C:1998 No.13 */  /* This is not C99 */\r
 144 typedef  unsigned int    uint32_t;   /* For 32bit compiler */\r
 145 typedef  unsigned short  uint16_t;\r
 146 typedef  unsigned char   uint8_t;\r
 147 typedef  unsigned char   byte_t;     /* This is not C99 */\r
 148 typedef  float           float32_t;  /* This is not C99 */\r
 149 typedef  double          float64_t;  /* This is not C99 */\r
 150 typedef  unsigned int    bool_t;     /* MISRA-C:1998 No.13 */  /* This is not C99 */\r
 151 typedef  unsigned int    bool32_t;   /* For 32bit compiler */\r
 152 typedef  unsigned short  bool16_t;\r
 153 typedef  unsigned char   bool8_t;\r
 154 typedef  int             int_fast32_t;\r
 155 typedef  int             int_fast16_t;\r
 156 typedef  int             int_fast8_t;\r
 157 typedef  unsigned int    uint_fast32_t;\r
 158 typedef  unsigned int    uint_fast16_t;\r
 159 typedef  unsigned int    uint_fast8_t;\r
 160 \r
 161 #define  INT_FAST32_MAX  INT_MAX\r
 162 \r
 163 \r
 164  \r
 165 /***********************************************************************\r
 166   <<< [INVALID_ARRAY_INDEX] >>> \r
 167 ************************************************************************/\r
 168 enum { INVALID_ARRAY_INDEX = -1 };\r
 169 \r
 170 \r
 171  \r
 172 /*********************************************************************************************\r
 173   <<< [bit_flags32_t] [bit_flags_fast32_t] >>> \r
 174   <<< [BitField] [BIT_FIELD_ENDIAN] [BIT_FIELD_LITTLE_ENDIAN] [BIT_FIELD_BIG_ENDIAN] >>> \r
 175 **********************************************************************************************/\r
 176 typedef  uint32_t      bit_flags32_t; \r
 177 typedef  uint_fast32_t bit_flags_fast32_t;\r
 178 typedef  unsigned int  BitField; \r
 179 typedef  uint32_t      BitField32;\r
 180 #define  BIT_FIELD_ENDIAN           BIT_FIELD_LITTLE_ENDIAN\r
 181 #define  BIT_FIELD_LITTLE_ENDIAN    1\r
 182 #define  BIT_FIELD_BIG_ENDIAN       2\r
 183 \r
 184 \r
 185  \r
 186 /***********************************************************************\r
 187   <<< [IsBitSet]        Check 1 bit >>> \r
 188   <<< [IsAnyBitsSet]    Check multiple bits >>> \r
 189   <<< [IsAllBitsSet]    Check multiple bits >>> \r
 190   <<< [IsBitNotSet]     Check 1 bit >>> \r
 191   <<< [IsAnyBitsNotSet] Check multiple bits >>> \r
 192   <<< [IsAllBitsNotSet] Check multiple bits >>> \r
 193 ************************************************************************/\r
 194 #define  IsBitSet( variable, const_value ) \\r
 195         ( ( (variable) & (const_value) ) != 0 )\r
 196 \r
 197 #define  IsAnyBitsSet( variable, or_const_value ) \\r
 198         ( ( (variable) & (or_const_value) ) != 0 )\r
 199 \r
 200 #define  IsAllBitsSet( variable, or_const_value ) \\r
 201         ( ( (variable) & (or_const_value) ) == (or_const_value) )\r
 202 \r
 203 #define  IsBitNotSet( variable, const_value ) \\r
 204         ( ( (variable) & (const_value) ) == 0 )\r
 205 \r
 206 #define  IsAnyBitsNotSet( variable, or_const_value ) \\r
 207         ( ( (variable) & (or_const_value) ) != (or_const_value) )\r
 208 \r
 209 #define  IsAllBitsNotSet( variable, or_const_value ) \\r
 210         ( ( (variable) & (or_const_value) ) == 0 )\r
 211 \r
 212 \r
 213  \r
 214 /***********************************************************************\r
 215   <<< [bool type] >>> \r
 216 ************************************************************************/\r
 217 #ifndef  __cplusplus\r
 218  #ifndef  BOOL_DEFINED\r
 219   typedef unsigned char   bool;\r
 220   enum  { true = 1, false = 0 };\r
 221  #define  BOOL_DEFINED\r
 222  #endif\r
 223 #endif\r
 224 \r
 225 \r
 226  \r
 227 /***********************************************************************\r
 228   <<< (malloc_redirected) >>> \r
 229 ************************************************************************/\r
 230 #define  malloc   malloc_redirected\r
 231 #define  realloc  realloc_redirected\r
 232 #define  calloc   calloc_redirected\r
 233 void*  malloc_redirected( size_t  in_Size );\r
 234 void*  realloc_redirected( void*  in_Address,  size_t  in_Size );\r
 235 void*  calloc_redirected( size_t  in_Count,  size_t  in_Size );\r
 236 void*  malloc_no_redirected( size_t  in_Size );\r
 237 void*  realloc_no_redirected( void*  in_Address,  size_t  in_Size );\r
 238 void*  calloc_no_redirected( size_t  in_Count,  size_t  in_Size );\r
 239 \r
 240 \r
 241  \r
 242 /***********************************************************************\r
 243   <<< [FuncType] >>> \r
 244 ************************************************************************/\r
 245 typedef  int (*FuncType)( void* Param ); \r
 246 typedef  errnum_t (* InitializeFuncType )( void* self, void* Parameter );\r
 247 //typedef  int (*FinishFuncType)( void* m, int e );  /*[FinishFuncType]*/\r
 248 typedef  errnum_t (*FinalizeFuncType)( void* self, errnum_t e );  /*[FinalizeFuncType]*/\r
 249 \r
 250 \r
 251  \r
 252 /***********************************************************************\r
 253   <<< [InterfaceID_Class] >>> \r
 254   <<< [InterfaceToVTableClass] >>> \r
 255 - const InterfaceID_Class  g_SampleInterface_ID;\r
 256 ************************************************************************/\r
 257 typedef struct _InterfaceID_Class  InterfaceID_Class;\r
 258 struct _InterfaceID_Class {\r
 259         char*  InterfaceName;\r
 260 };\r
 261 \r
 262 typedef struct _InterfaceToVTableClass  InterfaceToVTableClass;\r
 263 struct _InterfaceToVTableClass {\r
 264         const InterfaceID_Class*  InterfaceID;\r
 265         const void*               VTable;\r
 266 };\r
 267 \r
 268 \r
 269  \r
 270 /***********************************************************************\r
 271   <<< [ClassID_Class] >>> \r
 272 - const ClassID_Class  g_SampleClass_ID;\r
 273 ************************************************************************/\r
 274 typedef struct _ClassID_Class  ClassID_Class;\r
 275 struct _ClassID_Class {\r
 276         char*                          ClassName;\r
 277         const ClassID_Class**          SuperClassID_Array;\r
 278         int                            SuperClassID_Array_Count;\r
 279         size_t                         Size;\r
 280         InitializeFuncType             InitializeFunction;\r
 281         const InterfaceToVTableClass*  InterfaceToVTable_Array;\r
 282         int                            InterfaceToVTable_Array_Conut;\r
 283 };\r
 284 \r
 285 bool      ClassID_Class_isSuperClass( const ClassID_Class* ClassID, const ClassID_Class* SuperClassID );\r
 286 errnum_t  ClassID_Class_createObject( const ClassID_Class* ClassID, void* out_Object, void* Parameter );\r
 287 void*     ClassID_Class_getVTable( const ClassID_Class* ClassID, const InterfaceID_Class* InterfaceID );\r
 288 \r
 289 \r
 290  \r
 291 /***********************************************************************\r
 292   <<< [ClassID_SuperClass] >>> \r
 293 ************************************************************************/\r
 294 typedef struct _ClassID_SuperClass  ClassID_SuperClass;\r
 295 struct _ClassID_SuperClass {\r
 296         const ClassID_Class*  ClassID;  /* &g_(ClassName)_ID */\r
 297 };\r
 298 extern const ClassID_Class  g_ClassID_SuperClass_ID;\r
 299 \r
 300 \r
 301  \r
 302 /***********************************************************************\r
 303   <<< [g_FinalizerInterface_ID] >>> \r
 304 ************************************************************************/\r
 305 \r
 306 extern const InterfaceID_Class  g_FinalizerInterface_ID;\r
 307 \r
 308 /*[FinalizerVTableClass]*/\r
 309 typedef struct _FinalizerVTableClass  FinalizerVTableClass;\r
 310 struct _FinalizerVTableClass {\r
 311         int               OffsetToSelf;\r
 312         FinalizeFuncType  Finalize;\r
 313 };\r
 314 \r
 315 \r
 316  \r
 317 /***********************************************************************\r
 318   <<< [g_PrintXML_Interface_ID] >>> \r
 319 ************************************************************************/\r
 320 \r
 321 extern const InterfaceID_Class  g_PrintXML_Interface_ID;\r
 322 \r
 323 typedef errnum_t (* PrintXML_FuncType )( void* self, FILE* OutputStream );\r
 324 \r
 325 \r
 326 /*[PrintXML_VTableClass]*/\r
 327 typedef struct _PrintXML_VTableClass  PrintXML_VTableClass;\r
 328 struct _PrintXML_VTableClass {\r
 329         int                OffsetToSelf;\r
 330         PrintXML_FuncType  PrintXML;\r
 331 };\r
 332 \r
 333 \r
 334  \r
 335 /***********************************************************************\r
 336   <<< [fopen_ccs] >>> \r
 337 ************************************************************************/\r
 338 #if defined(_UNICODE) \r
 339   #define  fopen_ccs  ",ccs=UNICODE"\r
 340 #else\r
 341   #define  fopen_ccs  "t"\r
 342 #endif\r
 343 \r
 344 \r
 345  \r
 346 /***********************************************************************\r
 347   <<< [SizedStruct] >>> \r
 348 ************************************************************************/\r
 349 typedef struct _SizedStruct  SizedStruct;\r
 350 struct _SizedStruct {\r
 351         size_t  ThisStructSize;\r
 352         int     OthersData;\r
 353 };\r
 354 \r
 355 \r
 356  \r
 357 /***********************************************************************\r
 358   <<< [NameOnlyClass] >>> \r
 359 ************************************************************************/\r
 360 typedef struct _NameOnlyClass  NameOnlyClass;\r
 361 struct _NameOnlyClass {\r
 362         const TCHAR*  Name;\r
 363         const void*   Delegate;\r
 364 };\r
 365 \r
 366  \r
 367 /***********************************************************************\r
 368   <<< [NameAndNumClass] >>> \r
 369 ************************************************************************/\r
 370 typedef struct _NameAndNumClass  NameAndNumClass;  /* Like NameOnlyClass */\r
 371 struct _NameAndNumClass {\r
 372         TCHAR*  Name;\r
 373         int     Number;\r
 374 };\r
 375 \r
 376 \r
 377  \r
 378 /***********************************************************************\r
 379   <<< [inline] [SUPPORT_INLINE_C_FUNC] [NOT_USE_INLINE_MACRO] >>> \r
 380 ************************************************************************/\r
 381 #ifndef  SUPPORT_INLINE_C_FUNC\r
 382   #define  SUPPORT_INLINE_C_FUNC  1\r
 383 #endif\r
 384 #ifndef  INLINE\r
 385   #if ! __cplusplus\r
 386     #if SUPPORT_INLINE_C_FUNC\r
 387       #define  inline  _inline     /* inline is specified under C99 */\r
 388     #endif\r
 389   #endif\r
 390 #endif\r
 391 \r
 392 #ifndef  NOT_USE_INLINE_MACRO\r
 393   #define  NOT_USE_INLINE_MACRO  0\r
 394 #endif\r
 395 \r
 396 \r
 397  \r
 398 /**************************************************************************\r
 399  <<< [ttoi_ex] >>> \r
 400 ***************************************************************************/\r
 401 int  ttoi_ex( const TCHAR* string,  bit_flags_fast32_t options );\r
 402 \r
 403 \r
 404  \r
 405 /***********************************************************************\r
 406   <<< [PointerType_plus] >>> \r
 407 ************************************************************************/\r
 408 inline void  PointerType_plus( const void* in_out_Element, int PlusMinusByte )\r
 409 {\r
 410         *(int8_t**) in_out_Element = *(int8_t**) in_out_Element + PlusMinusByte;\r
 411 }\r
 412 \r
 413 \r
 414  \r
 415 /***********************************************************************\r
 416   <<< [PointerType_diff] >>> \r
 417 ************************************************************************/\r
 418 inline ptrdiff_t  PointerType_diff( const void* PointerA, const void* PointerB )\r
 419 {\r
 420         return  (uintptr_t) PointerA - (uintptr_t) PointerB;\r
 421 }\r
 422 \r
 423 \r
 424  \r
 425 /**************************************************************************\r
 426  <<< [JOIN_SYMBOL] >>> \r
 427 ***************************************************************************/\r
 428 #define JOIN_SYMBOL(x, y)  JOIN_SYMBOL_AGAIN(x, y)\r
 429 #define JOIN_SYMBOL_AGAIN(x, y) x##y\r
 430         /* CERT secure coding standard PRE05-C */\r
 431 \r
 432 \r
 433  \r
 434 /**************************************************************************\r
 435  <<< [static_assert] >>> \r
 436 ***************************************************************************/\r
 437 #define  static_assert( ConstantExpression, StringLiteral ) \\r
 438         __pragma(warning(push)) \\r
 439         __pragma(warning(disable:4127)) \\r
 440         do { typedef char JOIN_SYMBOL( AssertionFailed_, __LINE__ )[(ConstantExpression) ? 1 : -1]; } while(0) \\r
 441         __pragma(warning(pop))\r
 442 \r
 443 #define  static_assert_global( ConstantExpression, StringLiteral ) \\r
 444         __pragma(warning(push)) \\r
 445         __pragma(warning(disable:4127)) \\r
 446         typedef char JOIN_SYMBOL( AssertionFailed_, __LINE__ )[(ConstantExpression) ? 1 : -1] \\r
 447         __pragma(warning(pop))\r
 448 \r
 449         /* CERT secure coding standard DCL03-C */\r
 450         /* If "ConstantExpression" is false, illegal array size error will be raised. */\r
 451 \r
 452 \r
 453  \r
 454 #if  __cplusplus\r
 455  }  /* End of C Symbol */ \r
 456 #endif\r
 457  \r
 458 /*=================================================================*/\r
 459 /* <<< [Error4_Inline/Error4_Inline.h] >>> */ \r
 460 /*=================================================================*/\r
 461  \r
 462 /***********************************************************************\r
 463   <<< [UNREFERENCED_VARIABLE] >>> \r
 464   <<< [UNREFERENCED_VARIABLE_2] >>>\r
 465   <<< [UNREFERENCED_VARIABLE_3] >>>\r
 466   <<< [UNREFERENCED_VARIABLE_4] >>>\r
 467 ************************************************************************/\r
 468 #ifdef  __linux__\r
 469         #define  UNREFERENCED_VARIABLE( x )\r
 470         #define  UNREFERENCED_VARIABLES( x )\r
 471 #else\r
 472 \r
 473 #define  UNREFERENCED_VARIABLE( a1 )       UNREFERENCED_VARIABLE_Sub( &(a1) )\r
 474 #define  UNREFERENCED_VARIABLE_2( a1,a2 )  UNREFERENCED_VARIABLE_2_Sub( &(a1), &(a2) )\r
 475 #define  UNREFERENCED_VARIABLE_3( a1,a2,a3 )     UNREFERENCED_VARIABLE_3_Sub( &(a1), &(a2), &(a3) )\r
 476 #define  UNREFERENCED_VARIABLE_4( a1,a2,a3,a4 )  UNREFERENCED_VARIABLE_4_Sub( &(a1), &(a2), &(a3), &(a4) )\r
 477 \r
 478 inline void  UNREFERENCED_VARIABLE_Sub( const void* a1 ) { a1; }\r
 479 inline void  UNREFERENCED_VARIABLE_2_Sub( const void* a1, const void* a2 ) { a1,a2; }\r
 480 inline void  UNREFERENCED_VARIABLE_3_Sub( const void* a1, const void* a2, const void* a3 ) { a1,a2,a3; }\r
 481 inline void  UNREFERENCED_VARIABLE_4_Sub( const void* a1, const void* a2, const void* a3, const void* a4 ) { a1,a2,a3,a4; }\r
 482 \r
 483 #endif\r
 484 \r
 485 \r
 486  \r
 487 /*=================================================================*/\r
 488 /* <<< [Lock_1/Lock_1.h] >>> */ \r
 489 /*=================================================================*/\r
 490  \r
 491 /***********************************************************************\r
 492   <<< [SingletonInitializerClass] >>> \r
 493 ************************************************************************/\r
 494 typedef struct {\r
 495         volatile LONG  InitializeStep;\r
 496 } SingletonInitializerClass;\r
 497 \r
 498 #ifndef  SingletonInitializerClass_FailSleepTime\r
 499         #ifndef NDEBUG\r
 500                 #define  SingletonInitializerClass_FailSleepTime  60000\r
 501         #else\r
 502                 #define  SingletonInitializerClass_FailSleepTime  0\r
 503         #endif\r
 504 #endif\r
 505 \r
 506 bool  SingletonInitializerClass_isFirst( SingletonInitializerClass* self );\r
 507 void  SingletonInitializerClass_onFinishedInitialize( SingletonInitializerClass* self, int e );\r
 508 bool  SingletonInitializerClass_isInitialized( SingletonInitializerClass* self );\r
 509 \r
 510 \r
 511  \r
 512 /*=================================================================*/\r
 513 /* <<< [Print/Print2.h] >>> */ \r
 514 /*=================================================================*/\r
 515  \r
 516 #if  __cplusplus\r
 517  extern "C" {  /* Start of C Symbol */ \r
 518 #endif\r
 519  \r
 520 /***********************************************************************\r
 521   <<< [USE_printf_to] >>> \r
 522 ************************************************************************/\r
 523 #define  USE_printf_to_stdout    1\r
 524 #define  USE_printf_to_debugger  2\r
 525 #define  USE_printf_to_file      3\r
 526 \r
 527 \r
 528  \r
 529 /***********************************************************************\r
 530   <<< [PrintfCounterClass] >>> \r
 531 ************************************************************************/\r
 532 #if USE_PRINTF_COUNTER\r
 533 \r
 534 typedef struct _PrintfCounterClass  PrintfCounterClass;\r
 535 struct _PrintfCounterClass {\r
 536         int  Count;\r
 537         int  BreakCount;\r
 538         int  BreakIndent;\r
 539 };\r
 540 extern PrintfCounterClass  g_PrintfCounter;\r
 541 \r
 542 #endif\r
 543 \r
 544 \r
 545  \r
 546 errnum_t  vsprintf_r( char* s, size_t s_size, const char* format, va_list va ); \r
 547  \r
 548 errnum_t  vswprintf_r( wchar_t* s, size_t s_size, const wchar_t* format, va_list va ); \r
 549  \r
 550 /*[vstprintf_r]*/\r
 551 #if defined(_UNICODE) \r
 552   #define  vstprintf_r  vswprintf_r\r
 553 #else\r
 554   #define  vstprintf_r  vsprintf_r\r
 555 #endif\r
 556  \r
 557 errnum_t  stprintf_r( TCHAR* s, size_t s_size, const TCHAR* format, ... ); \r
 558  \r
 559 errnum_t  stcpy_part_r( TCHAR* s, size_t s_size, TCHAR* s_start, TCHAR** p_s_last, \r
 560                    const TCHAR* src, const TCHAR* src_over );\r
 561 errnum_t  stprintf_part_r( TCHAR* s, size_t s_size, TCHAR* s_start, TCHAR** p_s_last,\r
 562                       const TCHAR* format, ... );\r
 563  \r
 564 errnum_t  ftcopy_part_r( FILE* OutputStream, const TCHAR* Str, const TCHAR* StrOver );\r
 565  \r
 566 errnum_t  OpenConsole( bool  in_OpenIfNoConsole,  bool*  out_IsExistOrNewConsole );\r
 567 \r
 568  \r
 569 #if  __cplusplus\r
 570  }    /* End of C Symbol */ \r
 571 #endif\r
 572 \r
 573  \r
 574 /*=================================================================*/\r
 575 /* <<< [StrT_typedef/StrT_typedef.h] >>> */ \r
 576 /*=================================================================*/\r
 577  \r
 578 /***********************************************************************\r
 579   <<< [NewStringsEnum] >>> \r
 580 ************************************************************************/\r
 581 typedef enum  _NewStringsEnum  NewStringsEnum;\r
 582 enum  _NewStringsEnum {\r
 583         NewStringsEnum_NewPointersAndLinkCharacters = 0x06,\r
 584         NewStringsEnum_NewPointersAndNewCharacters  = 0x03,\r
 585         NewStringsEnum_LinkCharacters               = 0x04,\r
 586         NewStringsEnum_NewPointers                  = 0x02,\r
 587         NewStringsEnum_NewCharacters                = 0x01,\r
 588         NewStringsEnum_NoAllocate                   = 0x00\r
 589 };\r
 590 \r
 591 \r
 592  \r
 593 /*=================================================================*/\r
 594 /* <<< [SetX/SetX.h] >>> */ \r
 595 /*=================================================================*/\r
 596  \r
 597 #ifndef  __SETX_H \r
 598 #define  __SETX_H\r
 599 \r
 600 #ifdef  __cplusplus\r
 601  extern "C" {  /* Start of C Symbol */\r
 602 #endif\r
 603 \r
 604  \r
 605 /******************************************************************\r
 606   <<< Set4_typedef >>> \r
 607 *******************************************************************/\r
 608 \r
 609 typedef struct _Set4      Set4;\r
 610 typedef struct _Set4Iter  Set4Iter;\r
 611 \r
 612 typedef  int  (*FuncType_create_in_set4)( void** pm, Set4* Set );\r
 613  \r
 614 /***********************************************************************\r
 615   <<< [Set2] >>> \r
 616 ************************************************************************/\r
 617 typedef  struct _Set2  Set2;\r
 618 struct _Set2 {\r
 619         void*  First;\r
 620         void*  Next;\r
 621         void*  Over;\r
 622 \r
 623         #ifdef _DEBUG\r
 624         void**   PointerOfDebugArray;  /* void<type> */\r
 625         #endif\r
 626 };\r
 627 \r
 628 //[Set2_IteratorClass]\r
 629 typedef struct _Set2_IteratorClass  Set2_IteratorClass;\r
 630 struct _Set2_IteratorClass {\r
 631         Set2*     Parent;\r
 632         int       ElementSize;\r
 633         uint8_t*  Current;\r
 634 };\r
 635 \r
 636 #define  Set2_initConst( m )  ( (m)->First = NULL, (m)->Next = NULL )\r
 637 errnum_t  Set2_init( Set2* m, int FirstSize );\r
 638 errnum_t  Set2_finish( Set2* m, errnum_t e );\r
 639 #define  Set2_isInited( m )  ( (m)->First != NULL )\r
 640 \r
 641 #define  Set2_allocate( m, pp ) \\r
 642         Set2_alloc_imp( m, (void*)(pp), sizeof(**(pp)) )\r
 643 \r
 644 #define  Set2_alloc( m, pp, type ) \\r
 645         Set2_alloc_imp( m, (void*)(pp), sizeof(type) )\r
 646 \r
 647 errnum_t  Set2_alloc_imp( Set2* m, void* pm, size_t size );\r
 648 \r
 649 #define  Set2_push( m, pp, type ) \\r
 650         Set2_alloc_imp( m, (void*)(pp), sizeof(type) )\r
 651 \r
 652 #define  Set2_pop( m, pp, type ) \\r
 653         Set2_pop_imp( m, (void*)(pp), sizeof(type) )\r
 654 \r
 655 errnum_t  Set2_pop_imp( Set2* m, void* pp, size_t size );\r
 656 \r
 657 #define  Set2_free( m, pp, e ) \\r
 658         Set2_free_imp( m, pp, sizeof(**(pp)), e )\r
 659 errnum_t  Set2_free_imp( Set2* self,  void* in_PointerOfPointer,  size_t  in_Size_ofElement,  errnum_t  e );\r
 660 \r
 661 #define  Set2_freeLast( m, p, type, e ) \\r
 662         ( ((char*)(m)->Next - sizeof(type) == (char*)(p)) ? \\r
 663                 (m)->Next = (p), (e) : \\r
 664                 ((e)?(e):E_OTHERS) )\r
 665 \r
 666 #define  Set2_toEmpty( m ) \\r
 667         ( (m)->Next = (m)->First, 0 )\r
 668 \r
 669 #define  Set2_expandIfOverByAddr( m, OverAddrBasedOnNowFirst ) \\r
 670         ( (void*)(OverAddrBasedOnNowFirst) <= (m)->Over ? 0 : \\r
 671                 Set2_expandIfOverByAddr_imp( m, OverAddrBasedOnNowFirst ) )\r
 672 \r
 673 #define  Set2_expandIfOverByOffset( m, Size ) \\r
 674         Set2_expandIfOverByAddr( m, (char*)(m)->First + (Size) )\r
 675 errnum_t  Set2_expandIfOverByAddr_imp( Set2* m, void* OverAddrBasedOnNowFirst );\r
 676 \r
 677 #define  Set2_allocMulti( m, out_pElem, ElemType, nElem ) \\r
 678         Set2_allocMulti_sub( m, (void*)(out_pElem), sizeof(ElemType) * (nElem) )\r
 679 errnum_t  Set2_allocMulti_sub( Set2* m, void* out_pElem, size_t ElemsSize );\r
 680 \r
 681 #define  Set2_forEach( self, Item, Item_Over, Type ) \\r
 682         *(Item) = (Type*)( (self)->First ),  *(Item_Over) = (Type*)( (self)->Next ); \\r
 683         *(Item) < *(Item_Over); \\r
 684         *(Item) += 1\r
 685 \r
 686 errnum_t  Set2_getIterator( Set2* self, Set2_IteratorClass* out_Iterator, int ElementSize );\r
 687 errnum_t  Set2_getDescendingIterator( Set2* self, Set2_IteratorClass* out_Iterator, int ElementSize );\r
 688 void*  Set2_IteratorClass_getNext( Set2_IteratorClass* self );\r
 689 void*  Set2_IteratorClass_getPrevious( Set2_IteratorClass* self );\r
 690 \r
 691 \r
 692 //[Set2_forEach2]\r
 693 #define  Set2_forEach2( self, Iterator, out_Element ) \\r
 694         Set2_forEach2_1( self, Iterator, out_Element, sizeof(**(out_Element)) ); \\r
 695         Set2_forEach2_2( self, Iterator, out_Element ); \\r
 696         Set2_forEach2_3( self, Iterator, out_Element )\r
 697 \r
 698 inline void  Set2_forEach2_1( Set2* self, Set2_IteratorClass* Iterator,  void* out_Element,\r
 699         size_t ElementSize )\r
 700 {\r
 701         Set2_getIterator( self, Iterator, ElementSize );\r
 702         *(void**) out_Element = Set2_IteratorClass_getNext( Iterator );\r
 703 }\r
 704 \r
 705 inline bool  Set2_forEach2_2( Set2* self,  Set2_IteratorClass* Iterator,  void* out_Element )\r
 706 {\r
 707         UNREFERENCED_VARIABLE_2( self, Iterator );\r
 708         return  ( *(void**) out_Element != NULL );\r
 709 }\r
 710 \r
 711 inline void  Set2_forEach2_3( Set2* self, Set2_IteratorClass* Iterator,  void* out_Element )\r
 712 {\r
 713         UNREFERENCED_VARIABLE( self );\r
 714         *(void**) out_Element = Set2_IteratorClass_getNext( Iterator );\r
 715 }\r
 716 \r
 717 \r
 718 #define  Set2_getArray( self, out_Array, out_Count ) \\r
 719         ( ( *(void**)(out_Array) = (self)->First, \\r
 720         *(out_Count) = ( (byte_t*) (self)->Next - (byte_t*) (self)->First ) / sizeof(**(out_Array))), 0 )\r
 721 \r
 722 #define  Set2_refer( m, iElem, out_pElem ) \\r
 723         Set2_ref_imp( m, iElem, out_pElem, sizeof(**(out_pElem)) )\r
 724 \r
 725 #define  Set2_ref( m, iElem, out_pElem, ElemType ) \\r
 726         Set2_ref_imp( m, iElem, out_pElem, sizeof(ElemType) )\r
 727 \r
 728 errnum_t  Set2_ref_imp( Set2* m, int iElem, void* out_pElem, size_t ElemSize );\r
 729 \r
 730 #define  Set2_isEmpty( m ) \\r
 731         ( (m)->Next == (m)->First )\r
 732 \r
 733 #define  Set2_getCount( m, Type ) \\r
 734         ( ( (byte_t*)(m)->Next - (byte_t*)(m)->First ) / sizeof(Type) )\r
 735 \r
 736 #define  Set2_getCountMax( m, Type ) \\r
 737         ( ( (byte_t*)(m)->Over - (byte_t*)(m)->First ) / sizeof(Type) )\r
 738 \r
 739 #define  Set2_checkPtrInArr( m, p ) \\r
 740         ( (m)->First <= (p) && (p) < (m)->Over ? 0 : E_NOT_FOUND_SYMBOL )\r
 741 \r
 742 errnum_t  Set2_separate( Set2* m, int NextSize, void** allocate_Array );\r
 743 \r
 744 #ifdef _DEBUG\r
 745 void  Set2_setDebug( Set2* m, void* PointerOfDebugArray );\r
 746 #endif\r
 747 \r
 748  \r
 749 /***********************************************************************\r
 750   <<< [Set2a] >>> \r
 751 ************************************************************************/\r
 752 typedef  struct _Set2  Set2a;\r
 753 \r
 754 void  Set2a_initConst( Set2a* m, void* ArrInStack );\r
 755 int   Set2a_init( Set2a* m, void* ArrInStack, size_t ArrInStack_Size );\r
 756 int   Set2a_finish( Set2a* m, void* ArrInStack, int e );\r
 757 int   Set2a_toEmpty( Set2a* m );\r
 758 //int Set2a_alloc( Set2a* m, void* ArrInStack, ClassA** out_p, Type ClassA );\r
 759 int   Set2a_expandIfOverByAddr( Set2a* m, void* OverAddrBasedOnNowFirst );\r
 760 \r
 761 \r
 762 \r
 763 // for inside\r
 764 \r
 765 #define  Set2a_initConst( m, ArrInStack ) \\r
 766         ( (m)->First = (ArrInStack) )\r
 767 \r
 768 #define  Set2a_finish( m, ArrInStack, e ) \\r
 769         ( (m)->First == (ArrInStack) ? (e) : ( free( (m)->First ), (e) ) )\r
 770 \r
 771 #define  Set2a_toEmpty( m ) \\r
 772         Set2_toEmpty( m )\r
 773 \r
 774 #define  Set2a_alloc( m, ArrInStack, out_Pointer, ClassA ) \\r
 775         ( (void*)( (ClassA*)((m)->Next) + 1 ) <= (m)->Over ? \\r
 776                 ( *(out_Pointer) = (ClassA*)(m)->Next,  (m)->Next = (ClassA*)((m)->Next) + 1, 0 ) : \\r
 777                 Set2a_alloc_imp( m, ArrInStack, out_Pointer, sizeof(ClassA) ) )\r
 778 \r
 779 int  Set2a_alloc_imp( Set2a* m, void* ArrInStack, void* out_Pointer, size_t ElemSize );\r
 780 \r
 781 #define  Set2a_expandIfOverByAddr( m, ArrInStack, OverAddrBasedOnNowFirst ) \\r
 782         ( (void*)(OverAddrBasedOnNowFirst) <= (m)->Over ? 0 : \\r
 783                 Set2a_expandIfOverByAddr_imp( m, ArrInStack, OverAddrBasedOnNowFirst ) )\r
 784 \r
 785 int  Set2a_expandIfOverByAddr_imp( Set2a* m, void* ArrInStack, void* OverAddrBasedOnNowFirst );\r
 786 \r
 787 \r
 788  \r
 789 /******************************************************************\r
 790   <<< [Set4] >>> \r
 791 *******************************************************************/\r
 792 struct _Set4 {\r
 793         byte_t*   FirstBlock;\r
 794         byte_t*   CurrentBlockFirst;\r
 795         byte_t*   CurrentBlockNext;\r
 796         union {\r
 797                 byte_t*   CurrentBlockOver;\r
 798                 byte_t**  NextBlock;\r
 799         } u;\r
 800         size_t    HeapSize;\r
 801         size_t    ElementSize;\r
 802 };\r
 803 \r
 804 struct _Set4Iter {\r
 805         void*  p;\r
 806         void*  Over;\r
 807 };\r
 808 \r
 809 /* errnum_t  Set4_init( Set4* self, Type, int FirstHeapSize ); */\r
 810 /* errnum_t  Set4_allocate( Set4* self, Type** out_ElementPointer ); */\r
 811 /* errnum_t  Set4_free( Set4* self, Type** in_out_ElementPointer ); */\r
 812 /* Type*     Set4_ref( Set4* self, int i, Type ); */\r
 813 \r
 814 \r
 815 /* Private */\r
 816 errnum_t  Set4_init_imp( Set4* self,  size_t in_ElementSize,  size_t FirstHeapSize );\r
 817 errnum_t  Set4_finish2_imp2( Set4* self );\r
 818 errnum_t  Set4_finish2_imp( Set4* self,  errnum_t  e,  size_t in_ElementSize,  FinalizeFuncType  in_Type_Finalize );\r
 819 errnum_t  Set4_alloc_imp( Set4* self,  void* out_ElementPointer,  size_t in_ElementSize );\r
 820 errnum_t  Set4_free_imp( Set4* self,  void* in_out_ElementPointer,  size_t in_ElementSize,  errnum_t e );\r
 821 void*     Set4_ref_imp( Set4* self, int i, int size );\r
 822 int       Set4_getCount_imp( Set4* self, int size );\r
 823 void      Set4_forEach_imp2( Set4* self, Set4Iter* p, int size );\r
 824 \r
 825 \r
 826  \r
 827 /**************************************************************************\r
 828   <<< [ListClass] Linked List >>> \r
 829 ***************************************************************************/\r
 830 typedef struct  _ListClass          ListClass;\r
 831 typedef struct  _ListElementClass   ListElementClass;\r
 832 typedef struct  _ListIteratorClass  ListIteratorClass;\r
 833 \r
 834 /*[ListElementClass]*/\r
 835 struct  _ListElementClass {  /* This struct can be menbers of Data */\r
 836         void*              Data;  /* Element Data */\r
 837         ListClass*         List;  /* NULL = Not in a list */\r
 838         ListElementClass*  Next;\r
 839         ListElementClass*  Previous;\r
 840 };\r
 841 \r
 842 struct  _ListClass {\r
 843         void*              Data;  /* List owner. ListClass does not set this */\r
 844         ListElementClass   Terminator;\r
 845         int                Count;\r
 846 };\r
 847 \r
 848 /*[ListIteratorClass]*/\r
 849 struct  _ListIteratorClass {\r
 850         ListElementClass*  Element;\r
 851         ListElementClass   ModifiedElement;\r
 852 };\r
 853 \r
 854        void      ListClass_initConst( ListClass* self );\r
 855 inline errnum_t  ListClass_add( ListClass* self, ListElementClass* Element ); /* addFirst */\r
 856        errnum_t  ListClass_addAtIndex( ListClass* self, int Index, ListElementClass* Element );\r
 857 inline errnum_t  ListClass_addFirst( ListClass* self, ListElementClass* Element );\r
 858 inline errnum_t  ListClass_addLast( ListClass* self, ListElementClass* Element );\r
 859 inline int       ListClass_getCount( ListClass* self );\r
 860 inline errnum_t  ListClass_getData( ListClass* self, int Index, void* out_Data );\r
 861        errnum_t  ListClass_get( ListClass* self, int Index, ListElementClass** out_Element );\r
 862        errnum_t  ListClass_set( ListClass* self, int Index, ListElementClass* Element );\r
 863        errnum_t  ListClass_replace( ListClass* self, ListElementClass* RemovingElement, ListElementClass* AddingElement );\r
 864 inline errnum_t  ListClass_getFirstData( ListClass* self, void* out_Data );\r
 865 inline errnum_t  ListClass_getLastData( ListClass* self, void* out_Data );\r
 866 inline errnum_t  ListClass_getFirst( ListClass* self, ListElementClass** out_Element );\r
 867 inline errnum_t  ListClass_getLast( ListClass* self, ListElementClass** out_Element );\r
 868        int       ListClass_getIndexOfData( ListClass* self, void* Data );\r
 869        int       ListClass_getIndexOf( ListClass* self, ListElementClass* Element );\r
 870        int       ListClass_getLastIndexOfData( ListClass* self, void* Data );\r
 871        errnum_t  ListClass_getArray( ListClass* self, void* DataArray, size_t DataArraySize );\r
 872        errnum_t  ListClass_removeByIndex( ListClass* self, int Index );\r
 873        errnum_t  ListClass_remove( ListClass* self, ListElementClass* Element );\r
 874 inline errnum_t  ListClass_removeFirst( ListClass* self );\r
 875 inline errnum_t  ListClass_removeLast( ListClass* self );\r
 876        errnum_t  ListClass_clear( ListClass* self );\r
 877 inline errnum_t  ListClass_push( ListClass* self, ListElementClass* Element );\r
 878 inline void*     ListClass_popData( ListClass* self );\r
 879 inline ListElementClass*  ListClass_pop( ListClass* self );\r
 880 inline errnum_t  ListClass_enqueue( ListClass* self, ListElementClass* Element );\r
 881 inline void*     ListClass_dequeueData( ListClass* self );\r
 882 inline ListElementClass*  ListClass_dequeue( ListClass* self );\r
 883 inline errnum_t  ListClass_getListIterator( ListClass* self, ListIteratorClass* out_Iterator );\r
 884 inline errnum_t  ListClass_getDescendingListIterator( ListClass* self, ListIteratorClass* out_Iterator );\r
 885 \r
 886 inline void  ListElementClass_initConst( ListElementClass* self, void* Data );\r
 887 \r
 888 void*     ListIteratorClass_getNext( ListIteratorClass* self );\r
 889 void*     ListIteratorClass_getPrevious( ListIteratorClass* self );\r
 890 errnum_t  ListIteratorClass_replace( ListIteratorClass* self, ListElementClass* AddingElement );\r
 891 errnum_t  ListIteratorClass_remove( ListIteratorClass* self );\r
 892 \r
 893 \r
 894 \r
 895 /* Implements of ListClass */\r
 896 errnum_t  ListClass_addAt_Sub( ListElementClass* AddingElement, ListElementClass* Target );\r
 897 \r
 898 \r
 899 /*[ListClass_add]*/\r
 900 inline errnum_t  ListClass_add( ListClass* self, ListElementClass* Element )\r
 901 {\r
 902         return  ListClass_addFirst( self, Element );\r
 903 }\r
 904 \r
 905 \r
 906 /*[ListClass_addFirst]*/\r
 907 inline errnum_t  ListClass_addFirst( ListClass* self, ListElementClass* Element )\r
 908 {\r
 909         return  ListClass_addAt_Sub( Element, self->Terminator.Next );\r
 910 }\r
 911 \r
 912 \r
 913 /*[ListClass_addLast]*/\r
 914 inline errnum_t  ListClass_addLast( ListClass* self, ListElementClass* Element )\r
 915 {\r
 916         return  ListClass_addAt_Sub( Element, &self->Terminator );\r
 917 }\r
 918 \r
 919 \r
 920 /*[ListClass_getCount]*/\r
 921 inline int  ListClass_getCount( ListClass* self )\r
 922 {\r
 923         return  self->Count;\r
 924 }\r
 925 \r
 926 \r
 927 /*[ListClass_getData]*/\r
 928 inline errnum_t  ListClass_getData( ListClass* self, int Index, void* out_Data )\r
 929 {\r
 930         errnum_t  e;\r
 931         ListElementClass*  target;\r
 932 \r
 933         e= ListClass_get( self, Index, &target );\r
 934         if ( e == 0 )\r
 935                 { *(void**) out_Data = target->Data; }\r
 936         return  e;\r
 937 }\r
 938 \r
 939 \r
 940 /*[ListClass_getFirstData]*/\r
 941 inline errnum_t  ListClass_getFirstData( ListClass* self, void* out_Data )\r
 942 {\r
 943         if ( self->Count == 0 ) {\r
 944                 return  E_NOT_FOUND_SYMBOL;\r
 945         }\r
 946         else {\r
 947                 *(void**) out_Data = self->Terminator.Next->Data;\r
 948                 return  0;\r
 949         }\r
 950 }\r
 951 \r
 952 \r
 953 /*[ListClass_getLastData]*/\r
 954 inline errnum_t  ListClass_getLastData( ListClass* self, void* out_Data )\r
 955 {\r
 956         if ( self->Count == 0 ) {\r
 957                 return  E_NOT_FOUND_SYMBOL;\r
 958         }\r
 959         else {\r
 960                 *(void**) out_Data = self->Terminator.Previous->Data;\r
 961                 return  0;\r
 962         }\r
 963 }\r
 964 \r
 965 \r
 966 /*[ListClass_getFirst]*/\r
 967 inline errnum_t  ListClass_getFirst( ListClass* self, ListElementClass** out_Element )\r
 968 {\r
 969         if ( self->Count == 0 ) {\r
 970                 return  E_NOT_FOUND_SYMBOL;\r
 971         }\r
 972         else {\r
 973                 *out_Element = self->Terminator.Next;\r
 974                 return  0;\r
 975         }\r
 976 }\r
 977 \r
 978 \r
 979 /*[ListClass_getLast]*/\r
 980 inline errnum_t  ListClass_getLast( ListClass* self, ListElementClass** out_Element )\r
 981 {\r
 982         if ( self->Count == 0 ) {\r
 983                 return  E_NOT_FOUND_SYMBOL;\r
 984         }\r
 985         else {\r
 986                 *out_Element = self->Terminator.Previous;\r
 987                 return  0;\r
 988         }\r
 989 }\r
 990 \r
 991 \r
 992 /*[ListClass_isExistData]*/\r
 993 inline bool  ListClass_isExistData( ListClass* self, void* Data )\r
 994 {\r
 995         return  ( ListClass_getIndexOfData( self, Data ) != INVALID_ARRAY_INDEX );\r
 996 }\r
 997 \r
 998 \r
 999 /*[ListClass_removeFirst]*/\r
1000 inline errnum_t  ListClass_removeFirst( ListClass* self )\r
1001 {\r
1002         if ( self->Count == 0 ) {\r
1003                 return  E_NOT_FOUND_SYMBOL;\r
1004         }\r
1005         else {\r
1006                 return  ListClass_remove( self, self->Terminator.Next );\r
1007         }\r
1008 }\r
1009 \r
1010 \r
1011 /*[ListClass_removeLast]*/\r
1012 inline errnum_t  ListClass_removeLast( ListClass* self )\r
1013 {\r
1014         if ( self->Count == 0 ) {\r
1015                 return  E_NOT_FOUND_SYMBOL;\r
1016         }\r
1017         else {\r
1018                 return  ListClass_remove( self, self->Terminator.Previous );\r
1019         }\r
1020 }\r
1021 \r
1022 \r
1023 /*[ListClass_push]*/\r
1024 inline errnum_t  ListClass_push( ListClass* self, ListElementClass* Element )\r
1025 {\r
1026         return  ListClass_addFirst( self, Element );\r
1027 }\r
1028 \r
1029 \r
1030 /*[ListClass_popData]*/\r
1031 inline void*  ListClass_popData( ListClass* self )\r
1032 {\r
1033         if ( self->Count == 0 ) {\r
1034                 return  NULL;\r
1035         }\r
1036         else {\r
1037                 ListElementClass*  element = self->Terminator.Next;\r
1038 \r
1039                 ListClass_remove( self, element );\r
1040                 return  element->Data;\r
1041         }\r
1042 }\r
1043 \r
1044 \r
1045 /*[ListClass_pop]*/\r
1046 inline ListElementClass*  ListClass_pop( ListClass* self )\r
1047 {\r
1048         if ( self->Count == 0 ) {\r
1049                 return  NULL;\r
1050         }\r
1051         else {\r
1052                 ListElementClass*  element = self->Terminator.Next;\r
1053 \r
1054                 ListClass_remove( self, element );\r
1055                 return  element;\r
1056         }\r
1057 }\r
1058 \r
1059 \r
1060 /*[ListClass_enqueue]*/\r
1061 inline errnum_t  ListClass_enqueue( ListClass* self, ListElementClass* Element )\r
1062 {\r
1063         return  ListClass_addLast( self, Element );\r
1064 }\r
1065 \r
1066 \r
1067 /*[ListClass_dequeueData]*/\r
1068 inline void*  ListClass_dequeueData( ListClass* self )\r
1069 {\r
1070         return  ListClass_popData( self );\r
1071 }\r
1072 \r
1073 \r
1074 /*[ListClass_dequeue]*/\r
1075 inline ListElementClass*  ListClass_dequeue( ListClass* self )\r
1076 {\r
1077         return  ListClass_pop( self );\r
1078 }\r
1079 \r
1080 \r
1081 /*[ListClass_getListIterator]*/\r
1082 inline errnum_t  ListClass_getListIterator( ListClass* self, ListIteratorClass* out_Iterator )\r
1083 {\r
1084         out_Iterator->Element = &self->Terminator;\r
1085         out_Iterator->ModifiedElement.List = NULL;\r
1086         return  0;\r
1087 }\r
1088 \r
1089 \r
1090 /*[ListClass_getDescendingListIterator]*/\r
1091 inline errnum_t  ListClass_getDescendingListIterator( ListClass* self, ListIteratorClass* out_Iterator )\r
1092 {\r
1093         out_Iterator->Element = &self->Terminator;\r
1094         out_Iterator->ModifiedElement.List = NULL;\r
1095         return  0;\r
1096 }\r
1097 \r
1098 \r
1099 /*[ListElementClass_initConst]*/\r
1100 inline void  ListElementClass_initConst( ListElementClass* self, void* Data )\r
1101 {\r
1102         self->Data = Data;\r
1103         self->List = NULL;\r
1104 \r
1105         #ifndef NDEBUG\r
1106                 self->Next     = NULL;\r
1107                 self->Previous = NULL;\r
1108         #endif\r
1109 }\r
1110 \r
1111 \r
1112  \r
1113 /***********************************************************************\r
1114   <<< [ListClass_forEach] >>> \r
1115 ************************************************************************/\r
1116 #define  ListClass_forEach( self, iterator, out_Element ) \\r
1117         ListClass_forEach_1( self, iterator, out_Element ); \\r
1118         ListClass_forEach_2( self, iterator, out_Element ); \\r
1119         ListClass_forEach_3( self, iterator, out_Element )\r
1120 \r
1121 \r
1122 inline void  ListClass_forEach_1( ListClass* self, ListIteratorClass* iterator,  void* out_Element )\r
1123 {\r
1124         ListClass_getListIterator( self, iterator );\r
1125         *(void**) out_Element = ListIteratorClass_getNext( iterator );\r
1126 }\r
1127 \r
1128 \r
1129 inline bool  ListClass_forEach_2( ListClass* self,  ListIteratorClass* iterator,  void* out_Element )\r
1130 {\r
1131         UNREFERENCED_VARIABLE_2( self, iterator );\r
1132         return  ( *(void**) out_Element != NULL );\r
1133 }\r
1134 \r
1135 \r
1136 inline void  ListClass_forEach_3( ListClass* self, ListIteratorClass* iterator,  void* out_Element )\r
1137 {\r
1138         UNREFERENCED_VARIABLE( self );\r
1139         *(void**) out_Element = ListIteratorClass_getNext( iterator );\r
1140 }\r
1141 \r
1142 \r
1143  \r
1144 /**************************************************************************\r
1145   <<< [ListClass:ClassID] >>> \r
1146 ***************************************************************************/\r
1147 errnum_t  ListClass_finalizeWithVTable( ListClass* self, bool IsFreeElements, errnum_t e );\r
1148 errnum_t  ListClass_printXML( ListClass* self, FILE* OutputStream );\r
1149 \r
1150 \r
1151  \r
1152 /***********************************************************************\r
1153   <<< [Variant_SuperClass] >>>\r
1154 ************************************************************************/\r
1155 \r
1156 typedef struct _VariantClass  VariantClass;\r
1157 \r
1158 typedef struct _Variant_SuperClass  Variant_SuperClass;\r
1159 struct _Variant_SuperClass {\r
1160 \r
1161         /* <Inherit parent="ClassID_SuperClass"> */\r
1162         const ClassID_Class*   ClassID;\r
1163         /* </Inherit> */\r
1164 \r
1165         FinalizerVTableClass*  FinalizerVTable;\r
1166         VariantClass*          StaticAddress;\r
1167 };\r
1168 \r
1169 extern const ClassID_Class  g_Variant_SuperClass_ID;\r
1170 errnum_t  Variant_SuperClass_initialize( Variant_SuperClass* self, void* Parameter );\r
1171 errnum_t  Variant_SuperClass_overwrite( Variant_SuperClass* self,\r
1172         Variant_SuperClass* AddingElement );\r
1173 \r
1174 \r
1175  \r
1176 /***********************************************************************\r
1177   <<< [VariantClass] >>>\r
1178 - VariantClass* == Variant_SuperClass**\r
1179 ************************************************************************/\r
1180 typedef struct _VariantClass  VariantClass;\r
1181  \r
1182 struct _VariantClass {\r
1183         Variant_SuperClass*  Object;\r
1184         ListElementClass     ListElement;\r
1185 };\r
1186 \r
1187 \r
1188  \r
1189 /***********************************************************************\r
1190   <<< [VariantListClass] >>>\r
1191 ************************************************************************/\r
1192 typedef struct _VariantListIteratorClass  VariantListIteratorClass;\r
1193 typedef struct _Variant_SuperClass        Variant_SuperClass;\r
1194 typedef struct _VariantListIteratorClass  VariantListIteratorClass;\r
1195 \r
1196 typedef struct _VariantListClass  VariantListClass;\r
1197 struct _VariantListClass {\r
1198         ListClass /*<VariantClass>*/  List;\r
1199 };\r
1200 \r
1201 void      VariantListClass_initConst( VariantListClass* self );\r
1202 /*        VariantListClass_initialize is not exist */\r
1203 errnum_t  VariantListClass_finalize( VariantListClass* self, errnum_t e );\r
1204 \r
1205 errnum_t  VariantListClass_createElement( VariantListClass* self,\r
1206         void* /*<Variant_SuperClass**>*/ out_ElementObject,\r
1207         const ClassID_Class* ClassID,  void* Parameter );\r
1208 \r
1209 errnum_t  VariantListClass_destroyElement( VariantListClass* self,\r
1210         void* /*<Variant_SuperClass**>*/  in_out_ElementObject,  errnum_t e );\r
1211 \r
1212 errnum_t  VariantListClass_getListIterator( VariantListClass* self,\r
1213         VariantListIteratorClass* out_Iterator );\r
1214 \r
1215 \r
1216  \r
1217 /***********************************************************************\r
1218   <<< [VariantListIteratorClass] >>>\r
1219 ************************************************************************/\r
1220 typedef struct _VariantListIteratorClass  VariantListIteratorClass;\r
1221 struct _VariantListIteratorClass {\r
1222         ListIteratorClass  Iterator;\r
1223 };\r
1224 Variant_SuperClass*  VariantListIteratorClass_getNext( VariantListIteratorClass* self );\r
1225 \r
1226 \r
1227 /*[VariantListClass_getListIterator]*/\r
1228 inline errnum_t  VariantListClass_getListIterator( VariantListClass* self,\r
1229         VariantListIteratorClass* out_Iterator )\r
1230 {\r
1231         return  ListClass_getListIterator( &self->List, &out_Iterator->Iterator );\r
1232 }\r
1233 \r
1234 \r
1235  \r
1236 /***********************************************************************\r
1237   <<< [VariantListClass_forEach] >>>\r
1238 ************************************************************************/\r
1239 #define  VariantListClass_forEach( self, Iterator, out_Pointer ) \\r
1240         VariantListClass_forEach_Sub1( self, Iterator, out_Pointer ); \\r
1241         *(out_Pointer) != NULL; \\r
1242         VariantListClass_forEach_Sub3( Iterator, out_Pointer )\r
1243 \r
1244 inline void  VariantListClass_forEach_Sub1( VariantListClass* self,\r
1245         VariantListIteratorClass* Iterator, void* out_Pointer )\r
1246 {\r
1247         VariantListClass_getListIterator( self, Iterator );\r
1248         *(void**) out_Pointer = VariantListIteratorClass_getNext( Iterator );\r
1249 }\r
1250 \r
1251 inline void  VariantListClass_forEach_Sub3( \\r
1252         VariantListIteratorClass* Iterator, void* out_Pointer )\r
1253 {\r
1254         *(void**) out_Pointer = VariantListIteratorClass_getNext( Iterator );\r
1255 }\r
1256 \r
1257 \r
1258  \r
1259 /***********************************************************************\r
1260   <<< [PArray] >>> \r
1261 ************************************************************************/\r
1262 typedef  errnum_t (* CompareFuncType )( const void* ppLeft, const void* ppRight, const void* Param,\r
1263         int* out_Result );\r
1264 \r
1265 int  PArray_setFromArray( void* PointerArray, size_t PointerArraySize, void* out_ppRight,\r
1266         void* SrcArray, size_t SrcArraySize, size_t SrcArrayElemSize );\r
1267 \r
1268 \r
1269  \r
1270 errnum_t  PArray_doShakerSort( const void* PointerArray,  size_t PointerArraySize,\r
1271         const void* ppLeft,  const void* ppRight,  CompareFuncType Compare,  const void* Param );\r
1272 \r
1273 \r
1274  \r
1275 errnum_t  PArray_doBinarySearch( const void* PointerArray, size_t PointerArraySize,\r
1276         const void* Key, CompareFuncType Compare, const void* Param,\r
1277         int* out_FoundOrLeftIndex, int* out_CompareResult );\r
1278 \r
1279 \r
1280  \r
1281 /***********************************************************************\r
1282   <<< [DictionaryAA_Class] Dictionary using AA tree >>> \r
1283 ************************************************************************/\r
1284 typedef struct _DictionaryAA_Class      DictionaryAA_Class;\r
1285 typedef struct _DictionaryAA_NodeClass  DictionaryAA_NodeClass;\r
1286 \r
1287 struct _DictionaryAA_Class {\r
1288         DictionaryAA_NodeClass*  Root;\r
1289 };\r
1290 \r
1291 \r
1292 /*[DictionaryAA_TraverseFuncType]*/\r
1293 typedef errnum_t (* DictionaryAA_TraverseFuncType )(\r
1294         DictionaryAA_NodeClass* Node, void* UserParameter );\r
1295 \r
1296 void      DictionaryAA_Class_initConst( DictionaryAA_Class* self );\r
1297 errnum_t  DictionaryAA_Class_finalize( DictionaryAA_Class* self, errnum_t e );\r
1298 errnum_t  DictionaryAA_Class_finalize2( DictionaryAA_Class* self,  errnum_t  e,\r
1299         bool  in_IsFreeItem,  FinalizeFuncType  in_Type_Finalize );\r
1300 /*errnum_t  DictionaryAA_Class_freeAllKeysHeap( DictionaryAA_Class* self, errnum_t e );*/\r
1301 \r
1302 errnum_t  DictionaryAA_Class_insert( DictionaryAA_Class* self, const TCHAR* Key,\r
1303         DictionaryAA_NodeClass** out_Node );\r
1304 errnum_t  DictionaryAA_Class_remove( DictionaryAA_Class* self, const TCHAR* Key );\r
1305 errnum_t  DictionaryAA_Class_search( DictionaryAA_Class* self, const TCHAR* Key,\r
1306         DictionaryAA_NodeClass** out_Node );\r
1307 bool      DictionaryAA_Class_isExist( DictionaryAA_Class* self, const TCHAR* Key );\r
1308 errnum_t  DictionaryAA_Class_traverse( DictionaryAA_Class* self,\r
1309         DictionaryAA_TraverseFuncType  Function,  void*  UserParameter );\r
1310 errnum_t  DictionaryAA_Class_toEmpty( DictionaryAA_Class* self );\r
1311 errnum_t  DictionaryAA_Class_getArray( DictionaryAA_Class* self,\r
1312         TCHAR***  in_out_Strings,  int*  in_out_StringCount,  NewStringsEnum  in_HowToAllocate );\r
1313 errnum_t  DictionaryAA_Class_print( DictionaryAA_Class* self, FILE* OutputStream );\r
1314 \r
1315 \r
1316 /*[DictionaryAA_Class_forEach]*/\r
1317 #define  DictionaryAA_Class_forEach( in_out_Iterator, out_Node ) \\r
1318         *(out_Node) = DictionaryAA_IteratorClass_getNext( in_out_Iterator ); \\r
1319         *(out_Node) != NULL; \\r
1320         *(out_Node) = DictionaryAA_IteratorClass_getNext( in_out_Iterator )\r
1321 \r
1322 \r
1323  \r
1324 /***********************************************************************\r
1325   <<< [DictionaryAA_NodeClass] >>> \r
1326 ************************************************************************/\r
1327 struct _DictionaryAA_NodeClass {\r
1328         void*                    Item;  /* User defined */\r
1329 \r
1330         const TCHAR*             Key;   /* This is had by DictionaryAA_Class */\r
1331         int                      Height;\r
1332         DictionaryAA_NodeClass*  Left;\r
1333         DictionaryAA_NodeClass*  Right;\r
1334 };\r
1335 \r
1336 extern  DictionaryAA_NodeClass  g_DictionaryAA_NullNode;\r
1337 \r
1338 \r
1339  \r
1340 /***********************************************************************\r
1341   <<< [DictionaryAA_IteratorClass] >>> \r
1342 ************************************************************************/\r
1343 typedef struct _DictionaryAA_IteratorClass  DictionaryAA_IteratorClass;\r
1344 struct _DictionaryAA_IteratorClass {\r
1345         Set2 /*<DictionaryAA_NodeClass*>*/  Nodes;\r
1346         DictionaryAA_NodeClass**            NextNode;\r
1347 };\r
1348 \r
1349 void      DictionaryAA_IteratorClass_initConst( DictionaryAA_IteratorClass* self );\r
1350 errnum_t  DictionaryAA_IteratorClass_initialize( DictionaryAA_IteratorClass* self,\r
1351         DictionaryAA_Class* Collection );\r
1352 errnum_t  DictionaryAA_IteratorClass_finalize( DictionaryAA_IteratorClass* self, errnum_t e );\r
1353 \r
1354 DictionaryAA_NodeClass*  DictionaryAA_IteratorClass_getNext(\r
1355         DictionaryAA_IteratorClass* self );\r
1356 \r
1357 \r
1358 /*[DictionaryAA_IteratorClass_initConst]*/\r
1359 inline void  DictionaryAA_IteratorClass_initConst( DictionaryAA_IteratorClass* self )\r
1360 {\r
1361         Set2_initConst( &self->Nodes );\r
1362 }\r
1363 \r
1364 \r
1365 /*[DictionaryAA_IteratorClass_finalize]*/\r
1366 inline errnum_t  DictionaryAA_IteratorClass_finalize( DictionaryAA_IteratorClass* self, errnum_t e )\r
1367 {\r
1368         return  Set2_finish( &self->Nodes, e );\r
1369 }\r
1370 \r
1371 \r
1372  \r
1373 /*-------------------------------------------------------------------------*/\r
1374 /* <<<< ### (Set4) Class >>>> */ \r
1375 /*-------------------------------------------------------------------------*/\r
1376 \r
1377 \r
1378  \r
1379 /****************************************************************\r
1380   <<< [Set4_initConst] >>> \r
1381 *****************************************************************/\r
1382 #define  Set4_initConst( self ) \\r
1383         ( (self)->FirstBlock = NULL )\r
1384 \r
1385  \r
1386 /****************************************************************\r
1387   <<< [Set4_init] >>> \r
1388 *****************************************************************/\r
1389 #define  Set4_init( self, type, HeapSize ) \\r
1390         Set4_init_imp( self, sizeof(type), HeapSize )\r
1391 \r
1392 \r
1393  \r
1394 /****************************************************************\r
1395   <<< [Set4_finish] >>> \r
1396 *****************************************************************/\r
1397 #define  Set4_finish( self, e, type, in_Type_Finalize ) \\r
1398         ( (in_Type_Finalize) == NULL ?  Set4_finish2_imp2( self ), e : \\r
1399                 ( Set4_finish2_imp( self, e, sizeof(type), in_Type_Finalize ), Set4_finish2_imp2( self ), e ) )\r
1400 \r
1401 \r
1402  \r
1403 /****************************************************************\r
1404   <<< [Set4_allocate] >>> \r
1405 *****************************************************************/\r
1406 #define  Set4_allocate( self, out_ElementPointer ) \\r
1407         Set4_alloc_imp( self, out_ElementPointer, sizeof(**(out_ElementPointer)) )\r
1408 \r
1409 \r
1410  \r
1411 /****************************************************************\r
1412   <<< [Set4_alloc] >>> \r
1413 *****************************************************************/\r
1414 #if 0\r
1415 #define  Set4_alloc( self, pp, type ) \\r
1416         Set4_alloc_imp( self, pp, sizeof(type) )\r
1417 #endif\r
1418 \r
1419 \r
1420  \r
1421 /****************************************************************\r
1422   <<< [Set4_free] >>> \r
1423 *****************************************************************/\r
1424 #define  Set4_free( self, in_out_ElementPointer, e ) \\r
1425         Set4_free_imp( self, in_out_ElementPointer, sizeof(**(in_out_ElementPointer)), e )\r
1426 \r
1427 \r
1428  \r
1429 /****************************************************************\r
1430   <<< [Set4_toEmpty] >>> \r
1431 *****************************************************************/\r
1432 #define  Set4_toEmpty( self, type, type_finish ) \\r
1433         ( Set4_finish2( self, type, type_finish ), \\r
1434                 (self)->FirstBlock = NULL, \\r
1435                 (self)->Next = (self)->CurrentBlockOver = &(self)->FirstBlock )\r
1436 \r
1437 \r
1438  \r
1439 /****************************************************************\r
1440   <<< [Set4_ref] >>> \r
1441 *****************************************************************/\r
1442 #define  Set4_ref( self, i, type ) \\r
1443         ( (type*) Set4_ref_imp( self, i, sizeof(type) ) )\r
1444 \r
1445 \r
1446  \r
1447 /****************************************************************\r
1448   <<< [Set4_getCount] >>> \r
1449 *****************************************************************/\r
1450 #define Set4_getCount( self, type ) \\r
1451          Set4_getCount_imp( self, sizeof(type) )\r
1452 \r
1453 #if 0\r
1454 #define Set4_getN( self, type ) \\r
1455          Set4_getCount_imp( self, sizeof(type) )\r
1456 #endif\r
1457 \r
1458 \r
1459  \r
1460 /****************************************************************\r
1461   <<< [Set4_forEach] >>> \r
1462 *****************************************************************/\r
1463 #define  Set4_forEach( self, iter, ptr ) \\r
1464         (iter)->p = NULL, Set4_forEach_imp2( self, iter, sizeof(**(ptr)) ); \\r
1465         *(void**)(ptr) = (iter)->p, (iter)->p != NULL; \\r
1466         Set4_forEach_imp2( self, iter, sizeof(**(ptr)) )\r
1467 \r
1468 #if 0\r
1469 #define  Set4_forEach( self, iter, ptr, type ) \\r
1470         (iter)->p = NULL, Set4_forEach_imp2( self, iter, sizeof(type) ); \\r
1471         *(ptr) = (type*)(iter)->p, (iter)->p != NULL; \\r
1472         Set4_forEach_imp2( self, iter, sizeof(type) )\r
1473 #endif\r
1474 \r
1475 #define  Set4_forEach_imp( self, ptr, size ) \\r
1476         (ptr)->p = NULL, Set4_forEach_imp2( self, ptr, size ); \\r
1477         (ptr)->p != NULL; \\r
1478         Set4_forEach_imp2( self, ptr, size )\r
1479 \r
1480 \r
1481  \r
1482 /****************************************************************\r
1483   <<< [Set4Iter_init] >>> \r
1484 *****************************************************************/\r
1485 #define  Set4Iter_init( self, Set, pptr, type ) \\r
1486         ( (self)->p = NULL, Set4_forEach_imp2( Set, self, sizeof(type) ), \\r
1487                 *(pptr) = (type*)((self)->p), ( (self)->p == NULL ? E_NO_NEXT : 0 ) )\r
1488 \r
1489 \r
1490  \r
1491 /****************************************************************\r
1492   <<< [Set4Iter_next] >>> \r
1493 *****************************************************************/\r
1494 #define  Set4Iter_next( self, Set, pptr, type ) \\r
1495         ( Set4_forEach_imp2( Set, self, sizeof(type) ), \\r
1496                 *(pptr) = (type*)((self)->p), ( (self)->p == NULL ? E_NO_NEXT : 0 ) )\r
1497 \r
1498 \r
1499  \r
1500 #ifdef  __cplusplus\r
1501  }  /* End of C Symbol */ \r
1502 #endif\r
1503 #endif\r
1504  \r
1505 /*=================================================================*/\r
1506 /* <<< [DebugTools/DebugTools.h] >>> */ \r
1507 /*=================================================================*/\r
1508  \r
1509 #if  __cplusplus\r
1510  extern "C" {  /* Start of C Symbol */ \r
1511 #endif\r
1512 \r
1513 \r
1514 #ifndef NDEBUG\r
1515         #define  NDEBUG_ERROR\r
1516 #else\r
1517         #define  NDEBUG_ERROR  ___cut_NDEBUG_ERROR\r
1518 #endif\r
1519 \r
1520  \r
1521 /**************************************************************************\r
1522   <<< [DebugTools] >>> \r
1523 ***************************************************************************/\r
1524 #ifndef  NDEBUG\r
1525         #define  DEBUGTOOLS_USES  1\r
1526 #else\r
1527         #define  DEBUGTOOLS_USES  0\r
1528 #endif\r
1529 \r
1530 \r
1531 #if  DEBUGTOOLS_USES\r
1532 typedef struct _DebugTools  DebugTools;\r
1533 struct _DebugTools {\r
1534         int     m_BreakID;\r
1535         int     m_DisableBreakExceptID_plus1;\r
1536         int     m_ReturnValueOnBreak_minus1;\r
1537         TCHAR*  m_BreakByFName;\r
1538 };\r
1539 int  Debug_setReturnValueOnBreak( int ID );\r
1540 int  Debug_disableBreak( int iExceptID );\r
1541 int  Debug_setBreakByFName( const TCHAR* Path );\r
1542 int  Debug_onOpen( const TCHAR* Path );\r
1543 #endif\r
1544 \r
1545  \r
1546 /***********************************************************************\r
1547   <<< [HeapLogClass] >>> \r
1548 ************************************************************************/\r
1549 void  HeapLogClass_log( void*  in_Address,  size_t  in_Size );\r
1550 int   HeapLogClass_getID( const void*  in_Address );\r
1551 void  HeapLogClass_printID( const void*  in_Address );\r
1552 void  HeapLogClass_addWatch( int  in_IndexNum,  int  in_AllocatedID,  ptrdiff_t  in_Offset,\r
1553         uint32_t  in_BreakValue,  bool  in_IsPrintf );\r
1554 void  HeapLogClass_watch( int  in_IndexNum );\r
1555 void* HeapLogClass_getWatchingAddress( int  in_IndexNum );\r
1556 void  HeapLogClass_finalize(void);\r
1557 \r
1558 enum { HeapLogClass_NotAllocatedID = -1 };\r
1559 \r
1560 \r
1561  \r
1562 /**************************************************************************\r
1563  <<< [g_DebugVar] >>> \r
1564 ***************************************************************************/\r
1565 extern int  g_DebugVar[10];\r
1566 \r
1567 \r
1568  \r
1569 /*[dll_global_g_DebugBreakCount]*/\r
1570 #ifndef  dll_global_g_DebugBreakCount\r
1571         #define  dll_global_g_DebugBreakCount\r
1572 #endif\r
1573  \r
1574 /***********************************************************************\r
1575   <<< [TestableDebugBreak] >>> \r
1576 ************************************************************************/\r
1577 #define  TestableDebugBreak()  ( TestableDebugBreak_Sub() ? (DebugBreakR(),0) : 0 )\r
1578 int      TestableDebugBreak_Sub(void);\r
1579 \r
1580 void     SetTestableDebugBreak( bool IsEnableBreak );\r
1581 int      GetDebugBreakCount(void);\r
1582 \r
1583 \r
1584  \r
1585 #if  __cplusplus\r
1586  }  /* End of C Symbol */ \r
1587 #endif\r
1588 \r
1589 \r
1590  \r
1591 /*=================================================================*/\r
1592 /* <<< [StrT/StrT.h] >>> */ \r
1593 /*=================================================================*/\r
1594  \r
1595 #if  __cplusplus\r
1596  extern "C" {  /* Start of C Symbol */ \r
1597 #endif\r
1598 \r
1599 errnum_t  StrT_cpy( TCHAR* Dst, size_t DstSize, const TCHAR* Src );\r
1600 errnum_t  StrT_cat( TCHAR* Dst, size_t DstSize, const TCHAR* Src );\r
1601 TCHAR*  StrT_chr( const TCHAR* String, TCHAR Key );\r
1602 TCHAR*  StrT_chrs( const TCHAR* s, const TCHAR* keys );\r
1603 TCHAR*  StrT_rstr( const TCHAR* String, const TCHAR* SearchStart, const TCHAR* Keyword,\r
1604         void* NullConfig );\r
1605 TCHAR*  StrT_chrNext( const TCHAR* in_Start, TCHAR in_KeyCharactor );\r
1606 TCHAR*  StrT_skip( const TCHAR* s, const TCHAR* keys );\r
1607 TCHAR*  StrT_rskip( const TCHAR* String, const TCHAR* SearchStart, const TCHAR* Keys,\r
1608         void* NullConfig );\r
1609 bool    StrT_isCIdentifier( TCHAR Character );\r
1610 TCHAR*  StrT_searchOverOfCIdentifier( const TCHAR* Text );\r
1611 TCHAR*  StrT_searchOverOfIdiom( const TCHAR* Text );\r
1612 int  StrT_cmp_part( const TCHAR* StringA_Start, const TCHAR* StringA_Over,\r
1613         const TCHAR* StringB );\r
1614 int  StrT_cmp_i_part( const TCHAR* StringA_Start, const TCHAR* StringA_Over,\r
1615         const TCHAR* StringB );\r
1616 int  StrT_cmp_part2( const TCHAR* StringA_Start, const TCHAR* StringA_Over,\r
1617         const TCHAR* StringB_Start, const TCHAR* StringB_Over );\r
1618 #define  TwoChar8( Character1, Character2 ) \\r
1619         ( (Character1) + ( (Character2) << 8 ) )\r
1620 #define  FourChar8( Character1, Character2, Character3, Character4 ) \\r
1621         ( (Character1) + ( (Character2) << 8 ) + ( (Character3) << 16 ) + ( (Character4) << 24 ) )\r
1622 \r
1623 inline errnum_t  StrT_cat( TCHAR* Dst, size_t DstSize, const TCHAR* Src )\r
1624 {\r
1625         return  stcpy_part_r( Dst, DstSize, _tcschr( Dst, _T('\0') ), NULL, Src, NULL );\r
1626 }\r
1627 \r
1628 \r
1629  \r
1630 int  StrT_searchPartStringIndex( const TCHAR* in_String, const TCHAR* in_StringOver,\r
1631         const TCHAR** in_StringsArray,  uint_fast32_t in_StringsArrayLength,\r
1632         int in_DefaultIndex );\r
1633  \r
1634 int  StrT_searchPartStringIndexI( const TCHAR* in_String, const TCHAR* in_StringOver,\r
1635         const TCHAR** in_StringsArray,  uint_fast32_t in_StringsArrayLength,\r
1636         int in_DefaultIndex );\r
1637  \r
1638 errnum_t  StrT_convStrToId( const TCHAR* str, const TCHAR** strs, const int* ids, int n, int default_id ); \r
1639 errnum_t  StrT_convStrLeftToId( const TCHAR* Str, const TCHAR** Strs, const size_t* Lens, const int* Ids,\r
1640                            int CountOfStrs, TCHAR* Separeters, int DefaultId, TCHAR** out_PosOfLastOfStr );\r
1641 void*  StrT_convPartStrToPointer( const TCHAR* StringStart, const TCHAR* StringOver,\r
1642         const NameOnlyClass* Table, size_t TableSize, void* Default );\r
1643 TCHAR*  StrT_convertNumToStr( int Number, const NameAndNumClass* Table, int TableCount,\r
1644         const TCHAR* DefaultStr );\r
1645  \r
1646 //[GetStringSizeFromPointer]\r
1647 inline size_t  GetStringSizeFromPointer( void* String, size_t StringSize, void* Pointer )\r
1648 {\r
1649         return  (uintptr_t) String + StringSize - (uintptr_t) Pointer;\r
1650 }\r
1651 \r
1652  \r
1653 /***********************************************************************\r
1654   <<< [StrT_Malloc] >>> \r
1655 ************************************************************************/\r
1656 errnum_t  MallocAndCopyString( const TCHAR** out_NewString, const TCHAR* SourceString );\r
1657 errnum_t  MallocAndCopyString_char( const TCHAR** out_NewString, const char* SourceString );\r
1658 errnum_t  MallocAndCopyStringByLength( const TCHAR** out_NewString, const TCHAR* SourceString,\r
1659         unsigned CountOfCharacter );\r
1660 \r
1661 #ifndef _UNICODE\r
1662         #define  MallocAndCopyString_char  MallocAndCopyString\r
1663 #endif\r
1664 \r
1665 errnum_t  StrHS_insert( TCHAR**  in_out_WholeString,\r
1666         int  in_TargetIndexInWholeString,  int*  out_NextWholeInWholeString,\r
1667         const TCHAR*  in_InsertString );\r
1668 errnum_t  StrHS_printf( TCHAR**  in_out_String,  const TCHAR*  in_Format,  ... );\r
1669 errnum_t  StrHS_printfV( TCHAR**  in_out_String,  const TCHAR*  in_Format,  va_list  in_VaList );\r
1670 errnum_t  StrHS_printfPart( TCHAR**  in_out_String,\r
1671         int  in_IndexInString,  int*  out_NextIndexInString,\r
1672         const TCHAR*  in_Format,  ... );\r
1673 errnum_t  StrHS_printfPartV( TCHAR**  in_out_String,\r
1674         int  in_IndexInString,  int*  out_NextIndexInString,\r
1675         const TCHAR*  in_Format,  va_list  in_VaList );\r
1676 \r
1677 \r
1678  \r
1679 /***********************************************************************\r
1680   <<< [StrT_Edit] >>> \r
1681 ************************************************************************/\r
1682 errnum_t  StrT_cutPart( TCHAR*  in_out_String,  TCHAR*  in_StartOfCut,  TCHAR*  in_OverOfCut );\r
1683 errnum_t  StrT_trim( TCHAR* out_Str, size_t out_Str_Size, const TCHAR* in_Str );\r
1684 errnum_t  StrT_cutLastOf( TCHAR* in_out_Str, TCHAR Charactor );\r
1685 errnum_t  StrT_cutLineComment( TCHAR* out_Str, size_t out_Str_Size, const TCHAR* in_Str, const TCHAR* CommentSign );\r
1686 errnum_t  StrT_insert( TCHAR*  in_out_WholeString,  size_t  in_MaxSize_of_WholeString,\r
1687         TCHAR*  in_out_Target_in_WholeString,  TCHAR**  out_NextTarget_in_WholeString,\r
1688         const TCHAR*  in_InsertString );\r
1689 errnum_t  StrT_meltCmdLine( TCHAR* out_Str, size_t out_Str_Size, const TCHAR** pLine );\r
1690 errnum_t  StrT_getExistSymbols( unsigned* out, bool bCase, const TCHAR* Str, const TCHAR* Symbols, ... );\r
1691 errnum_t  StrT_replace1( TCHAR* in_out_String, TCHAR FromCharacter, TCHAR ToCharacter,\r
1692         unsigned Opt );\r
1693 \r
1694 \r
1695  \r
1696 /***********************************************************************\r
1697   <<< [StrT_Edit2] >>> \r
1698 ************************************************************************/\r
1699 errnum_t  StrT_replace( TCHAR* Out, size_t OutSize, const TCHAR* In,\r
1700                    const TCHAR* FromStr, const TCHAR* ToStr, unsigned Opt );\r
1701 errnum_t  StrT_changeToXML_Attribute( TCHAR* out_Str, size_t StrSize, const TCHAR* InputStr );\r
1702 errnum_t  StrT_resumeFromXML_Attribute( TCHAR* out_Str, size_t out_Str_Size, const TCHAR* XML_Attr );\r
1703 errnum_t  StrT_changeToXML_Text( TCHAR* out_Str, size_t StrSize, const TCHAR* InputStr );\r
1704 \r
1705 enum { STR_1TIME = 1 };\r
1706 \r
1707 \r
1708  \r
1709 /***********************************************************************\r
1710   <<< [W3CDTF] >>> \r
1711 ************************************************************************/\r
1712 enum { W3CDTF_MAX_LENGTH = 27+3 };  /* \8f¬\90\943\8c\85 */\r
1713 enum { W3CDTF_CURRENT_TIME_ZONE = 9999 };\r
1714 \r
1715 errnum_t  W3CDTF_fromSYSTEMTIME( TCHAR* out_W3CDTF, size_t W3CDTF_ByteSize,\r
1716         const SYSTEMTIME* Time, int TimeZoneMinute );\r
1717 errnum_t  W3CDTF_toSYSTEMTIME( const TCHAR* String, SYSTEMTIME* out_Time, int* out_BiasMinute );\r
1718 errnum_t  W3CDTF_getTimeZoneDesignator( TCHAR* out_TZD, size_t TZD_ByteSize,\r
1719         int  BiasMinute );\r
1720 \r
1721 \r
1722  \r
1723 /***********************************************************************\r
1724   <<< [StrT_Path] >>> \r
1725 ************************************************************************/\r
1726 enum { StrT_LocalPathMaxSize = 4096 };\r
1727 enum { MAX_LOCAL_PATH = 4096 };\r
1728 TCHAR*  StrT_refFName( const TCHAR* s );\r
1729 TCHAR*  StrT_refExt( const TCHAR* s );\r
1730 void  StrT_cutFragmentInPath( TCHAR* in_out_Path );\r
1731 bool  StrT_isFullPath( const TCHAR* s );\r
1732 \r
1733 errnum_t  StrT_getFullPath_part( TCHAR* Str, size_t StrSize, TCHAR* StrStart,\r
1734         TCHAR** out_StrLast, const TCHAR* StepPath, const TCHAR* BasePath );\r
1735 errnum_t  StrT_allocateFullPath( TCHAR** out_FullPath, const TCHAR* StepPath, TCHAR* BasePath );\r
1736 errnum_t  StrT_getStepPath( TCHAR* out_StepPath, size_t StepPathSize,\r
1737         const TCHAR* FullPath, const TCHAR* BasePath );\r
1738 errnum_t  StrT_getParentFullPath_part( TCHAR* Str, size_t StrSize, TCHAR* StrStart,\r
1739         TCHAR** out_StrLast, const TCHAR* StepPath, const TCHAR* BasePath );\r
1740 errnum_t  StrT_getBaseName_part( TCHAR* Str, size_t StrSize, TCHAR* StrStart,\r
1741         TCHAR** out_StrLast, const TCHAR* SrcPath );\r
1742 errnum_t  StrT_addLastOfFileName( TCHAR* out_Path, size_t PathSize,\r
1743                              const TCHAR* BasePath, const TCHAR* AddName );\r
1744 errnum_t  StrT_encodeToValidPath( TCHAR* out_Path,  size_t in_OutPathSize,  const TCHAR* in_Path,  bool  in_IsName );\r
1745 \r
1746 inline errnum_t  StrT_getFullPath( TCHAR* out_FullPath, size_t FullPathSize,\r
1747         const TCHAR* StepPath, const TCHAR* BasePath )\r
1748 {\r
1749         return  StrT_getFullPath_part( out_FullPath, FullPathSize, out_FullPath,\r
1750                 NULL, StepPath, BasePath );\r
1751 }\r
1752 \r
1753 inline errnum_t  StrT_getParentFullPath( TCHAR* Str, size_t StrSize,\r
1754         const TCHAR* SrcPath, const TCHAR* BasePath )\r
1755 {\r
1756         return StrT_getParentFullPath_part( Str, StrSize, Str, NULL, SrcPath, BasePath );\r
1757 }\r
1758 \r
1759 inline errnum_t  StrT_getBaseName( TCHAR* Str, size_t StrSize, const TCHAR* SrcPath )\r
1760 {\r
1761         return  StrT_getBaseName_part( Str, StrSize, Str, NULL, SrcPath );\r
1762 }\r
1763 \r
1764 \r
1765  \r
1766 /**************************************************************************\r
1767   <<< [Strs] >>> \r
1768 ***************************************************************************/\r
1769 typedef  struct _Strs  Strs;\r
1770 struct _Strs {\r
1771         byte_t*  MemoryAddress;   /* first memory = [ TCHAR* FirstStr | elem[] ],  other memory = [ elem[] ] */\r
1772         byte_t*  MemoryOver;\r
1773         byte_t*  NextElem;        /* elem = [ TCHAR* NextStr | TCHAR[] ] */\r
1774         TCHAR**  PointerToNextStrInPrevElem;  /* first = &FirstStr,  other = &NextStr */\r
1775         TCHAR**  Prev_PointerToNextStrInPrevElem;\r
1776 \r
1777         Strs*   FirstOfStrs;\r
1778         Strs*   NextStrs;\r
1779 };\r
1780 \r
1781 void Strs_initConst( Strs* m );\r
1782 errnum_t  Strs_init( Strs* m );\r
1783 errnum_t  Strs_finish( Strs* m, errnum_t e );\r
1784 errnum_t  Strs_toEmpty( Strs* m );\r
1785 bool Strs_isInited( Strs* m );\r
1786 errnum_t  Strs_add( Strs* m, const TCHAR* Str, const TCHAR** out_pAlloc );\r
1787 errnum_t  Strs_addBinary( Strs* m, const TCHAR* Str, const TCHAR* StrOver, const TCHAR** out_AllocStr );\r
1788 errnum_t  Strs_freeLast( Strs* m, TCHAR* AllocStr );\r
1789 errnum_t  Strs_toEmpty( Strs* m );\r
1790 /* for ( Strs_forEach( Strs* m, TCHAR** in_out_Str ) ); */\r
1791 TCHAR*  Strx_getFirst( Strs* m );\r
1792 TCHAR*  Strx_getNext( Strs* m, TCHAR* Str );\r
1793 \r
1794 \r
1795 #define  Strs_initConst( m )  ( (m)->MemoryAddress =  NULL )\r
1796 #define  Strs_isInited( m )    ( (m)->MemoryAddress != NULL )\r
1797 \r
1798 #define  Strs_forEach( m, pStr ) \\r
1799         *(pStr) = Strs_getFirst( m ); \\r
1800         *(pStr) != NULL; \\r
1801         *(pStr) = Strs_getNext( m, *(pStr) )\r
1802 \r
1803 #define  Strs_getFirst( m ) \\r
1804         ( *(TCHAR**) (m)->FirstOfStrs->MemoryAddress )\r
1805 \r
1806 #define  Strs_getNext( m, p ) \\r
1807         ( *( (TCHAR**)(p) - 1 ) )\r
1808 \r
1809 #define  Strs_getFreeAddr( m )  ( (TCHAR*)( (m)->NextElem + sizeof(TCHAR*) ) )\r
1810 #define  Strs_getFreeSize( m )  ( (m)->MemoryOver - (byte_t*)(m)->NextElem - sizeof(TCHAR*) )\r
1811 #define  Strs_getFreeCount( m ) ( Strs_getFreeSize( m ) / sizeof(TCHAR) )\r
1812 #define  Strs_expandCount( m, c )  ( Strs_expandSize( (m), (c) * sizeof(TCHAR) ) )\r
1813 errnum_t  Strs_expandSize( Strs* m, size_t FreeSize );\r
1814 errnum_t  Strs_commit( Strs* m, TCHAR* StrOver );\r
1815 errnum_t  Strs_allocateArray( Strs* self,  TCHAR*** out_PointerArray,  int* out_Count );\r
1816 \r
1817 \r
1818  \r
1819 /***********************************************************************\r
1820   <<< [StrArr] >>> \r
1821 ************************************************************************/\r
1822 typedef struct _StrArr  StrArr;\r
1823 struct _StrArr {\r
1824         Set2  Array;  // array of TCHAR*\r
1825         Strs  Chars;\r
1826 };\r
1827 \r
1828 errnum_t  StrArr_init( StrArr* m );\r
1829 errnum_t  StrArr_finish( StrArr* m, errnum_t e );\r
1830 \r
1831 errnum_t  StrArr_add( StrArr* m, const TCHAR* Str, int* out_I );\r
1832 errnum_t  StrArr_commit( StrArr* m );\r
1833 errnum_t  StrArr_fillTo( StrArr* m, int n, const TCHAR* Str );\r
1834 errnum_t  StrArr_toEmpty( StrArr* m );\r
1835 \r
1836 #define  StrArr_initConst( m )   Set2_initConst( &(m)->Array )\r
1837 #define  StrArr_getFreeAddr( m )  Strs_getFreeAddr( &(m)->Chars )\r
1838 #define  StrArr_getFreeSize( m )  Strs_getFreeSize( &(m)->Chars )\r
1839 #define  StrArr_getFreeCount( m ) Strs_getFreeCount( &(m)->Chars )\r
1840 #define  StrArr_expandSize( m, sz )  Strs_expandSize( &(m)->Chars, sz )\r
1841 #define  StrArr_expandCount( m, c )  Strs_expandCount( &(m)->Chars, c )\r
1842 #define  StrArr_getArray( m )     ((TCHAR**)(m)->Array.First)\r
1843 //#define  StrArr_getN( m )          Set2_getCount( &(m)->Array, TCHAR* )\r
1844 #define  StrArr_getCount( m )        Set2_getCount( &(m)->Array, TCHAR* )\r
1845 \r
1846 \r
1847  \r
1848 /***********************************************************************\r
1849   <<< [StrArr_forEach] >>> \r
1850 ************************************************************************/\r
1851 #define  StrArr_forEach( self, Iterator, out_String ) \\r
1852         StrArr_forEach_1( self, Iterator, out_String ); \\r
1853         StrArr_forEach_2( Iterator ); \\r
1854         StrArr_forEach_3( Iterator, out_String )\r
1855 \r
1856 /*[StrArrIterator]*/\r
1857 typedef struct _StrArrIterator  StrArrIterator;\r
1858 struct _StrArrIterator {\r
1859         const TCHAR**  Pointer;\r
1860         const TCHAR**  PointerOver;\r
1861 };\r
1862 \r
1863 inline void  StrArr_forEach_1( StrArr* self, StrArrIterator* Iterator, const TCHAR** out_String )\r
1864 {\r
1865         Iterator->Pointer = (const TCHAR**) self->Array.First;\r
1866         Iterator->PointerOver = (const TCHAR**) self->Array.Next;\r
1867         *out_String = *Iterator->Pointer;\r
1868 }\r
1869 \r
1870 inline bool  StrArr_forEach_2( StrArrIterator* Iterator )\r
1871 {\r
1872         return  Iterator->Pointer < Iterator->PointerOver;\r
1873 }\r
1874 \r
1875 inline void  StrArr_forEach_3( StrArrIterator* Iterator, const TCHAR** out_String )\r
1876 {\r
1877         Iterator->Pointer += 1;\r
1878         *out_String = *Iterator->Pointer;\r
1879 }\r
1880 \r
1881 \r
1882  \r
1883 /***********************************************************************\r
1884   <<< [CSV] >>> \r
1885 ************************************************************************/\r
1886 errnum_t  StrT_meltCSV( TCHAR* out_Str, size_t out_Str_Size, const TCHAR** pCSV );\r
1887 errnum_t  StrArr_parseCSV( StrArr* m, const TCHAR* CSVLine );\r
1888 errnum_t  StrT_parseCSV_f( const TCHAR* StringOfCSV, bit_flags32_t* out_ReadFlags, const TCHAR* Types, ... );\r
1889 \r
1890 \r
1891  \r
1892 /***********************************************************************\r
1893   <<< [StrFile] Read Class >>> \r
1894 ************************************************************************/\r
1895  \r
1896 typedef struct _StrFile  StrFile;\r
1897 struct _StrFile {\r
1898         void*   Buffer;\r
1899         size_t  BufferSize;\r
1900         bool    IsBufferInHeap;\r
1901         bool    IsTextMode;\r
1902         int     OffsetToHeapBlockFirst;\r
1903         int     CharSize;\r
1904         void*   Pointer;  // (void*)0xFFFFFFFF = EOF\r
1905 };\r
1906 \r
1907 #define   StrFile   StrFile_BlackBox\r
1908  \r
1909 typedef struct _StrFile_BlackBox  StrFile;\r
1910 struct _StrFile_BlackBox {\r
1911         uint8_t  BlackBox[24];\r
1912 };\r
1913  \r
1914 #undef   StrFile\r
1915 static_assert_global( sizeof(StrFile) == sizeof(StrFile_BlackBox), "" );\r
1916  \r
1917 enum {\r
1918         STR_FILE_READ = 0,\r
1919 \r
1920         STR_FILE_CHAR  = 0x00,\r
1921         STR_FILE_WCHAR = 0x10,\r
1922 #ifdef _UNICODE\r
1923         STR_FILE_TCHAR = 0x10,\r
1924 #else\r
1925         STR_FILE_TCHAR = 0x00,\r
1926 #endif\r
1927 \r
1928         STR_FILE_TEXT   = 0x00,\r
1929         STR_FILE_BINARY = 0x01,\r
1930 };\r
1931 \r
1932 void      StrFile_initConst( StrFile* self );\r
1933 errnum_t  StrFile_init_fromStr( StrFile* self, TCHAR* LinkStr );\r
1934 errnum_t  StrFile_init_fromSizedStructInStream( StrFile* self, HANDLE* Stream );\r
1935 errnum_t  StrFile_init_withBuf( StrFile* self, void* LinkBuffer, size_t LinkBufferSize, int Flags );\r
1936 errnum_t  StrFile_finish( StrFile* self, errnum_t e );\r
1937 errnum_t  StrFile_isInited( StrFile* self );\r
1938 \r
1939 errnum_t  StrFile_readLine( StrFile* self, TCHAR* out_Line, size_t LineSize );\r
1940 bool      StrFile_isAtEndOfStream( StrFile* self );\r
1941 \r
1942 \r
1943  \r
1944 /***********************************************************************\r
1945   <<< [StrFile] Write Class >>> \r
1946 ************************************************************************/\r
1947 \r
1948 errnum_t  StrFile_init_toHeap( StrFile* self, int Flags );\r
1949 errnum_t  StrFile_write( StrFile* self, const TCHAR* Text );\r
1950 errnum_t  StrFile_writeBinary( StrFile* self, const void* Data, size_t DataSize );\r
1951 errnum_t  StrFile_expandIfOver( StrFile* self, size_t DataSize );\r
1952 errnum_t  StrFile_peekWrittenString( StrFile* self, TCHAR** out_String );\r
1953 errnum_t  StrFile_peekWrittenStringW( StrFile* self, wchar_t** out_String );\r
1954 errnum_t  StrFile_peekWrittenStringA( StrFile* self, char** out_String );\r
1955 errnum_t  StrFile_pickupSizedStruct( StrFile* m, SizedStruct** out_Struct );\r
1956 errnum_t  StrFile_moveSizedStructToStream( StrFile* self, HANDLE Stream );\r
1957 errnum_t  StrFile_setPointer( StrFile* self, int OffsetOfPointer );\r
1958 errnum_t  StrFile_getPointer( StrFile* self, int* out_OffsetOfPointer );\r
1959 \r
1960 \r
1961 #ifdef _UNICODE\r
1962 #define  StrFile_peekWrittenString  StrFile_peekWrittenStringW\r
1963 #else\r
1964 #define  StrFile_peekWrittenString  StrFile_peekWrittenStringA\r
1965 #endif\r
1966 \r
1967 \r
1968  \r
1969 /***********************************************************************\r
1970   <<< [SearchStringByBM_Class] >>> \r
1971 ************************************************************************/\r
1972 typedef struct _SearchStringByBM_Class  SearchStringByBM_Class;\r
1973 struct _SearchStringByBM_Class {\r
1974         const TCHAR*  TextString;\r
1975         int           TextStringLength;\r
1976         const TCHAR*  Keyword;\r
1977         int           KeywordLastIndex;\r
1978         int           KeywordLastPosition;  /* Index of TextString */\r
1979         int*          SkipArray;\r
1980         TCHAR         SkipArray_MinCharacter;\r
1981         TCHAR         SkipArray_MaxCharacter;\r
1982 };\r
1983 \r
1984 void      SearchStringByBM_Class_initConst( SearchStringByBM_Class* self );\r
1985 errnum_t  SearchStringByBM_Class_initialize( SearchStringByBM_Class* self,\r
1986         const TCHAR* TextString,  const TCHAR* Keyword );\r
1987 errnum_t  SearchStringByBM_Class_initializeFromPart( SearchStringByBM_Class* self,\r
1988         const TCHAR* TextString,  size_t TextString_Length,  const TCHAR* Keyword );\r
1989 errnum_t  SearchStringByBM_Class_finalize( SearchStringByBM_Class* self, errnum_t e );\r
1990 errnum_t  SearchStringByBM_Class_search( SearchStringByBM_Class* self, int* out_KeywordIndex );\r
1991 \r
1992 \r
1993 enum { SearchString_NotFound = -1 };  /*[SearchString_NotFound]*/\r
1994 \r
1995 \r
1996  \r
1997 /***********************************************************************\r
1998   <<< [SearchStringByAC_Class] >>> \r
1999 ************************************************************************/\r
2000 enum { SearchStringByAC_Fail = 0 };                   /*[SearchStringByAC_Fail]*/\r
2001 enum { SearchStringByAC_RootState = 0 };              /*[SearchStringByAC_RootState]*/\r
2002 #if 0\r
2003 enum { SearchStringByAC_MaxCharacterCode = 0xFFFF };  /*[SearchStringByAC_MaxCharacterCode]*/\r
2004 #else\r
2005 enum { SearchStringByAC_MaxCharacterCode = 0xFF };  /*[SearchStringByAC_MaxCharacterCode]*/\r
2006 #endif\r
2007 typedef int16_t (* AC_GotoFunctionType )[ SearchStringByAC_MaxCharacterCode + 1 ];\r
2008         /* Array of next_state[state][character] */\r
2009 \r
2010 typedef struct _SearchStringByAC_Class  SearchStringByAC_Class;\r
2011 struct _SearchStringByAC_Class {\r
2012         int            StateNum;\r
2013         const TCHAR*   TextString;\r
2014         unsigned       TextStringLength;\r
2015         int            TextStringIndex;\r
2016         const TCHAR**  FoundKeywords;\r
2017         int            FoundKeywordsCount;\r
2018         int            FoundKeywordIndex;\r
2019 \r
2020         Set2            GoToFunction;  /* <AC_GotoFunctionType> Next state[ state ][ character ] */\r
2021         int*            FailureFunction;    /* Next state[ state ] */\r
2022         const TCHAR***  OutputFunction;     /* TCHAR*  OutputFunction.Keyword[ state ][ count ] */\r
2023         int*            OutputCount;        /* int     OutputFunction.Count[ state ] */\r
2024         int16_t         StateCount;         /* newstate + 1 */\r
2025 };\r
2026 \r
2027 void      SearchStringByAC_Class_initConst( SearchStringByAC_Class* self );\r
2028 errnum_t  SearchStringByAC_Class_initialize( SearchStringByAC_Class* self,\r
2029         const TCHAR* TextString, const TCHAR** KeywordArray, size_t KeywordArrayCount );\r
2030 errnum_t  SearchStringByAC_Class_initializeFromPart( SearchStringByAC_Class* self,\r
2031         const TCHAR* TextString,  size_t TextString_Length,\r
2032         const TCHAR** KeywordArray,  size_t KeywordArrayCount );\r
2033 errnum_t  SearchStringByAC_Class_finalize( SearchStringByAC_Class* self, errnum_t e );\r
2034 errnum_t  SearchStringByAC_Class_search( SearchStringByAC_Class* self,\r
2035         int* out_TextStringIndex, TCHAR** out_Keyword );\r
2036 errnum_t  SearchStringByAC_Class_setTextString( SearchStringByAC_Class* self,\r
2037         const TCHAR* TextString );\r
2038 errnum_t  SearchStringByAC_Class_setTextStringFromPart( SearchStringByAC_Class* self,\r
2039         const TCHAR* TextString,  size_t TextString_Length );\r
2040 inline  const TCHAR*  SearchStringByAC_Class_getTextString( SearchStringByAC_Class* self )\r
2041         { return  self->TextString; }\r
2042 \r
2043 \r
2044  \r
2045 #if  __cplusplus\r
2046  }  /* End of C Symbol */ \r
2047 #endif\r
2048 \r
2049  \r
2050 /*=================================================================*/\r
2051 /* <<< [CRT_plus_2/CRT_plus_2.h] >>> */ \r
2052 /*=================================================================*/\r
2053  \r
2054 /***********************************************************************\r
2055   <<< [HeapMemory_allocate] >>> \r
2056   <<< [HeapMemory_allocateArray] >>> \r
2057 ************************************************************************/\r
2058 \r
2059 #define  HeapMemory_allocate( out_Pointer ) \\r
2060     HeapMemory_allocateBytes( out_Pointer, sizeof( **(out_Pointer) ) )\r
2061 \r
2062 #define  HeapMemory_allocateArray( out_Pointer, Count ) \\r
2063     HeapMemory_allocateBytes( out_Pointer, sizeof( **(out_Pointer) ) * (Count) )\r
2064 \r
2065 inline errnum_t  HeapMemory_allocateBytes( void* out_Pointer, size_t MemorySize )\r
2066 {\r
2067         void**  out = (void**) out_Pointer;\r
2068 \r
2069         *out = malloc( MemorySize );\r
2070 \r
2071         if ( *out == NULL )\r
2072                 { return  E_FEW_MEMORY; }\r
2073         else\r
2074                 { return  0; }\r
2075 }\r
2076 \r
2077 \r
2078 /*[MallocMemory]*/\r
2079 inline errnum_t  MallocMemory( void* out_MemoryAddress, size_t MemorySize )\r
2080 {\r
2081         return  HeapMemory_allocateBytes( out_MemoryAddress, MemorySize );\r
2082 }\r
2083 \r
2084 \r
2085  \r
2086 /***********************************************************************\r
2087   <<< [HeapMemory_free] >>> \r
2088 ************************************************************************/\r
2089 inline errnum_t  HeapMemory_free( const void* in_out_MemoryAddress, errnum_t e )\r
2090 {\r
2091         void*  address = *(void**) in_out_MemoryAddress;\r
2092 \r
2093         if ( address != NULL )\r
2094                 { free( address ); }\r
2095 \r
2096         *(void**) in_out_MemoryAddress = NULL;\r
2097 \r
2098         return  e;\r
2099 }\r
2100 \r
2101 \r
2102 /*[FreeMemory]*/\r
2103 inline errnum_t  FreeMemory( const void* in_out_MemoryAddress, errnum_t e )\r
2104 {\r
2105         return  HeapMemory_free( in_out_MemoryAddress, e );\r
2106 }\r
2107 \r
2108 \r
2109  \r
2110 /**************************************************************************\r
2111  <<< [Interface] >>> \r
2112 ***************************************************************************/\r
2113 typedef struct _VTableDefine  VTableDefine;  /*[VTableDefine]*/\r
2114 struct _VTableDefine {\r
2115   int    m_IMethod;\r
2116   void*  m_method;\r
2117 };\r
2118 \r
2119 #define  VTable_Obj( i )  ( (void*) ( (char*)(i) - (*(i))->m_Offset ) )  /*[VTable_Obj]*/\r
2120 #define  VTable_Method( i, m_method )  (*(i))->m_method  /*[VTable_Method]*/\r
2121 \r
2122 #ifdef  __cplusplus\r
2123 extern "C" {\r
2124 #endif\r
2125 \r
2126 errnum_t  DefaultFunction( void* a );\r
2127 errnum_t  DefaultFunction_NotImplementYet( void* a );\r
2128 //errnum_t  DefaultFunction_Finish( void* a, errnum_t e );\r
2129 errnum_t  DefaultFunction_Finalize( void* a, errnum_t e );\r
2130 \r
2131 errnum_t  VTableDefine_overwrite( VTableDefine* aVTable, size_t aVTable_ByteSize, int iMethod, void* Func );\r
2132 \r
2133 #ifdef  __cplusplus\r
2134 }\r
2135 #endif\r
2136 \r
2137 \r
2138  \r
2139 /*=================================================================*/\r
2140 /* <<< [Error4/Error4.h] >>> */ \r
2141 /*=================================================================*/\r
2142  \r
2143 #if  __cplusplus\r
2144  extern "C" {  /* Start of C Symbol */ \r
2145 #endif\r
2146 \r
2147 \r
2148  \r
2149 /***********************************************************************\r
2150   <<< [SetBreakErrorID] >>> \r
2151 ************************************************************************/\r
2152 #ifndef  ENABLE_ERROR_BREAK_IN_ERROR_CLASS\r
2153         #if ! NDEBUG\r
2154                 #define  ENABLE_ERROR_BREAK_IN_ERROR_CLASS  1\r
2155         #else\r
2156                 #define  ENABLE_ERROR_BREAK_IN_ERROR_CLASS  0\r
2157         #endif\r
2158 #endif\r
2159 \r
2160 #ifndef  ENABLE_DEBUG_ERROR_BREAK_IN_ERROR_CLASS\r
2161         #if ! NDEBUG\r
2162                 #define  ENABLE_DEBUG_ERROR_BREAK_IN_ERROR_CLASS  1\r
2163         #else\r
2164                 #define  ENABLE_DEBUG_ERROR_BREAK_IN_ERROR_CLASS  0\r
2165         #endif\r
2166 #endif\r
2167 \r
2168 #ifndef  IS_MULTI_THREAD_ERROR_CLASS\r
2169  \r
2170         #define  IS_MULTI_THREAD_ERROR_CLASS  0  /*[IS_MULTI_THREAD_ERROR_CLASS]:single*/\r
2171  \r
2172 #endif\r
2173 \r
2174 #ifndef  NDEBUG\r
2175         #define  ERR2_ENABLE_ERROR_LOG  1\r
2176 #else\r
2177         #define  ERR2_ENABLE_ERROR_LOG  0\r
2178 #endif\r
2179 \r
2180 /*[dll_global_g_Error]*/\r
2181 #ifndef  dll_global_g_Error\r
2182         #define  dll_global_g_Error\r
2183 #endif\r
2184 \r
2185 \r
2186 #if ENABLE_ERROR_BREAK_IN_ERROR_CLASS\r
2187         /*[IF][IF_D][ASSERT_R][ASSERT_D]*/\r
2188         /* "IF" is able to break at nearest code raising error */\r
2189         #define  IF_D(x)  IF(x)\r
2190         #define  IF(x) \\r
2191                 if( (x) && ( OnRaisingError_Sub((const char*)__FILE__,__LINE__) ? (DebugBreakR(),1) : (1) ) )\r
2192 \r
2193         #define  ASSERT_R( x, goto_err_or_Statement ) \\r
2194                 __pragma(warning(push)) \\r
2195                 __pragma(warning(disable:4127)) \\r
2196                         do{  IF(!(x)) { goto_err_or_Statement; } }  while(0)   /* do-while is CERT standard PRE10-C */ \\r
2197                 __pragma(warning(pop))\r
2198 \r
2199         #define  ASSERT_D( x, goto_err_or_Statement )  ASSERT_R( x, goto_err_or_Statement )\r
2200 #else\r
2201         #define  IF(x)  if(x)\r
2202         #define  IF_D(x) \\r
2203                 __pragma(warning(push)) \\r
2204                 __pragma(warning(disable:4127)) \\r
2205                         if(0) \\r
2206                 __pragma(warning(pop))\r
2207 \r
2208         #define  ASSERT_R( x, goto_err_or_Statement ) \\r
2209                 __pragma(warning(push)) \\r
2210                 __pragma(warning(disable:4127)) \\r
2211                         do{  if(!(x)) { goto_err_or_Statement; } }while(0)   /* do-while is CERT standard PRE10-C */ \\r
2212                 __pragma(warning(pop))\r
2213 \r
2214         #define  ASSERT_D( x, goto_err_or_Statement )\r
2215 #endif\r
2216 \r
2217 \r
2218 void  DebugBreakR(void);\r
2219 #if ! ENABLE_ERROR_BREAK_IN_ERROR_CLASS\r
2220         inline void  SetBreakErrorID( int ID ) { ID=ID; /* avoid warning */ }\r
2221         inline void  ClearError() {}\r
2222         inline void  IfErrThenBreak() {}\r
2223         typedef  int  ErrStackAreaClass;  // dummy type\r
2224         inline void  PushErr( ErrStackAreaClass* ErrStackArea )  { UNREFERENCED_VARIABLE( ErrStackArea ); }\r
2225         inline void  PopErr(  ErrStackAreaClass* ErrStackArea )  { UNREFERENCED_VARIABLE( ErrStackArea ); }\r
2226 #else\r
2227         void  SetBreakErrorID( int ID );\r
2228         void  ClearError(void);\r
2229         void  IfErrThenBreak(void);\r
2230         typedef  struct _ErrorClass  ErrStackAreaClass;\r
2231         void  PushErr( ErrStackAreaClass* ErrStackArea );\r
2232         void  PopErr(  ErrStackAreaClass* ErrStackArea );\r
2233 \r
2234         bool  OnRaisingError_Sub( const char* FilePath, int LineNum );\r
2235 \r
2236         typedef  struct _ErrorClass  ErrorClass;  /*[ErrorClass]*/\r
2237         struct _ErrorClass {\r
2238                 bool         IsError;\r
2239                 #if  ENABLE_DEBUG_ERROR_BREAK_IN_ERROR_CLASS\r
2240                         int     ErrorID;\r
2241                 #endif\r
2242                 int          BreakErrorID;\r
2243                 const char*  FilePath;\r
2244                 int          LineNum;\r
2245 \r
2246                 #if IS_MULTI_THREAD_ERROR_CLASS\r
2247                         FinalizerClass  Finalizer;\r
2248                         #if  ENABLE_DEBUG_ERROR_BREAK_IN_ERROR_CLASS\r
2249                                 DWORD  ThreadID;\r
2250                                 int    GlobalErrorID;\r
2251                         #endif\r
2252                 #endif\r
2253         };\r
2254         errnum_t  ErrorClass_finalize( ErrorClass* self, errnum_t e );\r
2255 \r
2256         #if ! IS_MULTI_THREAD_ERROR_CLASS\r
2257                 dll_global_g_Error extern  ErrorClass  g_Error;\r
2258         #endif\r
2259 #endif\r
2260 \r
2261 errnum_t  MergeError( errnum_t e, errnum_t ee );\r
2262 void  ErrorLog_add( errnum_t e );\r
2263 \r
2264 \r
2265  \r
2266 /***********************************************************************\r
2267   <<< [ErrorMessage] >>> \r
2268 ************************************************************************/\r
2269 void  Error4_printf( const TCHAR* format, ... );\r
2270 void  Error4_getErrStr( int ErrNum, TCHAR* out_ErrStr, size_t ErrStrSize );\r
2271 void  Error4_clear( int err_num );\r
2272 errnum_t  SaveWindowsLastError(void);\r
2273 \r
2274 \r
2275  \r
2276 /***********************************************************************\r
2277   <<< [stdio] >>> \r
2278 ************************************************************************/\r
2279 void  Error4_showToStdErr( int err_num );\r
2280 void  Error4_showToStdIO( FILE* out, int err_num );\r
2281 \r
2282 \r
2283  \r
2284 /***********************************************************************\r
2285   <<< [DEBUG_TRUE, DEBUG_FALSE] >>> \r
2286 ************************************************************************/\r
2287 #if ! NDEBUG\r
2288  #define  DEBUG_TRUE   1\r
2289  #define  DEBUG_FALSE  0\r
2290 #else\r
2291  #define  DEBUG_TRUE   __cut_on_debug =\r
2292  #define  DEBUG_FALSE  0\r
2293 #endif\r
2294 \r
2295 \r
2296  \r
2297 /***********************************************************************\r
2298   <<< [DEBUG_CODE] >>> \r
2299 ************************************************************************/\r
2300 #if ! NDEBUG\r
2301         #define  DEBUG_CODE( expression ) \\r
2302                 __pragma(warning(push)) \\r
2303                 __pragma(warning(disable:4127)) \\r
2304                         do { expression; } while(0)   /* do-while is CERT standard PRE10-C */ \\r
2305                 __pragma(warning(pop))\r
2306 #else\r
2307         #define  DEBUG_CODE( expression )  /* no execute */\r
2308 #endif\r
2309 \r
2310 \r
2311  \r
2312 /***********************************************************************\r
2313   <<< [CHECK_ARG] >>> \r
2314 ************************************************************************/\r
2315 #ifndef  CHECK_ARG\r
2316   #define  CHECK_ARG  1\r
2317 #endif\r
2318 \r
2319 /*[GetIsCheckArg][SetIsCheckArg]*/\r
2320 #if CHECK_ARG\r
2321 extern bool  g_IsCheckArg;\r
2322 inline bool  GetIsCheckArg(void)  { return  g_IsCheckArg; }\r
2323 inline void  SetIsCheckArg( bool IsCheckArg )  { g_IsCheckArg = IsCheckArg; }\r
2324 #endif\r
2325 \r
2326 \r
2327  \r
2328 /***********************************************************************\r
2329   <<< [INVALID_VALUE] >>> \r
2330 ************************************************************************/\r
2331 enum { INVALID_VALUE = 0xDEDEDEDE };\r
2332 \r
2333 \r
2334  \r
2335 /***********************************************************************\r
2336   <<< [DUMMY_INITIAL_VALUE] >>> \r
2337 ************************************************************************/\r
2338 #ifndef NDEBUG\r
2339         enum { DUMMY_INITIAL_VALUE = 0xDEDEDEDE };\r
2340         enum { DUMMY_INITIAL_VALUE_8BIT  = 0xDE };\r
2341         enum { DUMMY_INITIAL_VALUE_16BIT = 0xDEDE };\r
2342         #ifdef _UNICODE\r
2343                 enum { DUMMY_INITIAL_VALUE_TCHAR = 0xDEDE };\r
2344         #else\r
2345                 enum { DUMMY_INITIAL_VALUE_TCHAR = 0xDE - 0x100 };  /* 0x100 is to change to signed type */\r
2346         #endif\r
2347         /* Disable VC++ warning C4701 : local variable may be used without having been initialized */\r
2348         /* 0xDEDEDEDE means "not initialized" */\r
2349 #else\r
2350         enum { DUMMY_INITIAL_VALUE = 0 };\r
2351         enum { DUMMY_INITIAL_VALUE_8BIT  = 0 };\r
2352         enum { DUMMY_INITIAL_VALUE_16BIT = 0 };\r
2353         enum { DUMMY_INITIAL_VALUE_TCHAR = 0 };\r
2354         /* 0 reduces code size */\r
2355 #endif\r
2356 \r
2357 \r
2358  \r
2359 /***********************************************************************\r
2360   <<< [DISCARD_STRUCT] >>> \r
2361   <<< [DISCARD_ARRAY] >>> \r
2362   <<< [DISCARD_BYTES] >>> \r
2363   <<< [MEMSET_TO_NOT_INIT] >>> \r
2364 ************************************************************************/\r
2365 #ifndef  ENABLE_DISCARD_STRUCT\r
2366  #if ! NDEBUG\r
2367   #define  ENABLE_DISCARD_STRUCT  1\r
2368  #else\r
2369   #define  ENABLE_DISCARD_STRUCT  0\r
2370  #endif\r
2371 #endif\r
2372 \r
2373 #if  USE_MEMSET_TO_NOT_INIT\r
2374         #define  DISCARD_STRUCT( TypedAddress ) \\r
2375                 memset( TypedAddress, 0xDE, sizeof(*(TypedAddress)) )\r
2376         #define  DISCARD_ARRAY( TypedAddress, Count ) \\r
2377                 memset( TypedAddress, 0xDE, sizeof(*(TypedAddress)) * (Count) )\r
2378         #define  DISCARD_BYTES( Address, ByteSize )  memset( Address, 0xDE, ByteSize )\r
2379 //      #define  MEMSET_TO_NOT_INIT( Address, ByteSize )  memset( Address, 0xDE, ByteSize )\r
2380 #else\r
2381         #define  DISCARD_STRUCT( Address )                __noop()\r
2382         #define  DISCARD_ARRAY( Address, Count )          __noop()\r
2383         #define  DISCARD_BYTES( Address, ByteSize )       __noop()\r
2384 //      #define  MEMSET_TO_NOT_INIT( Address, ByteSize )  __noop()\r
2385 #endif\r
2386 \r
2387 \r
2388  \r
2389 /***********************************************************************\r
2390   <<< [NAME_STR] >>> \r
2391 ************************************************************************/\r
2392 #ifndef  NAME_STR\r
2393  #if ! NDEBUG\r
2394   #define  NAME_STR  1\r
2395  #else\r
2396   #define  NAME_STR  0\r
2397  #endif\r
2398 #endif\r
2399 \r
2400  \r
2401 /***********************************************************************\r
2402   <<< [Error4_VariablesClass] >>> \r
2403 ************************************************************************/\r
2404 typedef struct _Error4_VariablesClass  Error4_VariablesClass;\r
2405 struct _Error4_VariablesClass {\r
2406         DWORD  WindowsLastError;\r
2407 };\r
2408 \r
2409 Error4_VariablesClass*  Get_Error4_Variables(void);\r
2410 \r
2411 #ifdef _DEBUG\r
2412         extern Error4_VariablesClass*  g_Error4_Variables;\r
2413 #endif\r
2414 \r
2415 \r
2416  \r
2417 #if  __cplusplus\r
2418  }  /* End of C Symbol */ \r
2419 #endif\r
2420  \r
2421 /*=================================================================*/\r
2422 /* <<< [Expat/Expat_incude.h] >>> */ \r
2423 /*=================================================================*/\r
2424  \r
2425 #ifndef  __EXPAT_H\r
2426 #define  __EXPAT_H\r
2427 \r
2428 #define  XML_STATIC   /* [SETTING] define or not define. if not define, deploy libexpat(w).dll */\r
2429 \r
2430 \r
2431 // reference: README.txt : * Special note about MS VC++ and runtime libraries\r
2432 #if _UNICODE\r
2433   #define  XML_UNICODE_WCHAR_T\r
2434   #if defined(XML_STATIC)\r
2435     #if _MT\r
2436       #if _DLL  // Visual C++ /MD option, MSVCP**.DLL\r
2437         #pragma comment(lib, "libexpatwMD.lib")  // not supplied\r
2438       #else  // Visual C++ /MT option\r
2439 \r
2440         #pragma comment(lib, "libexpatwMT.lib")\r
2441 \r
2442         #ifndef NDEBUG\r
2443           #pragma comment(linker,"/NODEFAULTLIB:LIBCMT" )\r
2444         #endif\r
2445       #endif\r
2446     #else\r
2447       #pragma comment(lib, "libexpatwML.lib")   // not supplied\r
2448     #endif\r
2449   #else  // DLL version\r
2450 \r
2451     #pragma comment(lib, "libexpatw.lib")  // libexpatw.dll, including multi thread static runtime library\r
2452 \r
2453   #endif\r
2454 #else\r
2455   #if defined(XML_STATIC)\r
2456     #if _MT\r
2457       #if _DLL  // Visual C++ /MD option, MSVCP**.DLL\r
2458         #pragma comment(lib, "libexpatMD.lib")  // not supplied\r
2459       #else  // Visual C++ /MT option\r
2460 \r
2461         #pragma comment(lib, "libexpatMT.lib")\r
2462 \r
2463         #ifndef NDEBUG\r
2464           # pragma comment(linker,"/NODEFAULTLIB:LIBCMT" )\r
2465         #endif\r
2466       #endif\r
2467     #else\r
2468       #pragma comment(lib, "libexpatML.lib")   // not supplied\r
2469     #endif\r
2470   #else  // DLL version\r
2471 \r
2472     #pragma comment(lib, "libexpat.lib")  // libexpat.dll, including multi thread static runtime library\r
2473 \r
2474   #endif\r
2475 #endif\r
2476 \r
2477 #include  <expat.h> \r
2478 \r
2479 \r
2480 #endif\r
2481  \r
2482 /*=================================================================*/\r
2483 /* <<< [FileT/FileT.h] >>> */ \r
2484 /*=================================================================*/\r
2485  \r
2486 #if  __cplusplus\r
2487  extern "C" {  /* Start of C Symbol */ \r
2488 #endif\r
2489 \r
2490 #define  FileT_isExistWildcard  1\r
2491 bool  FileT_isExist( const TCHAR* path );\r
2492 bool  FileT_isFile( const TCHAR* path );\r
2493 bool  FileT_isDir( const TCHAR* path );\r
2494 int   FileT_isDiff( const TCHAR* Path1, const TCHAR* Path2, bool* bDiff );\r
2495 int   FileT_isSameText( TCHAR* Path1, TCHAR* Path2, int Format1, int Format2, bool* out_bSame );\r
2496 int   FileT_isSameBinaryFile( const TCHAR* PathA, const TCHAR* PathB, int Flags, bool* out_IsSame );\r
2497 \r
2498 \r
2499  \r
2500 /* FileT_CallByNestFindData */ \r
2501 typedef struct {\r
2502         void*     CallerArgument;\r
2503         TCHAR*    FullPath;  // abstruct path\r
2504         TCHAR*    StepPath;\r
2505         TCHAR*    FileName;\r
2506         DWORD     FileAttributes;\r
2507 } FileT_CallByNestFindData;\r
2508 \r
2509 int  FileT_callByNestFind( const TCHAR* Path, BitField Flags, void* Obj, FuncType Callback );\r
2510 \r
2511 enum { FileT_FolderBeforeFiles = 1 };\r
2512 enum { FileT_FolderAfterFiles  = 2 };\r
2513 enum { FileT_Folder = FILE_ATTRIBUTE_DIRECTORY };\r
2514 \r
2515  \r
2516 /***********************************************************************\r
2517   <<< [FileT_Read] >>> \r
2518 ************************************************************************/\r
2519 int  FileT_openForRead( FILE** out_pFile, const TCHAR* path );\r
2520 // int  FileT_close( FILE* File, int e );\r
2521 errnum_t  FileT_closeAndNULL( FILE** in_out_File, errnum_t e );\r
2522 \r
2523 \r
2524  \r
2525 errnum_t  FileT_readAll( FILE* File, TCHAR** out_Text, size_t* out_TextLength );\r
2526 \r
2527 \r
2528  \r
2529 /***********************************************************************\r
2530   <<< [FileT_Write] >>> \r
2531 ************************************************************************/\r
2532 int  FileT_openForWrite( FILE** out_pFile, const TCHAR* Path,  bit_flags_fast32_t  Flags );\r
2533 \r
2534 enum { F_Unicode = 1,  F_Append = 2 };\r
2535 \r
2536 int  FileT_copy( const TCHAR* SrcPath, const TCHAR* DstPath );\r
2537 int  FileT_mkdir( const TCHAR* Path );\r
2538 int  FileT_del( const TCHAR* Path );\r
2539 int  FileT_writePart( FILE* File, const TCHAR* Start, TCHAR* Over );\r
2540 \r
2541 \r
2542  \r
2543 /***********************************************************************\r
2544   <<< [FileT_WinAPI] >>> \r
2545 ************************************************************************/\r
2546 int  FileT_readSizedStruct_WinAPI( HANDLE* Stream, void** out_SizedStruct );\r
2547 int  FileT_writeSizedStruct_WinAPI( HANDLE* Stream, SizedStruct* OutputSizedStruct );\r
2548 \r
2549 \r
2550  \r
2551 /***********************************************************************\r
2552   <<< [FileFormatEnum] >>> \r
2553 ************************************************************************/\r
2554 typedef enum {\r
2555         FILE_FORMAT_NOT_EXIST = 0,  /* File does not exist */\r
2556         FILE_FORMAT_NO_BOM    = 1,\r
2557         FILE_FORMAT_UNICODE   = 2,\r
2558         FILE_FORMAT_UTF_8     = 3,\r
2559 } FileFormatEnum;\r
2560 \r
2561 \r
2562  \r
2563 /***********************************************************************\r
2564 * Function: FileT_readUnicodeFileBOM\r
2565 ************************************************************************/\r
2566 errnum_t  FileT_readUnicodeFileBOM( const TCHAR* Path, FileFormatEnum* out_Format );\r
2567 \r
2568 \r
2569  \r
2570 /***********************************************************************\r
2571 * Function: FileT_cutFFFE\r
2572 ************************************************************************/\r
2573 errnum_t  FileT_cutFFFE( const TCHAR* in_InputPath,  const TCHAR*  in_OutputPath,  bool  in_IsAppend );\r
2574 \r
2575 \r
2576  \r
2577 /***********************************************************************\r
2578   <<< [ParseXML2] >>>\r
2579 ************************************************************************/\r
2580 typedef struct _ParseXML2_ConfigClass  ParseXML2_ConfigClass;\r
2581 typedef struct _ParseXML2_StatusClass  ParseXML2_StatusClass;\r
2582 typedef errnum_t  (* ParseXML2_CallbackType )( ParseXML2_StatusClass* Status );\r
2583 \r
2584 struct _ParseXML2_ConfigClass {\r
2585         BitField                Flags;   /* F_ParseXML2_Delegate | F_ParseXML2_OnStartElement ... */\r
2586         void*                   Delegate;       /* Flags|= F_ParseXML2_Delegate,       if enabled */\r
2587         ParseXML2_CallbackType  OnStartElement; /* Flags|= F_ParseXML2_OnStartElement, if enabled */\r
2588         ParseXML2_CallbackType  OnEndElement;   /* Flags|= F_ParseXML2_OnEndElement,   if enabled */\r
2589         ParseXML2_CallbackType  OnText;         /* Flags|= F_ParseXML2_OnText,         if enabled */\r
2590 };\r
2591 enum {\r
2592         F_ParseXML2_Delegate       = 0x0001,\r
2593         F_ParseXML2_OnStartElement = 0x0004,\r
2594         F_ParseXML2_OnEndElement   = 0x0008,\r
2595         F_ParseXML2_OnText         = 0x0010,\r
2596 };\r
2597 \r
2598 struct _ParseXML2_StatusClass {\r
2599         void*   Delegate;\r
2600         int     LineNum;\r
2601         int     Depth;                 /* Root XML element is 0 */\r
2602         int     PreviousCallbackType;  /* e.g.) F_ParseXML2_OnStartElement. Initial value is 0 */\r
2603 \r
2604         TCHAR*  XPath;\r
2605         TCHAR*  TagName;\r
2606         union {\r
2607                 struct {\r
2608                         const XML_Char**  Attributes;  /* for ParseXML2_StatusClass_getAttribute */\r
2609                 } OnStartElement;\r
2610 \r
2611                 struct {  /* for ParseXML2_StatusClass_mallocCopyText */\r
2612                         const TCHAR*  Text;  /* not NULL terminated */\r
2613                         int           TextLength;\r
2614                 } OnText;\r
2615         } u;\r
2616 };\r
2617 \r
2618 errnum_t  ParseXML2( const TCHAR* XML_Path, ParseXML2_ConfigClass* in_out_Config );\r
2619 errnum_t  ParseXML2_StatusClass_getAttribute( ParseXML2_StatusClass* self,\r
2620         const TCHAR* AttributeName, TCHAR** out_AttribyteValue );\r
2621 errnum_t  ParseXML2_StatusClass_mallocCopyText( ParseXML2_StatusClass* self,\r
2622         TCHAR** out_Text );\r
2623 \r
2624 enum { E_XML_PARSER = 0x3101 };\r
2625 \r
2626 \r
2627  \r
2628 /***********************************************************************\r
2629   <<< [Writables] >>> \r
2630 ************************************************************************/\r
2631 #ifndef  Uses_AppKey\r
2632 #define  Uses_AppKey  1\r
2633 #endif\r
2634 \r
2635 typedef void*  AppKey;\r
2636 typedef struct _Writables  Writables;\r
2637 \r
2638 errnum_t  AppKey_newWritable( AppKey** in_out_m,  Writables** out_Writable,  ... );\r
2639 errnum_t  AppKey_newWritable_byArray( AppKey** in_out_m,  Writables** out_Writable,\r
2640         TCHAR**  in_Paths,  int  in_PathCount );\r
2641 void      AppKey_initGlobal_const(void);\r
2642 errnum_t  AppKey_finishGlobal( errnum_t e );\r
2643 errnum_t  AppKey_addNewWritableFolder( const TCHAR* Path );\r
2644 errnum_t  AppKey_addWritableFolder( AppKey* m, const TCHAR* Path );\r
2645 errnum_t  AppKey_checkWritable( const TCHAR* Path );\r
2646 \r
2647 \r
2648 struct _Writables {\r
2649         TCHAR**   m_Paths;  // array of array of TCHAR\r
2650         int       m_nPath;  // -1= not inited\r
2651 };\r
2652 \r
2653 errnum_t   Writables_delete( Writables* m, errnum_t e );\r
2654 \r
2655 errnum_t   Writables_add( Writables* m, AppKey* Key, const TCHAR* Path );\r
2656 errnum_t   Writables_remove( Writables* m, const TCHAR* Path );\r
2657 \r
2658 errnum_t   Writables_enable( Writables* m );\r
2659 errnum_t   Writables_disable( Writables* m, errnum_t e );\r
2660 \r
2661 extern  Writables  g_CurrentWritables;\r
2662 \r
2663 \r
2664  \r
2665 #if  __cplusplus\r
2666  }  /* End of C Symbol */ \r
2667 #endif\r
2668  \r
2669 /*=================================================================*/\r
2670 /* <<< [IniFile2/IniFile2.h] >>> */ \r
2671 /*=================================================================*/\r
2672  \r
2673 #if  __cplusplus\r
2674  extern "C" {  /* Start of C Symbol */ \r
2675 #endif\r
2676  \r
2677 bool  IniStr_isLeft( const TCHAR* line, const TCHAR* symbol ); \r
2678  \r
2679 TCHAR*  IniStr_refRight( const TCHAR* line, bool bTrimRight ); \r
2680  \r
2681 #if  __cplusplus\r
2682  }    /* End of C Symbol */ \r
2683 #endif\r
2684 \r
2685  \r
2686 /*=================================================================*/\r
2687 /* <<< [Locale/Locale.h] >>> */ \r
2688 /*=================================================================*/\r
2689  \r
2690 #if  __cplusplus\r
2691  extern "C" {  /* Start of C Symbol */ \r
2692 #endif\r
2693 \r
2694 \r
2695  \r
2696 /***********************************************************************\r
2697   <<< [Locale] >>> \r
2698 ************************************************************************/\r
2699 extern char*  g_LocaleSymbol;\r
2700 int  Locale_init(void);\r
2701 int  Locale_isInited(void);\r
2702 \r
2703 \r
2704  \r
2705 /***********************************************************************\r
2706   <<< [FileTime] >>> \r
2707 ************************************************************************/\r
2708 \r
2709 #define  FILETIME_addDays( pAnsTime, pBaseTime, plus ) \\r
2710   ( *(ULONGLONG*)(pAnsTime) = *(ULONGLONG*)(pBaseTime) \\r
2711           + (plus) * ((LONGLONG)(24*60*60)*(1000*1000*10)) )\r
2712 \r
2713 #define  FILETIME_addHours( pAnsTime, pBaseTime, plus ) \\r
2714   ( *(ULONGLONG*)(pAnsTime) = *(ULONGLONG*)(pBaseTime) \\r
2715           + (plus) * ((LONGLONG)(60*60)*(1000*1000*10)) )\r
2716 \r
2717 #define  FILETIME_addMinutes( pAnsTime, pBaseTime, plus ) \\r
2718   ( *(ULONGLONG*)(pAnsTime) = *(ULONGLONG*)(pBaseTime) \\r
2719           + (plus) * ((LONGLONG)(60)*(1000*1000*10)) )\r
2720 \r
2721 #define  FILETIME_addSeconds( pAnsTime, pBaseTime, plus ) \\r
2722   ( *(ULONGLONG*)(pAnsTime) = *(ULONGLONG*)(pBaseTime) \\r
2723           + (plus) * ((LONGLONG)(1000*1000*10)) )\r
2724 \r
2725 #define  FILETIME_sub( pLeftTime, pRightTime ) \\r
2726   ( *(ULONGLONG*)(pLeftTime) - *(ULONGLONG*)(pRightTime) )\r
2727 \r
2728 \r
2729  \r
2730 #if  __cplusplus\r
2731  }  /* End of C Symbol */ \r
2732 #endif\r
2733 \r
2734 \r
2735  \r
2736 /*=================================================================*/\r
2737 /* <<< [Parse2/Parse2.h] >>> */ \r
2738 /*=================================================================*/\r
2739  \r
2740 /***********************************************************************\r
2741   <<< [E_CATEGORY_PARSER2] >>> \r
2742 ************************************************************************/\r
2743 #ifndef  E_CATEGORY_PARSER2  /* If not duplicated */\r
2744         #define  E_CATEGORY_PARSER2  E_CATEGORY_PARSER2\r
2745         enum { E_CATEGORY_PARSER2 = 0x00000600 };\r
2746 #endif\r
2747 \r
2748 enum { E_NOT_FOUND_PARTNER_BRACKET = E_CATEGORY_PARSER2 | 0x01 };  /*[E_NOT_FOUND_PARTNER_BRACKET]*/\r
2749 \r
2750 \r
2751  \r
2752 /***********************************************************************\r
2753   <<< [ParsedRangeClass] >>> \r
2754 ************************************************************************/\r
2755 typedef struct _ParsedRangeClass  ParsedRangeClass;\r
2756 struct _ParsedRangeClass {\r
2757 \r
2758         /* <Inherit parent="Variant_SuperClass"> */\r
2759         const ClassID_Class*   ClassID;\r
2760         FinalizerVTableClass*  FinalizerVTable;\r
2761         VariantClass*          StaticAddress;\r
2762         /* </Inherit> */\r
2763 \r
2764         const TCHAR*  Start;\r
2765         const TCHAR*  Over;\r
2766 };\r
2767 extern const ClassID_Class  g_ParsedRangeClass_ID;\r
2768 \r
2769 void  ParsedRangeClass_initConst( ParsedRangeClass* self );\r
2770 \r
2771 int  ParsedRanges_compareByStart( const void* _a1, const void* _a2 );\r
2772 \r
2773 #ifndef NDEBUG\r
2774 void  ParsedRangeClass_onInitializedForDebug( ParsedRangeClass* self );\r
2775 #else\r
2776 inline void  ParsedRangeClass_onInitializedForDebug( ParsedRangeClass* self )\r
2777 {\r
2778         UNREFERENCED_VARIABLE( self );\r
2779 }\r
2780 #endif\r
2781 \r
2782 \r
2783  \r
2784 errnum_t  ParsedRanges_write_by_Cut(\r
2785         Set2* /*<ParsedRangeClass>*/ CutRanges,\r
2786         const TCHAR* Text, FILE* OutFile );\r
2787 \r
2788 \r
2789  \r
2790 /***********************************************************************\r
2791   <<< [LineNumberIndexClass] >>> \r
2792 ************************************************************************/\r
2793 typedef struct _LineNumberIndexClass  LineNumberIndexClass;\r
2794 struct _LineNumberIndexClass {\r
2795         Set2  /*<const TCHAR*>*/  LeftsOfLine;\r
2796 };\r
2797 \r
2798 void      LineNumberIndexClass_initConst( LineNumberIndexClass* self );\r
2799 errnum_t  LineNumberIndexClass_initialize( LineNumberIndexClass* self, const TCHAR* Text );\r
2800 errnum_t  LineNumberIndexClass_finalize( LineNumberIndexClass* self, errnum_t e );\r
2801 errnum_t  LineNumberIndexClass_searchLineNumber( LineNumberIndexClass* self, const TCHAR* Position,\r
2802         int* out_LineNumber );\r
2803 int  LineNumberIndexClass_getCountOfLines( LineNumberIndexClass* self );\r
2804 \r
2805 \r
2806  \r
2807 /***********************************************************************\r
2808   <<< [SyntaxSubNodeClass] >>> \r
2809 ************************************************************************/\r
2810 typedef struct _SyntaxSubNodeClass_IDClass  SyntaxSubNodeClass_IDClass;\r
2811 typedef struct _SyntaxNodeClass             SyntaxNodeClass;\r
2812 \r
2813 \r
2814 typedef struct _SyntaxSubNodeClass  SyntaxSubNodeClass;\r
2815 struct _SyntaxSubNodeClass {\r
2816 \r
2817         /* <Inherit parent="ParsedRangeClass"> */\r
2818         const ClassID_Class*         ClassID;\r
2819         const FinalizerVTableClass*  FinalizerVTable;\r
2820         const TCHAR*                 Start;\r
2821         const TCHAR*                 Over;\r
2822         /* </Inherit> */\r
2823 \r
2824         const PrintXML_VTableClass*  PrintXML_VTable;\r
2825         SyntaxNodeClass*             Parent;\r
2826         ListElementClass             SubNodeListElement;  /* for ".Parent" */\r
2827 };\r
2828 \r
2829 extern const ClassID_Class  g_SyntaxSubNodeClass_ID;\r
2830 errnum_t  SyntaxSubNodeClass_printXML( SyntaxSubNodeClass* self, FILE* OutputStream );\r
2831 \r
2832 \r
2833  \r
2834 /***********************************************************************\r
2835   <<< [SyntaxNodeClass] >>> \r
2836 ************************************************************************/\r
2837 typedef struct _SyntaxNodeClass_IDClass  SyntaxNodeClass_IDClass;\r
2838 \r
2839 typedef struct _SyntaxNodeClass  SyntaxNodeClass;\r
2840 struct _SyntaxNodeClass {\r
2841 \r
2842         /* <Inherit parent="SyntaxSubNodeClass"> */\r
2843         const ClassID_Class*         ClassID;\r
2844         const FinalizerVTableClass*  FinalizerVTable;\r
2845         const TCHAR*                 Start;\r
2846         const TCHAR*                 Over;\r
2847         const PrintXML_VTableClass*  PrintXML_VTable;\r
2848         SyntaxNodeClass*             Parent;\r
2849         ListElementClass             SubNodeListElement;  /* for ".Parent" */\r
2850         /* </Inherit> */\r
2851 \r
2852         ListClass                    SubNodeList;\r
2853         ListElementClass             ListElement;  /* Next and previous in source file */\r
2854 };\r
2855 \r
2856 errnum_t  Delete_SyntaxNodeList( ListClass* /*<SyntaxNodeClass*>*/ NodeList, errnum_t e );\r
2857 \r
2858 extern const ClassID_Class  g_SyntaxNodeClass_ID;\r
2859 void      SyntaxNodeClass_initConst( SyntaxNodeClass* self );\r
2860 errnum_t  SyntaxNodeClass_printXML( SyntaxNodeClass* self, FILE* OutputStream );\r
2861 errnum_t  SyntaxNodeClass_addSubNode( SyntaxNodeClass* self, SyntaxSubNodeClass* SubNode );\r
2862 \r
2863 \r
2864  \r
2865 /***********************************************************************\r
2866   <<< [PP_DirectiveClass] >>> \r
2867 ************************************************************************/\r
2868 \r
2869 typedef struct _PP_DirectiveClass  PP_DirectiveClass;\r
2870 typedef struct _PP_SharpIfClass  PP_SharpIfClass;\r
2871 typedef struct _PP_SharpElseClass  PP_SharpElseClass;\r
2872 typedef struct _PP_SharpEndifClass  PP_SharpEndifClass;\r
2873 typedef struct _PP_SharpIfdefClass  PP_SharpIfdefClass;\r
2874 typedef struct _PP_SharpIfndefClass  PP_SharpIfndefClass;\r
2875 \r
2876 \r
2877 typedef struct _PP_DirectiveClass  PP_DirectiveClass;\r
2878 struct _PP_DirectiveClass {\r
2879 \r
2880         /* <Inherit parent="ParsedRangeClass"> */\r
2881         const ClassID_Class*   ClassID;\r
2882         FinalizerVTableClass*  FinalizerVTable;\r
2883         VariantClass*          StaticAddress;\r
2884         const TCHAR*           Start;  /* Left of a line having the direvtive */\r
2885         const TCHAR*           Over;\r
2886         /* </Inherit> */\r
2887 \r
2888         const TCHAR*  DirectiveName_Start;\r
2889         const TCHAR*  DirectiveName_Over;\r
2890 };\r
2891 extern const ClassID_Class  g_PP_DirectiveClass_ID;\r
2892 \r
2893 \r
2894 errnum_t  Parse_PP_Directive( const TCHAR* Text,\r
2895         Set2* /*<PP_DirectiveClass*>*/ DirectivePointerArray );\r
2896 errnum_t  Delete_PP_Directive( Set2* DirectivePointerArray, errnum_t e );\r
2897 \r
2898 \r
2899 void  PP_DirectiveClass_initConst( PP_DirectiveClass* self );\r
2900 \r
2901 \r
2902  \r
2903 errnum_t  ParsedRanges_getCut_by_PP_Directive(\r
2904         Set2* /*<ParsedRangeClass>*/    CutRanges,\r
2905         Set2* /*<PP_DirectiveClass*>*/  DirectivePointerArray,\r
2906         const TCHAR* Symbol,  bool IsCutDefine );\r
2907 \r
2908 \r
2909  \r
2910 errnum_t  CutPreprocessorDirectives_from_C_LanguageToken(\r
2911         ListClass* /*<C_LanguageTokenClass*>*/ TokenList,\r
2912         Set2* /*<PP_DirectiveClass*>*/ Directives );\r
2913 \r
2914 \r
2915  \r
2916 /***********************************************************************\r
2917   <<< [PP_SharpDefineClass] >>> \r
2918 ************************************************************************/\r
2919 typedef struct _PP_SharpDefineClass_IDClass  PP_SharpDefineClass_IDClass;\r
2920 \r
2921 typedef struct _PP_SharpDefineClass  PP_SharpDefineClass;\r
2922 struct _PP_SharpDefineClass {\r
2923 \r
2924         /* <Inherit parent="PP_DirectiveClass"> */\r
2925         const ClassID_Class*   ClassID;\r
2926         FinalizerVTableClass*  FinalizerVTable;\r
2927         VariantClass*          StaticAddress;\r
2928         const TCHAR*           Start;\r
2929         const TCHAR*           Over;\r
2930         const TCHAR*           DirectiveName_Start;\r
2931         const TCHAR*           DirectiveName_Over;\r
2932         /* </Inherit> */\r
2933 \r
2934         const TCHAR*  Symbol_Start;\r
2935         const TCHAR*  Symbol_Over;\r
2936 };\r
2937 \r
2938 extern const ClassID_Class  g_PP_SharpDefineClass_ID;\r
2939 \r
2940 \r
2941  \r
2942 /***********************************************************************\r
2943   <<< [PP_SharpIncludeClass] >>> \r
2944 ************************************************************************/\r
2945 typedef struct _PP_SharpIncludeClass_IDClass  PP_SharpIncludeClass_IDClass;\r
2946 \r
2947 typedef struct _PP_SharpIncludeClass  PP_SharpIncludeClass;\r
2948 struct _PP_SharpIncludeClass {\r
2949 \r
2950         /* <Inherit parent="PP_DirectiveClass"> */\r
2951         const ClassID_Class*   ClassID;\r
2952         FinalizerVTableClass*  FinalizerVTable;\r
2953         VariantClass*          StaticAddress;\r
2954         const TCHAR*           Start;\r
2955         const TCHAR*           Over;\r
2956         const TCHAR*           DirectiveName_Start;\r
2957         const TCHAR*           DirectiveName_Over;\r
2958         /* </Inherit> */\r
2959 \r
2960         const TCHAR*  Path_Start;\r
2961         const TCHAR*  Path_Over;\r
2962         TCHAR         PathBracket;  /* _T('<') or _T('"') */\r
2963 };\r
2964 \r
2965 extern const ClassID_Class  g_PP_SharpIncludeClass_ID;\r
2966 \r
2967 \r
2968  \r
2969 /***********************************************************************\r
2970   <<< [PP_SharpIfClass] >>> \r
2971 ************************************************************************/\r
2972 typedef struct _PP_SharpIfClass_IDClass  PP_SharpIfClass_IDClass;\r
2973 \r
2974 typedef struct _PP_SharpIfClass  PP_SharpIfClass;\r
2975 struct _PP_SharpIfClass {\r
2976 \r
2977         /* <Inherit parent="PP_DirectiveClass"> */\r
2978         const ClassID_Class*   ClassID;\r
2979         FinalizerVTableClass*  FinalizerVTable;\r
2980         VariantClass*          StaticAddress;\r
2981         const TCHAR*           Start;\r
2982         const TCHAR*           Over;\r
2983         const TCHAR*           DirectiveName_Start;\r
2984         const TCHAR*           DirectiveName_Over;\r
2985         /* </Inherit> */\r
2986 \r
2987         PP_DirectiveClass*   NextDirective;\r
2988         PP_SharpEndifClass*  EndDirective;\r
2989 };\r
2990 \r
2991 extern const ClassID_Class  g_PP_SharpIfClass_ID;\r
2992 \r
2993 \r
2994  \r
2995 /***********************************************************************\r
2996   <<< [PP_SharpElseClass] >>> \r
2997 ************************************************************************/\r
2998 typedef struct _PP_SharpElseClass  PP_SharpElseClass;\r
2999 struct _PP_SharpElseClass {\r
3000 \r
3001         /* <Inherit parent="PP_DirectiveClass"> */\r
3002         const ClassID_Class*   ClassID;\r
3003         FinalizerVTableClass*  FinalizerVTable;\r
3004         VariantClass*          StaticAddress;\r
3005         const TCHAR*           Start;\r
3006         const TCHAR*           Over;\r
3007         const TCHAR*           DirectiveName_Start;\r
3008         const TCHAR*           DirectiveName_Over;\r
3009         /* </Inherit> */\r
3010 \r
3011         PP_SharpIfClass*     StartDirective;\r
3012         PP_SharpEndifClass*  EndDirective;\r
3013 };\r
3014 extern const ClassID_Class  g_PP_SharpElseClass_ID;\r
3015 \r
3016 \r
3017  \r
3018 /***********************************************************************\r
3019   <<< [PP_SharpEndifClass] >>> \r
3020 ************************************************************************/\r
3021 typedef struct _PP_SharpEndifClass  PP_SharpEndifClass;\r
3022 struct _PP_SharpEndifClass {\r
3023 \r
3024         /* <Inherit parent="PP_DirectiveClass"> */\r
3025         const ClassID_Class*   ClassID;\r
3026         FinalizerVTableClass*  FinalizerVTable;\r
3027         VariantClass*          StaticAddress;\r
3028         const TCHAR*           Start;\r
3029         const TCHAR*           Over;\r
3030         const TCHAR*           DirectiveName_Start;\r
3031         const TCHAR*           DirectiveName_Over;\r
3032         /* </Inherit> */\r
3033 \r
3034         PP_SharpIfClass*    StartDirective;\r
3035         PP_DirectiveClass*  PreviousDirective;\r
3036 };\r
3037 extern const ClassID_Class  g_PP_SharpEndifClass_ID;\r
3038 \r
3039 \r
3040  \r
3041 /***********************************************************************\r
3042   <<< [PP_SharpIfdefClass] >>> \r
3043 ************************************************************************/\r
3044 typedef struct _PP_SharpIfdefClass  PP_SharpIfdefClass;\r
3045 struct _PP_SharpIfdefClass {\r
3046 \r
3047         /* <Inherit parent="PP_SharpIfClass"> */\r
3048         const ClassID_Class*   ClassID;\r
3049         FinalizerVTableClass*  FinalizerVTable;\r
3050         VariantClass*          StaticAddress;\r
3051         const TCHAR*           Start;\r
3052         const TCHAR*           Over;\r
3053         const TCHAR*           DirectiveName_Start;\r
3054         const TCHAR*           DirectiveName_Over;\r
3055         PP_DirectiveClass*     NextDirective;\r
3056         PP_SharpEndifClass*    EndDirective;\r
3057         /* </Inherit> */\r
3058 \r
3059         const TCHAR*  Symbol_Start;\r
3060         const TCHAR*  Symbol_Over;\r
3061 };\r
3062 extern const ClassID_Class  g_PP_SharpIfdefClass_ID;\r
3063 \r
3064 \r
3065  \r
3066 /***********************************************************************\r
3067   <<< [PP_SharpIfndefClass] >>> \r
3068 ************************************************************************/\r
3069 typedef struct _PP_SharpIfndefClass  PP_SharpIfndefClass;\r
3070 struct _PP_SharpIfndefClass {\r
3071 \r
3072         /* <Inherit parent="PP_SharpIfdefClass"> */\r
3073         const ClassID_Class*   ClassID;\r
3074         FinalizerVTableClass*  FinalizerVTable;\r
3075         VariantClass*          StaticAddress;\r
3076         const TCHAR*           Start;\r
3077         const TCHAR*           Over;\r
3078         const TCHAR*           DirectiveName_Start;\r
3079         const TCHAR*           DirectiveName_Over;\r
3080         PP_DirectiveClass*     NextDirective;\r
3081         PP_SharpEndifClass*    EndDirective;\r
3082         const TCHAR*           Symbol_Start;\r
3083         const TCHAR*           Symbol_Over;\r
3084         /* </Inherit> */\r
3085 };\r
3086 extern const ClassID_Class  g_PP_SharpIfndefClass_ID;\r
3087 \r
3088 \r
3089  \r
3090 /***********************************************************************\r
3091   <<< [C_LanguageTokenEnum] >>> \r
3092 ************************************************************************/\r
3093 typedef enum _C_LanguageTokenEnum  C_LanguageTokenEnum;\r
3094 enum _C_LanguageTokenEnum {\r
3095         gc_TokenOfOther       = 0,\r
3096         gc_TokenOfNumber      = 0xA1,\r
3097         gc_TokenOfCIdentifier = 0xA2,\r
3098         gc_TokenOfString      = 0xA3,\r
3099         gc_TokenOfChar        = 0xA4,\r
3100 \r
3101         gc_TokenOf_28         = '(',\r
3102         gc_TokenOf_29         = ')',\r
3103         gc_TokenOf_7B         = '{',\r
3104         gc_TokenOf_7D         = '}',\r
3105         gc_TokenOf_5B         = '[',\r
3106         gc_TokenOf_5D         = ']',\r
3107         gc_TokenOf_3A         = ':',\r
3108         gc_TokenOf_3B         = ';',\r
3109         gc_TokenOf_2A         = '*',\r
3110         gc_TokenOf_0A         = '\n',\r
3111         gc_TokenOf_3D         = '=',\r
3112         gc_TokenOf_2E         = '.',\r
3113         gc_TokenOf_26         = '&',\r
3114         gc_TokenOf_2B         = '+',\r
3115         gc_TokenOf_2D         = '-',\r
3116         gc_TokenOf_7E         = '~',\r
3117         gc_TokenOf_21         = '!',\r
3118         gc_TokenOf_2F         = '/',\r
3119         gc_TokenOf_25         = '%',\r
3120         gc_TokenOf_3E         = '>',\r
3121         gc_TokenOf_3C         = '<',\r
3122         gc_TokenOf_5E         = '^',\r
3123         gc_TokenOf_7C         = '|',\r
3124         gc_TokenOf_3F         = '?',\r
3125         gc_TokenOf_2C         = ',',\r
3126         gc_TokenOf_2A2F       = TwoChar8( '/', '*' ),\r
3127         gc_TokenOf_2F2A       = TwoChar8( '*', '/' ),\r
3128         gc_TokenOf_2F2F       = TwoChar8( '/', '/' ),\r
3129         gc_TokenOf_3E2D       = TwoChar8( '-', '>' ),\r
3130         gc_TokenOf_2B2B       = TwoChar8( '+', '+' ),\r
3131         gc_TokenOf_2D2D       = TwoChar8( '-', '-' ),\r
3132         gc_TokenOf_3C3C       = TwoChar8( '<', '<' ),\r
3133         gc_TokenOf_3E3E       = TwoChar8( '>', '>' ),\r
3134         gc_TokenOf_3D3E       = TwoChar8( '>', '=' ),\r
3135         gc_TokenOf_3D3C       = TwoChar8( '<', '=' ),\r
3136         gc_TokenOf_3D3D       = TwoChar8( '=', '=' ),\r
3137         gc_TokenOf_3D21       = TwoChar8( '!', '=' ),\r
3138         gc_TokenOf_2626       = TwoChar8( '&', '&' ),\r
3139         gc_TokenOf_7C7C       = TwoChar8( '|', '|' ),\r
3140         gc_TokenOf_3D2B       = TwoChar8( '+', '=' ),\r
3141         gc_TokenOf_3D2D       = TwoChar8( '-', '=' ),\r
3142         gc_TokenOf_3D2A       = TwoChar8( '*', '=' ),\r
3143         gc_TokenOf_3D2F       = TwoChar8( '/', '=' ),\r
3144         gc_TokenOf_3D25       = TwoChar8( '%', '=' ),\r
3145         /* <<= */\r
3146         /* >>= */\r
3147         gc_TokenOf_3D26       = TwoChar8( '&', '=' ),\r
3148         gc_TokenOf_3D7C       = TwoChar8( '|', '=' ),\r
3149         gc_TokenOf_3D5E       = TwoChar8( '^', '=' ),\r
3150 };\r
3151 \r
3152 TCHAR*  C_LanguageTokenEnum_convertToStr( C_LanguageTokenEnum Value );\r
3153 \r
3154 \r
3155  \r
3156 /***********************************************************************\r
3157   <<< [C_LanguageTokenClass] >>> \r
3158 ************************************************************************/\r
3159 typedef struct _C_LanguageTokenClass_IDClass  C_LanguageTokenClass_IDClass;\r
3160 \r
3161 typedef struct _C_LanguageTokenClass  C_LanguageTokenClass;\r
3162 struct _C_LanguageTokenClass {\r
3163 \r
3164         /* <Inherit parent="SyntaxSubNodeClass"> */\r
3165         const ClassID_Class*         ClassID;\r
3166         const FinalizerVTableClass*  FinalizerVTable;\r
3167         const TCHAR*                 Start;\r
3168         const TCHAR*                 Over;\r
3169         const PrintXML_VTableClass*  PrintXML_VTable;\r
3170         SyntaxNodeClass*             Parent;\r
3171         ListElementClass             SubNodeListElement;  /* for ".Parent" */\r
3172         /* </Inherit> */\r
3173 \r
3174         C_LanguageTokenEnum          TokenType;\r
3175         ListElementClass             ListElement;  /* Next and previous in source file */\r
3176         SyntaxNodeClass*             ParentBlock;\r
3177 };\r
3178 \r
3179 extern const ClassID_Class  g_C_LanguageTokenClass_ID;\r
3180 void      C_LanguageTokenClass_initConst( C_LanguageTokenClass* self );\r
3181 errnum_t  C_LanguageTokenClass_printXML( C_LanguageTokenClass* self, FILE* OutputStream );\r
3182 \r
3183 \r
3184  \r
3185 /***********************************************************************\r
3186   <<< [NaturalDocsDefinitionClass] >>> \r
3187 ************************************************************************/\r
3188 typedef struct _NaturalDocsDefinitionClass  NaturalDocsDefinitionClass;\r
3189 struct _NaturalDocsDefinitionClass {\r
3190         const TCHAR*  Name;  /* Has */\r
3191         const TCHAR*  NameStart;\r
3192         const TCHAR*  NameOver;\r
3193 \r
3194         const TCHAR*  Brief;  /* Has */\r
3195         const TCHAR*  BriefStart;\r
3196         const TCHAR*  BriefOver;\r
3197 };\r
3198 \r
3199 void      NaturalDocsDefinitionClass_initConst( NaturalDocsDefinitionClass* self );\r
3200 errnum_t  NaturalDocsDefinitionClass_finalize( NaturalDocsDefinitionClass* self,  errnum_t e );\r
3201 \r
3202 \r
3203  \r
3204 /***********************************************************************\r
3205   <<< [NaturalDocsDescriptionTypeEnum] >>> \r
3206 ************************************************************************/\r
3207 typedef enum _NaturalDocsDescriptionTypeEnum  NaturalDocsDescriptionTypeEnum;\r
3208 enum _NaturalDocsDescriptionTypeEnum {\r
3209         NaturalDocsDescriptionType_Unknown,\r
3210         NaturalDocsDescriptionType_SubTitle,\r
3211         NaturalDocsDescriptionType_Paragraph,\r
3212         NaturalDocsDescriptionType_Code,\r
3213         NaturalDocsDescriptionType_DefinitionList,\r
3214 \r
3215         NaturalDocsDescriptionType_Count\r
3216 };\r
3217 \r
3218 const TCHAR*  NaturalDocsDescriptionTypeEnum_to_String( int in,  const TCHAR* in_OutOfRange );\r
3219 \r
3220 \r
3221  \r
3222 /***********************************************************************\r
3223   <<< [NaturalDocsDescriptionClass] >>> \r
3224 ************************************************************************/\r
3225 typedef struct _NaturalDocsDescriptionClass  NaturalDocsDescriptionClass;\r
3226 struct _NaturalDocsDescriptionClass {\r
3227         NaturalDocsDescriptionTypeEnum  Type;\r
3228 \r
3229         const TCHAR*  Start;\r
3230         const TCHAR*  Over;\r
3231 \r
3232         union {\r
3233                 void*                        Unknown;\r
3234                 NaturalDocsDefinitionClass*  Definition;\r
3235         } u;\r
3236 };\r
3237 \r
3238 void      NaturalDocsDescriptionClass_initConst( NaturalDocsDescriptionClass* self );\r
3239 errnum_t  NaturalDocsDescriptionClass_finalize( NaturalDocsDescriptionClass* self,  errnum_t e );\r
3240 \r
3241 \r
3242  \r
3243 /***********************************************************************\r
3244   <<< [NaturalDocsParserConfigClass] >>> \r
3245 ************************************************************************/\r
3246 typedef struct _NaturalDocsParserConfigClass  NaturalDocsParserConfigClass;\r
3247 struct _NaturalDocsParserConfigClass {\r
3248         bit_flags_fast32_t  Flags;  /*<NaturalDocsParserConfigEnum>*/\r
3249         TCHAR**             AdditionalKeywords;\r
3250         int                 AdditionalKeywordsLength;\r
3251         int                 AdditionalKeywordsEndsScopesFirstIndex;\r
3252         int                 AdditionalKeywordsEndsScopesLength;\r
3253 };\r
3254 typedef enum _NaturalDocsParserConfigEnum  NaturalDocsParserConfigEnum;\r
3255 enum _NaturalDocsParserConfigEnum {\r
3256         NaturalDocsParserConfig_AdditionalKeywords       = 0x0001,\r
3257         NaturalDocsParserConfig_AdditionalKeywordsLength = 0x0002,\r
3258         NaturalDocsParserConfig_AdditionalKeywordsEndsScopesFirstIndex = 0x0004,\r
3259         NaturalDocsParserConfig_AdditionalKeywordsEndsScopesLength     = 0x0008,\r
3260 };\r
3261 \r
3262 \r
3263  \r
3264 /***********************************************************************\r
3265   <<< [NaturalDocsHeaderClass] >>> \r
3266 ************************************************************************/\r
3267 typedef struct _NaturalDocsHeaderClass  NaturalDocsHeaderClass;\r
3268 struct _NaturalDocsHeaderClass {\r
3269         const TCHAR*  Keyword;  /* Has */\r
3270         const TCHAR*  KeywordStart;\r
3271         const TCHAR*  KeywordOver;\r
3272 \r
3273         const TCHAR*  Name;     /* Has */\r
3274         const TCHAR*  NameStart;\r
3275         const TCHAR*  NameOver;\r
3276 \r
3277         const TCHAR*  BriefNoIndent;\r
3278         const TCHAR*  Brief;    /* Has */\r
3279         const TCHAR*  BriefStart;\r
3280         const TCHAR*  BriefOver;\r
3281 \r
3282         const TCHAR*  ArgumentsLabel;\r
3283         Set2          Arguments;  /*<NaturalDocsDefinitionClass>*/ /* Has */\r
3284 \r
3285         const TCHAR*  ReturnValueLabel;\r
3286         const TCHAR*  ReturnValue; /* Has */\r
3287         const TCHAR*  ReturnValueStart;\r
3288         const TCHAR*  ReturnValueOver;\r
3289 \r
3290         const TCHAR*  Descriptions; /* Has */\r
3291         const TCHAR*  DescriptionsStart;\r
3292         const TCHAR*  DescriptionsOver;\r
3293 \r
3294         Set2          DescriptionItems;  /*<NaturalDocsDescriptionClass>*/ /* Has */\r
3295 };\r
3296 \r
3297 void      NaturalDocsHeaderClass_initConst( NaturalDocsHeaderClass* self );\r
3298 errnum_t  NaturalDocsHeaderClass_finalize( NaturalDocsHeaderClass* self,  errnum_t e );\r
3299 \r
3300 errnum_t  ParseNaturalDocsComment( const TCHAR* in_SourceStart, const TCHAR* in_SourceOver,\r
3301         NaturalDocsHeaderClass** out_NaturalDocsHeader,  NaturalDocsParserConfigClass* config );\r
3302 \r
3303 \r
3304  \r
3305 /***********************************************************************\r
3306   <<< [NaturalCommentClass] >>> \r
3307 ************************************************************************/\r
3308 typedef struct _NaturalCommentClass  NaturalCommentClass;\r
3309 struct _NaturalCommentClass {\r
3310 \r
3311         /* <Inherit parent="SyntaxNodeClass"> */\r
3312         const ClassID_Class*         ClassID;\r
3313         const FinalizerVTableClass*  FinalizerVTable;\r
3314         const TCHAR*                 Start;\r
3315         const TCHAR*                 Over;\r
3316         const PrintXML_VTableClass*  PrintXML_VTable;\r
3317         SyntaxNodeClass*             Parent;\r
3318         ListElementClass             SubNodeListElement;  /* for ".Parent" */\r
3319         ListClass                    SubNodeList;\r
3320         ListElementClass             ListElement;  /* Next and previous in source file */\r
3321         /* </Inherit> */\r
3322 \r
3323         int   StartLineNum;\r
3324         int   LastLineNum;\r
3325         NaturalDocsHeaderClass*  NaturalDocsHeader;\r
3326         NaturalCommentClass*     ParentComment;\r
3327 };\r
3328 \r
3329 extern const ClassID_Class  g_NaturalCommentClass_ID;\r
3330 void      NaturalCommentClass_initConst( NaturalCommentClass* self );\r
3331 errnum_t  NaturalCommentClass_finalize( NaturalCommentClass* self, errnum_t e );\r
3332 errnum_t  NaturalCommentClass_printXML( NaturalCommentClass* self, FILE* OutputStream );\r
3333 \r
3334 \r
3335 errnum_t  MakeNaturalComments_C_Language( ListClass* /*<C_LanguageTokenClass*>*/ TokenList,\r
3336         LineNumberIndexClass*  LineNumbers,\r
3337         ListClass* /*<NaturalCommentClass*>*/ TopSyntaxNodeList,\r
3338         NaturalDocsParserConfigClass* config );\r
3339 \r
3340 \r
3341  \r
3342 /***********************************************************************\r
3343   <<< [Parse_C_Language] >>> \r
3344 ************************************************************************/\r
3345 errnum_t  LexicalAnalize_C_Language( const TCHAR* Text,\r
3346         ListClass* /*<C_LanguageTokenClass*>*/ TokenList );\r
3347 errnum_t  CutComment_C_LanguageToken( ListClass* /*<C_LanguageTokenClass*>*/ TokenList );\r
3348 errnum_t  Delete_C_LanguageToken( ListClass* /*<C_LanguageTokenClass*>*/ TokenList, errnum_t e );\r
3349  \r
3350 errnum_t  CutCommentC_1( const TCHAR*  in_InputPath,  const TCHAR*  in_OutputPath );\r
3351 errnum_t  CopyWithoutComment_C_Language( ListClass*  in_Tokens,  TCHAR*  in_Text,  FILE*  in_OutStream );\r
3352  \r
3353 /*=================================================================*/\r
3354 /* <<< [PlatformSDK_plus/PlatformSDK_plus.h] >>> */ \r
3355 /*=================================================================*/\r
3356  \r
3357 #if  __cplusplus\r
3358  extern "C" {  /* Start of C Symbol */ \r
3359 #endif\r
3360 \r
3361 \r
3362  \r
3363 int  GetCommandLineUnnamed( int Index1, TCHAR* out_AParam, size_t AParamSize ); \r
3364 int  GetCommandLineNamed( const TCHAR* Name, bool bCase, TCHAR* out_Value, size_t ValueSize );\r
3365 int  GetCommandLineNamedC8( const TCHAR* Name, bool bCase, char* out_Value, size_t ValueSize );\r
3366 int  GetCommandLineNamedI( const TCHAR* Name, bool bCase, int* out_Value );\r
3367 bool GetCommandLineExist( const TCHAR* Name, bool bCase );\r
3368 \r
3369 #if ! _UNICODE\r
3370         #define  GetCommandLineNamedC8  GetCommandLineNamed\r
3371 #endif\r
3372 \r
3373  \r
3374 errnum_t  GetProcessInformation( DWORD  in_ProcessID,  PROCESSENTRY32*  out_Info );\r
3375  \r
3376 /* [CloseHandleInFin] */ \r
3377 #if ENABLE_ERROR_BREAK_IN_ERROR_CLASS\r
3378         #define  CloseHandleInFin( h, e ) \\r
3379                 ( \\r
3380                         ( (h) == INVALID_HANDLE_VALUE || (h) == NULL ||  CloseHandle( h ) )  ? \\r
3381                         (e)  : \\r
3382                         ( \\r
3383                                 ( OnRaisingError_Sub((const char*)__FILE__,__LINE__) )  ? \\r
3384                                 (DebugBreakR(), E_OTHERS)  : \\r
3385                                 (E_OTHERS) \\r
3386                         ) \\r
3387                 )\r
3388 #else\r
3389         #define  CloseHandleInFin( h, e ) \\r
3390                 ( \\r
3391                         ( (h) == INVALID_HANDLE_VALUE || (h) == NULL ||  CloseHandle( h ) )  ? \\r
3392                         (e)  : \\r
3393                         (E_OTHERS) \\r
3394                 )\r
3395 #endif\r
3396 \r
3397 \r
3398  \r
3399 /* [env] */ \r
3400 #define  env( Str, StrSize, Input ) \\r
3401         env_part( Str, StrSize, Str, NULL, Input )\r
3402 int  env_part( TCHAR* Str,  unsigned StrSize,  TCHAR* StrStart, TCHAR** out_StrLast,\r
3403          const TCHAR* Input );\r
3404 int  env_malloc( TCHAR** out_Value, size_t* out_ValueLen, const TCHAR* Name );\r
3405 \r
3406 \r
3407  \r
3408 #if  __cplusplus\r
3409  }  /* End of C Symbol */ \r
3410 #endif\r
3411  \r
3412 /*=================================================================*/\r
3413 /* <<< [Global0/Global0.h] >>> */ \r
3414 /*=================================================================*/\r
3415  \r
3416 #if  __cplusplus\r
3417  extern "C" {  /* Start of C Symbol */ \r
3418 #endif\r
3419 \r
3420 \r
3421  \r
3422 /***********************************************************************\r
3423   <<< [Globals] >>> \r
3424 ************************************************************************/\r
3425 #define  USE_GLOBALS  1\r
3426 \r
3427 void Globals_initConst(void);\r
3428 int  Globals_initialize(void);\r
3429 int  Globals_finalize( int e );\r
3430 \r
3431 #if NDEBUG\r
3432   #define  get_InitedObject( m, isInited )  (m)\r
3433 #else\r
3434   #define  get_InitedObject( m, isInited )  ( isInited( m ) ? (m) : (DebugBreakR(), (m)) )\r
3435 #endif\r
3436 \r
3437 \r
3438  \r
3439 #if  __cplusplus\r
3440  }  /* End of C Symbol */ \r
3441 #endif\r
3442  \r
3443 #endif  // __CLIB_H \r
3444 \r
3445 #ifdef _MSC_VER\r
3446  #if  showIncludes\r
3447   #pragma message( "end of #include  \"" __FILE__ "\"" )\r
3448  #endif\r
3449 #endif\r
3450  \r