Use stdint.h types throughout PDFium.

core/src/fxcrt/fx_basic_buffer.cpp

 // 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_LPSTR 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(FX_BYTE, 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) {
@@ skipping 45 matching lines @@
         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;
     FX_LPBYTE pNewBuffer = m_pBuffer;
     if (pNewBuffer) {
-        pNewBuffer = FX_Realloc(FX_BYTE, m_pBuffer, new_size);
+        pNewBuffer = FX_Realloc(uint8_t, m_pBuffer, new_size);
     } else {
-        pNewBuffer = FX_Alloc(FX_BYTE, new_size);
+        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;
     }
@@ skipping 19 matching lines @@
     ExpandBuf(size);
     if (!m_pBuffer) {
         return;
     }
     FXSYS_memmove32(m_pBuffer + pos + size, m_pBuffer + pos, m_DataSize - pos);
     if (pBuf) {
         FXSYS_memcpy32(m_pBuffer + pos, pBuf, size);
     }
     m_DataSize += size;
 }
-void CFX_BinaryBuf::AppendFill(FX_BYTE byte, FX_STRSIZE count)
+void CFX_BinaryBuf::AppendFill(uint8_t byte, FX_STRSIZE count)
 {
     ExpandBuf(count);
     if (!m_pBuffer) {
         return;
     }
     FXSYS_memset8(m_pBuffer + m_DataSize, byte, count);
     m_DataSize += count;
 }
 CFX_ByteStringC CFX_BinaryBuf::GetByteString() const
 {
@@ skipping 95 matching lines @@
     return *this;
 }
 void CFX_WideTextBuf::operator =(FX_WSTR str)
 {
     CopyData(str.GetPtr(), str.GetLength() * sizeof(FX_WCHAR));
 }
 CFX_WideStringC CFX_WideTextBuf::GetWideString() const
 {
     return CFX_WideStringC((FX_LPCWSTR)m_pBuffer, m_DataSize / sizeof(FX_WCHAR));
 }
-CFX_ArchiveSaver& CFX_ArchiveSaver::operator << (FX_BYTE i)
+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)
 {
@@ skipping 62 matching lines @@
 CFX_ArchiveLoader::CFX_ArchiveLoader(FX_LPCBYTE 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 >> (FX_BYTE& i)
+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));
@@ skipping 101 matching lines @@
         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;
 }
-FX_INT32 IFX_BufferArchive::AppendBlock(const void* pBuf, size_t size)
+int32_t IFX_BufferArchive::AppendBlock(const void* pBuf, size_t size)
 {
     if (!pBuf || size < 1) {
         return 0;
     }
     if (!m_pBuffer) {
-        m_pBuffer = FX_Alloc(FX_BYTE, m_BufSize);
+        m_pBuffer = FX_Alloc(uint8_t, m_BufSize);
     }
     FX_LPBYTE buffer = (FX_LPBYTE)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_memcpy32(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 (FX_INT32)size;
+    return (int32_t)size;
 }
-FX_INT32 IFX_BufferArchive::AppendByte(FX_BYTE byte)
+int32_t IFX_BufferArchive::AppendByte(uint8_t byte)
 {
     return AppendBlock(&byte, 1);
 }
-FX_INT32 IFX_BufferArchive::AppendDWord(FX_DWORD i)
+int32_t IFX_BufferArchive::AppendDWord(FX_DWORD i)
 {
     char buf[32];
     FXSYS_itoa(i, buf, 10);
     return AppendBlock(buf, (size_t)FXSYS_strlen(buf));
 }
-FX_INT32 IFX_BufferArchive::AppendString(FX_BSTR lpsz)
+int32_t IFX_BufferArchive::AppendString(FX_BSTR 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()
@@ skipping 54 matching lines @@
 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);
 }