[Trion-cvs] trion v0.2/object std_types.hpp,1.2,1.3

[Daniel R. <co...@us...>]

Update of /cvsroot/trion/trion v0.2/object
In directory sc8-pr-cvs10.sourceforge.net:/tmp/cvs-serv2339

Modified Files:
	std_types.hpp 
Log Message:
no message

Index: std_types.hpp
===================================================================
RCS file: /cvsroot/trion/trion v0.2/object/std_types.hpp,v
retrieving revision 1.2
retrieving revision 1.3
diff -C2 -d -r1.2 -r1.3
*** std_types.hpp	23 Feb 2006 12:26:40 -0000	1.2
--- std_types.hpp	24 Jun 2006 15:01:46 -0000	1.3
***************
*** 9,13 ****
  
  // -----------------------------------------------------------------------
! // Copyright (C) 2003, Trion Development Group Members
  // All rights reserved.
  //
--- 9,13 ----
  
  // -----------------------------------------------------------------------
! // Copyright (C) 2006, Trion Development Group Members
  // All rights reserved.
  //
***************
*** 41,73 ****
  #define __STANDARD_DATA_TYPE_DEFINITIONS__
  
! typedef long unsigned int size_t;
  
! typedef unsigned char  uchar;
! typedef unsigned short ushort;
! typedef unsigned int   uint;
! typedef unsigned long  ulong;
  
! #ifndef __SIZE_TYPE__
! #define __SIZE_TYPE__ long unsigned int
! #endif
  
! typedef __SIZE_TYPE__ size_t;
  
! /** Placement new operator. Used to construct objects at reserved memory locations. */
! inline void *operator new(size_t, void *place) throw() { return place; }
  
! /** Placement new operator for arrays. Used to construct arrays of objects at reserved memory locations. */
  inline void *operator new[](size_t, void *place) throw() { return place; }
  
! /** Delete operator. Used to call destructors. */
  inline void  operator delete  (void*, void*) throw() { }
- 
- /** Delete operator for array. Used to call destructors. */
  inline void  operator delete[](void*, void*) throw() { }
  
! void* operator new(size_t count) throw();
! void* operator new[](size_t count) throw();
! void operator delete(void* pointer) throw();
! void operator delete[](void* pointer) throw();
  
  #endif
--- 41,91 ----
  #define __STANDARD_DATA_TYPE_DEFINITIONS__
  
! typedef unsigned char u08b;
! typedef  signed  char s08b;
  
! typedef unsigned short u16b;
! typedef  signed  short s16b;
  
! typedef unsigned int u32b;
! typedef  signed  int s32b;
  
! typedef unsigned long long u64b;
! typedef  signed  long long s64b;
  
! typedef long unsigned int size_t;
  
! /** Placement new operators, used to construct (arrays of) objects at reserved memory locations. */
! inline void *operator new  (size_t, void *place) throw() { return place; }
  inline void *operator new[](size_t, void *place) throw() { return place; }
  
! /** Placement delete operators, used to call destructors for (arrays of) objects. */
  inline void  operator delete  (void*, void*) throw() { }
  inline void  operator delete[](void*, void*) throw() { }
  
! /** Allow a 32bit wide bitfield to be accessed like an ordinary integer */
! template<class T> struct bf32
! {
!  private:
!     union { u32b integer;  T bitfield; };
! 
!  public:
!     bf32(u32b value) : integer(value) {}; // Allows initialization with an integer
! 
!     operator u32b() { return integer;   } // Default conversation to an integer
!     operator T&()   { return bitfield;  } // Conversation to the bitfield type
! 
!     T* operator->() { return &bitfield; } // Access to the members of the bitfield
! };
! 
! /** Some very basic operations to initialize and copy memory ranges */
! template<class T> void memset(T* begin, T* end, const T& value)
! {
!     while(begin != end) *(begin++) = value;
! }
! 
! template<class T> void memcopy(T* begin, T* end, T* destination)
! {
!     while(begin != end) *(destination++) = *(begin++);
! }
  
  #endif