Remove typdefs for pointer types in fx_system.h

core/src/fpdfapi/fpdf_parser/fpdf_parser_parser.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 <utility>
 #include <vector>
 
 #include "../../../include/fpdfapi/fpdf_module.h"
@@ skipping 66 matching lines @@
         m_pTrailer = NULL;
     }
     ReleaseEncryptHandler();
     SetEncryptDictionary(NULL);
     if (m_bOwnFileRead && m_Syntax.m_pFileAccess) {
         m_Syntax.m_pFileAccess->Release();
         m_Syntax.m_pFileAccess = NULL;
     }
     FX_POSITION pos = m_ObjectStreamMap.GetStartPosition();
     while (pos) {
-        FX_LPVOID objnum;
+        void* objnum;
         CPDF_StreamAcc* pStream;
         m_ObjectStreamMap.GetNextAssoc(pos, objnum, (void*&)pStream);
         delete pStream;
     }
     m_ObjectStreamMap.RemoveAll();
     m_SortedOffset.RemoveAll();
     m_CrossRef.RemoveAll();
     m_V5Type.RemoveAll();
     m_ObjVersion.RemoveAll();
     int32_t iLen = m_Trailers.GetSize();
@@ skipping 19 matching lines @@
         if (*(FX_DWORD*)buf == tag) {
             return offset;
         }
         offset ++;
         if (offset > 1024) {
             return -1;
         }
     }
     return -1;
 }
-FX_DWORD CPDF_Parser::StartParse(FX_LPCSTR filename, FX_BOOL bReParse)
+FX_DWORD CPDF_Parser::StartParse(const FX_CHAR* filename, FX_BOOL bReParse)
 {
     IFX_FileRead* pFileAccess = FX_CreateFileRead(filename);
     if (!pFileAccess) {
         return PDFPARSE_ERROR_FILE;
     }
     return StartParse(pFileAccess, bReParse);
 }
-FX_DWORD CPDF_Parser::StartParse(FX_LPCWSTR filename, FX_BOOL bReParse)
+FX_DWORD CPDF_Parser::StartParse(const FX_WCHAR* filename, FX_BOOL bReParse)
 {
     IFX_FileRead* pFileAccess = FX_CreateFileRead(filename);
     if (!pFileAccess) {
         return PDFPARSE_ERROR_FILE;
     }
     return StartParse(pFileAccess, bReParse);
 }
 CPDF_SecurityHandler* FPDF_CreateStandardSecurityHandler();
 CPDF_SecurityHandler* FPDF_CreatePubKeyHandler(void*);
 FX_DWORD CPDF_Parser::StartParse(IFX_FileRead* pFileAccess, FX_BOOL bReParse, FX_BOOL bOwnFileRead)
@@ skipping 26 matching lines @@
     if (m_Syntax.m_FileLen <  m_Syntax.m_HeaderOffset + 9) {
         return PDFPARSE_ERROR_FORMAT;
     }
     m_Syntax.RestorePos(m_Syntax.m_FileLen - m_Syntax.m_HeaderOffset - 9);
     if (!bReParse) {
         m_pDocument = new CPDF_Document(this);
     }
     FX_BOOL bXRefRebuilt = FALSE;
     if (m_Syntax.SearchWord(FX_BSTRC("startxref"), TRUE, FALSE, 4096)) {
         FX_FILESIZE startxref_offset = m_Syntax.SavePos();
-        FX_LPVOID pResult = FXSYS_bsearch(&startxref_offset, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
+        void* pResult = FXSYS_bsearch(&startxref_offset, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
         if (pResult == NULL) {
             m_SortedOffset.Add(startxref_offset);
         }
         m_Syntax.GetKeyword();
         FX_BOOL bNumber;
         CFX_ByteString xrefpos_str = m_Syntax.GetNextWord(bNumber);
         if (!bNumber) {
             return PDFPARSE_ERROR_FORMAT;
         }
         m_LastXRefOffset = (FX_FILESIZE)FXSYS_atoi64(xrefpos_str);
@@ skipping 240 matching lines @@
     for (int32_t i = 1; i < CrossRefList.GetSize(); i ++)
         if (!LoadCrossRefV4(CrossRefList[i], XRefStreamList[i], FALSE, i == 0)) {
             return FALSE;
         }
     return TRUE;
 }
 FX_BOOL CPDF_Parser::LoadLinearizedCrossRefV4(FX_FILESIZE pos, FX_DWORD dwObjCount)
 {
     FX_FILESIZE dwStartPos = pos - m_Syntax.m_HeaderOffset;
     m_Syntax.RestorePos(dwStartPos);
-    FX_LPVOID pResult = FXSYS_bsearch(&pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
+    void* pResult = FXSYS_bsearch(&pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
     if (pResult == NULL) {
         m_SortedOffset.Add(pos);
     }
     FX_DWORD start_objnum = 0;
     FX_DWORD count = dwObjCount;
     FX_FILESIZE SavedPos = m_Syntax.SavePos();
     int32_t recordsize = 20;
     char* pBuf = FX_Alloc(char, 1024 * recordsize + 1);
     pBuf[1024 * recordsize] = '\0';
     int32_t nBlocks = count / 1024 + 1;
     for (int32_t block = 0; block < nBlocks; block ++) {
         int32_t block_size = block == nBlocks - 1 ? count % 1024 : 1024;
         FX_DWORD dwReadSize = block_size * recordsize;
         if ((FX_FILESIZE)(dwStartPos + dwReadSize) > m_Syntax.m_FileLen) {
             FX_Free(pBuf);
             return FALSE;
         }
-        if (!m_Syntax.ReadBlock((FX_LPBYTE)pBuf, dwReadSize)) {
+        if (!m_Syntax.ReadBlock((uint8_t*)pBuf, dwReadSize)) {
             FX_Free(pBuf);
             return FALSE;
         }
         for (int32_t i = 0; i < block_size; i ++) {
             FX_DWORD objnum = start_objnum + block * 1024 + i;
             char* pEntry = pBuf + i * recordsize;
             if (pEntry[17] == 'f') {
                 m_CrossRef.SetAtGrow(objnum, 0);
                 m_V5Type.SetAtGrow(objnum, 0);
             } else {
                 int32_t offset = FXSYS_atoi(pEntry);
                 if (offset == 0) {
                     for (int32_t c = 0; c < 10; c ++) {
                         if (pEntry[c] < '0' || pEntry[c] > '9') {
                             FX_Free(pBuf);
                             return FALSE;
                         }
                     }
                 }
                 m_CrossRef.SetAtGrow(objnum, offset);
                 int32_t version = FXSYS_atoi(pEntry + 11);
                 if (version >= 1) {
                     m_bVersionUpdated = TRUE;
                 }
                 m_ObjVersion.SetAtGrow(objnum, version);
                 if (m_CrossRef[objnum] < m_Syntax.m_FileLen) {
-                    FX_LPVOID pResult = FXSYS_bsearch(&m_CrossRef[objnum], m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
+                    void* pResult = FXSYS_bsearch(&m_CrossRef[objnum], m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
                     if (pResult == NULL) {
                         m_SortedOffset.Add(m_CrossRef[objnum]);
                     }
                 }
                 m_V5Type.SetAtGrow(objnum, 1);
             }
         }
     }
     FX_Free(pBuf);
     m_Syntax.RestorePos(SavedPos + count * recordsize);
     return TRUE;
 }
 FX_BOOL CPDF_Parser::LoadCrossRefV4(FX_FILESIZE pos, FX_FILESIZE streampos, FX_BOOL bSkip, FX_BOOL bFirst)
 {
     m_Syntax.RestorePos(pos);
     if (m_Syntax.GetKeyword() != FX_BSTRC("xref")) {
         return FALSE;
     }
-    FX_LPVOID pResult = FXSYS_bsearch(&pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
+    void* pResult = FXSYS_bsearch(&pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
     if (pResult == NULL) {
         m_SortedOffset.Add(pos);
     }
     if (streampos) {
-        FX_LPVOID pResult = FXSYS_bsearch(&streampos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
+        void* pResult = FXSYS_bsearch(&streampos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
         if (pResult == NULL) {
             m_SortedOffset.Add(streampos);
         }
     }
     while (1) {
         FX_FILESIZE SavedPos = m_Syntax.SavePos();
         FX_BOOL bIsNumber;
         CFX_ByteString word = m_Syntax.GetNextWord(bIsNumber);
         if (word.IsEmpty()) {
             return FALSE;
@@ skipping 15 matching lines @@
             bFirstItem = TRUE;
         }
         m_dwXrefStartObjNum = start_objnum;
         if (!bSkip) {
             char* pBuf = FX_Alloc(char, 1024 * recordsize + 1);
             pBuf[1024 * recordsize] = '\0';
             int32_t nBlocks = count / 1024 + 1;
             FX_BOOL bFirstBlock = TRUE;
             for (int32_t block = 0; block < nBlocks; block ++) {
                 int32_t block_size = block == nBlocks - 1 ? count % 1024 : 1024;
-                m_Syntax.ReadBlock((FX_LPBYTE)pBuf, block_size * recordsize);
+                m_Syntax.ReadBlock((uint8_t*)pBuf, block_size * recordsize);
                 for (int32_t i = 0; i < block_size; i ++) {
                     FX_DWORD objnum = start_objnum + block * 1024 + i;
                     char* pEntry = pBuf + i * recordsize;
                     if (pEntry[17] == 'f') {
                         if (bFirstItem) {
                             objnum = 0;
                             bFirstItem = FALSE;
                         }
                         if (bFirstBlock) {
                             FX_FILESIZE offset = (FX_FILESIZE)FXSYS_atoi64(pEntry);
@@ skipping 15 matching lines @@
                                 }
                             }
                         }
                         m_CrossRef.SetAtGrow(objnum, offset);
                         int32_t version = FXSYS_atoi(pEntry + 11);
                         if (version >= 1) {
                             m_bVersionUpdated = TRUE;
                         }
                         m_ObjVersion.SetAtGrow(objnum, version);
                         if (m_CrossRef[objnum] < m_Syntax.m_FileLen) {
-                            FX_LPVOID pResult = FXSYS_bsearch(&m_CrossRef[objnum], m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
+                            void* pResult = FXSYS_bsearch(&m_CrossRef[objnum], m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
                             if (pResult == NULL) {
                                 m_SortedOffset.Add(m_CrossRef[objnum]);
                             }
                         }
                         m_V5Type.SetAtGrow(objnum, 1);
                     }
                     if (bFirstBlock) {
                         bFirstBlock = FALSE;
                     }
                 }
@@ skipping 28 matching lines @@
     m_SortedOffset.RemoveAll();
     m_ObjVersion.RemoveAll();
     if (m_pTrailer) {
         m_pTrailer->Release();
         m_pTrailer = NULL;
     }
     int32_t status = 0;
     int32_t inside_index = 0;
     FX_DWORD objnum = 0, gennum = 0;
     int32_t depth = 0;
-    FX_LPBYTE buffer = FX_Alloc(uint8_t, 4096);
+    uint8_t* buffer = FX_Alloc(uint8_t, 4096);
     FX_FILESIZE pos = m_Syntax.m_HeaderOffset;
     FX_FILESIZE start_pos = 0, start_pos1 = 0;
     FX_FILESIZE last_obj = -1, last_xref = -1, last_trailer = -1;
     while (pos < m_Syntax.m_FileLen) {
         FX_BOOL bOverFlow = FALSE;
         FX_DWORD size = (FX_DWORD)(m_Syntax.m_FileLen - pos);
         if (size > 4096) {
             size = 4096;
         }
         if (!m_Syntax.m_pFileAccess->ReadBlock(buffer, pos, size)) {
@@ skipping 125 matching lines @@
                             }
                             break;
                         case 3:
                             if (PDF_CharType[byte] == 'W' || PDF_CharType[byte] == 'D') {
                                 if (objnum > 0x1000000) {
                                     status = 0;
                                     break;
                                 }
                                 FX_FILESIZE obj_pos = start_pos - m_Syntax.m_HeaderOffset;
                                 last_obj = start_pos;
-                                FX_LPVOID pResult = FXSYS_bsearch(&obj_pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
+                                void* pResult = FXSYS_bsearch(&obj_pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
                                 if (pResult == NULL) {
                                     m_SortedOffset.Add(obj_pos);
                                 }
                                 FX_FILESIZE obj_end = 0;
                                 CPDF_Object *pObject = ParseIndirectObjectAtByStrict(m_pDocument, obj_pos, objnum, NULL, &obj_end);
                                 if (pObject) {
                                     int iType = pObject->GetType();
                                     if (iType == PDFOBJ_STREAM) {
                                         CPDF_Stream* pStream = (CPDF_Stream*)pObject;
                                         CPDF_Dictionary* pDict = pStream->GetDict();
@@ skipping 182 matching lines @@
             }
         }
         pos += size;
     }
     if (last_xref != -1 && last_xref > last_obj) {
         last_trailer = last_xref;
     } else if (last_trailer == -1 || last_xref < last_obj) {
         last_trailer = m_Syntax.m_FileLen;
     }
     FX_FILESIZE offset = last_trailer - m_Syntax.m_HeaderOffset;
-    FX_LPVOID pResult = FXSYS_bsearch(&offset, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
+    void* pResult = FXSYS_bsearch(&offset, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
     if (pResult == NULL) {
         m_SortedOffset.Add(offset);
     }
     FX_Free(buffer);
     return TRUE;
 }
-static FX_DWORD _GetVarInt(FX_LPCBYTE p, int32_t n)
+static FX_DWORD _GetVarInt(const uint8_t* p, int32_t n)
 {
     FX_DWORD result = 0;
     for (int32_t i = 0; i < n; i ++) {
         result = result * 256 + p[i];
     }
     return result;
 }
 FX_BOOL CPDF_Parser::LoadCrossRefV5(FX_FILESIZE pos, FX_FILESIZE& prev, FX_BOOL bMainXRef)
 {
     CPDF_Stream* pStream = (CPDF_Stream*)ParseIndirectObjectAt(m_pDocument, pos, 0, NULL);
@@ skipping 60 matching lines @@
         WidthArray.Add(pArray->GetInteger(i));
         dwAccWidth += WidthArray[i];
     }
     if (!dwAccWidth.IsValid() || WidthArray.GetSize() < 3) {
         pStream->Release();
         return FALSE;
     }
     FX_DWORD totalWidth = dwAccWidth.ValueOrDie();
     CPDF_StreamAcc acc;
     acc.LoadAllData(pStream);
-    FX_LPCBYTE pData = acc.GetData();
+    const uint8_t* pData = acc.GetData();
     FX_DWORD dwTotalSize = acc.GetSize();
     FX_DWORD segindex = 0;
     for (FX_DWORD i = 0; i < arrIndex.size(); i ++) {
         int32_t startnum = arrIndex[i].first;
         if (startnum < 0) {
             continue;
         }
         m_dwXrefStartObjNum = pdfium::base::checked_cast<FX_DWORD, int32_t> (startnum);
         FX_DWORD count = pdfium::base::checked_cast<FX_DWORD, int32_t> (arrIndex[i].second);
         FX_SAFE_DWORD dwCaculatedSize = segindex;
         dwCaculatedSize += count;
         dwCaculatedSize *= totalWidth;
         if (!dwCaculatedSize.IsValid() || dwCaculatedSize.ValueOrDie() > dwTotalSize) { 
             continue;
         }
-        FX_LPCBYTE segstart = pData + segindex * totalWidth;
+        const uint8_t* segstart = pData + segindex * totalWidth;
         FX_SAFE_DWORD dwMaxObjNum = startnum;
         dwMaxObjNum += count;
         FX_DWORD dwV5Size = pdfium::base::checked_cast<FX_DWORD, int32_t> (m_V5Type.GetSize());
         if (!dwMaxObjNum.IsValid() || dwMaxObjNum.ValueOrDie() > dwV5Size) {
             continue;
         }
         for (FX_DWORD j = 0; j < count; j ++) {
             int32_t type = 1;
-            FX_LPCBYTE entrystart = segstart + j * totalWidth;
+            const uint8_t* entrystart = segstart + j * totalWidth;
             if (WidthArray[0]) {
                 type = _GetVarInt(entrystart, WidthArray[0]);
             }
             if (m_V5Type[startnum + j] == 255) {
                 FX_FILESIZE offset = _GetVarInt(entrystart + WidthArray[0], WidthArray[1]);
                 m_CrossRef[startnum + j] = offset;
-                FX_LPVOID pResult = FXSYS_bsearch(&offset, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
+                void* pResult = FXSYS_bsearch(&offset, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
                 if (pResult == NULL) {
                     m_SortedOffset.Add(offset);
                 }
                 continue;
             }
             if (m_V5Type[startnum + j]) {
                 continue;
             }
             m_V5Type[startnum + j] = type;
             if (type == 0) {
                 m_CrossRef[startnum + j] = 0;
             } else {
                 FX_FILESIZE offset = _GetVarInt(entrystart + WidthArray[0], WidthArray[1]);
                 m_CrossRef[startnum + j] = offset;
                 if (type == 1) {
-                    FX_LPVOID pResult = FXSYS_bsearch(&offset, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
+                    void* pResult = FXSYS_bsearch(&offset, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
                     if (pResult == NULL) {
                         m_SortedOffset.Add(offset);
                     }
                 } else {
                     if (offset < 0 || offset >= m_V5Type.GetSize()) {
                         pStream->Release();
                         return FALSE;
                     }
                     m_V5Type[offset] = 255;
                 }
@@ skipping 41 matching lines @@
     if (objnum >= (FX_DWORD)m_CrossRef.GetSize()) {
         return TRUE;
     }
     if (m_V5Type[objnum] == 0) {
         return TRUE;
     }
     if (m_V5Type[objnum] == 2) {
         return TRUE;
     }
     FX_FILESIZE pos = m_CrossRef[objnum];
-    FX_LPVOID pResult = FXSYS_bsearch(&pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
+    void* pResult = FXSYS_bsearch(&pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
     if (pResult == NULL) {
         return TRUE;
     }
     if ((FX_FILESIZE*)pResult - (FX_FILESIZE*)m_SortedOffset.GetData() == m_SortedOffset.GetSize() - 1) {
         return FALSE;
     }
     FX_FILESIZE size = ((FX_FILESIZE*)pResult)[1] - pos;
     FX_FILESIZE SavedPos = m_Syntax.SavePos();
     m_Syntax.RestorePos(pos);
     bForm = m_Syntax.SearchMultiWord(FX_BSTRC("/Form\0stream"), TRUE, size) == 0;
@@ skipping 13 matching lines @@
         return ParseIndirectObjectAt(pObjList, pos, objnum, pContext);
     }
     if (m_V5Type[objnum] == 2) {
         CPDF_StreamAcc* pObjStream = GetObjectStream((FX_DWORD)m_CrossRef[objnum]);
         if (pObjStream == NULL) {
             return NULL;
         }
         int32_t n = pObjStream->GetDict()->GetInteger(FX_BSTRC("N"));
         int32_t offset = pObjStream->GetDict()->GetInteger(FX_BSTRC("First"));
         CPDF_SyntaxParser syntax;
-        CFX_SmartPointer<IFX_FileStream> file(FX_CreateMemoryStream((FX_LPBYTE)pObjStream->GetData(), (size_t)pObjStream->GetSize(), FALSE));
+        CFX_SmartPointer<IFX_FileStream> file(FX_CreateMemoryStream((uint8_t*)pObjStream->GetData(), (size_t)pObjStream->GetSize(), FALSE));
         syntax.InitParser(file.Get(), 0);
         CPDF_Object* pRet = NULL;
         while (n) {
             FX_DWORD thisnum = syntax.GetDirectNum();
             FX_DWORD thisoff = syntax.GetDirectNum();
             if (thisnum == objnum) {
                 syntax.RestorePos(offset + thisoff);
                 pRet = syntax.GetObject(pObjList, 0, 0, pContext);
                 break;
             }
@@ skipping 24 matching lines @@
         return 0;
     }
     if (m_V5Type[objnum] == 2) {
         objnum = (FX_DWORD)m_CrossRef[objnum];
     }
     if (m_V5Type[objnum] == 1 || m_V5Type[objnum] == 255) {
         FX_FILESIZE offset = m_CrossRef[objnum];
         if (offset == 0) {
             return 0;
         }
-        FX_LPVOID pResult = FXSYS_bsearch(&offset, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
+        void* pResult = FXSYS_bsearch(&offset, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
         if (pResult == NULL) {
             return 0;
         }
         if ((FX_FILESIZE*)pResult - (FX_FILESIZE*)m_SortedOffset.GetData() == m_SortedOffset.GetSize() - 1) {
             return 0;
         }
         return ((FX_FILESIZE*)pResult)[1] - offset;
     }
     return 0;
 }
-void CPDF_Parser::GetIndirectBinary(FX_DWORD objnum, FX_LPBYTE& pBuffer, FX_DWORD& size)
+void CPDF_Parser::GetIndirectBinary(FX_DWORD objnum, uint8_t*& pBuffer, FX_DWORD& size)
 {
     pBuffer = NULL;
     size = 0;
     if (objnum >= (FX_DWORD)m_CrossRef.GetSize()) {
         return;
     }
     if (m_V5Type[objnum] == 2) {
         CPDF_StreamAcc* pObjStream = GetObjectStream((FX_DWORD)m_CrossRef[objnum]);
         if (pObjStream == NULL) {
             return;
         }
         int32_t n = pObjStream->GetDict()->GetInteger(FX_BSTRC("N"));
         int32_t offset = pObjStream->GetDict()->GetInteger(FX_BSTRC("First"));
         CPDF_SyntaxParser syntax;
-        FX_LPCBYTE pData = pObjStream->GetData();
+        const uint8_t* pData = pObjStream->GetData();
         FX_DWORD totalsize = pObjStream->GetSize();
-        CFX_SmartPointer<IFX_FileStream> file(FX_CreateMemoryStream((FX_LPBYTE)pData, (size_t)totalsize, FALSE));
+        CFX_SmartPointer<IFX_FileStream> file(FX_CreateMemoryStream((uint8_t*)pData, (size_t)totalsize, FALSE));
         syntax.InitParser(file.Get(), 0);
         while (n) {
             FX_DWORD thisnum = syntax.GetDirectNum();
             FX_DWORD thisoff = syntax.GetDirectNum();
             if (thisnum == objnum) {
                 if (n == 1) {
                     size = totalsize - (thisoff + offset);
                 } else {
                     syntax.GetDirectNum();  // Skip nextnum.
                     FX_DWORD nextoff = syntax.GetDirectNum();
@@ skipping 27 matching lines @@
         }
         word = m_Syntax.GetNextWord(bIsNumber);
         if (!bIsNumber) {
             m_Syntax.RestorePos(SavedPos);
             return;
         }
         if (m_Syntax.GetKeyword() != FX_BSTRC("obj")) {
             m_Syntax.RestorePos(SavedPos);
             return;
         }
-        FX_LPVOID pResult = FXSYS_bsearch(&pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
+        void* pResult = FXSYS_bsearch(&pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
         if (pResult == NULL) {
             m_Syntax.RestorePos(SavedPos);
             return;
         }
         FX_FILESIZE nextoff = ((FX_FILESIZE*)pResult)[1];
         FX_BOOL bNextOffValid = FALSE;
         if (nextoff != pos) {
             m_Syntax.RestorePos(nextoff);
             word = m_Syntax.GetNextWord(bIsNumber);
             if (word == FX_BSTRC("xref")) {
@@ skipping 309 matching lines @@
         ++dwCount;
         if (m_Syntax.m_FileLen >= (FX_FILESIZE)(m_Syntax.SavePos() + m_Syntax.m_HeaderOffset)) {
             break;
         }
         m_Syntax.GetNextChar(ch);
         type = PDF_CharType[ch];
     }
     m_LastXRefOffset += dwCount;
     FX_POSITION pos = m_ObjectStreamMap.GetStartPosition();
     while (pos) {
-        FX_LPVOID objnum;
+        void* objnum;
         CPDF_StreamAcc* pStream;
         m_ObjectStreamMap.GetNextAssoc(pos, objnum, (void*&)pStream);
         delete pStream;
     }
     m_ObjectStreamMap.RemoveAll();
     if (!LoadLinearizedAllCrossRefV4(m_LastXRefOffset, m_dwXrefStartObjNum) && !LoadLinearizedAllCrossRefV5(m_LastXRefOffset)) {
         m_LastXRefOffset = 0;
         m_Syntax.m_MetadataObjnum = dwSaveMetadataObjnum;
         return PDFPARSE_ERROR_FORMAT;
     }
@@ skipping 82 matching lines @@
             }
         }
         if (!m_pFileAccess->ReadBlock(m_pFileBuf, read_pos, read_size)) {
             return FALSE;
         }
         m_BufOffset = read_pos;
     }
     ch = m_pFileBuf[pos - m_BufOffset];
     return TRUE;
 }
-FX_BOOL CPDF_SyntaxParser::ReadBlock(FX_LPBYTE pBuf, FX_DWORD size)
+FX_BOOL CPDF_SyntaxParser::ReadBlock(uint8_t* pBuf, FX_DWORD size)
 {
     if (!m_pFileAccess->ReadBlock(pBuf, m_Pos + m_HeaderOffset, size)) {
         return FALSE;
     }
     m_Pos += size;
     return TRUE;
 }
 #define MAX_WORD_BUFFER 256
 void CPDF_SyntaxParser::GetNextWord()
 {
@@ skipping 261 matching lines @@
             }
         }
         type = PDF_CharType[ch];
     }
     m_Pos --;
 }
 CFX_ByteString CPDF_SyntaxParser::GetNextWord(FX_BOOL& bIsNumber)
 {
     GetNextWord();
     bIsNumber = m_bIsNumber;
-    return CFX_ByteString((FX_LPCSTR)m_WordBuffer, m_WordSize);
+    return CFX_ByteString((const FX_CHAR*)m_WordBuffer, m_WordSize);
 }
 CFX_ByteString CPDF_SyntaxParser::GetKeyword()
 {
     GetNextWord();
-    return CFX_ByteString((FX_LPCSTR)m_WordBuffer, m_WordSize);
+    return CFX_ByteString((const FX_CHAR*)m_WordBuffer, m_WordSize);
 }
 CPDF_Object* CPDF_SyntaxParser::GetObject(CPDF_IndirectObjects* pObjList, FX_DWORD objnum, FX_DWORD gennum, PARSE_CONTEXT* pContext, FX_BOOL bDecrypt)
 {
     CFX_AutoRestorer<int> restorer(&s_CurrentRecursionDepth);
     if (++s_CurrentRecursionDepth > kParserMaxRecursionDepth) {
         return NULL;
     }
     FX_FILESIZE SavedPos = m_Pos;
     FX_BOOL bTypeOnly = pContext && (pContext->m_Flags & PDFPARSE_TYPEONLY);
     FX_BOOL bIsNumber;
@@ skipping 404 matching lines @@
             } else {
                 m_Pos = StreamStartPos;
                 if (FindTag(FX_BSTRC("endobj"), 0) < 0) {
                     return NULL;
                 }
             }
         }
         m_Pos = StreamStartPos;
     }
     CPDF_Stream* pStream;
-    FX_LPBYTE pData = FX_Alloc(uint8_t, len);
+    uint8_t* pData = FX_Alloc(uint8_t, len);
     ReadBlock(pData, len);
     if (pCryptoHandler) {
         CFX_BinaryBuf dest_buf;
         dest_buf.EstimateSize(pCryptoHandler->DecryptGetSize(len));
-        FX_LPVOID context = pCryptoHandler->DecryptStart(objnum, gennum);
+        void* context = pCryptoHandler->DecryptStart(objnum, gennum);
         pCryptoHandler->DecryptStream(context, pData, len, dest_buf);
         pCryptoHandler->DecryptFinish(context, dest_buf);
         FX_Free(pData);
         pData = dest_buf.GetBuffer();
         len = dest_buf.GetSize();
         dest_buf.DetachBuffer();
     }
     pStream = new CPDF_Stream(pData, len, pDict);
     if (pContext) {
         pContext->m_DataEnd = pContext->m_DataStart + len;
@@ skipping 19 matching lines @@
     m_BufOffset = 0;
     pFileAccess->ReadBlock(m_pFileBuf, 0, (size_t)((FX_FILESIZE)m_BufSize > m_FileLen ? m_FileLen : m_BufSize));
 }
 int32_t CPDF_SyntaxParser::GetDirectNum()
 {
     GetNextWord();
     if (!m_bIsNumber) {
         return 0;
     }
     m_WordBuffer[m_WordSize] = 0;
-    return FXSYS_atoi((FX_LPCSTR)m_WordBuffer);
+    return FXSYS_atoi((const FX_CHAR*)m_WordBuffer);
 }
-FX_BOOL CPDF_SyntaxParser::IsWholeWord(FX_FILESIZE startpos, FX_FILESIZE limit, FX_LPCBYTE tag, FX_DWORD taglen)
+FX_BOOL CPDF_SyntaxParser::IsWholeWord(FX_FILESIZE startpos, FX_FILESIZE limit, const uint8_t* tag, FX_DWORD taglen)
 {
     uint8_t type = PDF_CharType[tag[0]];
     FX_BOOL bCheckLeft = type != 'D' && type != 'W';
     type = PDF_CharType[tag[taglen - 1]];
     FX_BOOL bCheckRight = type != 'D' && type != 'W';
     uint8_t ch;
     if (bCheckRight && startpos + (int32_t)taglen <= limit && GetCharAt(startpos + (int32_t)taglen, ch)) {
         uint8_t type = PDF_CharType[ch];
         if (type == 'N' || type == 'R') {
             return FALSE;
@@ skipping 11 matching lines @@
 {
     int32_t taglen = tag.GetLength();
     if (taglen == 0) {
         return FALSE;
     }
     FX_FILESIZE pos = m_Pos;
     int32_t offset = 0;
     if (!bForward) {
         offset = taglen - 1;
     }
-    FX_LPCBYTE tag_data = tag.GetPtr();
+    const uint8_t* tag_data = tag.GetPtr();
     uint8_t byte;
     while (1) {
         if (bForward) {
             if (limit) {
                 if (pos >= m_Pos + limit) {
                     return FALSE;
                 }
             }
             if (!GetCharAt(pos, byte)) {
                 return FALSE;
@@ skipping 35 matching lines @@
             offset = byte == tag_data[taglen - 1] ? taglen - 2 : taglen - 1;
             pos --;
         }
         if (pos < 0) {
             return FALSE;
         }
     }
     return FALSE;
 }
 struct _SearchTagRecord {
-    FX_LPCBYTE  m_pTag;
+    const uint8_t*      m_pTag;
     FX_DWORD    m_Len;
     FX_DWORD    m_Offset;
 };
 int32_t CPDF_SyntaxParser::SearchMultiWord(FX_BSTR tags, FX_BOOL bWholeWord, FX_FILESIZE limit)
 {
     int32_t ntags = 1, i;
     for (i = 0; i < tags.GetLength(); i ++)
         if (tags[i] == 0) {
             ntags ++;
         }
@@ skipping 134 matching lines @@
     FX_BOOL                             CheckPage(IFX_DownloadHints* pHints);
     FX_BOOL                             CheckResources(IFX_DownloadHints* pHints);
     FX_BOOL                             CheckAnnots(IFX_DownloadHints* pHints);
     FX_BOOL                             CheckAcroForm(IFX_DownloadHints* pHints);
     FX_BOOL                             CheckAcroFormSubObject(IFX_DownloadHints* pHints);
     FX_BOOL                             CheckTrailerAppend(IFX_DownloadHints* pHints);
     FX_BOOL                             CheckPageStatus(IFX_DownloadHints* pHints);
     FX_BOOL                             CheckAllCrossRefStream(IFX_DownloadHints *pHints);
 
     int32_t                            CheckCrossRefStream(IFX_DownloadHints *pHints, FX_FILESIZE &xref_offset);
-    FX_BOOL                             IsLinearizedFile(FX_LPBYTE pData, FX_DWORD dwLen);
+    FX_BOOL                             IsLinearizedFile(uint8_t* pData, FX_DWORD dwLen);
     void                                SetStartOffset(FX_FILESIZE dwOffset);
     FX_BOOL                             GetNextToken(CFX_ByteString &token);
     FX_BOOL                             GetNextChar(uint8_t &ch);
     CPDF_Object *                       ParseIndirectObjectAt(FX_FILESIZE pos, FX_DWORD objnum);
     CPDF_Object *                       GetObject(FX_DWORD objnum, IFX_DownloadHints* pHints, FX_BOOL *pExistInFile);
     FX_BOOL                             GetPageKids(CPDF_Parser *pParser, CPDF_Object *pPages);
     FX_BOOL                             PreparePageItem();
     FX_BOOL                             LoadPages(IFX_DownloadHints* pHints);
     FX_BOOL                             LoadAllXref(IFX_DownloadHints* pHints);
     FX_BOOL                             LoadAllFile(IFX_DownloadHints* pHints);
@@ skipping 229 matching lines @@
         return 0;
     }
     if (pParser->m_V5Type[objnum] == 2) {
         objnum = (FX_DWORD)pParser->m_CrossRef[objnum];
     }
     if (pParser->m_V5Type[objnum] == 1 || pParser->m_V5Type[objnum] == 255) {
         offset = pParser->m_CrossRef[objnum];
         if (offset == 0) {
             return 0;
         }
-        FX_LPVOID pResult = FXSYS_bsearch(&offset, pParser->m_SortedOffset.GetData(), pParser->m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
+        void* pResult = FXSYS_bsearch(&offset, pParser->m_SortedOffset.GetData(), pParser->m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
         if (pResult == NULL) {
             return 0;
         }
         if ((FX_FILESIZE*)pResult - (FX_FILESIZE*)pParser->m_SortedOffset.GetData() == pParser->m_SortedOffset.GetSize() - 1) {
             return 0;
         }
         return (FX_DWORD)(((FX_FILESIZE*)pResult)[1] - offset);
     }
     return 0;
 }
@@ skipping 668 matching lines @@
     if (dwSize < (FX_FILESIZE)req_size) {
         return PDF_UNKNOW_LINEARIZED;
     }
     uint8_t buffer[1024];
     m_pFileRead->ReadBlock(buffer, 0, req_size);
     if (IsLinearizedFile(buffer, req_size)) {
         return PDF_IS_LINEARIZED;
     }
     return PDF_NOT_LINEARIZED;
 }
-FX_BOOL CPDF_DataAvail::IsLinearizedFile(FX_LPBYTE pData, FX_DWORD dwLen)
+FX_BOOL CPDF_DataAvail::IsLinearizedFile(uint8_t* pData, FX_DWORD dwLen)
 {
     CFX_SmartPointer<IFX_FileStream> file(FX_CreateMemoryStream(pData, (size_t)dwLen, FALSE));
     int32_t offset = GetHeaderOffset(file.Get());
     if (offset == -1) {
         m_docStatus = PDF_DATAAVAIL_ERROR;
         return FALSE;
     }
     m_dwHeaderOffset = offset;
     m_syntaxParser.InitParser(file.Get(), offset);
     m_syntaxParser.RestorePos(m_syntaxParser.m_HeaderOffset + 9);
@@ skipping 63 matching lines @@
     pHints->AddSegment(req_pos, dwSize);
     return FALSE;
 }
 int32_t CPDF_DataAvail::CheckCrossRefStream(IFX_DownloadHints* pHints, FX_FILESIZE &xref_offset)
 {
     xref_offset = 0;
     FX_DWORD req_size = (FX_DWORD)(m_Pos + 512 > m_dwFileLen ? m_dwFileLen - m_Pos : 512);
     if (m_pFileAvail->IsDataAvail(m_Pos, req_size)) {
         int32_t iSize = (int32_t)(m_Pos + req_size - m_dwCurrentXRefSteam);
         CFX_BinaryBuf buf(iSize);
-        FX_LPBYTE pBuf = buf.GetBuffer();
+        uint8_t* pBuf = buf.GetBuffer();
         m_pFileRead->ReadBlock(pBuf, m_dwCurrentXRefSteam, iSize);
         CFX_SmartPointer<IFX_FileStream> file(FX_CreateMemoryStream(pBuf, (size_t)iSize, FALSE));
         m_parser.m_Syntax.InitParser(file.Get(), 0);
         FX_BOOL bNumber = FALSE;
         CFX_ByteString objnum = m_parser.m_Syntax.GetNextWord(bNumber);
         if (!bNumber) {
             return -1;
         }
         FX_DWORD objNum = FXSYS_atoi(objnum);
         CPDF_Object *pObj = m_parser.ParseIndirectObjectAt(NULL, 0, objNum, NULL);
@@ skipping 217 matching lines @@
         m_docStatus = PDF_DATAAVAIL_LOADALLCRSOSSREF;
     }
     return TRUE;
 }
 FX_BOOL CPDF_DataAvail::CheckTrailer(IFX_DownloadHints* pHints)
 {
     int32_t iTrailerSize = (int32_t)(m_Pos + 512 > m_dwFileLen ? m_dwFileLen - m_Pos : 512);
     if (m_pFileAvail->IsDataAvail(m_Pos, iTrailerSize)) {
         int32_t iSize = (int32_t)(m_Pos + iTrailerSize - m_dwTrailerOffset);
         CFX_BinaryBuf buf(iSize);
-        FX_LPBYTE pBuf = buf.GetBuffer();
+        uint8_t* pBuf = buf.GetBuffer();
         if (!pBuf) {
             m_docStatus = PDF_DATAAVAIL_ERROR;
             return FALSE;
         }
         if (!m_pFileRead->ReadBlock(pBuf, m_dwTrailerOffset, iSize)) {
             return FALSE;
         }
         CFX_SmartPointer<IFX_FileStream> file(FX_CreateMemoryStream(pBuf, (size_t)iSize, FALSE));
         m_syntaxParser.InitParser(file.Get(), 0);
         CPDF_Object *pTrailer = m_syntaxParser.GetObject(NULL, 0, 0, 0);
@@ skipping 598 matching lines @@
 {
     int32_t iSize = m_childNode.GetSize();
     for (int32_t i = 0; i < iSize; ++i) {
         CPDF_PageNode *pNode = (CPDF_PageNode*)m_childNode[i];
         if (pNode) {
             delete pNode;
         }
     }
     m_childNode.RemoveAll();
 }