Remove FX_BOOL from core

core/fxcrt/fx_arabic.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/fxcrt/fx_arabic.h"
 #include "core/fxcrt/fx_ucd.h"
 
 namespace {
@@ skipping 358 matching lines @@
     return 0;
   } else {
     return iAction;
   }
 }
 
 int32_t FX_BidiReorderLevel(int32_t iBaseLevel,
                             CFX_WideString& wsText,
                             const CFX_Int32Array& levels,
                             int32_t iStart,
-                            FX_BOOL bReverse) {
+                            bool bReverse) {
   ASSERT(iBaseLevel >= 0 && iBaseLevel <= FX_BIDIMAXLEVEL);
   ASSERT(wsText.GetLength() == levels.GetSize());
   ASSERT(iStart >= 0 && iStart < wsText.GetLength());
   int32_t iSize = wsText.GetLength();
   if (iSize < 1) {
     return 0;
   }
   bReverse = bReverse || FX_IsOdd(iBaseLevel);
   int32_t i = iStart, iLevel;
   for (; i < iSize; i++) {
@@ skipping 15 matching lines @@
                     CFX_WideString& wsText,
                     const CFX_Int32Array& levels) {
   ASSERT(iBaseLevel >= 0 && iBaseLevel <= FX_BIDIMAXLEVEL);
   ASSERT(wsText.GetLength() == levels.GetSize());
   int32_t iSize = wsText.GetLength();
   if (iSize < 1) {
     return;
   }
   int32_t i = 0;
   while (i < iSize) {
-    i += FX_BidiReorderLevel(iBaseLevel, wsText, levels, i, FALSE);
+    i += FX_BidiReorderLevel(iBaseLevel, wsText, levels, i, false);
   }
 }
 
 template <class baseType>
 class CFX_BidiLineTemplate {
  public:
   void FX_BidiReverseString(CFX_ArrayTemplate<baseType>& chars,
                             int32_t iStart,
                             int32_t iCount) {
     ASSERT(iStart > -1 && iStart < chars.GetSize());
     ASSERT(iCount >= 0 && iStart + iCount <= chars.GetSize());
     baseType *pStart, *pEnd;
     int32_t iEnd = iStart + iCount - 1, iTemp;
     while (iStart < iEnd) {
       pStart = chars.GetDataPtr(iStart++);
       pEnd = chars.GetDataPtr(iEnd--);
       iTemp = pStart->m_iBidiPos;
       pStart->m_iBidiPos = pEnd->m_iBidiPos;
       pEnd->m_iBidiPos = iTemp;
     }
   }
   void FX_BidiSetDeferredRun(CFX_ArrayTemplate<baseType>& chars,
-                             FX_BOOL bClass,
+                             bool bClass,
                              int32_t iStart,
                              int32_t iCount,
                              int32_t iValue) {
     ASSERT(iStart > -1 && iStart <= chars.GetSize());
     ASSERT(iStart - iCount > -1);
     baseType* pTC;
     int32_t iLast = iStart - iCount;
     if (bClass) {
       for (int32_t i = iStart - 1; i >= iLast; i--) {
         pTC = chars.GetDataPtr(i);
         pTC->m_iBidiClass = (int16_t)iValue;
       }
     } else {
       for (int32_t i = iStart - 1; i >= iLast; i--) {
         pTC = chars.GetDataPtr(i);
         pTC->m_iBidiLevel = (int16_t)iValue;
       }
     }
   }
   void FX_BidiClassify(CFX_ArrayTemplate<baseType>& chars,
                        int32_t iCount,
-                       FX_BOOL bWS) {
+                       bool bWS) {
     ASSERT(iCount > -1 && iCount <= chars.GetSize());
     baseType* pTC;
     if (bWS) {
       for (int32_t i = 0; i < iCount; i++) {
         pTC = chars.GetDataPtr(i);
         pTC->m_iBidiClass =
             (int16_t)(pTC->m_dwCharProps & FX_BIDICLASSBITSMASK) >>
             FX_BIDICLASSBITS;
       }
     } else {
@@ skipping 63 matching lines @@
           if (iNum > 0) {
             iNum++;
           }
           continue;
         }
       }
       ASSERT(iClsCur <= FX_BIDICLASS_BN);
       iAction = gc_FX_BidiWeakActions[iState][iClsCur];
       iClsRun = FX_BidiGetDeferredType(iAction);
       if (iClsRun != FX_BIDIWEAKACTION_XX && iNum > 0) {
-        FX_BidiSetDeferredRun(chars, TRUE, i, iNum, iClsRun);
+        FX_BidiSetDeferredRun(chars, true, i, iNum, iClsRun);
         iNum = 0;
       }
       iClsNew = FX_BidiGetResolvedType(iAction);
       if (iClsNew != FX_BIDIWEAKACTION_XX) {
         pTC->m_iBidiClass = (int16_t)iClsNew;
       }
       if (FX_BIDIWEAKACTION_IX & iAction) {
         iNum++;
       }
       iState = gc_FX_BidiWeakStates[iState][iClsCur];
     }
     if (iNum > 0) {
       iClsCur = FX_BidiDirection(iBaseLevel);
       iClsRun = FX_BidiGetDeferredType(gc_FX_BidiWeakActions[iState][iClsCur]);
       if (iClsRun != FX_BIDIWEAKACTION_XX) {
-        FX_BidiSetDeferredRun(chars, TRUE, i, iNum, iClsRun);
+        FX_BidiSetDeferredRun(chars, true, i, iNum, iClsRun);
       }
     }
   }
   void FX_BidiResolveNeutrals(CFX_ArrayTemplate<baseType>& chars,
                               int32_t iCount,
                               int32_t iBaseLevel) {
     ASSERT(iCount > -1 && iCount <= chars.GetSize());
     ASSERT(iBaseLevel >= 0 && iBaseLevel <= FX_BIDIMAXLEVEL);
     iCount--;
     if (iCount < 1) {
       return;
     }
     baseType* pTC;
     int32_t iLevel = iBaseLevel;
     int32_t iState = FX_IsOdd(iBaseLevel) ? FX_BNSr : FX_BNSl;
     int32_t i = 0, iNum = 0, iClsCur, iClsRun, iClsNew, iAction;
     for (; i <= iCount; i++) {
       pTC = chars.GetDataPtr(i);
       iClsCur = pTC->m_iBidiClass;
       if (iClsCur == FX_BIDICLASS_BN) {
         if (iNum) {
           iNum++;
         }
         continue;
       }
       ASSERT(iClsCur < FX_BIDICLASS_AL);
       iAction = gc_FX_BidiNeutralActions[iState][iClsCur];
       iClsRun = FX_BidiGetDeferredNeutrals(iAction, iLevel);
       if (iClsRun != FX_BIDICLASS_N && iNum > 0) {
-        FX_BidiSetDeferredRun(chars, TRUE, i, iNum, iClsRun);
+        FX_BidiSetDeferredRun(chars, true, i, iNum, iClsRun);
         iNum = 0;
       }
       iClsNew = FX_BidiGetResolvedNeutrals(iAction);
       if (iClsNew != FX_BIDICLASS_N) {
         pTC->m_iBidiClass = (int16_t)iClsNew;
       }
       if (FX_BIDINEUTRALACTION_In & iAction) {
         iNum++;
       }
       iState = gc_FX_BidiNeutralStates[iState][iClsCur];
       iLevel = pTC->m_iBidiLevel;
     }
     if (iNum > 0) {
       iClsCur = FX_BidiDirection(iLevel);
       iClsRun = FX_BidiGetDeferredNeutrals(
           gc_FX_BidiNeutralActions[iState][iClsCur], iLevel);
       if (iClsRun != FX_BIDICLASS_N) {
-        FX_BidiSetDeferredRun(chars, TRUE, i, iNum, iClsRun);
+        FX_BidiSetDeferredRun(chars, true, i, iNum, iClsRun);
       }
     }
   }
   void FX_BidiResolveImplicit(CFX_ArrayTemplate<baseType>& chars,
                               int32_t iCount) {
     ASSERT(iCount > -1 && iCount <= chars.GetSize());
     baseType* pTC;
     int32_t iCls, iLevel;
     for (int32_t i = 0; i < iCount; i++) {
       pTC = chars.GetDataPtr(i);
@@ skipping 30 matching lines @@
         case FX_BIDICLASS_LRO:
         case FX_BIDICLASS_RLO:
         case FX_BIDICLASS_PDF:
         case FX_BIDICLASS_BN:
           pTC->m_iBidiLevel = (int16_t)iLevel;
           iNum++;
           break;
         case FX_BIDICLASS_S:
         case FX_BIDICLASS_B:
           if (iNum > 0) {
-            FX_BidiSetDeferredRun(chars, FALSE, i, iNum, iBaseLevel);
+            FX_BidiSetDeferredRun(chars, false, i, iNum, iBaseLevel);
           }
           pTC->m_iBidiLevel = (int16_t)iBaseLevel;
           iNum = 0;
           break;
         default:
           iNum = 0;
           break;
       }
       iLevel = pTC->m_iBidiLevel;
     }
     if (iNum > 0) {
-      FX_BidiSetDeferredRun(chars, FALSE, i, iNum, iBaseLevel);
+      FX_BidiSetDeferredRun(chars, false, i, iNum, iBaseLevel);
     }
   }
   int32_t FX_BidiReorderLevel(CFX_ArrayTemplate<baseType>& chars,
                               int32_t iCount,
                               int32_t iBaseLevel,
                               int32_t iStart,
-                              FX_BOOL bReverse) {
+                              bool bReverse) {
     ASSERT(iCount > -1 && iCount <= chars.GetSize());
     ASSERT(iBaseLevel >= 0 && iBaseLevel <= FX_BIDIMAXLEVEL);
     ASSERT(iStart >= 0 && iStart < iCount);
     if (iCount < 1) {
       return 0;
     }
     baseType* pTC;
     bReverse = bReverse || FX_IsOdd(iBaseLevel);
     int32_t i = iStart, iLevel;
     for (; i < iCount; i++) {
@@ skipping 12 matching lines @@
     }
     return iNum;
   }
   void FX_BidiReorder(CFX_ArrayTemplate<baseType>& chars,
                       int32_t iCount,
                       int32_t iBaseLevel) {
     ASSERT(iCount > -1 && iCount <= chars.GetSize());
     ASSERT(iBaseLevel >= 0 && iBaseLevel <= FX_BIDIMAXLEVEL);
     int32_t i = 0;
     while (i < iCount) {
-      i += FX_BidiReorderLevel(chars, iCount, iBaseLevel, i, FALSE);
+      i += FX_BidiReorderLevel(chars, iCount, iBaseLevel, i, false);
     }
   }
   void FX_BidiPosition(CFX_ArrayTemplate<baseType>& chars, int32_t iCount) {
     ASSERT(iCount > -1 && iCount <= chars.GetSize());
     baseType* pTC;
     int32_t i = 0;
     while (i < iCount) {
       pTC = chars.GetDataPtr(i);
       pTC = chars.GetDataPtr(pTC->m_iBidiPos);
       pTC->m_iBidiOrder = i++;
     }
   }
 
   void FX_BidiLine(CFX_ArrayTemplate<baseType>& chars,
                    int32_t iCount,
                    int32_t iBaseLevel) {
     ASSERT(iCount > -1 && iCount <= chars.GetSize());
     if (iCount < 2) {
       return;
     }
-    FX_BidiClassify(chars, iCount, FALSE);
+    FX_BidiClassify(chars, iCount, false);
     FX_BidiResolveExplicit(chars, iCount, iBaseLevel);
     FX_BidiResolveWeak(chars, iCount, iBaseLevel);
     FX_BidiResolveNeutrals(chars, iCount, iBaseLevel);
     FX_BidiResolveImplicit(chars, iCount);
-    FX_BidiClassify(chars, iCount, TRUE);
+    FX_BidiClassify(chars, iCount, true);
     FX_BidiResolveWhitespace(chars, iCount, iBaseLevel);
     FX_BidiReorder(chars, iCount, iBaseLevel);
     FX_BidiPosition(chars, iCount);
   }
 };
 void FX_BidiLine(CFX_TxtCharArray& chars, int32_t iCount, int32_t iBaseLevel) {
   CFX_BidiLineTemplate<CFX_TxtChar> blt;
   blt.FX_BidiLine(chars, iCount, iBaseLevel);
 }
 void FX_BidiLine(CFX_RTFCharArray& chars, int32_t iCount, int32_t iBaseLevel) {
   CFX_BidiLineTemplate<CFX_RTFChar> blt;
   blt.FX_BidiLine(chars, iCount, iBaseLevel);
 }