Revert "FX_BOOL considered harmful, part 2."
[pdfium.git] / core / src / fxcrt / fx_basic_buffer.cpp
index ef3cd21..9fc400e 100644 (file)
-// Copyright 2014 PDFium Authors. All rights reserved.\r
-// Use of this source code is governed by a BSD-style license that can be\r
-// found in the LICENSE file.\r
\r
-// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com\r
-\r
-#include "../../include/fxcrt/fx_basic.h"\r
-FX_STRSIZE FX_ftoa(FX_FLOAT f, FX_LPSTR buf);\r
-CFX_BinaryBuf::CFX_BinaryBuf(IFX_Allocator* pAllocator)\r
-    : m_pAllocator(pAllocator)\r
-    , m_AllocStep(0)\r
-    , m_pBuffer(NULL)\r
-    , m_DataSize(0)\r
-    , m_AllocSize(0)\r
-{\r
-}\r
-CFX_BinaryBuf::CFX_BinaryBuf(FX_STRSIZE size, IFX_Allocator* pAllocator)\r
-    : m_pAllocator(pAllocator)\r
-    , m_AllocStep(0)\r
-    , m_DataSize(size)\r
-    , m_AllocSize(size)\r
-{\r
-    m_pBuffer = FX_Allocator_Alloc(m_pAllocator, FX_BYTE, size);\r
-}\r
-CFX_BinaryBuf::~CFX_BinaryBuf()\r
-{\r
-    if (m_pBuffer) {\r
-        FX_Allocator_Free(m_pAllocator, m_pBuffer);\r
-    }\r
-}\r
-void CFX_BinaryBuf::Delete(int start_index, int count)\r
-{\r
-    if (!m_pBuffer || start_index < 0 || start_index + count > m_DataSize) {\r
-        return;\r
-    }\r
-    FXSYS_memmove32(m_pBuffer + start_index, m_pBuffer + start_index + count, m_DataSize - start_index - count);\r
-    m_DataSize -= count;\r
-}\r
-void CFX_BinaryBuf::Clear()\r
-{\r
-    m_DataSize = 0;\r
-}\r
-void CFX_BinaryBuf::DetachBuffer()\r
-{\r
-    m_DataSize = 0;\r
-    m_pBuffer = NULL;\r
-    m_AllocSize = 0;\r
-}\r
-void CFX_BinaryBuf::AttachData(void* buffer, FX_STRSIZE size)\r
-{\r
-    if (m_pBuffer) {\r
-        FX_Allocator_Free(m_pAllocator, m_pBuffer);\r
-    }\r
-    m_DataSize = size;\r
-    m_pBuffer = (FX_LPBYTE)buffer;\r
-    m_AllocSize = size;\r
-}\r
-void CFX_BinaryBuf::TakeOver(CFX_BinaryBuf& other)\r
-{\r
-    AttachData(other.GetBuffer(), other.GetSize());\r
-    other.DetachBuffer();\r
-}\r
-void CFX_BinaryBuf::EstimateSize(FX_STRSIZE size, FX_STRSIZE step)\r
-{\r
-    m_AllocStep = step;\r
-    if (m_AllocSize >= size) {\r
-        return;\r
-    }\r
-    ExpandBuf(size - m_DataSize);\r
-}\r
-void CFX_BinaryBuf::ExpandBuf(FX_STRSIZE add_size)\r
-{\r
-    FX_STRSIZE new_size = add_size + m_DataSize;\r
-    if (m_AllocSize >= new_size) {\r
-        return;\r
-    }\r
-    int alloc_step;\r
-    if (m_AllocStep == 0) {\r
-        alloc_step = m_AllocSize / 4;\r
-        if (alloc_step < 128 ) {\r
-            alloc_step = 128;\r
-        }\r
-    } else {\r
-        alloc_step = m_AllocStep;\r
-    }\r
-    new_size = (new_size + alloc_step - 1) / alloc_step * alloc_step;\r
-    FX_LPBYTE pNewBuffer = m_pBuffer;\r
-    if (pNewBuffer) {\r
-        pNewBuffer = FX_Allocator_Realloc(m_pAllocator, FX_BYTE, m_pBuffer, new_size);\r
-    } else {\r
-        pNewBuffer = FX_Allocator_Alloc(m_pAllocator, FX_BYTE, new_size);\r
-    }\r
-    if (pNewBuffer) {\r
-        m_pBuffer = pNewBuffer;\r
-        m_AllocSize = new_size;\r
-    }\r
-}\r
-void CFX_BinaryBuf::CopyData(const void* pStr, FX_STRSIZE size)\r
-{\r
-    if (size == 0) {\r
-        m_DataSize = 0;\r
-        return;\r
-    }\r
-    if (m_AllocSize < size) {\r
-        ExpandBuf(size - m_DataSize);\r
-    }\r
-    if (!m_pBuffer) {\r
-        return;\r
-    }\r
-    FXSYS_memcpy32(m_pBuffer, pStr, size);\r
-    m_DataSize = size;\r
-}\r
-void CFX_BinaryBuf::AppendBlock(const void* pBuf, FX_STRSIZE size)\r
-{\r
-    ExpandBuf(size);\r
-    if (pBuf && m_pBuffer) {\r
-        FXSYS_memcpy32(m_pBuffer + m_DataSize, pBuf, size);\r
-    }\r
-    m_DataSize += size;\r
-}\r
-void CFX_BinaryBuf::InsertBlock(FX_STRSIZE pos, const void* pBuf, FX_STRSIZE size)\r
-{\r
-    ExpandBuf(size);\r
-    if (!m_pBuffer) {\r
-        return;\r
-    }\r
-    FXSYS_memmove32(m_pBuffer + pos + size, m_pBuffer + pos, m_DataSize - pos);\r
-    if (pBuf) {\r
-        FXSYS_memcpy32(m_pBuffer + pos, pBuf, size);\r
-    }\r
-    m_DataSize += size;\r
-}\r
-void CFX_BinaryBuf::AppendFill(FX_BYTE byte, FX_STRSIZE count)\r
-{\r
-    ExpandBuf(count);\r
-    if (!m_pBuffer) {\r
-        return;\r
-    }\r
-    FXSYS_memset8(m_pBuffer + m_DataSize, byte, count);\r
-    m_DataSize += count;\r
-}\r
-CFX_ByteStringC CFX_BinaryBuf::GetByteString() const\r
-{\r
-    return CFX_ByteStringC(m_pBuffer, m_DataSize);\r
-}\r
-void CFX_BinaryBuf::GetByteStringL(CFX_ByteStringL &str) const\r
-{\r
-    str.Set(CFX_ByteStringC(m_pBuffer, m_DataSize), m_pAllocator);\r
-}\r
-CFX_ByteTextBuf& CFX_ByteTextBuf::operator << (FX_BSTR lpsz)\r
-{\r
-    AppendBlock((FX_LPCBYTE)lpsz, lpsz.GetLength());\r
-    return *this;\r
-}\r
-CFX_ByteTextBuf& CFX_ByteTextBuf::operator << (int i)\r
-{\r
-    char buf[32];\r
-    FXSYS_itoa(i, buf, 10);\r
-    AppendBlock(buf, (FX_STRSIZE)FXSYS_strlen(buf));\r
-    return *this;\r
-}\r
-CFX_ByteTextBuf& CFX_ByteTextBuf::operator << (FX_DWORD i)\r
-{\r
-    char buf[32];\r
-    FXSYS_itoa(i, buf, 10);\r
-    AppendBlock(buf, (FX_STRSIZE)FXSYS_strlen(buf));\r
-    return *this;\r
-}\r
-CFX_ByteTextBuf& CFX_ByteTextBuf::operator << (double f)\r
-{\r
-    char buf[32];\r
-    FX_STRSIZE len = FX_ftoa((FX_FLOAT)f, buf);\r
-    AppendBlock(buf, len);\r
-    return *this;\r
-}\r
-CFX_ByteTextBuf& CFX_ByteTextBuf::operator << (const CFX_ByteTextBuf& buf)\r
-{\r
-    AppendBlock(buf.m_pBuffer, buf.m_DataSize);\r
-    return *this;\r
-}\r
-void CFX_ByteTextBuf::operator =(const CFX_ByteStringC& str)\r
-{\r
-    CopyData((FX_LPCBYTE)str, str.GetLength());\r
-}\r
-void CFX_WideTextBuf::AppendChar(FX_WCHAR ch)\r
-{\r
-    if (m_AllocSize < m_DataSize + (FX_STRSIZE)sizeof(FX_WCHAR)) {\r
-        ExpandBuf(sizeof(FX_WCHAR));\r
-    }\r
-    ASSERT(m_pBuffer != NULL);\r
-    *(FX_WCHAR*)(m_pBuffer + m_DataSize) = ch;\r
-    m_DataSize += sizeof(FX_WCHAR);\r
-}\r
-CFX_WideTextBuf& CFX_WideTextBuf::operator << (FX_WSTR str)\r
-{\r
-    AppendBlock(str.GetPtr(), str.GetLength() * sizeof(FX_WCHAR));\r
-    return *this;\r
-}\r
-CFX_WideTextBuf& CFX_WideTextBuf::operator << (const CFX_WideString &str)\r
-{\r
-    AppendBlock((FX_LPCWSTR)str, str.GetLength() * sizeof(FX_WCHAR));\r
-    return *this;\r
-}\r
-CFX_WideTextBuf& CFX_WideTextBuf::operator << (int i)\r
-{\r
-    char buf[32];\r
-    FXSYS_itoa(i, buf, 10);\r
-    FX_STRSIZE len = (FX_STRSIZE)FXSYS_strlen(buf);\r
-    if (m_AllocSize < m_DataSize + (FX_STRSIZE)(len * sizeof(FX_WCHAR))) {\r
-        ExpandBuf(len * sizeof(FX_WCHAR));\r
-    }\r
-    ASSERT(m_pBuffer != NULL);\r
-    FX_LPWSTR str = (FX_WCHAR*)(m_pBuffer + m_DataSize);\r
-    for (FX_STRSIZE j = 0; j < len; j ++) {\r
-        *str ++ = buf[j];\r
-    }\r
-    m_DataSize += len * sizeof(FX_WCHAR);\r
-    return *this;\r
-}\r
-CFX_WideTextBuf& CFX_WideTextBuf::operator << (double f)\r
-{\r
-    char buf[32];\r
-    FX_STRSIZE len = FX_ftoa((FX_FLOAT)f, buf);\r
-    if (m_AllocSize < m_DataSize + (FX_STRSIZE)(len * sizeof(FX_WCHAR))) {\r
-        ExpandBuf(len * sizeof(FX_WCHAR));\r
-    }\r
-    ASSERT(m_pBuffer != NULL);\r
-    FX_LPWSTR str = (FX_WCHAR*)(m_pBuffer + m_DataSize);\r
-    for (FX_STRSIZE i = 0; i < len; i ++) {\r
-        *str ++ = buf[i];\r
-    }\r
-    m_DataSize += len * sizeof(FX_WCHAR);\r
-    return *this;\r
-}\r
-CFX_WideTextBuf& CFX_WideTextBuf::operator << (FX_LPCWSTR lpsz)\r
-{\r
-    AppendBlock(lpsz, (FX_STRSIZE)FXSYS_wcslen(lpsz)*sizeof(FX_WCHAR));\r
-    return *this;\r
-}\r
-CFX_WideTextBuf& CFX_WideTextBuf::operator << (const CFX_WideTextBuf& buf)\r
-{\r
-    AppendBlock(buf.m_pBuffer, buf.m_DataSize);\r
-    return *this;\r
-}\r
-void CFX_WideTextBuf::operator =(FX_WSTR str)\r
-{\r
-    CopyData(str.GetPtr(), str.GetLength() * sizeof(FX_WCHAR));\r
-}\r
-CFX_WideStringC CFX_WideTextBuf::GetWideString() const\r
-{\r
-    return CFX_WideStringC((FX_LPCWSTR)m_pBuffer, m_DataSize / sizeof(FX_WCHAR));\r
-}\r
-void CFX_WideTextBuf::GetWideStringL(CFX_WideStringL& wideText) const\r
-{\r
-    wideText.Set(CFX_WideStringC((FX_LPCWSTR)m_pBuffer, m_DataSize / sizeof(FX_WCHAR)), m_pAllocator);\r
-}\r
-CFX_ArchiveSaver& CFX_ArchiveSaver::operator << (FX_BYTE i)\r
-{\r
-    if (m_pStream) {\r
-        m_pStream->WriteBlock(&i, 1);\r
-    } else {\r
-        m_SavingBuf.AppendByte(i);\r
-    }\r
-    return *this;\r
-}\r
-CFX_ArchiveSaver& CFX_ArchiveSaver::operator << (int i)\r
-{\r
-    if (m_pStream) {\r
-        m_pStream->WriteBlock(&i, sizeof(int));\r
-    } else {\r
-        m_SavingBuf.AppendBlock(&i, sizeof(int));\r
-    }\r
-    return *this;\r
-}\r
-CFX_ArchiveSaver& CFX_ArchiveSaver::operator << (FX_DWORD i)\r
-{\r
-    if (m_pStream) {\r
-        m_pStream->WriteBlock(&i, sizeof(FX_DWORD));\r
-    } else {\r
-        m_SavingBuf.AppendBlock(&i, sizeof(FX_DWORD));\r
-    }\r
-    return *this;\r
-}\r
-CFX_ArchiveSaver& CFX_ArchiveSaver::operator << (FX_FLOAT f)\r
-{\r
-    if (m_pStream) {\r
-        m_pStream->WriteBlock(&f, sizeof(FX_FLOAT));\r
-    } else {\r
-        m_SavingBuf.AppendBlock(&f, sizeof(FX_FLOAT));\r
-    }\r
-    return *this;\r
-}\r
-CFX_ArchiveSaver& CFX_ArchiveSaver::operator << (FX_BSTR bstr)\r
-{\r
-    int len = bstr.GetLength();\r
-    if (m_pStream) {\r
-        m_pStream->WriteBlock(&len, sizeof(int));\r
-        m_pStream->WriteBlock(bstr, len);\r
-    } else {\r
-        m_SavingBuf.AppendBlock(&len, sizeof(int));\r
-        m_SavingBuf.AppendBlock(bstr, len);\r
-    }\r
-    return *this;\r
-}\r
-CFX_ArchiveSaver& CFX_ArchiveSaver::operator << (FX_LPCWSTR wstr)\r
-{\r
-    FX_STRSIZE len = (FX_STRSIZE)FXSYS_wcslen(wstr);\r
-    if (m_pStream) {\r
-        m_pStream->WriteBlock(&len, sizeof(int));\r
-        m_pStream->WriteBlock(wstr, len);\r
-    } else {\r
-        m_SavingBuf.AppendBlock(&len, sizeof(int));\r
-        m_SavingBuf.AppendBlock(wstr, len);\r
-    }\r
-    return *this;\r
-}\r
-CFX_ArchiveSaver& CFX_ArchiveSaver::operator << (const CFX_WideString& wstr)\r
-{\r
-    CFX_ByteString encoded = wstr.UTF16LE_Encode();\r
-    return operator << (encoded);\r
-}\r
-void CFX_ArchiveSaver::Write(const void* pData, FX_STRSIZE dwSize)\r
-{\r
-    if (m_pStream) {\r
-        m_pStream->WriteBlock(pData, dwSize);\r
-    } else {\r
-        m_SavingBuf.AppendBlock(pData, dwSize);\r
-    }\r
-}\r
-CFX_ArchiveLoader::CFX_ArchiveLoader(FX_LPCBYTE pData, FX_DWORD dwSize)\r
-{\r
-    m_pLoadingBuf = pData;\r
-    m_LoadingPos = 0;\r
-    m_LoadingSize = dwSize;\r
-}\r
-FX_BOOL CFX_ArchiveLoader::IsEOF()\r
-{\r
-    return m_LoadingPos >= m_LoadingSize;\r
-}\r
-CFX_ArchiveLoader& CFX_ArchiveLoader::operator >> (FX_BYTE& i)\r
-{\r
-    if (m_LoadingPos >= m_LoadingSize) {\r
-        return *this;\r
-    }\r
-    i = m_pLoadingBuf[m_LoadingPos++];\r
-    return *this;\r
-}\r
-CFX_ArchiveLoader& CFX_ArchiveLoader::operator >> (int& i)\r
-{\r
-    Read(&i, sizeof(int));\r
-    return *this;\r
-}\r
-CFX_ArchiveLoader& CFX_ArchiveLoader::operator >> (FX_DWORD& i)\r
-{\r
-    Read(&i, sizeof(FX_DWORD));\r
-    return *this;\r
-}\r
-CFX_ArchiveLoader& CFX_ArchiveLoader::operator >> (FX_FLOAT& i)\r
-{\r
-    Read(&i, sizeof(FX_FLOAT));\r
-    return *this;\r
-}\r
-CFX_ArchiveLoader& CFX_ArchiveLoader::operator >> (CFX_ByteString& str)\r
-{\r
-    if (m_LoadingPos + 4 > m_LoadingSize) {\r
-        return *this;\r
-    }\r
-    int len;\r
-    operator >> (len);\r
-    str.Empty();\r
-    if (len <= 0 || m_LoadingPos + len > m_LoadingSize) {\r
-        return *this;\r
-    }\r
-    FX_LPSTR buffer = str.GetBuffer(len);\r
-    FXSYS_memcpy32(buffer, m_pLoadingBuf + m_LoadingPos, len);\r
-    str.ReleaseBuffer(len);\r
-    m_LoadingPos += len;\r
-    return *this;\r
-}\r
-CFX_ArchiveLoader& CFX_ArchiveLoader::operator >> (CFX_WideString& str)\r
-{\r
-    CFX_ByteString encoded;\r
-    operator >> (encoded);\r
-    str = CFX_WideString::FromUTF16LE((const unsigned short*)(FX_LPCSTR)encoded, encoded.GetLength());\r
-    return *this;\r
-}\r
-FX_BOOL CFX_ArchiveLoader::Read(void* pBuf, FX_DWORD dwSize)\r
-{\r
-    if (m_LoadingPos + dwSize > m_LoadingSize) {\r
-        return FALSE;\r
-    }\r
-    FXSYS_memcpy32(pBuf, m_pLoadingBuf + m_LoadingPos, dwSize);\r
-    m_LoadingPos += dwSize;\r
-    return TRUE;\r
-}\r
-void CFX_BitStream::Init(FX_LPCBYTE pData, FX_DWORD dwSize)\r
-{\r
-    m_pData = pData;\r
-    m_BitSize = dwSize * 8;\r
-    m_BitPos = 0;\r
-}\r
-void CFX_BitStream::ByteAlign()\r
-{\r
-    int mod = m_BitPos % 8;\r
-    if (mod == 0) {\r
-        return;\r
-    }\r
-    m_BitPos += 8 - mod;\r
-}\r
-FX_DWORD CFX_BitStream::GetBits(FX_DWORD nBits)\r
-{\r
-    if (nBits > m_BitSize || m_BitPos + nBits > m_BitSize) {\r
-        return 0;\r
-    }\r
-    if (nBits == 1) {\r
-        int bit = (m_pData[m_BitPos / 8] & (1 << (7 - m_BitPos % 8))) ? 1 : 0;\r
-        m_BitPos ++;\r
-        return bit;\r
-    }\r
-    FX_DWORD byte_pos = m_BitPos / 8;\r
-    FX_DWORD bit_pos = m_BitPos % 8, bit_left = nBits;\r
-    FX_DWORD result = 0;\r
-    if (bit_pos) {\r
-        if (8 - bit_pos >= bit_left) {\r
-            result = (m_pData[byte_pos] & (0xff >> bit_pos)) >> (8 - bit_pos - bit_left);\r
-            m_BitPos += bit_left;\r
-            return result;\r
-        }\r
-        bit_left -= 8 - bit_pos;\r
-        result = (m_pData[byte_pos++] & ((1 << (8 - bit_pos)) - 1)) << bit_left;\r
-    }\r
-    while (bit_left >= 8) {\r
-        bit_left -= 8;\r
-        result |= m_pData[byte_pos++] << bit_left;\r
-    }\r
-    if (bit_left) {\r
-        result |= m_pData[byte_pos] >> (8 - bit_left);\r
-    }\r
-    m_BitPos += nBits;\r
-    return result;\r
-}\r
-IFX_BufferArchive::IFX_BufferArchive(FX_STRSIZE size, IFX_Allocator* pAllocator)\r
-    : m_pAllocator(pAllocator)\r
-    , m_BufSize(size)\r
-    , m_pBuffer(NULL)\r
-    , m_Length(0)\r
-{\r
-}\r
-void IFX_BufferArchive::Clear()\r
-{\r
-    m_Length = 0;\r
-    if (m_pBuffer) {\r
-        FX_Allocator_Free(m_pAllocator, m_pBuffer);\r
-        m_pBuffer = NULL;\r
-    }\r
-}\r
-FX_BOOL IFX_BufferArchive::Flush()\r
-{\r
-    FX_BOOL bRet = DoWork(m_pBuffer, m_Length);\r
-    m_Length = 0;\r
-    return bRet;\r
-}\r
-FX_INT32 IFX_BufferArchive::AppendBlock(const void* pBuf, size_t size)\r
-{\r
-    if (!pBuf || size < 1) {\r
-        return 0;\r
-    }\r
-    if (!m_pBuffer) {\r
-        m_pBuffer = FX_Allocator_Alloc(m_pAllocator, FX_BYTE, m_BufSize);\r
-        if (!m_pBuffer) {\r
-            return -1;\r
-        }\r
-    }\r
-    FX_LPBYTE buffer = (FX_LPBYTE)pBuf;\r
-    FX_STRSIZE temp_size = (FX_STRSIZE)size;\r
-    while (temp_size > 0) {\r
-        FX_STRSIZE buf_size = FX_MIN(m_BufSize - m_Length, (FX_STRSIZE)temp_size);\r
-        FXSYS_memcpy32(m_pBuffer + m_Length, buffer, buf_size);\r
-        m_Length += buf_size;\r
-        if (m_Length == m_BufSize) {\r
-            if (!Flush()) {\r
-                return -1;\r
-            }\r
-        }\r
-        temp_size -= buf_size;\r
-        buffer += buf_size;\r
-    }\r
-    return (FX_INT32)size;\r
-}\r
-FX_INT32 IFX_BufferArchive::AppendByte(FX_BYTE byte)\r
-{\r
-    return AppendBlock(&byte, 1);\r
-}\r
-FX_INT32 IFX_BufferArchive::AppendDWord(FX_DWORD i)\r
-{\r
-    char buf[32];\r
-    FXSYS_itoa(i, buf, 10);\r
-    return AppendBlock(buf, (size_t)FXSYS_strlen(buf));\r
-}\r
-FX_INT32 IFX_BufferArchive::AppendString(FX_BSTR lpsz)\r
-{\r
-    return AppendBlock((FX_LPCBYTE)lpsz, lpsz.GetLength());\r
-}\r
-CFX_FileBufferArchive::CFX_FileBufferArchive(FX_STRSIZE size, IFX_Allocator* pAllocator)\r
-    : IFX_BufferArchive(size, pAllocator)\r
-    , m_pFile(NULL)\r
-    , m_bTakeover(FALSE)\r
-{\r
-}\r
-CFX_FileBufferArchive::~CFX_FileBufferArchive()\r
-{\r
-    Clear();\r
-}\r
-void CFX_FileBufferArchive::Clear()\r
-{\r
-    if (m_pFile && m_bTakeover) {\r
-        m_pFile->Release();\r
-    }\r
-    m_pFile = NULL;\r
-    m_bTakeover = FALSE;\r
-    IFX_BufferArchive::Clear();\r
-}\r
-FX_BOOL CFX_FileBufferArchive::AttachFile(IFX_StreamWrite *pFile, FX_BOOL bTakeover )\r
-{\r
-    if (!pFile) {\r
-        return FALSE;\r
-    }\r
-    if (m_pFile && m_bTakeover) {\r
-        m_pFile->Release();\r
-    }\r
-    m_pFile = pFile;\r
-    m_bTakeover = bTakeover;\r
-    return TRUE;\r
-}\r
-FX_BOOL CFX_FileBufferArchive::AttachFile(FX_LPCWSTR filename)\r
-{\r
-    if (!filename) {\r
-        return FALSE;\r
-    }\r
-    if (m_pFile && m_bTakeover) {\r
-        m_pFile->Release();\r
-    }\r
-    m_pFile = FX_CreateFileWrite(filename);\r
-    if (!m_pFile) {\r
-        return FALSE;\r
-    }\r
-    m_bTakeover = TRUE;\r
-    return TRUE;\r
-}\r
-FX_BOOL CFX_FileBufferArchive::AttachFile(FX_LPCSTR filename)\r
-{\r
-    if (!filename) {\r
-        return FALSE;\r
-    }\r
-    if (m_pFile && m_bTakeover) {\r
-        m_pFile->Release();\r
-    }\r
-    m_pFile = FX_CreateFileWrite(filename);\r
-    if (!m_pFile) {\r
-        return FALSE;\r
-    }\r
-    m_bTakeover = TRUE;\r
-    return TRUE;\r
-}\r
-FX_BOOL CFX_FileBufferArchive::DoWork(const void* pBuf, size_t size)\r
-{\r
-    if (!m_pFile) {\r
-        return FALSE;\r
-    }\r
-    if (!pBuf || size < 1) {\r
-        return TRUE;\r
-    }\r
-    return m_pFile->WriteBlock(pBuf, size);\r
-}\r
+// 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
+
+#include "../../include/fxcrt/fx_basic.h"
+FX_STRSIZE FX_ftoa(FX_FLOAT f, FX_CHAR* buf);
+CFX_BinaryBuf::CFX_BinaryBuf()
+    : m_AllocStep(0)
+    , m_pBuffer(NULL)
+    , m_DataSize(0)
+    , m_AllocSize(0)
+{
+}
+CFX_BinaryBuf::CFX_BinaryBuf(FX_STRSIZE size)
+    : m_AllocStep(0)
+    , m_DataSize(size)
+    , m_AllocSize(size)
+{
+    m_pBuffer = FX_Alloc(uint8_t, size);
+}
+CFX_BinaryBuf::~CFX_BinaryBuf()
+{
+    if (m_pBuffer) {
+        FX_Free(m_pBuffer);
+    }
+}
+void CFX_BinaryBuf::Delete(int start_index, int count)
+{
+    if (!m_pBuffer || start_index < 0 || start_index + count > m_DataSize) {
+        return;
+    }
+    FXSYS_memmove(m_pBuffer + start_index, m_pBuffer + start_index + count, m_DataSize - start_index - count);
+    m_DataSize -= count;
+}
+void CFX_BinaryBuf::Clear()
+{
+    m_DataSize = 0;
+}
+void CFX_BinaryBuf::DetachBuffer()
+{
+    m_DataSize = 0;
+    m_pBuffer = NULL;
+    m_AllocSize = 0;
+}
+void CFX_BinaryBuf::AttachData(void* buffer, FX_STRSIZE size)
+{
+    if (m_pBuffer) {
+        FX_Free(m_pBuffer);
+    }
+    m_DataSize = size;
+    m_pBuffer = (uint8_t*)buffer;
+    m_AllocSize = size;
+}
+void CFX_BinaryBuf::TakeOver(CFX_BinaryBuf& other)
+{
+    AttachData(other.GetBuffer(), other.GetSize());
+    other.DetachBuffer();
+}
+void CFX_BinaryBuf::EstimateSize(FX_STRSIZE size, FX_STRSIZE step)
+{
+    m_AllocStep = step;
+    if (m_AllocSize >= size) {
+        return;
+    }
+    ExpandBuf(size - m_DataSize);
+}
+void CFX_BinaryBuf::ExpandBuf(FX_STRSIZE add_size)
+{
+    FX_STRSIZE new_size = add_size + m_DataSize;
+    if (m_AllocSize >= new_size) {
+        return;
+    }
+    int alloc_step;
+    if (m_AllocStep == 0) {
+        alloc_step = m_AllocSize / 4;
+        if (alloc_step < 128 ) {
+            alloc_step = 128;
+        }
+    } else {
+        alloc_step = m_AllocStep;
+    }
+    new_size = (new_size + alloc_step - 1) / alloc_step * alloc_step;
+    uint8_t* pNewBuffer = m_pBuffer;
+    if (pNewBuffer) {
+        pNewBuffer = FX_Realloc(uint8_t, m_pBuffer, new_size);
+    } else {
+        pNewBuffer = FX_Alloc(uint8_t, new_size);
+    }
+    m_pBuffer = pNewBuffer;
+    m_AllocSize = new_size;
+}
+void CFX_BinaryBuf::CopyData(const void* pStr, FX_STRSIZE size)
+{
+    if (size == 0) {
+        m_DataSize = 0;
+        return;
+    }
+    if (m_AllocSize < size) {
+        ExpandBuf(size - m_DataSize);
+    }
+    if (!m_pBuffer) {
+        return;
+    }
+    FXSYS_memcpy(m_pBuffer, pStr, size);
+    m_DataSize = size;
+}
+void CFX_BinaryBuf::AppendBlock(const void* pBuf, FX_STRSIZE size)
+{
+    ExpandBuf(size);
+    if (pBuf && m_pBuffer) {
+        FXSYS_memcpy(m_pBuffer + m_DataSize, pBuf, size);
+    }
+    m_DataSize += size;
+}
+void CFX_BinaryBuf::InsertBlock(FX_STRSIZE pos, const void* pBuf, FX_STRSIZE size)
+{
+    ExpandBuf(size);
+    if (!m_pBuffer) {
+        return;
+    }
+    FXSYS_memmove(m_pBuffer + pos + size, m_pBuffer + pos, m_DataSize - pos);
+    if (pBuf) {
+        FXSYS_memcpy(m_pBuffer + pos, pBuf, size);
+    }
+    m_DataSize += size;
+}
+void CFX_BinaryBuf::AppendFill(uint8_t byte, FX_STRSIZE count)
+{
+    ExpandBuf(count);
+    if (!m_pBuffer) {
+        return;
+    }
+    FXSYS_memset(m_pBuffer + m_DataSize, byte, count);
+    m_DataSize += count;
+}
+CFX_ByteStringC CFX_BinaryBuf::GetByteString() const
+{
+    return CFX_ByteStringC(m_pBuffer, m_DataSize);
+}
+CFX_ByteTextBuf& CFX_ByteTextBuf::operator << (const CFX_ByteStringC& lpsz)
+{
+    AppendBlock(lpsz.GetPtr(), lpsz.GetLength());
+    return *this;
+}
+CFX_ByteTextBuf& CFX_ByteTextBuf::operator << (int i)
+{
+    char buf[32];
+    FXSYS_itoa(i, buf, 10);
+    AppendBlock(buf, FXSYS_strlen(buf));
+    return *this;
+}
+CFX_ByteTextBuf& CFX_ByteTextBuf::operator << (FX_DWORD i)
+{
+    char buf[32];
+    FXSYS_itoa(i, buf, 10);
+    AppendBlock(buf, FXSYS_strlen(buf));
+    return *this;
+}
+CFX_ByteTextBuf& CFX_ByteTextBuf::operator << (double f)
+{
+    char buf[32];
+    FX_STRSIZE len = FX_ftoa((FX_FLOAT)f, buf);
+    AppendBlock(buf, len);
+    return *this;
+}
+CFX_ByteTextBuf& CFX_ByteTextBuf::operator << (const CFX_ByteTextBuf& buf)
+{
+    AppendBlock(buf.m_pBuffer, buf.m_DataSize);
+    return *this;
+}
+void CFX_ByteTextBuf::operator =(const CFX_ByteStringC& str)
+{
+    CopyData(str.GetPtr(), str.GetLength());
+}
+void CFX_WideTextBuf::AppendChar(FX_WCHAR ch)
+{
+    if (m_AllocSize < m_DataSize + (FX_STRSIZE)sizeof(FX_WCHAR)) {
+        ExpandBuf(sizeof(FX_WCHAR));
+    }
+    ASSERT(m_pBuffer != NULL);
+    *(FX_WCHAR*)(m_pBuffer + m_DataSize) = ch;
+    m_DataSize += sizeof(FX_WCHAR);
+}
+CFX_WideTextBuf& CFX_WideTextBuf::operator << (const CFX_WideStringC& str)
+{
+    AppendBlock(str.GetPtr(), str.GetLength() * sizeof(FX_WCHAR));
+    return *this;
+}
+CFX_WideTextBuf& CFX_WideTextBuf::operator << (const CFX_WideString &str)
+{
+    AppendBlock(str.c_str(), str.GetLength() * sizeof(FX_WCHAR));
+    return *this;
+}
+CFX_WideTextBuf& CFX_WideTextBuf::operator << (int i)
+{
+    char buf[32];
+    FXSYS_itoa(i, buf, 10);
+    FX_STRSIZE len = FXSYS_strlen(buf);
+    if (m_AllocSize < m_DataSize + (FX_STRSIZE)(len * sizeof(FX_WCHAR))) {
+        ExpandBuf(len * sizeof(FX_WCHAR));
+    }
+    ASSERT(m_pBuffer != NULL);
+    FX_WCHAR* str = (FX_WCHAR*)(m_pBuffer + m_DataSize);
+    for (FX_STRSIZE j = 0; j < len; j ++) {
+        *str ++ = buf[j];
+    }
+    m_DataSize += len * sizeof(FX_WCHAR);
+    return *this;
+}
+CFX_WideTextBuf& CFX_WideTextBuf::operator << (double f)
+{
+    char buf[32];
+    FX_STRSIZE len = FX_ftoa((FX_FLOAT)f, buf);
+    if (m_AllocSize < m_DataSize + (FX_STRSIZE)(len * sizeof(FX_WCHAR))) {
+        ExpandBuf(len * sizeof(FX_WCHAR));
+    }
+    ASSERT(m_pBuffer != NULL);
+    FX_WCHAR* str = (FX_WCHAR*)(m_pBuffer + m_DataSize);
+    for (FX_STRSIZE i = 0; i < len; i ++) {
+        *str ++ = buf[i];
+    }
+    m_DataSize += len * sizeof(FX_WCHAR);
+    return *this;
+}
+CFX_WideTextBuf& CFX_WideTextBuf::operator << (const FX_WCHAR* lpsz)
+{
+    AppendBlock(lpsz, FXSYS_wcslen(lpsz)*sizeof(FX_WCHAR));
+    return *this;
+}
+CFX_WideTextBuf& CFX_WideTextBuf::operator << (const CFX_WideTextBuf& buf)
+{
+    AppendBlock(buf.m_pBuffer, buf.m_DataSize);
+    return *this;
+}
+void CFX_WideTextBuf::operator =(const CFX_WideStringC& str)
+{
+    CopyData(str.GetPtr(), str.GetLength() * sizeof(FX_WCHAR));
+}
+CFX_WideStringC CFX_WideTextBuf::GetWideString() const
+{
+    return CFX_WideStringC((const FX_WCHAR*)m_pBuffer, m_DataSize / sizeof(FX_WCHAR));
+}
+CFX_ArchiveSaver& CFX_ArchiveSaver::operator << (uint8_t i)
+{
+    if (m_pStream) {
+        m_pStream->WriteBlock(&i, 1);
+    } else {
+        m_SavingBuf.AppendByte(i);
+    }
+    return *this;
+}
+CFX_ArchiveSaver& CFX_ArchiveSaver::operator << (int i)
+{
+    if (m_pStream) {
+        m_pStream->WriteBlock(&i, sizeof(int));
+    } else {
+        m_SavingBuf.AppendBlock(&i, sizeof(int));
+    }
+    return *this;
+}
+CFX_ArchiveSaver& CFX_ArchiveSaver::operator << (FX_DWORD i)
+{
+    if (m_pStream) {
+        m_pStream->WriteBlock(&i, sizeof(FX_DWORD));
+    } else {
+        m_SavingBuf.AppendBlock(&i, sizeof(FX_DWORD));
+    }
+    return *this;
+}
+CFX_ArchiveSaver& CFX_ArchiveSaver::operator << (FX_FLOAT f)
+{
+    if (m_pStream) {
+        m_pStream->WriteBlock(&f, sizeof(FX_FLOAT));
+    } else {
+        m_SavingBuf.AppendBlock(&f, sizeof(FX_FLOAT));
+    }
+    return *this;
+}
+CFX_ArchiveSaver& CFX_ArchiveSaver::operator << (const CFX_ByteStringC& bstr)
+{
+    int len = bstr.GetLength();
+    if (m_pStream) {
+        m_pStream->WriteBlock(&len, sizeof(int));
+        m_pStream->WriteBlock(bstr.GetPtr(), len);
+    } else {
+        m_SavingBuf.AppendBlock(&len, sizeof(int));
+        m_SavingBuf.AppendBlock(bstr.GetPtr(), len);
+    }
+    return *this;
+}
+CFX_ArchiveSaver& CFX_ArchiveSaver::operator << (const FX_WCHAR* wstr)
+{
+    FX_STRSIZE len = FXSYS_wcslen(wstr);
+    if (m_pStream) {
+        m_pStream->WriteBlock(&len, sizeof(int));
+        m_pStream->WriteBlock(wstr, len);
+    } else {
+        m_SavingBuf.AppendBlock(&len, sizeof(int));
+        m_SavingBuf.AppendBlock(wstr, len);
+    }
+    return *this;
+}
+CFX_ArchiveSaver& CFX_ArchiveSaver::operator << (const CFX_WideString& wstr)
+{
+    CFX_ByteString encoded = wstr.UTF16LE_Encode();
+    return operator << (encoded);
+}
+void CFX_ArchiveSaver::Write(const void* pData, FX_STRSIZE dwSize)
+{
+    if (m_pStream) {
+        m_pStream->WriteBlock(pData, dwSize);
+    } else {
+        m_SavingBuf.AppendBlock(pData, dwSize);
+    }
+}
+CFX_ArchiveLoader::CFX_ArchiveLoader(const uint8_t* pData, FX_DWORD dwSize)
+{
+    m_pLoadingBuf = pData;
+    m_LoadingPos = 0;
+    m_LoadingSize = dwSize;
+}
+FX_BOOL CFX_ArchiveLoader::IsEOF()
+{
+    return m_LoadingPos >= m_LoadingSize;
+}
+CFX_ArchiveLoader& CFX_ArchiveLoader::operator >> (uint8_t& i)
+{
+    if (m_LoadingPos >= m_LoadingSize) {
+        return *this;
+    }
+    i = m_pLoadingBuf[m_LoadingPos++];
+    return *this;
+}
+CFX_ArchiveLoader& CFX_ArchiveLoader::operator >> (int& i)
+{
+    Read(&i, sizeof(int));
+    return *this;
+}
+CFX_ArchiveLoader& CFX_ArchiveLoader::operator >> (FX_DWORD& i)
+{
+    Read(&i, sizeof(FX_DWORD));
+    return *this;
+}
+CFX_ArchiveLoader& CFX_ArchiveLoader::operator >> (FX_FLOAT& i)
+{
+    Read(&i, sizeof(FX_FLOAT));
+    return *this;
+}
+CFX_ArchiveLoader& CFX_ArchiveLoader::operator >> (CFX_ByteString& str)
+{
+    if (m_LoadingPos + 4 > m_LoadingSize) {
+        return *this;
+    }
+    int len;
+    operator >> (len);
+    str.Empty();
+    if (len <= 0 || m_LoadingPos + len > m_LoadingSize) {
+        return *this;
+    }
+    FX_CHAR* buffer = str.GetBuffer(len);
+    FXSYS_memcpy(buffer, m_pLoadingBuf + m_LoadingPos, len);
+    str.ReleaseBuffer(len);
+    m_LoadingPos += len;
+    return *this;
+}
+CFX_ArchiveLoader& CFX_ArchiveLoader::operator >> (CFX_WideString& str)
+{
+    CFX_ByteString encoded;
+    operator >> (encoded);
+    str = CFX_WideString::FromUTF16LE((const unsigned short*)encoded.c_str(), encoded.GetLength());
+    return *this;
+}
+FX_BOOL CFX_ArchiveLoader::Read(void* pBuf, FX_DWORD dwSize)
+{
+    if (m_LoadingPos + dwSize > m_LoadingSize) {
+        return FALSE;
+    }
+    FXSYS_memcpy(pBuf, m_pLoadingBuf + m_LoadingPos, dwSize);
+    m_LoadingPos += dwSize;
+    return TRUE;
+}
+void CFX_BitStream::Init(const uint8_t* pData, FX_DWORD dwSize)
+{
+    m_pData = pData;
+    m_BitSize = dwSize * 8;
+    m_BitPos = 0;
+}
+void CFX_BitStream::ByteAlign()
+{
+    int mod = m_BitPos % 8;
+    if (mod == 0) {
+        return;
+    }
+    m_BitPos += 8 - mod;
+}
+FX_DWORD CFX_BitStream::GetBits(FX_DWORD nBits)
+{
+    if (nBits > m_BitSize || m_BitPos + nBits > m_BitSize) {
+        return 0;
+    }
+    if (nBits == 1) {
+        int bit = (m_pData[m_BitPos / 8] & (1 << (7 - m_BitPos % 8))) ? 1 : 0;
+        m_BitPos ++;
+        return bit;
+    }
+    FX_DWORD byte_pos = m_BitPos / 8;
+    FX_DWORD bit_pos = m_BitPos % 8, bit_left = nBits;
+    FX_DWORD result = 0;
+    if (bit_pos) {
+        if (8 - bit_pos >= bit_left) {
+            result = (m_pData[byte_pos] & (0xff >> bit_pos)) >> (8 - bit_pos - bit_left);
+            m_BitPos += bit_left;
+            return result;
+        }
+        bit_left -= 8 - bit_pos;
+        result = (m_pData[byte_pos++] & ((1 << (8 - bit_pos)) - 1)) << bit_left;
+    }
+    while (bit_left >= 8) {
+        bit_left -= 8;
+        result |= m_pData[byte_pos++] << bit_left;
+    }
+    if (bit_left) {
+        result |= m_pData[byte_pos] >> (8 - bit_left);
+    }
+    m_BitPos += nBits;
+    return result;
+}
+IFX_BufferArchive::IFX_BufferArchive(FX_STRSIZE size)
+    : m_BufSize(size)
+    , m_pBuffer(NULL)
+    , m_Length(0)
+{
+}
+void IFX_BufferArchive::Clear()
+{
+    m_Length = 0;
+    if (m_pBuffer) {
+        FX_Free(m_pBuffer);
+        m_pBuffer = NULL;
+    }
+}
+FX_BOOL IFX_BufferArchive::Flush()
+{
+    FX_BOOL bRet = DoWork(m_pBuffer, m_Length);
+    m_Length = 0;
+    return bRet;
+}
+int32_t IFX_BufferArchive::AppendBlock(const void* pBuf, size_t size)
+{
+    if (!pBuf || size < 1) {
+        return 0;
+    }
+    if (!m_pBuffer) {
+        m_pBuffer = FX_Alloc(uint8_t, m_BufSize);
+    }
+    uint8_t* buffer = (uint8_t*)pBuf;
+    FX_STRSIZE temp_size = (FX_STRSIZE)size;
+    while (temp_size > 0) {
+        FX_STRSIZE buf_size = FX_MIN(m_BufSize - m_Length, (FX_STRSIZE)temp_size);
+        FXSYS_memcpy(m_pBuffer + m_Length, buffer, buf_size);
+        m_Length += buf_size;
+        if (m_Length == m_BufSize) {
+            if (!Flush()) {
+                return -1;
+            }
+        }
+        temp_size -= buf_size;
+        buffer += buf_size;
+    }
+    return (int32_t)size;
+}
+int32_t IFX_BufferArchive::AppendByte(uint8_t byte)
+{
+    return AppendBlock(&byte, 1);
+}
+int32_t IFX_BufferArchive::AppendDWord(FX_DWORD i)
+{
+    char buf[32];
+    FXSYS_itoa(i, buf, 10);
+    return AppendBlock(buf, (size_t)FXSYS_strlen(buf));
+}
+int32_t IFX_BufferArchive::AppendString(const CFX_ByteStringC& lpsz)
+{
+    return AppendBlock(lpsz.GetPtr(), lpsz.GetLength());
+}
+CFX_FileBufferArchive::CFX_FileBufferArchive(FX_STRSIZE size)
+    : IFX_BufferArchive(size)
+    , m_pFile(NULL)
+    , m_bTakeover(FALSE)
+{
+}
+CFX_FileBufferArchive::~CFX_FileBufferArchive()
+{
+    Clear();
+}
+void CFX_FileBufferArchive::Clear()
+{
+    if (m_pFile && m_bTakeover) {
+        m_pFile->Release();
+    }
+    m_pFile = NULL;
+    m_bTakeover = FALSE;
+    IFX_BufferArchive::Clear();
+}
+FX_BOOL CFX_FileBufferArchive::AttachFile(IFX_StreamWrite *pFile, FX_BOOL bTakeover )
+{
+    if (!pFile) {
+        return FALSE;
+    }
+    if (m_pFile && m_bTakeover) {
+        m_pFile->Release();
+    }
+    m_pFile = pFile;
+    m_bTakeover = bTakeover;
+    return TRUE;
+}
+FX_BOOL CFX_FileBufferArchive::AttachFile(const FX_WCHAR* filename)
+{
+    if (!filename) {
+        return FALSE;
+    }
+    if (m_pFile && m_bTakeover) {
+        m_pFile->Release();
+    }
+    m_pFile = FX_CreateFileWrite(filename);
+    if (!m_pFile) {
+        return FALSE;
+    }
+    m_bTakeover = TRUE;
+    return TRUE;
+}
+FX_BOOL CFX_FileBufferArchive::AttachFile(const FX_CHAR* filename)
+{
+    if (!filename) {
+        return FALSE;
+    }
+    if (m_pFile && m_bTakeover) {
+        m_pFile->Release();
+    }
+    m_pFile = FX_CreateFileWrite(filename);
+    if (!m_pFile) {
+        return FALSE;
+    }
+    m_bTakeover = TRUE;
+    return TRUE;
+}
+FX_BOOL CFX_FileBufferArchive::DoWork(const void* pBuf, size_t size)
+{
+    if (!m_pFile) {
+        return FALSE;
+    }
+    if (!pBuf || size < 1) {
+        return TRUE;
+    }
+    return m_pFile->WriteBlock(pBuf, size);
+}