FX_BOOL considered harmful.

core/src/fpdfapi/fpdf_font/fpdf_font_cid.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_module.h"
 #include "../../../include/fpdfapi/fpdf_page.h"
 #include "../../../include/fpdfapi/fpdf_resource.h"
 #include "../../../include/fxge/fx_freetype.h"
 #include "../../../include/fxge/fx_ge.h"
 #include "../fpdf_cmaps/cmap_int.h"
 #include "font_int.h"
 
 extern short TT2PDF(int m, FXFT_Face face);
-extern FX_BOOL FT_UseTTCharmap(FXFT_Face face, int platform_id, int encoding_id);
+extern bool FT_UseTTCharmap(FXFT_Face face, int platform_id, int encoding_id);
 
 CPDF_CMapManager::CPDF_CMapManager()
 {
-    m_bPrompted = FALSE;
+    m_bPrompted = false;
     FXSYS_memset(m_CID2UnicodeMaps, 0, sizeof m_CID2UnicodeMaps);
 }
 CPDF_CMapManager::~CPDF_CMapManager()
 {
-    DropAll(FALSE);
+    DropAll(false);
 }
-CPDF_CMap* CPDF_CMapManager::GetPredefinedCMap(const CFX_ByteString& name, FX_BOOL bPromptCJK)
+CPDF_CMap* CPDF_CMapManager::GetPredefinedCMap(const CFX_ByteString& name, bool bPromptCJK)
 {
     CPDF_CMap* pCMap;
     if (m_CMaps.Lookup(name, (void*&)pCMap)) {
         return pCMap;
     }
     pCMap = LoadPredefinedCMap(name, bPromptCJK);
     if (name.IsEmpty()) {
         return pCMap;
     }
     m_CMaps.SetAt(name, pCMap);
     return pCMap;
 }
-CPDF_CMap* CPDF_CMapManager::LoadPredefinedCMap(const CFX_ByteString& name, FX_BOOL bPromptCJK)
+CPDF_CMap* CPDF_CMapManager::LoadPredefinedCMap(const CFX_ByteString& name, bool bPromptCJK)
 {
     CPDF_CMap* pCMap = new CPDF_CMap;
     const FX_CHAR* pname = name;
     if (*pname == '/') {
         pname ++;
     }
     pCMap->LoadPredefined(this, pname, bPromptCJK);
     return pCMap;
 }
 static const FX_CHAR* const g_CharsetNames[NUMBER_OF_CIDSETS] = {NULL, "GB1", "CNS1", "Japan1", "Korea1", "UCS" };
 static const int g_CharsetCPs[NUMBER_OF_CIDSETS] = {0, 936, 950, 932, 949, 1200 };
 int _CharsetFromOrdering(const CFX_ByteString& Ordering)
 {
         for (int charset = 1; charset < NUMBER_OF_CIDSETS; charset++) {
                 if (Ordering == CFX_ByteStringC(g_CharsetNames[charset]))
                         return charset;
         }
         return CIDSET_UNKNOWN;
 }
 void CPDF_CMapManager::ReloadAll()
 {
-    DropAll(TRUE);
+    DropAll(true);
 }
-void CPDF_CMapManager::DropAll(FX_BOOL bReload)
+void CPDF_CMapManager::DropAll(bool bReload)
 {
     FX_POSITION pos = m_CMaps.GetStartPosition();
     while (pos) {
         CFX_ByteString name;
         CPDF_CMap* pCMap;
         m_CMaps.GetNextAssoc(pos, name, (void*&)pCMap);
         if (pCMap == NULL) {
             continue;
         }
         if (bReload) {
-            pCMap->LoadPredefined(this, name, FALSE);
+            pCMap->LoadPredefined(this, name, false);
         } else {
             delete pCMap;
         }
     }
     for (int i = 0; i < sizeof m_CID2UnicodeMaps / sizeof(CPDF_CID2UnicodeMap*); i ++) {
         CPDF_CID2UnicodeMap* pMap = m_CID2UnicodeMaps[i];
         if (pMap == NULL) {
             continue;
         }
         if (bReload) {
-            pMap->Load(this, i, FALSE);
+            pMap->Load(this, i, false);
         } else {
             delete pMap;
         }
     }
 }
-CPDF_CID2UnicodeMap* CPDF_CMapManager::GetCID2UnicodeMap(int charset, FX_BOOL bPromptCJK)
+CPDF_CID2UnicodeMap* CPDF_CMapManager::GetCID2UnicodeMap(int charset, bool bPromptCJK)
 {
     if (m_CID2UnicodeMaps[charset] == NULL) {
         m_CID2UnicodeMaps[charset] = LoadCID2UnicodeMap(charset, bPromptCJK);
     }
     return m_CID2UnicodeMaps[charset];
 }
-CPDF_CID2UnicodeMap* CPDF_CMapManager::LoadCID2UnicodeMap(int charset, FX_BOOL bPromptCJK)
+CPDF_CID2UnicodeMap* CPDF_CMapManager::LoadCID2UnicodeMap(int charset, bool bPromptCJK)
 {
     CPDF_CID2UnicodeMap* pMap = new CPDF_CID2UnicodeMap();
     if (!pMap->Initialize()) {
         delete pMap;
         return NULL;
     }
     pMap->Load(this, charset, bPromptCJK);
     return pMap;
 }
 CPDF_CMapParser::CPDF_CMapParser()
 {
     m_pCMap = NULL;
     m_Status = 0;
     m_CodeSeq = 0;
 }
-FX_BOOL CPDF_CMapParser::Initialize(CPDF_CMap* pCMap)
+bool    CPDF_CMapParser::Initialize(CPDF_CMap* pCMap)
 {
     m_pCMap = pCMap;
     m_Status = 0;
     m_CodeSeq = 0;
     m_AddMaps.EstimateSize(0, 10240);
-    return TRUE;
+    return true;
 }
 static FX_DWORD CMap_GetCode(const CFX_ByteStringC& word)
 {
     int num = 0;
     if (word.GetAt(0) == '<') {
         for (int i = 1; i < word.GetLength(); i ++) {
             uint8_t digit = word.GetAt(i);
             if (digit >= '0' && digit <= '9') {
                 digit = digit - '0';
             } else if (digit >= 'a' && digit <= 'f') {
                 digit = digit - 'a' + 10;
             } else if (digit >= 'A' && digit <= 'F') {
                 digit = digit - 'A' + 10;
             } else {
                 return num;
             }
             num = num * 16 + digit;
         }
     } else {
         for (int i = 0; i < word.GetLength(); i ++) {
             if (word.GetAt(i) < '0' || word.GetAt(i) > '9') {
                 return num;
             }
             num = num * 10 + word.GetAt(i) - '0';
         }
     }
     return num;
 }
-static FX_BOOL _CMap_GetCodeRange(_CMap_CodeRange& range, const CFX_ByteStringC& first, const CFX_ByteStringC& second)
+static bool _CMap_GetCodeRange(_CMap_CodeRange& range, const CFX_ByteStringC& first, const CFX_ByteStringC& second)
 {
     if (first.GetLength() == 0 || first.GetAt(0) != '<') {
-        return FALSE;
+        return false;
     }
     int i;
     for (i = 1; i < first.GetLength(); i ++)
         if (first.GetAt(i) == '>') {
             break;
         }
     range.m_CharSize = (i - 1) / 2;
     if (range.m_CharSize > 4) {
-        return FALSE;
+        return false;
     }
     for (i = 0; i < range.m_CharSize; i ++) {
         uint8_t digit1 = first.GetAt(i * 2 + 1);
         uint8_t digit2 = first.GetAt(i * 2 + 2);
         uint8_t byte = (digit1 >= '0' && digit1 <= '9') ? (digit1 - '0') : ((digit1 & 0xdf) - 'A' + 10);
         byte = byte * 16 + ((digit2 >= '0' && digit2 <= '9') ? (digit2 - '0') : ((digit2 & 0xdf) - 'A' + 10));
         range.m_Lower[i] = byte;
     }
     FX_DWORD size = second.GetLength();
     for (i = 0; i < range.m_CharSize; i ++) {
         uint8_t digit1 = ((FX_DWORD)i * 2 + 1 < size) ? second.GetAt((FX_STRSIZE)i * 2 + 1) : 0;
         uint8_t digit2 = ((FX_DWORD)i * 2 + 2 < size) ? second.GetAt((FX_STRSIZE)i * 2 + 2) : 0;
         uint8_t byte = (digit1 >= '0' && digit1 <= '9') ? (digit1 - '0') : ((digit1 & 0xdf) - 'A' + 10);
         byte = byte * 16 + ((digit2 >= '0' && digit2 <= '9') ? (digit2 - '0') : ((digit2 & 0xdf) - 'A' + 10));
         range.m_Upper[i] = byte;
     }
-    return TRUE;
+    return true;
 }
 static CFX_ByteString CMap_GetString(const CFX_ByteStringC& word)
 {
     return word.Mid(1, word.GetLength() - 2);
 }
 void CPDF_CMapParser::ParseWord(const CFX_ByteStringC& word)
 {
     if (word.IsEmpty()) {
         return;
     }
@@ skipping 85 matching lines @@
         }
     }
     m_LastWord = word;
 }
 CPDF_CMap::CPDF_CMap()
 {
     m_Charset = CIDSET_UNKNOWN;
     m_Coding = CIDCODING_UNKNOWN;
     m_CodingScheme = TwoBytes;
     m_bVertical = 0;
-    m_bLoaded = FALSE;
+    m_bLoaded = false;
     m_pMapping = NULL;
     m_pLeadingBytes = NULL;
     m_pAddMapping = NULL;
     m_pEmbedMap = NULL;
     m_pUseMap = NULL;
     m_nCodeRanges = 0;
 }
 CPDF_CMap::~CPDF_CMap()
 {
     if (m_pMapping) {
@@ skipping 43 matching lines @@
     { "KSC-EUC", CIDSET_KOREA1, CIDCODING_KOREA, CPDF_CMap::MixedTwoBytes, 1, {0xa1, 0xfe} },
     { "KSCms-UHC", CIDSET_KOREA1, CIDCODING_KOREA, CPDF_CMap::MixedTwoBytes, 1, {0x81, 0xfe} },
     { "KSCms-UHC-HW", CIDSET_KOREA1, CIDCODING_KOREA, CPDF_CMap::MixedTwoBytes, 1, {0x81, 0xfe} },
     { "KSCpc-EUC", CIDSET_KOREA1, CIDCODING_KOREA, CPDF_CMap::MixedTwoBytes, 1, {0xa1, 0xfd} },
     { "UniKS-UCS2", CIDSET_KOREA1, CIDCODING_UCS2, CPDF_CMap::TwoBytes },
     { "UniKS-UTF16", CIDSET_KOREA1, CIDCODING_UTF16, CPDF_CMap::TwoBytes },
     { NULL, 0, 0 }
 };
 extern void FPDFAPI_FindEmbeddedCMap(const char* name, int charset, int coding, const FXCMAP_CMap*& pMap);
 extern FX_WORD FPDFAPI_CIDFromCharCode(const FXCMAP_CMap* pMap, FX_DWORD charcode);
-FX_BOOL CPDF_CMap::LoadPredefined(CPDF_CMapManager* pMgr, const FX_CHAR* pName, FX_BOOL bPromptCJK)
+bool CPDF_CMap::LoadPredefined(CPDF_CMapManager* pMgr, const FX_CHAR* pName, bool bPromptCJK)
 {
     m_PredefinedCMap = pName;
     if (m_PredefinedCMap == FX_BSTRC("Identity-H") || m_PredefinedCMap == FX_BSTRC("Identity-V")) {
         m_Coding = CIDCODING_CID;
         m_bVertical = pName[9] == 'V';
-        m_bLoaded = TRUE;
-        return TRUE;
+        m_bLoaded = true;
+        return true;
     }
     CFX_ByteString cmapid = m_PredefinedCMap;
     m_bVertical = cmapid.Right(1) == FX_BSTRC("V");
     if (cmapid.GetLength() > 2) {
         cmapid = cmapid.Left(cmapid.GetLength() - 2);
     }
     int index = 0;
     while (1) {
         if (g_PredefinedCMaps[index].m_pName == NULL) {
-            return FALSE;
+            return false;
         }
         if (cmapid == CFX_ByteStringC(g_PredefinedCMaps[index].m_pName)) {
             break;
         }
         index ++;
     }
     const CPDF_PredefinedCMap& map = g_PredefinedCMaps[index];
     m_Charset = map.m_Charset;
     m_Coding = map.m_Coding;
     m_CodingScheme = map.m_CodingScheme;
     if (m_CodingScheme == MixedTwoBytes) {
         m_pLeadingBytes = FX_Alloc(uint8_t, 256);
         for (FX_DWORD i = 0; i < map.m_LeadingSegCount; i ++) {
             for (int b = map.m_LeadingSegs[i * 2]; b <= map.m_LeadingSegs[i * 2 + 1]; b ++) {
                 m_pLeadingBytes[b] = 1;
             }
         }
     }
     FPDFAPI_FindEmbeddedCMap(pName, m_Charset, m_Coding, m_pEmbedMap);
     if (m_pEmbedMap) {
-        m_bLoaded = TRUE;
-        return TRUE;
+        m_bLoaded = true;
+        return true;
     }
-    return FALSE;
+    return false;
 }
 extern "C" {
     static int compare_dword(const void* data1, const void* data2)
     {
         return (*(FX_DWORD*)data1) - (*(FX_DWORD*)data2);
     }
 };
-FX_BOOL CPDF_CMap::LoadEmbedded(const uint8_t* pData, FX_DWORD size)
+bool CPDF_CMap::LoadEmbedded(const uint8_t* pData, FX_DWORD size)
 {
     m_pMapping = FX_Alloc(FX_WORD, 65536);
     CPDF_CMapParser parser;
     parser.Initialize(this);
     CPDF_SimpleParser syntax(pData, size);
     while (1) {
         CFX_ByteStringC word = syntax.GetWord();
         if (word.IsEmpty()) {
             break;
         }
         parser.ParseWord(word);
     }
     if (m_CodingScheme == MixedFourBytes && parser.m_AddMaps.GetSize()) {
         m_pAddMapping = FX_Alloc(uint8_t, parser.m_AddMaps.GetSize() + 4);
         *(FX_DWORD*)m_pAddMapping = parser.m_AddMaps.GetSize() / 8;
         FXSYS_memcpy(m_pAddMapping + 4, parser.m_AddMaps.GetBuffer(), parser.m_AddMaps.GetSize());
         FXSYS_qsort(m_pAddMapping + 4, parser.m_AddMaps.GetSize() / 8, 8, compare_dword);
     }
-    return TRUE;
+    return true;
 }
 extern "C" {
     static int compareCID(const void* key, const void* element)
     {
         if ((*(FX_DWORD*)key) < (*(FX_DWORD*)element)) {
             return -1;
         }
         if ((*(FX_DWORD*)key) > (*(FX_DWORD*)element) + ((FX_DWORD*)element)[1] / 65536) {
             return 1;
         }
@@ skipping 232 matching lines @@
     }
     return 0;
 }
 CPDF_CID2UnicodeMap::CPDF_CID2UnicodeMap()
 {
     m_EmbeddedCount = 0;
 }
 CPDF_CID2UnicodeMap::~CPDF_CID2UnicodeMap()
 {
 }
-FX_BOOL CPDF_CID2UnicodeMap::Initialize()
+bool CPDF_CID2UnicodeMap::Initialize()
 {
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_CID2UnicodeMap::IsLoaded()
+bool CPDF_CID2UnicodeMap::IsLoaded()
 {
     return m_EmbeddedCount != 0;
 }
 FX_WCHAR CPDF_CID2UnicodeMap::UnicodeFromCID(FX_WORD CID)
 {
     if (m_Charset == CIDSET_UNICODE) {
         return CID;
     }
     if (CID < m_EmbeddedCount) {
         return m_pEmbeddedMap[CID];
     }
     return 0;
 }
 void FPDFAPI_LoadCID2UnicodeMap(int charset, const FX_WORD*& pMap, FX_DWORD& count);
-void CPDF_CID2UnicodeMap::Load(CPDF_CMapManager* pMgr, int charset, FX_BOOL bPromptCJK)
+void CPDF_CID2UnicodeMap::Load(CPDF_CMapManager* pMgr, int charset, bool bPromptCJK)
 {
     m_Charset = charset;
     FPDFAPI_LoadCID2UnicodeMap(charset, m_pEmbeddedMap, m_EmbeddedCount);
 }
 #include "ttgsubtable.h"
 CPDF_CIDFont::CPDF_CIDFont() : CPDF_Font(PDFFONT_CIDFONT)
 {
     m_pCMap = NULL;
     m_pAllocatedCMap = NULL;
     m_pCID2UnicodeMap = NULL;
     m_pAnsiWidths = NULL;
     m_pCIDToGIDMap = NULL;
-    m_bCIDIsGID = FALSE;
-    m_bAdobeCourierStd = FALSE;
+    m_bCIDIsGID = false;
+    m_bAdobeCourierStd = false;
     m_pTTGSUBTable = NULL;
     FXSYS_memset(m_CharBBox, 0xff, 256 * sizeof(FX_SMALL_RECT));
 }
 CPDF_CIDFont::~CPDF_CIDFont()
 {
     if (m_pAnsiWidths) {
         FX_Free(m_pAnsiWidths);
     }
     delete m_pAllocatedCMap;
     delete m_pCIDToGIDMap;
     delete m_pTTGSUBTable;
 }
 FX_WORD CPDF_CIDFont::CIDFromCharCode(FX_DWORD charcode) const
 {
     if (m_pCMap == NULL) {
         return (FX_WORD)charcode;
     }
     return m_pCMap->CIDFromCharCode(charcode);
 }
-FX_BOOL CPDF_CIDFont::IsVertWriting() const
+bool CPDF_CIDFont::IsVertWriting() const
 {
-    return m_pCMap ? m_pCMap->IsVertWriting() : FALSE;
+    return m_pCMap ? m_pCMap->IsVertWriting() : false;
 }
 extern FX_DWORD FPDFAPI_CharCodeFromCID(const FXCMAP_CMap* pMap, FX_WORD cid);
 static FX_DWORD _EmbeddedCharcodeFromUnicode(const FXCMAP_CMap* pEmbedMap, int charset, FX_WCHAR unicode)
 {
     if (charset <= 0 || charset > 4) {
         return 0;
     }
     CPDF_FontGlobals* pFontGlobals = CPDF_ModuleMgr::Get()->GetPageModule()->GetFontGlobals();
     const FX_WORD* pCodes = pFontGlobals->m_EmbeddedToUnicodes[charset].m_pMap;
     if (pCodes == NULL) {
@@ skipping 128 matching lines @@
             encoding = FXFT_ENCODING_UNICODE;
     }
     int err = FXFT_Select_Charmap(face, encoding);
     if (err) {
         err = FXFT_Select_Charmap(face, FXFT_ENCODING_UNICODE);
     }
     if (err && FXFT_Get_Face_Charmaps(face)) {
         FXFT_Set_Charmap(face, *FXFT_Get_Face_Charmaps(face));
     }
 }
-FX_BOOL CPDF_CIDFont::_Load()
+bool CPDF_CIDFont::_Load()
 {
     if (m_pFontDict->GetString(FX_BSTRC("Subtype")) == FX_BSTRC("TrueType")) {
         return LoadGB2312();
     }
     CPDF_Array* pFonts = m_pFontDict->GetArray(FX_BSTRC("DescendantFonts"));
     if (pFonts == NULL) {
-        return FALSE;
+        return false;
     }
     if (pFonts->GetCount() != 1) {
-        return FALSE;
+        return false;
     }
     CPDF_Dictionary* pCIDFontDict = pFonts->GetDict(0);
     if (pCIDFontDict == NULL) {
-        return FALSE;
+        return false;
     }
     m_BaseFont = pCIDFontDict->GetString(FX_BSTRC("BaseFont"));
     if ((m_BaseFont.Compare("CourierStd") == 0 || m_BaseFont.Compare("CourierStd-Bold") == 0
             || m_BaseFont.Compare("CourierStd-BoldOblique") == 0 || m_BaseFont.Compare("CourierStd-Oblique") == 0)
             && !IsEmbedded()) {
-        m_bAdobeCourierStd = TRUE;
+        m_bAdobeCourierStd = true;
     }
     CPDF_Dictionary* pFontDesc = pCIDFontDict->GetDict(FX_BSTRC("FontDescriptor"));
     if (pFontDesc) {
         LoadFontDescriptor(pFontDesc);
     }
     CPDF_Object* pEncoding = m_pFontDict->GetElementValue(FX_BSTRC("Encoding"));
     if (pEncoding == NULL) {
-        return FALSE;
+        return false;
     }
     CFX_ByteString subtype = pCIDFontDict->GetString(FX_BSTRC("Subtype"));
-    m_bType1 = FALSE;
+    m_bType1 = false;
     if (subtype == FX_BSTRC("CIDFontType0")) {
-        m_bType1 = TRUE;
+        m_bType1 = true;
     }
     if (pEncoding->GetType() == PDFOBJ_NAME) {
         CFX_ByteString cmap = pEncoding->GetString();
         m_pCMap = CPDF_ModuleMgr::Get()->GetPageModule()->GetFontGlobals()->m_CMapManager.GetPredefinedCMap(cmap,
                   m_pFontFile && m_bType1);
     } else if (pEncoding->GetType() == PDFOBJ_STREAM) {
         m_pAllocatedCMap = m_pCMap = new CPDF_CMap;
         CPDF_Stream* pStream = (CPDF_Stream*)pEncoding;
         CPDF_StreamAcc acc;
-        acc.LoadAllData(pStream, FALSE);
+        acc.LoadAllData(pStream, false);
         m_pCMap->LoadEmbedded(acc.GetData(), acc.GetSize());
     } else {
-        return FALSE;
+        return false;
     }
     if (m_pCMap == NULL) {
-        return FALSE;
+        return false;
     }
     m_Charset = m_pCMap->m_Charset;
     if (m_Charset == CIDSET_UNKNOWN) {
         CPDF_Dictionary* pCIDInfo = pCIDFontDict->GetDict(FX_BSTRC("CIDSystemInfo"));
         if (pCIDInfo) {
             m_Charset = _CharsetFromOrdering(pCIDInfo->GetString(FX_BSTRC("Ordering")));
         }
     }
     if (m_Charset != CIDSET_UNKNOWN)
         m_pCID2UnicodeMap = CPDF_ModuleMgr::Get()->GetPageModule()->GetFontGlobals()->m_CMapManager.GetCID2UnicodeMap(m_Charset,
@@ skipping 12 matching lines @@
     }
     if (!IsEmbedded()) {
         LoadSubstFont();
     }
     if (1) {
         if (m_pFontFile || (GetSubstFont()->m_SubstFlags & FXFONT_SUBST_EXACT)) {
             CPDF_Object* pmap = pCIDFontDict->GetElementValue(FX_BSTRC("CIDToGIDMap"));
             if (pmap) {
                 if (pmap->GetType() == PDFOBJ_STREAM) {
                     m_pCIDToGIDMap = new CPDF_StreamAcc;
-                    m_pCIDToGIDMap->LoadAllData((CPDF_Stream*)pmap, FALSE);
+                    m_pCIDToGIDMap->LoadAllData((CPDF_Stream*)pmap, false);
                 } else if (pmap->GetString() == FX_BSTRC("Identity")) {
 #if _FXM_PLATFORM_  == _FXM_PLATFORM_APPLE_
                     if (m_pFontFile) {
-                        m_bCIDIsGID = TRUE;
+                        m_bCIDIsGID = true;
                     }
 #else
-                    m_bCIDIsGID = TRUE;
+                    m_bCIDIsGID = true;
 #endif
                 }
             }
         }
     }
     CheckFontMetrics();
     if (IsVertWriting()) {
         pWidthArray = pCIDFontDict->GetArray(FX_BSTRC("W2"));
         if (pWidthArray) {
             LoadMetricsArray(pWidthArray, m_VertMetrics, 3);
         }
         CPDF_Array* pDefaultArray = pCIDFontDict->GetArray(FX_BSTRC("DW2"));
         if (pDefaultArray) {
             m_DefaultVY = pDefaultArray->GetInteger(0);
             m_DefaultW1 = pDefaultArray->GetInteger(1);
         } else {
             m_DefaultVY = 880;
             m_DefaultW1 = -1000;
         }
     }
-    return TRUE;
+    return true;
 }
 FX_FLOAT _CIDTransformToFloat(uint8_t ch)
 {
     if (ch < 128) {
         return ch * 1.0f / 127;
     }
     return (-255 + ch) * 1.0f / 127;
 }
 void CPDF_CIDFont::GetCharBBox(FX_DWORD charcode, FX_RECT& rect, int level)
 {
     if (charcode < 256 && m_CharBBox[charcode].Right != -1) {
         rect.bottom = m_CharBBox[charcode].Bottom;
         rect.left = m_CharBBox[charcode].Left;
         rect.right = m_CharBBox[charcode].Right;
         rect.top = m_CharBBox[charcode].Top;
         return;
     }
-    FX_BOOL bVert = FALSE;
+    bool bVert = false;
     int glyph_index = GlyphFromCharCode(charcode, &bVert);
     if (m_Font.m_Face == NULL) {
         rect = FX_RECT(0, 0, 0, 0);
     } else {
         rect.left = rect.bottom = rect.right = rect.top = 0;
         FXFT_Face face = m_Font.m_Face;
         if (FXFT_Is_Face_Tricky(face)) {
             int err = FXFT_Load_Glyph(face, glyph_index, FXFT_LOAD_IGNORE_GLOBAL_ADVANCE_WIDTH);
             if (!err) {
                 FXFT_BBox cbox;
@@ skipping 98 matching lines @@
     const FX_DWORD* list = m_WidthList.GetData();
     for (int i = 0; i < size; i += 3) {
         if (CID >= list[i] && CID <= list[i + 1]) {
             dwWidth = (FX_WORD)list[i + 2];
             break;
         }
     }
     vx = (short)dwWidth / 2;
     vy = (short)m_DefaultVY;
 }
-int     CPDF_CIDFont::GetGlyphIndex(FX_DWORD unicode, FX_BOOL *pVertGlyph)
+int     CPDF_CIDFont::GetGlyphIndex(FX_DWORD unicode, bool *pVertGlyph)
 {
     if (pVertGlyph) {
-        *pVertGlyph = FALSE;
+        *pVertGlyph = false;
     }
     int index = FXFT_Get_Char_Index(m_Font.m_Face, unicode );
     if (unicode == 0x2502) {
         return index;
     }
     if (index && IsVertWriting()) {
         if (m_pTTGSUBTable) {
             TT_uint32_t vindex = 0;
             m_pTTGSUBTable->GetVerticalGlyph(index, &vindex);
             if (vindex) {
                 index = vindex;
                 if (pVertGlyph) {
-                    *pVertGlyph = TRUE;
+                    *pVertGlyph = true;
                 }
             }
             return index;
         }
         if (NULL == m_Font.m_pGsubData) {
             unsigned long length = 0;
             int error = FXFT_Load_Sfnt_Table( m_Font.m_Face, FT_MAKE_TAG('G', 'S', 'U', 'B'), 0, NULL, &length);
             if (!error) {
                 m_Font.m_pGsubData = (unsigned char*)FX_Alloc(uint8_t, length);
             }
         }
         int error = FXFT_Load_Sfnt_Table( m_Font.m_Face, FT_MAKE_TAG('G', 'S', 'U', 'B'), 0, m_Font.m_pGsubData, NULL);
         if (!error && m_Font.m_pGsubData) {
             m_pTTGSUBTable = new CFX_CTTGSUBTable;
             m_pTTGSUBTable->LoadGSUBTable((FT_Bytes)m_Font.m_pGsubData);
             TT_uint32_t vindex = 0;
             m_pTTGSUBTable->GetVerticalGlyph(index, &vindex);
             if (vindex) {
                 index = vindex;
                 if (pVertGlyph) {
-                    *pVertGlyph = TRUE;
+                    *pVertGlyph = true;
                 }
             }
         }
         return index;
     }
     if (pVertGlyph) {
-        *pVertGlyph = FALSE;
+        *pVertGlyph = false;
     }
     return index;
 }
-int CPDF_CIDFont::GlyphFromCharCode(FX_DWORD charcode, FX_BOOL *pVertGlyph)
+int CPDF_CIDFont::GlyphFromCharCode(FX_DWORD charcode, bool *pVertGlyph)
 {
     if (pVertGlyph) {
-        *pVertGlyph = FALSE;
+        *pVertGlyph = false;
     }
     if (m_pFontFile == NULL && m_pCIDToGIDMap == NULL) {
         FX_WORD cid = CIDFromCharCode(charcode);
         FX_WCHAR unicode = 0;
         if (m_bCIDIsGID) {
 #if _FXM_PLATFORM_ != _FXM_PLATFORM_APPLE_
             return cid;
 #else
             if (m_Flags & PDFFONT_SYMBOLIC) {
                 return cid;
@@ skipping 14 matching lines @@
             if (unicode == 0 && !(m_Flags & PDFFONT_SYMBOLIC)) {
                 unicode = UnicodeFromCharCode(charcode).GetAt(0);
             }
         }
         if (unicode == 0) {
             if (!m_bAdobeCourierStd) {
                 return charcode == 0 ? -1 : (int)charcode;
             }
             charcode += 31;
             int index = 0, iBaseEncoding;
-            FX_BOOL bMSUnicode = FT_UseTTCharmap(m_Font.m_Face, 3, 1);
-            FX_BOOL bMacRoman = FALSE;
+            bool bMSUnicode = FT_UseTTCharmap(m_Font.m_Face, 3, 1);
+            bool bMacRoman = false;
             if (!bMSUnicode) {
                 bMacRoman = FT_UseTTCharmap(m_Font.m_Face, 1, 0);
             }
             iBaseEncoding = PDFFONT_ENCODING_STANDARD;
             if (bMSUnicode) {
                 iBaseEncoding = PDFFONT_ENCODING_WINANSI;
             } else if (bMacRoman) {
                 iBaseEncoding = PDFFONT_ENCODING_MACROMAN;
             }
             const FX_CHAR* name = GetAdobeCharName(iBaseEncoding, NULL, charcode);
@@ skipping 100 matching lines @@
     return m_pCMap->GetCharSize(charcode);
 }
 int CPDF_CIDFont::CountChar(const FX_CHAR* pString, int size) const
 {
     return m_pCMap->CountChar(pString, size);
 }
 int CPDF_CIDFont::AppendChar(FX_CHAR* str, FX_DWORD charcode) const
 {
     return m_pCMap->AppendChar(str, charcode);
 }
-FX_BOOL CPDF_CIDFont::IsUnicodeCompatible() const
+bool CPDF_CIDFont::IsUnicodeCompatible() const
 {
     if (!m_pCMap->IsLoaded() || m_pCID2UnicodeMap == NULL || !m_pCID2UnicodeMap->IsLoaded()) {
         return m_pCMap->m_Coding != CIDCODING_UNKNOWN;
     }
-    return TRUE;
+    return true;
 }
-FX_BOOL CPDF_CIDFont::IsFontStyleFromCharCode(FX_DWORD charcode) const
+bool CPDF_CIDFont::IsFontStyleFromCharCode(FX_DWORD charcode) const
 {
-    return TRUE;
+    return true;
 }
 void CPDF_CIDFont::LoadSubstFont()
 {
     m_Font.LoadSubst(m_BaseFont, !m_bType1, m_Flags, m_StemV * 5, m_ItalicAngle, g_CharsetCPs[m_Charset], IsVertWriting());
 }
 void CPDF_CIDFont::LoadMetricsArray(CPDF_Array* pArray, CFX_DWordArray& result, int nElements)
 {
     int width_status = 0;
     int iCurElement = 0;
     int first_code = 0, last_code;
@@ skipping 33 matching lines @@
                 }
                 result.Add(pObj->GetInteger());
                 iCurElement ++;
                 if (iCurElement == nElements) {
                     width_status = 0;
                 }
             }
         }
     }
 }
-FX_BOOL CPDF_CIDFont::LoadGB2312()
+bool CPDF_CIDFont::LoadGB2312()
 {
     m_BaseFont = m_pFontDict->GetString(FX_BSTRC("BaseFont"));
     CPDF_Dictionary* pFontDesc = m_pFontDict->GetDict(FX_BSTRC("FontDescriptor"));
     if (pFontDesc) {
         LoadFontDescriptor(pFontDesc);
     }
     m_Charset = CIDSET_GB1;
-    m_bType1 = FALSE;
+    m_bType1 = false;
     m_pCMap = CPDF_ModuleMgr::Get()->GetPageModule()->GetFontGlobals()->m_CMapManager.GetPredefinedCMap(
-                  FX_BSTRC("GBK-EUC-H"), FALSE);
-    m_pCID2UnicodeMap = CPDF_ModuleMgr::Get()->GetPageModule()->GetFontGlobals()->m_CMapManager.GetCID2UnicodeMap(m_Charset, FALSE);
+                  FX_BSTRC("GBK-EUC-H"), false);
+    m_pCID2UnicodeMap = CPDF_ModuleMgr::Get()->GetPageModule()->GetFontGlobals()->m_CMapManager.GetCID2UnicodeMap(m_Charset, false);
     if (!IsEmbedded()) {
         LoadSubstFont();
     }
     CheckFontMetrics();
     m_DefaultWidth = 1000;
     m_pAnsiWidths = FX_Alloc(FX_WORD, 128);
     for (int i = 32; i < 127; i ++) {
         m_pAnsiWidths[i] = 500;
     }
-    return TRUE;
+    return true;
 }
 const struct _CIDTransform {
     FX_WORD             CID;
     uint8_t             a, b, c, d, e, f;
 }
 Japan1_VertCIDs[] = {
     {97, 129, 0, 0, 127, 55, 0},
     {7887, 127, 0, 0, 127, 76, 89},
     {7888, 127, 0, 0, 127, 79, 94},
     {7889, 0, 129, 127, 0, 17, 127},
@@ skipping 161 matching lines @@
         if (middlecode > CID) {
             end = middle - 1;
         } else if (middlecode < CID) {
             begin = middle + 1;
         } else {
             return &Japan1_VertCIDs[middle].a;
         }
     }
     return NULL;
 }