SYS/SYS_Types.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Side Effects Software Inc
 *      477 Richmond Street West
 *      Toronto, Ontario
 *      Canada   M5V 3E7
 *      416-504-9876
 *
 * NAME:        SYS_Types.h ( SYS Library, C++)
 *
 * COMMENTS:    Common types used throughout Houdini.
 */

#ifndef __SYS_Types__
#define __SYS_Types__

// Include system types
#include <sys/types.h>

/*
 * Integer types
 */
typedef signed char     int8;
typedef unsigned char   uint8;
typedef short           int16;
typedef unsigned short  uint16;
typedef int             int32;
typedef unsigned int    uint32;

typedef unsigned char   uchar;
typedef unsigned int    uint;

/*
 * Avoid using uint64.
 * The extra bit of precision is NOT worth the cost in pain and suffering
 * induced by use of unsigned.
 */
#if defined(WIN32)
    typedef __int64             int64;
    typedef unsigned __int64    uint64;
#elif defined(MBSD)
    #include <stdint.h>
    typedef int64_t             int64;
    typedef uint64_t    uint64;
#elif defined(SOLARIS) || defined(PPC64) || defined(AMD64)
    typedef long                int64;
    typedef unsigned long       uint64;
#else
    typedef long long           int64;
    typedef unsigned long long  uint64;
#endif

/*
 * Floating Point Types
 * By specifying the number of bits (i.e. fpreal32), the precision is
 * automatically determined.  The fpreal type defaults to the precision for the
 * Houdini release and may change accordingly.  fpreal should be used unless
 * there are specific reasons for requiring a certain precision.
 */
typedef float   fpreal32;
typedef double  fpreal64;
typedef float   fpreal;

#define SYS_FPREAL_SIZE 32

#ifdef __cplusplus
    /* Include half-precision floats after other types are defined */
    #include "fpreal16.h"
#else
    typedef unsigned short fpreal16;
#endif

typedef union {
    int32       ival;
    uint32      uval;
    fpreal32    fval;
} SYS_FPReal32Union;

typedef union {
    int64       ival;
    uint64      uval;
    fpreal64    fval;
} SYS_FPReal64Union;

/*
 * When declaring floating point constants, please use the following macros.
 * If a floating point expression contains a double precision constant, all
 * arguments will be promoted to double precision then the result cast back to
 * single precision.  To avoid the cost of conversions, please use the correct
 * types.  Try to avoid using 180.0F.
 */

#define CONST_INT8(x)   ((int8)x)
#define CONST_UINT8(x)  ((uint8)x)
#define CONST_INT16(x)  ((int16)x)
#define CONST_UINT16(x) ((uint16)x)
#define CONST_INT32(x)  ((int32)x)
#define CONST_UINT32(x) ((uint32)x)

#if defined(WIN32)
    #define CONST_INT64(x)      ((int64)x)
    #define CONST_UINT64(x)     ((uint64)x)
#else
    #define CONST_INT64(x)      (x##LL)
    #define CONST_UINT64(x)     (x##LL)
#endif

#define CONST_FPREAL16(c)       ((fpreal16)c)
#define CONST_FPREAL32(c)       ((fpreal32)c)
#define CONST_FPREAL64(c)       ((fpreal64)c)
#define CONST_FPREAL(c)         ((fpreal)c)

/// Function modifiers
///
/// Note that these qualifiers can only appear in function declarations.
///
// @{

/// Mark function as deprecated and may be removed in the future.
#if defined(GCC3)
    #define SYS_DEPRECATED      __attribute__ ((deprecated))
#elif defined(_MSC_VER)
    #define SYS_DEPRECATED      __declspec(deprecated) 
#else
    #define SYS_DEPRECATED
#endif

/// Mark function to be inlined. If this is done, taking the address of such
/// a function is not allowed.
#if defined(GCC3)
    #define SYS_FORCE_INLINE    __attribute__ ((always_inline))
#elif defined(_MSC_VER)
    #define SYS_FORCE_INLINE    __forceinline
#else
    #define SYS_FORCE_INLINE    inline
#endif

/// Mark function as NOT to be inlined.
#if defined(GCC3)
    #define SYS_NO_INLINE       __attribute__ ((noinline))
#elif defined(_MSC_VER)
    #define SYS_FO_INLINE       __declspec(noinline)
#else
    #define SYS_NO_INLINE
#endif

/// Mark a function as doing printf-style formatting, and generate warnings
/// if the formatting string doesn't match the types.  string_index is the
/// parameter index of the format string, and first_to_check is the index of
/// the "..." parameter.  These indices are both base 1, and "this" counts as
/// the first parameter if it's a method.
#if defined(GCC3)
    #define SYS_PRINTF_CHECK_ATTRIBUTE(string_index, first_to_check) \
        __attribute__ ((format (printf, string_index, first_to_check)))
#else
    #define SYS_PRINTF_CHECK_ATTRIBUTE(string_index, first_to_check)
#endif
// @}

#endif

---