Remove typdefs for pointer types in fx_system.h

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 33 matching lines @@
     switch (m_Type) {
         case PDFOBJ_BOOLEAN:
             return ((CPDF_Boolean*)this)->m_bValue ? "true" : "false";
         case PDFOBJ_NUMBER:
             return ((CPDF_Number*)this)->GetString();
         case PDFOBJ_STRING:
             return ((CPDF_String*)this)->m_String;
         case PDFOBJ_NAME:
             return ((CPDF_Name*)this)->m_Name;
         case PDFOBJ_REFERENCE: {
-                CPDF_Reference* pRef = (CPDF_Reference*)(FX_LPVOID)this;
+                CPDF_Reference* pRef = (CPDF_Reference*)(void*)this;
                 if (pRef->m_pObjList == NULL) {
                     break;
                 }
                 CPDF_Object* pObj = pRef->m_pObjList->GetIndirectObject(pRef->m_RefObjNum);
                 if (pObj == NULL) {
                     return CFX_ByteString();
                 }
                 return pObj->GetString();
             }
     }
     return CFX_ByteString();
 }
 CFX_ByteStringC CPDF_Object::GetConstString() const
 {
     switch (m_Type) {
         case PDFOBJ_STRING:
-            return CFX_ByteStringC((FX_LPCBYTE)((CPDF_String*)this)->m_String, ((CPDF_String*)this)->m_String.GetLength());
+            return CFX_ByteStringC((const uint8_t*)((CPDF_String*)this)->m_String, ((CPDF_String*)this)->m_String.GetLength());
         case PDFOBJ_NAME:
-            return CFX_ByteStringC((FX_LPCBYTE)((CPDF_Name*)this)->m_Name, ((CPDF_Name*)this)->m_Name.GetLength());
+            return CFX_ByteStringC((const uint8_t*)((CPDF_Name*)this)->m_Name, ((CPDF_Name*)this)->m_Name.GetLength());
         case PDFOBJ_REFERENCE: {
-                CPDF_Reference* pRef = (CPDF_Reference*)(FX_LPVOID)this;
+                CPDF_Reference* pRef = (CPDF_Reference*)(void*)this;
                 if (pRef->m_pObjList == NULL) {
                     break;
                 }
                 CPDF_Object* pObj = pRef->m_pObjList->GetIndirectObject(pRef->m_RefObjNum);
                 if (pObj == NULL) {
                     return CFX_ByteStringC();
                 }
                 return pObj->GetConstString();
             }
     }
     return CFX_ByteStringC();
 }
 FX_FLOAT CPDF_Object::GetNumber() const
 {
     switch (m_Type) {
         case PDFOBJ_NUMBER:
             return ((CPDF_Number*)this)->GetNumber();
         case PDFOBJ_REFERENCE: {
-                CPDF_Reference* pRef = (CPDF_Reference*)(FX_LPVOID)this;
+                CPDF_Reference* pRef = (CPDF_Reference*)(void*)this;
                 if (pRef->m_pObjList == NULL) {
                     break;
                 }
                 CPDF_Object* pObj = pRef->m_pObjList->GetIndirectObject(pRef->m_RefObjNum);
                 if (pObj == NULL) {
                     return 0;
                 }
                 return pObj->GetNumber();
             }
     }
     return 0;
 }
 FX_FLOAT CPDF_Object::GetNumber16() const
 {
     return GetNumber();
 }
 int CPDF_Object::GetInteger() const
 {
     CFX_AutoRestorer<int> restorer(&s_nCurRefDepth);
     if (++s_nCurRefDepth > OBJECT_REF_MAX_DEPTH) {
         return 0;
     }
     switch (m_Type) {
         case PDFOBJ_BOOLEAN:
             return ((CPDF_Boolean*)this)->m_bValue;
         case PDFOBJ_NUMBER:
             return ((CPDF_Number*)this)->GetInteger();
         case PDFOBJ_REFERENCE: {
-                CPDF_Reference* pRef = (CPDF_Reference*)(FX_LPVOID)this;
+                CPDF_Reference* pRef = (CPDF_Reference*)(void*)this;
                 PARSE_CONTEXT context;
                 FXSYS_memset32(&context, 0, sizeof(PARSE_CONTEXT));
                 if (pRef->m_pObjList == NULL) {
                     return 0;
                 }
                 CPDF_Object* pObj = pRef->m_pObjList->GetIndirectObject(pRef->m_RefObjNum, &context);
                 if (pObj == NULL) {
                     return 0;
                 }
                 return pObj->GetInteger();
@@ skipping 92 matching lines @@
         case PDFOBJ_REFERENCE:
             return (((CPDF_Reference*)this)->Identical((CPDF_Reference*)pOther));
     }
     return FALSE;
 }
 CPDF_Object* CPDF_Object::GetDirect() const
 {
     if (m_Type != PDFOBJ_REFERENCE) {
         return (CPDF_Object*)this;
     }
-    CPDF_Reference* pRef = (CPDF_Reference*)(FX_LPVOID)this;
+    CPDF_Reference* pRef = (CPDF_Reference*)(void*)this;
     if (pRef->m_pObjList == NULL) {
         return NULL;
     }
     return pRef->m_pObjList->GetIndirectObject(pRef->m_RefObjNum);
 }
 CPDF_Object* CPDF_Object::Clone(FX_BOOL bDirect) const
 {
     CFX_MapPtrToPtr visited;
     return CloneInternal(bDirect, &visited);
 }
@@ skipping 77 matching lines @@
     } else if (m_Type == PDFOBJ_STREAM) {
         CPDF_StreamAcc stream;
         stream.LoadAllData((CPDF_Stream*)this, FALSE);
         CFX_WideString result = PDF_DecodeText(stream.GetData(), stream.GetSize(), pCharMap);
         return result;
     } else if (m_Type == PDFOBJ_NAME) {
         return PDF_DecodeText(((CPDF_Name*)this)->m_Name, pCharMap);
     }
     return CFX_WideString();
 }
-void CPDF_Object::SetUnicodeText(FX_LPCWSTR pUnicodes, int len)
+void CPDF_Object::SetUnicodeText(const FX_WCHAR* pUnicodes, int len)
 {
     if (m_Type == PDFOBJ_STRING) {
         ((CPDF_String*)this)->m_String = PDF_EncodeText(pUnicodes, len);
     } else if (m_Type == PDFOBJ_STREAM) {
         CFX_ByteString result = PDF_EncodeText(pUnicodes, len);
-        ((CPDF_Stream*)this)->SetData((FX_LPBYTE)result.c_str(), result.GetLength(), FALSE, FALSE);
+        ((CPDF_Stream*)this)->SetData((uint8_t*)result.c_str(), result.GetLength(), FALSE, FALSE);
     }
 }
 
 CPDF_Number::CPDF_Number(int value)
     : CPDF_Object(PDFOBJ_NUMBER), m_bInteger(TRUE), m_Integer(value) {
 }
 
 CPDF_Number::CPDF_Number(FX_FLOAT value)
     : CPDF_Object(PDFOBJ_NUMBER), m_bInteger(FALSE), m_Float(value) {
 }
@@ skipping 212 matching lines @@
     for (int i = 0; i < m_Objects.GetSize(); i ++)
         if (!((CPDF_Object*)m_Objects[i])->IsIdentical((CPDF_Object*)pOther->m_Objects[i])) {
             return FALSE;
         }
     return TRUE;
 }
 CPDF_Dictionary::~CPDF_Dictionary()
 {
     FX_POSITION pos = m_Map.GetStartPosition();
     while (pos) {
-        FX_LPVOID value = m_Map.GetNextValue(pos);
+        void* value = m_Map.GetNextValue(pos);
         if (value)
             ((CPDF_Object*)value)->Release();
     }
 }
 FX_POSITION CPDF_Dictionary::GetStartPos() const
 {
     return m_Map.GetStartPosition();
 }
 CPDF_Object* CPDF_Dictionary::GetNextElement(FX_POSITION& pos, CFX_ByteString& key) const
 {
     if (pos == NULL) {
         return NULL;
     }
     CPDF_Object* p;
-    m_Map.GetNextAssoc(pos, key, (FX_LPVOID&)p);
+    m_Map.GetNextAssoc(pos, key, (void*&)p);
     return p;
 }
 CPDF_Object* CPDF_Dictionary::GetElement(FX_BSTR key) const
 {
     CPDF_Object* p = NULL;
     m_Map.Lookup(key, (void*&)p);
     return p;
 }
 CPDF_Object* CPDF_Dictionary::GetElementValue(FX_BSTR key) const
 {
@@ skipping 130 matching lines @@
 {
     CFX_AffineMatrix matrix;
     CPDF_Array* pArray = GetArray(key);
     if (pArray) {
         matrix = pArray->GetMatrix();
     }
     return matrix;
 }
 FX_BOOL CPDF_Dictionary::KeyExist(FX_BSTR key) const
 {
-    FX_LPVOID value;
+    void* value;
     return m_Map.Lookup(key, value);
 }
 void CPDF_Dictionary::SetAt(FX_BSTR key, CPDF_Object* pObj, CPDF_IndirectObjects* pObjs)
 {
     ASSERT(m_Type == PDFOBJ_DICTIONARY);
     CPDF_Object* p = NULL;
     m_Map.Lookup(key, (void*&)p);
     if (p == pObj) {
         return;
     }
@@ skipping 40 matching lines @@
 {
     if (pOther == NULL) {
         return FALSE;
     }
     if (m_Map.GetCount() != pOther->m_Map.GetCount()) {
         return FALSE;
     }
     FX_POSITION pos = m_Map.GetStartPosition();
     while (pos) {
         CFX_ByteString key;
-        FX_LPVOID value;
+        void* value;
         m_Map.GetNextAssoc(pos, key, value);
         if (!value)
             return FALSE;
         if (!((CPDF_Object*)value)->IsIdentical(pOther->GetElement(key))) {
             return FALSE;
         }
     }
     return TRUE;
 }
 void CPDF_Dictionary::SetAtInteger(FX_BSTR key, int i)
@@ skipping 39 matching lines @@
 {
     CPDF_Array* pArray = new CPDF_Array;
     pArray->AddNumber16(matrix.a);
     pArray->AddNumber16(matrix.b);
     pArray->AddNumber16(matrix.c);
     pArray->AddNumber16(matrix.d);
     pArray->AddNumber(matrix.e);
     pArray->AddNumber(matrix.f);
     SetAt(key, pArray);
 }
-CPDF_Stream::CPDF_Stream(FX_LPBYTE pData, FX_DWORD size, CPDF_Dictionary* pDict)
+CPDF_Stream::CPDF_Stream(uint8_t* pData, FX_DWORD size, CPDF_Dictionary* pDict)
     : CPDF_Object(PDFOBJ_STREAM) {
     m_pDict = pDict;
     m_dwSize = size;
     m_GenNum = (FX_DWORD) - 1;
     m_pDataBuf = pData;
     m_pCryptoHandler = NULL;
 }
 CPDF_Stream::~CPDF_Stream()
 {
     if (m_GenNum == (FX_DWORD) - 1 && m_pDataBuf != NULL) {
@@ skipping 14 matching lines @@
     if (m_GenNum == (FX_DWORD) - 1) {
         if (m_pDataBuf) {
             FX_Free(m_pDataBuf);
         }
     }
     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)
+void CPDF_Stream::InitStream(uint8_t* pData, FX_DWORD size, CPDF_Dictionary* pDict)
 {
     InitStream(pDict);
     m_GenNum = (FX_DWORD) - 1;
     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)
+void CPDF_Stream::SetData(const uint8_t* 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;
+        m_pDataBuf = (uint8_t*)pData;
     } else {
         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) {
         m_pDict->RemoveAt(FX_BSTRC("Filter"));
         m_pDict->RemoveAt(FX_BSTRC("DecodeParms"));
     }
 }
-FX_BOOL CPDF_Stream::ReadRawData(FX_FILESIZE offset, FX_LPBYTE buf, FX_DWORD size) const
+FX_BOOL CPDF_Stream::ReadRawData(FX_FILESIZE offset, uint8_t* buf, FX_DWORD size) const
 {
     if ((m_GenNum != (FX_DWORD) - 1) && m_pFile) {
         return m_pFile->ReadBlock(buf, m_FileOffset + offset, size);
     }
     if (m_pDataBuf) {
         FXSYS_memcpy32(buf, m_pDataBuf + offset, size);
     }
     return TRUE;
 }
 void CPDF_Stream::InitStream(IFX_FileRead *pFile, CPDF_Dictionary* pDict)
@@ skipping 39 matching lines @@
                 return FALSE;
             }
             size -= actualSize;
             srcOffset += actualSize;
             destOffset += actualSize;
         }
         return TRUE;
     }
     if (m_GenNum != (FX_DWORD) - 1 || pOther->m_GenNum != (FX_DWORD) - 1) {
         IFX_FileRead* pFile = NULL;
-        FX_LPBYTE pBuf = NULL;
+        uint8_t* pBuf = NULL;
         FX_DWORD offset = 0;
         if (pOther->m_GenNum != (FX_DWORD) - 1) {
             pFile = pOther->m_pFile;
             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;
         }
         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;
         }
         return TRUE;
     }
     return FXSYS_memcmp32(m_pDataBuf, pOther->m_pDataBuf, m_dwSize) == 0;
 }
-CPDF_Stream* CPDF_Stream::Clone(FX_BOOL bDirect, FPDF_LPFCloneStreamCallback lpfCallback, FX_LPVOID pUserData) const
+CPDF_Stream* CPDF_Stream::Clone(FX_BOOL bDirect, FPDF_LPFCloneStreamCallback lpfCallback, void* pUserData) const
 {
     CPDF_Dictionary *pCloneDict = (CPDF_Dictionary*)m_pDict->Clone(bDirect);
     IFX_FileStream *pFS = NULL;
     if (lpfCallback) {
         pFS = lpfCallback((CPDF_Stream*)this, pUserData);
     }
     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(uint8_t, 4096);
+        uint8_t* 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;
     }
     pObj->InitStream((IFX_FileRead*)pFS, pCloneDict);
     return pObj;
 }
-extern FX_BOOL PDF_DataDecode(FX_LPCBYTE src_buf, FX_DWORD src_size, const CPDF_Dictionary* pDict,
-                              FX_LPBYTE& dest_buf, FX_DWORD& dest_size, CFX_ByteString& ImageEncoding,
+extern FX_BOOL PDF_DataDecode(const uint8_t* src_buf, FX_DWORD src_size, const CPDF_Dictionary* pDict,
+                              uint8_t*& dest_buf, FX_DWORD& dest_size, CFX_ByteString& ImageEncoding,
                               CPDF_Dictionary*& pImageParms, FX_DWORD estimated_size, FX_BOOL bImageAcc);
 CPDF_StreamAcc::CPDF_StreamAcc()
 {
     m_bNewBuf = FALSE;
     m_pData = NULL;
     m_dwSize = 0;
     m_pImageParam = NULL;
     m_pStream = NULL;
     m_pSrcData = NULL;
 }
 void CPDF_StreamAcc::LoadAllData(const CPDF_Stream* pStream, FX_BOOL bRawAccess, FX_DWORD estimated_size,
                                  FX_BOOL bImageAcc)
 {
     if (pStream == NULL || pStream->GetType() != PDFOBJ_STREAM) {
         return;
     }
     m_pStream = pStream;
     if (pStream->IsMemoryBased() &&
             (!pStream->GetDict()->KeyExist(FX_BSTRC("Filter")) || bRawAccess)) {
         m_dwSize = pStream->m_dwSize;
-        m_pData = (FX_LPBYTE)pStream->m_pDataBuf;
+        m_pData = (uint8_t*)pStream->m_pDataBuf;
         return;
     }
-    FX_LPBYTE pSrcData;
+    uint8_t* pSrcData;
     FX_DWORD dwSrcSize = pStream->m_dwSize;
     if (dwSrcSize == 0) {
         return;
     }
     if (!pStream->IsMemoryBased()) {
         pSrcData = m_pSrcData = FX_Alloc(uint8_t, dwSrcSize);
         if (!pStream->ReadRawData(0, pSrcData, dwSrcSize)) {
             return;
         }
     } else {
         pSrcData = pStream->m_pDataBuf;
     }
-    FX_LPBYTE pDecryptedData;
+    uint8_t* pDecryptedData;
     FX_DWORD dwDecryptedSize;
     if (pStream->m_pCryptoHandler) {
         CFX_BinaryBuf dest_buf;
         dest_buf.EstimateSize(pStream->m_pCryptoHandler->DecryptGetSize(dwSrcSize));
-        FX_LPVOID context = pStream->m_pCryptoHandler->DecryptStart(pStream->GetObjNum(), pStream->m_GenNum);
+        void* context = pStream->m_pCryptoHandler->DecryptStart(pStream->GetObjNum(), pStream->m_GenNum);
         pStream->m_pCryptoHandler->DecryptStream(context, pSrcData, dwSrcSize, dest_buf);
         pStream->m_pCryptoHandler->DecryptFinish(context, dest_buf);
         pDecryptedData = dest_buf.GetBuffer();
         dwDecryptedSize = dest_buf.GetSize();
         dest_buf.DetachBuffer();
     } else {
         pDecryptedData = pSrcData;
         dwDecryptedSize = dwSrcSize;
     }
     if (!pStream->GetDict()->KeyExist(FX_BSTRC("Filter")) || bRawAccess) {
@@ skipping 18 matching lines @@
 }
 CPDF_StreamAcc::~CPDF_StreamAcc()
 {
     if (m_bNewBuf && m_pData) {
         FX_Free(m_pData);
     }
     if (m_pSrcData) {
         FX_Free(m_pSrcData);
     }
 }
-FX_LPCBYTE CPDF_StreamAcc::GetData() const
+const uint8_t* CPDF_StreamAcc::GetData() const
 {
     if (m_bNewBuf) {
         return m_pData;
     }
     if (!m_pStream) {
         return NULL;
     }
     return m_pStream->m_pDataBuf;
 }
 FX_DWORD CPDF_StreamAcc::GetSize() const
 {
     if (m_bNewBuf) {
         return m_dwSize;
     }
     if (!m_pStream) {
         return 0;
     }
     return m_pStream->m_dwSize;
 }
-FX_LPBYTE CPDF_StreamAcc::DetachData()
+uint8_t* CPDF_StreamAcc::DetachData()
 {
     if (m_bNewBuf) {
-        FX_LPBYTE p = m_pData;
+        uint8_t* p = m_pData;
         m_pData = NULL;
         m_dwSize = 0;
         return p;
     }
-    FX_LPBYTE p = FX_Alloc(uint8_t, m_dwSize);
+    uint8_t* 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)
 {
     m_pParser = pParser;
     m_IndirectObjs.InitHashTable(1013);
     if (pParser) {
         m_LastObjNum = m_pParser->GetLastObjNum();
     } else {
         m_LastObjNum = 0;
     }
 }
 CPDF_IndirectObjects::~CPDF_IndirectObjects()
 {
     FX_POSITION pos = m_IndirectObjs.GetStartPosition();
     while (pos) {
-        FX_LPVOID key, value;
+        void* key;
+        void* value;
         m_IndirectObjs.GetNextAssoc(pos, key, value);
         ((CPDF_Object*)value)->Destroy();
     }
 }
 CPDF_Object* CPDF_IndirectObjects::GetIndirectObject(FX_DWORD objnum, struct PARSE_CONTEXT* pContext)
 {
     if (objnum == 0) {
         return NULL;
     }
-    FX_LPVOID value;
+    void* value;
     {
-        if (m_IndirectObjs.Lookup((FX_LPVOID)(uintptr_t)objnum, value)) {
+        if (m_IndirectObjs.Lookup((void*)(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)(uintptr_t)objnum, value)) {
+    if (m_IndirectObjs.Lookup((void*)(uintptr_t)objnum, value)) {
         if (value) {
             ((CPDF_Object *)value)->Destroy();
         }
     }
-    m_IndirectObjs.SetAt((FX_LPVOID)(uintptr_t)objnum, pObj);
+    m_IndirectObjs.SetAt((void*)(uintptr_t)objnum, pObj);
     return pObj;
 }
 int CPDF_IndirectObjects::GetIndirectType(FX_DWORD objnum)
 {
-    FX_LPVOID value;
-    if (m_IndirectObjs.Lookup((FX_LPVOID)(uintptr_t)objnum, value)) {
+    void* value;
+    if (m_IndirectObjs.Lookup((void*)(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)(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)(uintptr_t)m_LastObjNum, pObj);
+    m_IndirectObjs.SetAt((void*)(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)(uintptr_t)objnum, value)) {
+    void* value;
+    if (!m_IndirectObjs.Lookup((void*)(uintptr_t)objnum, value)) {
         return;
     }
     if (((CPDF_Object*)value)->GetObjNum() == -1) {
         return;
     }
     ((CPDF_Object*)value)->Destroy();
-    m_IndirectObjs.RemoveKey((FX_LPVOID)(uintptr_t)objnum);
+    m_IndirectObjs.RemoveKey((void*)(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)(uintptr_t)objnum, value)) {
+    void* value = NULL;
+    if (m_IndirectObjs.Lookup((void*)(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)(uintptr_t)objnum, pObj);
+    m_IndirectObjs.SetAt((void*)(uintptr_t)objnum, pObj);
     if (m_LastObjNum < objnum) {
         m_LastObjNum = objnum;
     }
 }
 FX_DWORD CPDF_IndirectObjects::GetLastObjNum() const
 {
     return m_LastObjNum;
 }