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.314  2004/11/15 14:44:37  mju
*  Add fast_truncate.
*  Add documentation regarding accuracy of fast_... functions.
*
*  Revision 1.313  2004/11/11 22:18:49  mju
*  Add FAST_CEIL and FAST_FLOOR inlines.
*  Rename ROUND as FAST_ROUND with #define for legacy usages.
*  Tweak round inline to avoid extra fld/fstp instructions.
*
*  Revision 1.312  2004/07/15 13:56:13  dwilliss
*  Define ERRVALUE even if not C++
*
*  Revision 1.311  2004/06/22 20:54:03  mju
*  Move mdlgShowErrorCode here so available for MFC without including mdlg hdr.
*
*  Revision 1.310  2004/06/17 19:37:36  mju
*  Make compiler warning 4258 an error.
*
*  Revision 1.309  2004/05/10 17:09:30  mju
*  Move MGD::PIXEL typedef here.
*
*  Revision 1.308  2004/05/07 16:35:26  mju
*  Add enum operator ^ for toggle of flag bits.
*
*  Revision 1.307  2004/03/11 22:09:52  scowan
*  4702 downgraded to a warning.
*
*  Revision 1.306  2004/03/11 20:29:30  scowan
*  Make 4702 an error for release builds.
*
*  Revision 1.305  2004/03/11 18:48:06  scowan
*  Added more warnings and made one warnings an error.
*
*  Revision 1.304  2004/03/05 18:41:34  mju
*  Comment out warning re static object init not thread-safe.
*
*  Revision 1.303  2004/03/04 20:34:17  scowan
*  Comment const expr warning./
*
*  Revision 1.302  2004/03/04 20:31:53  scowan
*  Added new warning.
*
*  Revision 1.301  2004/03/04 18:50:04  scowan
*  Comment out another warning.
*
*  Revision 1.300  2004/03/04 18:41:10  scowan
*  Comment out two warnings as are redundant.
*
*  Revision 1.299  2004/03/04 17:59:22  scowan
*  Added more warnings and errors.
*
*  Revision 1.298  2004/02/19 17:00:53  mju
*  Don't define use_mgui if defined already.
*
*  Revision 1.297  2004/02/19 15:49:23  mju
*  Define use_mgui for x_native and win32_mfc.
*
*  Revision 1.296  2004/02/16 18:01:26  mju
*  Add DEPRECATED macro so will generate compiler warnings when use deprecated items.
*
*  Revision 1.295  2004/02/16 16:10:11  mju
*  Remove some legacy namespace stuff.
*
*  Revision 1.294  2003/12/26 17:08:21  scowan
*  Promote new warning to an error.
*
*  Revision 1.293  2003/12/24 20:13:05  scowan
*  Added more vc7 fixes.
*
*  Revision 1.292  2003/12/24 18:43:17  scowan
*  Adjusted for vc7.
*
*  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

#if !defined(USE_MGUI) && (defined(X_NATIVE) || defined(WIN32_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

#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
#ifdef WIN32
#pragma deprecated("ENUM")
#endif
#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)
   #define DEPRECATED __declspec(deprecated)
   // 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: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
   #pragma warning (error:4390)  // Empty control statement found, no point for it
   #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
   #pragma warning (error:4548)  // expression before comma has no effect; expected expression with side-effect
   #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:4700)  // Local variable used without having been 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
   #ifdef 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 (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: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 (3: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 (3:4515)      // 'namespace' : namespace uses itself
   #pragma warning (3:4527)      // instances of type 'class' can never be destroyed - user-defined destructor required
   #pragma warning (3: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:4701)      // Local variable not initialized
   #pragma warning (3:4702)      // Unreachable code
   #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
   #pragma warning (3:4928)      // illegal copy-initialization; more than one user-defined conversion has been implicitly applied
   #pragma warning (3: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: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...
#else
   #define DEPRECATED
#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) && 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;
   }

namespace MGD {
   //! Pixel value on drawing device.
   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 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                                                     */
/*----------------------------------------------------------------------------*/

typedef int ERRVALUE;               //!< Return type value, signifies < 0 is an error

// NOTE: ERRVALUE must be defined even if not C++.  The freetype13 library,
// when compiled for Mac OS X, has a module we wrote to read resource forks
// This module includes miodefns.h, which uses ERRVALUE.  Freetype13 is not
// a C++ library.  So to whoever put it in the cplusplus only section below...
//   PTHATHATHATHATH!

#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

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


/*----------------------------------------------------------------------------*/
/*    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)
// Accounts for Intel rounding .5 values to nearest -even- integer, corrects for up to +/- 1000000

//! Fast round of value to nearest integer, with X.5 values rounded up.
//! This function is approximately 3X faster than using static_cast<INT32>(x+.5) on Intel.
//! Accuracy limitations:
//! Values in the range from -1000000 to +1000000 at exactly .5 will be handled correctly.
//! Values outside that range may not always be rounded up.  In addition, values in the
//! range of -1000 to 1000 which are within 1E-10 of .5 may not be correctly rounded down.
//! The FAST_... functions should not be used if exact accuracy is required.
inline INT32 FAST_ROUND (double x) {
   static const double d = 1E-10;
   INT32 result;
   __asm fld x
   __asm fadd d
   __asm fistp result
   return result;
   }

//! Fast return of smallest integer greater than or equal to specified value.
//! This function is at least 5X faster than using static_cast<INT32>(ceil(x)) on Intel.
//! Accuracy limitations:
//! Values in the range from -1000000 to +1000000 at exactly .0 will be handled correctly.
//! Values outside that range may not always be correct.  In addition, values in the
//! range of -1000 to 1000 which are within 1E-10 of .0 may not be correctly rounded.
//! The FAST_... functions should not be used if exact accuracy is required.
inline INT32 FAST_CEIL (double x) {
   static const double d = .4999999999;
   INT32 result;
   __asm fld x
   __asm fadd d
   __asm fistp result
   return result;
   }

//! Fast return of largest integer less than or equal to specified value.
//! This function is at least 5X faster than using static_cast<INT32>(floor(x)) on Intel.
//! Accuracy limitations:
//! Values in the range from -1000000 to +1000000 at exactly .0 will be handled correctly.
//! Values outside that range may not always be correct.  In addition, values in the
//! range of -1000 to 1000 which are within 1E-10 of .0 may not be correctly rounded.
//! The FAST_... functions should not be used if exact accuracy is required.
inline INT32 FAST_FLOOR (double x) {
   static const double d = -.4999999999;
   INT32 result;
   __asm fld x
   __asm fadd d
   __asm fistp result
   return result;
   }

//! Fast return of largest integer less than or equal to specified value.
//! This function is at approximately 3X faster than using static_cast<INT32>(x) on Intel.
//! If values are known to always be positive (or negative) it will be faster to
//! use the FAST_FLOOR (or FAST_CEIL) function as appropriate.
//! Accuracy limitations:
//! Values in the range from -1000000 to +1000000 at exactly .0 will be handled correctly.
//! Values outside that range may not always be correct.  In addition, values in the
//! range of -1000 to 1000 which are within 1E-10 of .0 may not be correctly rounded.
//! The FAST_... functions should not be used if exact accuracy is required.
inline INT32 FAST_TRUNCATE (double x) {
   static const double d = .4999999999;
   INT32 result;
   if (x < 0) {
      __asm fld x
      __asm fadd d
      __asm fistp result
      }
   else {
      __asm fld x
      __asm fsub d
      __asm fistp result
      }
   return result;
   }


#else

#define  FAST_ROUND(d)     static_cast<INT32>(floor((d)+.5))
#define  FAST_CEIL(d)      static_cast<INT32>(ceil(d))
#define  FAST_FLOOR(d)     static_cast<INT32>(floor(d))
#define  FAST_TRUNCATE(d)  static_cast<INT32>(d)

#endif

#define  ROUND FAST_ROUND

#if defined(__cplusplus)

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

//! Compile-time validate that public global has a matching prototype.
#if defined(WIN32) && !defined(VC7)    // VC 7 causes ERRVALUE GLOBALFUNC GetLastErrCode() to be interpreted as ERRVALUE::GetLastErrCode()
#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); } \
   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 

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

//!\addtogroup mdlg Mdlg functions
//!@{

//! Display error dialog with text for specified error code.
//! @return error code or EUserCancel.
//! Similar to MdlgShowMessageCode(parent,errcode,MDLG_MESSAGETYPE_Error) except
//! that EUserCancel messages are not displayed.
ERRVALUE MdlgShowErrorCode (
   MDLGPARENT parent,                  //!< Parent for dialog, NULL for default
   ERRVALUE errcode                    //!< Error code
   );

//!@}

#endif   // C++

#endif   // #ifndef INC_MI32_STDDEFNS_H

---