Remove FX_BOOL from core

core/fpdfapi/page/fpdf_page_func.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/fpdfapi/page/pageint.h"
 
 #include <limits.h>
 
@@ skipping 66 matching lines @@
   FX_FLOAT divisor = xmax - xmin;
   return ymin + (divisor ? (x - xmin) * (ymax - ymin) / divisor : 0);
 }
 
 class CPDF_PSFunc : public CPDF_Function {
  public:
   CPDF_PSFunc() : CPDF_Function(Type::kType4PostScript) {}
   ~CPDF_PSFunc() override {}
 
   // CPDF_Function
-  FX_BOOL v_Init(CPDF_Object* pObj) override;
-  FX_BOOL v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const override;
+  bool v_Init(CPDF_Object* pObj) override;
+  bool v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const override;
 
  private:
   CPDF_PSEngine m_PS;
 };
 
-FX_BOOL CPDF_PSFunc::v_Init(CPDF_Object* pObj) {
+bool CPDF_PSFunc::v_Init(CPDF_Object* pObj) {
   CPDF_StreamAcc acc;
-  acc.LoadAllData(pObj->AsStream(), FALSE);
+  acc.LoadAllData(pObj->AsStream(), false);
   return m_PS.Parse(reinterpret_cast<const FX_CHAR*>(acc.GetData()),
                     acc.GetSize());
 }
 
-FX_BOOL CPDF_PSFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const {
+bool CPDF_PSFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const {
   CPDF_PSEngine& PS = const_cast<CPDF_PSEngine&>(m_PS);
   PS.Reset();
   for (uint32_t i = 0; i < m_nInputs; i++)
     PS.Push(inputs[i]);
   PS.Execute();
   if (PS.GetStackSize() < m_nOutputs)
-    return FALSE;
+    return false;
   for (uint32_t i = 0; i < m_nOutputs; i++)
     results[m_nOutputs - i - 1] = PS.Pop();
-  return TRUE;
+  return true;
 }
 
 }  // namespace
 
 class CPDF_PSOP {
  public:
   explicit CPDF_PSOP(PDF_PSOP op) : m_op(op), m_value(0) {
     ASSERT(m_op != PSOP_CONST);
     ASSERT(m_op != PSOP_PROC);
   }
@@ skipping 16 matching lines @@
   }
 
   PDF_PSOP GetOp() const { return m_op; }
 
  private:
   const PDF_PSOP m_op;
   const FX_FLOAT m_value;
   std::unique_ptr<CPDF_PSProc> m_proc;
 };
 
-FX_BOOL CPDF_PSEngine::Execute() {
+bool CPDF_PSEngine::Execute() {
   return m_MainProc.Execute(this);
 }
 
 CPDF_PSProc::CPDF_PSProc() {}
 CPDF_PSProc::~CPDF_PSProc() {}
 
-FX_BOOL CPDF_PSProc::Execute(CPDF_PSEngine* pEngine) {
+bool CPDF_PSProc::Execute(CPDF_PSEngine* pEngine) {
   for (size_t i = 0; i < m_Operators.size(); ++i) {
     const PDF_PSOP op = m_Operators[i]->GetOp();
     if (op == PSOP_PROC)
       continue;
 
     if (op == PSOP_CONST) {
       pEngine->Push(m_Operators[i]->GetFloatValue());
       continue;
     }
 
     if (op == PSOP_IF) {
       if (i == 0 || m_Operators[i - 1]->GetOp() != PSOP_PROC)
-        return FALSE;
+        return false;
 
       if (static_cast<int>(pEngine->Pop()))
         m_Operators[i - 1]->GetProc()->Execute(pEngine);
     } else if (op == PSOP_IFELSE) {
       if (i < 2 || m_Operators[i - 1]->GetOp() != PSOP_PROC ||
           m_Operators[i - 2]->GetOp() != PSOP_PROC) {
-        return FALSE;
+        return false;
       }
       size_t offset = static_cast<int>(pEngine->Pop()) ? 2 : 1;
       m_Operators[i - offset]->GetProc()->Execute(pEngine);
     } else {
       pEngine->DoOperator(op);
     }
   }
-  return TRUE;
+  return true;
 }
 
 CPDF_PSEngine::CPDF_PSEngine() {
   m_StackCount = 0;
 }
 CPDF_PSEngine::~CPDF_PSEngine() {}
 void CPDF_PSEngine::Push(FX_FLOAT v) {
   if (m_StackCount == PSENGINE_STACKSIZE) {
     return;
   }
   m_Stack[m_StackCount++] = v;
 }
 FX_FLOAT CPDF_PSEngine::Pop() {
   if (m_StackCount == 0) {
     return 0;
   }
   return m_Stack[--m_StackCount];
 }
-FX_BOOL CPDF_PSEngine::Parse(const FX_CHAR* str, int size) {
+bool CPDF_PSEngine::Parse(const FX_CHAR* str, int size) {
   CPDF_SimpleParser parser((uint8_t*)str, size);
   CFX_ByteStringC word = parser.GetWord();
   if (word != "{") {
-    return FALSE;
+    return false;
   }
   return m_MainProc.Parse(&parser, 0);
 }
 
-FX_BOOL CPDF_PSProc::Parse(CPDF_SimpleParser* parser, int depth) {
+bool CPDF_PSProc::Parse(CPDF_SimpleParser* parser, int depth) {
   if (depth > kMaxDepth)
-    return FALSE;
+    return false;
 
   while (1) {
     CFX_ByteStringC word = parser->GetWord();
     if (word.IsEmpty()) {
-      return FALSE;
+      return false;
     }
     if (word == "}") {
-      return TRUE;
+      return true;
     }
     if (word == "{") {
       std::unique_ptr<CPDF_PSProc> proc(new CPDF_PSProc);
       std::unique_ptr<CPDF_PSOP> op(new CPDF_PSOP(std::move(proc)));
       m_Operators.push_back(std::move(op));
       if (!m_Operators.back()->GetProc()->Parse(parser, depth + 1)) {
-        return FALSE;
+        return false;
       }
     } else {
       bool found = false;
       for (const PDF_PSOpName& op_name : kPsOpNames) {
         if (word == CFX_ByteStringC(op_name.name)) {
           std::unique_ptr<CPDF_PSOP> op(new CPDF_PSOP(op_name.op));
           m_Operators.push_back(std::move(op));
           found = true;
           break;
         }
       }
       if (!found) {
         std::unique_ptr<CPDF_PSOP> op(new CPDF_PSOP(FX_atof(word)));
         m_Operators.push_back(std::move(op));
       }
     }
   }
 }
 
-FX_BOOL CPDF_PSEngine::DoOperator(PDF_PSOP op) {
+bool CPDF_PSEngine::DoOperator(PDF_PSOP op) {
   int i1;
   int i2;
   FX_FLOAT d1;
   FX_FLOAT d2;
   FX_SAFE_INT32 result;
   switch (op) {
     case PSOP_ADD:
       d1 = Pop();
       d2 = Pop();
       Push(d1 + d2);
@@ skipping 208 matching lines @@
         j -= n;
       auto begin_it = std::begin(m_Stack) + m_StackCount - n;
       auto middle_it = begin_it - j;
       auto end_it = std::begin(m_Stack) + m_StackCount;
       std::rotate(begin_it, middle_it, end_it);
       break;
     }
     default:
       break;
   }
-  return TRUE;
+  return true;
 }
 
 CPDF_SampledFunc::CPDF_SampledFunc() : CPDF_Function(Type::kType0Sampled) {}
 
 CPDF_SampledFunc::~CPDF_SampledFunc() {}
 
-FX_BOOL CPDF_SampledFunc::v_Init(CPDF_Object* pObj) {
+bool CPDF_SampledFunc::v_Init(CPDF_Object* pObj) {
   CPDF_Stream* pStream = pObj->AsStream();
   if (!pStream)
     return false;
 
   CPDF_Dictionary* pDict = pStream->GetDict();
   CPDF_Array* pSize = pDict->GetArrayFor("Size");
   CPDF_Array* pEncode = pDict->GetArrayFor("Encode");
   CPDF_Array* pDecode = pDict->GetArrayFor("Decode");
   m_nBitsPerSample = pDict->GetIntegerFor("BitsPerSample");
   if (!IsValidBitsPerSample(m_nBitsPerSample))
-    return FALSE;
+    return false;
 
   m_SampleMax = 0xffffffff >> (32 - m_nBitsPerSample);
   m_pSampleStream.reset(new CPDF_StreamAcc);
-  m_pSampleStream->LoadAllData(pStream, FALSE);
+  m_pSampleStream->LoadAllData(pStream, false);
   FX_SAFE_UINT32 nTotalSampleBits = 1;
   m_EncodeInfo.resize(m_nInputs);
   for (uint32_t i = 0; i < m_nInputs; i++) {
     m_EncodeInfo[i].sizes = pSize ? pSize->GetIntegerAt(i) : 0;
     if (!pSize && i == 0)
       m_EncodeInfo[i].sizes = pDict->GetIntegerFor("Size");
     nTotalSampleBits *= m_EncodeInfo[i].sizes;
     if (pEncode) {
       m_EncodeInfo[i].encode_min = pEncode->GetFloatAt(i * 2);
       m_EncodeInfo[i].encode_max = pEncode->GetFloatAt(i * 2 + 1);
     } else {
       m_EncodeInfo[i].encode_min = 0;
       m_EncodeInfo[i].encode_max =
           m_EncodeInfo[i].sizes == 1 ? 1 : (FX_FLOAT)m_EncodeInfo[i].sizes - 1;
     }
   }
   nTotalSampleBits *= m_nBitsPerSample;
   nTotalSampleBits *= m_nOutputs;
   FX_SAFE_UINT32 nTotalSampleBytes = nTotalSampleBits;
   nTotalSampleBytes += 7;
   nTotalSampleBytes /= 8;
   if (!nTotalSampleBytes.IsValid() || nTotalSampleBytes.ValueOrDie() == 0 ||
       nTotalSampleBytes.ValueOrDie() > m_pSampleStream->GetSize()) {
-    return FALSE;
+    return false;
   }
   m_DecodeInfo.resize(m_nOutputs);
   for (uint32_t i = 0; i < m_nOutputs; i++) {
     if (pDecode) {
       m_DecodeInfo[i].decode_min = pDecode->GetFloatAt(2 * i);
       m_DecodeInfo[i].decode_max = pDecode->GetFloatAt(2 * i + 1);
     } else {
       m_DecodeInfo[i].decode_min = m_pRanges[i * 2];
       m_DecodeInfo[i].decode_max = m_pRanges[i * 2 + 1];
     }
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CPDF_SampledFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const {
+bool CPDF_SampledFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const {
   int pos = 0;
   CFX_FixedBufGrow<FX_FLOAT, 16> encoded_input_buf(m_nInputs);
   FX_FLOAT* encoded_input = encoded_input_buf;
   CFX_FixedBufGrow<uint32_t, 32> int_buf(m_nInputs * 2);
   uint32_t* index = int_buf;
   uint32_t* blocksize = index + m_nInputs;
   for (uint32_t i = 0; i < m_nInputs; i++) {
     if (i == 0)
       blocksize[i] = 1;
     else
       blocksize[i] = blocksize[i - 1] * m_EncodeInfo[i - 1].sizes;
     encoded_input[i] =
         PDF_Interpolate(inputs[i], m_pDomains[i * 2], m_pDomains[i * 2 + 1],
                         m_EncodeInfo[i].encode_min, m_EncodeInfo[i].encode_max);
     index[i] = std::min((uint32_t)std::max(0.f, encoded_input[i]),
                         m_EncodeInfo[i].sizes - 1);
     pos += index[i] * blocksize[i];
   }
   FX_SAFE_INT32 bits_to_output = m_nOutputs;
   bits_to_output *= m_nBitsPerSample;
   if (!bits_to_output.IsValid())
-    return FALSE;
+    return false;
 
   FX_SAFE_INT32 bitpos = pos;
   bitpos *= bits_to_output.ValueOrDie();
   if (!bitpos.IsValid())
-    return FALSE;
+    return false;
 
   FX_SAFE_INT32 range_check = bitpos;
   range_check += bits_to_output.ValueOrDie();
   if (!range_check.IsValid())
-    return FALSE;
+    return false;
 
   const uint8_t* pSampleData = m_pSampleStream->GetData();
   if (!pSampleData)
-    return FALSE;
+    return false;
 
   for (uint32_t j = 0; j < m_nOutputs; j++) {
     uint32_t sample =
         GetBits32(pSampleData, bitpos.ValueOrDie() + j * m_nBitsPerSample,
                   m_nBitsPerSample);
     FX_FLOAT encoded = (FX_FLOAT)sample;
     for (uint32_t i = 0; i < m_nInputs; i++) {
       if (index[i] == m_EncodeInfo[i].sizes - 1) {
         if (index[i] == 0)
           encoded = encoded_input[i] * (FX_FLOAT)sample;
       } else {
         FX_SAFE_INT32 bitpos2 = blocksize[i];
         bitpos2 += pos;
         bitpos2 *= m_nOutputs;
         bitpos2 += j;
         bitpos2 *= m_nBitsPerSample;
         if (!bitpos2.IsValid())
-          return FALSE;
+          return false;
         uint32_t sample1 =
             GetBits32(pSampleData, bitpos2.ValueOrDie(), m_nBitsPerSample);
         encoded += (encoded_input[i] - index[i]) *
                    ((FX_FLOAT)sample1 - (FX_FLOAT)sample);
       }
     }
     results[j] =
         PDF_Interpolate(encoded, 0, (FX_FLOAT)m_SampleMax,
                         m_DecodeInfo[j].decode_min, m_DecodeInfo[j].decode_max);
   }
-  return TRUE;
+  return true;
 }
 
 CPDF_ExpIntFunc::CPDF_ExpIntFunc()
     : CPDF_Function(Type::kType2ExpotentialInterpolation),
       m_pBeginValues(nullptr),
       m_pEndValues(nullptr) {}
 
 CPDF_ExpIntFunc::~CPDF_ExpIntFunc() {
   FX_Free(m_pBeginValues);
   FX_Free(m_pEndValues);
 }
-FX_BOOL CPDF_ExpIntFunc::v_Init(CPDF_Object* pObj) {
+bool CPDF_ExpIntFunc::v_Init(CPDF_Object* pObj) {
   CPDF_Dictionary* pDict = pObj->GetDict();
   if (!pDict) {
-    return FALSE;
+    return false;
   }
   CPDF_Array* pArray0 = pDict->GetArrayFor("C0");
   if (m_nOutputs == 0) {
     m_nOutputs = 1;
     if (pArray0) {
       m_nOutputs = pArray0->GetCount();
     }
   }
   CPDF_Array* pArray1 = pDict->GetArrayFor("C1");
   m_pBeginValues = FX_Alloc2D(FX_FLOAT, m_nOutputs, 2);
   m_pEndValues = FX_Alloc2D(FX_FLOAT, m_nOutputs, 2);
   for (uint32_t i = 0; i < m_nOutputs; i++) {
     m_pBeginValues[i] = pArray0 ? pArray0->GetFloatAt(i) : 0.0f;
     m_pEndValues[i] = pArray1 ? pArray1->GetFloatAt(i) : 1.0f;
   }
   m_Exponent = pDict->GetFloatFor("N");
   m_nOrigOutputs = m_nOutputs;
   if (m_nOutputs && m_nInputs > INT_MAX / m_nOutputs) {
-    return FALSE;
+    return false;
   }
   m_nOutputs *= m_nInputs;
-  return TRUE;
+  return true;
 }
-FX_BOOL CPDF_ExpIntFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const {
+bool CPDF_ExpIntFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const {
   for (uint32_t i = 0; i < m_nInputs; i++)
     for (uint32_t j = 0; j < m_nOrigOutputs; j++) {
       results[i * m_nOrigOutputs + j] =
           m_pBeginValues[j] +
           (FX_FLOAT)FXSYS_pow(inputs[i], m_Exponent) *
               (m_pEndValues[j] - m_pBeginValues[j]);
     }
-  return TRUE;
+  return true;
 }
 
 CPDF_StitchFunc::CPDF_StitchFunc()
     : CPDF_Function(Type::kType3Stitching),
       m_pBounds(nullptr),
       m_pEncode(nullptr) {}
 
 CPDF_StitchFunc::~CPDF_StitchFunc() {
   FX_Free(m_pBounds);
   FX_Free(m_pEncode);
 }
 
-FX_BOOL CPDF_StitchFunc::v_Init(CPDF_Object* pObj) {
+bool CPDF_StitchFunc::v_Init(CPDF_Object* pObj) {
   CPDF_Dictionary* pDict = pObj->GetDict();
   if (!pDict) {
-    return FALSE;
+    return false;
   }
   if (m_nInputs != kRequiredNumInputs) {
-    return FALSE;
+    return false;
   }
   CPDF_Array* pArray = pDict->GetArrayFor("Functions");
   if (!pArray) {
-    return FALSE;
+    return false;
   }
   uint32_t nSubs = pArray->GetCount();
   if (nSubs == 0)
-    return FALSE;
+    return false;
   m_nOutputs = 0;
   for (uint32_t i = 0; i < nSubs; i++) {
     CPDF_Object* pSub = pArray->GetDirectObjectAt(i);
     if (pSub == pObj)
-      return FALSE;
+      return false;
     std::unique_ptr<CPDF_Function> pFunc(CPDF_Function::Load(pSub));
     if (!pFunc)
-      return FALSE;
+      return false;
     // Check that the input dimensionality is 1, and that all output
     // dimensionalities are the same.
     if (pFunc->CountInputs() != kRequiredNumInputs)
-      return FALSE;
+      return false;
     if (pFunc->CountOutputs() != m_nOutputs) {
       if (m_nOutputs)
-        return FALSE;
+        return false;
 
       m_nOutputs = pFunc->CountOutputs();
     }
 
     m_pSubFunctions.push_back(std::move(pFunc));
   }
   m_pBounds = FX_Alloc(FX_FLOAT, nSubs + 1);
   m_pBounds[0] = m_pDomains[0];
   pArray = pDict->GetArrayFor("Bounds");
   if (!pArray)
-    return FALSE;
+    return false;
   for (uint32_t i = 0; i < nSubs - 1; i++)
     m_pBounds[i + 1] = pArray->GetFloatAt(i);
   m_pBounds[nSubs] = m_pDomains[1];
   m_pEncode = FX_Alloc2D(FX_FLOAT, nSubs, 2);
   pArray = pDict->GetArrayFor("Encode");
   if (!pArray)
-    return FALSE;
+    return false;
 
   for (uint32_t i = 0; i < nSubs * 2; i++)
     m_pEncode[i] = pArray->GetFloatAt(i);
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CPDF_StitchFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* outputs) const {
+bool CPDF_StitchFunc::v_Call(FX_FLOAT* inputs, FX_FLOAT* outputs) const {
   FX_FLOAT input = inputs[0];
   size_t i;
   for (i = 0; i < m_pSubFunctions.size() - 1; i++) {
     if (input < m_pBounds[i + 1])
       break;
   }
   input = PDF_Interpolate(input, m_pBounds[i], m_pBounds[i + 1],
                           m_pEncode[i * 2], m_pEncode[i * 2 + 1]);
   int nresults;
   m_pSubFunctions[i]->Call(&input, kRequiredNumInputs, outputs, nresults);
-  return TRUE;
+  return true;
 }
 
 // static
 std::unique_ptr<CPDF_Function> CPDF_Function::Load(CPDF_Object* pFuncObj) {
   std::unique_ptr<CPDF_Function> pFunc;
   if (!pFuncObj)
     return pFunc;
 
   int iType = -1;
   if (CPDF_Stream* pStream = pFuncObj->AsStream())
@@ skipping 31 matching lines @@
 }
 
 CPDF_Function::CPDF_Function(Type type)
     : m_pDomains(nullptr), m_pRanges(nullptr), m_Type(type) {}
 
 CPDF_Function::~CPDF_Function() {
   FX_Free(m_pDomains);
   FX_Free(m_pRanges);
 }
 
-FX_BOOL CPDF_Function::Init(CPDF_Object* pObj) {
+bool CPDF_Function::Init(CPDF_Object* pObj) {
   CPDF_Stream* pStream = pObj->AsStream();
   CPDF_Dictionary* pDict = pStream ? pStream->GetDict() : pObj->AsDictionary();
 
   CPDF_Array* pDomains = pDict->GetArrayFor("Domain");
   if (!pDomains)
-    return FALSE;
+    return false;
 
   m_nInputs = pDomains->GetCount() / 2;
   if (m_nInputs == 0)
-    return FALSE;
+    return false;
 
   m_pDomains = FX_Alloc2D(FX_FLOAT, m_nInputs, 2);
   for (uint32_t i = 0; i < m_nInputs * 2; i++) {
     m_pDomains[i] = pDomains->GetFloatAt(i);
   }
   CPDF_Array* pRanges = pDict->GetArrayFor("Range");
   m_nOutputs = 0;
   if (pRanges) {
     m_nOutputs = pRanges->GetCount() / 2;
     m_pRanges = FX_Alloc2D(FX_FLOAT, m_nOutputs, 2);
     for (uint32_t i = 0; i < m_nOutputs * 2; i++)
       m_pRanges[i] = pRanges->GetFloatAt(i);
   }
   uint32_t old_outputs = m_nOutputs;
   if (!v_Init(pObj))
-    return FALSE;
+    return false;
   if (m_pRanges && m_nOutputs > old_outputs) {
     m_pRanges = FX_Realloc(FX_FLOAT, m_pRanges, m_nOutputs * 2);
     if (m_pRanges) {
       FXSYS_memset(m_pRanges + (old_outputs * 2), 0,
                    sizeof(FX_FLOAT) * (m_nOutputs - old_outputs) * 2);
     }
   }
-  return TRUE;
+  return true;
 }
 
-FX_BOOL CPDF_Function::Call(FX_FLOAT* inputs,
-                            uint32_t ninputs,
-                            FX_FLOAT* results,
-                            int& nresults) const {
+bool CPDF_Function::Call(FX_FLOAT* inputs,
+                         uint32_t ninputs,
+                         FX_FLOAT* results,
+                         int& nresults) const {
   if (m_nInputs != ninputs) {
-    return FALSE;
+    return false;
   }
   nresults = m_nOutputs;
   for (uint32_t i = 0; i < m_nInputs; i++) {
     if (inputs[i] < m_pDomains[i * 2])
       inputs[i] = m_pDomains[i * 2];
     else if (inputs[i] > m_pDomains[i * 2 + 1])
       inputs[i] = m_pDomains[i * 2] + 1;
   }
   v_Call(inputs, results);
   if (m_pRanges) {
     for (uint32_t i = 0; i < m_nOutputs; i++) {
       if (results[i] < m_pRanges[i * 2])
         results[i] = m_pRanges[i * 2];
       else if (results[i] > m_pRanges[i * 2 + 1])
         results[i] = m_pRanges[i * 2 + 1];
     }
   }
-  return TRUE;
+  return true;
 }
 
 const CPDF_SampledFunc* CPDF_Function::ToSampledFunc() const {
   return m_Type == Type::kType0Sampled
              ? static_cast<const CPDF_SampledFunc*>(this)
              : nullptr;
 }
 
 const CPDF_ExpIntFunc* CPDF_Function::ToExpIntFunc() const {
   return m_Type == Type::kType2ExpotentialInterpolation
              ? static_cast<const CPDF_ExpIntFunc*>(this)
              : nullptr;
 }
 
 const CPDF_StitchFunc* CPDF_Function::ToStitchFunc() const {
   return m_Type == Type::kType3Stitching
              ? static_cast<const CPDF_StitchFunc*>(this)
              : nullptr;
 }