Clean up some if/else if statements in CPDF_Parser::RebuildCrossRef().

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 "core/include/fpdfapi/fpdf_parser.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 590 matching lines @@
     const FX_FILESIZE saved_pos = pos;
     bool bOverFlow = false;
     FX_DWORD size = std::min((FX_DWORD)(m_Syntax.m_FileLen - pos), kBufferSize);
     if (!m_Syntax.m_pFileAccess->ReadBlock(buffer.data(), pos, size))
       break;
 
     for (FX_DWORD i = 0; i < size; i++) {
       uint8_t byte = buffer[i];
       switch (state) {
         case ParserState::kDefault:
-          if (PDFCharIsWhitespace(byte))
+          if (PDFCharIsWhitespace(byte)) {
             state = ParserState::kWhitespace;
-
-          if (std::isdigit(byte)) {
+          } else if (std::isdigit(byte)) {
             --i;
             state = ParserState::kWhitespace;
-          }
-
-          if (byte == '%') {
+          } else if (byte == '%') {
             inside_index = 0;
             state = ParserState::kComment;
-          }
-
-          if (byte == '(') {
+          } else if (byte == '(') {
             state = ParserState::kString;
             depth = 1;
-          }
-
-          if (byte == '<') {
+          } else if (byte == '<') {
             inside_index = 1;
             state = ParserState::kHexString;
-          }
-
-          if (byte == '\\')
+          } else if (byte == '\\') {
             state = ParserState::kEscapedString;
-
-          if (byte == 't') {
+          } else if (byte == 't') {
             state = ParserState::kTrailer;
             inside_index = 1;
           }
           break;
 
         case ParserState::kWhitespace:
-          if (PDFCharIsWhitespace(byte)) {
-            break;
-          } else if (std::isdigit(byte)) {
+          if (std::isdigit(byte)) {
             start_pos = pos + i;
             state = ParserState::kObjNum;
             objnum = FXSYS_toDecimalDigit(byte);
-
           } else if (byte == 't') {
             state = ParserState::kTrailer;
             inside_index = 1;
-
           } else if (byte == 'x') {
             state = ParserState::kXref;
             inside_index = 1;
-
-          } else {
+          } else if (!PDFCharIsWhitespace(byte)) {
             --i;
             state = ParserState::kDefault;
           }
           break;
 
         case ParserState::kObjNum:
           if (std::isdigit(byte)) {
             objnum = objnum * 10 + FXSYS_toDecimalDigit(byte);
-            break;
           } else if (PDFCharIsWhitespace(byte)) {
             state = ParserState::kPostObjNum;
           } else {
             --i;
             state = ParserState::kEndObj;
             inside_index = 0;
           }
           break;
 
         case ParserState::kPostObjNum:
           if (std::isdigit(byte)) {
             start_pos1 = pos + i;
             state = ParserState::kGenNum;
             gennum = FXSYS_toDecimalDigit(byte);
-          } else if (PDFCharIsWhitespace(byte)) {
-            break;
           } else if (byte == 't') {
             state = ParserState::kTrailer;
             inside_index = 1;
-          } else {
+          } else if (!PDFCharIsWhitespace(byte)) {
             --i;
             state = ParserState::kDefault;
           }
           break;
 
         case ParserState::kGenNum:
           if (std::isdigit(byte)) {
             gennum = gennum * 10 + FXSYS_toDecimalDigit(byte);
-            break;
           } else if (PDFCharIsWhitespace(byte)) {
             state = ParserState::kPostGenNum;
           } else {
             --i;
             state = ParserState::kDefault;
           }
           break;
 
         case ParserState::kPostGenNum:
           if (byte == 'o') {
             state = ParserState::kBeginObj;
             inside_index = 1;
-          } else if (PDFCharIsWhitespace(byte)) {
-            break;
           } else if (std::isdigit(byte)) {
             objnum = gennum;
             gennum = FXSYS_toDecimalDigit(byte);
             start_pos = start_pos1;
             start_pos1 = pos + i;
             state = ParserState::kGenNum;
           } else if (byte == 't') {
             state = ParserState::kTrailer;
             inside_index = 1;
-          } else {
+          } else if (!PDFCharIsWhitespace(byte)) {
             --i;
             state = ParserState::kDefault;
           }
           break;
 
         case ParserState::kBeginObj:
           switch (inside_index) {
             case 1:
               if (byte != 'b') {
                 --i;
@@ skipping 2277 matching lines @@
                                        FX_BOOL* pExistInFile) {
   CPDF_Object* pRet = nullptr;
   FX_DWORD size = 0;
   FX_FILESIZE offset = 0;
   CPDF_Parser* pParser = nullptr;
   if (pExistInFile)
     *pExistInFile = TRUE;
 
   if (m_pDocument) {
     size = GetObjectSize(objnum, offset);
-    pParser = (CPDF_Parser*)(m_pDocument->GetParser());
+    pParser = m_pDocument->GetParser();
   } else {
     size = (FX_DWORD)m_parser.GetObjectSize(objnum);
     offset = m_parser.GetObjectOffset(objnum);
     pParser = &m_parser;
   }
   if (!IsDataAvail(offset, size, pHints)) {
     return nullptr;
   }
   if (pParser) {
     pRet = pParser->ParseIndirectObject(nullptr, objnum);
@@ skipping 79 matching lines @@
 FX_BOOL CPDF_DataAvail::PreparePageItem() {
   CPDF_Dictionary* pRoot = m_pDocument->GetRoot();
   CPDF_Reference* pRef =
       ToReference(pRoot ? pRoot->GetElement("Pages") : nullptr);
   if (!pRef) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
 
   m_PagesObjNum = pRef->GetRefObjNum();
-  m_pCurrentParser = (CPDF_Parser*)m_pDocument->GetParser();
+  m_pCurrentParser = m_pDocument->GetParser();
   m_docStatus = PDF_DATAAVAIL_PAGETREE;
   return TRUE;
 }
 bool CPDF_DataAvail::IsFirstCheck(int iPage) {
   return m_pageMapCheckState.insert(iPage).second;
 }
 void CPDF_DataAvail::ResetFirstCheck(int iPage) {
   m_pageMapCheckState.erase(iPage);
 }
 FX_BOOL CPDF_DataAvail::CheckPage(IFX_DownloadHints* pHints) {
@@ skipping 1050 matching lines @@
         }
       } else {
         if (!m_bCurPageDictLoadOK && !CheckPage(iPage, pHints)) {
           return DataNotAvailable;
         }
       }
     } else {
       if (!LoadAllFile(pHints)) {
         return DataNotAvailable;
       }
-      ((CPDF_Parser*)m_pDocument->GetParser())->RebuildCrossRef();
+      m_pDocument->GetParser()->RebuildCrossRef();
       ResetFirstCheck(iPage);
       return DataAvailable;
     }
   } else {
     if (!m_bTotalLoadPageTree) {
       if (!m_bCurPageDictLoadOK && !CheckPage(iPage, pHints)) {
         return DataNotAvailable;
       }
     }
   }
@@ skipping 539 matching lines @@
   if (!m_pLinearizedDict)
     return -1;
   CPDF_Array* pRange = m_pLinearizedDict->GetArrayBy("H");
   if (!pRange)
     return -1;
   CPDF_Object* pStreamLen = pRange->GetElementValue(1);
   if (!pStreamLen)
     return -1;
   return pStreamLen->GetInteger();
 }