FX_BOOL considered harmful.

core/src/fpdftext/fpdf_text.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 "../../../third_party/base/nonstd_unique_ptr.h"
 #include "../../include/fpdfapi/fpdf_page.h"
 #include "../../include/fpdfapi/fpdf_pageobj.h"
 #include "../../include/fpdfapi/fpdf_resource.h"
 #include "../../include/fpdftext/fpdf_text.h"
 #include "../../include/fxcrt/fx_arb.h"
 #include "../../include/fxcrt/fx_ucd.h"
 #include "text_int.h"
 #include "txtproc.h"
 
 CFX_ByteString CharFromUnicodeAlt(FX_WCHAR unicode, int destcp, const FX_CHAR* defchar)
 {
     if (destcp == 0) {
         if (unicode < 0x80) {
             return CFX_ByteString((char)unicode);
         }
         const FX_CHAR* altstr = FCS_GetAltStr(unicode);
         if (altstr) {
             return CFX_ByteString(altstr, -1);
         }
         return CFX_ByteString(defchar, -1);
     }
-    FX_BOOL bDef = FALSE;
     char buf[10];
-    int ret = FXSYS_WideCharToMultiByte(destcp, 0, (wchar_t*)&unicode, 1, buf, 10, NULL, &bDef);
-    if (ret && !bDef) {
+    int iDef = 0;
+    int ret = FXSYS_WideCharToMultiByte(destcp, 0, (wchar_t*)&unicode, 1, buf, 10, NULL, &iDef);
+    if (ret && !iDef) {
         return CFX_ByteString(buf, ret);
     }
     const FX_CHAR* altstr = FCS_GetAltStr(unicode);
     if (altstr) {
         return CFX_ByteString(altstr, -1);
     }
     return CFX_ByteString(defchar, -1);
 }
 CTextPage::CTextPage()
 {
@@ skipping 239 matching lines @@
         }
         lastheight = pBaseLine->m_MaxFontSizeV;
         lastbaseline = pBaseLine->m_BaseLine;
         CFX_WideString str;
         pBaseLine->WriteOutput(str, MinLeftX, MaxRightX - MinLeftX, iMinWidth);
         lines.Add(str);
     }
 }
 void NormalizeCompositeChar(FX_WCHAR wChar, CFX_WideString& sDest)
 {
-    wChar = FX_GetMirrorChar(wChar, TRUE, FALSE);
+    wChar = FX_GetMirrorChar(wChar, true, false);
     FX_WCHAR* pDst = NULL;
     FX_STRSIZE nCount = FX_Unicode_GetNormalization(wChar, pDst);
     if (nCount < 1 ) {
         sDest += wChar;
         return;
     }
     pDst = new FX_WCHAR[nCount];
     FX_Unicode_GetNormalization(wChar, pDst);
     for (int nIndex = 0; nIndex < nCount; nIndex++) {
         sDest += pDst[nIndex];
     }
     delete[] pDst;
 }
 void NormalizeString(CFX_WideString& str)
 {
     if (str.GetLength() <= 0) {
         return;
     }
     CFX_WideString sBuffer;
     nonstd::unique_ptr<IFX_BidiChar> pBidiChar(IFX_BidiChar::Create());
     CFX_WordArray order;
-    FX_BOOL bR2L = FALSE;
+    bool bR2L = false;
     int32_t start = 0, count = 0, i = 0;
     int nR2L = 0, nL2R = 0;
     for (i = 0; i < str.GetLength(); i++) {
         if(pBidiChar->AppendChar(str.GetAt(i))) {
             int32_t ret = pBidiChar->GetBidiInfo(start, count);
             order.Add(start);
             order.Add(count);
             order.Add(ret);
             if(!bR2L) {
                 if(ret == 2) {
@@ skipping 11 matching lines @@
         order.Add(ret);
         if(!bR2L) {
             if(ret == 2) {
                 nR2L++;
             } else if(ret == 1) {
                 nL2R++;
             }
         }
     }
     if(nR2L > 0 && nR2L >= nL2R) {
-        bR2L = TRUE;
+        bR2L = true;
     }
     if(bR2L) {
         int count = order.GetSize();
         for(int j = count - 1; j > 0; j -= 3) {
             int ret = order.GetAt(j);
             int start = order.GetAt(j - 2);
             int count1 = order.GetAt(j - 1);
             if(ret == 2 || ret == 0) {
                 for(int i = start + count1 - 1; i >= start; i--) {
                     NormalizeCompositeChar(str[i], sBuffer);
                 }
             } else {
                 i = j;
-                FX_BOOL bSymbol = FALSE;
+                bool bSymbol = false;
                 while(i > 0 && order.GetAt(i) != 2) {
                     bSymbol = !order.GetAt(i);
                     i -= 3;
                 }
                 int end = start + count1 ;
                 int n = 0;
                 if(bSymbol) {
                     n = i + 6;
                 } else {
                     n = i + 3;
@@ skipping 11 matching lines @@
                         int end = start + count1 ;
                         for(int m = start; m < end; m++) {
                             sBuffer += str[m];
                         }
                     }
                 }
             }
         }
     } else {
         int count = order.GetSize();
-        FX_BOOL bL2R = FALSE;
+        bool bL2R = false;
         for(int j = 0; j < count; j += 3) {
             int ret = order.GetAt(j + 2);
             int start = order.GetAt(j);
             int count1 = order.GetAt(j + 1);
             if(ret == 2 || (j == 0 && ret == 0 && !bL2R)) {
                 int i = j + 3;
                 while(bR2L && i < count) {
                     if(order.GetAt(i + 2) == 1) {
                         break;
                     } else {
                         i += 3;
                     }
                 }
                 if(i == 3) {
                     j = -3;
-                    bL2R = TRUE;
+                    bL2R = true;
                     continue;
                 }
                 int end = str.GetLength() - 1;
                 if(i < count) {
                     end = order.GetAt(i) - 1;
                 }
                 j = i - 3;
                 for(int n = end; n >= start; n--) {
                     NormalizeCompositeChar(str[i], sBuffer);
                 }
             } else {
                 int end = start + count1 ;
                 for(int i = start; i < end; i++) {
                     sBuffer += str[i];
                 }
             }
         }
     }
     str.Empty();
     str += sBuffer;
 }
-static FX_BOOL IsNumber(CFX_WideString& str)
+static bool IsNumber(CFX_WideString& str)
 {
     for (int i = 0; i < str.GetLength(); i ++) {
         FX_WCHAR ch = str[i];
         if ((ch < '0' || ch > '9') && ch != '-' && ch != '+' && ch != '.' && ch != ' ') {
-            return FALSE;
+            return false;
         }
     }
-    return TRUE;
+    return true;
 }
 void CTextPage::FindColumns()
 {
     int i;
     for (i = 0; i < m_BaseLines.GetSize(); i ++) {
         CTextBaseLine* pBaseLine = (CTextBaseLine*)m_BaseLines.GetAt(i);
         for (int j = 0; j < pBaseLine->m_TextList.GetSize(); j ++) {
             CTextBox* pTextBox = (CTextBox*)pBaseLine->m_TextList.GetAt(j);
             CTextColumn* pColumn = FindColumn(pTextBox->m_Right);
             if (pColumn == NULL) {
@@ skipping 78 matching lines @@
     pText->m_Text = text;
     pText->m_Left = leftx;
     pText->m_Right = rightx;
     pText->m_Top = topy;
     pText->m_Bottom = bottomy;
     pText->m_SpaceWidth = spacew;
     pText->m_FontSizeV = fontsize_v;
     pText->m_pColumn = NULL;
     m_TextList.InsertAt(i, pText);
 }
-FX_BOOL GetIntersection(FX_FLOAT low1, FX_FLOAT high1, FX_FLOAT low2, FX_FLOAT high2,
+bool GetIntersection(FX_FLOAT low1, FX_FLOAT high1, FX_FLOAT low2, FX_FLOAT high2,
                         FX_FLOAT& interlow, FX_FLOAT& interhigh);
-FX_BOOL CTextBaseLine::CanMerge(CTextBaseLine* pOther)
+bool CTextBaseLine::CanMerge(CTextBaseLine* pOther)
 {
     FX_FLOAT inter_top, inter_bottom;
     if (!GetIntersection(m_Bottom, m_Top, pOther->m_Bottom, pOther->m_Top,
                          inter_bottom, inter_top)) {
-        return FALSE;
+        return false;
     }
     FX_FLOAT inter_h = inter_top - inter_bottom;
     if (inter_h < (m_Top - m_Bottom) / 2 && inter_h < (pOther->m_Top - pOther->m_Bottom) / 2) {
-        return FALSE;
+        return false;
     }
     FX_FLOAT dy = (FX_FLOAT)FXSYS_fabs(m_BaseLine - pOther->m_BaseLine);
     for (int i = 0; i < m_TextList.GetSize(); i ++) {
         CTextBox* pText = (CTextBox*)m_TextList.GetAt(i);
         for (int j = 0; j < pOther->m_TextList.GetSize(); j ++) {
             CTextBox* pOtherText = (CTextBox*)pOther->m_TextList.GetAt(j);
             FX_FLOAT inter_left, inter_right;
             if (!GetIntersection(pText->m_Left, pText->m_Right,
                                  pOtherText->m_Left, pOtherText->m_Right, inter_left, inter_right)) {
                 continue;
             }
             FX_FLOAT inter_w = inter_right - inter_left;
             if (inter_w < pText->m_SpaceWidth / 2 && inter_w < pOtherText->m_SpaceWidth / 2) {
                 continue;
             }
             if (dy >= (pText->m_Bottom - pText->m_Top) / 2 ||
                     dy >= (pOtherText->m_Bottom - pOtherText->m_Top) / 2) {
-                return FALSE;
+                return false;
             }
         }
     }
-    return TRUE;
+    return true;
 }
 void CTextBaseLine::Merge(CTextBaseLine* pOther)
 {
     for (int i = 0; i < pOther->m_TextList.GetSize(); i ++) {
         CTextBox* pText = (CTextBox*)pOther->m_TextList.GetAt(i);
         InsertTextBox(pText->m_Left, pText->m_Right, pText->m_Top, pText->m_Bottom,
                       pText->m_SpaceWidth, pText->m_FontSizeV, pText->m_Text);
     }
 }
-FX_BOOL CTextBaseLine::GetWidth(FX_FLOAT& leftx, FX_FLOAT& rightx)
+bool CTextBaseLine::GetWidth(FX_FLOAT& leftx, FX_FLOAT& rightx)
 {
     int i;
     for (i = 0; i < m_TextList.GetSize(); i ++) {
         CTextBox* pText = (CTextBox*)m_TextList.GetAt(i);
         if (pText->m_Text != L" ") {
             break;
         }
     }
     if (i == m_TextList.GetSize()) {
-        return FALSE;
+        return false;
     }
     CTextBox* pText = (CTextBox*)m_TextList.GetAt(i);
     leftx = pText->m_Left;
     for (i = m_TextList.GetSize() - 1; i >= 0; i --) {
         CTextBox* pText = (CTextBox*)m_TextList.GetAt(i);
         if (pText->m_Text != L" ") {
             break;
         }
     }
     pText = (CTextBox*)m_TextList.GetAt(i);
     rightx = pText->m_Right;
-    return TRUE;
+    return true;
 }
 void CTextBaseLine::MergeBoxes()
 {
     int i = 0;
     while (1) {
         if (i >= m_TextList.GetSize() - 1) {
             break;
         }
         CTextBox* pThisText = (CTextBox*)m_TextList.GetAt(i);
         CTextBox* pNextText = (CTextBox*)m_TextList.GetAt(i + 1);
@@ skipping 104 matching lines @@
 void PDF_GetPageText_Unicode(CFX_WideStringArray& lines, CPDF_Document* pDoc, CPDF_Dictionary* pPage,
                              int iMinWidth, FX_DWORD flags)
 {
     lines.RemoveAll();
     if (pPage == NULL) {
         return;
     }
     CPDF_Page page;
     page.Load(pDoc, pPage);
     CPDF_ParseOptions options;
-    options.m_bTextOnly = TRUE;
-    options.m_bSeparateForm = FALSE;
+    options.m_bTextOnly = true;
+    options.m_bSeparateForm = false;
     page.ParseContent(&options);
     CFX_FloatRect page_bbox = page.GetPageBBox();
     if (flags & PDF2TXT_AUTO_ROTATE) {
         CheckRotate(page, page_bbox);
     }
     CTextPage texts;
     texts.m_bAutoWidth = flags & PDF2TXT_AUTO_WIDTH;
     texts.m_bKeepColumn = flags & PDF2TXT_KEEP_COLUMN;
-    texts.m_bBreakSpace = TRUE;
+    texts.m_bBreakSpace = true;
     FX_POSITION pos = page.GetFirstObjectPosition();
     while (pos) {
         CPDF_PageObject* pObject = page.GetNextObject(pos);
         if (!(flags & PDF2TXT_INCLUDE_INVISIBLE)) {
             CFX_FloatRect rect(pObject->m_Left, pObject->m_Bottom, pObject->m_Right, pObject->m_Top);
             if (!page_bbox.Contains(rect)) {
                 continue;
             }
         }
         texts.ProcessObject(pObject);
     }
     texts.WriteOutput(lines, iMinWidth);
 }
 void PDF_GetPageText(CFX_ByteStringArray& lines, CPDF_Document* pDoc, CPDF_Dictionary* pPage,
                      int iMinWidth, FX_DWORD flags)
 {
     lines.RemoveAll();
     CFX_WideStringArray wlines;
     PDF_GetPageText_Unicode(wlines, pDoc, pPage, iMinWidth, flags);
     for (int i = 0; i < wlines.GetSize(); i ++) {
         CFX_WideString wstr = wlines[i];
         CFX_ByteString str;
         for (int c = 0; c < wstr.GetLength(); c ++) {
             str += CharFromUnicodeAlt(wstr[c], FXSYS_GetACP(), "?");
         }
         lines.Add(str);
     }
 }
-extern void _PDF_GetTextStream_Unicode(CFX_WideTextBuf& buffer, CPDF_PageObjects* pPage, FX_BOOL bUseLF,
+extern void _PDF_GetTextStream_Unicode(CFX_WideTextBuf& buffer, CPDF_PageObjects* pPage, bool bUseLF,
                                        CFX_PtrArray* pObjArray);
 void PDF_GetTextStream_Unicode(CFX_WideTextBuf& buffer, CPDF_Document* pDoc, CPDF_Dictionary* pPage, FX_DWORD flags)
 {
     buffer.EstimateSize(0, 10240);
     CPDF_Page page;
     page.Load(pDoc, pPage);
     CPDF_ParseOptions options;
-    options.m_bTextOnly = TRUE;
-    options.m_bSeparateForm = FALSE;
+    options.m_bTextOnly = true;
+    options.m_bSeparateForm = false;
     page.ParseContent(&options);
-    _PDF_GetTextStream_Unicode(buffer, &page, TRUE, NULL);
+    _PDF_GetTextStream_Unicode(buffer, &page, true, NULL);
 }