extlzham 0.0.1.PROTOTYPE

data/contrib/lzham/lzhamdecomp/lzham_mem.h

@@ -0,0 +1,112 @@
+// File: lzham_mem.h
+// See Copyright Notice and license at the end of include/lzham.h
+#pragma once
+
+namespace lzham
+{
+   void     lzham_mem_init();
+   
+   void*    lzham_malloc(size_t size, size_t* pActual_size = NULL);
+   void*    lzham_realloc(void* p, size_t size, size_t* pActual_size = NULL, bool movable = true);
+   void     lzham_free(void* p);
+   size_t   lzham_msize(void* p);
+
+   template<typename T>
+   inline T* lzham_new()
+   {
+      T* p = static_cast<T*>(lzham_malloc(sizeof(T)));
+      if (!p) return NULL;
+      if (LZHAM_IS_SCALAR_TYPE(T))
+         return p;
+      return helpers::construct(p);
+   }
+     
+   template<typename T, typename A>
+   inline T* lzham_new(const A& init0)
+   {
+      T* p = static_cast<T*>(lzham_malloc(sizeof(T)));
+      if (!p) return NULL;
+      return new (static_cast<void*>(p)) T(init0); 
+   }
+   
+   template<typename T, typename A, typename B>
+   inline T* lzham_new(const A& init0, const B& init1)
+   {
+      T* p = static_cast<T*>(lzham_malloc(sizeof(T)));
+      if (!p) return NULL;
+      return new (static_cast<void*>(p)) T(init0, init1); 
+   }
+   
+   template<typename T, typename A, typename B, typename C>
+   inline T* lzham_new(const A& init0, const B& init1, const C& init2)
+   {
+      T* p = static_cast<T*>(lzham_malloc(sizeof(T)));
+      if (!p) return NULL;
+      return new (static_cast<void*>(p)) T(init0, init1, init2); 
+   }
+   
+   template<typename T, typename A, typename B, typename C, typename D>
+   inline T* lzham_new(const A& init0, const B& init1, const C& init2, const D& init3)
+   {
+      T* p = static_cast<T*>(lzham_malloc(sizeof(T)));
+      if (!p) return NULL;
+      return new (static_cast<void*>(p)) T(init0, init1, init2, init3); 
+   }
+
+   template<typename T>
+   inline T* lzham_new_array(uint32 num)
+   {
+      if (!num) num = 1;
+
+      uint8* q = static_cast<uint8*>(lzham_malloc(LZHAM_MIN_ALLOC_ALIGNMENT + sizeof(T) * num));
+      if (!q)
+         return NULL;
+
+      T* p = reinterpret_cast<T*>(q + LZHAM_MIN_ALLOC_ALIGNMENT);
+
+      reinterpret_cast<uint32*>(p)[-1] = num;
+      reinterpret_cast<uint32*>(p)[-2] = ~num;
+
+      if (!LZHAM_IS_SCALAR_TYPE(T))
+      {
+         helpers::construct_array(p, num);
+      }
+      return p;
+   }
+
+   template<typename T> 
+   inline void lzham_delete(T* p)
+   {
+      if (p) 
+      {
+         if (!LZHAM_IS_SCALAR_TYPE(T))
+         {
+            helpers::destruct(p);
+         }
+         lzham_free(p);
+      }         
+   }
+
+   template<typename T> 
+   inline void lzham_delete_array(T* p)
+   {
+      if (p)
+      {
+         const uint32 num = reinterpret_cast<uint32*>(p)[-1];
+         const uint32 num_check = reinterpret_cast<uint32*>(p)[-2];
+         LZHAM_ASSERT(num && (num == ~num_check));
+         if (num == ~num_check)
+         {
+            if (!LZHAM_IS_SCALAR_TYPE(T))
+            {
+               helpers::destruct_array(p, num);
+            }
+
+            lzham_free(reinterpret_cast<uint8*>(p) - LZHAM_MIN_ALLOC_ALIGNMENT);
+         }
+      }
+   }   
+   
+   void lzham_print_mem_stats();
+
+} // namespace lzham

data/contrib/lzham/lzhamdecomp/lzham_platform.cpp

@@ -0,0 +1,157 @@
+// File: platform.cpp
+// See Copyright Notice and license at the end of include/lzham.h
+#include "lzham_core.h"
+#include "lzham_timer.h"
+#include <assert.h>
+
+#if LZHAM_PLATFORM_X360
+#include <xbdm.h>
+#endif
+
+#define LZHAM_FORCE_DEBUGGER_PRESENT 1
+
+#ifndef _MSC_VER
+int sprintf_s(char *buffer, size_t sizeOfBuffer, const char *format, ...)
+{
+   if (!sizeOfBuffer)
+      return 0;
+
+   va_list args;
+   va_start(args, format);
+   int c = vsnprintf(buffer, sizeOfBuffer, format, args);
+   va_end(args);
+
+   buffer[sizeOfBuffer - 1] = '\0';
+
+   if (c < 0)
+      return static_cast<int>(sizeOfBuffer - 1);
+
+   return LZHAM_MIN(c, (int)sizeOfBuffer - 1);
+}
+int vsprintf_s(char *buffer, size_t sizeOfBuffer, const char *format, va_list args)
+{
+   if (!sizeOfBuffer)
+      return 0;
+
+   int c = vsnprintf(buffer, sizeOfBuffer, format, args);
+
+   buffer[sizeOfBuffer - 1] = '\0';
+
+   if (c < 0)
+      return static_cast<int>(sizeOfBuffer - 1);
+
+   return LZHAM_MIN(c, (int)sizeOfBuffer - 1);
+}
+#endif // __GNUC__
+
+bool lzham_is_debugger_present(void)
+{
+#if LZHAM_PLATFORM_X360
+   return DmIsDebuggerPresent() != 0;
+#elif LZHAM_USE_WIN32_API
+   return IsDebuggerPresent() != 0;
+#elif LZHAM_FORCE_DEBUGGER_PRESENT
+   return true;
+#else
+   return false;
+#endif
+}
+
+void lzham_debug_break(void)
+{
+#if LZHAM_USE_WIN32_API
+   DebugBreak();
+#elif (TARGET_OS_MAC == 1) && (TARGET_IPHONE_SIMULATOR == 0) && (TARGET_OS_IPHONE == 0)
+   __asm {int 3}
+#else
+   assert(0);
+#endif
+}
+
+void lzham_output_debug_string(const char* p)
+{
+   LZHAM_NOTE_UNUSED(p);
+#if LZHAM_USE_WIN32_API
+   OutputDebugStringA(p);
+#else
+   fputs(p, stderr);
+#endif
+}
+
+#if LZHAM_BUFFERED_PRINTF
+// This stuff was a quick hack only intended for debugging/development.
+namespace lzham
+{
+   struct buffered_str
+   {
+      enum { cBufSize = 256 };
+      char m_buf[cBufSize];
+   };
+
+   static lzham::vector<buffered_str> g_buffered_strings;
+   static volatile long g_buffered_string_locked;
+   
+   static void lock_buffered_strings()
+   {
+      while (atomic_exchange32(&g_buffered_string_locked, 1) == 1)
+      {
+         lzham_yield_processor();
+         lzham_yield_processor();
+         lzham_yield_processor();
+         lzham_yield_processor();
+      }
+
+      LZHAM_MEMORY_IMPORT_BARRIER
+   }
+   
+   static void unlock_buffered_strings()
+   {
+      LZHAM_MEMORY_EXPORT_BARRIER
+
+      atomic_exchange32(&g_buffered_string_locked, 0);
+   }
+
+} // namespace lzham
+
+void lzham_buffered_printf(const char *format, ...)
+{
+   format;
+   
+   char buf[lzham::buffered_str::cBufSize];
+   
+   va_list args;
+   va_start(args, format);
+   vsnprintf_s(buf, sizeof(buf), sizeof(buf), format, args);
+   va_end(args);   
+
+   buf[sizeof(buf) - 1] = '\0';
+   
+   lzham::lock_buffered_strings();
+   
+   if (!lzham::g_buffered_strings.capacity())
+   {
+      lzham::g_buffered_strings.try_reserve(2048);
+   }
+
+   if (lzham::g_buffered_strings.try_resize(lzham::g_buffered_strings.size() + 1))
+   {
+      memcpy(lzham::g_buffered_strings.back().m_buf, buf, sizeof(buf));
+   }
+
+   lzham::unlock_buffered_strings();
+}
+
+void lzham_flush_buffered_printf()
+{
+   lzham::lock_buffered_strings();
+
+   for (lzham::uint i = 0; i < lzham::g_buffered_strings.size(); i++)
+   {
+      printf("%s", lzham::g_buffered_strings[i].m_buf);
+   }
+
+   lzham::g_buffered_strings.try_resize(0);
+
+   lzham::unlock_buffered_strings();
+}
+#endif   

data/contrib/lzham/lzhamdecomp/lzham_platform.h

@@ -0,0 +1,284 @@
+// File: lzham_platform.h
+// See Copyright Notice and license at the end of include/lzham.h
+#pragma once
+
+bool lzham_is_debugger_present(void);
+void lzham_debug_break(void);
+void lzham_output_debug_string(const char* p);
+
+// actually in lzham_assert.cpp
+void lzham_assert(const char* pExp, const char* pFile, unsigned line);
+void lzham_fail(const char* pExp, const char* pFile, unsigned line);
+
+#ifdef WIN32
+   #define LZHAM_BREAKPOINT DebuggerBreak();
+   #define LZHAM_BUILTIN_EXPECT(c, v) c
+#elif defined(__GNUC__)
+   #define LZHAM_BREAKPOINT asm("int $3");
+   #define LZHAM_BUILTIN_EXPECT(c, v) __builtin_expect(c, v)
+#else
+   #define LZHAM_BREAKPOINT
+   #define LZHAM_BUILTIN_EXPECT(c, v) c
+#endif
+
+#if defined(__GNUC__) && LZHAM_PLATFORM_PC
+extern __inline__ __attribute__((__always_inline__,__gnu_inline__)) void lzham_yield_processor()
+{
+   __asm__ __volatile__("pause");
+}
+#elif LZHAM_PLATFORM_X360
+#define lzham_yield_processor() \
+   YieldProcessor(); \
+   __asm { or r0, r0, r0 } \
+   YieldProcessor(); \
+   __asm { or r1, r1, r1 } \
+   YieldProcessor(); \
+   __asm { or r0, r0, r0 } \
+   YieldProcessor(); \
+   __asm { or r1, r1, r1 } \
+   YieldProcessor(); \
+   __asm { or r0, r0, r0 } \
+   YieldProcessor(); \
+   __asm { or r1, r1, r1 } \
+   YieldProcessor(); \
+   __asm { or r0, r0, r0 } \
+   YieldProcessor(); \
+   __asm { or r1, r1, r1 }
+#else
+LZHAM_FORCE_INLINE void lzham_yield_processor()
+{
+#if LZHAM_USE_MSVC_INTRINSICS
+   #if LZHAM_PLATFORM_PC_X64
+      _mm_pause();
+   #else
+      YieldProcessor();
+   #endif
+#else
+   // No implementation
+#endif
+}
+#endif
+
+#ifndef _MSC_VER
+   int sprintf_s(char *buffer, size_t sizeOfBuffer, const char *format, ...);
+   int vsprintf_s(char *buffer, size_t sizeOfBuffer, const char *format, va_list args);
+#endif
+
+#if LZHAM_PLATFORM_X360
+   #define LZHAM_MEMORY_EXPORT_BARRIER MemoryBarrier();
+#else
+   // Barriers shouldn't be necessary on x86/x64.
+   // TODO: Should use __sync_synchronize() on other platforms that support GCC.
+   #define LZHAM_MEMORY_EXPORT_BARRIER
+#endif
+
+#if LZHAM_PLATFORM_X360
+   #define LZHAM_MEMORY_IMPORT_BARRIER MemoryBarrier();
+#else
+   // Barriers shouldn't be necessary on x86/x64.
+   // TODO: Should use __sync_synchronize() on other platforms that support GCC.
+   #define LZHAM_MEMORY_IMPORT_BARRIER
+#endif
+
+// Note: It's very important that LZHAM_READ_BIG_ENDIAN_UINT32() is fast on the target platform.
+// This is used to read every DWORD from the input stream.
+
+#if LZHAM_USE_UNALIGNED_INT_LOADS
+   #if LZHAM_BIG_ENDIAN_CPU
+      #define LZHAM_READ_BIG_ENDIAN_UINT32(p) *reinterpret_cast<const uint32*>(p)
+   #else
+      #if defined(LZHAM_USE_MSVC_INTRINSICS)
+         #define LZHAM_READ_BIG_ENDIAN_UINT32(p) _byteswap_ulong(*reinterpret_cast<const uint32*>(p))
+      #elif defined(__GNUC__)
+         #define LZHAM_READ_BIG_ENDIAN_UINT32(p) __builtin_bswap32(*reinterpret_cast<const uint32*>(p))
+      #else
+         #define LZHAM_READ_BIG_ENDIAN_UINT32(p) utils::swap32(*reinterpret_cast<const uint32*>(p))
+      #endif
+   #endif
+#else
+   #define LZHAM_READ_BIG_ENDIAN_UINT32(p) ((reinterpret_cast<const uint8*>(p)[0] << 24) | (reinterpret_cast<const uint8*>(p)[1] << 16) | (reinterpret_cast<const uint8*>(p)[2] << 8) | (reinterpret_cast<const uint8*>(p)[3]))
+#endif
+
+#if LZHAM_USE_WIN32_ATOMIC_FUNCTIONS
+   extern "C" __int64 _InterlockedCompareExchange64(__int64 volatile * Destination, __int64 Exchange, __int64 Comperand);
+   #if defined(_MSC_VER)
+      #pragma intrinsic(_InterlockedCompareExchange64)
+   #endif
+#endif // LZHAM_USE_WIN32_ATOMIC_FUNCTIONS
+
+namespace lzham
+{
+#if LZHAM_USE_WIN32_ATOMIC_FUNCTIONS
+   typedef LONG atomic32_t;
+   typedef LONGLONG atomic64_t;
+
+   // Returns the original value.
+   inline atomic32_t atomic_compare_exchange32(atomic32_t volatile *pDest, atomic32_t exchange, atomic32_t comparand)
+   {
+      LZHAM_ASSERT((reinterpret_cast<ptr_bits_t>(pDest) & 3) == 0);
+      return InterlockedCompareExchange(pDest, exchange, comparand);
+   }
+
+   // Returns the original value.
+   inline atomic64_t atomic_compare_exchange64(atomic64_t volatile *pDest, atomic64_t exchange, atomic64_t comparand)
+   {
+      LZHAM_ASSERT((reinterpret_cast<ptr_bits_t>(pDest) & 7) == 0);
+      return _InterlockedCompareExchange64(pDest, exchange, comparand);
+   }
+
+   // Returns the resulting incremented value.
+   inline atomic32_t atomic_increment32(atomic32_t volatile *pDest)
+   {
+      LZHAM_ASSERT((reinterpret_cast<ptr_bits_t>(pDest) & 3) == 0);
+      return InterlockedIncrement(pDest);
+   }
+
+   // Returns the resulting decremented value.
+   inline atomic32_t atomic_decrement32(atomic32_t volatile *pDest)
+   {
+      LZHAM_ASSERT((reinterpret_cast<ptr_bits_t>(pDest) & 3) == 0);
+      return InterlockedDecrement(pDest);
+   }
+
+   // Returns the original value.
+   inline atomic32_t atomic_exchange32(atomic32_t volatile *pDest, atomic32_t val)
+   {
+      LZHAM_ASSERT((reinterpret_cast<ptr_bits_t>(pDest) & 3) == 0);
+      return InterlockedExchange(pDest, val);
+   }
+
+   // Returns the resulting value.
+   inline atomic32_t atomic_add32(atomic32_t volatile *pDest, atomic32_t val)
+   {
+      LZHAM_ASSERT((reinterpret_cast<ptr_bits_t>(pDest) & 3) == 0);
+      return InterlockedExchangeAdd(pDest, val) + val;
+   }
+
+   // Returns the original value.
+   inline atomic32_t atomic_exchange_add(atomic32_t volatile *pDest, atomic32_t val)
+   {
+      LZHAM_ASSERT((reinterpret_cast<ptr_bits_t>(pDest) & 3) == 0);
+      return InterlockedExchangeAdd(pDest, val);
+   }
+#elif LZHAM_USE_GCC_ATOMIC_BUILTINS
+   typedef long atomic32_t;
+   typedef long long atomic64_t;
+
+   // Returns the original value.
+   inline atomic32_t atomic_compare_exchange32(atomic32_t volatile *pDest, atomic32_t exchange, atomic32_t comparand)
+   {
+      LZHAM_ASSERT((reinterpret_cast<ptr_bits_t>(pDest) & 3) == 0);
+      return __sync_val_compare_and_swap(pDest, comparand, exchange);
+   }
+
+   // Returns the original value.
+   inline atomic64_t atomic_compare_exchange64(atomic64_t volatile *pDest, atomic64_t exchange, atomic64_t comparand)
+   {
+      LZHAM_ASSERT((reinterpret_cast<ptr_bits_t>(pDest) & 7) == 0);
+      return __sync_val_compare_and_swap(pDest, comparand, exchange);
+   }
+
+   // Returns the resulting incremented value.
+   inline atomic32_t atomic_increment32(atomic32_t volatile *pDest)
+   {
+      LZHAM_ASSERT((reinterpret_cast<ptr_bits_t>(pDest) & 3) == 0);
+      return __sync_add_and_fetch(pDest, 1);
+   }
+
+   // Returns the resulting decremented value.
+   inline atomic32_t atomic_decrement32(atomic32_t volatile *pDest)
+   {
+      LZHAM_ASSERT((reinterpret_cast<ptr_bits_t>(pDest) & 3) == 0);
+      return __sync_sub_and_fetch(pDest, 1);
+   }
+
+   // Returns the original value.
+   inline atomic32_t atomic_exchange32(atomic32_t volatile *pDest, atomic32_t val)
+   {
+      LZHAM_ASSERT((reinterpret_cast<ptr_bits_t>(pDest) & 3) == 0);
+      return __sync_lock_test_and_set(pDest, val);
+   }
+
+   // Returns the resulting value.
+   inline atomic32_t atomic_add32(atomic32_t volatile *pDest, atomic32_t val)
+   {
+      LZHAM_ASSERT((reinterpret_cast<ptr_bits_t>(pDest) & 3) == 0);
+      return __sync_add_and_fetch(pDest, val);
+   }
+
+   // Returns the original value.
+   inline atomic32_t atomic_exchange_add(atomic32_t volatile *pDest, atomic32_t val)
+   {
+      LZHAM_ASSERT((reinterpret_cast<ptr_bits_t>(pDest) & 3) == 0);
+      return __sync_fetch_and_add(pDest, val);
+   }
+#else
+   #define LZHAM_NO_ATOMICS 1
+
+   // Atomic ops not supported - but try to do something reasonable. Assumes no threading at all.
+   typedef long atomic32_t;
+   typedef long long atomic64_t;
+
+   inline atomic32_t atomic_compare_exchange32(atomic32_t volatile *pDest, atomic32_t exchange, atomic32_t comparand)
+   {
+      LZHAM_ASSERT((reinterpret_cast<ptr_bits_t>(pDest) & 3) == 0);
+      atomic32_t cur = *pDest;
+      if (cur == comparand)
+         *pDest = exchange;
+      return cur;
+   }
+
+   inline atomic64_t atomic_compare_exchange64(atomic64_t volatile *pDest, atomic64_t exchange, atomic64_t comparand)
+   {
+      LZHAM_ASSERT((reinterpret_cast<ptr_bits_t>(pDest) & 7) == 0);
+      atomic64_t cur = *pDest;
+      if (cur == comparand)
+         *pDest = exchange;
+      return cur;
+   }
+
+   inline atomic32_t atomic_increment32(atomic32_t volatile *pDest)
+   {
+      LZHAM_ASSERT((reinterpret_cast<ptr_bits_t>(pDest) & 3) == 0);
+      return (*pDest += 1);
+   }
+
+   inline atomic32_t atomic_decrement32(atomic32_t volatile *pDest)
+   {
+      LZHAM_ASSERT((reinterpret_cast<ptr_bits_t>(pDest) & 3) == 0);
+      return (*pDest -= 1);
+   }
+
+   inline atomic32_t atomic_exchange32(atomic32_t volatile *pDest, atomic32_t val)
+   {
+      LZHAM_ASSERT((reinterpret_cast<ptr_bits_t>(pDest) & 3) == 0);
+      atomic32_t cur = *pDest;
+      *pDest = val;
+      return cur;
+   }
+
+   inline atomic32_t atomic_add32(atomic32_t volatile *pDest, atomic32_t val)
+   {
+      LZHAM_ASSERT((reinterpret_cast<ptr_bits_t>(pDest) & 3) == 0);
+      return (*pDest += val);
+   }
+
+   inline atomic32_t atomic_exchange_add(atomic32_t volatile *pDest, atomic32_t val)
+   {
+      LZHAM_ASSERT((reinterpret_cast<ptr_bits_t>(pDest) & 3) == 0);
+      atomic32_t cur = *pDest;
+      *pDest += val;
+      return cur;
+   }
+
+#endif
+
+#if LZHAM_BUFFERED_PRINTF
+   void lzham_buffered_printf(const char *format, ...);
+   void lzham_flush_buffered_printf();
+#else
+   inline void lzham_buffered_printf(const char *format, ...) { (void)format; }
+   inline void lzham_flush_buffered_printf() { }
+#endif
+
+} // namespace lzham