FX_BOOL considered harmful.

core/src/fxcodec/codec/fx_codec.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/fxcodec/fx_codec.h"
 #include "codec_int.h"
 CCodec_ModuleMgr::CCodec_ModuleMgr()
   : m_pBasicModule(new CCodec_BasicModule),
@@ skipping 31 matching lines @@
         m_NextLine = 0;
     }
     while (m_NextLine < line) {
         ReadNextLine();
         m_NextLine ++;
     }
     m_pLastScanline = ReadNextLine();
     m_NextLine ++;
     return m_pLastScanline;
 }
-FX_BOOL CCodec_ScanlineDecoder::SkipToScanline(int line, IFX_Pause* pPause)
+bool CCodec_ScanlineDecoder::SkipToScanline(int line, IFX_Pause* pPause)
 {
     if (m_pDataCache && line < m_pDataCache->m_nCachedLines) {
-        return FALSE;
+        return false;
     }
     if (m_NextLine == line || m_NextLine == line + 1) {
-        return FALSE;
+        return false;
     }
     if (m_NextLine < 0 || m_NextLine > line) {
         v_Rewind();
         m_NextLine = 0;
     }
     m_pLastScanline = NULL;
     while (m_NextLine < line) {
         m_pLastScanline = ReadNextLine();
         m_NextLine ++;
         if (pPause && pPause->NeedToPauseNow()) {
-            return TRUE;
+            return true;
         }
     }
-    return FALSE;
+    return false;
 }
 uint8_t* CCodec_ScanlineDecoder::ReadNextLine()
 {
     uint8_t* pLine = v_GetNextLine();
     if (pLine == NULL) {
         return NULL;
     }
     if (m_pDataCache && m_NextLine == m_pDataCache->m_nCachedLines) {
         FXSYS_memcpy(&m_pDataCache->m_Data + m_NextLine * m_Pitch, pLine, m_Pitch);
         m_pDataCache->m_nCachedLines ++;
@@ skipping 17 matching lines @@
         m_pDataCache = NULL;
     }
     m_pDataCache = (CCodec_ImageDataCache*)FX_TryAlloc(uint8_t, sizeof(CCodec_ImageDataCache) + m_Pitch * m_OutputHeight);
     if (m_pDataCache == NULL) {
         return;
     }
     m_pDataCache->m_Height = m_OutputHeight;
     m_pDataCache->m_Width = m_OutputWidth;
     m_pDataCache->m_nCachedLines = 0;
 }
-FX_BOOL CCodec_BasicModule::RunLengthEncode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf,
+bool CCodec_BasicModule::RunLengthEncode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf,
         FX_DWORD& dest_size)
 {
-    return FALSE;
+    return false;
 }
 extern "C" double FXstrtod(const char* nptr, char** endptr)
 {
     double ret = 0.0;
     const char* ptr = nptr;
     const char* exp_ptr = NULL;
     int e_number = 0,
         e_signal = 0,
         e_point = 0,
         is_negative = 0;
@@ skipping 85 matching lines @@
         while(exp_ret--) {
             ret *= 10.0;
         }
     } else {
         while(exp_ret--) {
             ret /= 10.0;
         }
     }
     return is_negative ? -ret : ret;
 }
-FX_BOOL CCodec_BasicModule::A85Encode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf,
+bool CCodec_BasicModule::A85Encode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf,
                                       FX_DWORD& dest_size)
 {
-    return FALSE;
+    return false;
 }
 class CCodec_RLScanlineDecoder : public CCodec_ScanlineDecoder
 {
 public:
     CCodec_RLScanlineDecoder();
     virtual ~CCodec_RLScanlineDecoder();
-    FX_BOOL                             Create(const uint8_t* src_buf, FX_DWORD src_size, int width, int height, int nComps, int bpc);
+    bool                                Create(const uint8_t* src_buf, FX_DWORD src_size, int width, int height, int nComps, int bpc);
     virtual void                v_DownScale(int dest_width, int dest_height) {}
-    virtual FX_BOOL             v_Rewind();
+    virtual bool                v_Rewind();
     virtual uint8_t*    v_GetNextLine();
     virtual FX_DWORD    GetSrcOffset()
     {
         return m_SrcOffset;
     }
 protected:
-    FX_BOOL                             CheckDestSize();
+    bool                                CheckDestSize();
     void                                GetNextOperator();
     void                                UpdateOperator(uint8_t used_bytes);
 
     uint8_t*                    m_pScanline;
     const uint8_t*                      m_pSrcBuf;
     FX_DWORD                    m_SrcSize;
     FX_DWORD                    m_dwLineBytes;
     FX_DWORD                    m_SrcOffset;
-    FX_BOOL                             m_bEOD;
+    bool                                m_bEOD;
     uint8_t                             m_Operator;
 };
 CCodec_RLScanlineDecoder::CCodec_RLScanlineDecoder()
     : m_pScanline(NULL)
     , m_pSrcBuf(NULL)
     , m_SrcSize(0)
     , m_dwLineBytes(0)
     , m_SrcOffset(0)
-    , m_bEOD(FALSE)
+    , m_bEOD(false)
     , m_Operator(0)
 {
 }
 CCodec_RLScanlineDecoder::~CCodec_RLScanlineDecoder()
 {
     if (m_pScanline) {
         FX_Free(m_pScanline);
     }
 }
-FX_BOOL CCodec_RLScanlineDecoder::CheckDestSize()
+bool CCodec_RLScanlineDecoder::CheckDestSize()
 {
     FX_DWORD i = 0;
     FX_DWORD old_size = 0;
     FX_DWORD dest_size = 0;
     while (i < m_SrcSize) {
         if (m_pSrcBuf[i] < 128) {
             old_size = dest_size;
             dest_size += m_pSrcBuf[i] + 1;
             if (dest_size < old_size) {
-                return FALSE;
+                return false;
             }
             i += m_pSrcBuf[i] + 2;
         } else if (m_pSrcBuf[i] > 128) {
             old_size = dest_size;
             dest_size += 257 - m_pSrcBuf[i];
             if (dest_size < old_size) {
-                return FALSE;
+                return false;
             }
             i += 2;
         } else {
             break;
         }
     }
     if (((FX_DWORD)m_OrigWidth * m_nComps * m_bpc * m_OrigHeight + 7) / 8 > dest_size) {
-        return FALSE;
+        return false;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CCodec_RLScanlineDecoder::Create(const uint8_t* src_buf, FX_DWORD src_size, int width, int height, int nComps, int bpc)
+bool CCodec_RLScanlineDecoder::Create(const uint8_t* src_buf, FX_DWORD src_size, int width, int height, int nComps, int bpc)
 {
     m_pSrcBuf = src_buf;
     m_SrcSize = src_size;
     m_OutputWidth = m_OrigWidth = width;
     m_OutputHeight = m_OrigHeight = height;
     m_nComps = nComps;
     m_bpc = bpc;
-    m_bColorTransformed = FALSE;
+    m_bColorTransformed = false;
     m_DownScale = 1;
     m_Pitch = (width * nComps * bpc + 31) / 32 * 4;
     m_dwLineBytes = (width * nComps * bpc + 7) / 8;
     m_pScanline = FX_Alloc(uint8_t, m_Pitch);
     return CheckDestSize();
 }
-FX_BOOL CCodec_RLScanlineDecoder::v_Rewind()
+bool CCodec_RLScanlineDecoder::v_Rewind()
 {
     FXSYS_memset(m_pScanline, 0, m_Pitch);
     m_SrcOffset = 0;
-    m_bEOD = FALSE;
+    m_bEOD = false;
     m_Operator = 0;
-    return TRUE;
+    return true;
 }
 uint8_t* CCodec_RLScanlineDecoder::v_GetNextLine()
 {
     if (m_SrcOffset == 0) {
         GetNextOperator();
     } else {
         if (m_bEOD) {
             return NULL;
         }
     }
     FXSYS_memset(m_pScanline, 0, m_Pitch);
     FX_DWORD col_pos = 0;
-    FX_BOOL     eol = FALSE;
+    bool        eol = false;
     while (m_SrcOffset < m_SrcSize && !eol) {
         if (m_Operator < 128) {
             FX_DWORD copy_len = m_Operator + 1;
             if (col_pos + copy_len >= m_dwLineBytes) {
                 copy_len = m_dwLineBytes - col_pos;
-                eol = TRUE;
+                eol = true;
             }
             if (copy_len >= m_SrcSize - m_SrcOffset) {
                 copy_len = m_SrcSize - m_SrcOffset;
-                m_bEOD = TRUE;
+                m_bEOD = true;
             }
             FXSYS_memcpy(m_pScanline + col_pos, m_pSrcBuf + m_SrcOffset, copy_len);
             col_pos += copy_len;
             UpdateOperator((uint8_t)copy_len);
         } else if (m_Operator > 128) {
             int fill = 0;
             if (m_SrcOffset - 1 < m_SrcSize - 1) {
                 fill = m_pSrcBuf[m_SrcOffset];
             }
             FX_DWORD duplicate_len = 257 - m_Operator;
             if (col_pos + duplicate_len >= m_dwLineBytes) {
                 duplicate_len = m_dwLineBytes - col_pos;
-                eol = TRUE;
+                eol = true;
             }
             FXSYS_memset(m_pScanline + col_pos, fill, duplicate_len);
             col_pos += duplicate_len;
             UpdateOperator((uint8_t)duplicate_len);
         } else {
-            m_bEOD = TRUE;
+            m_bEOD = true;
             break;
         }
     }
     return m_pScanline;
 }
 void CCodec_RLScanlineDecoder::GetNextOperator()
 {
     if (m_SrcOffset >= m_SrcSize) {
         m_Operator = 128;
         return;
@@ skipping 33 matching lines @@
 ICodec_ScanlineDecoder* CCodec_BasicModule::CreateRunLengthDecoder(const uint8_t* src_buf, FX_DWORD src_size, int width, int height,
         int nComps, int bpc)
 {
     CCodec_RLScanlineDecoder* pRLScanlineDecoder = new CCodec_RLScanlineDecoder;
     if (!pRLScanlineDecoder->Create(src_buf, src_size, width, height, nComps, bpc)) {
         delete pRLScanlineDecoder;
         return NULL;
     }
     return pRLScanlineDecoder;
 }