Use stdint.h types throughout PDFium.

core/include/fxcrt/fx_basic.h

 // 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 CORE_INCLUDE_FXCRT_FX_BASIC_H_
 #define CORE_INCLUDE_FXCRT_FX_BASIC_H_
 
 #include "fx_memory.h"
@@ skipping 23 matching lines @@
     CFX_BinaryBuf(FX_STRSIZE size);
 
     ~CFX_BinaryBuf();
 
     void                                        Clear();
 
     void                                        EstimateSize(FX_STRSIZE size, FX_STRSIZE alloc_step = 0);
 
     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)
     {
         AppendBlock(str.GetPtr(), str.GetLength());
     }
 
-    inline void                         AppendByte(FX_BYTE byte)
+    inline void                         AppendByte(uint8_t byte)
     {
         if (m_AllocSize <= m_DataSize) {
             ExpandBuf(1);
         }
         m_pBuffer[m_DataSize++] = byte;
     }
 
     void                                        InsertBlock(FX_STRSIZE pos, const void* pBuf, FX_STRSIZE size);
 
     void                                        AttachData(void* pBuf, FX_STRSIZE size);
@@ skipping 30 matching lines @@
     void                                        ExpandBuf(FX_STRSIZE size);
 };
 class CFX_ByteTextBuf : public CFX_BinaryBuf
 {
 public:
 
     void                                        operator = (FX_BSTR str);
 
     void                                        AppendChar(int ch)
     {
-        AppendByte((FX_BYTE)ch);
+        AppendByte((uint8_t)ch);
     }
 
     CFX_ByteTextBuf&            operator << (int i);
 
     CFX_ByteTextBuf&            operator << (FX_DWORD i);
 
     CFX_ByteTextBuf&            operator << (double f);
 
     CFX_ByteTextBuf&            operator << (FX_BSTR lpsz);
 
@@ skipping 40 matching lines @@
         CFX_BinaryBuf::Delete(start_index * sizeof(FX_WCHAR), count * sizeof(FX_WCHAR));
     }
 
     CFX_WideStringC                     GetWideString() const;
 };
 class CFX_ArchiveSaver 
 {
 public:
     CFX_ArchiveSaver() : m_pStream(NULL) {}
 
-    CFX_ArchiveSaver&           operator << (FX_BYTE i);
+    CFX_ArchiveSaver&           operator << (uint8_t i);
 
     CFX_ArchiveSaver&           operator << (int i);
 
     CFX_ArchiveSaver&           operator << (FX_DWORD i);
 
     CFX_ArchiveSaver&           operator << (FX_FLOAT i);
 
     CFX_ArchiveSaver&           operator << (double i);
 
     CFX_ArchiveSaver&           operator << (FX_BSTR bstr);
 
     CFX_ArchiveSaver&           operator << (FX_LPCWSTR 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()
     {
         return m_SavingBuf.GetBuffer();
     }
 
     void                                        SetStream(IFX_FileStream* pStream)
     {
         m_pStream = pStream;
     }
 protected:
 
     CFX_BinaryBuf                       m_SavingBuf;
 
     IFX_FileStream*                     m_pStream;
 };
 class CFX_ArchiveLoader 
 {
 public:
 
     CFX_ArchiveLoader(FX_LPCBYTE pData, FX_DWORD dwSize);
 
-    CFX_ArchiveLoader&          operator >> (FX_BYTE& i);
+    CFX_ArchiveLoader&          operator >> (uint8_t& i);
 
     CFX_ArchiveLoader&          operator >> (int& i);
 
     CFX_ArchiveLoader&          operator >> (FX_DWORD& i);
 
     CFX_ArchiveLoader&          operator >> (FX_FLOAT& i);
 
     CFX_ArchiveLoader&          operator >> (double& i);
 
     CFX_ArchiveLoader&          operator >> (CFX_ByteString& bstr);
@@ skipping 16 matching lines @@
 public:
     IFX_BufferArchive(FX_STRSIZE size);
     virtual ~IFX_BufferArchive() { }
 
     virtual void                        Clear();
 
 
     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(FX_BSTR lpsz);
 
 protected:
 
     virtual     FX_BOOL                 DoWork(const void* pBuf, size_t size) = 0;
 
     FX_STRSIZE                          m_BufSize;
 
     FX_LPBYTE                           m_pBuffer;
 
     FX_STRSIZE                          m_Length;
@@ skipping 13 matching lines @@
 private:
 
     virtual FX_BOOL                     DoWork(const void* pBuf, size_t size);
 
     IFX_StreamWrite                     *m_pFile;
 
     FX_BOOL                                     m_bTakeover;
 };
 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()
     {
         m_PendingBytes = 0;
     }
 
     void                        Clear();
 
-    void                        Input(FX_BYTE byte);
+    void                        Input(uint8_t byte);
 
     void                        AppendChar(FX_DWORD ch);
 
     void                        ClearStatus()
     {
         m_PendingBytes = 0;
     }
 
     CFX_WideStringC     GetResult() const
     {
@@ skipping 219 matching lines @@
         if (iStart < 0) {
             return -1;
         }
         for (; iStart < (int)m_nSize; iStart ++)
             if (((TYPE*)m_pData)[iStart] == data) {
                 return iStart;
             }
         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() : CFX_BasicArray(sizeof(ObjectClass)) {}
 
     ~CFX_ObjectArray()
     {
         RemoveAll();
     }
 
     void                        Add(const ObjectClass& data)
     {
         new ((void*)InsertSpaceAt(m_nSize, 1)) ObjectClass(data);
     }
 
     ObjectClass&        Add()
     {
         return *(ObjectClass*) new ((void*)InsertSpaceAt(m_nSize, 1)) ObjectClass();
     }
 
     void*                       AddSpace()
     {
         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;
         }
         FXSYS_assert(nStart > -1 && nStart < nSize);
         if (nCount < 0) {
             nCount = nSize;
         }
         if (nStart + nCount > nSize) {
             nCount = nSize - nStart;
         }
         if (nCount < 1) {
             return 0;
         }
         nSize = m_nSize;
         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;
         }
         FXSYS_assert(nStart > -1 && nStart < nSize);
         if (nCount < 0) {
             nCount = nSize;
         }
         if (nStart + nCount > nSize) {
             nCount = nSize - nStart;
         }
         if (nCount < 1) {
             return 0;
         }
         RemoveAll();
         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;
     }
 
     int                         GetSize() const
     {
         return m_nSize;
     }
 
@@ skipping 57 matching lines @@
         return m_UnitSize;
     }
 
     void*       Iterate(FX_BOOL (*callback)(void* param, void* pData), void* param) const;
 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;
 };
 template <class ElementType>
 class CFX_SegmentedArray : public CFX_BaseSegmentedArray
@@ skipping 132 matching lines @@
 };
 template <class KeyType, class ValueType>
 class CFX_MapPtrTemplate : public CFX_MapPtrToPtr
 {
 public:
     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)) {
+        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
     {
         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:
 
     FX_BOOL                     Lookup(FX_DWORD key, FX_DWORD& value) const;
 
     void                        SetAt(FX_DWORD key, FX_DWORD value);
 
@@ skipping 511 matching lines @@
     T *m_pObj;
 };
 #define FX_DATALIST_LENGTH      1024
 template<size_t unit>
 class CFX_SortListArray 
 {
 protected:
 
     struct DataList {
 
-        FX_INT32        start;
+        int32_t start;
 
-        FX_INT32        count;
+        int32_t count;
         FX_LPBYTE       data;
     };
 public:
 
     CFX_SortListArray() : m_CurList(0) {}
 
     ~CFX_SortListArray()
     {
         Clear();
     }
 
 
     void                        Clear()
     {
-        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_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;
         }
         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_Alloc2D(FX_BYTE, temp_count, unit);
+            list.data = FX_Alloc2D(uint8_t, temp_count, unit);
             list.start = nStart;
             list.count = temp_count;
             Append(list);
             nCount -= temp_count;
             nStart += temp_count;
         }
     }
 
-    FX_LPBYTE           GetAt(FX_INT32 nIndex)
+    FX_LPBYTE           GetAt(int32_t nIndex)
     {
         if (nIndex < 0) {
             return NULL;
         }
         if (m_CurList < 0 || m_CurList >= m_DataLists.GetSize()) {
             return NULL;
         }
         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);
                 if (nIndex < list->start) {
                     iEnd = iMid - 1;
                 } else if (nIndex >= list->start + list->count) {
                     iStart = iMid + 1;
                 } else {
                     pCurList = list;
                     m_CurList = iMid;
                     break;
                 }
             }
         }
         return pCurList ? pCurList->data + (nIndex - pCurList->start) * unit : NULL;
     }
 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;
             } else {
                 if (iMid == iEnd) {
                     iFind = iMid + 1;
                     break;
                 }
                 DataList* next_list = m_DataLists.GetDataPtr(iMid + 1);
                 if (list.start < next_list->start) {
                     iFind = iMid + 1;
                     break;
                 } else {
                     iStart = iMid + 1;
                 }
             }
         }
         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:
 
     void                        Clear()
     {
         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);
         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);
     }
 protected:
     T1                  m_Data;
 };
 typedef CFX_ListArrayTemplate<CFX_SortListArray<sizeof(FX_FILESIZE)>, FX_FILESIZE>      CFX_FileSizeListArray;
 typedef CFX_ListArrayTemplate<CFX_SortListArray<sizeof(FX_DWORD)>, FX_DWORD>            CFX_DWordListArray;
 typedef enum {
     Ready,
@@ skipping 45 matching lines @@
     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_