FX_BOOL considered harmful.

core/include/fxcrt/fx_basic.h

 // 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
 
 #ifndef CORE_INCLUDE_FXCRT_FX_BASIC_H_
 #define CORE_INCLUDE_FXCRT_FX_BASIC_H_
 
 #include "fx_memory.h"
@@ skipping 200 matching lines @@
     CFX_ArchiveLoader&          operator >> (FX_DWORD& i);
 
     CFX_ArchiveLoader&          operator >> (FX_FLOAT& i);
 
     CFX_ArchiveLoader&          operator >> (double& i);
 
     CFX_ArchiveLoader&          operator >> (CFX_ByteString& bstr);
 
     CFX_ArchiveLoader&          operator >> (CFX_WideString& wstr);
 
-    FX_BOOL                                     IsEOF();
+    bool                                        IsEOF();
 
-    FX_BOOL                                     Read(void* pBuf, FX_DWORD dwSize);
+    bool                                        Read(void* pBuf, FX_DWORD dwSize);
 protected:
 
     FX_DWORD                            m_LoadingPos;
 
     const uint8_t*                              m_pLoadingBuf;
 
     FX_DWORD                            m_LoadingSize;
 
 };
 
 class IFX_BufferArchive
 {
 public:
     IFX_BufferArchive(FX_STRSIZE size);
     virtual ~IFX_BufferArchive() {}
 
     virtual void Clear();
 
-    FX_BOOL Flush();
+    bool Flush();
 
     int32_t AppendBlock(const void* pBuf, size_t size);
 
     int32_t AppendByte(uint8_t byte);
 
     int32_t AppendDWord(FX_DWORD i);
 
 
     int32_t AppendString(const CFX_ByteStringC& lpsz);
 
 protected:
 
-    virtual FX_BOOL DoWork(const void* pBuf, size_t size) = 0;
+    virtual bool DoWork(const void* pBuf, size_t size) = 0;
 
     FX_STRSIZE m_BufSize;
 
     uint8_t* m_pBuffer;
 
     FX_STRSIZE m_Length;
 };
 
 class CFX_FileBufferArchive : public IFX_BufferArchive
 {
 public:
     CFX_FileBufferArchive(FX_STRSIZE size = 32768);
     ~CFX_FileBufferArchive() override;
 
     void Clear() override;
 
-    FX_BOOL AttachFile(IFX_StreamWrite *pFile, FX_BOOL bTakeover = FALSE);
+    bool AttachFile(IFX_StreamWrite *pFile, bool bTakeover = false);
 
-    FX_BOOL AttachFile(const FX_WCHAR* filename);
+    bool AttachFile(const FX_WCHAR* filename);
 
-    FX_BOOL AttachFile(const FX_CHAR* filename);
+    bool AttachFile(const FX_CHAR* filename);
 
 private:
-    FX_BOOL DoWork(const void* pBuf, size_t size) override;
+    bool DoWork(const void* pBuf, size_t size) override;
 
     IFX_StreamWrite* m_pFile;
 
-    FX_BOOL m_bTakeover;
+    bool m_bTakeover;
 };
 
 struct CFX_CharMap {
 
     static CFX_CharMap*         GetDefaultMapper(int32_t codepage = 0);
 
 
     CFX_WideString      (*m_GetWideString)(CFX_CharMap* pMap, const CFX_ByteString& bstr);
 
     CFX_ByteString      (*m_GetByteString)(CFX_CharMap* pMap, const CFX_WideString& wstr);
@@ skipping 61 matching lines @@
 CFX_WideString FX_UrlDecode(const CFX_ByteString& bsUrl);
 CFX_ByteString FX_EncodeURI(const CFX_WideString& wsURI);
 CFX_WideString FX_DecodeURI(const CFX_ByteString& bsURI);
 class CFX_BasicArray
 {
 protected:
     CFX_BasicArray(int unit_size);
 
     ~CFX_BasicArray();
 
-    FX_BOOL                     SetSize(int nNewSize);
+    bool                        SetSize(int nNewSize);
 
-    FX_BOOL                     Append(const CFX_BasicArray& src);
+    bool                        Append(const CFX_BasicArray& src);
 
-    FX_BOOL                     Copy(const CFX_BasicArray& src);
+    bool                        Copy(const CFX_BasicArray& src);
 
     uint8_t*            InsertSpaceAt(int nIndex, int nCount);
 
-    FX_BOOL                     RemoveAt(int nIndex, int nCount);
+    bool                        RemoveAt(int nIndex, int nCount);
 
-    FX_BOOL                     InsertAt(int nStartIndex, const CFX_BasicArray* pNewArray);
+    bool                        InsertAt(int nStartIndex, const CFX_BasicArray* pNewArray);
 
     const void*         GetDataPtr(int index) const;
 protected:
 
     uint8_t*            m_pData;
 
     int                         m_nSize;
 
     int                         m_nMaxSize;
 
     int                         m_nUnitSize;
 };
 template<class TYPE>
 class CFX_ArrayTemplate : public CFX_BasicArray
 {
 public:
     CFX_ArrayTemplate() : CFX_BasicArray(sizeof(TYPE)) {}
 
     int                 GetSize() const
     {
         return m_nSize;
     }
 
     int                 GetUpperBound() const
     {
         return m_nSize - 1;
     }
 
-    FX_BOOL             SetSize(int nNewSize)
+    bool                SetSize(int nNewSize)
     {
         return CFX_BasicArray::SetSize(nNewSize);
     }
 
     void                RemoveAll()
     {
         SetSize(0);
     }
 
     const TYPE  GetAt(int nIndex) const
     {
         if (nIndex < 0 || nIndex >= m_nSize) {
             return (const TYPE&)(*(volatile const TYPE*)NULL);
         }
         return ((const TYPE*)m_pData)[nIndex];
     }
 
-    FX_BOOL             SetAt(int nIndex, TYPE newElement)
+    bool                SetAt(int nIndex, TYPE newElement)
     {
         if (nIndex < 0 || nIndex >= m_nSize) {
-            return FALSE;
+            return false;
         }
         ((TYPE*)m_pData)[nIndex] = newElement;
-        return TRUE;
+        return true;
     }
 
     TYPE&               ElementAt(int nIndex)
     {
         if (nIndex < 0 || nIndex >= m_nSize) {
             return *(TYPE*)NULL;
         }
         return ((TYPE*)m_pData)[nIndex];
     }
 
     const TYPE* GetData() const
     {
         return (const TYPE*)m_pData;
     }
 
     TYPE*               GetData()
     {
         return (TYPE*)m_pData;
     }
 
-    FX_BOOL             SetAtGrow(int nIndex, TYPE newElement)
+    bool                SetAtGrow(int nIndex, TYPE newElement)
     {
         if (nIndex < 0) {
-            return FALSE;
+            return false;
         }
         if (nIndex >= m_nSize)
             if (!SetSize(nIndex + 1)) {
-                return FALSE;
+                return false;
             }
         ((TYPE*)m_pData)[nIndex] = newElement;
-        return TRUE;
+        return true;
     }
 
-    FX_BOOL             Add(TYPE newElement)
+    bool                Add(TYPE newElement)
     {
         if (m_nSize < m_nMaxSize) {
             m_nSize ++;
         } else if (!SetSize(m_nSize + 1)) {
-            return FALSE;
+            return false;
         }
         ((TYPE*)m_pData)[m_nSize - 1] = newElement;
-        return TRUE;
+        return true;
     }
 
-    FX_BOOL             Append(const CFX_ArrayTemplate& src)
+    bool                Append(const CFX_ArrayTemplate& src)
     {
         return CFX_BasicArray::Append(src);
     }
 
-    FX_BOOL             Copy(const CFX_ArrayTemplate& src)
+    bool                Copy(const CFX_ArrayTemplate& src)
     {
         return CFX_BasicArray::Copy(src);
     }
 
     TYPE*               GetDataPtr(int index)
     {
         return (TYPE*)CFX_BasicArray::GetDataPtr(index);
     }
 
     TYPE*               AddSpace()
@@ skipping 15 matching lines @@
     }
 
     TYPE&               operator[](int nIndex)
     {
         if (nIndex < 0 || nIndex >= m_nSize) {
             *(volatile char*)0 = '\0';
         }
         return ((TYPE*)m_pData)[nIndex];
     }
 
-    FX_BOOL             InsertAt(int nIndex, TYPE newElement, int nCount = 1)
+    bool                InsertAt(int nIndex, TYPE newElement, int nCount = 1)
     {
         if (!InsertSpaceAt(nIndex, nCount)) {
-            return FALSE;
+            return false;
         }
         while (nCount--) {
             ((TYPE*)m_pData)[nIndex++] = newElement;
         }
-        return TRUE;
+        return true;
     }
 
-    FX_BOOL             RemoveAt(int nIndex, int nCount = 1)
+    bool                RemoveAt(int nIndex, int nCount = 1)
     {
         return CFX_BasicArray::RemoveAt(nIndex, nCount);
     }
 
-    FX_BOOL             InsertAt(int nStartIndex, const CFX_BasicArray* pNewArray)
+    bool                InsertAt(int nStartIndex, const CFX_BasicArray* pNewArray)
     {
         return CFX_BasicArray::InsertAt(nStartIndex, pNewArray);
     }
 
     int                 Find(TYPE data, int iStart = 0) const
     {
         if (iStart < 0) {
             return -1;
         }
         for (; iStart < (int)m_nSize; iStart ++)
@@ skipping 152 matching lines @@
     int         GetSegmentSize() const
     {
         return m_SegmentSize;
     }
 
     int         GetUnitSize() const
     {
         return m_UnitSize;
     }
 
-    void*       Iterate(FX_BOOL (*callback)(void* param, void* pData), void* param) const;
+    void*       Iterate(bool (*callback)(void* param, void* pData), void* param) const;
 private:
 
     int                         m_UnitSize;
 
     short                       m_SegmentSize;
 
     uint8_t                     m_IndexSize;
 
     uint8_t                     m_IndexDepth;
 
     int                         m_DataSize;
 
     void*                       m_pIndex;
     void**      GetIndex(int seg_index) const;
-    void*       IterateIndex(int level, int& start, void** pIndex, FX_BOOL (*callback)(void* param, void* pData), void* param) const;
-    void*       IterateSegment(const uint8_t* pSegment, int count, FX_BOOL (*callback)(void* param, void* pData), void* param) const;
+    void*       IterateIndex(int level, int& start, void** pIndex, bool (*callback)(void* param, void* pData), void* param) const;
+    void*       IterateSegment(const uint8_t* pSegment, int count, bool (*callback)(void* param, void* pData), void* param) const;
 };
 template <class ElementType>
 class CFX_SegmentedArray : public CFX_BaseSegmentedArray
 {
 public:
     CFX_SegmentedArray(int segment_units, int index_size = 8)
         : CFX_BaseSegmentedArray(sizeof(ElementType), segment_units, index_size)
     {}
 
     void        Add(ElementType data)
@@ skipping 61 matching lines @@
 public:
     CFX_MapPtrToPtr(int nBlockSize = 10);
 
     ~CFX_MapPtrToPtr();
 
     int GetCount() const
     {
         return m_nCount;
     }
 
-    FX_BOOL IsEmpty() const
+    bool IsEmpty() const
     {
         return m_nCount == 0;
     }
 
-    FX_BOOL Lookup(void* key, void*& rValue) const;
+    bool Lookup(void* key, void*& rValue) const;
 
     void* GetValueAt(void* key) const;
 
     void*& operator[](void* key);
 
     void SetAt(void* key, void* newValue)
     {
         (*this)[key] = newValue;
     }
 
-    FX_BOOL RemoveKey(void* key);
+    bool RemoveKey(void* key);
 
     void RemoveAll();
 
     FX_POSITION GetStartPosition() const
     {
         return (m_nCount == 0) ? NULL : (FX_POSITION) - 1;
     }
 
     void GetNextAssoc(FX_POSITION& rNextPosition, void*& rKey, void*& rValue) const;
 
     FX_DWORD GetHashTableSize() const
     {
         return m_nHashTableSize;
     }
 
-    void InitHashTable(FX_DWORD hashSize, FX_BOOL bAllocNow = TRUE);
+    void InitHashTable(FX_DWORD hashSize, bool bAllocNow = true);
 protected:
 
     CAssoc** m_pHashTable;
 
     FX_DWORD m_nHashTableSize;
 
     int m_nCount;
 
     CAssoc* m_pFreeList;
 
     struct CFX_Plex* m_pBlocks;
 
     int m_nBlockSize;
 
     FX_DWORD HashKey(void* key) const;
 
     CAssoc* NewAssoc();
 
     void FreeAssoc(CAssoc* pAssoc);
 
     CAssoc* GetAssocAt(void* key, FX_DWORD& hash) const;
 };
 
 class CFX_CMapDWordToDWord
 {
 public:
 
-    FX_BOOL                     Lookup(FX_DWORD key, FX_DWORD& value) const;
+    bool                        Lookup(FX_DWORD key, FX_DWORD& value) const;
 
     void                        SetAt(FX_DWORD key, FX_DWORD value);
 
     void                        EstimateSize(FX_DWORD size, FX_DWORD grow_by);
 
     FX_POSITION         GetStartPosition() const;
 
     void                        GetNextAssoc(FX_POSITION& pos, FX_DWORD& key, FX_DWORD& value) const;
 protected:
 
@@ skipping 14 matching lines @@
         void* value;
     };
 public:
     CFX_MapByteStringToPtr(int nBlockSize = 10);
 
     int GetCount() const
     {
         return m_nCount;
     }
 
-    FX_BOOL IsEmpty() const
+    bool IsEmpty() const
     {
         return m_nCount == 0;
     }
 
-    FX_BOOL Lookup(const CFX_ByteStringC& key, void*& rValue) const;
+    bool Lookup(const CFX_ByteStringC& key, void*& rValue) const;
 
     void*& operator[](const CFX_ByteStringC& key);
 
     void SetAt(const CFX_ByteStringC& key, void* newValue)
     {
         (*this)[key] = newValue;
     }
 
-    FX_BOOL RemoveKey(const CFX_ByteStringC& key);
+    bool RemoveKey(const CFX_ByteStringC& key);
 
     void RemoveAll();
 
     FX_POSITION GetStartPosition() const
     {
         return (m_nCount == 0) ? NULL : (FX_POSITION) - 1;
     }
 
     void GetNextAssoc(FX_POSITION& rNextPosition, CFX_ByteString& rKey, void*& rValue) const;
 
     void*               GetNextValue(FX_POSITION& rNextPosition) const;
 
     FX_DWORD GetHashTableSize() const
     {
         return m_nHashTableSize;
     }
 
-    void InitHashTable(FX_DWORD hashSize, FX_BOOL bAllocNow = TRUE);
+    void InitHashTable(FX_DWORD hashSize, bool bAllocNow = true);
 
     FX_DWORD HashKey(const CFX_ByteStringC& key) const;
 protected:
 
     CAssoc** m_pHashTable;
 
     FX_DWORD m_nHashTableSize;
 
     int m_nCount;
 
@@ skipping 20 matching lines @@
     ~CFX_CMapByteStringToPtr();
 
     void                        RemoveAll();
 
     FX_POSITION         GetStartPosition() const;
 
     void                        GetNextAssoc(FX_POSITION& rNextPosition, CFX_ByteString& rKey, void*& rValue) const;
 
     void*               GetNextValue(FX_POSITION& rNextPosition) const;
 
-    FX_BOOL                     Lookup(const CFX_ByteStringC& key, void*& rValue) const;
+    bool                        Lookup(const CFX_ByteStringC& key, void*& rValue) const;
 
     void                        SetAt(const CFX_ByteStringC& key, void* value);
 
     void                        RemoveKey(const CFX_ByteStringC& key);
 
     int                         GetCount() const;
 
     void                        AddValue(const CFX_ByteStringC& key, void* pValue);
 private:
 
@@ skipping 103 matching lines @@
 struct FX_PRIVATEDATA {
 
     void                                        FreeData();
 
     void*                               m_pModuleId;
 
     void*                               m_pData;
 
     PD_CALLBACK_FREEDATA        m_pCallback;
 
-    FX_BOOL                                     m_bSelfDestruct;
+    bool                                        m_bSelfDestruct;
 };
 class CFX_PrivateData
 {
 public:
 
     ~CFX_PrivateData();
 
     void                                        ClearAll();
 
     void                                        SetPrivateData(void* module_id, void* pData, PD_CALLBACK_FREEDATA callback);
 
     void                                        SetPrivateObj(void* module_id, CFX_DestructObject* pObj);
 
     void*                               GetPrivateData(void* module_id);
 
-    FX_BOOL                                     LookupPrivateData(void* module_id, void* &pData) const
+    bool                                        LookupPrivateData(void* module_id, void* &pData) const
     {
         if (!module_id) {
-            return FALSE;
+            return false;
         }
         FX_DWORD nCount = m_DataList.GetSize();
         for (FX_DWORD n = 0; n < nCount; n ++) {
             if (m_DataList[n].m_pModuleId == module_id) {
                 pData = m_DataList[n].m_pData;
-                return TRUE;
+                return true;
             }
         }
-        return FALSE;
+        return false;
     }
 
-    FX_BOOL                                     RemovePrivateData(void* module_id);
+    bool                                        RemovePrivateData(void* module_id);
 protected:
 
     CFX_ArrayTemplate<FX_PRIVATEDATA>   m_DataList;
 
-    void                                        AddData(void* module_id, void* pData, PD_CALLBACK_FREEDATA callback, FX_BOOL bSelfDestruct);
+    void                                        AddData(void* module_id, void* pData, PD_CALLBACK_FREEDATA callback, bool bSelfDestruct);
 };
 class CFX_BitStream
 {
 public:
 
     void                                Init(const uint8_t* pData, FX_DWORD dwSize);
 
 
     FX_DWORD                    GetBits(FX_DWORD nBits);
 
     void                                ByteAlign();
 
-    FX_BOOL                             IsEOF()
+    bool                                IsEOF()
     {
         return m_BitPos >= m_BitSize;
     }
 
     void                                SkipBits(FX_DWORD nBits)
     {
         m_BitPos += nBits;
     }
 
     void                                Rewind()
@@ skipping 92 matching lines @@
     const ObjClass*             GetObject() const
     {
         return m_pObject;
     }
 
     operator                    const ObjClass*() const
     {
         return m_pObject;
     }
 
-    FX_BOOL                             IsNull() const
+    bool                                IsNull() const
     {
         return m_pObject == NULL;
     }
 
-    FX_BOOL                             NotNull() const
+    bool                                NotNull() const
     {
         return m_pObject != NULL;
     }
 
     ObjClass*                   GetModify()
     {
         if (m_pObject == NULL) {
             m_pObject = new CountedObj;
             m_pObject->m_RefCount = 1;
         } else if (m_pObject->m_RefCount > 1) {
@@ skipping 10 matching lines @@
         if (m_pObject == NULL) {
             return;
         }
         m_pObject->m_RefCount --;
         if (m_pObject->m_RefCount <= 0) {
             delete m_pObject;
         }
         m_pObject = NULL;
     }
 
-    FX_BOOL                             operator == (const Ref& ref) const
+    bool                                operator == (const Ref& ref) const
     {
         return m_pObject == ref.m_pObject;
     }
 protected:
 
     CountedObj*                 m_pObject;
 };
 class IFX_Pause
 {
 public:
     virtual ~IFX_Pause() { }
-    virtual FX_BOOL     NeedToPauseNow() = 0;
+    virtual bool        NeedToPauseNow() = 0;
 };
 class CFX_DataFilter
 {
 public:
 
     virtual ~CFX_DataFilter();
 
     void                        SetDestFilter(CFX_DataFilter* pFilter);
 
-    FX_BOOL                     IsEOF() const
+    bool                        IsEOF() const
     {
         return m_bEOF;
     }
 
     FX_DWORD            GetSrcPos()
     {
         return m_SrcPos;
     }
 
     void                        FilterIn(const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf);
 
     void                        FilterFinish(CFX_BinaryBuf& dest_buf);
 protected:
 
     CFX_DataFilter();
     virtual void        v_FilterIn(const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf) = 0;
     virtual void        v_FilterFinish(CFX_BinaryBuf& dest_buf) = 0;
     void                        ReportEOF(FX_DWORD left_input);
 
-    FX_BOOL                     m_bEOF;
+    bool                        m_bEOF;
 
     FX_DWORD            m_SrcPos;
 
     CFX_DataFilter*     m_pDestFilter;
 };
 
 template<typename T>
 class CFX_AutoRestorer {
 public:
     explicit CFX_AutoRestorer(T* location) {
@@ skipping 224 matching lines @@
     FX_FLOAT c;
     FX_FLOAT d;
     FX_FLOAT e;
     FX_FLOAT f;
     FX_FLOAT g;
     FX_FLOAT h;
     FX_FLOAT i;
 };
 
 #endif  // CORE_INCLUDE_FXCRT_FX_BASIC_H_