FX_BOOL considered harmful.

core/src/fxcodec/codec/fx_codec_flate.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 "../../../../third_party/base/nonstd_unique_ptr.h"
 #include "../../../../third_party/zlib_v128/zlib.h"
 #include "../../../include/fxcodec/fx_codec.h"
 #include "../../../include/fxcodec/fx_codec_flate.h"
@@ skipping 66 matching lines @@
     void FPDFAPI_FlateEnd(void* context)
     {
         inflateEnd((z_stream*)context);
         ((z_stream*)context)->zfree(0, context);
     }
 }  // extern "C"
 
 class CLZWDecoder
 {
 public:
-    FX_BOOL Decode(uint8_t* output, FX_DWORD& outlen, const uint8_t* input, FX_DWORD& size, FX_BOOL bEarlyChange);
+    int Decode(uint8_t* output, FX_DWORD& outlen, const uint8_t* input, FX_DWORD& size, bool bEarlyChange);
+
 private:
+    void                AddCode(FX_DWORD prefix_code, uint8_t append_char);
+    void                DecodeString(FX_DWORD code);
+
     FX_DWORD    m_InPos;
     FX_DWORD    m_OutPos;
     uint8_t*    m_pOutput;
     const uint8_t*      m_pInput;
-    FX_BOOL             m_Early;
-    void                AddCode(FX_DWORD prefix_code, uint8_t append_char);
+    bool                m_Early;
     FX_DWORD    m_CodeArray[5021];
     FX_DWORD    m_nCodes;
     uint8_t             m_DecodeStack[4000];
     FX_DWORD    m_StackLen;
-    void                DecodeString(FX_DWORD code);
     int                 m_CodeLen;
 };
 void CLZWDecoder::AddCode(FX_DWORD prefix_code, uint8_t append_char)
 {
     if (m_nCodes + m_Early == 4094) {
         return;
     }
     m_CodeArray[m_nCodes ++] = (prefix_code << 16) | append_char;
     if (m_nCodes + m_Early == 512 - 258) {
         m_CodeLen = 10;
@@ skipping 15 matching lines @@
             return;
         }
         m_DecodeStack[m_StackLen++] = (uint8_t)data;
         code = data >> 16;
     }
     if (m_StackLen >= sizeof(m_DecodeStack)) {
         return;
     }
     m_DecodeStack[m_StackLen++] = (uint8_t)code;
 }
-int CLZWDecoder::Decode(uint8_t* dest_buf, FX_DWORD& dest_size, const uint8_t* src_buf, FX_DWORD& src_size, FX_BOOL bEarlyChange)
+int CLZWDecoder::Decode(uint8_t* dest_buf, FX_DWORD& dest_size, const uint8_t* src_buf, FX_DWORD& src_size, bool bEarlyChange)
 {
     m_CodeLen = 9;
     m_InPos = 0;
     m_OutPos = 0;
     m_pInput = src_buf;
     m_pOutput = dest_buf;
     m_Early = bEarlyChange ? 1 : 0;
     m_nCodes = 0;
     FX_DWORD old_code = (FX_DWORD) - 1;
     uint8_t last_char;
@@ skipping 83 matching lines @@
     int pb = FXSYS_abs(p - b);
     int pc = FXSYS_abs(p - c);
     if (pa <= pb && pa <= pc) {
         return (uint8_t)a;
     }
     if (pb <= pc) {
         return (uint8_t)b;
     }
     return (uint8_t)c;
 }
-static FX_BOOL PNG_PredictorEncode(uint8_t*& data_buf, FX_DWORD& data_size,
+static bool PNG_PredictorEncode(uint8_t*& data_buf, FX_DWORD& data_size,
                                    int predictor, int Colors,
                                    int BitsPerComponent, int Columns)
 {
     const int BytesPerPixel = (Colors * BitsPerComponent + 7) / 8;
     const int row_size = (Colors * BitsPerComponent * Columns + 7) / 8;
     if (row_size <= 0)
-        return FALSE;
+        return false;
     const int row_count = (data_size + row_size - 1) / row_size;
     const int last_row_size = data_size % row_size;
     uint8_t* dest_buf = FX_Alloc2D(uint8_t, row_size + 1, row_count);
     int byte_cnt = 0;
     uint8_t* pSrcData = data_buf;
     uint8_t* pDestData = dest_buf;
     for (int row = 0; row < row_count; row++) {
         if (predictor == 10) {
             pDestData[0] = 0;
             int move_size = row_size;
@@ skipping 62 matching lines @@
                     break;
             }
             byte_cnt++;
         }
         pDestData += (row_size + 1);
         pSrcData += row_size;
     }
     FX_Free(data_buf);
     data_buf = dest_buf;
     data_size = (row_size + 1) * row_count - (last_row_size > 0 ? (row_size - last_row_size) : 0);
-    return TRUE;
+    return true;
 }
 static void PNG_PredictLine(uint8_t* pDestData, const uint8_t* pSrcData, const uint8_t* pLastLine,
                             int bpc, int nColors, int nPixels)
 {
     int row_size = (nPixels * bpc * nColors + 7) / 8;
     int BytesPerPixel = (bpc * nColors + 7) / 8;
     uint8_t tag = pSrcData[0];
     if (tag == 0) {
         FXSYS_memmove(pDestData, pSrcData + 1, row_size);
         return;
@@ skipping 44 matching lines @@
                     }
                     pDestData[byte] = raw_byte + PaethPredictor(left, up, upper_left);
                     break;
                 }
             default:
                 pDestData[byte] = raw_byte;
                 break;
         }
     }
 }
-static FX_BOOL PNG_Predictor(uint8_t*& data_buf, FX_DWORD& data_size,
+static bool PNG_Predictor(uint8_t*& data_buf, FX_DWORD& data_size,
                              int Colors, int BitsPerComponent, int Columns)
 {
     const int BytesPerPixel = (Colors * BitsPerComponent + 7) / 8;
     const int row_size = (Colors * BitsPerComponent * Columns + 7) / 8;
     if (row_size <= 0)
-        return FALSE;
+        return false;
     const int row_count = (data_size + row_size) / (row_size + 1);
     const int last_row_size = data_size % (row_size + 1);
     uint8_t* dest_buf = FX_Alloc2D(uint8_t, row_size, row_count);
     int byte_cnt = 0;
     uint8_t* pSrcData = data_buf;
     uint8_t* pDestData = dest_buf;
     for (int row = 0; row < row_count; row ++) {
         uint8_t tag = pSrcData[0];
         byte_cnt++;
         if (tag == 0) {
@@ skipping 59 matching lines @@
                     break;
             }
             byte_cnt++;
         }
         pSrcData += row_size + 1;
         pDestData += row_size;
     }
     FX_Free(data_buf);
     data_buf = dest_buf;
     data_size = row_size * row_count - (last_row_size > 0 ? (row_size + 1 - last_row_size) : 0);
-    return TRUE;
+    return true;
 }
 static void TIFF_PredictorEncodeLine(uint8_t* dest_buf, int row_size, int BitsPerComponent, int Colors, int Columns)
 {
     int BytesPerPixel = BitsPerComponent * Colors / 8;
     if (BitsPerComponent < 8) {
         uint8_t mask = 0x01;
         if (BitsPerComponent == 2) {
             mask = 0x03;
         } else if (BitsPerComponent == 4) {
             mask = 0x0F;
@@ skipping 18 matching lines @@
         }
     } else {
         for (int i = row_size - BytesPerPixel; i >= BytesPerPixel; i -= BytesPerPixel) {
             FX_WORD pixel = (dest_buf[i] << 8) | dest_buf[i + 1];
             pixel -= (dest_buf[i - BytesPerPixel] << 8) | dest_buf[i - BytesPerPixel + 1];
             dest_buf[i] = pixel >> 8;
             dest_buf[i + 1] = (uint8_t)pixel;
         }
     }
 }
-static FX_BOOL TIFF_PredictorEncode(uint8_t*& data_buf, FX_DWORD& data_size,
+static bool TIFF_PredictorEncode(uint8_t*& data_buf, FX_DWORD& data_size,
                                     int Colors, int BitsPerComponent, int Columns)
 {
     int row_size = (Colors * BitsPerComponent * Columns + 7) / 8;
     if (row_size == 0)
-        return FALSE;
+        return false;
     const int row_count = (data_size + row_size - 1) / row_size;
     const int last_row_size = data_size % row_size;
     for (int row = 0; row < row_count; row++) {
         uint8_t* scan_line = data_buf + row * row_size;
         if ((row + 1) * row_size > (int)data_size) {
             row_size = last_row_size;
         }
         TIFF_PredictorEncodeLine(scan_line, row_size, BitsPerComponent, Colors, Columns);
     }
-    return TRUE;
+    return true;
 }
 static void TIFF_PredictLine(uint8_t* dest_buf, int row_size, int BitsPerComponent, int Colors, int Columns)
 {
     if (BitsPerComponent == 1) {
         int row_bits = FX_MIN(BitsPerComponent * Colors * Columns, row_size * 8);
         int index_pre = 0;
         int col_pre = 0;
         for(int i = 1; i < row_bits; i ++) {
             int col = i % 8;
             int index = i / 8;
@@ skipping 14 matching lines @@
             pixel += (dest_buf[i] << 8) | dest_buf[i + 1];
             dest_buf[i] = pixel >> 8;
             dest_buf[i + 1] = (uint8_t)pixel;
         }
     } else {
         for (int i = BytesPerPixel; i < row_size; i ++) {
             dest_buf[i] += dest_buf[i - BytesPerPixel];
         }
     }
 }
-static FX_BOOL TIFF_Predictor(uint8_t*& data_buf, FX_DWORD& data_size,
+static bool TIFF_Predictor(uint8_t*& data_buf, FX_DWORD& data_size,
                               int Colors, int BitsPerComponent, int Columns)
 {
     int row_size = (Colors * BitsPerComponent * Columns + 7) / 8;
     if (row_size == 0)
-        return FALSE;
+        return false;
     const int row_count = (data_size + row_size - 1) / row_size;
     const int last_row_size = data_size % row_size;
     for (int row = 0; row < row_count; row ++) {
         uint8_t* scan_line = data_buf + row * row_size;
         if ((row + 1) * row_size > (int)data_size) {
             row_size = last_row_size;
         }
         TIFF_PredictLine(scan_line, row_size, BitsPerComponent, Colors, Columns);
     }
-    return TRUE;
+    return true;
 }
 class CCodec_FlateScanlineDecoder : public CCodec_ScanlineDecoder
 {
 public:
     CCodec_FlateScanlineDecoder();
     ~CCodec_FlateScanlineDecoder();
     void Create(const uint8_t* src_buf, FX_DWORD src_size, int width, int height, int nComps, int bpc,
                 int predictor, int Colors, int BitsPerComponent, int Columns);
     virtual void                Destroy()
     {
         delete this;
     }
     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();
     void*                               m_pFlate;
     const uint8_t*                      m_SrcBuf;
     FX_DWORD                    m_SrcSize;
     uint8_t*                    m_pScanline;
     uint8_t*                    m_pLastLine;
     uint8_t*                    m_pPredictBuffer;
     uint8_t*                    m_pPredictRaw;
     int                                 m_Predictor;
@@ skipping 28 matching lines @@
 }
 void CCodec_FlateScanlineDecoder::Create(const uint8_t* src_buf, FX_DWORD src_size, int width, int height,
         int nComps, int bpc, int predictor, int Colors, int BitsPerComponent, int Columns)
 {
     m_SrcBuf = 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_Pitch = (width * nComps * bpc + 7) / 8;
     m_pScanline = FX_Alloc(uint8_t, m_Pitch);
     m_Predictor = 0;
     if (predictor) {
         if (predictor >= 10) {
             m_Predictor = 2;
         } else if (predictor == 2) {
             m_Predictor = 1;
         }
         if (m_Predictor) {
             if (BitsPerComponent * Colors * Columns == 0) {
                 BitsPerComponent = m_bpc;
                 Colors = m_nComps;
                 Columns = m_OrigWidth;
             }
             m_Colors = Colors;
             m_BitsPerComponent = BitsPerComponent;
             m_Columns = Columns;
             m_PredictPitch = (m_BitsPerComponent * m_Colors * m_Columns + 7) / 8;
             m_pLastLine = FX_Alloc(uint8_t, m_PredictPitch);
             m_pPredictRaw = FX_Alloc(uint8_t, m_PredictPitch + 1);
             m_pPredictBuffer = FX_Alloc(uint8_t, m_PredictPitch);
         }
     }
 }
-FX_BOOL CCodec_FlateScanlineDecoder::v_Rewind()
+bool CCodec_FlateScanlineDecoder::v_Rewind()
 {
     if (m_pFlate) {
         FPDFAPI_FlateEnd(m_pFlate);
     }
     m_pFlate = FPDFAPI_FlateInit(my_alloc_func, my_free_func);
     if (m_pFlate == NULL) {
-        return FALSE;
+        return false;
     }
     FPDFAPI_FlateInput(m_pFlate, m_SrcBuf, m_SrcSize);
     m_LeftOver = 0;
-    return TRUE;
+    return true;
 }
 uint8_t* CCodec_FlateScanlineDecoder::v_GetNextLine()
 {
     if (m_Predictor) {
         if (m_Pitch == m_PredictPitch) {
             if (m_Predictor == 2) {
                 FPDFAPI_FlateOutput(m_pFlate, m_pPredictRaw, m_PredictPitch + 1);
                 PNG_PredictLine(m_pScanline, m_pPredictRaw, m_pLastLine, m_BitsPerComponent, m_Colors, m_Columns);
                 FXSYS_memcpy(m_pLastLine, m_pScanline, m_PredictPitch);
             } else {
@@ skipping 28 matching lines @@
     }
     return m_pScanline;
 }
 FX_DWORD CCodec_FlateScanlineDecoder::GetSrcOffset()
 {
     return FPDFAPI_FlateGetTotalIn(m_pFlate);
 }
 static void FlateUncompress(const uint8_t* src_buf, FX_DWORD src_size, FX_DWORD orig_size,
                             uint8_t*& dest_buf, FX_DWORD& dest_size, FX_DWORD& offset)
 {
-    const FX_BOOL useOldImpl = src_size < 10240;
+    const bool useOldImpl = src_size < 10240;
     FX_DWORD guess_size = orig_size ? orig_size : src_size * 2;
     FX_DWORD alloc_step = orig_size ? 10240 : (src_size < 10240 ? 10240 : src_size);
     static const FX_DWORD kMaxInitialAllocSize = 10000000;
     if (guess_size > kMaxInitialAllocSize) {
         guess_size = kMaxInitialAllocSize;
         alloc_step = kMaxInitialAllocSize;
     }
     FX_DWORD buf_size = guess_size;
     FX_DWORD last_buf_size = buf_size;
     void* context = nullptr;
@@ skipping 86 matching lines @@
     dest_size = 0;
     return;
 }
 ICodec_ScanlineDecoder* CCodec_FlateModule::CreateDecoder(const uint8_t* src_buf, FX_DWORD src_size, int width, int height,
         int nComps, int bpc, int predictor, int Colors, int BitsPerComponent, int Columns)
 {
     CCodec_FlateScanlineDecoder* pDecoder = new CCodec_FlateScanlineDecoder;
     pDecoder->Create(src_buf, src_size, width, height, nComps, bpc, predictor, Colors, BitsPerComponent, Columns);
     return pDecoder;
 }
-FX_DWORD CCodec_FlateModule::FlateOrLZWDecode(FX_BOOL bLZW, const uint8_t* src_buf, FX_DWORD src_size, FX_BOOL bEarlyChange,
+FX_DWORD CCodec_FlateModule::FlateOrLZWDecode(bool bLZW, const uint8_t* src_buf, FX_DWORD src_size, bool bEarlyChange,
         int predictor, int Colors, int BitsPerComponent, int Columns,
         FX_DWORD estimated_size, uint8_t*& dest_buf, FX_DWORD& dest_size)
 {
     dest_buf = NULL;
     FX_DWORD offset = 0;
     int predictor_type = 0;
     if (predictor) {
         if (predictor >= 10) {
             predictor_type = 2;
         } else if (predictor == 2) {
@@ skipping 16 matching lines @@
             dest_buf = FX_Alloc( uint8_t, dest_size + 1);
             dest_buf[dest_size] = '\0';
             decoder->Decode(dest_buf, dest_size, src_buf, offset, bEarlyChange);
         }
     } else {
         FlateUncompress(src_buf, src_size, estimated_size, dest_buf, dest_size, offset);
     }
     if (predictor_type == 0) {
         return offset;
     }
-    FX_BOOL ret = TRUE;
+    bool ret = true;
     if (predictor_type == 2) {
         ret = PNG_Predictor(dest_buf, dest_size, Colors, BitsPerComponent,
                             Columns);
     } else if (predictor_type == 1) {
         ret = TIFF_Predictor(dest_buf, dest_size, Colors, BitsPerComponent,
                              Columns);
     }
     return ret ? offset : -1;
 }
-FX_BOOL CCodec_FlateModule::Encode(const uint8_t* src_buf, FX_DWORD src_size,
+bool CCodec_FlateModule::Encode(const uint8_t* src_buf, FX_DWORD src_size,
                                    int predictor, int Colors, int BitsPerComponent, int Columns,
                                    uint8_t*& dest_buf, FX_DWORD& dest_size)
 {
     if (predictor != 2 && predictor < 10) {
         return Encode(src_buf, src_size, dest_buf, dest_size);
     }
     uint8_t* pSrcBuf = NULL;
     pSrcBuf = FX_Alloc(uint8_t, src_size);
     FXSYS_memcpy(pSrcBuf, src_buf, src_size);
-    FX_BOOL ret = TRUE;
+    bool ret = true;
     if (predictor == 2) {
         ret = TIFF_PredictorEncode(pSrcBuf, src_size, Colors, BitsPerComponent,
                                    Columns);
     } else if (predictor >= 10) {
         ret = PNG_PredictorEncode(pSrcBuf, src_size, predictor, Colors,
                                   BitsPerComponent, Columns);
     }
     if (ret)
         ret = Encode(pSrcBuf, src_size, dest_buf, dest_size);
     FX_Free(pSrcBuf);
     return ret;
 }
-FX_BOOL CCodec_FlateModule::Encode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf, FX_DWORD& dest_size)
+bool CCodec_FlateModule::Encode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf, FX_DWORD& dest_size)
 {
     dest_size = src_size + src_size / 1000 + 12;
     dest_buf = FX_Alloc( uint8_t, dest_size);
     unsigned long temp_size = dest_size;
     FPDFAPI_FlateCompress(dest_buf, &temp_size, src_buf, src_size);
     dest_size = (FX_DWORD)temp_size;
-    return TRUE;
+    return true;
 }