Use stdint.h types throughout PDFium.

core/src/fpdfapi/fpdf_parser/fpdf_parser_objects.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/fpdfapi/fpdf_parser.h"
 #include "../../../include/fxcrt/fx_string.h"
 
 //static
@@ skipping 277 matching lines @@
                 CPDF_Stream* pObj;
                 if (pThis->GetDict())
                     pObj = new CPDF_Stream(acc.DetachData(), streamSize, (CPDF_Dictionary*)((CPDF_Object*)pThis->GetDict())->CloneInternal(bDirect, visited));
                 else
                     pObj = new CPDF_Stream(acc.DetachData(), streamSize, NULL);
                 return pObj;
             }
         case PDFOBJ_REFERENCE: {
                 CPDF_Reference* pRef = (CPDF_Reference*)this;
                 FX_DWORD obj_num = pRef->m_RefObjNum;
-                if (bDirect && !visited->GetValueAt((void*)(FX_UINTPTR)obj_num)) {
-                    visited->SetAt((void*)(FX_UINTPTR)obj_num, (void*)1);
+                if (bDirect && !visited->GetValueAt((void*)(uintptr_t)obj_num)) {
+                    visited->SetAt((void*)(uintptr_t)obj_num, (void*)1);
                     CPDF_Object* ret;
                     if (pRef->GetDirect())
                         ret = pRef->GetDirect()->CloneInternal(TRUE, visited);
                     else
                         ret = NULL;
                     return ret;
                 } else {
                     return new CPDF_Reference(pRef->m_pObjList, obj_num);
                 }
             }
@@ skipping 579 matching lines @@
     }
     m_GenNum = 0;
     m_pFile = NULL;
     m_pCryptoHandler = NULL;
     m_FileOffset = 0;
 }
 void CPDF_Stream::InitStream(FX_LPBYTE pData, FX_DWORD size, CPDF_Dictionary* pDict)
 {
     InitStream(pDict);
     m_GenNum = (FX_DWORD) - 1;
-    m_pDataBuf = FX_Alloc(FX_BYTE, size);
+    m_pDataBuf = FX_Alloc(uint8_t, size);
     if (pData) {
         FXSYS_memcpy32(m_pDataBuf, pData, size);
     }
     m_dwSize = size;
     if (m_pDict) {
         m_pDict->SetAtInteger(FX_BSTRC("Length"), size);
     }
 }
 void CPDF_Stream::SetData(FX_LPCBYTE pData, FX_DWORD size, FX_BOOL bCompressed, FX_BOOL bKeepBuf)
 {
     if (m_GenNum == (FX_DWORD) - 1) {
         if (m_pDataBuf) {
             FX_Free(m_pDataBuf);
         }
     } else {
         m_GenNum = (FX_DWORD) - 1;
         m_pCryptoHandler = NULL;
     }
     if (bKeepBuf) {
         m_pDataBuf = (FX_LPBYTE)pData;
     } else {
-        m_pDataBuf = FX_Alloc(FX_BYTE, size);
+        m_pDataBuf = FX_Alloc(uint8_t, size);
         if (pData) {
             FXSYS_memcpy32(m_pDataBuf, pData, size);
         }
     }
     m_dwSize = size;
     if (m_pDict == NULL) {
         m_pDict = new CPDF_Dictionary;
     }
     m_pDict->SetAtInteger(FX_BSTRC("Length"), size);
     if (!bCompressed) {
@@ skipping 31 matching lines @@
     if (m_dwSize != pOther->m_dwSize) {
         return FALSE;
     }
     if (m_GenNum != (FX_DWORD) - 1 && pOther->m_GenNum != (FX_DWORD) - 1) {
         if (m_pFile == pOther->m_pFile && m_pFile == NULL) {
             return TRUE;
         }
         if (!m_pFile || !pOther->m_pFile) {
             return FALSE;
         }
-        FX_BYTE srcBuf[1024];
-        FX_BYTE destBuf[1024];
+        uint8_t srcBuf[1024];
+        uint8_t destBuf[1024];
         FX_DWORD size = m_dwSize;
         FX_DWORD srcOffset = m_FileOffset;
         FX_DWORD destOffset = pOther->m_FileOffset;
         if (m_pFile == pOther->m_pFile && srcOffset == destOffset) {
             return TRUE;
         }
         while (size > 0) {
             FX_DWORD actualSize = size > 1024 ? 1024 : size;
             m_pFile->ReadBlock(srcBuf, srcOffset, actualSize);
             pOther->m_pFile->ReadBlock(destBuf, destOffset, actualSize);
@@ skipping 15 matching lines @@
             pBuf = m_pDataBuf;
             offset = pOther->m_FileOffset;
         } else if (m_GenNum != (FX_DWORD) - 1) {
             pFile = m_pFile;
             pBuf = pOther->m_pDataBuf;
             offset = m_FileOffset;
         }
         if (NULL == pBuf) {
             return FALSE;
         }
-        FX_BYTE srcBuf[1024];
+        uint8_t srcBuf[1024];
         FX_DWORD size = m_dwSize;
         while (size > 0) {
             FX_DWORD actualSize = std::min(size, 1024U);
             pFile->ReadBlock(srcBuf, offset, actualSize);
             if (FXSYS_memcmp32(srcBuf, pBuf, actualSize) != 0) {
                 return FALSE;
             }
             pBuf += actualSize;
             size -= actualSize;
             offset += actualSize;
@@ skipping 11 matching lines @@
     }
     if (!pFS) {
         CPDF_StreamAcc acc;
         acc.LoadAllData(this, TRUE);
         FX_DWORD streamSize = acc.GetSize();
         return new CPDF_Stream(acc.DetachData(), streamSize, pCloneDict);
     }
     CPDF_Stream* pObj = new CPDF_Stream(NULL, 0, NULL);
     CPDF_StreamFilter *pSF = GetStreamFilter(TRUE);
     if (pSF) {
-        FX_LPBYTE pBuf = FX_Alloc(FX_BYTE, 4096);
+        FX_LPBYTE pBuf = FX_Alloc(uint8_t, 4096);
         FX_DWORD dwRead;
         do {
             dwRead = pSF->ReadBlock(pBuf, 4096);
             if (dwRead) {
                 pFS->WriteBlock(pBuf, dwRead);
             }
         } while (dwRead == 4096);
         pFS->Flush();
         FX_Free(pBuf);
         delete pSF;
@@ skipping 25 matching lines @@
         m_dwSize = pStream->m_dwSize;
         m_pData = (FX_LPBYTE)pStream->m_pDataBuf;
         return;
     }
     FX_LPBYTE pSrcData;
     FX_DWORD dwSrcSize = pStream->m_dwSize;
     if (dwSrcSize == 0) {
         return;
     }
     if (!pStream->IsMemoryBased()) {
-        pSrcData = m_pSrcData = FX_Alloc(FX_BYTE, dwSrcSize);
+        pSrcData = m_pSrcData = FX_Alloc(uint8_t, dwSrcSize);
         if (!pStream->ReadRawData(0, pSrcData, dwSrcSize)) {
             return;
         }
     } else {
         pSrcData = pStream->m_pDataBuf;
     }
     FX_LPBYTE pDecryptedData;
     FX_DWORD dwDecryptedSize;
     if (pStream->m_pCryptoHandler) {
         CFX_BinaryBuf dest_buf;
@@ skipping 58 matching lines @@
     return m_pStream->m_dwSize;
 }
 FX_LPBYTE CPDF_StreamAcc::DetachData()
 {
     if (m_bNewBuf) {
         FX_LPBYTE p = m_pData;
         m_pData = NULL;
         m_dwSize = 0;
         return p;
     }
-    FX_LPBYTE p = FX_Alloc(FX_BYTE, m_dwSize);
+    FX_LPBYTE p = FX_Alloc(uint8_t, m_dwSize);
     FXSYS_memcpy32(p, m_pData, m_dwSize);
     return p;
 }
 void CPDF_Reference::SetRef(CPDF_IndirectObjects* pDoc, FX_DWORD objnum)
 {
     m_pObjList = pDoc;
     m_RefObjNum = objnum;
 }
 CPDF_IndirectObjects::CPDF_IndirectObjects(CPDF_Parser* pParser)
 {
@@ skipping 14 matching lines @@
         ((CPDF_Object*)value)->Destroy();
     }
 }
 CPDF_Object* CPDF_IndirectObjects::GetIndirectObject(FX_DWORD objnum, struct PARSE_CONTEXT* pContext)
 {
     if (objnum == 0) {
         return NULL;
     }
     FX_LPVOID value;
     {
-        if (m_IndirectObjs.Lookup((FX_LPVOID)(FX_UINTPTR)objnum, value)) {
+        if (m_IndirectObjs.Lookup((FX_LPVOID)(uintptr_t)objnum, value)) {
             if (((CPDF_Object*)value)->GetObjNum() == -1) {
                 return NULL;
             }
             return (CPDF_Object*)value;
         }
     }
     CPDF_Object* pObj = NULL;
     if (m_pParser) {
         pObj = m_pParser->ParseIndirectObject(this, objnum, pContext);
     }
     if (pObj == NULL) {
         return NULL;
     }
     pObj->m_ObjNum = objnum;
     if (m_LastObjNum < objnum) {
         m_LastObjNum = objnum;
     }
-    if (m_IndirectObjs.Lookup((FX_LPVOID)(FX_UINTPTR)objnum, value)) {
+    if (m_IndirectObjs.Lookup((FX_LPVOID)(uintptr_t)objnum, value)) {
         if (value) {
             ((CPDF_Object *)value)->Destroy();
         }
     }
-    m_IndirectObjs.SetAt((FX_LPVOID)(FX_UINTPTR)objnum, pObj);
+    m_IndirectObjs.SetAt((FX_LPVOID)(uintptr_t)objnum, pObj);
     return pObj;
 }
 int CPDF_IndirectObjects::GetIndirectType(FX_DWORD objnum)
 {
     FX_LPVOID value;
-    if (m_IndirectObjs.Lookup((FX_LPVOID)(FX_UINTPTR)objnum, value)) {
+    if (m_IndirectObjs.Lookup((FX_LPVOID)(uintptr_t)objnum, value)) {
         return ((CPDF_Object*)value)->GetType();
     }
     if (m_pParser) {
         PARSE_CONTEXT context;
         FXSYS_memset32(&context, 0, sizeof(PARSE_CONTEXT));
         context.m_Flags = PDFPARSE_TYPEONLY;
-        return (int)(FX_UINTPTR)m_pParser->ParseIndirectObject(this, objnum, &context);
+        return (int)(uintptr_t)m_pParser->ParseIndirectObject(this, objnum, &context);
     }
     return 0;
 }
 FX_DWORD CPDF_IndirectObjects::AddIndirectObject(CPDF_Object* pObj)
 {
     if (pObj->m_ObjNum) {
         return pObj->m_ObjNum;
     }
     m_LastObjNum ++;
-    m_IndirectObjs.SetAt((FX_LPVOID)(FX_UINTPTR)m_LastObjNum, pObj);
+    m_IndirectObjs.SetAt((FX_LPVOID)(uintptr_t)m_LastObjNum, pObj);
     pObj->m_ObjNum = m_LastObjNum;
     return m_LastObjNum;
 }
 void CPDF_IndirectObjects::ReleaseIndirectObject(FX_DWORD objnum)
 {
     FX_LPVOID value;
-    if (!m_IndirectObjs.Lookup((FX_LPVOID)(FX_UINTPTR)objnum, value)) {
+    if (!m_IndirectObjs.Lookup((FX_LPVOID)(uintptr_t)objnum, value)) {
         return;
     }
     if (((CPDF_Object*)value)->GetObjNum() == -1) {
         return;
     }
     ((CPDF_Object*)value)->Destroy();
-    m_IndirectObjs.RemoveKey((FX_LPVOID)(FX_UINTPTR)objnum);
+    m_IndirectObjs.RemoveKey((FX_LPVOID)(uintptr_t)objnum);
 }
 void CPDF_IndirectObjects::InsertIndirectObject(FX_DWORD objnum, CPDF_Object* pObj)
 {
     if (objnum == 0 || pObj == NULL) {
         return;
     }
     FX_LPVOID value = NULL;
-    if (m_IndirectObjs.Lookup((FX_LPVOID)(FX_UINTPTR)objnum, value)) {
+    if (m_IndirectObjs.Lookup((FX_LPVOID)(uintptr_t)objnum, value)) {
         if (value)
         {
             if (pObj->GetGenNum() <= ((CPDF_Object*)value)->GetGenNum())
                 return;
             else
                 ((CPDF_Object*)value)->Destroy();
          }
     }
     pObj->m_ObjNum = objnum;
-    m_IndirectObjs.SetAt((FX_LPVOID)(FX_UINTPTR)objnum, pObj);
+    m_IndirectObjs.SetAt((FX_LPVOID)(uintptr_t)objnum, pObj);
     if (m_LastObjNum < objnum) {
         m_LastObjNum = objnum;
     }
 }
 FX_DWORD CPDF_IndirectObjects::GetLastObjNum() const
 {
     return m_LastObjNum;
 }