Global.H

Go to the documentation of this file.

#ifndef Global_H
#define Global_H

// $Id: Global.H 6634 2008-01-20 19:59:11Z furtak $
      
// This is an ORTS file (c) Michael Buro, licensed under the GPL

// general global definitions and useful macros

#include "All.H"
#include "Vector.H"

#if 1

typedef int8_t   sint1;
typedef uint8_t  uint1;
typedef int16_t  sint2;
typedef uint16_t uint2;
typedef int32_t  sint4;
typedef uint32_t uint4;
typedef int64_t  sint8;
typedef uint64_t uint8;

typedef intptr_t  sintptr;
typedef uintptr_t uintptr;

#else

// old

typedef   signed char        sint1;
typedef unsigned char        uint1;
typedef   signed short       sint2;
typedef unsigned short       uint2;
typedef   signed int         sint4;
typedef unsigned int         uint4;
typedef               float  real4;
typedef               double real8;
typedef          long double realC;
typedef   signed long long   sint8;
typedef unsigned long long   uint8;

#endif

typedef       float real4;
typedef      double real8;
typedef long double realC;

typedef void* vptr;
typedef char* cptr;

typedef const void* cvptr;
typedef const char* ccptr;

typedef const void* const cvptrc;
typedef const char* const ccptrc;

const sint1 min_sint1 = 0x80;
const sint1 max_sint1 = 0x7F;
const uint1 min_uint1 = 0x00;
const uint1 max_uint1 = 0xFF;
const sint2 min_sint2 = 0x8000;
const sint2 max_sint2 = 0x7FFF;
const uint2 min_uint2 = 0x0000;
const uint2 max_uint2 = 0xFFFF;
const sint4 min_sint4 = 0x80000000;
const sint4 max_sint4 = 0x7FFFFFFF;
const uint4 min_uint4 = 0x00000000;
const uint4 max_uint4 = 0xFFFFFFFF;
const sint8 min_sint8 = 0x8000000000000000LL;
const sint8 max_sint8 = 0x7FFFFFFFFFFFFFFFLL;
const uint8 min_uint8 = 0x0000000000000000LL;
const uint8 max_uint8 = 0xFFFFFFFFFFFFFFFFLL;
//const sintptr min_sintptr = INTPTR_MIN;
//const sintptr max_sintptr = INTPTR_MAX;
//const uintptr min_uintptr = 0;
//const uintptr max_uintptr = UINTPTR_MAX;

BOOST_STATIC_ASSERT(sizeof(sint1) == 1);
BOOST_STATIC_ASSERT(min_sint1 < 0);
BOOST_STATIC_ASSERT(max_sint1 > 0);
BOOST_STATIC_ASSERT(sizeof(uint1) == 1);
BOOST_STATIC_ASSERT(min_uint1 == 0);
BOOST_STATIC_ASSERT(max_uint1 > 0);
BOOST_STATIC_ASSERT(sizeof(sint2) == 2);
BOOST_STATIC_ASSERT(min_sint2 < 0);
BOOST_STATIC_ASSERT(max_sint2 > 0);
BOOST_STATIC_ASSERT(sizeof(uint2) == 2);
BOOST_STATIC_ASSERT(min_uint2 == 0);
BOOST_STATIC_ASSERT(max_uint2 > 0);
BOOST_STATIC_ASSERT(sizeof(sint4) == 4);
BOOST_STATIC_ASSERT(min_sint4 < 0);
BOOST_STATIC_ASSERT(max_sint4 > 0);
BOOST_STATIC_ASSERT(sizeof(uint4) == 4);
BOOST_STATIC_ASSERT(min_uint4 == 0);
BOOST_STATIC_ASSERT(max_uint4 > 0);
BOOST_STATIC_ASSERT(sizeof(sint8) == 8);
BOOST_STATIC_ASSERT(min_sint8 < 0);
BOOST_STATIC_ASSERT(max_sint8 > 0);
BOOST_STATIC_ASSERT(sizeof(uint8) == 8);
BOOST_STATIC_ASSERT(min_uint8 == 0LL);
BOOST_STATIC_ASSERT(max_uint8 > 0LL);

BOOST_STATIC_ASSERT(sizeof(sintptr) >= 4);
BOOST_STATIC_ASSERT(sizeof(uintptr) >= 4);

class ExitException
{
private:
  std::string sReason;
public:
  std::string* get_reason() { return &sReason; };
  ExitException(std::string s) : sReason(s) { }
};

// WINDOWS COMPATIBILITY

#ifdef GCC
#  define PACKED_STRUCT __attribute__((packed)) 
#  define PATH_SEP '/'

struct StringHash 
{
  size_t operator()( const std::string& x ) const
  {
    return EXT_NAMESPACE::hash< const char* >()( x.c_str() );
  }
};

#else
#  define rint(x) int(real4(x)+0.5)
#  define PACKED_STRUCT 
#  define PATH_SEP '\\'
#  ifndef M_PI
#    define M_PI       3.14159265358979323846
#    define M_PI_2     1.57079632679489661923
#    define M_PI_4     0.78539816339744830962
#    define M_1_PI     0.31830988618379067154
#    define M_2_PI     0.63661977236758134308
#    define M_SQRT2    1.41421356237309504880
#    define M_SQRT1_2  0.70710678118654752440
#    define srand48(n) srand((n))
#  endif

struct StringHash : public EXT_NAMESPACE::hash_compare<std::string>
{
};

#endif

#if defined GCC && defined __MINGW32__
#    define srand48(n) srand((n))
#endif

#ifndef GCC
#include "direct.h"
#define getcwd _getcwd
#define chdir _chdir
#endif

// frequently used for loops
// ..._DYN evaluates upper bound in each loop
// ... evaluates it only once at the loop start

#define FOREVER for (;;)

// important: 2 statements => put { } around FOR in if/else/while/for blocks
#define FOR(i, n)      typeof(n) _=(n); for (i=0; i < _; ++i)
#define FOR_DYN(i, n)  for (i=0; i < (n); ++i)

#define FORS(i, n) for (sint4 i=0, _=(n); i < _; ++i)
#define FORS_DYN(i, n) for (sint4 i=0; i < (n); ++i)

#define FORU(i, n) for (uint4 i=0, _=(n); i < _; ++i)
#define FORU_DYN(i, n) for (uint4 i=0; i < (n); ++i)

#define FORS_REV(i, n) for (sint4 i=(n)-1; i >= 0; --i)

// infers the upper bound type
#define FORT(i, n)      for (typeof(n) i=0, _=(n); i < _; ++i)
#define FORT_DYN(i, n)  for (typeof(n) i=0; i < (n); ++i)


// these are macros that traverse STL containers

// assumes container does not change
#define FORALL(CONT,i)  \
  for (typeof((CONT).begin()) i = (CONT).begin(), _ = (CONT).end(); i != _; ++i) 

// no increment, dynamic end
#define FORALL_NI(CONT,i)   \
  for (typeof((CONT).begin()) i = (CONT).begin(); i != (CONT).end();) 

// assumes container does not change and defines iterator outside of loop (B=BREAK) 
// ATTENTION: two lines of code => { } may be necessary!
#define FORALL_B(CONT,i) \
  typeof((CONT).begin()) i = (CONT).begin(); \
  for (typeof((CONT).begin()) _ = (CONT).end(); i != _; ++i) \

// container may change
#define FORALL_DYN(CONT,i)  \
  for (typeof((CONT).begin()) i = (CONT).begin(); i != (CONT).end(); ++i) 

// reverse traversal
// container does not change
#define FORALL_REV(CONT,i)  \
  for (typeof((CONT).rbegin()) i = (CONT).rbegin(), _ = (CONT).rend(); i != _; ++i) 

// reverse traversal
// assumes container does not change (BREAK version)
// ATTENTION: two lines of code => { } may be necessary!
#define FORALL_REV_B(CONT,i)    \
  typeof((CONT).rbegin()) i = (CONT).rbegin(); \
  for (typeof((CONT).rbegin()) _ = (CONT).rend(); i != _; ++i) 

// container may change
#define FORALL_REV_DYN(CONT,i)  \
  for (typeof((CONT).rbegin()) i = (CONT).rbegin(); i != (CONT).rend(); ++i)

#define FIND(cont, it, elem) typeof(cont.find(elem)) it = cont.find(elem);

#define errstr std::cerr
#define ABORT  assert(0==1)

#if defined(__GNUC__)
#define ERR(s) {\
  std::stringstream ss; ss << __FILE__ << " " << __FUNCTION__ \
  << "() (line " << __LINE__ << "): " << s; \
  errstr << "ERROR: " << ss.str() << std::endl; \
  throw ExitException(std::string(ss.str())); \
}

#define ERR2(s1, s2) {\
  std::stringstream ss; ss << __FILE__ << " " << __FUNCTION__ \
  << "() (line " << __LINE__ << "): " << s1 << " " << s2 ; \
  errstr << "ERROR: " << ss.str() << std::endl; \
  throw ExitException(std::string(ss.str())); \
}

#else
#define ERR(s) {\
  std::stringstream ss; ss << __FILE__ \
  << " () (line " << __LINE__ << "): " << s; \
  errstr << "ERROR: " << ss.str() << std::endl; \
  throw ExitException(std::string(ss.str())); \
}

#define ERR2(s1, s2) {\
  std::stringstream ss; ss << __FILE__ \
  << " () (line " << __LINE__ << "): " << s1 << " " << s2 ; \
  errstr << "ERROR: " << ss.str() << std::endl; \
  throw ExitException(std::string(ss.str())); \
}

#endif

#define REM(x) errstr << "REMARK: " << x << std::endl;
#define REM2(x,y) errstr << "REMARK: " << (x) << " " << (y) << std::endl;

inline sint4 my_round(real4 x) { return sint4(rint(x)); }

inline sint4 mult(sint4 x, sint4 y)
{
#ifdef GCC
  assert(::llabs(sint8(x)*sint8(y)) < 2000000000);
#endif
  return x*y;
}

inline sint8 mult(const sint8 x, const sint8 y)
{
  assert(fabs(real8(x)*real8(y)) < 1e18);
  return x*y;
}

inline uint4 square(const uint4& x) {
  assert(x <= 65535);
  return x*x;
}

inline sint4 square(const sint4& x) {
  assert(abs(x) <= 46340);
  return x*x;
}

inline sint8 square(const sint8& x) {
#ifdef GCC
  assert(::llabs(x) <= 3037000499LL);
#endif
  return x*x;
}

inline real4 square(const real4& x) {
  assert(fabs(x) <= 1.84391e19);
  return x*x;
}

inline real8 square(const real8& x) {
  assert(fabs(x) <= 1.0e150L);
  return x*x;
}

template<class T> T sign(T &x) {
  if (x > 0) return +1;
  if (x < 0) return -1;
  return 0;
}

template< class T>
inline std::string to_string(const T & Value)
{
  std::stringstream streamOut;
  streamOut << Value;
  return streamOut.str();
}

#if 0
// defined in STL
template <class T> void swap(T& x, T&y) {
  T temp = x; x = y; y = temp;
}
#endif


// check whether memory ranges do not overlap (for memcpy)
// ATTENTION: beware of side effects!
#define NO_OVERLAP(p,q,n) assert((p)+(n) <= (q) || (p) >= (q)+(n));

// SYSTEM DEPENDENT

#if 0
#  ifdef __i386__
#    if __GNUC__
#      define FLOAT_TO_INT(in,out)  \
         __asm__ __volatile__ ("fistpl %0" : "=m" (out) : "t" (in) : "st") ;
#    else // !__GNUC__ ( && __i386__)
#      define FLOAT_TO_INT(in,out)  out = rint(in)
#    endif // __GNUC__

#  else // __i386__
#    define FLOAT_TO_INT(in,out)  out = rint(in)
#  endif // __i386__
#endif


#if defined(__i386__) && __GNUC__ && !defined(__CYGWIN__)

#include <fenv.h>

#define FAST_ROUND 1

#define ROUND_REAL8_TO_SINT4(in,out)  \
    __asm__ __volatile__ ("fistpl %0" : "=m" (out) : "t" (in) : "st") ;

#define ROUND_TO_NEAREST fesetround(FE_TONEAREST)
#define ROUND_DOWNWARD   fesetround(FE_DOWNWARD)
#define ROUND_UPWARD     fesetround(FE_UPWARD)
#define ROUND_TOWARD_0   fesetround(FE_TOWARDZERO)
#define ROUND_DEFAULT    fesetround(FE_TONEAREST)

#define ASSERT_DEFAULT   assert(fegetround() == FE_TONEAREST)

#else

#define FAST_ROUND 0
#define ROUND_REAL8_TO_SINT4(in,out) out = (int)rint(in)

#endif

extern std::string sanitize_path(const std::string &fp);

extern char *alloc_sprintf(const char *fmt, ...);
extern char *alloc_sprintf(const char *fmt, va_list ap);
extern std::ostream &form(std::ostream& os, const char* fmt, ... );
extern std::ostream &form(std::ostream& os, const char* fmt, va_list ap);

// tokenize string into parts separated by a delimiter
// creates empty strings for consecutive delimters
extern void tokenize(const std::string& str,
             Vector<std::string>& tokens,
             const std::string& delimiters = " ");

extern bool gdb;  // set to -gdb option in main()

// requires the above definitions
// but we need this here to give every function access to random

#include "Typeof.H"

#endif