FX_BOOL considered harmful.

core/src/fpdfapi/fpdf_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 <limits.h>
 
 #include "../../../include/fpdfapi/fpdf_module.h"
 #include "../../../include/fpdfapi/fpdf_page.h"
 #include "../../../include/fxcrt/fx_safe_types.h"
 #include "../../../third_party/base/numerics/safe_conversions_impl.h"
 #include "pageint.h"
 
 class CPDF_PSEngine;
 typedef enum {PSOP_ADD, PSOP_SUB, PSOP_MUL, PSOP_DIV, PSOP_IDIV, PSOP_MOD,
               PSOP_NEG, PSOP_ABS, PSOP_CEILING, PSOP_FLOOR, PSOP_ROUND, PSOP_TRUNCATE,
               PSOP_SQRT, PSOP_SIN, PSOP_COS, PSOP_ATAN, PSOP_EXP, PSOP_LN, PSOP_LOG,
               PSOP_CVI, PSOP_CVR, PSOP_EQ, PSOP_NE, PSOP_GT, PSOP_GE, PSOP_LT, PSOP_LE,
               PSOP_AND, PSOP_OR, PSOP_XOR, PSOP_NOT, PSOP_BITSHIFT, PSOP_TRUE, PSOP_FALSE,
               PSOP_IF, PSOP_IFELSE, PSOP_POP, PSOP_EXCH, PSOP_DUP, PSOP_COPY,
               PSOP_INDEX, PSOP_ROLL, PSOP_PROC, PSOP_CONST
              } PDF_PSOP;
 class CPDF_PSProc
 {
 public:
     ~CPDF_PSProc();
-    FX_BOOL     Parse(CPDF_SimpleParser& parser);
-    FX_BOOL     Execute(CPDF_PSEngine* pEngine);
+    bool        Parse(CPDF_SimpleParser& parser);
+    bool        Execute(CPDF_PSEngine* pEngine);
     CFX_PtrArray                m_Operators;
 };
 #define PSENGINE_STACKSIZE 100
 class CPDF_PSEngine
 {
 public:
     CPDF_PSEngine();
     ~CPDF_PSEngine();
-    FX_BOOL     Parse(const FX_CHAR* string, int size);
-    FX_BOOL     Execute()
+    bool        Parse(const FX_CHAR* string, int size);
+    bool        Execute()
     {
         return m_MainProc.Execute(this);
     }
-    FX_BOOL     DoOperator(PDF_PSOP op);
+    bool        DoOperator(PDF_PSOP op);
     void        Reset()
     {
         m_StackCount = 0;
     }
     void        Push(FX_FLOAT value);
     void        Push(int value)
     {
         Push((FX_FLOAT)value);
     }
     FX_FLOAT    Pop();
@@ skipping 12 matching lines @@
     for (int i = 0; i < size; i ++) {
         if (m_Operators[i] == (void*)PSOP_PROC) {
             delete (CPDF_PSProc*)m_Operators[i + 1];
             i ++;
         } else if (m_Operators[i] == (void*)PSOP_CONST) {
             FX_Free((FX_FLOAT*)m_Operators[i + 1]);
             i ++;
         }
     }
 }
-FX_BOOL CPDF_PSProc::Execute(CPDF_PSEngine* pEngine)
+bool CPDF_PSProc::Execute(CPDF_PSEngine* pEngine)
 {
     int size = m_Operators.GetSize();
     for (int i = 0; i < size; i ++) {
         PDF_PSOP op = (PDF_PSOP)(uintptr_t)m_Operators[i];
         if (op == PSOP_PROC) {
             i ++;
         } else if (op == PSOP_CONST) {
             pEngine->Push(*(FX_FLOAT*)m_Operators[i + 1]);
             i ++;
         } else if (op == PSOP_IF) {
             if (i < 2 || m_Operators[i - 2] != (void*)PSOP_PROC) {
-                return FALSE;
+                return false;
             }
             if ((int)pEngine->Pop()) {
                 ((CPDF_PSProc*)m_Operators[i - 1])->Execute(pEngine);
             }
         } else if (op == PSOP_IFELSE) {
             if (i < 4 || m_Operators[i - 2] != (void*)PSOP_PROC ||
                     m_Operators[i - 4] != (void*)PSOP_PROC) {
-                return FALSE;
+                return false;
             }
             if ((int)pEngine->Pop()) {
                 ((CPDF_PSProc*)m_Operators[i - 3])->Execute(pEngine);
             } else {
                 ((CPDF_PSProc*)m_Operators[i - 1])->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)
 {
@@ skipping 20 matching lines @@
     {"cos", PSOP_COS}, {"atan", PSOP_ATAN}, {"exp", PSOP_EXP}, {"ln", PSOP_LN},
     {"log", PSOP_LOG}, {"cvi", PSOP_CVI}, {"cvr", PSOP_CVR}, {"eq", PSOP_EQ},
     {"ne", PSOP_NE}, {"gt", PSOP_GT}, {"ge", PSOP_GE}, {"lt", PSOP_LT},
     {"le", PSOP_LE}, {"and", PSOP_AND}, {"or", PSOP_OR}, {"xor", PSOP_XOR},
     {"not", PSOP_NOT}, {"bitshift", PSOP_BITSHIFT}, {"true", PSOP_TRUE},
     {"false", PSOP_FALSE}, {"if", PSOP_IF}, {"ifelse", PSOP_IFELSE},
     {"pop", PSOP_POP}, {"exch", PSOP_EXCH}, {"dup", PSOP_DUP},
     {"copy", PSOP_COPY}, {"index", PSOP_INDEX}, {"roll", PSOP_ROLL},
     {NULL, PSOP_PROC}
 };
-FX_BOOL CPDF_PSEngine::Parse(const FX_CHAR* string, int size)
+bool CPDF_PSEngine::Parse(const FX_CHAR* string, int size)
 {
     CPDF_SimpleParser parser((uint8_t*)string, size);
     CFX_ByteStringC word = parser.GetWord();
     if (word != FX_BSTRC("{")) {
-        return FALSE;
+        return false;
     }
     return m_MainProc.Parse(parser);
 }
-FX_BOOL CPDF_PSProc::Parse(CPDF_SimpleParser& parser)
+bool CPDF_PSProc::Parse(CPDF_SimpleParser& parser)
 {
     while (1) {
         CFX_ByteStringC word = parser.GetWord();
         if (word.IsEmpty()) {
-            return FALSE;
+            return false;
         }
         if (word == FX_BSTRC("}")) {
-            return TRUE;
+            return true;
         }
         if (word == FX_BSTRC("{")) {
             CPDF_PSProc* pProc = new CPDF_PSProc;
             m_Operators.Add((void*)PSOP_PROC);
             m_Operators.Add(pProc);
             if (!pProc->Parse(parser)) {
-                return FALSE;
+                return false;
             }
         } else {
             int i = 0;
             while (_PDF_PSOpNames[i].name) {
                 if (word == CFX_ByteStringC(_PDF_PSOpNames[i].name)) {
                     m_Operators.Add((void*)_PDF_PSOpNames[i].op);
                     break;
                 }
                 i ++;
             }
             if (_PDF_PSOpNames[i].name == NULL) {
                 FX_FLOAT* pd = FX_Alloc(FX_FLOAT, 1);
                 *pd = FX_atof(word);
                 m_Operators.Add((void*)PSOP_CONST);
                 m_Operators.Add(pd);
             }
         }
     }
 }
 #define PI 3.1415926535897932384626433832795f
-FX_BOOL CPDF_PSEngine::DoOperator(PDF_PSOP op)
+bool CPDF_PSEngine::DoOperator(PDF_PSOP op)
 {
     int i1, i2;
     FX_FLOAT d1, d2;
     switch (op) {
         case PSOP_ADD:
             d1 = Pop();
             d2 = Pop();
             Push(d1 + d2);
             break;
         case PSOP_SUB:
@@ skipping 207 matching lines @@
                         for (ii = 0; ii < n - 1; ii ++) {
                             m_Stack[m_StackCount - ii - 1] = m_Stack[m_StackCount - ii - 2];
                         }
                         m_Stack[m_StackCount - ii - 1] = last;
                     }
                 break;
             }
         default:
             break;
     }
-    return TRUE;
+    return true;
 }
 static FX_FLOAT PDF_Interpolate(FX_FLOAT x, FX_FLOAT xmin, FX_FLOAT xmax, FX_FLOAT ymin, FX_FLOAT ymax)
 {
     return ((x - xmin) * (ymax - ymin) / (xmax - xmin)) + ymin;
 }
 static FX_DWORD _GetBits32(const uint8_t* pData, int bitpos, int nbits)
 {
     int result = 0;
     for (int i = 0; i < nbits; i ++)
         if (pData[(bitpos + i) / 8] & (1 << (7 - (bitpos + i) % 8))) {
             result |= 1 << (nbits - i - 1);
         }
     return result;
 }
 typedef struct {
     FX_FLOAT    encode_max, encode_min;
     int                 sizes;
 } SampleEncodeInfo;
 typedef struct {
     FX_FLOAT    decode_max, decode_min;
 } SampleDecodeInfo;
 class CPDF_SampledFunc : public CPDF_Function
 {
 public:
     CPDF_SampledFunc();
     virtual ~CPDF_SampledFunc();
-    virtual FX_BOOL             v_Init(CPDF_Object* pObj);
-    virtual FX_BOOL             v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;
+    virtual bool                v_Init(CPDF_Object* pObj);
+    virtual bool                v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;
     SampleEncodeInfo*   m_pEncodeInfo;
     SampleDecodeInfo*   m_pDecodeInfo;
     FX_DWORD    m_nBitsPerSample;
     FX_DWORD    m_SampleMax;
     CPDF_StreamAcc*     m_pSampleStream;
 };
 CPDF_SampledFunc::CPDF_SampledFunc()
 {
     m_pSampleStream = NULL;
     m_pEncodeInfo = NULL;
     m_pDecodeInfo = NULL;
 }
 CPDF_SampledFunc::~CPDF_SampledFunc()
 {
     delete m_pSampleStream;
     if (m_pEncodeInfo) {
         FX_Free(m_pEncodeInfo);
     }
     if (m_pDecodeInfo) {
         FX_Free(m_pDecodeInfo);
     }
 }
-FX_BOOL CPDF_SampledFunc::v_Init(CPDF_Object* pObj)
+bool CPDF_SampledFunc::v_Init(CPDF_Object* pObj)
 {
     if (pObj->GetType() != PDFOBJ_STREAM) {
-        return FALSE;
+        return false;
     }
     CPDF_Stream* pStream = (CPDF_Stream*)pObj;
     CPDF_Dictionary* pDict = pStream->GetDict();
     CPDF_Array* pSize = pDict->GetArray(FX_BSTRC("Size"));
     CPDF_Array* pEncode = pDict->GetArray(FX_BSTRC("Encode"));
     CPDF_Array* pDecode = pDict->GetArray(FX_BSTRC("Decode"));
     m_nBitsPerSample = pDict->GetInteger(FX_BSTRC("BitsPerSample"));
     if (m_nBitsPerSample > 32) {
-        return FALSE;
+        return false;
     }
     m_SampleMax = 0xffffffff >> (32 - m_nBitsPerSample);
     m_pSampleStream = new CPDF_StreamAcc;
-    m_pSampleStream->LoadAllData(pStream, FALSE);
+    m_pSampleStream->LoadAllData(pStream, false);
     m_pEncodeInfo = FX_Alloc(SampleEncodeInfo, m_nInputs);
     FX_SAFE_DWORD nTotalSampleBits = 1;
     for (int i = 0; i < m_nInputs; i ++) {
         m_pEncodeInfo[i].sizes = pSize ? pSize->GetInteger(i) : 0;
         if (!pSize && i == 0) {
             m_pEncodeInfo[i].sizes = pDict->GetInteger(FX_BSTRC("Size"));
         }
         nTotalSampleBits *= m_pEncodeInfo[i].sizes;
         if (pEncode) {
             m_pEncodeInfo[i].encode_min = pEncode->GetFloat(i * 2);
             m_pEncodeInfo[i].encode_max = pEncode->GetFloat(i * 2 + 1);
         } else {
             m_pEncodeInfo[i].encode_min = 0;
             if (m_pEncodeInfo[i].sizes == 1) {
                 m_pEncodeInfo[i].encode_max = 1;
             } else {
                 m_pEncodeInfo[i].encode_max = (FX_FLOAT)m_pEncodeInfo[i].sizes - 1;
             }
         }
     }
     nTotalSampleBits *= m_nBitsPerSample;
     nTotalSampleBits *= m_nOutputs;
     FX_SAFE_DWORD nTotalSampleBytes = nTotalSampleBits;
     nTotalSampleBytes += 7;
     nTotalSampleBytes /= 8;
     if (!nTotalSampleBytes.IsValid() ||
         nTotalSampleBytes.ValueOrDie() == 0 ||
         nTotalSampleBytes.ValueOrDie() > m_pSampleStream->GetSize()) {
-        return FALSE;
+        return false;
     }
     m_pDecodeInfo = FX_Alloc(SampleDecodeInfo, m_nOutputs);
     for (int i = 0; i < m_nOutputs; i ++) {
         if (pDecode) {
             m_pDecodeInfo[i].decode_min = pDecode->GetFloat(2 * i);
             m_pDecodeInfo[i].decode_max = pDecode->GetFloat(2 * i + 1);
         } else {
             m_pDecodeInfo[i].decode_min = m_pRanges[i * 2];
             m_pDecodeInfo[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<int, 32> int_buf(m_nInputs * 2);
     int* index = int_buf;
     int* blocksize = index + m_nInputs;
     for (int i = 0; i < m_nInputs; i ++) {
         if (i == 0) {
             blocksize[i] = 1;
         } else {
             blocksize[i] = blocksize[i - 1] * m_pEncodeInfo[i - 1].sizes;
         }
         encoded_input[i] = PDF_Interpolate(inputs[i], m_pDomains[i * 2], m_pDomains[i * 2 + 1],
                                            m_pEncodeInfo[i].encode_min, m_pEncodeInfo[i].encode_max);
         index[i] = (int)encoded_input[i];
         if (index[i] < 0) {
             index[i] = 0;
         } else if (index[i] > m_pEncodeInfo[i].sizes - 1) {
             index[i] = m_pEncodeInfo[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 (int j = 0; j < m_nOutputs; j ++) {
         FX_DWORD sample = _GetBits32(pSampleData, bitpos.ValueOrDie() + j * m_nBitsPerSample, m_nBitsPerSample);
         FX_FLOAT encoded = (FX_FLOAT)sample;
         for (int i = 0; i < m_nInputs; i ++) {
             if (index[i] == m_pEncodeInfo[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;
                 }
                 FX_DWORD 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_pDecodeInfo[j].decode_min, m_pDecodeInfo[j].decode_max);
     }
-    return TRUE;
+    return true;
 }
 class CPDF_PSFunc : public CPDF_Function
 {
 public:
-    virtual FX_BOOL             v_Init(CPDF_Object* pObj);
-    virtual FX_BOOL             v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;
+    virtual bool                v_Init(CPDF_Object* pObj);
+    virtual bool                v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;
     CPDF_PSEngine m_PS;
 };
-FX_BOOL CPDF_PSFunc::v_Init(CPDF_Object* pObj)
+bool CPDF_PSFunc::v_Init(CPDF_Object* pObj)
 {
     CPDF_Stream* pStream = (CPDF_Stream*)pObj;
     CPDF_StreamAcc acc;
-    acc.LoadAllData(pStream, FALSE);
+    acc.LoadAllData(pStream, false);
     return m_PS.Parse((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 = (CPDF_PSEngine&)m_PS;
     PS.Reset();
     int i;
     for (i = 0; i < m_nInputs; i ++) {
         PS.Push(inputs[i]);
     }
     PS.Execute();
     if (PS.GetStackSize() < m_nOutputs) {
-        return FALSE;
+        return false;
     }
     for (i = 0; i < m_nOutputs; i ++) {
         results[m_nOutputs - i - 1] = PS.Pop();
     }
-    return TRUE;
+    return true;
 }
 class CPDF_ExpIntFunc : public CPDF_Function
 {
 public:
     CPDF_ExpIntFunc();
     virtual ~CPDF_ExpIntFunc();
-    virtual FX_BOOL             v_Init(CPDF_Object* pObj);
-    virtual FX_BOOL             v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;
+    virtual bool                v_Init(CPDF_Object* pObj);
+    virtual bool                v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;
     FX_FLOAT    m_Exponent;
     FX_FLOAT*   m_pBeginValues;
     FX_FLOAT*   m_pEndValues;
     int         m_nOrigOutputs;
 };
 CPDF_ExpIntFunc::CPDF_ExpIntFunc()
 {
     m_pBeginValues = NULL;
     m_pEndValues = NULL;
 }
 CPDF_ExpIntFunc::~CPDF_ExpIntFunc()
 {
     if (m_pBeginValues) {
         FX_Free(m_pBeginValues);
     }
     if (m_pEndValues) {
         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 == NULL) {
-        return FALSE;
+        return false;
     }
     CPDF_Array* pArray0 = pDict->GetArray(FX_BSTRC("C0"));
     if (m_nOutputs == 0) {
         m_nOutputs = 1;
         if (pArray0) {
             m_nOutputs = pArray0->GetCount();
         }
     }
     CPDF_Array* pArray1 = pDict->GetArray(FX_BSTRC("C1"));
     m_pBeginValues = FX_Alloc2D(FX_FLOAT, m_nOutputs, 2);
     m_pEndValues = FX_Alloc2D(FX_FLOAT, m_nOutputs, 2);
     for (int i = 0; i < m_nOutputs; i ++) {
         m_pBeginValues[i] = pArray0 ? pArray0->GetFloat(i) : 0.0f;
         m_pEndValues[i] = pArray1 ? pArray1->GetFloat(i) : 1.0f;
     }
     m_Exponent = pDict->GetFloat(FX_BSTRC("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 (int i = 0; i < m_nInputs; i ++)
         for (int 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;
 }
 class CPDF_StitchFunc : public CPDF_Function
 {
 public:
     CPDF_StitchFunc();
     virtual ~CPDF_StitchFunc();
-    virtual FX_BOOL             v_Init(CPDF_Object* pObj);
-    virtual FX_BOOL             v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;
+    virtual bool                v_Init(CPDF_Object* pObj);
+    virtual bool                v_Call(FX_FLOAT* inputs, FX_FLOAT* results) const;
     int                 m_nSubs;
     CPDF_Function** m_pSubFunctions;
     FX_FLOAT*   m_pBounds;
     FX_FLOAT*   m_pEncode;
 };
 CPDF_StitchFunc::CPDF_StitchFunc()
 {
     m_nSubs = 0;
     m_pSubFunctions = NULL;
     m_pBounds = NULL;
     m_pEncode = NULL;
 }
 CPDF_StitchFunc::~CPDF_StitchFunc()
 {
     for (int i = 0; i < m_nSubs; i ++)
         delete m_pSubFunctions[i];
     if (m_pSubFunctions) {
         FX_Free(m_pSubFunctions);
     }
     if (m_pBounds) {
         FX_Free(m_pBounds);
     }
     if (m_pEncode) {
         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 == NULL) {
-        return FALSE;
+        return false;
     }
     CPDF_Array* pArray = pDict->GetArray(FX_BSTRC("Functions"));
     if (pArray == NULL) {
-        return FALSE;
+        return false;
     }
     m_nSubs = pArray->GetCount();
     if (m_nSubs == 0) {
-        return FALSE;
+        return false;
     }
     m_pSubFunctions = FX_Alloc(CPDF_Function*, m_nSubs);
     m_nOutputs = 0;
     int i;
     for (i = 0; i < m_nSubs; i ++) {
         CPDF_Object* pSub = pArray->GetElementValue(i);
         if (pSub == pObj) {
-            return FALSE;
+            return false;
         }
         m_pSubFunctions[i] = CPDF_Function::Load(pSub);
         if (m_pSubFunctions[i] == NULL) {
-            return FALSE;
+            return false;
         }
         if (m_pSubFunctions[i]->CountOutputs() > m_nOutputs) {
             m_nOutputs = m_pSubFunctions[i]->CountOutputs();
         }
     }
     m_pBounds = FX_Alloc(FX_FLOAT, m_nSubs + 1);
     m_pBounds[0] = m_pDomains[0];
     pArray = pDict->GetArray(FX_BSTRC("Bounds"));
     if (pArray == NULL) {
-        return FALSE;
+        return false;
     }
     for (i = 0; i < m_nSubs - 1; i ++) {
         m_pBounds[i + 1] = pArray->GetFloat(i);
     }
     m_pBounds[m_nSubs] = m_pDomains[1];
     m_pEncode = FX_Alloc2D(FX_FLOAT, m_nSubs, 2);
     pArray = pDict->GetArray(FX_BSTRC("Encode"));
     if (pArray == NULL) {
-        return FALSE;
+        return false;
     }
     for (i = 0; i < m_nSubs * 2; i ++) {
         m_pEncode[i] = pArray->GetFloat(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];
     int i;
     for (i = 0; i < m_nSubs - 1; i ++)
         if (input < m_pBounds[i + 1]) {
             break;
         }
     if (m_pSubFunctions[i] == NULL) {
-        return FALSE;
+        return false;
     }
     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, m_nInputs, outputs, nresults);
-    return TRUE;
+    return true;
 }
 CPDF_Function* CPDF_Function::Load(CPDF_Object* pFuncObj)
 {
     if (pFuncObj == NULL) {
         return NULL;
     }
     CPDF_Function* pFunc = NULL;
     int type;
     if (pFuncObj->GetType() == PDFOBJ_STREAM) {
         type = ((CPDF_Stream*)pFuncObj)->GetDict()->GetInteger(FX_BSTRC("FunctionType"));
@@ skipping 28 matching lines @@
 {
     if (m_pDomains) {
         FX_Free(m_pDomains);
         m_pDomains = NULL;
     }
     if (m_pRanges) {
         FX_Free(m_pRanges);
         m_pRanges = NULL;
     }
 }
-FX_BOOL CPDF_Function::Init(CPDF_Object* pObj)
+bool CPDF_Function::Init(CPDF_Object* pObj)
 {
     CPDF_Dictionary* pDict;
     if (pObj->GetType() == PDFOBJ_STREAM) {
         pDict = ((CPDF_Stream*)pObj)->GetDict();
     } else {
         pDict = (CPDF_Dictionary*)pObj;
     }
     CPDF_Array* pDomains = pDict->GetArray(FX_BSTRC("Domain"));
     if (pDomains == NULL) {
-        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 (int i = 0; i < m_nInputs * 2; i ++) {
         m_pDomains[i] = pDomains->GetFloat(i);
     }
     CPDF_Array* pRanges = pDict->GetArray(FX_BSTRC("Range"));
     m_nOutputs = 0;
     if (pRanges) {
         m_nOutputs = pRanges->GetCount() / 2;
         m_pRanges = FX_Alloc2D(FX_FLOAT, m_nOutputs, 2);
         for (int i = 0; i < m_nOutputs * 2; i ++) {
             m_pRanges[i] = pRanges->GetFloat(i);
         }
     }
     FX_DWORD old_outputs = m_nOutputs;
     if (!v_Init(pObj)) {
-        return FALSE;
+        return false;
     }
     if (m_pRanges && m_nOutputs > (int)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, int ninputs, FX_FLOAT* results, int& nresults) const
+bool CPDF_Function::Call(FX_FLOAT* inputs, int ninputs, FX_FLOAT* results, int& nresults) const
 {
     if (m_nInputs != ninputs) {
-        return FALSE;
+        return false;
     }
     nresults = m_nOutputs;
     for (int 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 (int 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;
 }