Merge to XFA: CPDFText_ParseOptions never change from default.

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 <algorithm>
 #include <cctype>
 #include <cwctype>
 #include <memory>
@@ skipping 63 matching lines @@
       baseSpace = 0.0;
     }
   }
   return baseSpace;
 }
 
 const FX_FLOAT kDefaultFontSize = 1.0f;
 
 }  // namespace
 
-CPDFText_ParseOptions::CPDFText_ParseOptions()
-    : m_bGetCharCodeOnly(FALSE),
-      m_bNormalizeObjs(TRUE),
-      m_bOutputHyphen(FALSE) {}
-
 IPDF_TextPage* IPDF_TextPage::CreateTextPage(const CPDF_Page* pPage,
                                              int flags) {
   return new CPDF_TextPage(pPage, flags);
 }
 
 IPDF_TextPageFind* IPDF_TextPageFind::CreatePageFind(
     const IPDF_TextPage* pTextPage) {
   return pTextPage ? new CPDF_TextPageFind(pTextPage) : nullptr;
 }
 
@@ skipping 17 matching lines @@
       m_parserflag(flags),
       m_pPreTextObj(nullptr),
       m_bIsParsed(false),
       m_TextlineDir(-1),
       m_CurlineRect(0, 0, 0, 0) {
   m_TextBuf.EstimateSize(0, 10240);
   pPage->GetDisplayMatrix(m_DisplayMatrix, 0, 0, (int)pPage->GetPageWidth(),
                           (int)pPage->GetPageHeight(), 0);
 }
 
-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() {
   m_bIsParsed = false;
   if (!m_pPage)
     return FALSE;
 
   m_TextBuf.Clear();
   m_charList.RemoveAll();
   m_pPreTextObj = NULL;
   ProcessObject();
   m_bIsParsed = true;
-  if (!m_ParseOptions.m_bGetCharCodeOnly) {
-    m_CharIndex.RemoveAll();
-    int nCount = m_charList.GetSize();
-    if (nCount) {
-      m_CharIndex.Add(0);
+  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);
+    if (charinfo.m_Flag == FPDFTEXT_CHAR_GENERATED) {
+      bNormal = TRUE;
+    } else if (charinfo.m_Unicode == 0 || IsControlChar(charinfo)) {
+      bNormal = FALSE;
+    } else {
+      bNormal = TRUE;
     }
-    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);
-      if (charinfo.m_Flag == FPDFTEXT_CHAR_GENERATED) {
-        bNormal = TRUE;
-      } else if (charinfo.m_Unicode == 0 || IsControlChar(charinfo)) {
-        bNormal = FALSE;
+    if (bNormal) {
+      if (indexSize % 2) {
+        m_CharIndex.Add(1);
       } else {
-        bNormal = TRUE;
+        if (indexSize <= 0) {
+          continue;
+        }
+        m_CharIndex.SetAt(indexSize - 1, m_CharIndex.GetAt(indexSize - 1) + 1);
       }
-      if (bNormal) {
-        if (indexSize % 2) {
-          m_CharIndex.Add(1);
-        } else {
-          if (indexSize <= 0) {
-            continue;
-          }
-          m_CharIndex.SetAt(indexSize - 1,
-                            m_CharIndex.GetAt(indexSize - 1) + 1);
+    } else {
+      if (indexSize % 2) {
+        if (indexSize <= 0) {
+          continue;
         }
+        m_CharIndex.SetAt(indexSize - 1, i + 1);
       } else {
-        if (indexSize % 2) {
-          if (indexSize <= 0) {
-            continue;
-          }
-          m_CharIndex.SetAt(indexSize - 1, i + 1);
-        } else {
-          m_CharIndex.Add(i + 1);
-        }
+        m_CharIndex.Add(i + 1);
       }
     }
-    int indexSize = m_CharIndex.GetSize();
-    if (indexSize % 2) {
-      m_CharIndex.RemoveAt(indexSize - 1);
-    }
+  }
+  int indexSize = m_CharIndex.GetSize();
+  if (indexSize % 2) {
+    m_CharIndex.RemoveAt(indexSize - 1);
   }
   return TRUE;
 }
 int CPDF_TextPage::CountChars() const {
-  if (m_ParseOptions.m_bGetCharCodeOnly) {
-    return m_TextBuf.GetSize();
-  }
   return m_charList.GetSize();
 }
 int CPDF_TextPage::CharIndexFromTextIndex(int TextIndex) const {
   int indexSize = m_CharIndex.GetSize();
   int count = 0;
   for (int i = 0; i < indexSize; i += 2) {
     count += m_CharIndex.GetAt(i + 1);
     if (count > TextIndex) {
       return TextIndex - count + m_CharIndex.GetAt(i + 1) +
              m_CharIndex.GetAt(i);
@@ skipping 12 matching lines @@
       }
       return CharIndex - m_CharIndex.GetAt(i) + count -
              m_CharIndex.GetAt(i + 1);
     }
   }
   return -1;
 }
 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_bIsParsed) {
     return;
   }
   PAGECHAR_INFO info_curchar;
   CPDF_TextObject* pCurObj = NULL;
   CFX_FloatRect rect;
   int curPos = start;
@@ skipping 66 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 || !m_bIsParsed)
+  if (!m_bIsParsed)
     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;
@@ skipping 24 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_bIsParsed)
+  if (!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)) {
@@ skipping 17 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 || !m_bIsParsed)
+  if (!m_bIsParsed)
     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) {
@@ skipping 29 matching lines @@
       }
     }
   }
   resRectArray.Add(curRect);
   return;
 }
 int CPDF_TextPage::GetIndexAtPos(FX_FLOAT x,
                                  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 || !m_bIsParsed)
+  if (!m_bIsParsed)
     return;
 
   if (index < 0 || index >= m_charList.GetSize())
     return;
 
   const PAGECHAR_INFO* charinfo =
       static_cast<PAGECHAR_INFO*>(m_charList.GetAt(index));
   info->m_Charcode = charinfo->m_CharCode;
   info->m_OriginX = charinfo->m_OriginX;
   info->m_OriginY = charinfo->m_OriginY;
@@ skipping 90 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 || !m_bIsParsed || start < 0)
+  if (!m_bIsParsed || 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 || !m_bIsParsed)
+  if (!m_bIsParsed)
     return;
 
   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) {
     return FALSE;
   }
   FPDF_CHAR_INFO info_start;
   FPDF_CHAR_INFO info_end;
   GetCharInfo(start, &info_start);
   GetCharInfo(end, &info_end);
   while (info_end.m_CharBox.Width() == 0 || info_end.m_CharBox.Height() == 0) {
     if (--end <= start)
       return FALSE;
@@ skipping 17 matching lines @@
   if (Rotate < 0) {
     Rotate = -Rotate;
   } else if (Rotate > 0) {
     Rotate = 360 - Rotate;
   }
   return TRUE;
 }
 
 FX_BOOL CPDF_TextPage::GetBaselineRotate(const CFX_FloatRect& rect,
                                          int& Rotate) {
-  if (m_ParseOptions.m_bGetCharCodeOnly) {
-    return FALSE;
-  }
   int start, end, count,
       n = CountBoundedSegments(rect.left, rect.top, rect.right, rect.bottom,
                                TRUE);
   if (n < 1) {
     return FALSE;
   }
   if (n > 1) {
     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 || !m_bIsParsed)
+  if (!m_bIsParsed)
     return FALSE;
 
-  if (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)
-    return -1;
-
   m_Segment.RemoveAll();
   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;
@@ skipping 53 matching lines @@
   }
   if (segmentStatus == 1) {
     segmentStatus = 2;
     m_Segment.Add(segment);
     segment.m_Start = 0;
     segment.m_nCount = 0;
   }
   return m_Segment.GetSize();
 }
 void CPDF_TextPage::GetBoundedSegment(int index, int& start, int& count) const {
-  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 || !m_bIsParsed)
+  if (!m_bIsParsed)
     return -1;
 
   if (direction != FPDFTEXT_LEFT && direction != FPDFTEXT_RIGHT)
     return -1;
 
   if (index < 0 || index >= m_charList.GetSize())
     return -1;
 
   PAGECHAR_INFO charinfo;
   charinfo = *(PAGECHAR_INFO*)m_charList.GetAt(index);
@@ skipping 225 matching lines @@
       FX_WCHAR* pDst = NULL;
       FX_STRSIZE nCount = FX_Unicode_GetNormalization(wChar, pDst);
       if (nCount >= 1) {
         pDst = FX_Alloc(FX_WCHAR, nCount);
         FX_Unicode_GetNormalization(wChar, pDst);
         for (int nIndex = 0; nIndex < nCount; nIndex++) {
           PAGECHAR_INFO Info2 = Info;
           Info2.m_Unicode = pDst[nIndex];
           Info2.m_Flag = FPDFTEXT_CHAR_PIECE;
           m_TextBuf.AppendChar(Info2.m_Unicode);
-          if (!m_ParseOptions.m_bGetCharCodeOnly) {
-            m_charList.Add(Info2);
-          }
+          m_charList.Add(Info2);
         }
         FX_Free(pDst);
         return;
       }
     }
     m_TextBuf.AppendChar(wChar);
   } else {
     Info.m_Index = -1;
   }
-  if (!m_ParseOptions.m_bGetCharCodeOnly) {
-    m_charList.Add(Info);
-  }
+  m_charList.Add(Info);
 }
 void CPDF_TextPage::AddCharInfoByRLDirection(CFX_WideString& str, int i) {
   PAGECHAR_INFO Info = *(PAGECHAR_INFO*)m_TempCharList.GetAt(i);
   if (!IsControlChar(Info)) {
     Info.m_Index = m_TextBuf.GetLength();
     FX_WCHAR wChar = FX_GetMirrorChar(str.GetAt(i), TRUE, FALSE);
     FX_WCHAR* pDst = NULL;
     FX_STRSIZE nCount = FX_Unicode_GetNormalization(wChar, pDst);
     if (nCount >= 1) {
       pDst = FX_Alloc(FX_WCHAR, nCount);
       FX_Unicode_GetNormalization(wChar, pDst);
       for (int nIndex = 0; nIndex < nCount; nIndex++) {
         PAGECHAR_INFO Info2 = Info;
         Info2.m_Unicode = pDst[nIndex];
         Info2.m_Flag = FPDFTEXT_CHAR_PIECE;
         m_TextBuf.AppendChar(Info2.m_Unicode);
-        if (!m_ParseOptions.m_bGetCharCodeOnly) {
-          m_charList.Add(Info2);
-        }
+        m_charList.Add(Info2);
       }
       FX_Free(pDst);
       return;
     }
     Info.m_Unicode = wChar;
     m_TextBuf.AppendChar(Info.m_Unicode);
   } else {
     Info.m_Index = -1;
   }
-  if (!m_ParseOptions.m_bGetCharCodeOnly) {
-    m_charList.Add(Info);
-  }
+  m_charList.Add(Info);
 }
 void CPDF_TextPage::CloseTempLine() {
   int count1 = m_TempCharList.GetSize();
   if (count1 <= 0) {
     return;
   }
   std::unique_ptr<CFX_BidiChar> pBidiChar(new CFX_BidiChar);
   CFX_WideString str = m_TempTextBuf.GetWideString();
   CFX_WordArray order;
   FX_BOOL bR2L = FALSE;
@@ skipping 178 matching lines @@
   m_DisplayMatrix.Transform(this_x, this_y);
   if (FXSYS_fabs(this_y - prev_y) > threshold * 2) {
     for (int i = 0; i < count; i++) {
       ProcessTextObject(m_LineObj.GetAt(i));
     }
     m_LineObj.RemoveAll();
     m_LineObj.Add(Obj);
     return;
   }
   int i = 0;
-  if (m_ParseOptions.m_bNormalizeObjs) {
-    for (i = count - 1; i >= 0; i--) {
-      PDFTEXT_Obj prev_Obj = m_LineObj.GetAt(i);
-      CFX_Matrix prev_matrix;
-      prev_Obj.m_pTextObj->GetTextMatrix(&prev_matrix);
-      FX_FLOAT Prev_x = prev_Obj.m_pTextObj->GetPosX(),
-               Prev_y = prev_Obj.m_pTextObj->GetPosY();
-      prev_Obj.m_formMatrix.Transform(Prev_x, Prev_y);
-      m_DisplayMatrix.Transform(Prev_x, Prev_y);
-      if (this_x >= Prev_x) {
-        if (i == count - 1) {
-          m_LineObj.Add(Obj);
-        } else {
-          m_LineObj.InsertAt(i + 1, Obj);
-        }
-        break;
+  for (i = count - 1; i >= 0; i--) {
+    PDFTEXT_Obj prev_Obj = m_LineObj.GetAt(i);
+    CFX_Matrix prev_matrix;
+    prev_Obj.m_pTextObj->GetTextMatrix(&prev_matrix);
+    FX_FLOAT Prev_x = prev_Obj.m_pTextObj->GetPosX(),
+             Prev_y = prev_Obj.m_pTextObj->GetPosY();
+    prev_Obj.m_formMatrix.Transform(Prev_x, Prev_y);
+    m_DisplayMatrix.Transform(Prev_x, Prev_y);
+    if (this_x >= Prev_x) {
+      if (i == count - 1) {
+        m_LineObj.Add(Obj);
+      } else {
+        m_LineObj.InsertAt(i + 1, Obj);
       }
+      break;
     }
-    if (i < 0) {
-      m_LineObj.InsertAt(0, Obj);
-    }
-  } else {
-    m_LineObj.Add(Obj);
+  }
+  if (i < 0) {
+    m_LineObj.InsertAt(0, Obj);
   }
 }
+
 int32_t CPDF_TextPage::PreMarkedContent(PDFTEXT_Obj Obj) {
   CPDF_TextObject* pTextObj = Obj.m_pTextObj;
   CPDF_ContentMarkData* pMarkData =
       (CPDF_ContentMarkData*)pTextObj->m_ContentMark.GetObject();
   if (!pMarkData) {
     return FPDFTEXT_MC_PASS;
   }
   int nContentMark = pMarkData->CountItems();
   if (nContentMark < 1) {
     return FPDFTEXT_MC_PASS;
@@ skipping 228 matching lines @@
       if (GenerateCharInfo(TEXT_BLANK_CHAR, generateChar)) {
         if (!formMatrix.IsIdentity()) {
           generateChar.m_Matrix.Copy(formMatrix);
         }
         m_TempTextBuf.AppendChar(TEXT_BLANK_CHAR);
         m_TempCharList.Add(generateChar);
       }
     } else if (result == 2) {
       CloseTempLine();
       if (m_TextBuf.GetSize()) {
-        if (m_ParseOptions.m_bGetCharCodeOnly) {
+        if (GenerateCharInfo(TEXT_RETURN_CHAR, generateChar)) {
           m_TextBuf.AppendChar(TEXT_RETURN_CHAR);
+          if (!formMatrix.IsIdentity()) {
+            generateChar.m_Matrix.Copy(formMatrix);
+          }
+          m_charList.Add(generateChar);
+        }
+        if (GenerateCharInfo(TEXT_LINEFEED_CHAR, generateChar)) {
           m_TextBuf.AppendChar(TEXT_LINEFEED_CHAR);
-        } else {
-          if (GenerateCharInfo(TEXT_RETURN_CHAR, generateChar)) {
-            m_TextBuf.AppendChar(TEXT_RETURN_CHAR);
-            if (!formMatrix.IsIdentity()) {
-              generateChar.m_Matrix.Copy(formMatrix);
-            }
-            m_charList.Add(generateChar);
+          if (!formMatrix.IsIdentity()) {
+            generateChar.m_Matrix.Copy(formMatrix);
           }
-          if (GenerateCharInfo(TEXT_LINEFEED_CHAR, generateChar)) {
-            m_TextBuf.AppendChar(TEXT_LINEFEED_CHAR);
-            if (!formMatrix.IsIdentity()) {
-              generateChar.m_Matrix.Copy(formMatrix);
-            }
-            m_charList.Add(generateChar);
-          }
+          m_charList.Add(generateChar);
         }
       }
-    } else if (result == 3 && !m_ParseOptions.m_bOutputHyphen) {
+    } else if (result == 3) {
       int32_t nChars = pTextObj->CountChars();
       if (nChars == 1) {
         CPDF_TextObjectItem item;
         pTextObj->GetCharInfo(0, &item);
         CFX_WideString wstrItem =
             pTextObj->GetFont()->UnicodeFromCharCode(item.m_CharCode);
         if (wstrItem.IsEmpty()) {
           wstrItem += (FX_WCHAR)item.m_CharCode;
         }
         FX_WCHAR curChar = wstrItem.GetAt(0);
@@ skipping 420 matching lines @@
 }
 FX_BOOL CPDF_TextPage::IsSameTextObject(CPDF_TextObject* pTextObj1,
                                         CPDF_TextObject* pTextObj2) {
   if (!pTextObj1 || !pTextObj2) {
     return FALSE;
   }
   CFX_FloatRect rcPreObj(pTextObj2->m_Left, pTextObj2->m_Bottom,
                          pTextObj2->m_Right, pTextObj2->m_Top);
   CFX_FloatRect rcCurObj(pTextObj1->m_Left, pTextObj1->m_Bottom,
                          pTextObj1->m_Right, pTextObj1->m_Top);
-  if (rcPreObj.IsEmpty() && rcCurObj.IsEmpty() &&
-      !m_ParseOptions.m_bGetCharCodeOnly) {
+  if (rcPreObj.IsEmpty() && rcCurObj.IsEmpty()) {
     FX_FLOAT dbXdif = FXSYS_fabs(rcPreObj.left - rcCurObj.left);
     int nCount = m_charList.GetSize();
     if (nCount >= 2) {
       PAGECHAR_INFO perCharTemp = (PAGECHAR_INFO)m_charList[nCount - 2];
       FX_FLOAT dbSpace = perCharTemp.m_CharBox.Width();
       if (dbXdif > dbSpace) {
         return FALSE;
       }
     }
   }
@@ skipping 718 matching lines @@
   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);
 }