Merge to XFA: Kill FXSYS_mem{cpy,cmp,set.move}{32,8}.
[pdfium.git] / core / include / fxcrt / fx_basic.h
index bdb1599..85ade1a 100644 (file)
@@ -1,35 +1,37 @@
 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
+
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
-#ifndef _FX_BASIC_H_
-#define _FX_BASIC_H_
-#ifndef _STDINT_H_ 
-#define _STDINT_H_
-#include <stdint.h>
-#endif
-#ifndef _FX_SYSTEM_H_
-#include "fx_system.h"
-#endif
-#ifndef _FX_MEMORY_H_
+#ifndef CORE_INCLUDE_FXCRT_FX_BASIC_H_
+#define CORE_INCLUDE_FXCRT_FX_BASIC_H_
+
 #include "fx_memory.h"
-#endif
-#ifndef _FX_STRING_H_
-#include "fx_string.h"
-#endif
-#ifndef _FX_STREAM_H_
 #include "fx_stream.h"
-#endif
-class CFX_BinaryBuf : public CFX_Object
+#include "fx_string.h"
+#include "fx_system.h"
+
+// The FX_ArraySize(arr) macro returns the # of elements in an array arr.
+// The expression is a compile-time constant, and therefore can be
+// used in defining new arrays, for example.  If you use FX_ArraySize on
+// a pointer by mistake, you will get a compile-time error.
+//
+// One caveat is that FX_ArraySize() doesn't accept any array of an
+// anonymous type or a type defined inside a function.
+#define FX_ArraySize(array) (sizeof(ArraySizeHelper(array)))
+
+// This template function declaration is used in defining FX_ArraySize.
+// Note that the function doesn't need an implementation, as we only
+// use its type.
+template <typename T, size_t N>
+char (&ArraySizeHelper(T (&array)[N]))[N];
+
+class CFX_BinaryBuf 
 {
 public:
-
-    CFX_BinaryBuf(IFX_Allocator* pAllocator = NULL);
-
-    CFX_BinaryBuf(FX_STRSIZE size, IFX_Allocator* pAllocator = NULL);
+    CFX_BinaryBuf();
+    CFX_BinaryBuf(FX_STRSIZE size);
 
     ~CFX_BinaryBuf();
 
@@ -39,14 +41,14 @@ public:
 
     void                                       AppendBlock(const void* pBuf, FX_STRSIZE size);
 
-    void                                       AppendFill(FX_BYTE byte, FX_STRSIZE count);
+    void                                       AppendFill(uint8_t byte, FX_STRSIZE count);
 
-    void                                       AppendString(FX_BSTR str)
+    void                                       AppendString(const CFX_ByteStringC& str)
     {
         AppendBlock(str.GetPtr(), str.GetLength());
     }
 
-    inline void                                AppendByte(FX_BYTE byte)
+    inline void                                AppendByte(uint8_t byte)
     {
         if (m_AllocSize <= m_DataSize) {
             ExpandBuf(1);
@@ -64,7 +66,7 @@ public:
 
     void                                       Delete(int start_index, int count);
 
-    FX_LPBYTE                          GetBuffer() const
+    uint8_t*                           GetBuffer() const
     {
         return m_pBuffer;
     }
@@ -75,16 +77,13 @@ public:
     }
 
     CFX_ByteStringC                    GetByteString() const;
-    void                                       GetByteStringL(CFX_ByteStringL &str) const;
 
     void                                       DetachBuffer();
-
-    IFX_Allocator*                     m_pAllocator;
 protected:
 
     FX_STRSIZE                         m_AllocStep;
 
-    FX_LPBYTE                          m_pBuffer;
+    uint8_t*                           m_pBuffer;
 
     FX_STRSIZE                         m_DataSize;
 
@@ -96,13 +95,11 @@ class CFX_ByteTextBuf : public CFX_BinaryBuf
 {
 public:
 
-    CFX_ByteTextBuf(IFX_Allocator* pAllocator = NULL) : CFX_BinaryBuf(pAllocator) {}
-
-    void                                       operator = (FX_BSTR str);
+    void                                       operator = (const CFX_ByteStringC& str);
 
     void                                       AppendChar(int ch)
     {
-        AppendByte((FX_BYTE)ch);
+        AppendByte((uint8_t)ch);
     }
 
     CFX_ByteTextBuf&           operator << (int i);
@@ -111,7 +108,7 @@ public:
 
     CFX_ByteTextBuf&           operator << (double f);
 
-    CFX_ByteTextBuf&           operator << (FX_BSTR lpsz);
+    CFX_ByteTextBuf&           operator << (const CFX_ByteStringC& lpsz);
 
     CFX_ByteTextBuf&           operator << (const CFX_ByteTextBuf& buf);
 
@@ -124,11 +121,9 @@ class CFX_WideTextBuf : public CFX_BinaryBuf
 {
 public:
 
-    CFX_WideTextBuf(IFX_Allocator* pAllocator = NULL) : CFX_BinaryBuf(pAllocator) {}
-
-    void                                       operator = (FX_LPCWSTR lpsz);
+    void                                       operator = (const FX_WCHAR* lpsz);
 
-    void                                       operator = (FX_WSTR str);
+    void                                       operator = (const CFX_WideStringC& str);
 
     void                                       AppendChar(FX_WCHAR wch);
 
@@ -136,9 +131,9 @@ public:
 
     CFX_WideTextBuf&           operator << (double f);
 
-    CFX_WideTextBuf&           operator << (FX_LPCWSTR lpsz);
+    CFX_WideTextBuf&           operator << (const FX_WCHAR* lpsz);
 
-    CFX_WideTextBuf&           operator << (FX_WSTR str);
+    CFX_WideTextBuf&           operator << (const CFX_WideStringC& str);
     CFX_WideTextBuf&           operator << (const CFX_WideString &str);
 
     CFX_WideTextBuf&           operator << (const CFX_WideTextBuf& buf);
@@ -148,9 +143,9 @@ public:
         return m_DataSize / sizeof(FX_WCHAR);
     }
 
-    FX_LPWSTR                          GetBuffer() const
+    FX_WCHAR*                          GetBuffer() const
     {
-        return (FX_LPWSTR)m_pBuffer;
+        return (FX_WCHAR*)m_pBuffer;
     }
 
     void                                       Delete(int start_index, int count)
@@ -159,15 +154,13 @@ public:
     }
 
     CFX_WideStringC                    GetWideString() const;
-    void                                       GetWideStringL(CFX_WideStringL& wideText) const;
 };
-class CFX_ArchiveSaver : public CFX_Object
+class CFX_ArchiveSaver 
 {
 public:
+    CFX_ArchiveSaver() : m_pStream(NULL) {}
 
-    CFX_ArchiveSaver(IFX_Allocator* pAllocator = NULL) : m_SavingBuf(pAllocator), m_pStream(NULL) {}
-
-    CFX_ArchiveSaver&          operator << (FX_BYTE i);
+    CFX_ArchiveSaver&          operator << (uint8_t i);
 
     CFX_ArchiveSaver&          operator << (int i);
 
@@ -177,20 +170,20 @@ public:
 
     CFX_ArchiveSaver&          operator << (double i);
 
-    CFX_ArchiveSaver&          operator << (FX_BSTR bstr);
+    CFX_ArchiveSaver&          operator << (const CFX_ByteStringC& bstr);
 
-    CFX_ArchiveSaver&          operator << (FX_LPCWSTR bstr);
+    CFX_ArchiveSaver&          operator << (const FX_WCHAR* bstr);
 
     CFX_ArchiveSaver&          operator << (const CFX_WideString& wstr);
 
     void                                       Write(const void* pData, FX_STRSIZE dwSize);
 
-    FX_INTPTR                          GetLength()
+    intptr_t                           GetLength()
     {
         return m_SavingBuf.GetSize();
     }
 
-    FX_LPCBYTE                         GetBuffer()
+    const uint8_t*                             GetBuffer()
     {
         return m_SavingBuf.GetBuffer();
     }
@@ -205,13 +198,13 @@ protected:
 
     IFX_FileStream*                    m_pStream;
 };
-class CFX_ArchiveLoader : public CFX_Object
+class CFX_ArchiveLoader 
 {
 public:
 
-    CFX_ArchiveLoader(FX_LPCBYTE pData, FX_DWORD dwSize);
+    CFX_ArchiveLoader(const uint8_t* pData, FX_DWORD dwSize);
 
-    CFX_ArchiveLoader&         operator >> (FX_BYTE& i);
+    CFX_ArchiveLoader&         operator >> (uint8_t& i);
 
     CFX_ArchiveLoader&         operator >> (int& i);
 
@@ -232,16 +225,15 @@ protected:
 
     FX_DWORD                           m_LoadingPos;
 
-    FX_LPCBYTE                         m_pLoadingBuf;
+    const uint8_t*                             m_pLoadingBuf;
 
     FX_DWORD                           m_LoadingSize;
 };
 class IFX_BufferArchive
 {
 public:
-
-    IFX_BufferArchive(FX_STRSIZE size, IFX_Allocator* pAllocator = NULL);
-
+    IFX_BufferArchive(FX_STRSIZE size);
+    virtual ~IFX_BufferArchive() { }
 
     virtual void                       Clear();
 
@@ -249,40 +241,37 @@ public:
     FX_BOOL                                    Flush();
 
 
-    FX_INT32                           AppendBlock(const void* pBuf, size_t size);
+    int32_t                            AppendBlock(const void* pBuf, size_t size);
 
-    FX_INT32                           AppendByte(FX_BYTE byte);
+    int32_t                            AppendByte(uint8_t byte);
 
-    FX_INT32                           AppendDWord(FX_DWORD i);
+    int32_t                            AppendDWord(FX_DWORD i);
 
 
-    FX_INT32                           AppendString(FX_BSTR lpsz);
+    int32_t                            AppendString(const CFX_ByteStringC& lpsz);
 
 protected:
 
     virtual    FX_BOOL                 DoWork(const void* pBuf, size_t size) = 0;
 
-
-    IFX_Allocator*                     m_pAllocator;
-
     FX_STRSIZE                         m_BufSize;
 
-    FX_LPBYTE                          m_pBuffer;
+    uint8_t*                           m_pBuffer;
 
     FX_STRSIZE                         m_Length;
 };
-class CFX_FileBufferArchive : public IFX_BufferArchive, public CFX_Object
+class CFX_FileBufferArchive : public IFX_BufferArchive
 {
 public:
-    CFX_FileBufferArchive(FX_STRSIZE size = 32768, IFX_Allocator* pAllocator = NULL);
-    ~CFX_FileBufferArchive();
+    CFX_FileBufferArchive(FX_STRSIZE size = 32768);
+    ~CFX_FileBufferArchive() override;
     virtual void                       Clear();
 
     FX_BOOL                                    AttachFile(IFX_StreamWrite *pFile, FX_BOOL bTakeover = FALSE);
 
-    FX_BOOL                                    AttachFile(FX_LPCWSTR filename);
+    FX_BOOL                                    AttachFile(const FX_WCHAR* filename);
 
-    FX_BOOL                                    AttachFile(FX_LPCSTR filename);
+    FX_BOOL                                    AttachFile(const FX_CHAR* filename);
 private:
 
     virtual FX_BOOL                    DoWork(const void* pBuf, size_t size);
@@ -293,27 +282,26 @@ private:
 };
 struct CFX_CharMap {
 
-    static CFX_CharMap*                GetDefaultMapper(FX_INT32 codepage = 0);
+    static CFX_CharMap*                GetDefaultMapper(int32_t codepage = 0);
 
 
     CFX_WideString     (*m_GetWideString)(CFX_CharMap* pMap, const CFX_ByteString& bstr);
 
     CFX_ByteString     (*m_GetByteString)(CFX_CharMap* pMap, const CFX_WideString& wstr);
 
-    FX_INT32           (*m_GetCodePage)();
+    int32_t            (*m_GetCodePage)();
 };
 class CFX_UTF8Decoder
 {
 public:
-
-    CFX_UTF8Decoder(IFX_Allocator* pAllocator = NULL) : m_Buffer(pAllocator)
+    CFX_UTF8Decoder()
     {
         m_PendingBytes = 0;
     }
 
     void                       Clear();
 
-    void                       Input(FX_BYTE byte);
+    void                       Input(uint8_t byte);
 
     void                       AppendChar(FX_DWORD ch);
 
@@ -326,10 +314,6 @@ public:
     {
         return m_Buffer.GetWideString();
     }
-    void                       GetResult(CFX_WideStringL &result) const
-    {
-        m_Buffer.GetWideStringL(result);
-    }
 protected:
 
     int                                m_PendingBytes;
@@ -341,15 +325,14 @@ protected:
 class CFX_UTF8Encoder
 {
 public:
-
-    CFX_UTF8Encoder(IFX_Allocator* pAllocator = NULL) : m_Buffer(pAllocator)
+    CFX_UTF8Encoder()
     {
         m_UTF16First = 0;
     }
 
     void                       Input(FX_WCHAR unicode);
 
-    void                       AppendStr(FX_BSTR str)
+    void                       AppendStr(const CFX_ByteStringC& str)
     {
         m_UTF16First = 0;
         m_Buffer << str;
@@ -359,10 +342,6 @@ public:
     {
         return m_Buffer.GetByteString();
     }
-    void                       GetResult(CFX_ByteStringL &result) const
-    {
-        m_Buffer.GetByteStringL(result);
-    }
 protected:
 
     CFX_ByteTextBuf    m_Buffer;
@@ -373,24 +352,20 @@ CFX_ByteString FX_UrlEncode(const CFX_WideString& wsUrl);
 CFX_WideString FX_UrlDecode(const CFX_ByteString& bsUrl);
 CFX_ByteString FX_EncodeURI(const CFX_WideString& wsURI);
 CFX_WideString FX_DecodeURI(const CFX_ByteString& bsURI);
-class CFX_BasicArray : public CFX_Object
+class CFX_BasicArray 
 {
-public:
-
-    IFX_Allocator*     m_pAllocator;
 protected:
-
-    CFX_BasicArray(int unit_size, IFX_Allocator* pAllocator = NULL);
+    CFX_BasicArray(int unit_size);
 
     ~CFX_BasicArray();
 
-    FX_BOOL                    SetSize(int nNewSize, int nGrowBy);
+    FX_BOOL                    SetSize(int nNewSize);
 
     FX_BOOL                    Append(const CFX_BasicArray& src);
 
     FX_BOOL                    Copy(const CFX_BasicArray& src);
 
-    FX_LPBYTE          InsertSpaceAt(int nIndex, int nCount);
+    uint8_t*           InsertSpaceAt(int nIndex, int nCount);
 
     FX_BOOL                    RemoveAt(int nIndex, int nCount);
 
@@ -399,22 +374,19 @@ protected:
     const void*                GetDataPtr(int index) const;
 protected:
 
-    FX_LPBYTE          m_pData;
+    uint8_t*           m_pData;
 
     int                                m_nSize;
 
     int                                m_nMaxSize;
 
-    int                                m_nGrowBy;
-
     int                                m_nUnitSize;
 };
 template<class TYPE>
 class CFX_ArrayTemplate : public CFX_BasicArray
 {
 public:
-
-    CFX_ArrayTemplate(IFX_Allocator* pAllocator = NULL) : CFX_BasicArray(sizeof(TYPE), pAllocator) {}
+    CFX_ArrayTemplate() : CFX_BasicArray(sizeof(TYPE)) {}
 
     int                        GetSize() const
     {
@@ -426,14 +398,14 @@ public:
         return m_nSize - 1;
     }
 
-    FX_BOOL            SetSize(int nNewSize, int nGrowBy = -1)
+    FX_BOOL            SetSize(int nNewSize)
     {
-        return CFX_BasicArray::SetSize(nNewSize, nGrowBy);
+        return CFX_BasicArray::SetSize(nNewSize);
     }
 
     void               RemoveAll()
     {
-        SetSize(0, -1);
+        SetSize(0);
     }
 
     const TYPE GetAt(int nIndex) const
@@ -477,7 +449,7 @@ public:
             return FALSE;
         }
         if (nIndex >= m_nSize)
-            if (!SetSize(nIndex + 1, -1)) {
+            if (!SetSize(nIndex + 1)) {
                 return FALSE;
             }
         ((TYPE*)m_pData)[nIndex] = newElement;
@@ -488,7 +460,7 @@ public:
     {
         if (m_nSize < m_nMaxSize) {
             m_nSize ++;
-        } else if (!SetSize(m_nSize + 1, -1)) {
+        } else if (!SetSize(m_nSize + 1)) {
             return FALSE;
         }
         ((TYPE*)m_pData)[m_nSize - 1] = newElement;
@@ -569,19 +541,18 @@ public:
         return -1;
     }
 };
-typedef CFX_ArrayTemplate<FX_BYTE>             CFX_ByteArray;
+typedef CFX_ArrayTemplate<uint8_t>             CFX_ByteArray;
 typedef CFX_ArrayTemplate<FX_WORD>             CFX_WordArray;
 typedef CFX_ArrayTemplate<FX_DWORD>            CFX_DWordArray;
 typedef CFX_ArrayTemplate<void*>               CFX_PtrArray;
 typedef CFX_ArrayTemplate<FX_FILESIZE> CFX_FileSizeArray;
 typedef CFX_ArrayTemplate<FX_FLOAT>            CFX_FloatArray;
-typedef CFX_ArrayTemplate<FX_INT32>            CFX_Int32Array;
+typedef CFX_ArrayTemplate<int32_t>             CFX_Int32Array;
 template <class ObjectClass>
 class CFX_ObjectArray : public CFX_BasicArray
 {
 public:
-
-    CFX_ObjectArray(IFX_Allocator* pAllocator = NULL) : CFX_BasicArray(sizeof(ObjectClass), pAllocator) {}
+    CFX_ObjectArray() : CFX_BasicArray(sizeof(ObjectClass)) {}
 
     ~CFX_ObjectArray()
     {
@@ -603,12 +574,12 @@ public:
         return InsertSpaceAt(m_nSize, 1);
     }
 
-    FX_INT32           Append(const CFX_ObjectArray& src, FX_INT32 nStart = 0, FX_INT32 nCount = -1)
+    int32_t            Append(const CFX_ObjectArray& src, int32_t nStart = 0, int32_t nCount = -1)
     {
         if (nCount == 0) {
             return 0;
         }
-        FX_INT32 nSize = src.GetSize();
+        int32_t nSize = src.GetSize();
         if (!nSize) {
             return 0;
         }
@@ -626,18 +597,18 @@ public:
         InsertSpaceAt(m_nSize, nCount);
         ObjectClass* pStartObj = (ObjectClass*)GetDataPtr(nSize);
         nSize = nStart + nCount;
-        for (FX_INT32 i = nStart; i < nSize; i ++, pStartObj++) {
+        for (int32_t i = nStart; i < nSize; i ++, pStartObj++) {
             new ((void*)pStartObj) ObjectClass(src[i]);
         }
         return nCount;
     }
 
-    FX_INT32           Copy(const CFX_ObjectArray& src, FX_INT32 nStart = 0, FX_INT32 nCount = -1)
+    int32_t            Copy(const CFX_ObjectArray& src, int32_t nStart = 0, int32_t nCount = -1)
     {
         if (nCount == 0) {
             return 0;
         }
-        FX_INT32 nSize = src.GetSize();
+        int32_t nSize = src.GetSize();
         if (!nSize) {
             return 0;
         }
@@ -652,10 +623,10 @@ public:
             return 0;
         }
         RemoveAll();
-        SetSize(nCount, -1);
+        SetSize(nCount);
         ObjectClass* pStartObj = (ObjectClass*)m_pData;
         nSize = nStart + nCount;
-        for (FX_INT32 i = nStart; i < nSize; i ++, pStartObj++) {
+        for (int32_t i = nStart; i < nSize; i ++, pStartObj++) {
             new ((void*)pStartObj) ObjectClass(src[i]);
         }
         return nCount;
@@ -689,16 +660,15 @@ public:
         for (int i = 0; i < m_nSize; i ++) {
             ((ObjectClass*)GetDataPtr(i))->~ObjectClass();
         }
-        CFX_BasicArray::SetSize(0, -1);
+        CFX_BasicArray::SetSize(0);
     }
 };
 typedef CFX_ObjectArray<CFX_ByteString> CFX_ByteStringArray;
 typedef CFX_ObjectArray<CFX_WideString> CFX_WideStringArray;
-class CFX_BaseSegmentedArray : public CFX_Object
+class CFX_BaseSegmentedArray 
 {
 public:
-
-    CFX_BaseSegmentedArray(int unit_size = 1, int segment_units = 512, int index_size = 8, IFX_Allocator* pAllocator = NULL);
+    CFX_BaseSegmentedArray(int unit_size = 1, int segment_units = 512, int index_size = 8);
 
     ~CFX_BaseSegmentedArray();
 
@@ -728,32 +698,29 @@ public:
     }
 
     void*      Iterate(FX_BOOL (*callback)(void* param, void* pData), void* param) const;
-
-    IFX_Allocator*     m_pAllocator;
 private:
 
     int                                m_UnitSize;
 
     short                      m_SegmentSize;
 
-    FX_BYTE                    m_IndexSize;
+    uint8_t                    m_IndexSize;
 
-    FX_BYTE                    m_IndexDepth;
+    uint8_t                    m_IndexDepth;
 
     int                                m_DataSize;
 
     void*                      m_pIndex;
     void**     GetIndex(int seg_index) const;
     void*      IterateIndex(int level, int& start, void** pIndex, FX_BOOL (*callback)(void* param, void* pData), void* param) const;
-    void*      IterateSegment(FX_LPCBYTE pSegment, int count, FX_BOOL (*callback)(void* param, void* pData), void* param) const;
+    void*      IterateSegment(const uint8_t* pSegment, int count, FX_BOOL (*callback)(void* param, void* pData), void* param) const;
 };
 template <class ElementType>
 class CFX_SegmentedArray : public CFX_BaseSegmentedArray
 {
 public:
-
-    CFX_SegmentedArray(int segment_units, int index_size = 8, IFX_Allocator* pAllocator = NULL)
-        : CFX_BaseSegmentedArray(sizeof(ElementType), segment_units, index_size, pAllocator)
+    CFX_SegmentedArray(int segment_units, int index_size = 8)
+        : CFX_BaseSegmentedArray(sizeof(ElementType), segment_units, index_size)
     {}
 
     void       Add(ElementType data)
@@ -767,46 +734,35 @@ public:
     }
 };
 template <class DataType, int FixedSize>
-class CFX_FixedBufGrow : public CFX_Object
+class CFX_FixedBufGrow 
 {
 public:
-    CFX_FixedBufGrow(IFX_Allocator* pAllocator = NULL)
-        : m_pAllocator(pAllocator)
-        , m_pData(NULL)
+    CFX_FixedBufGrow() : m_pData(NULL)
     {}
-    CFX_FixedBufGrow(int data_size, IFX_Allocator* pAllocator = NULL)
-        : m_pAllocator(pAllocator)
-        , m_pData(NULL)
+    CFX_FixedBufGrow(int data_size) : m_pData(NULL)
     {
         if (data_size > FixedSize) {
-            m_pData = FX_Allocator_Alloc(m_pAllocator, DataType, data_size);
+            m_pData = FX_Alloc(DataType, data_size);
         } else {
-            if (FixedSize > SIZE_MAX/sizeof(DataType))
-                return;
-
-            FXSYS_memset32(m_Data, 0, sizeof(DataType)*FixedSize);
+            FXSYS_memset(m_Data, 0, sizeof(DataType)*FixedSize);
         }
     }
     void SetDataSize(int data_size)
     {
         if (m_pData) {
-            FX_Allocator_Free(m_pAllocator, m_pData);
+            FX_Free(m_pData);
         }
         m_pData = NULL;
         if (data_size > FixedSize) {
-            m_pData = FX_Allocator_Alloc(m_pAllocator, DataType, data_size);
+            m_pData = FX_Alloc(DataType, data_size);
         } else {
-
-            if (FixedSize > SIZE_MAX/sizeof(DataType))
-                return;
-
-            FXSYS_memset32(m_Data, 0, sizeof(DataType)*FixedSize);
+            FXSYS_memset(m_Data, 0, sizeof(DataType)*FixedSize);
         }
     }
     ~CFX_FixedBufGrow()
     {
         if (m_pData) {
-            FX_Allocator_Free(m_pAllocator, m_pData);
+            FX_Free(m_pData);
         }
     }
     operator DataType*()
@@ -814,38 +770,10 @@ public:
         return m_pData ? m_pData : m_Data;
     }
 private:
-    IFX_Allocator*     m_pAllocator;
     DataType           m_Data[FixedSize];
     DataType*          m_pData;
 };
-template <class DataType>
-class CFX_TempBuf
-{
-public:
-    CFX_TempBuf(int size, IFX_Allocator* pAllocator = NULL) : m_pAllocator(pAllocator)
-    {
-        m_pData = FX_Allocator_Alloc(m_pAllocator, DataType, size);
-    }
-    ~CFX_TempBuf()
-    {
-        if (m_pData) {
-            FX_Allocator_Free(m_pAllocator, m_pData);
-        }
-    }
-    DataType&  operator[](int i)
-    {
-        FXSYS_assert(m_pData != NULL);
-        return m_pData[i];
-    }
-    operator DataType*()
-    {
-        return m_pData;
-    }
-private:
-    IFX_Allocator*     m_pAllocator;
-    DataType*          m_pData;
-};
-class CFX_MapPtrToPtr : public CFX_Object
+class CFX_MapPtrToPtr 
 {
 protected:
 
@@ -858,8 +786,7 @@ protected:
         void* value;
     };
 public:
-
-    CFX_MapPtrToPtr(int nBlockSize = 10, IFX_Allocator* pAllocator = NULL);
+    CFX_MapPtrToPtr(int nBlockSize = 10);
 
     ~CFX_MapPtrToPtr();
 
@@ -903,8 +830,6 @@ public:
     void InitHashTable(FX_DWORD hashSize, FX_BOOL bAllocNow = TRUE);
 protected:
 
-    IFX_Allocator*     m_pAllocator;
-
     CAssoc** m_pHashTable;
 
     FX_DWORD m_nHashTableSize;
@@ -929,32 +854,31 @@ template <class KeyType, class ValueType>
 class CFX_MapPtrTemplate : public CFX_MapPtrToPtr
 {
 public:
-
-    CFX_MapPtrTemplate(IFX_Allocator* pAllocator = NULL) : CFX_MapPtrToPtr(10, pAllocator) {}
+    CFX_MapPtrTemplate() : CFX_MapPtrToPtr(10) {}
 
     FX_BOOL    Lookup(KeyType key, ValueType& rValue) const
     {
-        FX_LPVOID pValue = NULL;
-        if (!CFX_MapPtrToPtr::Lookup((void*)(FX_UINTPTR)key, pValue)) {
+        void* pValue = NULL;
+        if (!CFX_MapPtrToPtr::Lookup((void*)(uintptr_t)key, pValue)) {
             return FALSE;
         }
-        rValue = (ValueType)(FX_UINTPTR)pValue;
+        rValue = (ValueType)(uintptr_t)pValue;
         return TRUE;
     }
 
     ValueType& operator[](KeyType key)
     {
-        return (ValueType&)CFX_MapPtrToPtr::operator []((void*)(FX_UINTPTR)key);
+        return (ValueType&)CFX_MapPtrToPtr::operator []((void*)(uintptr_t)key);
     }
 
     void SetAt(KeyType key, ValueType newValue)
     {
-        CFX_MapPtrToPtr::SetAt((void*)(FX_UINTPTR)key, (void*)(FX_UINTPTR)newValue);
+        CFX_MapPtrToPtr::SetAt((void*)(uintptr_t)key, (void*)(uintptr_t)newValue);
     }
 
     FX_BOOL    RemoveKey(KeyType key)
     {
-        return CFX_MapPtrToPtr::RemoveKey((void*)(FX_UINTPTR)key);
+        return CFX_MapPtrToPtr::RemoveKey((void*)(uintptr_t)key);
     }
 
     void GetNextAssoc(FX_POSITION& rNextPosition, KeyType& rKey, ValueType& rValue) const
@@ -962,16 +886,14 @@ public:
         void* pKey = NULL;
         void* pValue = NULL;
         CFX_MapPtrToPtr::GetNextAssoc(rNextPosition, pKey, pValue);
-        rKey = (KeyType)(FX_UINTPTR)pKey;
-        rValue = (ValueType)(FX_UINTPTR)pValue;
+        rKey = (KeyType)(uintptr_t)pKey;
+        rValue = (ValueType)(uintptr_t)pValue;
     }
 };
-class CFX_CMapDWordToDWord : public CFX_Object
+class CFX_CMapDWordToDWord 
 {
 public:
 
-    CFX_CMapDWordToDWord(IFX_Allocator* pAllocator = NULL) : m_Buffer(pAllocator) {}
-
     FX_BOOL                    Lookup(FX_DWORD key, FX_DWORD& value) const;
 
     void                       SetAt(FX_DWORD key, FX_DWORD value);
@@ -985,7 +907,7 @@ protected:
 
     CFX_BinaryBuf      m_Buffer;
 };
-class CFX_MapByteStringToPtr : public CFX_Object
+class CFX_MapByteStringToPtr 
 {
 protected:
 
@@ -1000,8 +922,7 @@ protected:
         void* value;
     };
 public:
-
-    CFX_MapByteStringToPtr(int nBlockSize = 10, IFX_Allocator* pAllocator = NULL);
+    CFX_MapByteStringToPtr(int nBlockSize = 10);
 
     int GetCount() const
     {
@@ -1013,16 +934,16 @@ public:
         return m_nCount == 0;
     }
 
-    FX_BOOL Lookup(FX_BSTR key, void*& rValue) const;
+    FX_BOOL Lookup(const CFX_ByteStringC& key, void*& rValue) const;
 
-    void*& operator[](FX_BSTR key);
+    void*& operator[](const CFX_ByteStringC& key);
 
-    void SetAt(FX_BSTR key, void* newValue)
+    void SetAt(const CFX_ByteStringC& key, void* newValue)
     {
         (*this)[key] = newValue;
     }
 
-    FX_BOOL RemoveKey(FX_BSTR key);
+    FX_BOOL RemoveKey(const CFX_ByteStringC& key);
 
     void RemoveAll();
 
@@ -1033,7 +954,7 @@ public:
 
     void GetNextAssoc(FX_POSITION& rNextPosition, CFX_ByteString& rKey, void*& rValue) const;
 
-    FX_LPVOID          GetNextValue(FX_POSITION& rNextPosition) const;
+    void*              GetNextValue(FX_POSITION& rNextPosition) const;
 
     FX_DWORD GetHashTableSize() const
     {
@@ -1042,11 +963,9 @@ public:
 
     void InitHashTable(FX_DWORD hashSize, FX_BOOL bAllocNow = TRUE);
 
-    FX_DWORD HashKey(FX_BSTR key) const;
+    FX_DWORD HashKey(const CFX_ByteStringC& key) const;
 protected:
 
-    IFX_Allocator*     m_pAllocator;
-
     CAssoc** m_pHashTable;
 
     FX_DWORD m_nHashTableSize;
@@ -1063,16 +982,15 @@ protected:
 
     void FreeAssoc(CAssoc* pAssoc);
 
-    CAssoc* GetAssocAt(FX_BSTR key, FX_DWORD& hash) const;
+    CAssoc* GetAssocAt(const CFX_ByteStringC& key, FX_DWORD& hash) const;
 public:
 
     ~CFX_MapByteStringToPtr();
 };
-class CFX_CMapByteStringToPtr : public CFX_Object
+class CFX_CMapByteStringToPtr 
 {
 public:
-
-    CFX_CMapByteStringToPtr(IFX_Allocator* pAllocator = NULL);
+    CFX_CMapByteStringToPtr();
 
     ~CFX_CMapByteStringToPtr();
 
@@ -1082,22 +1000,22 @@ public:
 
     void                       GetNextAssoc(FX_POSITION& rNextPosition, CFX_ByteString& rKey, void*& rValue) const;
 
-    FX_LPVOID          GetNextValue(FX_POSITION& rNextPosition) const;
+    void*              GetNextValue(FX_POSITION& rNextPosition) const;
 
-    FX_BOOL                    Lookup(FX_BSTR key, void*& rValue) const;
+    FX_BOOL                    Lookup(const CFX_ByteStringC& key, void*& rValue) const;
 
-    void                       SetAt(FX_BSTR key, void* value);
+    void                       SetAt(const CFX_ByteStringC& key, void* value);
 
-    void                       RemoveKey(FX_BSTR key);
+    void                       RemoveKey(const CFX_ByteStringC& key);
 
     int                                GetCount() const;
 
-    void                       AddValue(FX_BSTR key, void* pValue);
+    void                       AddValue(const CFX_ByteStringC& key, void* pValue);
 private:
 
     CFX_BaseSegmentedArray                     m_Buffer;
 };
-class CFX_PtrList : public CFX_Object
+class CFX_PtrList 
 {
 protected:
 
@@ -1110,8 +1028,7 @@ protected:
         void* data;
     };
 public:
-
-    CFX_PtrList(int nBlockSize = 10, IFX_Allocator* pAllocator = NULL);
+    CFX_PtrList(int nBlockSize = 10);
 
     FX_POSITION GetHeadPosition() const
     {
@@ -1179,8 +1096,6 @@ public:
     void       RemoveAll();
 protected:
 
-    IFX_Allocator*     m_pAllocator;
-
     CNode* m_pNodeHead;
 
     CNode* m_pNodeTail;
@@ -1200,14 +1115,14 @@ public:
 
     ~CFX_PtrList();
 };
-typedef void (*PD_CALLBACK_FREEDATA)(FX_LPVOID pData);
+typedef void (*PD_CALLBACK_FREEDATA)(void* pData);
 struct FX_PRIVATEDATA {
 
     void                                       FreeData();
 
-    FX_LPVOID                          m_pModuleId;
+    void*                              m_pModuleId;
 
-    FX_LPVOID                          m_pData;
+    void*                              m_pData;
 
     PD_CALLBACK_FREEDATA       m_pCallback;
 
@@ -1217,19 +1132,17 @@ class CFX_PrivateData
 {
 public:
 
-    CFX_PrivateData(IFX_Allocator* pAllocator = NULL) : m_DataList(pAllocator) {}
-
     ~CFX_PrivateData();
 
     void                                       ClearAll();
 
-    void                                       SetPrivateData(FX_LPVOID module_id, FX_LPVOID pData, PD_CALLBACK_FREEDATA callback);
+    void                                       SetPrivateData(void* module_id, void* pData, PD_CALLBACK_FREEDATA callback);
 
-    void                                       SetPrivateObj(FX_LPVOID module_id, CFX_DestructObject* pObj);
+    void                                       SetPrivateObj(void* module_id, CFX_DestructObject* pObj);
 
-    FX_LPVOID                          GetPrivateData(FX_LPVOID module_id);
+    void*                              GetPrivateData(void* module_id);
 
-    FX_BOOL                                    LookupPrivateData(FX_LPVOID module_id, FX_LPVOID &pData) const
+    FX_BOOL                                    LookupPrivateData(void* module_id, void* &pData) const
     {
         if (!module_id) {
             return FALSE;
@@ -1244,18 +1157,18 @@ public:
         return FALSE;
     }
 
-    FX_BOOL                                    RemovePrivateData(FX_LPVOID module_id);
+    FX_BOOL                                    RemovePrivateData(void* module_id);
 protected:
 
     CFX_ArrayTemplate<FX_PRIVATEDATA>  m_DataList;
 
-    void                                       AddData(FX_LPVOID module_id, FX_LPVOID pData, PD_CALLBACK_FREEDATA callback, FX_BOOL bSelfDestruct);
+    void                                       AddData(void* module_id, void* pData, PD_CALLBACK_FREEDATA callback, FX_BOOL bSelfDestruct);
 };
-class CFX_BitStream : public CFX_Object
+class CFX_BitStream 
 {
 public:
 
-    void                               Init(FX_LPCBYTE pData, FX_DWORD dwSize);
+    void                               Init(const uint8_t* pData, FX_DWORD dwSize);
 
 
     FX_DWORD                   GetBits(FX_DWORD nBits);
@@ -1282,9 +1195,9 @@ protected:
 
     FX_DWORD                   m_BitSize;
 
-    FX_LPCBYTE                 m_pData;
+    const uint8_t*                     m_pData;
 };
-template <class ObjClass> class CFX_CountRef : public CFX_Object
+template <class ObjClass> class CFX_CountRef 
 {
 public:
 
@@ -1431,10 +1344,10 @@ protected:
 class IFX_Pause
 {
 public:
-
+    virtual ~IFX_Pause() { }
     virtual FX_BOOL    NeedToPauseNow() = 0;
 };
-class CFX_DataFilter : public CFX_Object
+class CFX_DataFilter 
 {
 public:
 
@@ -1452,13 +1365,13 @@ public:
         return m_SrcPos;
     }
 
-    void                       FilterIn(FX_LPCBYTE src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf);
+    void                       FilterIn(const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf);
 
     void                       FilterFinish(CFX_BinaryBuf& dest_buf);
 protected:
 
     CFX_DataFilter();
-    virtual void       v_FilterIn(FX_LPCBYTE src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf) = 0;
+    virtual void       v_FilterIn(const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf) = 0;
     virtual void       v_FilterFinish(CFX_BinaryBuf& dest_buf) = 0;
     void                       ReportEOF(FX_DWORD left_input);
 
@@ -1468,6 +1381,21 @@ protected:
 
     CFX_DataFilter*    m_pDestFilter;
 };
+
+template<typename T>
+class CFX_AutoRestorer {
+public:
+    explicit CFX_AutoRestorer(T* location) {
+      m_Location = location;
+      m_OldValue = *location;
+    }
+    ~CFX_AutoRestorer() { *m_Location = m_OldValue; }
+
+private:
+  T* m_Location;
+  T m_OldValue;
+};
+
 template <class T>
 class CFX_SmartPointer
 {
@@ -1477,7 +1405,7 @@ public:
     {
         m_pObj->Release();
     }
-    operator T*(void)
+    T* Get(void)
     {
         return m_pObj;
     }
@@ -1494,20 +1422,20 @@ protected:
 };
 #define FX_DATALIST_LENGTH     1024
 template<size_t unit>
-class CFX_SortListArray : public CFX_Object
+class CFX_SortListArray 
 {
 protected:
 
     struct DataList {
 
-        FX_INT32       start;
+        int32_t        start;
 
-        FX_INT32       count;
-        FX_LPBYTE      data;
+        int32_t        count;
+        uint8_t*       data;
     };
 public:
 
-    CFX_SortListArray(IFX_Allocator* pAllocator = NULL) : m_CurList(0), m_DataLists(pAllocator) {}
+    CFX_SortListArray() : m_CurList(0) {}
 
     ~CFX_SortListArray()
     {
@@ -1517,31 +1445,25 @@ public:
 
     void                       Clear()
     {
-        IFX_Allocator* pAllocator = m_DataLists.m_pAllocator;
-        for (FX_INT32 i = m_DataLists.GetUpperBound(); i >= 0; i--) {
+        for (int32_t i = m_DataLists.GetUpperBound(); i >= 0; i--) {
             DataList list = m_DataLists.ElementAt(i);
             if (list.data) {
-                FX_Allocator_Free(pAllocator, list.data);
+                FX_Free(list.data);
             }
         }
         m_DataLists.RemoveAll();
         m_CurList = 0;
     }
 
-    void                       Append(FX_INT32 nStart, FX_INT32 nCount)
+    void                       Append(int32_t nStart, int32_t nCount)
     {
         if (nStart < 0) {
             return;
         }
-        IFX_Allocator* pAllocator = m_DataLists.m_pAllocator;
         while (nCount > 0) {
-            FX_INT32 temp_count = FX_MIN(nCount, FX_DATALIST_LENGTH);
+            int32_t temp_count = FX_MIN(nCount, FX_DATALIST_LENGTH);
             DataList list;
-            list.data = FX_Allocator_Alloc(pAllocator, FX_BYTE, temp_count * unit);
-            if (!list.data) {
-                break;
-            }
-            FXSYS_memset32(list.data, 0, temp_count * unit);
+            list.data = FX_Alloc2D(uint8_t, temp_count, unit);
             list.start = nStart;
             list.count = temp_count;
             Append(list);
@@ -1550,7 +1472,7 @@ public:
         }
     }
 
-    FX_LPBYTE          GetAt(FX_INT32 nIndex)
+    uint8_t*           GetAt(int32_t nIndex)
     {
         if (nIndex < 0) {
             return NULL;
@@ -1561,9 +1483,9 @@ public:
         DataList *pCurList = m_DataLists.GetDataPtr(m_CurList);
         if (!pCurList || nIndex < pCurList->start || nIndex >= pCurList->start + pCurList->count) {
             pCurList = NULL;
-            FX_INT32 iStart = 0;
-            FX_INT32 iEnd = m_DataLists.GetUpperBound();
-            FX_INT32 iMid = 0;
+            int32_t iStart = 0;
+            int32_t iEnd = m_DataLists.GetUpperBound();
+            int32_t iMid = 0;
             while (iStart <= iEnd) {
                 iMid = (iStart + iEnd) / 2;
                 DataList* list = m_DataLists.GetDataPtr(iMid);
@@ -1583,11 +1505,11 @@ public:
 protected:
     void                       Append(const DataList& list)
     {
-        FX_INT32 iStart = 0;
-        FX_INT32 iEnd = m_DataLists.GetUpperBound();
-        FX_INT32 iFind = 0;
+        int32_t iStart = 0;
+        int32_t iEnd = m_DataLists.GetUpperBound();
+        int32_t iFind = 0;
         while (iStart <= iEnd) {
-            FX_INT32 iMid = (iStart + iEnd) / 2;
+            int32_t iMid = (iStart + iEnd) / 2;
             DataList* cur_list = m_DataLists.GetDataPtr(iMid);
             if (list.start < cur_list->start + cur_list->count) {
                 iEnd = iMid - 1;
@@ -1607,11 +1529,11 @@ protected:
         }
         m_DataLists.InsertAt(iFind, list);
     }
-    FX_INT32           m_CurList;
+    int32_t            m_CurList;
     CFX_ArrayTemplate<DataList>        m_DataLists;
 };
 template<typename T1, typename T2>
-class CFX_ListArrayTemplate : public CFX_Object
+class CFX_ListArrayTemplate 
 {
 public:
 
@@ -1620,19 +1542,19 @@ public:
         m_Data.Clear();
     }
 
-    void                       Add(FX_INT32 nStart, FX_INT32 nCount)
+    void                       Add(int32_t nStart, int32_t nCount)
     {
         m_Data.Append(nStart, nCount);
     }
 
-    T2&                                operator [] (FX_INT32 nIndex)
+    T2&                                operator [] (int32_t nIndex)
     {
-        FX_LPBYTE data = m_Data.GetAt(nIndex);
+        uint8_t* data = m_Data.GetAt(nIndex);
         FXSYS_assert(data != NULL);
         return (T2&)(*(volatile T2*)data);
     }
 
-    T2*                                GetPtrAt(FX_INT32 nIndex)
+    T2*                                GetPtrAt(int32_t nIndex)
     {
         return (T2*)m_Data.GetAt(nIndex);
     }
@@ -1651,4 +1573,57 @@ typedef enum {
 } FX_ProgressiveStatus;
 #define ProgressiveStatus      FX_ProgressiveStatus
 #define FX_NAMESPACE_DECLARE(namespace, type)       namespace::type
-#endif
+class IFX_Unknown
+{
+public:
+    virtual FX_DWORD   Release() = 0;
+    virtual FX_DWORD   AddRef() = 0;
+};
+#define FX_IsOdd(a)    ((a) & 1)
+
+class CFX_Vector_3by1 
+{
+public:
+
+    CFX_Vector_3by1() :
+        a(0.0f), b(0.0f), c(0.0f)
+    {}
+
+    CFX_Vector_3by1(FX_FLOAT a1, FX_FLOAT b1, FX_FLOAT c1):
+        a(a1), b(b1), c(c1)
+    {}
+
+    FX_FLOAT a;
+    FX_FLOAT b;
+    FX_FLOAT c;
+};
+class CFX_Matrix_3by3 
+{
+public:
+
+    CFX_Matrix_3by3():
+        a(0.0f), b(0.0f), c(0.0f), d(0.0f), e(0.0f), f(0.0f), g(0.0f), h(0.0f), i(0.0f)
+    {}
+
+    CFX_Matrix_3by3(FX_FLOAT a1, FX_FLOAT b1, FX_FLOAT c1, FX_FLOAT d1, FX_FLOAT e1, FX_FLOAT f1, FX_FLOAT g1, FX_FLOAT h1, FX_FLOAT i1) :
+        a(a1), b(b1), c(c1), d(d1), e(e1), f(f1), g(g1), h(h1), i(i1)
+    {}
+
+    CFX_Matrix_3by3 Inverse();
+
+    CFX_Matrix_3by3 Multiply(const CFX_Matrix_3by3 &m);
+
+    CFX_Vector_3by1 TransformVector(const CFX_Vector_3by1 &v);
+
+    FX_FLOAT a;
+    FX_FLOAT b;
+    FX_FLOAT c;
+    FX_FLOAT d;
+    FX_FLOAT e;
+    FX_FLOAT f;
+    FX_FLOAT g;
+    FX_FLOAT h;
+    FX_FLOAT i;
+};
+
+#endif  // CORE_INCLUDE_FXCRT_FX_BASIC_H_