mi32/stddefns.h

Go to the documentation of this file.

/**
*  mi32/stddefns.h - Standard definitions for MicroImages SDK
*
*  \if NODOC
*  Do not add new types/functions/macros/constants to this file without
*  first discussing the proposed change with the programming team.
*  This file should not reference any other header file.
*
*  $Log: stddefns.h_v $
*  Revision 1.291  2003/12/15 21:18:49  mju
*  If deprecate_all then undef other deprecation constants before redefining.
*
*  Revision 1.290  2003/10/28 18:20:12  mju
*  Turn off 4761 error until determine true meaning.
*
*  Revision 1.289  2003/10/24 13:42:58  mju
*  If DEPRECATE_ALL defined then define other deprecation items.
*
*  Revision 1.288  2003/10/22 20:17:05  mju
*  Make 4761 an error.
*
*  Revision 1.287  2003/10/20 16:41:17  mju
*  Make 4551 an error.
*
*  Revision 1.286  2003/10/17 16:00:45  mju
*  Remove obsolete platform references (alpha, msdos).
*
*  Revision 1.285  2003/10/03 20:13:35  linux32build!build
*  Doxygen
*
*  Revision 1.284  2003/09/25 21:29:07  dwilliss
*  Don't capitalize enum any more. Genitor needed it, doxygen doesn't like it.
*
*  Revision 1.283  2003/09/23 20:07:51  dwilliss
*  undefine some constants before we define them.  Some system include was
*  defining them on the Sun
*
*  Revision 1.282  2003/09/15 13:49:56  fileserver!dwilliss
*  Doxygen
*  \endif
**/

#ifndef INC_MI32_STDDEFNS_H
#define INC_MI32_STDDEFNS_H

#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

#ifndef NO_DEPRECATED
// Define ENUM macro to help Starbase Surveyor to document enumerations.
// \deprecated Doxygen doesn't like this and we don't use Surveyor any more.
#define  ENUM enum
#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(NT_INTEL) || defined(WIN32)
      #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)
   // 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:4553)  // '==' operator has no effect
   #pragma warning (error:4390)  // Empty control statement found, no point for it
   #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: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:4172)  // Returning address of local or temporary
   #pragma warning (error:4152)  // Pointer to function converted to pointer to data
   #pragma warning (error:4218)  // Function does not have a return type
   #pragma warning (error:4305)  // Argument truncation from '...' to '...'
   #pragma warning (error:4309)  // Truncation of constant value
   #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:4700)  // Local variable used without having been initialized
   #pragma warning (error:4715)  // 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
   #ifdef WARN_UNREF_PARM
      #pragma warning (3:4100)   // Unreferenced formal parameter
   #endif
   #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 (3:4212)      // Function declaration uses ellipsis, definition does not
   #pragma warning (3:4222)      // 'static' used on member function at file scope
   #pragma warning (3:4234)      // Keyword reserved for future use
   #pragma warning (3:4235)      // Keyword not supported
   #pragma warning (3:4244)      // Conversion results in possible loss of data
   #pragma warning (3:4701)      // Local variable not initialized
   #pragma warning (3:4705)      // Statement has no effect
   #pragma warning (3:4706)      // Assignment within conditional expression
   #pragma warning (3:4709)      // Comma operator within array brackets
   #ifdef WARN_NOT_INLINED
      #pragma warning (3:4710)      // Function not inlined
   #endif
   #pragma warning (disable:4284)   // Warning about operator-> with infix notation
   #pragma warning (disable:4355)   // 'this' used in base member initializaton list
   #pragma warning (disable:4786)   // Browser identifier limit of 255 characters was exceeded, oh well...
#endif

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

#if defined(__cplusplus)
   #if defined(WIN32) || defined(MAC_NATIVE)
      #define  ALLOW_NAMESPACES
      namespace std {}
      #define  USING_NAMESPACE_STD  using namespace std;
   #else
      #define  USING_NAMESPACE_STD
   #endif

   #ifdef   MAC_NATIVE
      using 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) && defined(_MSC_VER) && (_MSC_VER >= 1200)
   // Using Microsoft Visual C/C++ 6.0 or higher
   #include <basetsd.h>
   #define  INT32_is_int   //!< Indicates that INT32 is same type as "int"
   typedef int                   PTRINT;
   typedef unsigned int          PTRUINT;
#elif defined(LONGS_ARE_64_BIT)
   // Note, longs may be 32 or 64 bit on SGI, so we define LONGS_ARE_64_BIT
   // if using the 64-bit compiler.
   typedef int                   INT32;
   typedef unsigned int          UINT32;
   typedef long                  INT64;
   typedef unsigned long         UINT64;
   #define  INT32_is_int   //!< Indicates that INT32 is same type as "int"
   typedef long                  PTRINT;
   typedef unsigned long         PTRUINT;
#else
   typedef long                  INT32;   //!< Some X headers define it this way so must match
   typedef unsigned long         UINT32;
   typedef long long             INT64;
   typedef unsigned long long    UINT64;
   typedef long                  PTRINT;
   typedef unsigned long         PTRUINT;
#endif

typedef unsigned int          COLOR32;

#if defined(__cplusplus)

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 INT32_MAX = 2147483647;
const INT32 INT32_MIN = -INT32_MAX-1;
const UINT32 UINT32_MAX = 4294967295UL;
const UINT32 UINT32_MIN = 0;

// There's a system include file on Sun that #define these for us.
#undef INT64_MIN
#undef INT64_MAX
#undef UINT64_MIN
#undef UINT64_MAX

#if defined(WIN32)
//! Maximum value of a 64-bit signed integer
const INT64 INT64_MAX = 0x7FFFFFFFFFFFFFFF;
//! Maximum value of a 64-bit signed unsigned integer
const UINT64 UINT64_MAX = 0xFFFFFFFFFFFFFFFF;
#else
// G++ complains unless we specify LL or ULL
//! Maximum value of a 64-bit signed integer
const INT64 INT64_MAX = 0x7FFFFFFFFFFFFFFFLL;
//! Maximum value of a 64-bit signed unsigned integer
const UINT64 UINT64_MAX = 0xFFFFFFFFFFFFFFFFULL;
#endif

//! Minimum value of a 64-bit signed integer
const INT64 INT64_MIN = -INT64_MAX-1;
//! Minimum value of a 64-bit signed unsigned integer
const UINT64 UINT64_MIN = 0;

//! Create two INT32's to INT64 constants
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;
   }

#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 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

typedef float FLOAT;
typedef double DOUBLE;
typedef unsigned short UNICODE;

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

#if defined(__cplusplus)

struct WPOINT2D;                 //!< point.h
struct LPOINT2D;                 //!< point.h
struct FPOINT2D;                 //!< point.h
struct DPOINT2D;                 //!< point.h
struct WPOINT3D;                 //!< point.h
struct LPOINT3D;                 //!< point.h
struct FPOINT3D;                 //!< point.h
struct DPOINT3D;                 //!< point.h
struct FPOINT3DH;                //!< point.h
struct DPOINT3DH;                //!< point.h


struct WRECT2D;                  //!< rect.h
struct LRECT2D;                  //!< rect.h
struct DRECT2D;                  //!< rect.h
struct DRECT3D;                  //!< rect.h

typedef WRECT2D WRECTXY;
typedef LRECT2D LRECTXY;

struct MAPPROJPARM;              //!< mapproj.h
struct RVCGENINFO;               //!< rvcdefns.h
struct FNAMEINODEUC;             //!< rvcdefns.h

#endif   // C++


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

#if defined(__cplusplus)

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

typedef WPOLYGON WPOLYLINE;
typedef LPOLYGON LPOLYLINE;
typedef DPOLYGON DPOLYLINE;

struct DPOLYLINE3D { INT32 numpts; DPOINT3D *point; };

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

#endif   // C++

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

#if defined(__cplusplus)

struct DRANGE { double min, max; };

typedef UINT32 ICID;          //!< Interface component ID

typedef INT32 RVCINODENUM;          //!< Type for RVC Object Inode parameter
typedef int (*MfFiltFuncProto) (int, RVCINODENUM, RVCGENINFO*, void*, char*);
typedef int (*MfValidMultiProto) (int, FNAMEINODEUC*, void*, int*, char*);

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;
   #ifdef WIN32
      typedef unsigned long COLORREF;
   #else
      typedef UINT32 COLORREF;
   #endif
#endif


#endif   // C++

typedef DOUBLE Mat3x3[3][3];
typedef DOUBLE MAT3X3[3][3];
typedef DOUBLE MAT4X4[4][4];

typedef void *INIHANDLE;            //!< Ini access handle
typedef void *MXDHANDLE;            //!< Generic dialog handle
typedef unsigned long MPIXEL;       //!< Generic "pixel" value
typedef int ERRVALUE;               //!< Return type value, signifies < 0 is an error

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

#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  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(WIN32) && defined(__cplusplus)

//! On Intel, avoid the _ftol() call implied by the cast to integer.
//! ftol() is slow because of the way it casts.  It first has to switch
//! the conversion mode of the processor from round to truncate, which
//! cuases all pipelines to stall.  Then it converts the number and switches
//! back to rounding mode.  That's a lot of work to truncate a number when
//! the default would have been to do What We Wanted (W3)
inline INT32 ROUND(double x) {
   x += 1E-10;          // Account for Intel rounding .5 values to nearest -even- integer, corrects for up to +/- 1000000
   INT32 result;
   __asm fld x
   __asm fistp result
   return result;
   }

#else

#define  ROUND(d)       static_cast<INT32>(floor((d)+.5))

#endif

#if defined(__cplusplus)

//! Compile-time validate size of structure or class
#define  CHECKSIZE(s) \
   inline int _checksize () { return (1 / (sizeof(*this) == (s))); }

//! Compile-time validate that public global has a matching prototype.
#ifdef WIN32
#define  GLOBALFUNC  ::
#else
#define  GLOBALFUNC
#endif

//! Set or clear 'bit' in value based on 'bool'.
//! The type may be an enum if DEFINE_ENUM_OP_BITWISE used on enum.
template <class _CT> inline void SetBitFromBool (
   _CT& value,       //!< Value to modify
   unsigned bit,     //!< Bit(s) to set or clear.
   bool set          //!< 'true' to set, 'false' to clear
   ) { 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;}

//! Functions to convert two INT32's to an INT64
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 bitwise &, |, +, - operators for enumerations (for use as flags).
#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); }
#define  DEFINE_ENUM_OPERATORS   DEFINE_ENUM_OP_BITWISE

//! Define increment (++) operator for enumerations.
#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)
//! For testing: If you define USE_AMEMCPY in your makefile, all memcpy
//! calls will be replaced with our accelerated versions (Windows only,
//! other platforms either don't have MMX or I don't know the inline
//! assembler syntax of the compiler),  This may eventually go away
//! in favor of some new method, `cause Mike won't like this.

#include <memory.h>        //! Make sure we have memcpy prototyped...
#include <mi32/cpuext.h>   //! Define our prototype...
#define memcpy amemcpy     //!< override memcpy with our accelerated version
#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); \
   extern void* (*amemcpy)(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 

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

#endif   // #ifndef INC_MI32_STDDEFNS_H

---