Merge to XFA: Get rid of gotos in CPDF_SyntaxParser and FlateUncompress().

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 <set>
 #include <utility>
 #include <vector>
 
+#include "../../../../third_party/base/nonstd_unique_ptr.h"
 #include "../../../include/fpdfapi/fpdf_module.h"
 #include "../../../include/fpdfapi/fpdf_page.h"
 #include "../../../include/fpdfapi/fpdf_parser.h"
 #include "../../../include/fxcrt/fx_safe_types.h"
 #include "../fpdf_page/pageint.h"
 
+namespace {
+
+int CompareFileSize(const void* p1, const void* p2) {
+  return *(FX_FILESIZE*)p1 - *(FX_FILESIZE*)p2;
+}
+
+int32_t GetHeaderOffset(IFX_FileRead* pFile) {
+  const FX_DWORD tag = FXDWORD_FROM_LSBFIRST(0x46445025);
+  const size_t kBufSize = 4;
+  uint8_t buf[kBufSize];
+  int32_t offset = 0;
+  while (offset <= 1024) {
+    if (!pFile->ReadBlock(buf, offset, kBufSize))
+      return -1;
+
+    if (*(FX_DWORD*)buf == tag)
+      return offset;
+
+    ++offset;
+  }
+  return -1;
+}
+
+int32_t GetDirectInteger(CPDF_Dictionary* pDict, const CFX_ByteStringC& key) {
+  CPDF_Object* pObj = pDict->GetElement(key);
+  if (pObj && (pObj->GetType() == PDFOBJ_NUMBER))
+    return ((CPDF_Number*)pObj)->GetInteger();
+  return 0;
+}
+
+bool CheckDirectType(CPDF_Dictionary* pDict,
+                     const CFX_ByteStringC& key,
+                     int32_t iType) {
+  CPDF_Object* pObj = pDict->GetElement(key);
+  return !pObj || pObj->GetType() == iType;
+}
+
+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;
+}
+
+}  // namespace
+
 FX_BOOL IsSignatureDict(const CPDF_Dictionary* pDict) {
   CPDF_Object* pType = pDict->GetElementValue(FX_BSTRC("Type"));
   if (!pType) {
     pType = pDict->GetElementValue(FX_BSTRC("FT"));
     if (!pType) {
       return FALSE;
     }
   }
   if (pType->GetString() == FX_BSTRC("Sig")) {
     return TRUE;
   }
   return FALSE;
 }
-static int32_t _CompareDWord(const void* p1, const void* p2) {

[Lei Zhang, 2015/10/02 20:30:22]

Slight merge conflict due to this dead function.

-  return (*(FX_DWORD*)p1) - (*(FX_DWORD*)p2);
-}
-static int _CompareFileSize(const void* p1, const void* p2) {
-  FX_FILESIZE ret = (*(FX_FILESIZE*)p1) - (*(FX_FILESIZE*)p2);
-  if (ret > 0) {
-    return 1;
-  }
-  if (ret < 0) {
-    return -1;
-  }
-  return 0;
-}
 
 CPDF_Parser::CPDF_Parser() {
   m_pDocument = NULL;
   m_pTrailer = NULL;
   m_pEncryptDict = NULL;
   m_pSecurityHandler = NULL;
   m_pLinearized = NULL;
   m_dwFirstPageNo = 0;
   m_dwXrefStartObjNum = 0;
   m_bOwnFileRead = TRUE;
@@ skipping 42 matching lines @@
   for (int32_t i = 0; i < iLen; ++i) {
     if (CPDF_Dictionary* trailer = m_Trailers.GetAt(i))
       trailer->Release();
   }
   m_Trailers.RemoveAll();
   if (m_pLinearized) {
     m_pLinearized->Release();
     m_pLinearized = NULL;
   }
 }
-static int32_t GetHeaderOffset(IFX_FileRead* pFile) {
-  FX_DWORD tag = FXDWORD_FROM_LSBFIRST(0x46445025);
-  uint8_t buf[4];
-  int32_t offset = 0;
-  while (1) {
-    if (!pFile->ReadBlock(buf, offset, 4)) {
-      return -1;
-    }
-    if (*(FX_DWORD*)buf == tag) {
-      return offset;
-    }
-    offset++;
-    if (offset > 1024) {
-      return -1;
-    }
-  }
-  return -1;
-}
 CPDF_SecurityHandler* FPDF_CreateStandardSecurityHandler();
 CPDF_SecurityHandler* FPDF_CreatePubKeyHandler(void*);
 FX_DWORD CPDF_Parser::StartParse(IFX_FileRead* pFileAccess,
                                  FX_BOOL bReParse,
                                  FX_BOOL bOwnFileRead) {
   CloseParser(bReParse);
   m_bXRefStream = FALSE;
   m_LastXRefOffset = 0;
   m_bOwnFileRead = bOwnFileRead;
   int32_t offset = GetHeaderOffset(pFileAccess);
@@ skipping 22 matching lines @@
   }
   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();
     void* pResult = FXSYS_bsearch(&startxref_offset, m_SortedOffset.GetData(),
                                   m_SortedOffset.GetSize(), sizeof(FX_FILESIZE),
-                                  _CompareFileSize);
+                                  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 27 matching lines @@
     dwRet = SetEncryptHandler();
     if (dwRet != PDFPARSE_ERROR_SUCCESS) {
       return dwRet;
     }
     m_pDocument->LoadDoc();
     if (m_pDocument->GetRoot() == NULL) {
       return PDFPARSE_ERROR_FORMAT;
     }
   }
   FXSYS_qsort(m_SortedOffset.GetData(), m_SortedOffset.GetSize(),
-              sizeof(FX_FILESIZE), _CompareFileSize);
+              sizeof(FX_FILESIZE), CompareFileSize);
   FX_DWORD RootObjNum = GetRootObjNum();
   if (RootObjNum == 0) {
     ReleaseEncryptHandler();
     RebuildCrossRef();
     RootObjNum = GetRootObjNum();
     if (RootObjNum == 0) {
       return PDFPARSE_ERROR_FORMAT;
     }
     dwRet = SetEncryptHandler();
     if (dwRet != PDFPARSE_ERROR_SUCCESS) {
@@ skipping 85 matching lines @@
     return 0;
   }
   if (m_V5Type[objnum] == 1) {
     return m_CrossRef[objnum];
   }
   if (m_V5Type[objnum] == 2) {
     return m_CrossRef[(int32_t)m_CrossRef[objnum]];
   }
   return 0;
 }
-static int32_t GetDirectInteger(CPDF_Dictionary* pDict,
-                                const CFX_ByteStringC& key) {
-  CPDF_Object* pObj = pDict->GetElement(key);
-  if (pObj == NULL) {
-    return 0;
-  }
-  if (pObj->GetType() == PDFOBJ_NUMBER) {
-    return ((CPDF_Number*)pObj)->GetInteger();
-  }
-  return 0;
-}
-static FX_BOOL CheckDirectType(CPDF_Dictionary* pDict,
-                               const CFX_ByteStringC& key,
-                               int32_t iType) {
-  CPDF_Object* pObj = pDict->GetElement(key);
-  if (!pObj) {
-    return TRUE;
-  }
-  return pObj->GetType() == iType;
-}
+
 FX_BOOL CPDF_Parser::LoadAllCrossRefV4(FX_FILESIZE xrefpos) {
   if (!LoadCrossRefV4(xrefpos, 0, TRUE, FALSE)) {
     return FALSE;
   }
   m_pTrailer = LoadTrailerV4();
   if (m_pTrailer == NULL) {
     return FALSE;
   }
   int32_t xrefsize = GetDirectInteger(m_pTrailer, FX_BSTRC("Size"));
   if (xrefsize <= 0 || xrefsize > (1 << 20)) {
@@ skipping 71 matching lines @@
       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);
   void* pResult =
       FXSYS_bsearch(&pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(),
-                    sizeof(FX_FILESIZE), _CompareFileSize);
+                    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;
@@ skipping 26 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) {
           void* pResult = FXSYS_bsearch(
               &m_CrossRef[objnum], m_SortedOffset.GetData(),
-              m_SortedOffset.GetSize(), sizeof(FX_FILESIZE), _CompareFileSize);
+              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) {
+
+bool CPDF_Parser::FindPosInOffsets(FX_FILESIZE pos) const {
+  return FXSYS_bsearch(&pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(),
+                       sizeof(FX_FILESIZE), CompareFileSize);
+}
+
+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;
-  }
-  void* pResult =
-      FXSYS_bsearch(&pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(),
-                    sizeof(FX_FILESIZE), _CompareFileSize);
-  if (pResult == NULL) {
+  if (m_Syntax.GetKeyword() != FX_BSTRC("xref"))
+    return false;
+
+  if (!FindPosInOffsets(pos))
     m_SortedOffset.Add(pos);
-  }
-  if (streampos) {
-    void* pResult = FXSYS_bsearch(&streampos, m_SortedOffset.GetData(),
-                                  m_SortedOffset.GetSize(), sizeof(FX_FILESIZE),
-                                  _CompareFileSize);
-    if (pResult == NULL) {
+
+  if (streampos && !FindPosInOffsets(streampos))
       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;
-    }
+    if (word.IsEmpty())
+      return false;
+
     if (!bIsNumber) {
       m_Syntax.RestorePos(SavedPos);
       break;
     }
     FX_DWORD start_objnum = FXSYS_atoi(word);
-    if (start_objnum >= (1 << 20)) {
-      return FALSE;
-    }
+    if (start_objnum >= (1 << 20))
+      return false;
+
     FX_DWORD count = m_Syntax.GetDirectNum();
     m_Syntax.ToNextWord();
     SavedPos = m_Syntax.SavePos();
     FX_BOOL bFirstItem = FALSE;
     int32_t recordsize = 20;
-    if (bFirst) {
+    if (bFirst)
       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((uint8_t*)pBuf, block_size * recordsize);
         for (int32_t i = 0; i < block_size; i++) {
@@ skipping 13 matching lines @@
               }
             }
             m_CrossRef.SetAtGrow(objnum, 0);
             m_V5Type.SetAtGrow(objnum, 0);
           } else {
             FX_FILESIZE offset = (FX_FILESIZE)FXSYS_atoi64(pEntry);
             if (offset == 0) {
               for (int32_t c = 0; c < 10; c++) {
                 if (pEntry[c] < '0' || pEntry[c] > '9') {
                   FX_Free(pBuf);
-                  return FALSE;
+                  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) {
-              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]);
-              }
+            if (m_CrossRef[objnum] < m_Syntax.m_FileLen &&
+                !FindPosInOffsets(m_CrossRef[objnum])) {
+              m_SortedOffset.Add(m_CrossRef[objnum]);
             }
             m_V5Type.SetAtGrow(objnum, 1);
           }
           if (bFirstBlock) {
             bFirstBlock = FALSE;
           }
         }
       }
       FX_Free(pBuf);
     }
     m_Syntax.RestorePos(SavedPos + count * recordsize);
   }
-  if (streampos)
-    if (!LoadCrossRefV5(streampos, streampos, FALSE)) {
-      return FALSE;
-    }
-  return TRUE;
+  return !streampos || LoadCrossRefV5(streampos, streampos, FALSE);
 }
+
 FX_BOOL CPDF_Parser::LoadAllCrossRefV5(FX_FILESIZE xrefpos) {
   if (!LoadCrossRefV5(xrefpos, xrefpos, TRUE)) {
     return FALSE;
   }
   while (xrefpos)
     if (!LoadCrossRefV5(xrefpos, xrefpos, FALSE)) {
       return FALSE;
     }
   m_ObjectStreamMap.InitHashTable(101, FALSE);
   m_bXRefStream = TRUE;
@@ skipping 154 matching lines @@
               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;
                 void* pResult =
                     FXSYS_bsearch(&obj_pos, m_SortedOffset.GetData(),
                                   m_SortedOffset.GetSize(), sizeof(FX_FILESIZE),
-                                  _CompareFileSize);
+                                  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;
@@ skipping 197 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;
   void* pResult =
       FXSYS_bsearch(&offset, m_SortedOffset.GetData(), m_SortedOffset.GetSize(),
-                    sizeof(FX_FILESIZE), _CompareFileSize);
+                    sizeof(FX_FILESIZE), CompareFileSize);
   if (pResult == NULL) {
     m_SortedOffset.Add(offset);
   }
   FX_Free(buffer);
   return TRUE;
 }
-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);
   if (!pStream) {
     return FALSE;
   }
   if (m_pDocument) {
     CPDF_Dictionary* pDict = m_pDocument->GetRoot();
@@ skipping 86 matching lines @@
     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;
       const uint8_t* entrystart = segstart + j * totalWidth;
       if (WidthArray[0]) {
-        type = _GetVarInt(entrystart, WidthArray[0]);
+        type = GetVarInt(entrystart, WidthArray[0]);
       }
       if (m_V5Type[startnum + j] == 255) {
         FX_FILESIZE offset =
-            _GetVarInt(entrystart + WidthArray[0], WidthArray[1]);
+            GetVarInt(entrystart + WidthArray[0], WidthArray[1]);
         m_CrossRef[startnum + j] = offset;
         void* pResult = FXSYS_bsearch(&offset, m_SortedOffset.GetData(),
                                       m_SortedOffset.GetSize(),
-                                      sizeof(FX_FILESIZE), _CompareFileSize);
+                                      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]);
+            GetVarInt(entrystart + WidthArray[0], WidthArray[1]);
         m_CrossRef[startnum + j] = offset;
         if (type == 1) {
           void* pResult = FXSYS_bsearch(&offset, m_SortedOffset.GetData(),
                                         m_SortedOffset.GetSize(),
-                                        sizeof(FX_FILESIZE), _CompareFileSize);
+                                        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 (m_V5Type[objnum] == 0) {
     return TRUE;
   }
   if (m_V5Type[objnum] == 2) {
     return TRUE;
   }
   FX_FILESIZE pos = m_CrossRef[objnum];
   void* pResult =
       FXSYS_bsearch(&pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(),
-                    sizeof(FX_FILESIZE), _CompareFileSize);
+                    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);
@@ skipping 62 matching lines @@
   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;
     }
     void* pResult = FXSYS_bsearch(&offset, m_SortedOffset.GetData(),
                                   m_SortedOffset.GetSize(), sizeof(FX_FILESIZE),
-                                  _CompareFileSize);
+                                  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;
@@ skipping 60 matching lines @@
     if (!bIsNumber) {
       m_Syntax.RestorePos(SavedPos);
       return;
     }
     if (m_Syntax.GetKeyword() != FX_BSTRC("obj")) {
       m_Syntax.RestorePos(SavedPos);
       return;
     }
     void* pResult =
         FXSYS_bsearch(&pos, m_SortedOffset.GetData(), m_SortedOffset.GetSize(),
-                      sizeof(FX_FILESIZE), _CompareFileSize);
+                      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 258 matching lines @@
     dwRet = SetEncryptHandler();
     if (dwRet != PDFPARSE_ERROR_SUCCESS) {
       return dwRet;
     }
     m_pDocument->LoadAsynDoc(m_pLinearized->GetDict());
     if (m_pDocument->GetRoot() == NULL) {
       return PDFPARSE_ERROR_FORMAT;
     }
   }
   FXSYS_qsort(m_SortedOffset.GetData(), m_SortedOffset.GetSize(),
-              sizeof(FX_FILESIZE), _CompareFileSize);
+              sizeof(FX_FILESIZE), CompareFileSize);
   FX_DWORD RootObjNum = GetRootObjNum();
   if (RootObjNum == 0) {
     ReleaseEncryptHandler();
     RebuildCrossRef();
     RootObjNum = GetRootObjNum();
     if (RootObjNum == 0) {
       return PDFPARSE_ERROR_FORMAT;
     }
     dwRet = SetEncryptHandler();
     if (dwRet != PDFPARSE_ERROR_SUCCESS) {
@@ skipping 51 matching lines @@
     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;
   }
   FXSYS_qsort(m_SortedOffset.GetData(), m_SortedOffset.GetSize(),
-              sizeof(FX_FILESIZE), _CompareFileSize);
+              sizeof(FX_FILESIZE), CompareFileSize);
   m_Syntax.m_MetadataObjnum = dwSaveMetadataObjnum;
   return PDFPARSE_ERROR_SUCCESS;
 }
 
 // static
 int CPDF_SyntaxParser::s_CurrentRecursionDepth = 0;
 
 CPDF_SyntaxParser::CPDF_SyntaxParser() {
   m_pFileAccess = NULL;
   m_pCryptoHandler = NULL;
   m_pFileBuf = NULL;
   m_BufSize = CPDF_ModuleMgr::kFileBufSize;
   m_pFileBuf = NULL;
   m_MetadataObjnum = 0;
   m_dwWordPos = 0;
   m_bFileStream = FALSE;
 }
 CPDF_SyntaxParser::~CPDF_SyntaxParser() {
   FX_Free(m_pFileBuf);
 }
+
 FX_BOOL CPDF_SyntaxParser::GetCharAt(FX_FILESIZE pos, uint8_t& ch) {
-  FX_FILESIZE save_pos = m_Pos;
+  CFX_AutoRestorer<FX_FILESIZE> save_pos(&m_Pos);
   m_Pos = pos;
-  FX_BOOL ret = GetNextChar(ch);
-  m_Pos = save_pos;
-  return ret;
+  return GetNextChar(ch);
 }
+
 FX_BOOL CPDF_SyntaxParser::GetNextChar(uint8_t& ch) {
   FX_FILESIZE pos = m_Pos + m_HeaderOffset;
   if (pos >= m_FileLen) {
     return FALSE;
   }
   if (m_BufOffset >= pos || (FX_FILESIZE)(m_BufOffset + m_BufSize) <= pos) {
     FX_FILESIZE read_pos = pos;
     FX_DWORD read_size = m_BufSize;
     if ((FX_FILESIZE)read_size > m_FileLen) {
       read_size = (FX_DWORD)m_FileLen;
@@ skipping 934 matching lines @@
     } else {
       offset = byte == tag_data[taglen - 1] ? taglen - 2 : taglen - 1;
       pos--;
     }
     if (pos < 0) {
       return FALSE;
     }
   }
   return FALSE;
 }
+
 struct _SearchTagRecord {
   const uint8_t* m_pTag;
   FX_DWORD m_Len;
   FX_DWORD m_Offset;
 };
+
 int32_t CPDF_SyntaxParser::SearchMultiWord(const CFX_ByteStringC& tags,
                                            FX_BOOL bWholeWord,
                                            FX_FILESIZE limit) {
-  int32_t ntags = 1, i;
-  for (i = 0; i < tags.GetLength(); i++)
+  int32_t ntags = 1;
+  for (int i = 0; i < tags.GetLength(); ++i) {
     if (tags[i] == 0) {
-      ntags++;
+      ++ntags;
     }
-  _SearchTagRecord* pPatterns = FX_Alloc(_SearchTagRecord, ntags);
-  FX_DWORD start = 0, itag = 0, max_len = 0;
-  for (i = 0; i <= tags.GetLength(); i++) {
+  }
+
+  std::vector<_SearchTagRecord> patterns(ntags);
+  FX_DWORD start = 0;
+  FX_DWORD itag = 0;
+  FX_DWORD max_len = 0;
+  for (int i = 0; i <= tags.GetLength(); ++i) {
     if (tags[i] == 0) {
       FX_DWORD len = i - start;
-      if (len > max_len) {
-        max_len = len;
-      }
-      pPatterns[itag].m_pTag = tags.GetPtr() + start;
-      pPatterns[itag].m_Len = len;
-      pPatterns[itag].m_Offset = 0;
+      max_len = std::max(len, max_len);
+      patterns[itag].m_pTag = tags.GetPtr() + start;
+      patterns[itag].m_Len = len;
+      patterns[itag].m_Offset = 0;
       start = i + 1;
-      itag++;
+      ++itag;
     }
   }
-  FX_FILESIZE pos = m_Pos;
-  uint8_t byte;
-  GetCharAt(pos++, byte);
-  int32_t found = -1;
-  while (1) {
-    for (i = 0; i < ntags; i++) {
-      if (pPatterns[i].m_pTag[pPatterns[i].m_Offset] == byte) {
-        pPatterns[i].m_Offset++;
-        if (pPatterns[i].m_Offset == pPatterns[i].m_Len) {
-          if (!bWholeWord ||
-              IsWholeWord(pos - pPatterns[i].m_Len, limit, pPatterns[i].m_pTag,
-                          pPatterns[i].m_Len, FALSE)) {
-            found = i;
-            goto end;
-          } else {
-            if (pPatterns[i].m_pTag[0] == byte) {
-              pPatterns[i].m_Offset = 1;
-            } else {
-              pPatterns[i].m_Offset = 0;
-            }
-          }
-        }
-      } else {
-        if (pPatterns[i].m_pTag[0] == byte) {
-          pPatterns[i].m_Offset = 1;
-        } else {
-          pPatterns[i].m_Offset = 0;
-        }
+
+  const FX_FILESIZE pos_limit = m_Pos + limit;
+  for (FX_FILESIZE pos = m_Pos; !limit || pos < pos_limit; ++pos) {
+    uint8_t byte;
+    if (!GetCharAt(pos, byte))
+      break;
+
+    for (int i = 0; i < ntags; ++i) {
+      _SearchTagRecord& pat = patterns[i];
+      if (pat.m_pTag[pat.m_Offset] != byte) {
+        pat.m_Offset = (pat.m_pTag[0] == byte) ? 1 : 0;
+        continue;
       }
+
+      ++pat.m_Offset;
+      if (pat.m_Offset != pat.m_Len)
+        continue;
+
+      if (!bWholeWord ||
+          IsWholeWord(pos - pat.m_Len, limit, pat.m_pTag, pat.m_Len, FALSE)) {
+        return i;
+      }
+
+      pat.m_Offset = (pat.m_pTag[0] == byte) ? 1 : 0;
     }
-    if (limit && pos >= m_Pos + limit) {
-      goto end;
-    }
-    if (!GetCharAt(pos, byte)) {
-      goto end;
-    }
-    pos++;
   }
-end:
-  FX_Free(pPatterns);
-  return found;
+  return -1;
 }
+
 FX_FILESIZE CPDF_SyntaxParser::FindTag(const CFX_ByteStringC& tag,
                                        FX_FILESIZE limit) {
   int32_t taglen = tag.GetLength();
   int32_t match = 0;
   limit += m_Pos;
   FX_FILESIZE startpos = m_Pos;
   while (1) {
     uint8_t ch;
     if (!GetNextChar(ch)) {
       return -1;
@@ skipping 24 matching lines @@
       break;
     }
   }
 }
 
 class CPDF_DataAvail final : public IPDF_DataAvail {
  public:
   CPDF_DataAvail(IFX_FileAvail* pFileAvail, IFX_FileRead* pFileRead);
   ~CPDF_DataAvail() override;
 
-  virtual FX_BOOL IsDocAvail(IFX_DownloadHints* pHints) override;
+  FX_BOOL IsDocAvail(IFX_DownloadHints* pHints) override;
 
-  virtual void SetDocument(CPDF_Document* pDoc) override;
+  void SetDocument(CPDF_Document* pDoc) override;
 
-  virtual FX_BOOL IsPageAvail(int iPage, IFX_DownloadHints* pHints) override;
+  FX_BOOL IsPageAvail(int iPage, IFX_DownloadHints* pHints) override;
 
-  virtual int32_t IsFormAvail(IFX_DownloadHints* pHints) override;
+  int32_t IsFormAvail(IFX_DownloadHints* pHints) override;
 
-  virtual int32_t IsLinearizedPDF() override;
+  int32_t IsLinearizedPDF() override;
 
-  virtual FX_BOOL IsLinearized() override { return m_bLinearized; }
+  FX_BOOL IsLinearized() override { return m_bLinearized; }
 
-  virtual void GetLinearizedMainXRefInfo(FX_FILESIZE* pPos,
-                                         FX_DWORD* pSize) override;
+  void GetLinearizedMainXRefInfo(FX_FILESIZE* pPos, FX_DWORD* pSize) override;
 
  protected:
   static const int kMaxDataAvailRecursionDepth = 64;
   static int s_CurrentDataAvailRecursionDepth;
 
   FX_DWORD GetObjectSize(FX_DWORD objnum, FX_FILESIZE& offset);
   FX_BOOL IsObjectsAvail(CFX_PtrArray& obj_array,
                          FX_BOOL bParsePage,
                          IFX_DownloadHints* pHints,
                          CFX_PtrArray& ret_array);
@@ skipping 259 matching lines @@
   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;
     }
     void* pResult = FXSYS_bsearch(&offset, pParser->m_SortedOffset.GetData(),
                                   pParser->m_SortedOffset.GetSize(),
-                                  sizeof(FX_FILESIZE), _CompareFileSize);
+                                  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);
   }
@@ skipping 231 matching lines @@
 FX_BOOL CPDF_DataAvail::LoadAllXref(IFX_DownloadHints* pHints) {
   m_parser.m_Syntax.InitParser(m_pFileRead, (FX_DWORD)m_dwHeaderOffset);
   m_parser.m_bOwnFileRead = FALSE;
   if (!m_parser.LoadAllCrossRefV4(m_dwLastXRefOffset) &&
       !m_parser.LoadAllCrossRefV5(m_dwLastXRefOffset)) {
     m_docStatus = PDF_DATAAVAIL_LOADALLFILE;
     return FALSE;
   }
   FXSYS_qsort(m_parser.m_SortedOffset.GetData(),
               m_parser.m_SortedOffset.GetSize(), sizeof(FX_FILESIZE),
-              _CompareFileSize);
+              CompareFileSize);
   m_dwRootObjNum = m_parser.GetRootObjNum();
   m_dwInfoObjNum = m_parser.GetInfoObjNum();
   m_pCurrentParser = &m_parser;
   m_docStatus = PDF_DATAAVAIL_ROOT;
   return TRUE;
 }
 CPDF_Object* CPDF_DataAvail::GetObject(FX_DWORD objnum,
                                        IFX_DownloadHints* pHints,
                                        FX_BOOL* pExistInFile) {
   CPDF_Object* pRet = NULL;
@@ skipping 1310 matching lines @@
   return FALSE;
 }
 CPDF_PageNode::~CPDF_PageNode() {
   int32_t iSize = m_childNode.GetSize();
   for (int32_t i = 0; i < iSize; ++i) {
     CPDF_PageNode* pNode = (CPDF_PageNode*)m_childNode[i];
     delete pNode;
   }
   m_childNode.RemoveAll();
 }