FX_BOOL considered harmful.

core/src/fxcrt/fx_basic_array.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/fxcrt/fx_basic.h"
 #include "../../../third_party/base/numerics/safe_math.h"
 
 CFX_BasicArray::CFX_BasicArray(int unit_size)
     : m_pData(NULL)
     , m_nSize(0)
     , m_nMaxSize(0)
 {
     if (unit_size < 0 || unit_size > (1 << 28)) {
         m_nUnitSize = 4;
     } else {
         m_nUnitSize = unit_size;
     }
 }
 CFX_BasicArray::~CFX_BasicArray()
 {
     FX_Free(m_pData);
 }
-FX_BOOL CFX_BasicArray::SetSize(int nNewSize)
+bool CFX_BasicArray::SetSize(int nNewSize)
 {
     if (nNewSize <= 0) {
         FX_Free(m_pData);
         m_pData = NULL;
         m_nSize = m_nMaxSize = 0;
         return 0 == nNewSize;
     }
 
     if (m_pData == NULL) {
         pdfium::base::CheckedNumeric<int> totalSize = nNewSize;
         totalSize *= m_nUnitSize;
         if (!totalSize.IsValid()) {
             m_nSize = m_nMaxSize = 0;
-            return FALSE;
+            return false;
         }
         m_pData = FX_Alloc(uint8_t, totalSize.ValueOrDie());
         m_nSize = m_nMaxSize = nNewSize;
     } else if (nNewSize <= m_nMaxSize) {
         if (nNewSize > m_nSize) {
             FXSYS_memset(m_pData + m_nSize * m_nUnitSize, 0, (nNewSize - m_nSize) * m_nUnitSize);
         }
         m_nSize = nNewSize;
     } else {
         int nNewMax = nNewSize < m_nMaxSize ? m_nMaxSize : nNewSize;
         pdfium::base::CheckedNumeric<int> totalSize = nNewMax;
         totalSize *= m_nUnitSize;
         if (!totalSize.IsValid() || nNewMax < m_nSize) {
-            return FALSE;
+            return false;
         }
         uint8_t* pNewData = FX_Realloc(uint8_t, m_pData, totalSize.ValueOrDie());
         if (pNewData == NULL) {
-            return FALSE;
+            return false;
         }
         FXSYS_memset(pNewData + m_nSize * m_nUnitSize, 0, (nNewMax - m_nSize) * m_nUnitSize);
         m_pData = pNewData;
         m_nSize = nNewSize;
         m_nMaxSize = nNewMax;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_BasicArray::Append(const CFX_BasicArray& src)
+bool CFX_BasicArray::Append(const CFX_BasicArray& src)
 {
     int nOldSize = m_nSize;
     pdfium::base::CheckedNumeric<int> newSize = m_nSize;
     newSize += src.m_nSize;
     if (m_nUnitSize != src.m_nUnitSize || !newSize.IsValid() || !SetSize(newSize.ValueOrDie())) {
-        return FALSE;
+        return false;
     }
 
     FXSYS_memcpy(m_pData + nOldSize * m_nUnitSize, src.m_pData, src.m_nSize * m_nUnitSize);
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_BasicArray::Copy(const CFX_BasicArray& src)
+bool CFX_BasicArray::Copy(const CFX_BasicArray& src)
 {
     if (!SetSize(src.m_nSize)) {
-        return FALSE;
+        return false;
     }
     FXSYS_memcpy(m_pData, src.m_pData, src.m_nSize * m_nUnitSize);
-    return TRUE;
+    return true;
 }
 uint8_t* CFX_BasicArray::InsertSpaceAt(int nIndex, int nCount)
 {
     if (nIndex < 0 || nCount <= 0) {
         return NULL;
     }
     if (nIndex >= m_nSize) {
         if (!SetSize(nIndex + nCount)) {
             return NULL;
         }
     } else {
         int nOldSize = m_nSize;
         if (!SetSize(m_nSize + nCount)) {
             return NULL;
         }
         FXSYS_memmove(m_pData + (nIndex + nCount)*m_nUnitSize, m_pData + nIndex * m_nUnitSize,
                         (nOldSize - nIndex) * m_nUnitSize);
         FXSYS_memset(m_pData + nIndex * m_nUnitSize, 0, nCount * m_nUnitSize);
     }
     return m_pData + nIndex * m_nUnitSize;
 }
-FX_BOOL CFX_BasicArray::RemoveAt(int nIndex, int nCount)
+bool CFX_BasicArray::RemoveAt(int nIndex, int nCount)
 {
     if (nIndex < 0 || nCount <= 0 || m_nSize < nIndex + nCount) {
-        return FALSE;
+        return false;
     }
     int nMoveCount = m_nSize - (nIndex + nCount);
     if (nMoveCount) {
         FXSYS_memmove(m_pData + nIndex * m_nUnitSize, m_pData + (nIndex + nCount) * m_nUnitSize, nMoveCount * m_nUnitSize);
     }
     m_nSize -= nCount;
-    return TRUE;
+    return true;
 }
-FX_BOOL CFX_BasicArray::InsertAt(int nStartIndex, const CFX_BasicArray* pNewArray)
+bool CFX_BasicArray::InsertAt(int nStartIndex, const CFX_BasicArray* pNewArray)
 {
     if (pNewArray == NULL) {
-        return FALSE;
+        return false;
     }
     if (pNewArray->m_nSize == 0) {
-        return TRUE;
+        return true;
     }
     if (!InsertSpaceAt(nStartIndex, pNewArray->m_nSize)) {
-        return FALSE;
+        return false;
     }
     FXSYS_memcpy(m_pData + nStartIndex * m_nUnitSize, pNewArray->m_pData, pNewArray->m_nSize * m_nUnitSize);
-    return TRUE;
+    return true;
 }
 const void* CFX_BasicArray::GetDataPtr(int index) const
 {
     if (index < 0 || index >= m_nSize || m_pData == NULL) {
         return NULL;
     }
     return m_pData + index * m_nUnitSize;
 }
 CFX_BaseSegmentedArray::CFX_BaseSegmentedArray(int unit_size, int segment_units, int index_size)
     : m_UnitSize(unit_size)
@@ skipping 111 matching lines @@
         tree_size *= m_IndexSize;
     }
     void** pSpot = (void**)m_pIndex;
     for (i = 1; i < m_IndexDepth; i ++) {
         pSpot = (void**)pSpot[seg_index / tree_size];
         seg_index = seg_index % tree_size;
         tree_size /= m_IndexSize;
     }
     return pSpot;
 }
-void* CFX_BaseSegmentedArray::IterateSegment(const uint8_t* pSegment, int count, FX_BOOL (*callback)(void* param, void* pData), void* param) const
+void* CFX_BaseSegmentedArray::IterateSegment(const uint8_t* pSegment, int count, bool (*callback)(void* param, void* pData), void* param) const
 {
     for (int i = 0; i < count; i ++) {
         if (!callback(param, (void*)(pSegment + i * m_UnitSize))) {
             return (void*)(pSegment + i * m_UnitSize);
         }
     }
     return NULL;
 }
-void* CFX_BaseSegmentedArray::IterateIndex(int level, int& start, void** pIndex, FX_BOOL (*callback)(void* param, void* pData), void* param) const
+void* CFX_BaseSegmentedArray::IterateIndex(int level, int& start, void** pIndex, bool (*callback)(void* param, void* pData), void* param) const
 {
     if (level == 0) {
         int count = m_DataSize - start;
         if (count > m_SegmentSize) {
             count = m_SegmentSize;
         }
         start += count;
         return IterateSegment((const uint8_t*)pIndex, count, callback, param);
     }
     for (int i = 0; i < m_IndexSize; i ++) {
         if (pIndex[i] == NULL) {
             continue;
         }
         void* p = IterateIndex(level - 1, start, (void**)pIndex[i], callback, param);
         if (p) {
             return p;
         }
     }
     return NULL;
 }
-void* CFX_BaseSegmentedArray::Iterate(FX_BOOL (*callback)(void* param, void* pData), void* param) const
+void* CFX_BaseSegmentedArray::Iterate(bool (*callback)(void* param, void* pData), void* param) const
 {
     if (m_pIndex == NULL) {
         return NULL;
     }
     int start = 0;
     return IterateIndex(m_IndexDepth, start, (void**)m_pIndex, callback, param);
 }
 void* CFX_BaseSegmentedArray::GetAt(int index) const
 {
     if (index < 0 || index >= m_DataSize) {
@@ skipping 27 matching lines @@
                 FX_Free(pIndex[i % m_IndexSize]);
                 pIndex[i % m_IndexSize] = NULL;
             }
         } else {
             FX_Free(m_pIndex);
             m_pIndex = NULL;
         }
     }
     m_DataSize -= count;
 }