home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Internet 2000 May / MICD_2000_05.iso / CBuilder5 / INSTALL / DATA1.CAB / Program_Built_Files / Include / Vcl / sysclass.h < prev    next >
C/C++ Source or Header  |  2000-02-01  |  12KB  |  505 lines
  1. // SYSCLASS.H: Definitions of Pascal types
  2. // Copyright (c) 1997, 1999 Borland International
  3.  
  4. #if !defined(SYSCLASS_H)
  5. #define SYSCLASS_H
  6.  
  7. #if !defined(SystemHPP)
  8. #error Do not include this file directly.  Include 'system.hpp'.
  9. #endif
  10.  
  11. #if !defined(SYSMAC_H)
  12. #include <sysmac.h>
  13. #endif
  14.  
  15. // VCL_IOSTREAM: This macro enables the i/ostream insertion/extraction operators of VCL
  16. //               classes. The operators are otherwise hidden to cut down on the amount
  17. //               of lines (i.e. symbols) that must be compiled. (The redefinition of
  18. //               i/ostream as templates in the Standard Library made these headers
  19. //               fairly significant).
  20. //
  21. // If <iostream.h> has already been included, then expose the VCL insertion/extraction operators.
  22. //
  23. #if defined(__STD_IOSTREAM__)
  24. #define VCL_IOSTREAM
  25. using namespace std;
  26. #elif defined(VCL_IOSTREAM) && !defined(__STD_IOSTREAM__)
  27. #include <iostream.h>
  28. #endif
  29.  
  30. #if !defined(DSTRING_H)
  31. #include <dstring.h>
  32. #endif
  33. #if !defined(WSTRING_H)
  34. #include <wstring.h>
  35. #endif
  36.  
  37. #if !defined(SYSTOBJ_H)
  38. #include <systobj.h>
  39. #endif
  40.  
  41. #if !defined(SYSTDATE_H)
  42. #include <systdate.h>
  43. #endif
  44.  
  45. #if !defined(SYSCURR_H)
  46. #include <syscurr.h>
  47. #endif
  48.  
  49. #if !defined(SYSCOMP_H)
  50. #include <syscomp.h>
  51. #endif
  52.  
  53. #if !defined(SYSSET_H)
  54. #include <sysset.h>
  55. #endif
  56.  
  57. #if !defined(SYSMAC_H)
  58. #include <sysmac.h>
  59. #endif
  60.  
  61. #if !defined(SYSTVAR_H)
  62. #include <systvar.h>
  63. #endif
  64.  
  65. #if !defined(SYSDYN_H)
  66. #include <sysdyn.h>
  67. #endif
  68.  
  69. #if !defined(SYSOPEN_H)
  70. #include <sysopen.h>
  71. #endif
  72.  
  73. #if !defined(SYSTOBJ_H)
  74. #include <systobj.h>
  75. #endif
  76.  
  77. #if !defined(SYSVARI_H)
  78. #include <sysvari.h>
  79. #endif
  80.  
  81. #pragma option push -w-inl -w-lvc
  82.  
  83. namespace System
  84. {
  85.   class PACKAGE TVarArrayBound
  86.   {
  87.   public:
  88.     Integer ElementCount;
  89.     Integer LowBound;
  90.   };
  91.  
  92.   class PACKAGE TVarArray
  93.   {
  94.   public:
  95.     Word DimCount;
  96.     Word Flags;
  97.     Integer ElementSize;
  98.     Integer LockCount;
  99.     Pointer Data;
  100.     TVarArrayBound Bounds[256] /* [0..255] */;
  101.   };
  102.  
  103.   typedef class TMemoryManager *PMemoryManager;
  104.  
  105.   class PACKAGE TMemoryManager
  106.   {
  107.   public:
  108.     Pointer __fastcall (*GetMem)(Integer Size);
  109.     Integer __fastcall (*FreeMem)(Pointer P);
  110.     Pointer __fastcall (*ReallocMem)(Pointer P, Integer Size);
  111.   } ;
  112.  
  113.   class PACKAGE THeapStatus
  114.   {
  115.   public:
  116.     Cardinal TotalAddrSpace;
  117.     Cardinal TotalUncommitted;
  118.     Cardinal TotalCommitted;
  119.     Cardinal TotalAllocated;
  120.     Cardinal TotalFree;
  121.     Cardinal FreeSmall;
  122.     Cardinal FreeBig;
  123.     Cardinal Unused;
  124.     Cardinal Overhead;
  125.     Cardinal HeapErrorCode;
  126.   } ;
  127.  
  128.     typedef Integer __fastcall (*TThreadFunc)(Pointer Parameter);
  129.  
  130.     // Inspector Query
  131.     struct THeapBlock
  132.     {
  133.         void         *Start;
  134.         unsigned int Size;
  135.     };
  136.     // Inspector Query
  137.  
  138. #ifdef BCBVER1
  139.   #define USEDATAMODULE(FileName, DataModuleName)  \
  140.     class DELPHICLASS T##DataModuleName;       \
  141.     extern T##DataModuleName *DataModuleName;
  142. #else
  143.   #define USEDATAMODULE(FileName, DataModuleName)  \
  144.     class DELPHICLASS T##DataModuleName;       \
  145.     extern PACKAGE T##DataModuleName *DataModuleName;
  146. #endif
  147.  
  148. #ifdef BCBVER1
  149.   #define USEDATAMODULENS(FileName, UnitName, DataModuleName)  \
  150.     namespace UnitName {         \
  151.     class DELPHICLASS T##DataModuleName;       \
  152.     extern T##DataModuleName *DataModuleName;              \
  153.    };               \
  154.    using namespace UnitName
  155. #else
  156.   #define USEDATAMODULENS(FileName, UnitName, DataModuleName)  \
  157.     namespace UnitName {         \
  158.     class DELPHICLASS T##DataModuleName;       \
  159.     extern PACKAGE T##DataModuleName *DataModuleName;              \
  160.     };               \
  161.     using namespace UnitName
  162. #endif
  163.  
  164. #ifdef BCBVER1
  165.   #define USEFORM(FileName, FormName) \
  166.     class DELPHICLASS T##FormName;       \
  167.     extern T##FormName *FormName;
  168. #else
  169.   #define USEFORM(FileName, FormName) \
  170.     class DELPHICLASS T##FormName;       \
  171.     extern PACKAGE T##FormName *FormName;
  172. #endif
  173.  
  174. #define USEFORMRES(FileName, FormName, AncestorName) \
  175.    extern PACKAGE DummyThatIsNeverReferenced
  176.  
  177. #ifdef BCBVER1
  178.   #define USEFORMNS(FileName, UnitName, FormName) \
  179.     namespace UnitName {         \
  180.     class DELPHICLASS T##FormName;       \
  181.     extern T##FormName *FormName;          \
  182.     };               \
  183.     using namespace UnitName
  184. #else
  185.   #define USEFORMNS(FileName, UnitName, FormName) \
  186.     namespace UnitName {         \
  187.     class DELPHICLASS T##FormName;       \
  188.     extern PACKAGE T##FormName *FormName;          \
  189.     };               \
  190.     using namespace UnitName
  191. #endif
  192.  
  193. #define USEUNIT(ModName) \
  194.    extern PACKAGE DummyThatIsNeverReferenced
  195.  
  196. #define USEOBJ(FileName) \
  197.    extern PACKAGE DummyThatIsNeverReferenced
  198.  
  199. #define USERC(FileName) \
  200.    extern PACKAGE DummyThatIsNeverReferenced
  201.  
  202. #define USEASM(FileName) \
  203.    extern PACKAGE DummyThatIsNeverReferenced
  204.  
  205. #define USEDEF(FileName) \
  206.    extern PACKAGE DummyThatIsNeverReferenced
  207.  
  208. #define USERES(FileName) \
  209.    extern PACKAGE DummyThatIsNeverReferenced
  210.  
  211. #define USETLB(FileName) \
  212.    extern PACKAGE DummyThatIsNeverReferenced
  213.  
  214. #define USELIB(FileName) \
  215.    extern PACKAGE DummyThatIsNeverReferenced
  216.  
  217. #define USEFILE(FileName) \
  218.    extern PACKAGE DummyThatIsNeverReferenced
  219.  
  220. #define USEPACKAGE(FileName) \
  221.    extern PACKAGE DummyThatIsNeverReferenced
  222.  
  223. #define USEIDL(FileName) \
  224.    extern PACKAGE DummyThatIsNeverReferenced
  225.  
  226. #define USE(FileName, ContainerId) \
  227.    extern PACKAGE DummyThatIsNeverReferenced
  228.  
  229.   struct PACKAGE ResourceString
  230.   {
  231.     HINSTANCE       *hinstance;
  232.     unsigned long   id;                     // resource string id
  233.   };
  234.  
  235.   struct PACKAGE TModuleUnloadRec
  236.   {
  237.     TModuleUnloadRec    *next;
  238.     TModuleUnloadProc   *proc;
  239.   };
  240.   typedef TModuleUnloadRec *PModuleUnloadRec;
  241.  
  242.   struct PACKAGE TLibModule
  243.   {
  244.     TLibModule  *next;
  245.     long        instance;
  246.     long        codeinstance;
  247.     long        datainstance;   
  248.     long        resinstance;
  249.     long        reserved;
  250.   };
  251.  
  252.   struct PACKAGE TResStringRec
  253.   {
  254.     long        *module;
  255.     long        ident;
  256.   };
  257.   typedef TResStringRec *PResStringRec;
  258.  
  259.   // always get statically from vcleXX.lib
  260.   extern AnsiString __fastcall LoadResourceString(ResourceString const * const rsrc);
  261.  
  262.   // always get statically from vcleXX.lib
  263.   extern void __fastcall CheckSafecallResult(HRESULT hr);
  264.  
  265.   // always get statically from vcleXX.lib
  266.   extern void * __fastcall FindDynaInst(void * vmt, int ID);
  267.  
  268. } // namespace System
  269. using namespace System;
  270.  
  271. #if 0
  272. namespace Typinfo
  273. {
  274.   struct  TTypeInfo;
  275.   typedef TTypeInfo *PTypeInfo;
  276. }
  277.  
  278. namespace Controls
  279. {
  280.   typedef System::TDateTime TDate;
  281.   typedef System::TDateTime TTime;
  282. }
  283. #endif
  284.  
  285. // Define VCL_IOSTREAM operators
  286. //
  287. #if defined(VCL_IOSTREAM)
  288.  
  289. namespace System
  290. {
  291.   inline void read_to_delim(istream& strm, char delim, AnsiString& str)
  292.   {
  293.     char ch;
  294.     int nchars = 0;
  295.     char array[4096];
  296.     int capacity = sizeof array;
  297.  
  298.     while ( 1 )
  299.     {
  300.  
  301.       // Read as many characters as we can, up to the delimiter:
  302.       strm.get( array+nchars, capacity-nchars+1, delim );
  303.  
  304.       // This is the new string length:
  305.       nchars += strlen( array+nchars );
  306.  
  307.       // What stopped us?  An EOF?
  308.       if ( !strm.good() )
  309.         break;      // EOF encountered (or worse!)
  310.  
  311.       // Nope.  Was it the delimiter?
  312.       strm.get(ch);
  313.       if (ch==delim)
  314.         break;  // Yup. We're done.  Don't put it back on the stream.
  315.       else
  316.         strm.putback(ch); // Nope, Put it back and keep going.
  317.  
  318.     }
  319.     str = array;
  320.   }
  321.  
  322.   inline istream& operator >> (istream& is, AnsiString& arg)
  323.   {
  324.     read_to_delim(is, 0, arg);
  325.     return is;
  326.   }
  327.  
  328.   inline ostream& operator << (ostream& os, const AnsiString& arg)
  329.   {
  330.     return os << arg.c_str();
  331.   }
  332.  
  333.   template <unsigned char sz>
  334.   inline ostream& operator << (ostream& os, const SmallString<sz>& arg)
  335.   {
  336.     os << AnsiString(arg).c_str();
  337.     return os;
  338.   }
  339.  
  340.   template <unsigned char sz>
  341.   inline istream& operator >> (istream& is, SmallString<sz>& arg)
  342.   {
  343.     AnsiString s;
  344.     is >> s;
  345.     arg = s;
  346.     return is;
  347.   }
  348.  
  349.  
  350.   // Currency IOStream operators
  351.   //
  352.   inline ostream& operator << (ostream& os, const Currency& arg)
  353.   {
  354.     os << AnsiString(arg);
  355.     return os;
  356.   }
  357.  
  358.   inline istream& operator >> (istream& is, Currency& arg)
  359.   {
  360.     AnsiString s;
  361.     is >> s;
  362.     arg = s;
  363.     return is;
  364.   }
  365.  
  366.  
  367.   // TDateTime IOStream operators
  368.   //
  369.   inline ostream& operator << (ostream& os, const TDateTime& arg)
  370.   {
  371.     os << AnsiString(arg);
  372.     return os;
  373.   }
  374.  
  375.   inline istream& operator >> (istream& is, TDateTime& arg)
  376.   {
  377.     AnsiString s;
  378.     is >> s;
  379.     arg = s;
  380.     return is;
  381.   }
  382.  
  383.  
  384.   // Variant IOStream operators
  385.   //
  386.   inline ostream& operator <<(ostream& os, const Variant& arg)
  387.   {
  388.     switch (arg.VType)
  389.     {
  390.     case varEmpty:
  391.       os << "varEmpty";
  392.       break;
  393.     case varNull:
  394.       os << "varNull";
  395.       break;
  396.     case varSmallint:
  397.       os << "varSmallint: " << arg.VSmallint;
  398.       break;
  399.     case varInteger:
  400.       os << "varInteger: " << arg.VInteger;
  401.       break;
  402.     case varSingle:
  403.       os << "varSingle: " << arg.VSingle;
  404.       break;
  405.     case varDouble:
  406.       os << "varDouble: " << arg.VDouble;
  407.       break;
  408.     case varCurrency:
  409.       os << "varCurrency: " << arg.VCurrency;
  410.       break;
  411.     case varDate:
  412.       os << "varDate: " << arg.VDate;
  413.       break;
  414.     case varOleStr:
  415.       os << "varOleStr: " << AnsiString(arg.VOleStr);
  416.       break;
  417.     case varDispatch:
  418.       // workaround compiler bug: can't use static_cast with incomplete type
  419.       os << "varDispatch: " << (void*)arg.VDispatch;
  420.       break;
  421.     case varError:
  422.       os << "varError: " << arg.VError;
  423.       break;
  424.     case varBoolean:
  425.       os << "varBoolean: " << arg.operator bool();
  426.       break;
  427.     case varUnknown:
  428.       // workaround compiler bug: can't use static_cast with incomplete type
  429.       os << "varUnknown: " << (void*)arg.VUnknown;
  430.       break;
  431.     case varByte:
  432.       os << "varByte: " << arg.VByte;
  433.       break;
  434.     case varString:
  435.       os << "varString: " << arg.operator AnsiString();
  436.       break;
  437.     case varArray:
  438.       os << "varArray: " << static_cast<void*>(arg.VArray);
  439.       break;
  440.     case varSmallint | varByRef:
  441.       os << "varSmallint | varByRef: " << arg.VPointer;
  442.       break;
  443.     case varInteger | varByRef:
  444.       os << "varInteger | varByRef: " << arg.VPointer;
  445.       break;
  446.     case varSingle | varByRef:
  447.       os << "varSingle | varByRef: " << arg.VPointer;
  448.       break;
  449.     case varDouble | varByRef:
  450.       os << "varDouble | varByRef: " << arg.VPointer;
  451.       break;
  452.     case varCurrency | varByRef:
  453.       os << "varCurrency | varByRef: " << arg.VPointer;
  454.       break;
  455.     case varDate | varByRef:
  456.       os << "varDate | varByRef: " << arg.VPointer;
  457.       break;
  458.     case varOleStr | varByRef:
  459.       os << "varOleStr | varByRef: " << arg.VPointer;
  460.       break;
  461.     case varDispatch | varByRef:
  462.       os << "varDispatch | varByRef: " << arg.VPointer;
  463.       break;
  464.     case varError | varByRef:
  465.       os << "varError | varByRef: " << arg.VPointer;
  466.       break;
  467.     case varBoolean | varByRef:
  468.       os << "varBoolean | varByRef: " << arg.VPointer;
  469.       break;
  470.     case varUnknown | varByRef:
  471.       os << "varUnknown | varByRef: " << arg.VPointer;
  472.       break;
  473.     case varByte | varByRef:
  474.       os << "varByte | varByRef: " << arg.VPointer;
  475.       break;
  476.     case varString | varByRef:
  477.       os << "varString | varByRef: " << arg.VPointer;
  478.       break;
  479.     case varArray | varByRef:
  480.       os << "varArray | varByRef: " << arg.VPointer;
  481.       break;
  482.     }
  483.     return os;
  484.   }
  485. }       // namespace System
  486. #endif  // VCL_IOSTREAM
  487.  
  488.  
  489. #pragma option pop
  490.  
  491. // Undo the MACROs which mapped the Automation related types to their tagStruct.
  492. //
  493. #if defined(CURRENCY)
  494. #undef CURRENCY
  495. #endif
  496. #if defined(SAFEARRAY)
  497. #undef SAFEARRAY
  498. #endif
  499. #if defined(VARIANT)
  500. #undef  VARIANT
  501. #endif
  502.  
  503. #endif
  504.  
  505.