XFA: Manually correct IsParsered to IsParsed in remaining places.

core/src/fpdftext/fpdf_text_int.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 <ctype.h>
 #include <algorithm>
 
 #include "../../../third_party/base/nonstd_unique_ptr.h"
@@ skipping 78 matching lines @@
 IPDF_TextPage* IPDF_TextPage::CreateTextPage(const CPDF_Page* pPage,
                                              int flags) {
   return new CPDF_TextPage(pPage, flags);
 }
 IPDF_TextPage* IPDF_TextPage::CreateTextPage(const CPDF_PageObjects* pObjs,
                                              int flags) {
   return new CPDF_TextPage(pObjs, flags);
 }
 IPDF_TextPageFind* IPDF_TextPageFind::CreatePageFind(
     const IPDF_TextPage* pTextPage) {
-  if (!pTextPage) {
-    return NULL;
-  }
-  return new CPDF_TextPageFind(pTextPage);
+  return pTextPage ? new CPDF_TextPageFind(pTextPage) : nullptr;
 }
 IPDF_LinkExtract* IPDF_LinkExtract::CreateLinkExtract() {
   return new CPDF_LinkExtract();
 }
 #define TEXT_BLANK_CHAR L' '
 #define TEXT_LINEFEED_CHAR L'\n'
 #define TEXT_RETURN_CHAR L'\r'
 #define TEXT_EMPTY L""
 #define TEXT_BLANK L" "
 #define TEXT_RETURN_LINEFEED L"\r\n"
 #define TEXT_LINEFEED L"\n"
 #define TEXT_CHARRATIO_GAPDELTA 0.070
+
 CPDF_TextPage::CPDF_TextPage(const CPDF_Page* pPage, int flags)
-    : m_charList(512),
+    : m_pPage(pPage),
+      m_charList(512),
       m_TempCharList(50),
-      m_pPreTextObj(NULL),
-      m_IsParsered(FALSE),
+      m_parserflag(flags),
+      m_pPreTextObj(nullptr),
+      m_bIsParsed(false),
       m_TextlineDir(-1),
       m_CurlineRect(0, 0, 0, 0) {
-  m_pPage = pPage;
-  m_parserflag = flags;
   m_TextBuf.EstimateSize(0, 10240);
   pPage->GetDisplayMatrix(m_DisplayMatrix, 0, 0, (int)pPage->GetPageWidth(),
                           (int)pPage->GetPageHeight(), 0);
 }
+
 CPDF_TextPage::CPDF_TextPage(const CPDF_Page* pPage,
                              CPDFText_ParseOptions ParserOptions)
     : m_ParseOptions(ParserOptions),
+      m_pPage(pPage),
       m_charList(512),
       m_TempCharList(50),
-      m_pPreTextObj(NULL),
-      m_IsParsered(FALSE),
+      m_parserflag(0),
+      m_pPreTextObj(nullptr),
+      m_bIsParsed(false),
       m_TextlineDir(-1),
       m_CurlineRect(0, 0, 0, 0) {
-  m_pPage = pPage;
-  m_parserflag = 0;
   m_TextBuf.EstimateSize(0, 10240);
   pPage->GetDisplayMatrix(m_DisplayMatrix, 0, 0, (int)pPage->GetPageWidth(),
                           (int)pPage->GetPageHeight(), 0);
 }
+
 CPDF_TextPage::CPDF_TextPage(const CPDF_PageObjects* pPage, int flags)
-    : m_charList(512),
+    : m_pPage(pPage),
+      m_charList(512),
       m_TempCharList(50),
-      m_pPreTextObj(NULL),
-      m_IsParsered(FALSE),
+      m_parserflag(flags),
+      m_pPreTextObj(nullptr),
+      m_bIsParsed(false),
       m_TextlineDir(-1),
       m_CurlineRect(0, 0, 0, 0) {
-  m_pPage = pPage;
-  m_parserflag = flags;
   m_TextBuf.EstimateSize(0, 10240);
   CFX_FloatRect pageRect = pPage->CalcBoundingBox();
   m_DisplayMatrix = CFX_AffineMatrix(1, 0, 0, -1, pageRect.right, pageRect.top);
 }
 void CPDF_TextPage::NormalizeObjects(FX_BOOL bNormalize) {
   m_ParseOptions.m_bNormalizeObjs = bNormalize;
 }
 bool CPDF_TextPage::IsControlChar(const PAGECHAR_INFO& charInfo) {
   switch (charInfo.m_Unicode) {
     case 0x2:
     case 0x3:
     case 0x93:
     case 0x94:
     case 0x96:
     case 0x97:
     case 0x98:
     case 0xfffe:
       return charInfo.m_Flag != FPDFTEXT_CHAR_HYPHEN;
     default:
       return false;
   }
 }
 FX_BOOL CPDF_TextPage::ParseTextPage() {
-  if (!m_pPage) {
-    m_IsParsered = FALSE;
+  m_bIsParsed = false;
+  if (!m_pPage)
     return FALSE;
-  }
-  m_IsParsered = FALSE;
+
   m_TextBuf.Clear();
   m_charList.RemoveAll();
   m_pPreTextObj = NULL;
   ProcessObject();
-  m_IsParsered = TRUE;
+  m_bIsParsed = true;
   if (!m_ParseOptions.m_bGetCharCodeOnly) {
     m_CharIndex.RemoveAll();
     int nCount = m_charList.GetSize();
     if (nCount) {
       m_CharIndex.Add(0);
     }
     for (int i = 0; i < nCount; i++) {
       int indexSize = m_CharIndex.GetSize();
       FX_BOOL bNormal = FALSE;
       PAGECHAR_INFO charinfo = *(PAGECHAR_INFO*)m_charList.GetAt(i);
@@ skipping 67 matching lines @@
 }
 void CPDF_TextPage::GetRectArray(int start,
                                  int nCount,
                                  CFX_RectArray& rectArray) const {
   if (m_ParseOptions.m_bGetCharCodeOnly) {
     return;
   }
   if (start < 0 || nCount == 0) {
     return;
   }
-  if (!m_IsParsered) {
+  if (!m_bIsParsed) {
     return;
   }
   PAGECHAR_INFO info_curchar;
   CPDF_TextObject* pCurObj = NULL;
   CFX_FloatRect rect;
   int curPos = start;
   FX_BOOL flagNewRect = TRUE;
   if (nCount + start > m_charList.GetSize() || nCount == -1) {
     nCount = m_charList.GetSize() - start;
   }
@@ skipping 62 matching lines @@
         rect.bottom = info_curchar.m_CharBox.bottom;
       }
     }
   }
   rectArray.Add(rect);
   return;
 }
 int CPDF_TextPage::GetIndexAtPos(CPDF_Point point,
                                  FX_FLOAT xTolerance,
                                  FX_FLOAT yTolerance) const {
-  if (m_ParseOptions.m_bGetCharCodeOnly) {
+  if (m_ParseOptions.m_bGetCharCodeOnly || !m_bIsParsed)
     return -3;
-  }
-  if (!m_IsParsered) {
-    return -3;
-  }
+
   int pos = 0;
   int NearPos = -1;
   double xdif = 5000, ydif = 5000;
   while (pos < m_charList.GetSize()) {
     PAGECHAR_INFO charinfo = *(PAGECHAR_INFO*)(m_charList.GetAt(pos));
     CFX_FloatRect charrect = charinfo.m_CharBox;
     if (charrect.Contains(point.x, point.y)) {
       break;
     }
     if (xTolerance > 0 || yTolerance > 0) {
@@ skipping 22 matching lines @@
     }
     ++pos;
   }
   if (pos >= m_charList.GetSize()) {
     pos = NearPos;
   }
   return pos;
 }
 CFX_WideString CPDF_TextPage::GetTextByRect(const CFX_FloatRect& rect) const {
   CFX_WideString strText;
-  if (m_ParseOptions.m_bGetCharCodeOnly || !m_IsParsered) {
+  if (m_ParseOptions.m_bGetCharCodeOnly || !m_bIsParsed)
     return strText;
-  }
+
   int nCount = m_charList.GetSize();
   int pos = 0;
   FX_FLOAT posy = 0;
   FX_BOOL IsContainPreChar = FALSE;
   FX_BOOL ISAddLineFeed = FALSE;
   while (pos < nCount) {
     PAGECHAR_INFO charinfo = *(PAGECHAR_INFO*)m_charList.GetAt(pos++);
     if (IsRectIntersect(rect, charinfo.m_CharBox)) {
       if (FXSYS_fabs(posy - charinfo.m_OriginY) > 0 && !IsContainPreChar &&
           ISAddLineFeed) {
@@ skipping 15 matching lines @@
       }
     } else {
       IsContainPreChar = FALSE;
       ISAddLineFeed = TRUE;
     }
   }
   return strText;
 }
 void CPDF_TextPage::GetRectsArrayByRect(const CFX_FloatRect& rect,
                                         CFX_RectArray& resRectArray) const {
-  if (m_ParseOptions.m_bGetCharCodeOnly) {
+  if (m_ParseOptions.m_bGetCharCodeOnly || !m_bIsParsed)
     return;
-  }
-  if (!m_IsParsered) {
-    return;
-  }
+
   CFX_FloatRect curRect;
   FX_BOOL flagNewRect = TRUE;
   CPDF_TextObject* pCurObj = NULL;
   int nCount = m_charList.GetSize();
   int pos = 0;
   while (pos < nCount) {
     PAGECHAR_INFO info_curchar = *(PAGECHAR_INFO*)m_charList.GetAt(pos++);
     if (info_curchar.m_Flag == FPDFTEXT_CHAR_GENERATED) {
       continue;
     }
@@ skipping 34 matching lines @@
                                  FX_FLOAT y,
                                  FX_FLOAT xTolerance,
                                  FX_FLOAT yTolerance) const {
   if (m_ParseOptions.m_bGetCharCodeOnly) {
     return -3;
   }
   CPDF_Point point(x, y);
   return GetIndexAtPos(point, xTolerance, yTolerance);
 }
 void CPDF_TextPage::GetCharInfo(int index, FPDF_CHAR_INFO& info) const {
-  if (m_ParseOptions.m_bGetCharCodeOnly) {
+  if (m_ParseOptions.m_bGetCharCodeOnly || !m_bIsParsed)
     return;
-  }
-  if (!m_IsParsered) {
+
+  if (index < 0 || index >= m_charList.GetSize())
     return;
-  }
-  if (index < 0 || index >= m_charList.GetSize()) {
-    return;
-  }
+
   PAGECHAR_INFO charinfo;
   charinfo = *(PAGECHAR_INFO*)m_charList.GetAt(index);
   info.m_Charcode = charinfo.m_CharCode;
   info.m_OriginX = charinfo.m_OriginX;
   info.m_OriginY = charinfo.m_OriginY;
   info.m_Unicode = charinfo.m_Unicode;
   info.m_Flag = charinfo.m_Flag;
   info.m_CharBox = charinfo.m_CharBox;
   info.m_pTextObj = charinfo.m_pTextObj;
   if (charinfo.m_pTextObj && charinfo.m_pTextObj->GetFont()) {
@@ skipping 34 matching lines @@
       if (endIndex >= m_charList.GetSize()) {
         break;
       }
       charinfo3 = *(PAGECHAR_INFO*)m_charList.GetAt(endIndex);
     }
     endIndex--;
     nCount = endIndex - start + 1;
   }
 }
 CFX_WideString CPDF_TextPage::GetPageText(int start, int nCount) const {
-  if (!m_IsParsered || nCount == 0) {
+  if (!m_bIsParsed || nCount == 0)
     return L"";
-  }
-  if (start < 0) {
+
+  if (start < 0)
     start = 0;
-  }
+
   if (nCount == -1) {
     nCount = m_charList.GetSize() - start;
     return m_TextBuf.GetWideString().Mid(start,
                                          m_TextBuf.GetWideString().GetLength());
   }
   if (nCount <= 0 || m_charList.GetSize() <= 0) {
     return L"";
   }
   if (nCount + start > m_charList.GetSize() - 1) {
     nCount = m_charList.GetSize() - start;
@@ skipping 23 matching lines @@
     charinfo =
         *(PAGECHAR_INFO*)m_charList.GetAt(start + nCount - nCountOffset - 1);
   }
   nCount = start + nCount - nCountOffset - startindex;
   if (nCount <= 0) {
     return L"";
   }
   return m_TextBuf.GetWideString().Mid(startindex, nCount);
 }
 int CPDF_TextPage::CountRects(int start, int nCount) {
-  if (m_ParseOptions.m_bGetCharCodeOnly) {
+  if (m_ParseOptions.m_bGetCharCodeOnly || !m_bIsParsed || start < 0)
     return -1;
-  }
-  if (!m_IsParsered) {
-    return -1;
-  }
-  if (start < 0) {
-    return -1;
-  }
+
   if (nCount == -1 || nCount + start > m_charList.GetSize()) {
     nCount = m_charList.GetSize() - start;
   }
   m_SelRects.RemoveAll();
   GetRectArray(start, nCount, m_SelRects);
   return m_SelRects.GetSize();
 }
 void CPDF_TextPage::GetRect(int rectIndex,
                             FX_FLOAT& left,
                             FX_FLOAT& top,
                             FX_FLOAT& right,
                             FX_FLOAT& bottom) const {
-  if (m_ParseOptions.m_bGetCharCodeOnly) {
+  if (m_ParseOptions.m_bGetCharCodeOnly || !m_bIsParsed)
     return;
-  }
-  if (!m_IsParsered || rectIndex < 0 || rectIndex >= m_SelRects.GetSize()) {
+
+  if (rectIndex < 0 || rectIndex >= m_SelRects.GetSize())
     return;
-  }
+
   left = m_SelRects.GetAt(rectIndex).left;
   top = m_SelRects.GetAt(rectIndex).top;
   right = m_SelRects.GetAt(rectIndex).right;
   bottom = m_SelRects.GetAt(rectIndex).bottom;
 }
 FX_BOOL CPDF_TextPage::GetBaselineRotate(int start, int end, int& Rotate) {
   if (m_ParseOptions.m_bGetCharCodeOnly) {
     return FALSE;
   }
   if (end == start) {
@@ skipping 46 matching lines @@
     GetBoundedSegment(n - 1, start, count);
     end = start + count - 1;
     GetBoundedSegment(0, start, count);
   } else {
     GetBoundedSegment(0, start, count);
     end = start + count - 1;
   }
   return GetBaselineRotate(start, end, Rotate);
 }
 FX_BOOL CPDF_TextPage::GetBaselineRotate(int rectIndex, int& Rotate) {
-  if (m_ParseOptions.m_bGetCharCodeOnly) {
+  if (m_ParseOptions.m_bGetCharCodeOnly || !m_bIsParsed)
     return FALSE;
-  }
-  if (!m_IsParsered || rectIndex < 0 || rectIndex > m_SelRects.GetSize()) {
+
+  if (rectIndex < 0 || rectIndex > m_SelRects.GetSize())
     return FALSE;
-  }
+
   CFX_FloatRect rect = m_SelRects.GetAt(rectIndex);
   return GetBaselineRotate(rect, Rotate);
 }
 int CPDF_TextPage::CountBoundedSegments(FX_FLOAT left,
                                         FX_FLOAT top,
                                         FX_FLOAT right,
                                         FX_FLOAT bottom,
                                         FX_BOOL bContains) {
-  if (m_ParseOptions.m_bGetCharCodeOnly) {
+  if (m_ParseOptions.m_bGetCharCodeOnly)
     return -1;
-  }
+
   m_Segment.RemoveAll();
-  if (!m_IsParsered) {
+  if (!m_bIsParsed)
     return -1;
-  }
+
   CFX_FloatRect rect(left, bottom, right, top);
   rect.Normalize();
   int nCount = m_charList.GetSize();
   int pos = 0;
   FPDF_SEGMENT segment;
   segment.m_Start = 0;
   segment.m_nCount = 0;
   int segmentStatus = 0;
   FX_BOOL IsContainPreChar = FALSE;
   while (pos < nCount) {
@@ skipping 59 matching lines @@
   if (m_ParseOptions.m_bGetCharCodeOnly) {
     return;
   }
   if (index < 0 || index >= m_Segment.GetSize()) {
     return;
   }
   start = m_Segment.GetAt(index).m_Start;
   count = m_Segment.GetAt(index).m_nCount;
 }
 int CPDF_TextPage::GetWordBreak(int index, int direction) const {
-  if (m_ParseOptions.m_bGetCharCodeOnly) {
+  if (m_ParseOptions.m_bGetCharCodeOnly || !m_bIsParsed)
     return -1;
-  }
-  if (!m_IsParsered) {
+
+  if (direction != FPDFTEXT_LEFT && direction != FPDFTEXT_RIGHT)
     return -1;
-  }
-  if (direction != FPDFTEXT_LEFT && direction != FPDFTEXT_RIGHT) {
+
+  if (index < 0 || index >= m_charList.GetSize())
     return -1;
-  }
-  if (index < 0 || index >= m_charList.GetSize()) {
-    return -1;
-  }
+
   PAGECHAR_INFO charinfo;
   charinfo = *(PAGECHAR_INFO*)m_charList.GetAt(index);
   if (charinfo.m_Index == -1 || charinfo.m_Flag == FPDFTEXT_CHAR_GENERATED) {
     return index;
   }
   if (!IsLetter(charinfo.m_Unicode)) {
     return index;
   }
   int breakPos = index;
   if (direction == FPDFTEXT_LEFT) {
@@ skipping 1721 matching lines @@
   rects.Copy(m_resArray);
 }
 int CPDF_TextPageFind::GetCurOrder() const {
   return GetCharIndex(m_resStart);
 }
 int CPDF_TextPageFind::GetMatchedCount() const {
   int resStart = GetCharIndex(m_resStart);
   int resEnd = GetCharIndex(m_resEnd);
   return resEnd - resStart + 1;
 }
-CPDF_LinkExtract::CPDF_LinkExtract() : m_pTextPage(NULL), m_IsParserd(FALSE) {}
+
+CPDF_LinkExtract::CPDF_LinkExtract()
+    : m_pTextPage(nullptr), m_bIsParsed(false) {
+}
+
 CPDF_LinkExtract::~CPDF_LinkExtract() {
   DeleteLinkList();
 }
+
 FX_BOOL CPDF_LinkExtract::ExtractLinks(const IPDF_TextPage* pTextPage) {
-  if (!pTextPage || !pTextPage->IsParsed()) {
+  if (!pTextPage || !pTextPage->IsParsed())
     return FALSE;
-  }
+
   m_pTextPage = (const CPDF_TextPage*)pTextPage;
   m_strPageText = m_pTextPage->GetPageText(0, -1);
   DeleteLinkList();
   if (m_strPageText.IsEmpty()) {
     return FALSE;
   }
-  parserLink();
-  m_IsParserd = TRUE;
+  ParseLink();
+  m_bIsParsed = true;
   return TRUE;
 }
+
 void CPDF_LinkExtract::DeleteLinkList() {
   while (m_LinkList.GetSize()) {
     CPDF_LinkExt* linkinfo = NULL;
     linkinfo = m_LinkList.GetAt(0);
     m_LinkList.RemoveAt(0);
     delete linkinfo;
   }
   m_LinkList.RemoveAll();
 }
 int CPDF_LinkExtract::CountLinks() const {
-  if (!m_IsParserd) {
+  if (!m_bIsParsed) {
     return -1;
   }
   return m_LinkList.GetSize();
 }
-void CPDF_LinkExtract::parserLink() {
+void CPDF_LinkExtract::ParseLink() {
   int start = 0, pos = 0;
   int TotalChar = m_pTextPage->CountChars();
   while (pos < TotalChar) {
     FPDF_CHAR_INFO pageChar;
     m_pTextPage->GetCharInfo(pos, pageChar);
     if (pageChar.m_Flag == CHAR_GENERATED || pageChar.m_Unicode == 0x20 ||
         pos == TotalChar - 1) {
       int nCount = pos - start;
       if (pos == TotalChar - 1) {
         nCount++;
@@ skipping 131 matching lines @@
                                         int count,
                                         const CFX_WideString& strUrl) {
   CPDF_LinkExt* linkInfo = new CPDF_LinkExt;
   linkInfo->m_strUrl = strUrl;
   linkInfo->m_Start = start;
   linkInfo->m_Count = count;
   m_LinkList.Add(linkInfo);
 }
 
 CFX_WideString CPDF_LinkExtract::GetURL(int index) const {
-  if (!m_IsParserd || index < 0 || index >= m_LinkList.GetSize()) {
+  if (!m_bIsParsed || index < 0 || index >= m_LinkList.GetSize()) {
     return L"";
   }
   CPDF_LinkExt* link = NULL;
   link = m_LinkList.GetAt(index);
   if (!link) {
     return L"";
   }
   return link->m_strUrl;
 }
 void CPDF_LinkExtract::GetBoundedSegment(int index,
                                          int& start,
                                          int& count) const {
-  if (!m_IsParserd || index < 0 || index >= m_LinkList.GetSize()) {
+  if (!m_bIsParsed || index < 0 || index >= m_LinkList.GetSize()) {
     return;
   }
   CPDF_LinkExt* link = NULL;
   link = m_LinkList.GetAt(index);
   if (!link) {
     return;
   }
   start = link->m_Start;
   count = link->m_Count;
 }
 void CPDF_LinkExtract::GetRects(int index, CFX_RectArray& rects) const {
-  if (!m_IsParserd || index < 0 || index >= m_LinkList.GetSize()) {
+  if (!m_bIsParsed || index < 0 || index >= m_LinkList.GetSize()) {
     return;
   }
   CPDF_LinkExt* link = NULL;
   link = m_LinkList.GetAt(index);
   if (!link) {
     return;
   }
   m_pTextPage->GetRectArray(link->m_Start, link->m_Count, rects);
 }