FX_BOOL considered harmful.

core/src/fpdfapi/fpdf_parser/fpdf_parser_filters.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/fpdfapi/fpdf_parser.h"
 #include "../../../include/fxcodec/fx_codec.h"
 #include "../../../include/fxcodec/fx_codec_flate.h"
 #include "../../../include/fpdfapi/fpdf_module.h"
 #include "filters_int.h"
 
 extern "C" {
 
 static void* my_alloc_func(void* opaque, unsigned int items, unsigned int size)
 {
     return FX_Alloc2D(uint8_t, items, size);
 }
 static void my_free_func(void* opaque, void* address)
 {
     FX_Free(address);
 }
 
 }  // extern "C"
 
 CFX_DataFilter::CFX_DataFilter()
 {
-    m_bEOF = FALSE;
+    m_bEOF = false;
     m_pDestFilter = NULL;
     m_SrcPos = 0;
 }
 CFX_DataFilter::~CFX_DataFilter()
 {
     delete m_pDestFilter;
 }
 void CFX_DataFilter::SetDestFilter(CFX_DataFilter* pFilter)
 {
     if (m_pDestFilter) {
@@ skipping 22 matching lines @@
     if (m_pDestFilter) {
         CFX_BinaryBuf temp_buf;
         v_FilterFinish(temp_buf);
         if (temp_buf.GetSize()) {
             m_pDestFilter->FilterIn(temp_buf.GetBuffer(), temp_buf.GetSize(), dest_buf);
         }
         m_pDestFilter->FilterFinish(dest_buf);
     } else {
         v_FilterFinish(dest_buf);
     }
-    m_bEOF = TRUE;
+    m_bEOF = true;
 }
 void CFX_DataFilter::ReportEOF(FX_DWORD left_input)
 {
     if (m_bEOF) {
         return;
     }
-    m_bEOF = TRUE;
+    m_bEOF = true;
     m_SrcPos -= left_input;
 }
 CFX_DataFilter* FPDF_CreateFilter(const CFX_ByteStringC& name, const CPDF_Dictionary* pParam, int width, int height)
 {
     FX_DWORD id = name.GetID();
     switch (id) {
         case FXBSTR_ID('F', 'l', 'a', 't'):
         case FXBSTR_ID('F', 'l', 0, 0):
         case FXBSTR_ID('L', 'Z', 'W', 'D'):
         case FXBSTR_ID('L', 'Z', 'W', 0): {
@@ skipping 17 matching lines @@
             }
             return new CPDF_Ascii85Filter;
         case FXBSTR_ID('A', 'H', 'x', 0):
             return new CPDF_AsciiHexFilter;
         case FXBSTR_ID('A', '8', '5', 0):
             return new CPDF_Ascii85Filter;
         case FXBSTR_ID('R', 'u', 'n', 'L'):
             return new CPDF_RunLenFilter;
         case FXBSTR_ID('C', 'C', 'I', 'T'): {
                 int Encoding = 0;
-                int bEndOfLine = FALSE;
-                int bByteAlign = FALSE;
-                int bBlack = FALSE;
+                int bEndOfLine = false;
+                int bByteAlign = false;
+                int bBlack = false;
                 int nRows = 0;
                 int nColumns = 1728;
                 if (pParam) {
                     Encoding = pParam->GetInteger(FX_BSTRC("K"));
                     bEndOfLine = pParam->GetInteger(FX_BSTRC("EndOfLine"));
                     bByteAlign = pParam->GetInteger(FX_BSTRC("EncodedByteAlign"));
                     bBlack = pParam->GetInteger(FX_BSTRC("BlackIs1"));
                     nColumns = pParam->GetInteger(FX_BSTRC("Columns"), 1728);
                     nRows = pParam->GetInteger(FX_BSTRC("Rows"));
                 }
@@ skipping 42 matching lines @@
             }
         }
     } else {
         if (pParams && pParams->GetType() != PDFOBJ_DICTIONARY) {
             pParams = NULL;
         }
         pFirstFilter = FPDF_CreateFilter(pDecoder->GetString(), (CPDF_Dictionary*)pParams, width, height);
     }
     return pFirstFilter;
 }
-CPDF_StreamFilter* CPDF_Stream::GetStreamFilter(FX_BOOL bRaw) const
+CPDF_StreamFilter* CPDF_Stream::GetStreamFilter(bool bRaw) const
 {
     CFX_DataFilter* pFirstFilter = NULL;
     if (m_pCryptoHandler) {
         pFirstFilter = new CPDF_DecryptFilter(m_pCryptoHandler, m_ObjNum, m_GenNum);
     }
     if (!bRaw) {
         CFX_DataFilter* pFilter = _FPDF_CreateFilterFromDict(m_pDict);
         if (pFilter) {
             if (pFirstFilter == NULL) {
                 pFirstFilter = pFilter;
@@ skipping 95 matching lines @@
 }
 void CPDF_DecryptFilter::v_FilterIn(const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf)
 {
     if (m_pContext == NULL) {
         m_pContext = m_pCryptoHandler->DecryptStart(m_ObjNum, m_GenNum);
     }
     m_pCryptoHandler->DecryptStream(m_pContext, src_buf, src_size, dest_buf);
 }
 void CPDF_DecryptFilter::v_FilterFinish(CFX_BinaryBuf& dest_buf)
 {
-    m_bEOF = TRUE;
+    m_bEOF = true;
     if (m_pContext == NULL) {
         return;
     }
     m_pCryptoHandler->DecryptFinish(m_pContext, dest_buf);
     m_pContext = NULL;
 }
 CPDF_FlateFilter::CPDF_FlateFilter()
 {
     m_pContext = NULL;
 }
@@ skipping 15 matching lines @@
         dest_buf.AppendBlock(m_DestBuffer, out_size);
         if (ret == Z_BUF_ERROR) {
             break;
         }
         if (ret != Z_OK) {
             ReportEOF(FPDFAPI_FlateGetAvailIn(m_pContext));
             break;
         }
     }
 }
-CPDF_LzwFilter::CPDF_LzwFilter(FX_BOOL bEarlyChange)
+CPDF_LzwFilter::CPDF_LzwFilter(bool bEarlyChange)
 {
     m_bEarlyChange = bEarlyChange ? 1 : 0;
     m_CodeLen = 9;
     m_nCodes = 0;
     m_nLeftBits = 0;
     m_LeftBits = 0;
     m_OldCode = (FX_DWORD) - 1;
 }
 void CPDF_LzwFilter::v_FilterIn(const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf)
 {
@@ skipping 346 matching lines @@
                     FXSYS_memset(dest_buf.GetBuffer() + dest_buf.GetSize() - m_Count, byte, m_Count);
                     m_State = 0;
                     break;
                 }
         }
     }
 }
 CPDF_JpegFilter::CPDF_JpegFilter()
 {
     m_pContext = NULL;
-    m_bGotHeader = FALSE;
+    m_bGotHeader = false;
     m_pScanline = NULL;
     m_iLine = 0;
 }
 CPDF_JpegFilter::~CPDF_JpegFilter()
 {
     if (m_pScanline) {
         FX_Free(m_pScanline);
     }
     if (m_pContext) {
         CPDF_ModuleMgr::Get()->GetJpegModule()->Finish(m_pContext);
@@ skipping 24 matching lines @@
         int left_size = CPDF_ModuleMgr::Get()->GetJpegModule()->GetAvailInput(m_pContext);
         if (ret == 1) {
             ReportEOF(left_size);
             return;
         }
         if (ret == 2) {
             m_InputBuf.AppendBlock(jpeg_src_buf + jpeg_src_size - left_size, left_size);
             return;
         }
         CPDF_ModuleMgr::Get()->GetJpegModule()->StartScanline(m_pContext, 1);
-        m_bGotHeader = TRUE;
+        m_bGotHeader = true;
         m_Pitch = m_Width * m_nComps;
     }
     if (m_pScanline == NULL) {
         m_pScanline = FX_Alloc(uint8_t, m_Pitch + 4);
     }
     while (1) {
         if (!CPDF_ModuleMgr::Get()->GetJpegModule()->ReadScanline(m_pContext, m_pScanline)) {
             int left_size = CPDF_ModuleMgr::Get()->GetJpegModule()->GetAvailInput(m_pContext);
             m_InputBuf.AppendBlock(jpeg_src_buf + jpeg_src_size - left_size, left_size);
             break;
         }
         dest_buf.AppendBlock(m_pScanline, m_Pitch);
         m_iLine ++;
         if (m_iLine == m_Height) {
             ReportEOF(CPDF_ModuleMgr::Get()->GetJpegModule()->GetAvailInput(m_pContext));
             return;
         }
     }
 }
 CPDF_FaxFilter::CPDF_FaxFilter()
 {
     m_Encoding = 0;
-    m_bEndOfLine = FALSE;
-    m_bByteAlign = FALSE;
-    m_bBlack = FALSE;
+    m_bEndOfLine = false;
+    m_bByteAlign = false;
+    m_bBlack = false;
     m_nRows = 0;
     m_nColumns = 0;
     m_Pitch = 0;
     m_pScanlineBuf = NULL;
     m_pRefBuf = NULL;
     m_iRow = 0;
     m_InputBitPos = 0;
 }
 CPDF_FaxFilter::~CPDF_FaxFilter()
 {
     if (m_pScanlineBuf) {
         FX_Free(m_pScanlineBuf);
     }
     if (m_pRefBuf) {
         FX_Free(m_pRefBuf);
     }
 }
-FX_BOOL CPDF_FaxFilter::Initialize(int Encoding, int bEndOfLine, int bByteAlign, int bBlack, int nRows, int nColumns)
+bool CPDF_FaxFilter::Initialize(int Encoding, int bEndOfLine, int bByteAlign, int bBlack, int nRows, int nColumns)
 {
     m_Encoding = Encoding;
     m_bEndOfLine = bEndOfLine;
     m_bByteAlign = bByteAlign;
     m_bBlack = bBlack;
     m_nRows = nRows;
     m_nColumns = nColumns;
     m_Pitch = (m_nColumns + 7) / 8;
     m_pScanlineBuf = FX_Alloc(uint8_t, m_Pitch);
     m_pRefBuf = FX_Alloc(uint8_t, m_Pitch);
     FXSYS_memset(m_pScanlineBuf, 0xff, m_Pitch);
     FXSYS_memset(m_pRefBuf, 0xff, m_Pitch);
     m_iRow = 0;
     m_InputBitPos = 0;
-    return TRUE;
+    return true;
 }
 void CPDF_FaxFilter::v_FilterIn(const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf)
 {
     const uint8_t* fax_src_buf;
     FX_DWORD fax_src_size;
     CFX_BinaryBuf temp_buf;
     int bitpos;
     if (m_InputBuf.GetSize()) {
         temp_buf.EstimateSize(m_InputBuf.GetSize() + src_size);
         temp_buf.AppendBlock(m_InputBuf.GetBuffer(), m_InputBuf.GetSize());
         m_InputBuf.Clear();
         temp_buf.AppendBlock(src_buf, src_size);
         fax_src_buf = temp_buf.GetBuffer();
         fax_src_size = temp_buf.GetSize();
         bitpos = m_InputBitPos;
     } else {
         fax_src_buf = src_buf;
         fax_src_size = src_size;
         bitpos = 0;
     }
-    ProcessData(fax_src_buf, fax_src_size, bitpos, FALSE, dest_buf);
+    ProcessData(fax_src_buf, fax_src_size, bitpos, false, dest_buf);
     int left_bits = fax_src_size * 8 - bitpos;
     m_InputBuf.AppendBlock(fax_src_buf + bitpos / 8, (left_bits + 7) / 8);
     m_InputBitPos = bitpos % 8;
 }
 void CPDF_FaxFilter::v_FilterFinish(CFX_BinaryBuf& dest_buf)
 {
-    ProcessData(m_InputBuf.GetBuffer(), m_InputBuf.GetSize(), m_InputBitPos, TRUE, dest_buf);
+    ProcessData(m_InputBuf.GetBuffer(), m_InputBuf.GetSize(), m_InputBitPos, true, dest_buf);
 }
-FX_BOOL _FaxSkipEOL(const uint8_t* src_buf, int bitsize, int& bitpos);
-FX_BOOL _FaxG4GetRow(const uint8_t* src_buf, int bitsize, int& bitpos, uint8_t* dest_buf, const uint8_t* ref_buf, int columns);
-FX_BOOL _FaxGet1DLine(const uint8_t* src_buf, int bitsize, int& bitpos, uint8_t* dest_buf, int columns);
-void CPDF_FaxFilter::ProcessData(const uint8_t* src_buf, FX_DWORD src_size, int& bitpos, FX_BOOL bFinish,
+bool _FaxSkipEOL(const uint8_t* src_buf, int bitsize, int& bitpos);
+bool _FaxG4GetRow(const uint8_t* src_buf, int bitsize, int& bitpos, uint8_t* dest_buf, const uint8_t* ref_buf, int columns);
+bool _FaxGet1DLine(const uint8_t* src_buf, int bitsize, int& bitpos, uint8_t* dest_buf, int columns);
+void CPDF_FaxFilter::ProcessData(const uint8_t* src_buf, FX_DWORD src_size, int& bitpos, bool bFinish,
                                  CFX_BinaryBuf& dest_buf)
 {
     int bitsize = src_size * 8;
     while (1) {
         if ((bitsize < bitpos + 256) && !bFinish) {
             return;
         }
         int start_bitpos = bitpos;
         FXSYS_memset(m_pScanlineBuf, 0xff, m_Pitch);
         if (!ReadLine(src_buf, bitsize, bitpos)) {
             bitpos = start_bitpos;
             return;
         }
         if (m_Encoding) {
             FXSYS_memcpy(m_pRefBuf, m_pScanlineBuf, m_Pitch);
         }
         if (m_bBlack) {
             for (int i = 0; i < m_Pitch; i ++) {
                 m_pScanlineBuf[i] = ~m_pScanlineBuf[i];
             }
         }
         dest_buf.AppendBlock(m_pScanlineBuf, m_Pitch);
         m_iRow ++;
         if (m_iRow == m_nRows) {
             ReportEOF(src_size - (bitpos + 7) / 8);
             return;
         }
     }
 }
-FX_BOOL CPDF_FaxFilter::ReadLine(const uint8_t* src_buf, int bitsize, int& bitpos)
+bool CPDF_FaxFilter::ReadLine(const uint8_t* src_buf, int bitsize, int& bitpos)
 {
     if (!_FaxSkipEOL(src_buf, bitsize, bitpos)) {
-        return FALSE;
+        return false;
     }
-    FX_BOOL ret;
+    bool ret;
     if (m_Encoding < 0) {
         ret = _FaxG4GetRow(src_buf, bitsize, bitpos, m_pScanlineBuf, m_pRefBuf, m_nColumns);
     } else if (m_Encoding == 0) {
         ret = _FaxGet1DLine(src_buf, bitsize, bitpos, m_pScanlineBuf, m_nColumns);
     } else {
         if (bitpos == bitsize) {
-            return FALSE;
+            return false;
         }
-        FX_BOOL bNext1D = src_buf[bitpos / 8] & (1 << (7 - bitpos % 8));
+        bool bNext1D = src_buf[bitpos / 8] & (1 << (7 - bitpos % 8));
         bitpos ++;
         if (bNext1D) {
             ret = _FaxGet1DLine(src_buf, bitsize, bitpos, m_pScanlineBuf, m_nColumns);
         } else {
             ret = _FaxG4GetRow(src_buf, bitsize, bitpos, m_pScanlineBuf, m_pRefBuf, m_nColumns);
         }
     }
     if (!ret) {
-        return FALSE;
+        return false;
     }
     if (m_bEndOfLine)
         if (!_FaxSkipEOL(src_buf, bitsize, bitpos)) {
-            return FALSE;
+            return false;
         }
     if (m_bByteAlign) {
         bitpos = (bitpos + 7) / 8 * 8;
     }
-    return TRUE;
+    return true;
 }