home *** CD-ROM | disk | FTP | other *** search
/ Total C++ 2 / TOTALCTWO.iso / borland / services.pak / DEFS.H < prev    next >
C/C++ Source or Header  |  1997-05-06  |  10KB  |  374 lines
  1. //----------------------------------------------------------------------------
  2. // Borland Services Library
  3. // Copyright (c) 1993, 1997 by Borland International, All Rights Reserved
  4. //
  5. //$Revision:   5.9  $
  6. //
  7. //----------------------------------------------------------------------------
  8. #if !defined(SERVICES_DEFS_H)
  9. #define SERVICES_DEFS_H
  10.  
  11. #if !defined(__cplusplus)
  12. # error Must compile Borland Services Library as C++
  13. #endif
  14.  
  15. #if !defined(__TCHAR_H)
  16. # include <tchar.h>
  17. #endif
  18.  
  19. //----------------------------------------------------------------------------
  20. // We must use all libraries in DLLs if we are using SVCS in a DLL
  21. //
  22. // Define _SVCSDLL with -WSE (-WE for 32bit) to use SVCS & RTL in dlls.
  23. //
  24. // Be sure _BUILDSVCSDLL is defined when building an actual SVCS dll
  25. //
  26. #if defined(_SVCSDLL) || defined(_BUILDSVCSDLL)
  27. # if !defined(_SVCSDLL)
  28. #   define _SVCSDLL
  29. # endif
  30. # if !defined(_RTLDLL)
  31. #   define _RTLDLL
  32. # endif
  33. #endif
  34.  
  35. //
  36. // Include the appropriate compiler-specific header based on known compiler
  37. // defined preprocessor constants
  38. //
  39. #if defined(__BORLANDC__)
  40. # include <services/borlandc.h>
  41.  
  42. #elif defined(_MSC_VER)
  43. # include <services/msc.h>
  44.  
  45. #else
  46. # error Unknown compiler
  47. #endif
  48.  
  49. //
  50. // Get core RTL definitions
  51. //
  52. #if defined(BI_COMP_BORLANDC)
  53. # include <_defs.h>                   // Borland RTL core definitions
  54. #else
  55. # include <services/private/defs.h>   // General purpose definitions
  56. #endif
  57.  
  58. //----------------------------------------------------------------------------
  59. // OS-specific flags.
  60. //
  61.  
  62. //
  63. //  Need to do some special stuff when the OS doesn't support
  64. //  per-instance data in DLLs.
  65. //
  66. #if defined(BI_PLAT_WIN16)
  67. # define BI_NO_PER_INSTANCE_DATA
  68. #endif
  69.  
  70. //
  71. //  Sometimes we need to know if we're building for Windows 3.0.
  72. //
  73. #if defined(BI_PLAT_WIN16) && defined(WINVER) && WINVER < 0x030A
  74. # define BI_IS_WIN30
  75. #endif
  76.  
  77. //
  78. //  Windows 3.1 provides functions to read and write huge buffers.
  79. //
  80. #if defined(BI_PTR_16_16) && !defined(BI_IS_WIN30)
  81. # define BI_HAS_HREADWRITE
  82. #endif
  83.  
  84. //
  85. //  Under Windows 3.0 WEPs are seriously broken.
  86. //
  87. #if defined(BI_IS_WIN30)
  88. # define BI_WINDOWS_WEP_BUG
  89. #endif
  90.  
  91. //----------------------------------------------------------------------------
  92. // _RTTI provides a convenient macro for switching on Borland's __rtti
  93. // keyword for finer grained control over generation of runtime type
  94. // information.
  95. //
  96.  
  97. #if defined(BI_NO_RTTI)
  98. # define _RTTI
  99. #else
  100. # define _RTTI __rtti
  101. #endif
  102.  
  103. //----------------------------------------------------------------------------
  104. //  These CAST macros encapsulate the new cast syntax in the ANSI/ISO
  105. //  working paper. Note that TYPESAFE_DOWNCAST isn't as general as
  106. //  dynamic_cast -- it only works on pointers.
  107. //
  108. //  Usage:
  109. //
  110. //  TYPESAFE_DOWNCAST(object,toClass)
  111. //      Converts the pointer referred to by 'object' into a pointer to
  112. //      an object of type 'toClass'. Note that the macro parameters to
  113. //      TYPESAFE_DOWNCAST are in the opposite order from the rest of
  114. //      the macros here. When using a compiler that supports new style
  115. //      casts and runtime type information this is done with
  116. //      dynamic_cast<> and will return 0 if the cast cannot be done.
  117. //      When using a compiler that does not support new style casts and
  118. //      runtime type information this is done with fake runtime type
  119. //      information generated by the IMPLEMENT_CASTABLE macro.
  120. //
  121. //  STATIC_CAST(targetType,object)
  122. //      Converts the data object referred to by 'object' into the type
  123. //      referred to by 'targetType'. When using a compiler that supports
  124. //      new style casts, this is done with static_cast<> and will fail
  125. //      if the cast cannot be done without runtime type information.
  126. //      When using a compiler that does not support new style casts, this
  127. //      is done with an old style dangerous cast.
  128. //
  129. //  CONST_CAST(targetType,object)
  130. //      Converts the data object referred to by 'object' into the type
  131. //      referred to by 'targetType'. When using a compiler that supports
  132. //      new style casts, this is done with const_cast<> and will fail
  133. //      if the cast changes the type of the object in any way other than
  134. //      adding or removing const and volatile qualifiers.
  135. //      When using a compiler that does not support new style casts, this
  136. //      is done with an old style dangerous cast.
  137. //
  138. //  REINTERPRET_CAST(targetType,object)
  139. //      Converts the data object referred to by 'object' into the type
  140. //      referred to by 'targetType'. When using a compiler that supports
  141. //      new style casts, this is done with reinterpret_cast<>.
  142. //      When using a compiler that does not support new style casts, this
  143. //      is done with an old style dangerous cast.
  144. //
  145.  
  146. #if defined( BI_NO_NEW_CASTS )
  147. # define TYPESAFE_DOWNCAST(object,toClass)\
  148.         (object ?(toClass *)(object)->FindBase(#toClass) : 0)
  149. # define STATIC_CAST(targetType,object)   \
  150.         ((targetType)(object))
  151. # define CONST_CAST(targetType,object)    \
  152.         ((targetType)(object))
  153. # define REINTERPRET_CAST(targetType,object) \
  154.         (*(targetType*)(void *)&(object))
  155. #else
  156. # define TYPESAFE_DOWNCAST(object,toClass)\
  157.         dynamic_cast<toClass * >(object)
  158. # define STATIC_CAST(targetType,object)   \
  159.         static_cast<targetType >(object)
  160. # define CONST_CAST(targetType,object)    \
  161.         const_cast<targetType >(object)
  162. # define REINTERPRET_CAST(targetType,object) \
  163.         reinterpret_cast<targetType >(object)
  164. #endif
  165.  
  166. //----------------------------------------------------------------------------
  167. // Provide expansions for mutable and bool when appropriate.
  168. //
  169.  
  170. #if defined(BI_NO_MUTABLE)
  171. # define mutable
  172. #endif
  173.  
  174. #if defined(BI_NAMESPACE)
  175. namespace ClassLib {
  176. #endif
  177.  
  178. #if defined(BI_NO_BOOL)
  179. enum TBool {
  180.   false,
  181.   true
  182. };
  183.  
  184. # if defined(EMULATE_BOOL)
  185.     typedef TBool bool;
  186. #   define BI_UNIQUE_BOOL
  187. # else
  188.     typedef int bool;
  189. #   undef BI_UNIQUE_BOOL
  190. # endif
  191.  
  192. #else
  193.   typedef bool TBool;
  194. # define BI_UNIQUE_BOOL
  195.  
  196. #endif
  197.  
  198. #if defined(BI_NO_BOOL) && defined(EMULATE_BOOL)
  199.   template<class T> inline bool ToBool(const T& t) {
  200.     return STATIC_CAST(bool,(t!=0));
  201.   }
  202. #else
  203.   template<class T> inline bool ToBool(const T& t) {
  204.     return STATIC_CAST(bool,t);
  205.   }
  206. #endif
  207.  
  208. // end of emulated bool types
  209. //
  210. #if defined(BI_NAMESPACE)
  211. }     // namespace ClassLib
  212. #endif
  213.  
  214. //
  215. // Shorthand 'far' keyword evaluates to __far when needed & supported, else
  216. // nothing. Same with 'huge' and 'HUGE'
  217. //
  218. #if !defined(far)
  219. # if defined(BI_PTR_0_32)
  220. #   define far
  221. # else
  222. #   define far __far
  223. # endif
  224. #endif
  225. #if !defined(huge)
  226. # if defined(BI_PTR_0_32)
  227. #   define huge
  228. # else
  229. #   define huge __huge
  230. # endif
  231. #endif
  232. #if !defined(HUGE)
  233. # if defined(BI_PTR_0_32)
  234. #   define HUGE
  235. # else
  236. #   define HUGE __huge
  237. # endif
  238. #endif
  239.  
  240. //
  241. // Commonly used fixed-size integer types
  242. //
  243. #if defined(BI_COMP_BORLANDC)
  244. # include <systypes.h>
  245. #else
  246. # if defined(BI_NAMESPACE)
  247.   namespace ClassLib {
  248. # endif
  249.  
  250.   typedef signed char    int8;
  251.   typedef signed short   int16;
  252.   typedef signed long    int32;
  253.  
  254.   typedef unsigned char  uint8;
  255.   typedef unsigned short uint16;
  256.   typedef unsigned long  uint32;
  257.  
  258. # if defined(BI_NAMESPACE)
  259.   }     // namespace ClassLib
  260. # endif
  261. #endif
  262.  
  263.  
  264. #if defined(BI_NAMESPACE)
  265. namespace ClassLib {
  266. #endif
  267. //
  268. // Some nonfixed-size types defined similar to the fixedsize in systypes.h
  269. //
  270.  
  271. typedef unsigned long  ulong;
  272. typedef unsigned int   uint;
  273. typedef unsigned short ushort;
  274. typedef _TUCHAR uchar;
  275.  
  276. //
  277. // Integer byte, word and long word manipulation
  278. //
  279. inline uint16 MkUint16(uint8 lo, uint8 hi) {
  280.   return uint16(lo | (uint16(hi) << 8));
  281. }
  282. inline uint32 MkUint32(uint16 lo, uint16 hi) {
  283.   return lo | (uint32(hi) << 16);
  284. }
  285. inline uint16 LoUint16(uint32 u32) {
  286.   return uint16(u32);
  287. }
  288. inline int16 LoInt16(uint32 u32) {
  289.   return int16(u32);
  290. }
  291. inline uint16 HiUint16(uint32 u32) {
  292.   return uint16(u32 >> 16);
  293. }
  294. inline int16 HiInt16(uint32 u32) {
  295.   return int16(u32 >> 16);
  296. }
  297. inline uint8 LoUint8(uint16 u16) {
  298.   return uint8(u16);
  299. }
  300. inline int8 LoInt8(uint16 u16) {
  301.   return int8(u16);
  302. }
  303. inline uint8 HiUint8(uint16 u16) {
  304.   return uint8(u16 >> 8);
  305. }
  306. inline int8 HiInt8(uint16 u16) {
  307.   return int8(u16 >> 8);
  308. }
  309.  
  310. #if defined(BI_NAMESPACE)
  311. }     // namespace ClassLib
  312. #endif
  313.  
  314. //----------------------------------------------------------------------------
  315.  
  316. //
  317. // Define library-wide function calling conventions. Must rebuild everything
  318. // if changed, and must use appropriate modifier on derived classes.
  319. //
  320. #if !defined(_CALLCNVN)
  321. # if defined(BI_PLAT_OS2) || defined(BI_PLAT_WIN32) 
  322. #   define _CALLCNVN   //__stdcall
  323. # else
  324. #   if defined(_FASTTHIS)
  325. #     define _CALLCNVN __fastthis
  326. #   else
  327. #     define _CALLCNVN //__pascal
  328. #   endif
  329. # endif
  330. #endif
  331.  
  332. //
  333. // MSVC uses __declspecs, so just turn import/export into those
  334. //
  335. #if defined(BI_COMP_MSC)
  336. # define __export    __declspec(dllexport)
  337. # define __import    __declspec(dllimport)
  338. #endif
  339.  
  340. //----------------------------------------------------------------------------
  341. // Setup class, function and data modifier macros for Services
  342. //
  343. #if defined(_BUILDSVCSDLL)
  344. # define _SVCSCLASS     __export _CALLCNVN
  345. # define _SVCSCLASS_RTL __export
  346. # define _SVCSDATA      __export
  347. # define _SVCSFUNC      __export
  348. #elif defined(_SVCSDLL) && !defined(BI_PLAT_OS2)
  349. # define _SVCSCLASS     __import _CALLCNVN
  350. # define _SVCSCLASS_RTL __import
  351. # if defined(BI_PTR_0_32)
  352. #   define _SVCSDATA    __import
  353. #   define _SVCSFUNC    __import
  354. # else
  355. #   define _SVCSDATA    __far
  356. #   define _SVCSFUNC
  357. # endif
  358. #else
  359. # if defined(_SVCSFARVTABLE)
  360. #   define _SVCSCLASS   __huge _CALLCNVN
  361. # else
  362. #   define _SVCSCLASS   _CALLCNVN
  363. # endif
  364. # define _SVCSCLASS_RTL _EXPCLASS
  365. # define _SVCSDATA
  366. # define _SVCSFUNC
  367. #endif
  368.  
  369. #if defined(BI_NAMESPACE)
  370. using namespace ClassLib;
  371. #endif
  372.  
  373. #endif  // SERVICES_DEFS_H
  374.