mi32/stddefns.h

Go to the documentation of this file.

#ifndef INC_MI32_STDDEFNS_H
#define INC_MI32_STDDEFNS_H

#if !defined(USE_MGUI) && (defined(X_NATIVE) || defined(WINDOWS_MFC))
#define  USE_MGUI
#endif

#ifdef DEPRECATE_ALL
#undef   NO_DEPRECATED
#define  NO_DEPRECATED
#undef   DEPRECATE_GROUPKEY
#define  DEPRECATE_GROUPKEY
#undef   DEPRECATE_OLDHELP
#define  DEPRECATE_OLDHELP
#endif

// Undefine index macro defined on some Unix platforms
#ifdef index
#undef index
#endif

// Fix certain conflicting Windows macros if used.
#if defined(WIN32)
#include <mi32/winfixup.h>
#endif

#ifndef INC_MI32_DLLDEFNS_H
#include <mi32/dlldefns.h>
#endif

/*----------------------------------------------------------------------------*/
/*    Define platform definition for compatiblity with existing code          */
/*----------------------------------------------------------------------------*/

#if defined(WIN32) && !defined(WINNT)
   #define  WINNT
#endif

/*----------------------------------------------------------------------------*/
/*    Platform-specific byte-order definitions                                */
/*----------------------------------------------------------------------------*/

#if !defined(BYTEORDER_HiLo) && !defined(BYTEORDER_LoHi)
   #if defined(i386) || defined(LINUX_INTEL) || defined(WIN32) || defined(__x86_64__)
      #define  BYTEORDER_LoHi
   #else
      #define  BYTEORDER_HiLo
   #endif
#endif

#if !defined(BYTEORDER_Intel) && defined(BYTEORDER_LoHi)
   #define BYTEORDER_Intel
#endif

/*----------------------------------------------------------------------------*/
/*    Force compile errors for specific warnings                              */
/*----------------------------------------------------------------------------*/

#if defined(WIN32)
   #define DEPRECATED __declspec(deprecated)
   #define DEPRECATED_MSG(_msg) __declspec(deprecated(_msg))
   #ifdef NO_DEPRECATED
      #define WLEVEL error
   #else
      #define WLEVEL 3
   #endif
   // Microsoft visual C/C++ only
   #pragma warning (error:4002)     // too many actual parameters for macro
   #pragma warning (error:4003)     // not enough actual parameters for macro
   #pragma warning (error:4005)     // Macro defined twice
   #pragma warning (error:4013)     // Undefined function (missing prototype)
   #pragma warning (error:4028)     // Formal parameter different from declaration
   #pragma warning (error:4033)     // Function must return a value
   #pragma warning (error:4047)     // Different levels of indirection
   #pragma warning (error:4098)     // Void function returning a value
   #pragma warning (error:4129)     // Unrecognized character escape sequence
   #pragma warning (error:4131)     // Function uses old style declarator
   #pragma warning (error:4133)     // Incompatible types - from 'unsigned short *' to 'char *'
   #pragma warning (error:4150)     // Deletion of pointer to incomplete type
   #pragma warning (error:4152)     // Pointer to function converted to pointer to data
   #pragma warning (error:4172)     // Returning address of local or temporary
   // Next one commented out due to <xmemory> not compiling with it on
// #pragma warning (error:4217)     // 'operator' : member template functions cannot be used for copy-assignment or copy-construction
   #pragma warning (error:4218)     // Function does not have a return type
   #pragma warning (error:4258)     // Defintion from for loop is ignored, defintion from enclosing scope is used
   #pragma warning (error:4288)     // Loop variable used outside of loop
   #pragma warning (error:4305)     // Argument truncation from '...' to '...'
   #pragma warning (error:4309)     // Truncation of constant value
#ifdef WIN64
   #pragma warning (error:4311)     // Pointer truncation
#endif
   #pragma warning (error:4390)     // Empty control statement found, no point for it
   #pragma warning (error:4508)     // 'function' : function should return a value; 'void' return type assumed
#ifndef WINDOWS_MFC
   #pragma warning (error:4529)     // 'member_name' : forming a pointer-to-member requires explicit use of the address-of operator ('&') and a qualified name
#endif
   #pragma warning (error:4545)     // expression before comma evaluates to a function which is missing an argument list
   #pragma warning (error:4546)     // function call before comma missing argument list
   #pragma warning (error:4547)     // 'operator' : operator before comma has no effect; expected operator with side-effect
#if defined(WIN32) && defined(_MSC_VER) && (_MSC_VER < 1400)   // Stupid Microsoft header disallows this on VC 8
   #pragma warning (error:4548)     // expression before comma has no effect; expected expression with side-effect
#endif
   #pragma warning (error:4549)     // 'operator' : operator before comma has no effect; did you intend 'operator'?
#ifdef ALLOW_UNUSED_FUNCTIONS
   #pragma warning (3:4505)         // Local function not used
#else
   #pragma warning (error:4505)     // Local function not used
#endif
   #pragma warning (error:4551)     // Function call missing argument list
   #pragma warning (error:4552)     // Operator has no effect, expected operator with side effect
   #pragma warning (error:4553)     // '==' operator has no effect
   #pragma warning (error:4554)     // Check operator precedence
   #pragma warning (error:4700)     // Local variable used without having been initialized
   #pragma warning (error:4701)     // Local variable not initialized
   #pragma warning (error:4715)     // Not all control paths return a value
   #pragma warning (error:4717)     // 'method' : recursive on all control paths, function will cause runtime stack overflow.  Not all control paths return a value
// #pragma warning (error:4761)     // Integral size mismatch in argument
   #pragma warning (error:4804)     // Unsafe use of type 'bool' in operation
   #pragma warning (error:4805)     // Unsafe mix of types for bitwise operation
   #pragma warning (error:4806)     // Unsafe operation, no value of type 'bool can equal the given constant
#ifndef NO_WARN_UNREF_PARM
   #pragma warning (3:4100)         // Unreferenced formal parameter
#endif
   #pragma warning (3:4127)         // conditional expression is constant
   #pragma warning (3:4132)         // 'object' : const object should be initialized
   #pragma warning (3:4189)         // Local variable initialized but not referenced
   #pragma warning (3:4201)         // Nameless structure / union
   #pragma warning (3:4211)         // Redefine extern to static
   #pragma warning (WLEVEL:4212)    // Function declaration uses ellipsis, definition does not
   #pragma warning (WLEVEL:4222)    // 'static' used on member function at file scope
   #pragma warning (WLEVEL:4234)    // Keyword reserved for future use
   #pragma warning (WLEVEL:4235)    // Keyword not supported
   #pragma warning (3:4244)         // Conversion results in possible loss of data
   #pragma warning (3:4263)         // 'function' : member function does not override any base class virtual member function
   #pragma warning (3:4264)         // 'virtual_function' : no override available for virtual member function from base 'class'; function is hidden
   #pragma warning (3:4265)         // 'class' : class has virtual functions, but destructor is not virtual
   #pragma warning (3:4268)         // 'identifier' : 'const' static/global data initialized with compiler generated default constructor fills the object with zeros
   #pragma warning (WLEVEL:4287)    // 'operator' : unsigned/negative constant mismatch
   #pragma warning (3:4295)         // 'array' : array is too small to include a terminating null character
   #pragma warning (3:4296)         // 'operator' : expression is always false
   #pragma warning (3:4408)         // anonymous union did not declare any data members
   #pragma warning (3:4510)         // 'class' : default constructor could not be generated
   #pragma warning (WLEVEL:4515)    // 'namespace' : namespace uses itself
   #pragma warning (3:4527)         // instances of type 'class' can never be destroyed - user-defined destructor required
   #pragma warning (WLEVEL:4555)    // expression has no effect; expected expression with side-effect
   #pragma warning (3:4610)         // object 'class' can never be instantiated - user-defined constructor required
   // Next three commented out due to redundancy with error of actually using a ctor(), copy ctor() or op=()
// #pragma warning (3:4623)         // 'derived class' : default constructor could not be generated because a base class default constructor is inaccessible
// #pragma warning (3:4625)         // 'derived class' : copy constructor could not be generated because a base class copy constructor is inaccessible
// #pragma warning (3:4626)         // 'derived class' : assignment operator could not be generated because a base class assignment operator is inaccessible
// #pragma warning (3:4640)         // 'instance' : construction of local static object is not thread-safe
   #pragma warning (3:4702)         // Unreachable code
   #pragma warning (3:4706)         // Assignment within conditional expression
   #pragma warning (WLEVEL:4709)    // Comma operator within array brackets
   #pragma warning (3:4928)         // illegal copy-initialization; more than one user-defined conversion has been implicitly applied
   #pragma warning (WLEVEL:4946)    // reinterpret_cast used between related classes: 'class1' and 'class2'
#ifdef WARN_NOT_INLINED
   #pragma warning (3:4710)         // Function not inlined
#endif

   #pragma warning (disable:4251)   // class ... needs to have dll-interface to be used by clients of class ...
#if defined(WIN32) && defined(_MSC_VER) && (_MSC_VER >= 1400)
   #pragma warning (disable:4312)   // Conversion to type (pointer) of greater size
   #pragma warning (disable:4324)   // Structure '...' padded due to __declspec(align())
#endif
   #pragma warning (disable:4355)   // 'this' used in base member initializaton list
#if defined(WIN32) && defined(_MSC_VER) && (_MSC_VER >= 1400)
   #pragma warning (disable:4512)   // Assignment operator could not be generated
   #pragma warning (disable:4610)   // Class '...' can never be instantiated - user defined constructor required
#endif
   #pragma warning (disable:4786)   // Browser identifier limit of 255 characters was exceeded, oh well...
   #pragma warning (disable:4820)   // padding added after member

   #undef WLEVEL
#else
   #define DEPRECATED
   #define DEPRECATED_MSG(_msg)
#endif

/*----------------------------------------------------------------------------*/
/*    Namespace handling macros                                               */
/*----------------------------------------------------------------------------*/

#if defined(__cplusplus)
   #if defined(WIN32)
      #define  ALLOW_NAMESPACES
      namespace std {}
   #endif
#endif

/*----------------------------------------------------------------------------*/
/*    Platform-independent numeric types                                      */
/*----------------------------------------------------------------------------*/

typedef signed char              INT8;    // X11/Xmd.h defines it this way too
typedef unsigned char            UINT8;
typedef short                    INT16;
typedef unsigned short           UINT16;
#if defined(WIN32)
   #include <basetsd.h>
#elif defined(LONGS_ARE_64_BIT)
   #if !defined(PTRS_ARE_64_BIT) && !defined(PTRS_ARE_32_BIT)
      #define  PTRS_ARE_64_BIT   // If longs are 64-bit then pointers assumed to be unless explictly declared otherwise
   #endif
   typedef int                   INT32;
   typedef unsigned int          UINT32;
   typedef long                  INT64;
   typedef unsigned long         UINT64;
#else
   typedef long                  INT32;   
   typedef unsigned long         UINT32;
   typedef long long             INT64;
   typedef unsigned long long    UINT64;
#endif

#ifdef PTRINT
   #undef PTRINT
#endif

#ifdef PTRUINT
   #undef PTRUINT
#endif

#if defined(PTRS_ARE_64_BIT)
   typedef INT64              PTRINT;
   typedef UINT64             PTRUINT;
#else
   typedef INT32              PTRINT;
   typedef UINT32             PTRUINT;
#endif

typedef unsigned int          COLOR32;

#if defined(__cplusplus)

// There's a system include file on Sun that #define these for us.
#undef INT8_MIN
#undef INT8_MAX
#undef UINT8_MIN
#undef UINT8_MAX
#undef INT16_MIN
#undef INT16_MAX
#undef UINT16_MIN
#undef UINT16_MAX
#undef INT24_MIN
#undef INT24_MAX
#undef UINT24_MIN
#undef UINT24_MAX
#undef INT32_MIN
#undef INT32_MAX
#undef UINT32_MIN
#undef UINT32_MAX
#undef INT64_MIN
#undef INT64_MAX
#undef UINT64_MIN
#undef UINT64_MAX

const INT8 INT8_MAX = 127;
const INT8 INT8_MIN = -INT8_MAX-1;
const UINT8 UINT8_MAX = 255;
const UINT8 UINT8_MIN = 0;

const INT16 INT16_MAX = 32767;
const INT16 INT16_MIN = -INT16_MAX-1;
const UINT16 UINT16_MAX = 65535;
const UINT16 UINT16_MIN = 0;

const INT32 INT24_MAX = 8388607;
const INT32 INT24_MIN = -INT24_MAX-1;
const UINT32 UINT24_MAX = 16777215;
const UINT32 UINT24_MIN = 0;

const INT32 INT32_MAX = 2147483647;
const INT32 INT32_MIN = -INT32_MAX-1;
const UINT32 UINT32_MAX = 4294967295UL;
const UINT32 UINT32_MIN = 0;

#if defined(WIN32)
const INT64 INT64_MAX = 0x7FFFFFFFFFFFFFFF;
const UINT64 UINT64_MAX = 0xFFFFFFFFFFFFFFFF;
#else
// G++ complains unless we specify LL or ULL
const INT64 INT64_MAX = 0x7FFFFFFFFFFFFFFFLL;
const UINT64 UINT64_MAX = 0xFFFFFFFFFFFFFFFFULL;
#endif

const INT64 INT64_MIN = -INT64_MAX-1;
const UINT64 UINT64_MIN = 0;

const UINT64 INT64_MULT = static_cast<UINT64>(UINT32_MAX) + 1;

namespace MGUI {
   // Define generic ID for MGUI which is same size as pointer.
   typedef PTRINT ID;
   }

namespace MGD {
   typedef unsigned long PIXEL;
   }

#else // Not C++

#define INT8_MAX           127
#define INT8_MIN           (-INT8_MAX-1)
#define UINT8_MAX          255
#define UINT8_MIN          0

#define INT16_MAX          32767
#define INT16_MIN          (-INT16_MAX-1)
#define UINT16_MAX            65535
#define UINT16_MIN            0

#define INT24_MAX          8388607
#define INT24_MIN          (-INT24_MAX-1)
#define UINT24_MAX            16777215
#define UINT24_MIN            0

#define INT32_MAX          2147483647
#define INT32_MIN          (-INT32_MAX-1)
#define UINT32_MAX            4294967295
#define UINT32_MIN            0

#define INT64_MAX          0x7FFFFFFFFFFFFFFF
#define INT64_MIN          (-INT64_MAX-1)
#define UINT64_MAX            0xFFFFFFFFFFFFFFFF
#define UINT64_MIN            0

#endif

#ifdef WIN32
#define ALIGN8(_x) __declspec(align(8)) _x
#define ALIGN16(_x) __declspec(align(16)) _x
#else
#define ALIGN8(_x) _x __attribute((aligned(8)))
#define ALIGN16(_x) _x __attribute((aligned(16)))
#endif



typedef float FLOAT;
typedef double DOUBLE;

#if defined(WIN32) && defined(_MSC_VER) && (_MSC_VER >= 1400) && defined(_NATIVE_WCHAR_T_DEFINED)
// MS Visual C 2005 has wchar_t as built-in (2-byte) type and expects this in Windows API.
// But for some reason, it's only defined for C++, even if you pass the command
// line flag to treat it as a built-in type.  (Yes, this is a problem for some
// modules in MI/X)
typedef wchar_t MIUNICODE;
#else
typedef unsigned short MIUNICODE;
#endif

/*----------------------------------------------------------------------------*/
/*    Declarations (without definitions) for common classes and structures    */
/*----------------------------------------------------------------------------*/

#if defined(__cplusplus)

struct WPOINT2D;                 
struct LPOINT2D;                 
struct FPOINT2D;                 
struct DPOINT2D;                 
struct WPOINT3D;                 
struct LPOINT3D;                 
struct FPOINT3D;                 
struct DPOINT3D;                 
struct FPOINT3DH;                
struct DPOINT3DH;                


struct WRECT2D;                  
struct LRECT2D;                  
struct DRECT2D;                  
struct DRECT3D;                  

typedef LRECT2D LRECTXY;

#endif   // C++


/*----------------------------------------------------------------------------*/
/*    Coordinate data type definitions                                        */
/*----------------------------------------------------------------------------*/

#if defined(__cplusplus)

struct LPOLYGON { INT32 numpts; LPOINT2D *point; };
struct DPOLYGON { INT32 numpts; DPOINT2D *point; };

typedef DPOLYGON DPOLYLINE;

struct LSEGMENT2D { INT32 x1, y1, x2, y2; };

#endif   // C++

/*----------------------------------------------------------------------------*/
/*    Miscellaneous types                                                     */
/*----------------------------------------------------------------------------*/

enum TEXTID {
   TEXTID__None = 0,
   TEXTID__Default = 1              
   };

enum HELPID {
   HELPID__None = 0
   };

// NOTE: ERRVALUE must be defined even if not C++.
typedef int ERRVALUE;               

#if defined(__cplusplus)

struct DRANGE { double min, max; };

typedef INT64 ELEMNUM;        
// Special element number values
#define  ELEMENTNUM_None         -1
#define  ELEMENTNUM_DefaultList  -2

typedef UINT32 ICID;          
typedef INT32 RVCINODENUM;          
typedef struct _WidgetRec *Widget;

#ifdef WIN32_NATIVE
   #if defined(__cplusplus)
      class CWnd;
      typedef CWnd* MDLGPARENT;
   #endif
#else
   #ifndef X_NATIVE
      #define  X_NATIVE
   #endif
   typedef Widget MDLGPARENT;
   #if defined(WIN32)
      typedef unsigned long COLORREF;
   #else
      typedef UINT32 COLORREF;
   #endif
#endif

DEPRECATED_MSG("Deprecated, use TRANS2D_AFFINE or MAT3X3 instead") typedef DOUBLE Mat3x3[3][3];
typedef DOUBLE MAT3X3[3][3];
typedef DOUBLE MAT4X4[4][4];

typedef void *INIHANDLE;            
typedef void *MXDHANDLE;            
typedef unsigned long MPIXEL;       

enum MIPRODUCTCODE {
   MIPRODUCTCODE_Default = 0
   };


/*----------------------------------------------------------------------------*/
/*    Miscellaneous constants                                                 */
/*----------------------------------------------------------------------------*/

// Common error codes, for full list include errcodes hdr.
#define  EUserCancel -1000 
#define  EProgramError -1204  
#define  EBadFuncParm -1213   
#define  R_NewRequest -2026   
#define  R_SkipRequest -2035  


#ifdef FALSE
#undef FALSE
#endif
#define FALSE  0
#ifdef TRUE
#undef TRUE
#endif
#define TRUE   1

#ifndef NULL
#define NULL 0
#endif

#ifdef PI            // LINUX defined this
#undef PI
#endif
#define  PI          (3.14159265358979323846)
#define  RADTODEG    (180.0/PI)
#define  DEGTORAD    (PI/180.0)
#define  RADTODEG64  (64.0*180.0/PI)
#define  DEG64TORAD  (PI/(64.0*180.0))

#define  FEETTOMETERS   (0.3048)
#define  METERSTOFEET   (3.280839895)
#define  METERSTOINCHES (3.280839895*12.0)

#if defined(WIN32) && !defined(WIN32_NATIVE)
   #ifndef  NeedFunctionPrototypes
      #define  NeedFunctionPrototypes  1
   #endif
   #ifndef  XTSTRINGDEFINES
      #define  XTSTRINGDEFINES
   #endif
   #ifndef  XMSTRINGDEFINES
      #define  XMSTRINGDEFINES
   #endif
   #ifndef  XmHTML_STRINGDEFINES
      #define  XmHTML_STRINGDEFINES
   #endif
#endif

/*----------------------------------------------------------------------------*/
/*    Miscellaneous macros                                                    */
/*----------------------------------------------------------------------------*/

#ifdef MIN
#undef MIN
#endif
#ifdef MAX
#undef MAX
#endif

#ifndef membersize
   #define  membersize(type,name)   sizeof(((type*)0)->name)
#endif

#define  MI_ARRAYSIZE(a)   (sizeof(a)/sizeof(a[0]))

#define  MIN(i1,i2)     (((i1)<(i2))?(i1):(i2))
#define  MAX(i1,i2)     (((i1)>(i2))?(i1):(i2))
#define  SIGN(d)        (((d)<0) ? -1 : ((d)>0) ? 1 : 0)
#define  SWAP(a,b)      { a-=b; b+=a; a=b-a; }
#define  bound(val,min,max)   (((val)<(min))?(min):(((val)>(max))?(max):(val)))

#if defined(__cplusplus)

#define  CHECKSIZE(s) \
   inline int _checksize () { return (1 / ((sizeof(*this) == (s)) ? 1 : 0)); }

#define  GLOBALFUNC        

template <typename _TY> void Exchange (
   _TY& v1,          
   _TY& v2           
   ) { _TY temp(v1); v1 = v2; v2 = temp; }

template<typename _TY> inline void GetMinMax2 (
   const _TY a,
   const _TY b,
   _TY& minret,
   _TY& maxret
   ) {
   if (a < b) {
      minret = a;
      maxret = b;
      }
   else {
      minret = b;
      maxret = a;
      }
   }

template<typename _TY> inline void GetMinMax3 (
   const _TY a,
   const _TY b,
   const _TY c,
   _TY& minret,
   _TY& maxret
   ) {
   GetMinMax2(a,b,minret,maxret);
   if (c < minret) minret = c;
   else if (c > maxret) maxret = c;
   }

template <class _CT> inline void SetBitFromBool (
   _CT& value,       
   unsigned bit,     
   bool set          
   ) { if (set) value |= static_cast<_CT>(bit); else value &= static_cast<_CT>(~bit); }

inline void SetMinMax (double x, double& minx, double& maxx) { if (x < minx) minx = x;  if (x > maxx) maxx = x;}
inline void SetMinMax (INT32 x, INT32& minx, INT32& maxx) { if (x < minx) minx = x;  if (x > maxx) maxx = x;}
inline void SetMinMax (UINT32 x, UINT32& minx, UINT32& maxx) { if (x < minx) minx = x;  if (x > maxx) maxx = x;}

inline INT64 INT32ToINT64 (INT32 high, INT32 low) {INT64 retval = high; return ((retval << 32) + low);};
inline UINT64 UINT32ToUINT64 (UINT32 high, UINT32 low) {UINT64 retval = high; return ((retval << 32) + low);};
#if defined(WIN32)
inline void INT64ToINT32 (INT64 value, INT32& high, INT32& low) {low = static_cast<INT32>(value & 0x00000000FFFFFFFF); high = static_cast<INT32>(value >> 32); return;};
inline void UINT64ToUINT32 (UINT64 value, UINT32& high, UINT32& low) {low = static_cast<UINT32>(value & 0x00000000FFFFFFFF); high = static_cast<UINT32>(value >> 32); return;};
#else
inline void INT64ToINT32 (INT64 value, INT32& high, INT32& low) {low = static_cast<INT32>(value & 0x00000000FFFFFFFFLL); high = static_cast<INT32>(value >> 32); return;};
inline void UINT64ToUINT32 (UINT64 value, UINT32& high, UINT32& low) {low = static_cast<UINT32>(value & 0x00000000FFFFFFFFULL); high = static_cast<UINT32>(value >> 32); return;};
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT

#define  DEFINE_ENUM_OP_BITWISE(_CT) \
   inline _CT operator| (const _CT& lhs, const _CT& rhs) \
      { return (static_cast<_CT>(static_cast<const INT32>(lhs) | static_cast<const INT32>(rhs))); } \
   inline _CT& operator|= (_CT& lhs, const _CT& rhs) \
      { lhs = (static_cast<_CT>(static_cast<INT32>(lhs) | static_cast<const INT32>(rhs))); return (lhs); } \
   inline _CT& operator+= (_CT& lhs, const _CT& rhs) \
      { lhs = (static_cast<_CT>(static_cast<INT32>(lhs) | static_cast<const INT32>(rhs))); return (lhs); } \
   inline _CT operator& (const _CT& lhs, const _CT& rhs) \
      { return (static_cast<_CT>(static_cast<const INT32>(lhs) & static_cast<const INT32>(rhs))); } \
   inline _CT& operator&= (_CT& lhs, const _CT& rhs) \
      { lhs = (static_cast<_CT>(static_cast<INT32>(lhs) & static_cast<const INT32>(rhs))); return (lhs); } \
   inline _CT operator- (const _CT& lhs, const _CT& rhs) \
      { return (static_cast<_CT>(static_cast<const INT32>(lhs) & static_cast<const INT32>(~rhs))); } \
   inline _CT& operator-= (_CT& lhs, const _CT& rhs) \
      { lhs = (static_cast<_CT>(static_cast<INT32>(lhs) & static_cast<const INT32>(~rhs))); return (lhs); } \
   inline _CT operator^ (const _CT& lhs, const _CT& rhs) \
      { return (static_cast<_CT>(static_cast<const INT32>(lhs) ^ static_cast<const INT32>(rhs))); } \
   inline _CT& operator^= (_CT& lhs, const _CT& rhs) \
      { lhs = (static_cast<_CT>(static_cast<INT32>(lhs) ^ static_cast<const INT32>(rhs))); return (lhs); }

#define  DEFINE_ENUM_OP_INCREMENT(_CT) \
   inline _CT& operator++ (_CT& lhs) { lhs = static_cast<_CT>(lhs+1); return (lhs); }

#endif // GENERATING_DOXYGEN_OUTPUT

#else    // not C++

#define  CHECKSIZE(s)
#define  bool int

#endif   // C++

#if defined(USE_AMEMCPY) && defined(WIN32) && !defined(WIN64)

#include <memory.h>        
#include <mi32/cpuext.h>   
#define memcpy amemcpy     
#endif


/*----------------------------------------------------------------------------*/

#if defined(__cplusplus)
#ifndef GENERATING_DOXYGEN_OUTPUT

// Macro to prevent use of memset/memcpy/memcmp on pointer to specified type.
#ifdef memcpy
// Assume defined as 'amemcpy' so need definition to match
#define  PREVENT_MEMFUNC(type) \
   void memcmp(type *, const type *, int); \
   void memset(type *, int, int);
#else
#define  PREVENT_MEMFUNC(type) \
   void memcmp(type *, const type *, int); \
   void memcpy(type *, const type *, int); \
   void memset(type *, int, int);
#endif

// Macro to prevent use of memcmp on pointer of specified type.
#define  PREVENT_MEMCMP(type) \
   void memcmp(type *, const type *, int);

#endif // GENERATING_DOXYGEN_OUTPUT
#endif   //  __cplusplus 

/*----------------------------------------------------------------------------*/


ERRVALUE MdlgShowErrorCode (
   MDLGPARENT parent,                  
   ERRVALUE errcode                    
   );


#endif   // C++

#endif   // #ifndef INC_MI32_STDDEFNS_H

---