FX_BOOL considered harmful.

core/src/fxcrt/fx_basic_maps.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 "plex.h"
 
 static void ConstructElement(CFX_ByteString* pNewData)
@@ skipping 51 matching lines @@
         for (FX_DWORD nBucket = (HashKey(pAssocRet->key) % m_nHashTableSize) + 1; nBucket < m_nHashTableSize; nBucket ++) {
             if ((pAssocNext = m_pHashTable[nBucket]) != NULL) {
                 break;
             }
         }
     }
     rNextPosition = (FX_POSITION) pAssocNext;
     rKey = pAssocRet->key;
     rValue = pAssocRet->value;
 }
-FX_BOOL CFX_MapPtrToPtr::Lookup(void* key, void*& rValue) const
+bool CFX_MapPtrToPtr::Lookup(void* key, void*& rValue) const
 {
     FX_DWORD nHash;
     CAssoc* pAssoc = GetAssocAt(key, nHash);
     if (pAssoc == NULL) {
-        return FALSE;
+        return false;
     }
     rValue = pAssoc->value;
-    return TRUE;
+    return true;
 }
 void* CFX_MapPtrToPtr::GetValueAt(void* key) const
 {
     FX_DWORD nHash;
     CAssoc* pAssoc = GetAssocAt(key, nHash);
     if (pAssoc == NULL) {
         return NULL;
     }
     return pAssoc->value;
 }
@@ skipping 42 matching lines @@
     ASSERT(m_pFreeList != NULL);
     CFX_MapPtrToPtr::CAssoc* pAssoc = m_pFreeList;
     m_pFreeList = m_pFreeList->pNext;
     m_nCount++;
     ASSERT(m_nCount > 0);
     pAssoc->key = 0;
     pAssoc->value = 0;
     return pAssoc;
 }
 void CFX_MapPtrToPtr::InitHashTable(
-    FX_DWORD nHashSize, FX_BOOL bAllocNow)
+    FX_DWORD nHashSize, bool bAllocNow)
 {
     ASSERT(m_nCount == 0);
     ASSERT(nHashSize > 0);
     if (m_pHashTable != NULL) {
         FX_Free(m_pHashTable);
         m_pHashTable = NULL;
     }
     if (bAllocNow) {
         m_pHashTable = FX_Alloc(CAssoc*, nHashSize);
     }
     m_nHashTableSize = nHashSize;
 }
-FX_BOOL CFX_MapPtrToPtr::RemoveKey(void* key)
+bool CFX_MapPtrToPtr::RemoveKey(void* key)
 {
     if (m_pHashTable == NULL) {
-        return FALSE;
+        return false;
     }
     CAssoc** ppAssocPrev;
     ppAssocPrev = &m_pHashTable[HashKey(key) % m_nHashTableSize];
     CAssoc* pAssoc;
     for (pAssoc = *ppAssocPrev; pAssoc != NULL; pAssoc = pAssoc->pNext) {
         if (pAssoc->key == key) {
             *ppAssocPrev = pAssoc->pNext;
             FreeAssoc(pAssoc);
-            return TRUE;
+            return true;
         }
         ppAssocPrev = &pAssoc->pNext;
     }
-    return FALSE;
+    return false;
 }
 void CFX_MapPtrToPtr::FreeAssoc(CFX_MapPtrToPtr::CAssoc* pAssoc)
 {
     pAssoc->pNext = m_pFreeList;
     m_pFreeList = pAssoc;
     m_nCount--;
     ASSERT(m_nCount >= 0);
     if (m_nCount == 0) {
         RemoveAll();
     }
@@ skipping 135 matching lines @@
         return NULL;
     }
     CAssoc* pAssoc;
     for (pAssoc = m_pHashTable[nHash]; pAssoc != NULL; pAssoc = pAssoc->pNext) {
         if (pAssoc->key == key) {
             return pAssoc;
         }
     }
     return NULL;
 }
-FX_BOOL CFX_MapByteStringToPtr::Lookup(const CFX_ByteStringC& key, void*& rValue) const
+bool CFX_MapByteStringToPtr::Lookup(const CFX_ByteStringC& key, void*& rValue) const
 {
     FX_DWORD nHash;
     CAssoc* pAssoc = GetAssocAt(key, nHash);
     if (pAssoc == NULL) {
-        return FALSE;
+        return false;
     }
     rValue = pAssoc->value;
-    return TRUE;
+    return true;
 }
 void CFX_MapByteStringToPtr::InitHashTable(
-    FX_DWORD nHashSize, FX_BOOL bAllocNow)
+    FX_DWORD nHashSize, bool bAllocNow)
 {
     ASSERT(m_nCount == 0);
     ASSERT(nHashSize > 0);
     if (m_pHashTable != NULL) {
         FX_Free(m_pHashTable);
         m_pHashTable = NULL;
     }
     if (bAllocNow) {
         m_pHashTable = FX_Alloc(CAssoc*, nHashSize);
     }
     m_nHashTableSize = nHashSize;
 }
 inline FX_DWORD CFX_MapByteStringToPtr::HashKey(const CFX_ByteStringC& key) const
 {
     FX_DWORD nHash = 0;
     int len = key.GetLength();
     const uint8_t* buf = key.GetPtr();
     for (int i = 0; i < len; i ++) {
         nHash = (nHash << 5) + nHash + buf[i];
     }
     return nHash;
 }
-FX_BOOL CFX_MapByteStringToPtr::RemoveKey(const CFX_ByteStringC& key)
+bool CFX_MapByteStringToPtr::RemoveKey(const CFX_ByteStringC& key)
 {
     if (m_pHashTable == NULL) {
-        return FALSE;
+        return false;
     }
     CAssoc** ppAssocPrev;
     ppAssocPrev = &m_pHashTable[HashKey(key) % m_nHashTableSize];
     CAssoc* pAssoc;
     for (pAssoc = *ppAssocPrev; pAssoc != NULL; pAssoc = pAssoc->pNext) {
         if (pAssoc->key == key) {
             *ppAssocPrev = pAssoc->pNext;
             FreeAssoc(pAssoc);
-            return TRUE;
+            return true;
         }
         ppAssocPrev = &pAssoc->pNext;
     }
-    return FALSE;
+    return false;
 }
 struct _CompactString {
     uint8_t             m_CompactLen;
     uint8_t             m_LenHigh;
     uint8_t             m_LenLow;
     uint8_t             m_Unused;
     uint8_t*    m_pBuffer;
 };
 static void _CompactStringRelease(_CompactString* pCompact)
 {
     if (pCompact->m_CompactLen == 0xff) {
         FX_Free(pCompact->m_pBuffer);
     }
 }
-static FX_BOOL _CompactStringSame(_CompactString* pCompact, const uint8_t* pStr, int len)
+static bool _CompactStringSame(_CompactString* pCompact, const uint8_t* pStr, int len)
 {
     if (len < sizeof(_CompactString)) {
         if (pCompact->m_CompactLen != len) {
-            return FALSE;
+            return false;
         }
         return FXSYS_memcmp(&pCompact->m_LenHigh, pStr, len) == 0;
     }
     if (pCompact->m_CompactLen != 0xff || pCompact->m_LenHigh * 256 + pCompact->m_LenLow != len) {
-        return FALSE;
+        return false;
     }
     return FXSYS_memcmp(pCompact->m_pBuffer, pStr, len) == 0;
 }
 static void _CompactStringStore(_CompactString* pCompact, const uint8_t* pStr, int len)
 {
     if (len < (int)sizeof(_CompactString)) {
         pCompact->m_CompactLen = (uint8_t)len;
         FXSYS_memcpy(&pCompact->m_LenHigh, pStr, len);
         return;
     }
@@ skipping 77 matching lines @@
         pKey = (_CompactString*)m_Buffer.GetAt(index);
         if (pKey->m_CompactLen != 0xfe) {
             rNextPosition = (FX_POSITION)(uintptr_t)(index + 1);
             return rValue;
         }
         index ++;
     }
     rNextPosition = NULL;
     return rValue;
 }
-FX_BOOL _CMapLookupCallback(void* param, void* pData)
+bool _CMapLookupCallback(void* param, void* pData)
 {
     return !_CompactStringSame((_CompactString*)pData, ((CFX_ByteStringC*)param)->GetPtr(), ((CFX_ByteStringC*)param)->GetLength());
 }
-FX_BOOL CFX_CMapByteStringToPtr::Lookup(const CFX_ByteStringC& key, void*& rValue) const
+bool CFX_CMapByteStringToPtr::Lookup(const CFX_ByteStringC& key, void*& rValue) const
 {
     void* p = m_Buffer.Iterate(_CMapLookupCallback, (void*)&key);
     if (!p) {
-        return FALSE;
+        return false;
     }
     rValue = *(void**)((_CompactString*)p + 1);
-    return TRUE;
+    return true;
 }
 void CFX_CMapByteStringToPtr::SetAt(const CFX_ByteStringC& key, void* value)
 {
     ASSERT(value != NULL);
     int index, key_len = key.GetLength();
     int size = m_Buffer.GetSize();
     for (index = 0; index < size; index ++) {
         _CompactString* pKey = (_CompactString*)m_Buffer.GetAt(index);
         if (!_CompactStringSame(pKey, key.GetPtr(), key_len)) {
             continue;
@@ skipping 50 matching lines @@
 extern "C" {
     static int _CompareDWord(const void* p1, const void* p2)
     {
         return (*(FX_DWORD*)p1) - (*(FX_DWORD*)p2);
     }
 };
 struct _DWordPair {
     FX_DWORD key;
     FX_DWORD value;
 };
-FX_BOOL CFX_CMapDWordToDWord::Lookup(FX_DWORD key, FX_DWORD& value) const
+bool CFX_CMapDWordToDWord::Lookup(FX_DWORD key, FX_DWORD& value) const
 {
     void* pResult = FXSYS_bsearch(&key, m_Buffer.GetBuffer(), m_Buffer.GetSize() / sizeof(_DWordPair),
                                       sizeof(_DWordPair), _CompareDWord);
     if (pResult == NULL) {
-        return FALSE;
+        return false;
     }
     value = ((FX_DWORD*)pResult)[1];
-    return TRUE;
+    return true;
 }
 FX_POSITION CFX_CMapDWordToDWord::GetStartPosition() const
 {
     FX_DWORD count = m_Buffer.GetSize() / sizeof(_DWordPair);
     if (count == 0) {
         return NULL;
     }
     return (FX_POSITION)1;
 }
 void CFX_CMapDWordToDWord::GetNextAssoc(FX_POSITION& pos, FX_DWORD& key, FX_DWORD& value) const
@@ skipping 32 matching lines @@
             buf[mid].value = value;
             return;
         }
     }
     m_Buffer.InsertBlock(low * sizeof(_DWordPair), &pair, sizeof(_DWordPair));
 }
 void CFX_CMapDWordToDWord::EstimateSize(FX_DWORD size, FX_DWORD grow_by)
 {
     m_Buffer.EstimateSize(size, grow_by);
 }