source: to-imperative/trunk/runtime/pxx_common.hh @ 153

// $Source$
// $Revision: 153 $
// $Date: 2002-09-13 22:28:31 +0000 (Fri, 13 Sep 2002) $

#ifndef __pxx_common_hh__
#define __pxx_common_hh__

#include <unistd.h>
#include <stdint.h>
#include <stdio.h>

namespace pxx
{

#ifndef DEBUG
#define DEBUG 0
#endif

#ifndef PARANOIA
#define PARANOIA 0
#endif

#define null (0)

#define FATAL \
  fprintf( \
    stderr,"Fatal error in %s\nat %s:%d\n", \
    __PRETTY_FUNCTION__, __FILE__, __LINE__ \
  ), \
  pxx::fatal

extern void (*terminate) (int _error_code);
extern void fatal (char* _fmt, ...);

#define ROUNDS_SIZE (sizeof(size_t) * 8)

extern size_t page_size;
extern size_t orders [256];
extern size_t rounds [ROUNDS_SIZE];

static inline
size_t get_order( size_t _size )
{
  /*if( _size > 0 )*/ _size--;
#if 1
  size_t b;
  int n = -8;
  do {
    b = _size & 0xFF;
    _size >>= 8;
    n += 8;
  } while( _size );
  return orders[b] + n;
#else
  size_t n = 0;
  if (_size & 0xFFFF0000) { _size &= 0xFFFF0000; n += 16; }
  if (_size & 0xFF00FF00) { _size &= 0xFF00FF00; n += 8; }
  if (_size & 0xF0F0F0F0) { _size &= 0xF0F0F0F0; n += 4; }
  if (_size & 0xCCCCCCCC) { _size &= 0xCCCCCCCC; n += 2; }
  if (_size & 0xAAAAAAAA) n += 1;
  return n + 1;
#endif
}

static inline
bool aligned( void* _ptr, uintptr_t _align )
{
  return ((_align - 1) & (uintptr_t)_ptr) == 0;
}

template <typename typeT>
inline typeT* ptr_add( typeT* _ptr, size_t _value )
{
  return (typeT*)((char*)_ptr + _value);
}

template <typename typeT>
inline typeT* ptr_sub( typeT* _ptr, size_t _value )
{
  return (typeT*)((char*)_ptr - _value);
}

template <typename typeT1, typename typeT2>
inline ssize_t sub_ptr( typeT1* _ptr1, typeT2* _ptr2 )
{
  return (char*)_ptr1 - (char*)_ptr2;
}

#if 0
static inline
void* ptr_align( void* _ptr, uintptr_t _align )
{
  return (void*)(((uintptr_t)_ptr) & ~(_align - 1));
}

static inline
size_t size_align (size_t _size, size_t _align)
{
  _align--;
  return (_size + _align) & (~(_align));
}

inline void* ptr_and (void* _p1, void* _p2)
{
  return (void*)((uintptr_t)_p1 & (uintptr_t)_p2);
}

inline void* ptr_or (void* _p1, void* _p2)
{
  return (void*)((uintptr_t)_p1 | (uintptr_t)_p2);
}

inline void* ptr_xor (void* _p1, void* _p2)
{
  return (void*)((uintptr_t)_p1 ^ (uintptr_t)_p2);
}

inline void* ptr_diff (void* _p1, void* _p2)
{
  uintptr_t diff = (uintptr_t)_p1 ^ (uintptr_t)_p2;
  return (void*)(((diff ^ (diff - 1)) >> 1) + 1);
}
#endif

}

#endif // __pxx_common_hh__