This patch adds Jordan's romtool support for v2.

There are a few changes. The 20K bootblock size restriction is gone. 

ROMFS has been tested and works on v2 with qemu and kontron. Once this 
patch is in, those patches will follow. 

Signed-off-by: Ronald G. Minnich <rminnich@gmail.com>
Acked-by: Patrick Georgi <patrick.georgi@coresystems.de>


git-svn-id: svn://svn.coreboot.org/coreboot/trunk@4032 2b7e53f0-3cfb-0310-b3e9-8179ed1497e1

13 files changed, 803 insertions, 0 deletions

diff --git a/util/romtool/tools/lzma/C/Common/Alloc.cpp b/util/romtool/tools/lzma/C/Common/Alloc.cpp
new file mode 100644
index 0000000000..dcb331ee9f
--- /dev/null
+++ b/util/romtool/tools/lzma/C/Common/Alloc.cpp
@@ -0,0 +1,118 @@
+// Common/Alloc.cpp

+

+#include "StdAfx.h"

+

+#ifdef _WIN32

+#include "MyWindows.h"

+#else

+#include <stdlib.h>

+#endif

+

+#include "Alloc.h"

+

+/* #define _SZ_ALLOC_DEBUG */

+/* use _SZ_ALLOC_DEBUG to debug alloc/free operations */

+#ifdef _SZ_ALLOC_DEBUG

+#include <stdio.h>

+int g_allocCount = 0;

+int g_allocCountMid = 0;

+int g_allocCountBig = 0;

+#endif

+

+void *MyAlloc(size_t size) throw()

+{

+  if (size == 0)

+    return 0;

+  #ifdef _SZ_ALLOC_DEBUG

+  fprintf(stderr, "\nAlloc %10d bytes; count = %10d", size, g_allocCount++);

+  #endif

+  return ::malloc(size);

+}

+

+void MyFree(void *address) throw()

+{

+  #ifdef _SZ_ALLOC_DEBUG

+  if (address != 0)

+    fprintf(stderr, "\nFree; count = %10d", --g_allocCount);

+  #endif

+  

+  ::free(address);

+}

+

+#ifdef _WIN32

+

+void *MidAlloc(size_t size) throw()

+{

+  if (size == 0)

+    return 0;

+  #ifdef _SZ_ALLOC_DEBUG

+  fprintf(stderr, "\nAlloc_Mid %10d bytes;  count = %10d", size, g_allocCountMid++);

+  #endif

+  return ::VirtualAlloc(0, size, MEM_COMMIT, PAGE_READWRITE);

+}

+

+void MidFree(void *address) throw()

+{

+  #ifdef _SZ_ALLOC_DEBUG

+  if (address != 0)

+    fprintf(stderr, "\nFree_Mid; count = %10d", --g_allocCountMid);

+  #endif

+  if (address == 0)

+    return;

+  ::VirtualFree(address, 0, MEM_RELEASE);

+}

+

+static SIZE_T g_LargePageSize = 

+    #ifdef _WIN64

+    (1 << 21);

+    #else

+    (1 << 22);

+    #endif

+

+typedef SIZE_T (WINAPI *GetLargePageMinimumP)();

+

+bool SetLargePageSize()

+{

+  GetLargePageMinimumP largePageMinimum = (GetLargePageMinimumP)

+        ::GetProcAddress(::GetModuleHandle(TEXT("kernel32.dll")), "GetLargePageMinimum");

+  if (largePageMinimum == 0)

+    return false;

+  SIZE_T size = largePageMinimum();

+  if (size == 0 || (size & (size - 1)) != 0)

+    return false;

+  g_LargePageSize = size;

+  return true;

+}

+

+

+void *BigAlloc(size_t size) throw()

+{

+  if (size == 0)

+    return 0;

+  #ifdef _SZ_ALLOC_DEBUG

+  fprintf(stderr, "\nAlloc_Big %10d bytes;  count = %10d", size, g_allocCountBig++);

+  #endif

+  

+  if (size >= (1 << 18))

+  {

+    void *res = ::VirtualAlloc(0, (size + g_LargePageSize - 1) & (~(g_LargePageSize - 1)), 

+        MEM_COMMIT | MEM_LARGE_PAGES, PAGE_READWRITE);

+    if (res != 0)

+      return res;

+  }

+  return ::VirtualAlloc(0, size, MEM_COMMIT, PAGE_READWRITE);

+}

+

+void BigFree(void *address) throw()

+{

+  #ifdef _SZ_ALLOC_DEBUG

+  if (address != 0)

+    fprintf(stderr, "\nFree_Big; count = %10d", --g_allocCountBig);

+  #endif

+  

+  if (address == 0)

+    return;

+  ::VirtualFree(address, 0, MEM_RELEASE);

+}

+

+#endif

diff --git a/util/romtool/tools/lzma/C/Common/Alloc.h b/util/romtool/tools/lzma/C/Common/Alloc.h
new file mode 100644
index 0000000000..2ae3891de6
--- /dev/null
+++ b/util/romtool/tools/lzma/C/Common/Alloc.h
@@ -0,0 +1,29 @@
+// Common/Alloc.h

+

+#ifndef __COMMON_ALLOC_H

+#define __COMMON_ALLOC_H

+

+#include <stddef.h>

+

+void *MyAlloc(size_t size) throw();

+void MyFree(void *address) throw();

+

+#ifdef _WIN32

+

+bool SetLargePageSize();

+

+void *MidAlloc(size_t size) throw();

+void MidFree(void *address) throw();

+void *BigAlloc(size_t size) throw();

+void BigFree(void *address) throw();

+

+#else

+

+#define MidAlloc(size) MyAlloc(size)

+#define MidFree(address) MyFree(address)

+#define BigAlloc(size) MyAlloc(size)

+#define BigFree(address) MyFree(address)

+

+#endif

+

+#endif

diff --git a/util/romtool/tools/lzma/C/Common/CRC.cpp b/util/romtool/tools/lzma/C/Common/CRC.cpp
new file mode 100644
index 0000000000..92bc009c2f
--- /dev/null
+++ b/util/romtool/tools/lzma/C/Common/CRC.cpp
@@ -0,0 +1,61 @@
+// Common/CRC.cpp

+

+#include "StdAfx.h"

+

+#include "CRC.h"

+

+static const UInt32 kCRCPoly = 0xEDB88320;

+

+UInt32 CCRC::Table[256];

+

+void CCRC::InitTable()

+{

+  for (UInt32 i = 0; i < 256; i++)

+  {

+    UInt32 r = i;

+    for (int j = 0; j < 8; j++)

+      if (r & 1) 

+        r = (r >> 1) ^ kCRCPoly;

+      else     

+        r >>= 1;

+    CCRC::Table[i] = r;

+  }

+}

+

+class CCRCTableInit

+{

+public:

+  CCRCTableInit() { CCRC::InitTable(); }

+} g_CRCTableInit;

+

+void CCRC::UpdateByte(Byte b)

+{

+  _value = Table[((Byte)(_value)) ^ b] ^ (_value >> 8);

+}

+

+void CCRC::UpdateUInt16(UInt16 v)

+{

+  UpdateByte(Byte(v));

+  UpdateByte(Byte(v >> 8));

+}

+

+void CCRC::UpdateUInt32(UInt32 v)

+{

+  for (int i = 0; i < 4; i++)

+    UpdateByte((Byte)(v >> (8 * i)));

+}

+

+void CCRC::UpdateUInt64(UInt64 v)

+{

+  for (int i = 0; i < 8; i++)

+    UpdateByte((Byte)(v >> (8 * i)));

+}

+

+void CCRC::Update(const void *data, size_t size)

+{

+  UInt32 v = _value;

+  const Byte *p = (const Byte *)data;

+  for (; size > 0 ; size--, p++)

+    v = Table[((Byte)(v)) ^ *p] ^ (v >> 8);

+  _value = v;

+}

diff --git a/util/romtool/tools/lzma/C/Common/CRC.h b/util/romtool/tools/lzma/C/Common/CRC.h
new file mode 100644
index 0000000000..c9d43d0055
--- /dev/null
+++ b/util/romtool/tools/lzma/C/Common/CRC.h
@@ -0,0 +1,36 @@
+// Common/CRC.h

+

+#ifndef __COMMON_CRC_H

+#define __COMMON_CRC_H

+

+#include <stddef.h>

+#include "Types.h"

+

+class CCRC

+{

+  UInt32 _value;

+public:

+	static UInt32 Table[256];

+	static void InitTable();

+

+  CCRC():  _value(0xFFFFFFFF){};

+  void Init() { _value = 0xFFFFFFFF; }

+  void UpdateByte(Byte v);

+  void UpdateUInt16(UInt16 v);

+  void UpdateUInt32(UInt32 v);

+  void UpdateUInt64(UInt64 v);

+  void Update(const void *data, size_t size);

+  UInt32 GetDigest() const { return _value ^ 0xFFFFFFFF; } 

+  static UInt32 CalculateDigest(const void *data, size_t size)

+  {

+    CCRC crc;

+    crc.Update(data, size);

+    return crc.GetDigest();

+  }

+  static bool VerifyDigest(UInt32 digest, const void *data, size_t size)

+  {

+    return (CalculateDigest(data, size) == digest);

+  }

+};

+

+#endif

diff --git a/util/romtool/tools/lzma/C/Common/Defs.h b/util/romtool/tools/lzma/C/Common/Defs.h
new file mode 100644
index 0000000000..69b8ecea82
--- /dev/null
+++ b/util/romtool/tools/lzma/C/Common/Defs.h
@@ -0,0 +1,20 @@
+// Common/Defs.h

+

+#ifndef __COMMON_DEFS_H

+#define __COMMON_DEFS_H

+

+template <class T> inline T MyMin(T a, T b)

+  {  return a < b ? a : b; }

+template <class T> inline T MyMax(T a, T b)

+  {  return a > b ? a : b; }

+

+template <class T> inline int MyCompare(T a, T b)

+  {  return a < b ? -1 : (a == b ? 0 : 1); }

+

+inline int BoolToInt(bool value)

+  { return (value ? 1: 0); }

+

+inline bool IntToBool(int value)

+  { return (value != 0); }

+

+#endif

diff --git a/util/romtool/tools/lzma/C/Common/MyCom.h b/util/romtool/tools/lzma/C/Common/MyCom.h
new file mode 100644
index 0000000000..8476b57282
--- /dev/null
+++ b/util/romtool/tools/lzma/C/Common/MyCom.h
@@ -0,0 +1,203 @@
+// MyCom.h

+

+#ifndef __MYCOM_H

+#define __MYCOM_H

+

+#include "MyWindows.h"

+

+#define RINOK(x) { HRESULT __result_ = (x); if(__result_ != S_OK) return __result_; }

+

+template <class T>

+class CMyComPtr

+{

+  T* _p;

+public:

+  // typedef T _PtrClass;

+  CMyComPtr() { _p = NULL;}

+  CMyComPtr(T* p) {if ((_p = p) != NULL) p->AddRef(); }

+  CMyComPtr(const CMyComPtr<T>& lp)

+  {

+    if ((_p = lp._p) != NULL)

+      _p->AddRef();

+  }

+  ~CMyComPtr() { if (_p) _p->Release(); }

+  void Release() { if (_p) { _p->Release(); _p = NULL; } }

+  operator T*() const {  return (T*)_p;  }

+  // T& operator*() const {  return *_p; }

+  T** operator&() { return &_p; }

+  T* operator->() const { return _p; }

+  T* operator=(T* p) 

+  { 

+    if (p != 0)

+      p->AddRef();

+    if (_p) 

+      _p->Release();

+    _p = p;

+    return p;

+  }

+  T* operator=(const CMyComPtr<T>& lp) { return (*this = lp._p); }

+  bool operator!() const { return (_p == NULL); }

+  // bool operator==(T* pT) const {  return _p == pT; }

+  // Compare two objects for equivalence

+  void Attach(T* p2)

+  {

+    Release();

+    _p = p2;

+  }

+  T* Detach()

+  {

+    T* pt = _p;

+    _p = NULL;

+    return pt;

+  }

+  #ifdef _WIN32

+  HRESULT CoCreateInstance(REFCLSID rclsid, REFIID iid, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)

+  {

+    return ::CoCreateInstance(rclsid, pUnkOuter, dwClsContext, iid, (void**)&_p);

+  }

+  #endif

+  /*

+  HRESULT CoCreateInstance(LPCOLESTR szProgID, LPUNKNOWN pUnkOuter = NULL, DWORD dwClsContext = CLSCTX_ALL)

+  {

+    CLSID clsid;

+    HRESULT hr = CLSIDFromProgID(szProgID, &clsid);

+    ATLASSERT(_p == NULL);

+    if (SUCCEEDED(hr))

+      hr = ::CoCreateInstance(clsid, pUnkOuter, dwClsContext, __uuidof(T), (void**)&_p);

+    return hr;

+  }

+  */

+  template <class Q>

+  HRESULT QueryInterface(REFGUID iid, Q** pp) const

+  {

+    return _p->QueryInterface(iid, (void**)pp);

+  }

+};

+

+//////////////////////////////////////////////////////////

+

+class CMyComBSTR

+{

+public:

+  BSTR m_str;

+  CMyComBSTR() { m_str = NULL; }

+  CMyComBSTR(LPCOLESTR pSrc) {  m_str = ::SysAllocString(pSrc);  }

+  // CMyComBSTR(int nSize) { m_str = ::SysAllocStringLen(NULL, nSize); }

+  // CMyComBSTR(int nSize, LPCOLESTR sz) { m_str = ::SysAllocStringLen(sz, nSize);  }

+  CMyComBSTR(const CMyComBSTR& src) { m_str = src.MyCopy(); }

+  /*

+  CMyComBSTR(REFGUID src)

+  {

+    LPOLESTR szGuid;

+    StringFromCLSID(src, &szGuid);

+    m_str = ::SysAllocString(szGuid);

+    CoTaskMemFree(szGuid);

+  }

+  */

+  ~CMyComBSTR() { ::SysFreeString(m_str); }

+  CMyComBSTR& operator=(const CMyComBSTR& src)

+  {

+    if (m_str != src.m_str)

+    {

+      if (m_str)

+        ::SysFreeString(m_str);

+      m_str = src.MyCopy();

+    }

+    return *this;

+  }

+  CMyComBSTR& operator=(LPCOLESTR pSrc)

+  {

+    ::SysFreeString(m_str);

+    m_str = ::SysAllocString(pSrc);

+    return *this;

+  }

+  unsigned int Length() const { return ::SysStringLen(m_str); }

+  operator BSTR() const { return m_str; }

+  BSTR* operator&() { return &m_str; }

+  BSTR MyCopy() const 

+  { 

+    int byteLen = ::SysStringByteLen(m_str);

+    BSTR res = ::SysAllocStringByteLen(NULL, byteLen);

+    memmove(res, m_str, byteLen);

+    return res;

+  }

+  void Attach(BSTR src) {  m_str = src; }

+  BSTR Detach()

+  {

+    BSTR s = m_str;

+    m_str = NULL;

+    return s;

+  }

+  void Empty()

+  {

+    ::SysFreeString(m_str);

+    m_str = NULL;

+  }

+  bool operator!() const {  return (m_str == NULL); }

+};

+

+

+//////////////////////////////////////////////////////////

+

+class CMyUnknownImp

+{

+public:

+  ULONG __m_RefCount;

+  CMyUnknownImp(): __m_RefCount(0) {}

+};

+

+#define MY_QUERYINTERFACE_BEGIN STDMETHOD(QueryInterface) \

+    (REFGUID iid, void **outObject) { 

+

+#define MY_QUERYINTERFACE_ENTRY(i) if (iid == IID_ ## i) \

+    { *outObject = (void *)(i *)this; AddRef(); return S_OK; }

+

+#define MY_QUERYINTERFACE_END return E_NOINTERFACE; }

+

+#define MY_ADDREF_RELEASE \

+STDMETHOD_(ULONG, AddRef)() { return ++__m_RefCount; } \

+STDMETHOD_(ULONG, Release)() { if (--__m_RefCount != 0)  \

+  return __m_RefCount; delete this; return 0; }

+

+#define MY_UNKNOWN_IMP_SPEC(i) \

+  MY_QUERYINTERFACE_BEGIN \

+  i \

+  MY_QUERYINTERFACE_END \

+  MY_ADDREF_RELEASE

+

+

+#define MY_UNKNOWN_IMP STDMETHOD(QueryInterface)(REFGUID, void **) { \

+  MY_QUERYINTERFACE_END \

+  MY_ADDREF_RELEASE

+

+#define MY_UNKNOWN_IMP1(i) MY_UNKNOWN_IMP_SPEC( \

+  MY_QUERYINTERFACE_ENTRY(i) \

+  )

+

+#define MY_UNKNOWN_IMP2(i1, i2) MY_UNKNOWN_IMP_SPEC( \

+  MY_QUERYINTERFACE_ENTRY(i1) \

+  MY_QUERYINTERFACE_ENTRY(i2) \

+  )

+

+#define MY_UNKNOWN_IMP3(i1, i2, i3) MY_UNKNOWN_IMP_SPEC( \

+  MY_QUERYINTERFACE_ENTRY(i1) \

+  MY_QUERYINTERFACE_ENTRY(i2) \

+  MY_QUERYINTERFACE_ENTRY(i3) \

+  )

+

+#define MY_UNKNOWN_IMP4(i1, i2, i3, i4) MY_UNKNOWN_IMP_SPEC( \

+  MY_QUERYINTERFACE_ENTRY(i1) \

+  MY_QUERYINTERFACE_ENTRY(i2) \

+  MY_QUERYINTERFACE_ENTRY(i3) \

+  MY_QUERYINTERFACE_ENTRY(i4) \

+  )

+

+#define MY_UNKNOWN_IMP5(i1, i2, i3, i4, i5) MY_UNKNOWN_IMP_SPEC( \

+  MY_QUERYINTERFACE_ENTRY(i1) \

+  MY_QUERYINTERFACE_ENTRY(i2) \

+  MY_QUERYINTERFACE_ENTRY(i3) \

+  MY_QUERYINTERFACE_ENTRY(i4) \

+  MY_QUERYINTERFACE_ENTRY(i5) \

+  )

+

+#endif

diff --git a/util/romtool/tools/lzma/C/Common/MyGuidDef.h b/util/romtool/tools/lzma/C/Common/MyGuidDef.h
new file mode 100644
index 0000000000..889ea417b0
--- /dev/null
+++ b/util/romtool/tools/lzma/C/Common/MyGuidDef.h
@@ -0,0 +1,54 @@
+// Common/MyGuidDef.h

+

+#ifndef GUID_DEFINED

+#define GUID_DEFINED

+

+#include "Types.h"

+

+typedef struct {

+  UInt32 Data1;

+  UInt16 Data2;

+  UInt16 Data3;

+  unsigned char Data4[8];

+} GUID;

+

+#ifdef __cplusplus

+#define REFGUID const GUID &

+#else

+#define REFGUID const GUID *

+#endif

+

+#define REFCLSID REFGUID

+#define REFIID REFGUID

+

+#ifdef __cplusplus

+inline bool operator==(REFGUID g1, REFGUID g2)

+{ 

+  for (int i = 0; i < (int)sizeof(g1); i++)

+    if (((const unsigned char *)&g1)[i] != ((const unsigned char *)&g2)[i])

+      return false;

+  return true;

+}

+inline bool operator!=(REFGUID g1, REFGUID g2) { return !(g1 == g2); }

+#endif

+

+#ifdef __cplusplus

+  #define MY_EXTERN_C extern "C"

+#else

+  #define MY_EXTERN_C extern

+#endif

+

+#endif // GUID_DEFINED

+

+

+#ifdef DEFINE_GUID

+#undef DEFINE_GUID

+#endif

+

+#ifdef INITGUID

+  #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \

+    MY_EXTERN_C const GUID name = { l, w1, w2, { b1, b2,  b3,  b4,  b5,  b6,  b7,  b8 } }

+#else

+  #define DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \

+    MY_EXTERN_C const GUID name

+#endif

diff --git a/util/romtool/tools/lzma/C/Common/MyInitGuid.h b/util/romtool/tools/lzma/C/Common/MyInitGuid.h
new file mode 100644
index 0000000000..53b0f03428
--- /dev/null
+++ b/util/romtool/tools/lzma/C/Common/MyInitGuid.h
@@ -0,0 +1,13 @@
+// Common/MyInitGuid.h

+

+#ifndef __COMMON_MYINITGUID_H

+#define __COMMON_MYINITGUID_H

+

+#ifdef _WIN32

+#include <initguid.h>

+#else

+#define INITGUID

+#include "MyGuidDef.h"

+#endif

+

+#endif

diff --git a/util/romtool/tools/lzma/C/Common/MyUnknown.h b/util/romtool/tools/lzma/C/Common/MyUnknown.h
new file mode 100644
index 0000000000..6cd32caddb
--- /dev/null
+++ b/util/romtool/tools/lzma/C/Common/MyUnknown.h
@@ -0,0 +1,24 @@
+// MyUnknown.h

+

+#ifndef __MYUNKNOWN_H

+#define __MYUNKNOWN_H

+

+#ifdef _WIN32

+

+#ifdef _WIN32_WCE

+#if (_WIN32_WCE > 300)

+#include <basetyps.h>

+#else

+#define MIDL_INTERFACE(x) struct 

+#endif

+#else

+#include <basetyps.h>

+#endif

+

+#include <unknwn.h>

+

+#else 

+#include "MyWindows.h"

+#endif

+  

+#endif

diff --git a/util/romtool/tools/lzma/C/Common/MyWindows.h b/util/romtool/tools/lzma/C/Common/MyWindows.h
new file mode 100644
index 0000000000..2929be7c30
--- /dev/null
+++ b/util/romtool/tools/lzma/C/Common/MyWindows.h
@@ -0,0 +1,201 @@
+// MyWindows.h

+

+#ifndef __MYWINDOWS_H

+#define __MYWINDOWS_H

+

+#ifdef _WIN32

+

+#include <windows.h>

+

+#define CHAR_PATH_SEPARATOR '\\'

+#define WCHAR_PATH_SEPARATOR L'\\'

+#define STRING_PATH_SEPARATOR "\\"

+#define WSTRING_PATH_SEPARATOR L"\\"

+

+#else

+

+#define CHAR_PATH_SEPARATOR '/'

+#define WCHAR_PATH_SEPARATOR L'/'

+#define STRING_PATH_SEPARATOR "/"

+#define WSTRING_PATH_SEPARATOR L"/"

+

+#include <stddef.h> // for wchar_t

+#include <string.h>

+

+#include "MyGuidDef.h"

+

+typedef char CHAR;

+typedef unsigned char UCHAR;

+

+#undef BYTE

+typedef unsigned char BYTE;

+

+typedef short SHORT;

+typedef unsigned short USHORT;

+

+#undef WORD

+typedef unsigned short WORD;

+typedef short VARIANT_BOOL;

+

+typedef int INT;

+typedef Int32 INT32;

+typedef unsigned int UINT;

+typedef UInt32 UINT32;

+typedef INT32 LONG;   // LONG, ULONG and DWORD must be 32-bit

+typedef UINT32 ULONG;

+

+#undef DWORD

+typedef UINT32 DWORD;

+

+typedef Int64 LONGLONG;

+typedef UInt64 ULONGLONG;

+

+typedef struct LARGE_INTEGER { LONGLONG QuadPart; }LARGE_INTEGER;

+typedef struct _ULARGE_INTEGER { ULONGLONG QuadPart;} ULARGE_INTEGER;

+

+typedef const CHAR *LPCSTR;

+typedef CHAR TCHAR;

+typedef const TCHAR *LPCTSTR;

+typedef wchar_t WCHAR;

+typedef WCHAR OLECHAR;

+typedef const WCHAR *LPCWSTR;

+typedef OLECHAR *BSTR;

+typedef const OLECHAR *LPCOLESTR;

+typedef OLECHAR *LPOLESTR;

+

+typedef struct _FILETIME

+{

+  DWORD dwLowDateTime;

+  DWORD dwHighDateTime;

+}FILETIME;

+

+#define HRESULT LONG

+#define FAILED(Status) ((HRESULT)(Status)<0)

+typedef ULONG PROPID;

+typedef LONG SCODE;

+

+#define S_OK    ((HRESULT)0x00000000L)

+#define S_FALSE ((HRESULT)0x00000001L)

+#define E_NOTIMPL ((HRESULT)0x80004001L)

+#define E_NOINTERFACE ((HRESULT)0x80004002L)

+#define E_ABORT ((HRESULT)0x80004004L)

+#define E_FAIL ((HRESULT)0x80004005L)

+#define STG_E_INVALIDFUNCTION ((HRESULT)0x80030001L)

+#define E_OUTOFMEMORY ((HRESULT)0x8007000EL)

+#define E_INVALIDARG ((HRESULT)0x80070057L)

+

+#ifdef _MSC_VER

+#define STDMETHODCALLTYPE __stdcall 

+#else

+#define STDMETHODCALLTYPE 

+#endif

+

+#define STDMETHOD_(t, f) virtual t STDMETHODCALLTYPE f

+#define STDMETHOD(f) STDMETHOD_(HRESULT, f)

+#define STDMETHODIMP_(type) type STDMETHODCALLTYPE

+#define STDMETHODIMP STDMETHODIMP_(HRESULT)

+

+#define PURE = 0

+

+#define MIDL_INTERFACE(x) struct 

+

+struct IUnknown

+{

+  //virtual ~IUnknown() {}

+  STDMETHOD(QueryInterface) (REFIID iid, void **outObject) PURE;

+  STDMETHOD_(ULONG, AddRef)() PURE;

+  STDMETHOD_(ULONG, Release)() PURE;

+};

+

+typedef IUnknown *LPUNKNOWN;

+

+#define VARIANT_TRUE ((VARIANT_BOOL)-1)

+#define VARIANT_FALSE ((VARIANT_BOOL)0)

+

+enum VARENUM

+{	

+  VT_EMPTY	= 0,

+	VT_NULL	= 1,

+	VT_I2	= 2,

+	VT_I4	= 3,

+	VT_R4	= 4,

+	VT_R8	= 5,

+	VT_CY	= 6,

+	VT_DATE	= 7,

+	VT_BSTR	= 8,

+	VT_DISPATCH	= 9,

+	VT_ERROR	= 10,

+	VT_BOOL	= 11,

+	VT_VARIANT	= 12,

+	VT_UNKNOWN	= 13,

+	VT_DECIMAL	= 14,

+	VT_I1	= 16,

+	VT_UI1	= 17,

+	VT_UI2	= 18,

+	VT_UI4	= 19,

+	VT_I8	= 20,

+	VT_UI8	= 21,

+	VT_INT	= 22,

+	VT_UINT	= 23,

+	VT_VOID	= 24,

+	VT_HRESULT	= 25,

+	VT_FILETIME	= 64

+};

+

+typedef unsigned short VARTYPE;

+typedef WORD PROPVAR_PAD1;

+typedef WORD PROPVAR_PAD2;

+typedef WORD PROPVAR_PAD3;

+

+typedef struct tagPROPVARIANT

+{

+  VARTYPE vt;

+  PROPVAR_PAD1 wReserved1;

+  PROPVAR_PAD2 wReserved2;

+  PROPVAR_PAD3 wReserved3;

+  union 

+  {

+    CHAR cVal;

+    UCHAR bVal;

+    SHORT iVal;

+    USHORT uiVal;

+    LONG lVal;

+    ULONG ulVal;

+    INT intVal;

+    UINT uintVal;

+    LARGE_INTEGER hVal;

+    ULARGE_INTEGER uhVal;

+    VARIANT_BOOL boolVal;

+    SCODE scode;

+    FILETIME filetime;

+    BSTR bstrVal;

+  };

+} PROPVARIANT;

+

+typedef PROPVARIANT tagVARIANT;

+typedef tagVARIANT VARIANT;

+typedef VARIANT VARIANTARG;

+

+MY_EXTERN_C BSTR SysAllocStringByteLen(LPCSTR psz, UINT len);

+MY_EXTERN_C BSTR SysAllocString(const OLECHAR *sz);

+MY_EXTERN_C void SysFreeString(BSTR bstr);

+MY_EXTERN_C UINT SysStringByteLen(BSTR bstr);

+MY_EXTERN_C UINT SysStringLen(BSTR bstr);

+

+MY_EXTERN_C DWORD GetLastError();

+MY_EXTERN_C HRESULT VariantClear(VARIANTARG *prop);

+MY_EXTERN_C HRESULT VariantCopy(VARIANTARG *dest, VARIANTARG *src);

+MY_EXTERN_C LONG CompareFileTime(const FILETIME* ft1, const FILETIME* ft2);

+

+#define CP_ACP    0

+#define CP_OEMCP  1

+

+typedef enum tagSTREAM_SEEK

+{	

+  STREAM_SEEK_SET	= 0,

+  STREAM_SEEK_CUR	= 1,

+  STREAM_SEEK_END	= 2

+} STREAM_SEEK;

+

+#endif

+#endif

diff --git a/util/romtool/tools/lzma/C/Common/NewHandler.h b/util/romtool/tools/lzma/C/Common/NewHandler.h
new file mode 100644
index 0000000000..4c1727f824
--- /dev/null
+++ b/util/romtool/tools/lzma/C/Common/NewHandler.h
@@ -0,0 +1,16 @@
+// Common/NewHandler.h

+

+#ifndef __COMMON_NEWHANDLER_H

+#define __COMMON_NEWHANDLER_H

+

+class CNewException {};

+

+#ifdef _WIN32

+void 

+#ifdef _MSC_VER

+__cdecl 

+#endif

+operator delete(void *p) throw();

+#endif 

+

+#endif 

diff --git a/util/romtool/tools/lzma/C/Common/StdAfx.h b/util/romtool/tools/lzma/C/Common/StdAfx.h
new file mode 100644
index 0000000000..2547611bd7
--- /dev/null
+++ b/util/romtool/tools/lzma/C/Common/StdAfx.h
@@ -0,0 +1,9 @@
+// StdAfx.h

+

+#ifndef __STDAFX_H

+#define __STDAFX_H

+

+// #include "MyWindows.h"

+#include "NewHandler.h"

+

+#endif 

diff --git a/util/romtool/tools/lzma/C/Common/Types.h b/util/romtool/tools/lzma/C/Common/Types.h
new file mode 100644
index 0000000000..52d07081e8
--- /dev/null
+++ b/util/romtool/tools/lzma/C/Common/Types.h
@@ -0,0 +1,19 @@
+// Common/Types.h

+

+#ifndef __COMMON_TYPES_H

+#define __COMMON_TYPES_H

+

+typedef unsigned char Byte;

+typedef short Int16;

+typedef unsigned short UInt16;

+typedef int Int32;

+typedef unsigned int UInt32;

+#ifdef _MSC_VER

+typedef __int64 Int64;

+typedef unsigned __int64 UInt64;

+#else

+typedef long long int Int64;

+typedef unsigned long long int UInt64;

+#endif

+

+#endif