Merge to XFA: Use stdint.h types throughout PDFium.

core/src/fxcrt/fx_basic_maps.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_ext.h"
 #include "plex.h"
 static void ConstructElement(CFX_ByteString* pNewData)
 {
@@ skipping 24 matching lines @@
     m_pBlocks->FreeDataChain();
     m_pBlocks = NULL;
 }
 CFX_MapPtrToPtr::~CFX_MapPtrToPtr()
 {
     RemoveAll();
     ASSERT(m_nCount == 0);
 }
 FX_DWORD CFX_MapPtrToPtr::HashKey(void* key) const
 {
-    return ((FX_DWORD)(FX_UINTPTR)key) >> 4;
+    return ((FX_DWORD)(uintptr_t)key) >> 4;
 }
 void CFX_MapPtrToPtr::GetNextAssoc(FX_POSITION& rNextPosition, void*& rKey, void*& rValue) const
 {
     ASSERT(m_pHashTable != NULL);
     CAssoc* pAssocRet = (CAssoc*)rNextPosition;
     ASSERT(pAssocRet != NULL);
     if (pAssocRet == (CAssoc*) - 1) {
         for (FX_DWORD nBucket = 0; nBucket < m_nHashTableSize; nBucket++)
             if ((pAssocRet = m_pHashTable[nBucket]) != NULL) {
                 break;
@@ skipping 314 matching lines @@
         if (pAssoc->key == key) {
             *ppAssocPrev = pAssoc->pNext;
             FreeAssoc(pAssoc);
             return TRUE;
         }
         ppAssocPrev = &pAssoc->pNext;
     }
     return FALSE;
 }
 struct _CompactString {
-    FX_BYTE             m_CompactLen;
-    FX_BYTE             m_LenHigh;
-    FX_BYTE             m_LenLow;
-    FX_BYTE             m_Unused;
+    uint8_t             m_CompactLen;
+    uint8_t             m_LenHigh;
+    uint8_t             m_LenLow;
+    uint8_t             m_Unused;
     FX_LPBYTE   m_pBuffer;
 };
 static void _CompactStringRelease(_CompactString* pCompact)
 {
     if (pCompact->m_CompactLen == 0xff) {
         FX_Free(pCompact->m_pBuffer);
     }
 }
 static FX_BOOL _CompactStringSame(_CompactString* pCompact, FX_LPCBYTE pStr, int len)
 {
     if (len < sizeof(_CompactString)) {
         if (pCompact->m_CompactLen != len) {
             return FALSE;
         }
         return FXSYS_memcmp32(&pCompact->m_LenHigh, pStr, len) == 0;
     }
     if (pCompact->m_CompactLen != 0xff || pCompact->m_LenHigh * 256 + pCompact->m_LenLow != len) {
         return FALSE;
     }
     return FXSYS_memcmp32(pCompact->m_pBuffer, pStr, len) == 0;
 }
 static void _CompactStringStore(_CompactString* pCompact, FX_LPCBYTE pStr, int len)
 {
     if (len < (int)sizeof(_CompactString)) {
-        pCompact->m_CompactLen = (FX_BYTE)len;
+        pCompact->m_CompactLen = (uint8_t)len;
         FXSYS_memcpy32(&pCompact->m_LenHigh, pStr, len);
         return;
     }
     pCompact->m_CompactLen = 0xff;
     pCompact->m_LenHigh = len / 256;
     pCompact->m_LenLow = len % 256;
-    pCompact->m_pBuffer = FX_Alloc(FX_BYTE, len);
+    pCompact->m_pBuffer = FX_Alloc(uint8_t, len);
     FXSYS_memcpy32(pCompact->m_pBuffer, pStr, len);
 }
 static CFX_ByteStringC _CompactStringGet(_CompactString* pCompact)
 {
     if (pCompact->m_CompactLen == 0xff) {
         return CFX_ByteStringC(pCompact->m_pBuffer, pCompact->m_LenHigh * 256 + pCompact->m_LenLow);
     }
     if (pCompact->m_CompactLen == 0xfe) {
         return CFX_ByteStringC();
     }
@@ skipping 16 matching lines @@
         _CompactStringRelease((_CompactString*)m_Buffer.GetAt(i));
     }
     m_Buffer.RemoveAll();
 }
 FX_POSITION CFX_CMapByteStringToPtr::GetStartPosition() const
 {
     int size = m_Buffer.GetSize();
     for (int i = 0; i < size; i ++) {
         _CompactString* pKey = (_CompactString*)m_Buffer.GetAt(i);
         if (pKey->m_CompactLen != 0xfe) {
-            return (FX_POSITION)(FX_UINTPTR)(i + 1);
+            return (FX_POSITION)(uintptr_t)(i + 1);
         }
     }
     return NULL;
 }
 void CFX_CMapByteStringToPtr::GetNextAssoc(FX_POSITION& rNextPosition, CFX_ByteString& rKey, void*& rValue) const
 {
     if (rNextPosition == NULL) {
         return;
     }
-    int index = (int)(FX_UINTPTR)rNextPosition - 1;
+    int index = (int)(uintptr_t)rNextPosition - 1;
     _CompactString* pKey = (_CompactString*)m_Buffer.GetAt(index);
     rKey = _CompactStringGet(pKey);
     rValue = *(void**)(pKey + 1);
     index ++;
     int size = m_Buffer.GetSize();
     while (index < size) {
         pKey = (_CompactString*)m_Buffer.GetAt(index);
         if (pKey->m_CompactLen != 0xfe) {
-            rNextPosition = (FX_POSITION)(FX_UINTPTR)(index + 1);
+            rNextPosition = (FX_POSITION)(uintptr_t)(index + 1);
             return;
         }
         index ++;
     }
     rNextPosition = NULL;
 }
 FX_LPVOID CFX_CMapByteStringToPtr::GetNextValue(FX_POSITION& rNextPosition) const
 {
     if (rNextPosition == NULL) {
         return NULL;
     }
-    int index = (int)(FX_UINTPTR)rNextPosition - 1;
+    int index = (int)(uintptr_t)rNextPosition - 1;
     _CompactString* pKey = (_CompactString*)m_Buffer.GetAt(index);
     FX_LPVOID rValue = *(void**)(pKey + 1);
     index ++;
     int size = m_Buffer.GetSize();
     while (index < size) {
         pKey = (_CompactString*)m_Buffer.GetAt(index);
         if (pKey->m_CompactLen != 0xfe) {
-            rNextPosition = (FX_POSITION)(FX_UINTPTR)(index + 1);
+            rNextPosition = (FX_POSITION)(uintptr_t)(index + 1);
             return rValue;
         }
         index ++;
     }
     rNextPosition = NULL;
     return rValue;
 }
 FX_BOOL _CMapLookupCallback(void* param, void* pData)
 {
     return !_CompactStringSame((_CompactString*)pData, ((CFX_ByteStringC*)param)->GetPtr(), ((CFX_ByteStringC*)param)->GetLength());
@@ skipping 92 matching lines @@
     if (count == 0) {
         return NULL;
     }
     return (FX_POSITION)1;
 }
 void CFX_CMapDWordToDWord::GetNextAssoc(FX_POSITION& pos, FX_DWORD& key, FX_DWORD& value) const
 {
     if (pos == 0) {
         return;
     }
-    FX_DWORD index = ((FX_DWORD)(FX_UINTPTR)pos) - 1;
+    FX_DWORD index = ((FX_DWORD)(uintptr_t)pos) - 1;
     FX_DWORD count = m_Buffer.GetSize() / sizeof(_DWordPair);
     _DWordPair* buf = (_DWordPair*)m_Buffer.GetBuffer();
     key = buf[index].key;
     value = buf[index].value;
     if (index == count - 1) {
         pos = 0;
     } else {
-        pos = (FX_POSITION)((FX_UINTPTR)pos + 1);
+        pos = (FX_POSITION)((uintptr_t)pos + 1);
     }
 }
 void CFX_CMapDWordToDWord::SetAt(FX_DWORD key, FX_DWORD value)
 {
     FX_DWORD count = m_Buffer.GetSize() / sizeof(_DWordPair);
     _DWordPair* buf = (_DWordPair*)m_Buffer.GetBuffer();
     _DWordPair pair = {key, value};
     if (count == 0 || key > buf[count - 1].key) {
         m_Buffer.AppendBlock(&pair, sizeof(_DWordPair));
         return;
     }
     int low = 0, high = count - 1;
     while (low <= high) {
         int mid = (low + high) / 2;
         if (buf[mid].key < key) {
             low = mid + 1;
         } else if (buf[mid].key > key) {
             high = mid - 1;
         } else {
             buf[mid].value = value;
             return;
         }
     }
     m_Buffer.InsertBlock(low * sizeof(_DWordPair), &pair, sizeof(_DWordPair));
 }
 void CFX_CMapDWordToDWord::EstimateSize(FX_DWORD size, FX_DWORD grow_by)
 {
     m_Buffer.EstimateSize(size, grow_by);
 }