Merge to XFA: Use stdint.h types throughout PDFium.

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 "../../include/fpdfapi/fpdf_resource.h"
 #include "../../include/fpdfapi/fpdf_pageobj.h"
 #include "../../include/fpdftext/fpdf_text.h"
 #include "../../include/fpdfapi/fpdf_page.h"
@@ skipping 634 matching lines @@
     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()) {
         info.m_FontSize = charinfo.m_pTextObj->GetFontSize();
     }
     info.m_Matrix.Copy(charinfo.m_Matrix);
     return;
 }
-void CPDF_TextPage::CheckMarkedContentObject(FX_INT32& start, FX_INT32& nCount) const
+void CPDF_TextPage::CheckMarkedContentObject(int32_t& start, int32_t& nCount) const
 {
     PAGECHAR_INFO charinfo = *(PAGECHAR_INFO*)m_charList.GetAt(start);
     PAGECHAR_INFO charinfo2 = *(PAGECHAR_INFO*)m_charList.GetAt(start + nCount - 1);
     if (FPDFTEXT_CHAR_PIECE != charinfo.m_Flag && FPDFTEXT_CHAR_PIECE != charinfo2.m_Flag) {
         return;
     }
     if (FPDFTEXT_CHAR_PIECE == charinfo.m_Flag) {
         PAGECHAR_INFO charinfo1 = charinfo;
         int startIndex = start;
         while(FPDFTEXT_CHAR_PIECE == charinfo1.m_Flag && charinfo1.m_Index == charinfo.m_Index) {
@@ skipping 290 matching lines @@
         while (++breakPos < m_charList.GetSize()) {
             charinfo = *(PAGECHAR_INFO*)m_charList.GetAt(breakPos);
             if (!IsLetter(charinfo.m_Unicode)) {
                 return breakPos;
             }
         }
         return breakPos;
     }
     return breakPos;
 }
-FX_INT32 CPDF_TextPage::FindTextlineFlowDirection()
+int32_t CPDF_TextPage::FindTextlineFlowDirection()
 {
     if (!m_pPage)       {
         return -1;
     }
-    const FX_INT32 nPageWidth = (FX_INT32)((CPDF_Page*)m_pPage)->GetPageWidth();
-    const FX_INT32 nPageHeight = (FX_INT32)((CPDF_Page*)m_pPage)->GetPageHeight();
+    const int32_t nPageWidth = (int32_t)((CPDF_Page*)m_pPage)->GetPageWidth();
+    const int32_t nPageHeight = (int32_t)((CPDF_Page*)m_pPage)->GetPageHeight();
     CFX_ByteArray nHorizontalMask;
     if (!nHorizontalMask.SetSize(nPageWidth)) {
         return -1;
     }
-    FX_BYTE* pDataH = nHorizontalMask.GetData();
+    uint8_t* pDataH = nHorizontalMask.GetData();
     CFX_ByteArray nVerticalMask;
     if (!nVerticalMask.SetSize(nPageHeight)) {
         return -1;
     }
-    FX_BYTE* pDataV = nVerticalMask.GetData();
-    FX_INT32 index = 0;
+    uint8_t* pDataV = nVerticalMask.GetData();
+    int32_t index = 0;
     FX_FLOAT fLineHeight = 0.0f;
     CPDF_PageObject* pPageObj = NULL;
     FX_POSITION pos = NULL;
     pos = m_pPage->GetFirstObjectPosition();
     if(!pos) {
         return -1;
     }
     while(pos) {
         pPageObj = m_pPage->GetNextObject(pos);
         if(NULL == pPageObj) {
             continue;
         }
         if(PDFPAGE_TEXT != pPageObj->m_Type) {
             continue;
         }
-        FX_INT32 minH = (FX_INT32)pPageObj->m_Left < 0 ? 0 : (FX_INT32)pPageObj->m_Left;
-        FX_INT32 maxH = (FX_INT32)pPageObj->m_Right > nPageWidth ? nPageWidth : (FX_INT32)pPageObj->m_Right;
-        FX_INT32 minV = (FX_INT32)pPageObj->m_Bottom < 0 ? 0 : (FX_INT32)pPageObj->m_Bottom;
-        FX_INT32 maxV = (FX_INT32)pPageObj->m_Top > nPageHeight ? nPageHeight : (FX_INT32)pPageObj->m_Top;
+        int32_t minH = (int32_t)pPageObj->m_Left < 0 ? 0 : (int32_t)pPageObj->m_Left;
+        int32_t maxH = (int32_t)pPageObj->m_Right > nPageWidth ? nPageWidth : (int32_t)pPageObj->m_Right;
+        int32_t minV = (int32_t)pPageObj->m_Bottom < 0 ? 0 : (int32_t)pPageObj->m_Bottom;
+        int32_t maxV = (int32_t)pPageObj->m_Top > nPageHeight ? nPageHeight : (int32_t)pPageObj->m_Top;
         if (minH >= maxH || minV >= maxV) {
             continue;
         }
         FXSYS_memset8(pDataH + minH, 1, maxH - minH);
         FXSYS_memset8(pDataV + minV, 1, maxV - minV);
         if (fLineHeight <= 0.0f) {
             fLineHeight = pPageObj->m_Top - pPageObj->m_Bottom;
         }
         pPageObj = NULL;
     }
-    FX_INT32 nStartH = 0;
-    FX_INT32 nEndH = 0;
+    int32_t nStartH = 0;
+    int32_t nEndH = 0;
     FX_FLOAT nSumH = 0.0f;
     for (index = 0; index < nPageWidth; index++)
         if(1 == nHorizontalMask[index]) {
             break;
         }
     nStartH = index;
     for (index = nPageWidth; index > 0; index--)
         if(1 == nHorizontalMask[index - 1]) {
             break;
         }
     nEndH = index;
     for (index = nStartH; index < nEndH; index++) {
         nSumH += nHorizontalMask[index];
     }
     nSumH /= nEndH - nStartH;
-    FX_INT32 nStartV = 0;
-    FX_INT32 nEndV = 0;
+    int32_t nStartV = 0;
+    int32_t nEndV = 0;
     FX_FLOAT nSumV = 0.0f;
     for (index = 0; index < nPageHeight; index++)
         if(1 == nVerticalMask[index]) {
             break;
         }
     nStartV = index;
     for (index = nPageHeight; index > 0; index--)
         if(1 == nVerticalMask[index - 1]) {
             break;
         }
     nEndV = index;
     for (index = nStartV; index < nEndV; index++) {
         nSumV += nVerticalMask[index];
     }
     nSumV /= nEndV - nStartV;
-    if ((nEndV - nStartV) < (FX_INT32)(2 * fLineHeight)) {
+    if ((nEndV - nStartV) < (int32_t)(2 * fLineHeight)) {
         return 0;
     }
-    if ((nEndH - nStartH) < (FX_INT32)(2 * fLineHeight)) {
+    if ((nEndH - nStartH) < (int32_t)(2 * fLineHeight)) {
         return 1;
     }
     if (nSumH > 0.8f) {
         return 0;
     }
     if (nSumH - nSumV > 0.0f) {
         return 0;
     }
     if (nSumV - nSumH > 0.0f) {
         return 1;
@@ skipping 73 matching lines @@
         if(w == 0) {
             FX_RECT BBox;
             pFont->GetCharBBox(charCode, BBox);
             w = BBox.right - BBox.left;
         }
     }
     return w;
 }
 void CPDF_TextPage::OnPiece(IFX_BidiChar* pBidi, CFX_WideString& str)
 {
-    FX_INT32 start, count;
-    FX_INT32 ret = pBidi->GetBidiInfo(start, count);
+    int32_t start, count;
+    int32_t ret = pBidi->GetBidiInfo(start, count);
     if(ret == 2) {
         for(int i = start + count - 1; i >= start; i--) {
             m_TextBuf.AppendChar(str.GetAt(i));
             m_charList.Add(*(PAGECHAR_INFO*)m_TempCharList.GetAt(i));
         }
     } else {
         int end = start + count ;
         for(int i = start; i < end; i++) {
             m_TextBuf.AppendChar(str.GetAt(i));
             m_charList.Add(*(PAGECHAR_INFO*)m_TempCharList.GetAt(i));
@@ skipping 69 matching lines @@
 void CPDF_TextPage::CloseTempLine()
 {
     int count1 = m_TempCharList.GetSize();
     if (count1 <= 0) {
         return;
     }
     IFX_BidiChar* BidiChar = IFX_BidiChar::Create();
     CFX_WideString str = m_TempTextBuf.GetWideString();
     CFX_WordArray order;
     FX_BOOL bR2L = FALSE;
-    FX_INT32 start = 0, count = 0;
+    int32_t start = 0, count = 0;
     int nR2L = 0, nL2R = 0;
     FX_BOOL bPrevSpace = FALSE;
     for (int i = 0; i < str.GetLength(); i++) {
         if(str.GetAt(i) == 32) {
             if(bPrevSpace) {
                 m_TempTextBuf.Delete(i, 1);
                 m_TempCharList.Delete(i);
                 str.Delete(i);
                 count1--;
                 i--;
                 continue;
             }
             bPrevSpace = TRUE;
         } else {
             bPrevSpace = FALSE;
         }
         if(BidiChar && BidiChar->AppendChar(str.GetAt(i))) {
-            FX_INT32 ret = BidiChar->GetBidiInfo(start, count);
+            int32_t ret = BidiChar->GetBidiInfo(start, count);
             order.Add(start);
             order.Add(count);
             order.Add(ret);
             if(!bR2L) {
                 if(ret == 2) {
                     nR2L++;
                 } else if (ret == 1) {
                     nL2R++;
                 }
             }
         }
     }
     if(BidiChar && BidiChar->EndChar()) {
-        FX_INT32 ret = BidiChar->GetBidiInfo(start, count);
+        int32_t ret = BidiChar->GetBidiInfo(start, count);
         order.Add(start);
         order.Add(count);
         order.Add(ret);
         if(!bR2L) {
             if(ret == 2) {
                 nR2L++;
             } else if(ret == 1) {
                 nL2R++;
             }
         }
@@ skipping 153 matching lines @@
                 break;
             }
         }
         if(i < 0) {
             m_LineObj.InsertAt(0, Obj);
         }
     } else {
         m_LineObj.Add(Obj);
     }
 }
-FX_INT32 CPDF_TextPage::PreMarkedContent(PDFTEXT_Obj 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 139 matching lines @@
 {
     CPDF_TextObject* pTextObj = Obj.m_pTextObj;
     if(FXSYS_fabs(pTextObj->m_Right - pTextObj->m_Left) < 0.01f ) {
         return;
     }
     CFX_AffineMatrix formMatrix = Obj.m_formMatrix;
     CPDF_Font*  pFont = pTextObj->GetFont();
     CFX_AffineMatrix matrix;
     pTextObj->GetTextMatrix(&matrix);
     matrix.Concat(formMatrix);
-    FX_INT32 bPreMKC = PreMarkedContent(Obj);
+    int32_t bPreMKC = PreMarkedContent(Obj);
     if (FPDFTEXT_MC_DONE == bPreMKC) {
         m_pPreTextObj = pTextObj;
         m_perMatrix.Copy(formMatrix);
         return;
     }
     int result = 0;
     if (m_pPreTextObj) {
         result = ProcessInsertObject(pTextObj, formMatrix);
         if (2 == result) {
             m_CurlineRect = CFX_FloatRect(Obj.m_pTextObj->m_Left, Obj.m_pTextObj->m_Bottom, Obj.m_pTextObj->m_Right, Obj.m_pTextObj->m_Top);
@@ skipping 26 matching lines @@
                     if(GenerateCharInfo(TEXT_LINEFEED_CHAR, generateChar)) {
                         m_TextBuf.AppendChar(TEXT_LINEFEED_CHAR);
                         if (!formMatrix.IsIdentity()) {
                             generateChar.m_Matrix.Copy(formMatrix);
                         }
                         m_charList.Add(generateChar);
                     }
                 }
             }
         } else if (result == 3 && !m_ParseOptions.m_bOutputHyphen) {
-            FX_INT32 nChars = pTextObj->CountChars();
+            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);
                 if (0x2D == curChar || 0xAD == curChar) {
                     return;
@@ skipping 18 matching lines @@
         m_perMatrix.Copy(formMatrix);
         return;
     }
     m_pPreTextObj = pTextObj;
     m_perMatrix.Copy(formMatrix);
     int nItems = pTextObj->CountItems();
     FX_FLOAT baseSpace = _CalculateBaseSpace(pTextObj, matrix);
 
     FX_BOOL bIsBidiAndMirrosInverse = FALSE;
     IFX_BidiChar* BidiChar = IFX_BidiChar::Create();
-    FX_INT32 nR2L = 0;
-    FX_INT32 nL2R = 0;
-    FX_INT32 start = 0, count = 0;
+    int32_t nR2L = 0;
+    int32_t nL2R = 0;
+    int32_t start = 0, count = 0;
     CPDF_TextObjectItem item;
-    for (FX_INT32 i = 0; i < nItems; i++) {
+    for (int32_t i = 0; i < nItems; i++) {
         pTextObj->GetItemInfo(i, &item);
         if (item.m_CharCode == (FX_DWORD)-1) {
             continue;
         }
         CFX_WideString wstrItem = pFont->UnicodeFromCharCode(item.m_CharCode);
         FX_WCHAR wChar = wstrItem.GetAt(0);
         if ((wstrItem.IsEmpty() || wChar == 0) && item.m_CharCode) {
             wChar = (FX_WCHAR)item.m_CharCode;
         }
         if (!wChar) {
             continue;
         }
         if (BidiChar && BidiChar->AppendChar(wChar)) {
-            FX_INT32 ret = BidiChar->GetBidiInfo(start, count);
+            int32_t ret = BidiChar->GetBidiInfo(start, count);
             if (ret == 2) {
                 nR2L++;
             }
             else if (ret == 1) {
                 nL2R++;
             }
         }
     }
     if (BidiChar && BidiChar->EndChar()) {
-        FX_INT32 ret = BidiChar->GetBidiInfo(start, count);
+        int32_t ret = BidiChar->GetBidiInfo(start, count);
         if (ret == 2) {
             nR2L++;
         }
         else if (ret == 1) {
             nL2R++;
         }
     }
     FX_BOOL bR2L = FALSE;
     if (nR2L > 0 && nR2L >= nL2R) {
         bR2L = TRUE;
     }
     bIsBidiAndMirrosInverse = bR2L && (matrix.a * matrix.d - matrix.b * matrix.c) < 0;
-    FX_INT32 iBufStartAppend = m_TempTextBuf.GetLength();
-    FX_INT32 iCharListStartAppend = m_TempCharList.GetSize();
+    int32_t iBufStartAppend = m_TempTextBuf.GetLength();
+    int32_t iCharListStartAppend = m_TempCharList.GetSize();
 
     FX_FLOAT spacing = 0;
     for (int i = 0; i < nItems; i++) {
         CPDF_TextObjectItem item;
         PAGECHAR_INFO charinfo;
         charinfo.m_OriginX = 0;
         charinfo.m_OriginY = 0;
         pTextObj->GetItemInfo(i, &item);
         if (item.m_CharCode == (FX_DWORD) - 1) {
             CFX_WideString str = m_TempTextBuf.GetWideString();
@@ skipping 123 matching lines @@
             } else if(i == 0) {
                 CFX_WideString str = m_TempTextBuf.GetWideString();
                 if (!str.IsEmpty() && str.GetAt(str.GetLength() - 1) == TEXT_BLANK_CHAR) {
                     m_TempTextBuf.Delete(m_TempTextBuf.GetLength() - 1, 1);
                     m_TempCharList.Delete(m_TempCharList.GetSize() - 1);
                 }
             }
         }
     }
     if (bIsBidiAndMirrosInverse) {
-        FX_INT32 i, j;
+        int32_t i, j;
         i = iCharListStartAppend;
         j = m_TempCharList.GetSize() - 1;
         for (; i < j; i++, j--) {
             std::swap(m_TempCharList[i], m_TempCharList[j]);
             std::swap(m_TempCharList[i].m_Index, m_TempCharList[j].m_Index);
         }
         FX_WCHAR * pTempBuffer = m_TempTextBuf.GetBuffer();
         i = iBufStartAppend;
         j = m_TempTextBuf.GetLength() - 1;
         for (; i < j; i++, j--) {
             std::swap(pTempBuffer[i], pTempBuffer[j]);
         }
     }
 }
-FX_INT32 CPDF_TextPage::GetTextObjectWritingMode(const CPDF_TextObject* pTextObj)
+int32_t CPDF_TextPage::GetTextObjectWritingMode(const CPDF_TextObject* pTextObj)
 {
-    FX_INT32 nChars = pTextObj->CountChars();
+    int32_t nChars = pTextObj->CountChars();
     if (nChars == 1) {
         return m_TextlineDir;
     }
     CPDF_TextObjectItem first, last;
     pTextObj->GetCharInfo(0, &first);
     pTextObj->GetCharInfo(nChars - 1, &last);
     CFX_Matrix textMatrix;
     pTextObj->GetTextMatrix(&textMatrix);
     textMatrix.TransformPoint(first.m_OriginX, first.m_OriginY);
     textMatrix.TransformPoint(last.m_OriginX, last.m_OriginY);
@@ skipping 143 matching lines @@
                 }
             }
         }
     }
     if(bNewline) {
         if(IsHyphen(curChar)) {
             return 3;
         }
         return 2;
     }
-    FX_INT32 nChars = pObj->CountChars();
+    int32_t nChars = pObj->CountChars();
     if (nChars == 1 && ( 0x2D == curChar || 0xAD == curChar))
         if (IsHyphen(curChar)) {
             return 3;
         }
     CFX_WideString PrevStr = m_pPreTextObj->GetFont()->UnicodeFromCharCode(PrevItem.m_CharCode);
     FX_WCHAR preChar = PrevStr.GetAt(PrevStr.GetLength() - 1);
     CFX_AffineMatrix matrix;
     pObj->GetTextMatrix(&matrix);
     matrix.Concat(formMatrix);
     threshold = (FX_FLOAT)(nLastWidth > nThisWidth ? nLastWidth : nThisWidth);
@@ skipping 763 matching lines @@
     if (!m_IsParserd || 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);
 }