extlzham 0.0.1.PROTOTYPE

data/contrib/lzham/lzhamdecomp/lzham_timer.h

@@ -0,0 +1,99 @@
+// File: lzham_timer.h
+// See Copyright Notice and license at the end of include/lzham.h
+#pragma once
+
+namespace lzham
+{
+   typedef unsigned long long timer_ticks;
+      
+   class lzham_timer
+   {
+   public:
+      lzham_timer();
+      lzham_timer(timer_ticks start_ticks);
+      
+      void start();
+      void start(timer_ticks start_ticks);
+      
+      void stop();
+         
+      double get_elapsed_secs() const;
+      inline double get_elapsed_ms() const { return get_elapsed_secs() * 1000.0f; }
+      timer_ticks get_elapsed_us() const;
+      
+      static void init();
+      static inline timer_ticks get_ticks_per_sec() { return g_freq; }
+      static timer_ticks get_init_ticks();
+      static timer_ticks get_ticks();
+      static double ticks_to_secs(timer_ticks ticks);
+      static inline double ticks_to_ms(timer_ticks ticks) { return ticks_to_secs(ticks) * 1000.0f; }
+      static inline double get_secs() { return ticks_to_secs(get_ticks()); }
+      static inline double get_ms() { return ticks_to_ms(get_ticks()); }
+                   
+   private:
+      static timer_ticks g_init_ticks;
+      static timer_ticks g_freq;
+      static double g_inv_freq;
+      
+      timer_ticks m_start_time;
+      timer_ticks m_stop_time;
+      
+      bool m_started : 1;
+      bool m_stopped : 1;
+   };
+
+   enum var_args_t { cVarArgs };
+   
+#if LZHAM_PERF_SECTIONS
+   class scoped_perf_section
+   {
+   public:
+      inline scoped_perf_section() :
+         m_start_ticks(lzham_timer::get_ticks())
+      {
+         m_name[0] = '?';
+         m_name[1] = '\0';
+      }
+      
+      inline scoped_perf_section(const char *pName) :
+         m_start_ticks(lzham_timer::get_ticks())
+      {
+         strcpy_s(m_name, pName);
+         
+         lzham_buffered_printf("Thread: 0x%08X, BEGIN Time: %3.3fms, Section: %s\n", GetCurrentThreadId(), lzham_timer::ticks_to_ms(m_start_ticks), m_name);
+      }
+      
+      inline scoped_perf_section(var_args_t, const char *pName, ...) :
+         m_start_ticks(lzham_timer::get_ticks())
+      {
+         va_list args;
+         va_start(args, pName);
+         vsprintf_s(m_name, sizeof(m_name), pName, args);
+         va_end(args);
+         
+         lzham_buffered_printf("Thread: 0x%08X, BEGIN Time: %3.3fms, Section: %s\n", GetCurrentThreadId(), lzham_timer::ticks_to_ms(m_start_ticks), m_name);
+      }
+   
+      inline ~scoped_perf_section()
+      {
+         double end_ms = lzham_timer::get_ms();
+         double start_ms = lzham_timer::ticks_to_ms(m_start_ticks);
+         
+         lzham_buffered_printf("Thread: 0x%08X, END Time: %3.3fms, Total: %3.3fms, Section: %s\n", GetCurrentThreadId(), end_ms, end_ms - start_ms, m_name);
+      }
+
+   private:
+      char m_name[64];   
+      timer_ticks m_start_ticks;
+   };
+#else
+   class scoped_perf_section
+   {
+   public:
+      inline scoped_perf_section() { }
+      inline scoped_perf_section(const char *pName) { (void)pName; }
+      inline scoped_perf_section(var_args_t, const char *pName, ...) { (void)pName; }
+   };
+#endif // LZHAM_PERF_SECTIONS   
+
+} // namespace lzham

data/contrib/lzham/lzhamdecomp/lzham_traits.h

@@ -0,0 +1,141 @@
+// File: lzham_traits.h
+// See Copyright Notice and license at the end of include/lzham.h
+#pragma once
+
+namespace lzham
+{
+   template<typename T>
+   struct scalar_type
+   {
+      enum { cFlag = false };
+      static inline void construct(T* p) { helpers::construct(p); }
+      static inline void construct(T* p, const T& init) { helpers::construct(p, init); }
+      static inline void construct_array(T* p, uint n) { helpers::construct_array(p, n); }
+      static inline void destruct(T* p) { helpers::destruct(p); }
+      static inline void destruct_array(T* p, uint n) { helpers::destruct_array(p, n); }
+   };
+
+   template<typename T> struct scalar_type<T*>
+   {
+      enum { cFlag = true };
+      static inline void construct(T** p) { memset(p, 0, sizeof(T*)); }
+      static inline void construct(T** p, T* init) { *p = init; }
+      static inline void construct_array(T** p, uint n) { memset(p, 0, sizeof(T*) * n); }
+      static inline void destruct(T** p) { LZHAM_NOTE_UNUSED(p); }
+      static inline void destruct_array(T** p, uint n) { LZHAM_NOTE_UNUSED(p); LZHAM_NOTE_UNUSED(n); }
+   };
+
+#define LZHAM_DEFINE_BUILT_IN_TYPE(X) \
+   template<> struct scalar_type<X> { \
+   enum { cFlag = true }; \
+   static inline void construct(X* p) { memset(p, 0, sizeof(X)); } \
+   static inline void construct(X* p, const X& init) { memcpy(p, &init, sizeof(X)); } \
+   static inline void construct_array(X* p, uint n) { memset(p, 0, sizeof(X) * n); } \
+   static inline void destruct(X* p) { LZHAM_NOTE_UNUSED(p); } \
+   static inline void destruct_array(X* p, uint n) { LZHAM_NOTE_UNUSED(p); LZHAM_NOTE_UNUSED(n); } };
+
+   LZHAM_DEFINE_BUILT_IN_TYPE(bool)
+   LZHAM_DEFINE_BUILT_IN_TYPE(char)
+   LZHAM_DEFINE_BUILT_IN_TYPE(unsigned char)
+   LZHAM_DEFINE_BUILT_IN_TYPE(short)
+   LZHAM_DEFINE_BUILT_IN_TYPE(unsigned short)
+   LZHAM_DEFINE_BUILT_IN_TYPE(int)
+   LZHAM_DEFINE_BUILT_IN_TYPE(unsigned int)
+   LZHAM_DEFINE_BUILT_IN_TYPE(long)
+   LZHAM_DEFINE_BUILT_IN_TYPE(unsigned long)
+   LZHAM_DEFINE_BUILT_IN_TYPE(float)
+   LZHAM_DEFINE_BUILT_IN_TYPE(double)
+   LZHAM_DEFINE_BUILT_IN_TYPE(long double)
+   #if defined(WIN32)
+      LZHAM_DEFINE_BUILT_IN_TYPE(__int64)
+      LZHAM_DEFINE_BUILT_IN_TYPE(unsigned __int64)
+   #endif
+
+#undef LZHAM_DEFINE_BUILT_IN_TYPE
+
+// See: http://erdani.org/publications/cuj-2004-06.pdf
+
+   template<typename T>
+   struct bitwise_movable { enum { cFlag = false }; };
+
+// Defines type Q as bitwise movable.
+#define LZHAM_DEFINE_BITWISE_MOVABLE(Q) template<> struct bitwise_movable<Q> { enum { cFlag = true }; };
+
+   template<typename T>
+   struct bitwise_copyable { enum { cFlag = false }; };
+
+   // Defines type Q as bitwise copyable.
+#define LZHAM_DEFINE_BITWISE_COPYABLE(Q) template<> struct bitwise_copyable<Q> { enum { cFlag = true }; };
+
+#if defined(__APPLE__) || defined(__NetBSD__)
+   #define LZHAM_IS_POD(T) std::__is_pod<T>::__value
+#else
+   #define LZHAM_IS_POD(T) __is_pod(T)
+#endif
+
+#define LZHAM_IS_SCALAR_TYPE(T) (scalar_type<T>::cFlag)
+
+#define LZHAM_IS_BITWISE_COPYABLE(T) ((scalar_type<T>::cFlag) || (bitwise_copyable<T>::cFlag) || LZHAM_IS_POD(T))
+
+#define LZHAM_IS_BITWISE_MOVABLE(T) (LZHAM_IS_BITWISE_COPYABLE(T) || (bitwise_movable<T>::cFlag))
+
+#define LZHAM_HAS_DESTRUCTOR(T) ((!scalar_type<T>::cFlag) && (!LZHAM_IS_POD(T)))
+
+   // From yasli_traits.h:
+   // Credit goes to Boost;
+   // also found in the C++ Templates book by Vandevoorde and Josuttis
+
+   typedef char (&yes_t)[1];
+   typedef char (&no_t)[2];
+
+   template <class U> yes_t class_test(int U::*);
+   template <class U> no_t class_test(...);
+
+   template <class T> struct is_class
+   {
+      enum { value = (sizeof(class_test<T>(0)) == sizeof(yes_t)) };
+   };
+
+   template <typename T> struct is_pointer
+   {
+      enum { value = false };
+   };
+
+   template <typename T> struct is_pointer<T*>
+   {
+      enum { value = true };
+   };
+
+   LZHAM_DEFINE_BITWISE_COPYABLE(empty_type);
+   LZHAM_DEFINE_BITWISE_MOVABLE(empty_type);
+
+   namespace helpers
+   {
+      template <typename T>
+      inline void construct_array(T* p, uint n)
+      {
+         if (LZHAM_IS_SCALAR_TYPE(T))
+         {
+            memset(p, 0, sizeof(T) * n);
+         }
+         else
+         {
+            T* q = p + n;
+            for ( ; p != q; ++p)
+               new (static_cast<void*>(p)) T;
+         }
+      }
+
+      template <typename T>
+      inline void destruct_array(T* p, uint n)
+      {
+         if ( LZHAM_HAS_DESTRUCTOR(T) )
+         {
+            T* q = p + n;
+            for ( ; p != q; ++p)
+               p->~T();
+         }
+      }
+   }
+
+} // namespace lzham

data/contrib/lzham/lzhamdecomp/lzham_types.h

@@ -0,0 +1,97 @@
+// File: types.h
+// See Copyright Notice and license at the end of include/lzham.h
+#pragma once
+
+// TODO
+#if defined(__APPLE__) || defined(__FreeBSD__) || defined(__NetBSD__)
+   #undef INT8_MIN
+   #undef INT8_MAX
+   #undef UINT8_MIN
+   #undef UINT8_MAX
+
+   #undef INT16_MIN
+   #undef INT16_MAX
+   #undef UINT16_MIN
+   #undef UINT16_MAX
+
+   #undef INT32_MIN
+   #undef INT32_MAX
+   #undef UINT32_MIN
+   #undef UINT32_MAX
+
+   #undef INT64_MIN
+   #undef INT64_MAX
+   #undef UINT64_MIN
+   #undef UINT64_MAX
+#endif
+
+namespace lzham
+{
+   typedef unsigned char      uint8;
+   typedef signed char        int8;
+   typedef unsigned char      uint8;
+   typedef unsigned short     uint16;
+   typedef signed short       int16;
+   typedef unsigned int       uint32;
+   typedef uint32             uint;
+   typedef signed int         int32;
+
+   #ifdef _MSC_VER
+      typedef unsigned __int64      uint64;
+      typedef signed __int64        int64;
+   #else
+      typedef unsigned long long    uint64;
+      typedef long long             int64;
+   #endif
+
+   const uint8  UINT8_MIN  = 0;
+   const uint8  UINT8_MAX  = 0xFFU;
+   const uint16 UINT16_MIN = 0;
+   const uint16 UINT16_MAX = 0xFFFFU;
+   const uint32 UINT32_MIN = 0;
+   const uint32 UINT32_MAX = 0xFFFFFFFFU;
+   const uint64 UINT64_MIN = 0;
+   const uint64 UINT64_MAX = 0xFFFFFFFFFFFFFFFFULL;    //0xFFFFFFFFFFFFFFFFui64;
+
+   const int8  INT8_MIN  = -128;
+   const int8  INT8_MAX  = 127;
+   const int16 INT16_MIN = -32768;
+   const int16 INT16_MAX = 32767;
+   const int32 INT32_MIN = (-2147483647 - 1);
+   const int32 INT32_MAX = 2147483647;
+   const int64 INT64_MIN = (int64)0x8000000000000000ULL; //(-9223372036854775807i64 - 1);
+   const int64 INT64_MAX = (int64)0x7FFFFFFFFFFFFFFFULL; //9223372036854775807i64;
+
+#if LZHAM_64BIT_POINTERS
+   typedef uint64 uint_ptr;
+   typedef uint64 uint32_ptr;
+   typedef int64 signed_size_t;
+   typedef uint64 ptr_bits_t;
+   const ptr_bits_t PTR_BITS_XOR = 0xDB0DD4415C87DCF7ULL;
+#else
+   typedef unsigned int uint_ptr;
+   typedef unsigned int uint32_ptr;
+   typedef signed int signed_size_t;
+   typedef uint32 ptr_bits_t;
+   const ptr_bits_t PTR_BITS_XOR = 0x5C87DCF7UL;
+#endif
+   
+   enum
+   {
+      cInvalidIndex = -1
+   };
+
+   const uint cIntBits = sizeof(uint) * CHAR_BIT;
+
+   template<typename T> struct int_traits { enum { cMin = INT_MIN, cMax = INT_MAX, cSigned = true }; };
+   template<> struct int_traits<int8> { enum { cMin = INT8_MIN, cMax = INT8_MAX, cSigned = true }; };
+   template<> struct int_traits<int16> { enum { cMin = INT16_MIN, cMax = INT16_MAX, cSigned = true }; };
+   template<> struct int_traits<int32> { enum { cMin = INT32_MIN, cMax = INT32_MAX, cSigned = true }; };
+
+   template<> struct int_traits<uint> { enum { cMin = 0, cMax = UINT_MAX, cSigned = false }; };
+   template<> struct int_traits<uint8> { enum { cMin = 0, cMax = UINT8_MAX, cSigned = false }; };
+   template<> struct int_traits<uint16> { enum { cMin = 0, cMax = UINT16_MAX, cSigned = false }; };
+
+   struct empty_type { };
+
+} // namespace lzham

data/contrib/lzham/lzhamdecomp/lzham_utils.h

@@ -0,0 +1,58 @@
+// File: lzham_utils.h
+// See Copyright Notice and license at the end of include/lzham.h
+#pragma once
+
+#define LZHAM_GET_ALIGNMENT(v) ((!sizeof(v)) ? 1 : (__alignof(v) ? __alignof(v) : sizeof(uint32))) 
+
+#define LZHAM_MIN(a, b) (((a) < (b)) ? (a) : (b))
+#define LZHAM_MAX(a, b) (((a) < (b)) ? (b) : (a))
+
+template<class T, size_t N> T decay_array_to_subtype(T (&a)[N]);
+#define LZHAM_ARRAY_SIZE(X) (sizeof(X) / sizeof(decay_array_to_subtype(X)))
+
+namespace lzham
+{
+   namespace utils
+   {
+      template<typename T> inline void swap(T& l, T& r)
+      {
+         T temp(l);
+         l = r;
+         r = temp;
+      }
+      
+      template<typename T> inline void zero_object(T& obj)
+      {
+         memset(&obj, 0, sizeof(obj));
+      }
+                  
+      static inline uint32 swap32(uint32 x) { return ((x << 24U) | ((x << 8U) & 0x00FF0000U) | ((x >> 8U) & 0x0000FF00U) | (x >> 24U)); }
+      
+      inline uint count_leading_zeros16(uint v)
+      {
+         LZHAM_ASSERT(v < 0x10000);
+         
+         uint temp;
+         uint n = 16;
+         
+         temp = v >> 8;
+         if (temp) { n -=  8; v = temp; }
+
+         temp = v >> 4;
+         if (temp) { n -=  4; v = temp; }
+
+         temp = v >> 2;
+         if (temp) { n -=  2; v = temp; }
+
+         temp = v >> 1;
+         if (temp) { n -=  1; v = temp; }
+
+         if (v & 1) n--;
+
+         return n;
+      }
+      
+   }   // namespace utils
+         
+} // namespace lzham
+

data/contrib/lzham/lzhamdecomp/lzham_vector.cpp

@@ -0,0 +1,75 @@
+// File: lzham_vector.cpp
+// See Copyright Notice and license at the end of include/lzham.h
+#include "lzham_core.h"
+#include "lzham_vector.h"
+
+namespace lzham
+{
+   bool elemental_vector::increase_capacity(uint min_new_capacity, bool grow_hint, uint element_size, object_mover pMover, bool nofail)
+   {
+      LZHAM_ASSERT(m_size <= m_capacity);
+      
+#if LZHAM_64BIT_POINTERS
+      LZHAM_ASSUME(sizeof(void*) == sizeof(uint64));
+      LZHAM_ASSERT(min_new_capacity < (0x400000000ULL / element_size));
+#else      
+      LZHAM_ASSUME(sizeof(void*) == sizeof(uint32));
+      LZHAM_ASSERT(min_new_capacity < (0x7FFF0000U / element_size));
+#endif      
+
+      if (m_capacity >= min_new_capacity)
+         return true;
+
+      // new_capacity must be 64-bit when compiling on x64.
+		size_t new_capacity = (size_t)min_new_capacity;
+      if ((grow_hint) && (!math::is_power_of_2(static_cast<uint64>(new_capacity))))
+         new_capacity = static_cast<uint>(math::next_pow2(static_cast<uint64>(new_capacity)));
+
+      LZHAM_ASSERT(new_capacity && (new_capacity > m_capacity));
+
+      const size_t desired_size = element_size * new_capacity;
+      size_t actual_size;
+      if (!pMover)
+      {
+         void* new_p = lzham_realloc(m_p, desired_size, &actual_size, true);
+         if (!new_p)
+         {
+            if (nofail)
+               return false;
+               
+            char buf[256];
+            sprintf_s(buf, sizeof(buf), "vector: lzham_realloc() failed allocating %u bytes", desired_size);
+            LZHAM_FAIL(buf);
+         }
+         m_p = new_p;
+      }
+      else
+      {
+         void* new_p = lzham_malloc(desired_size, &actual_size);
+         if (!new_p)
+         {
+            if (nofail)
+               return false;
+               
+            char buf[256];
+            sprintf_s(buf, sizeof(buf), "vector: lzham_malloc() failed allocating %u bytes", desired_size);
+            LZHAM_FAIL(buf);
+         }
+         
+         (*pMover)(new_p, m_p, m_size);
+         
+         if (m_p)
+            lzham_free(m_p);
+
+         m_p = new_p;
+      }            
+      
+      if (actual_size > desired_size)
+         m_capacity = static_cast<uint>(actual_size / element_size);
+      else
+         m_capacity = static_cast<uint>(new_capacity);
+    
+      return true;
+   }
+
+} // namespace lzham