FX_BOOL considered harmful, part 2.

core/src/fpdfapi/fpdf_page/fpdf_page_parser.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_page.h"
 #include "../../../include/fpdfapi/fpdf_module.h"
 #include "../../../include/fpdfapi/fpdf_serial.h"
 #include "pageint.h"
 
-#define REQUIRE_PARAMS(count) if (m_ParamCount != count) { m_bAbort = TRUE; return; }
+#define REQUIRE_PARAMS(count) if (m_ParamCount != count) { m_bAbort = true; return; }
 
 CPDF_StreamContentParser::CPDF_StreamContentParser(
     CPDF_Document* pDocument,
     CPDF_Dictionary* pPageResources,
     CPDF_Dictionary* pParentResources,
     CFX_AffineMatrix* pmtContentToUser,
     CPDF_PageObjects* pObjList,
     CPDF_Dictionary* pResources,
     CPDF_Rect* pBBox,
     CPDF_ParseOptions* pOptions,
     CPDF_AllStates* pStates,
     int level)
     : m_pDocument(pDocument),
       m_pPageResources(pPageResources),
       m_pParentResources(pParentResources),
       m_pResources(pResources),
       m_pObjectList(pObjList),
       m_Level(level),
       m_ParamStartPos(0),
       m_ParamCount(0),
-      m_bAbort(FALSE),
+      m_bAbort(false),
       m_pCurStates(new CPDF_AllStates),
       m_pLastTextObject(nullptr),
       m_DefFontSize(0),
       m_pPathPoints(nullptr),
       m_PathPointCount(0),
       m_PathAllocSize(0),
       m_PathCurrentX(0.0f),
       m_PathCurrentY(0.0f),
       m_PathClipType(0),
       m_pLastImage(nullptr),
       m_pLastImageDict(nullptr),
       m_pLastCloneImageDict(nullptr),
-      m_bReleaseLastDict(TRUE),
-      m_bColored(FALSE),
-      m_bResourceMissing(FALSE)
+      m_bReleaseLastDict(true),
+      m_bColored(false),
+      m_bResourceMissing(false)
 {
     if (pmtContentToUser) {
         m_mtContentToUser = *pmtContentToUser;
     }
     if (pOptions) {
         m_Options = *pOptions;
     }
     if (!m_pResources) {
         m_pResources = m_pParentResources;
     }
@@ skipping 117 matching lines @@
     }
     if (param.m_Type == PDFOBJ_NAME) {
         CPDF_Name* pName = CPDF_Name::Create(CFX_ByteString(param.m_Name.m_Buffer, param.m_Name.m_Len));
         param.m_Type = 0;
         param.m_pObject = pName;
         return pName;
     }
     if (param.m_Type == 0) {
         return param.m_pObject;
     }
-    ASSERT(FALSE);
+    ASSERT(false);
     return NULL;
 }
 CFX_ByteString CPDF_StreamContentParser::GetString(FX_DWORD index)
 {
     if (index >= m_ParamCount) {
         return CFX_ByteString();
     }
     int real_index = m_ParamStartPos + m_ParamCount - index - 1;
     if (real_index >= PARAM_BUF_SIZE) {
         real_index -= PARAM_BUF_SIZE;
@@ skipping 22 matching lines @@
     }
     if (param.m_Type == 0 && param.m_pObject) {
         return param.m_pObject->GetNumber();
     }
     return 0;
 }
 FX_FLOAT CPDF_StreamContentParser::GetNumber16(FX_DWORD index)
 {
     return GetNumber(index);
 }
-void CPDF_StreamContentParser::SetGraphicStates(CPDF_PageObject* pObj, FX_BOOL bColor, FX_BOOL bText, FX_BOOL bGraph)
+void CPDF_StreamContentParser::SetGraphicStates(CPDF_PageObject* pObj, bool bColor, bool bText, bool bGraph)
 {
     pObj->m_GeneralState = m_pCurStates->m_GeneralState;
     pObj->m_ClipPath = m_pCurStates->m_ClipPath;
     pObj->m_ContentMark = m_CurContentMark;
     if (bColor) {
         pObj->m_ColorState = m_pCurStates->m_ColorState;
     }
     if (bGraph) {
         pObj->m_GraphState = m_pCurStates->m_GraphState;
     }
@@ skipping 71 matching lines @@
     {FXBSTR_ID('r', 'g', 0, 0), &CPDF_StreamContentParser::Handle_SetRGBColor_Fill},
     {FXBSTR_ID('r', 'i', 0, 0), &CPDF_StreamContentParser::Handle_SetRenderIntent},
     {FXBSTR_ID('s', 0, 0, 0),           &CPDF_StreamContentParser::Handle_CloseStrokePath},
     {FXBSTR_ID('s', 'c', 0, 0), &CPDF_StreamContentParser::Handle_SetColor_Fill},
     {FXBSTR_ID('s', 'c', 'n', 0),       &CPDF_StreamContentParser::Handle_SetColorPS_Fill},
     {FXBSTR_ID('s', 'h', 0, 0), &CPDF_StreamContentParser::Handle_ShadeFill},
     {FXBSTR_ID('v', 0, 0, 0),           &CPDF_StreamContentParser::Handle_CurveTo_23},
     {FXBSTR_ID('w', 0, 0, 0),           &CPDF_StreamContentParser::Handle_SetLineWidth},
     {FXBSTR_ID('y', 0, 0, 0),           &CPDF_StreamContentParser::Handle_CurveTo_13},
 };
-FX_BOOL CPDF_StreamContentParser::OnOperator(const FX_CHAR* op)
+bool CPDF_StreamContentParser::OnOperator(const FX_CHAR* op)
 {
     int i = 0;
     FX_DWORD opid = 0;
     while (i < 4 && op[i]) {
         opid = (opid << 8) + op[i];
         i ++;
     }
     while (i < 4) {
         opid <<= 8;
         i ++;
     };
     int low = 0, high = sizeof g_OpCodes / sizeof(OpCode) - 1;
     while (low <= high) {
         int middle = (low + high) / 2;
         int compare = opid - g_OpCodes[middle].m_OpId;
         if (compare == 0) {
             (this->*g_OpCodes[middle].m_OpHandler)();
-            return TRUE;
+            return true;
         }
         if (compare < 0) {
             high = middle - 1;
         } else {
             low = middle + 1;
         }
     }
     return m_CompatCount != 0;
 }
 void CPDF_StreamContentParser::Handle_CloseFillStrokePath()
 {
     if (m_Options.m_bTextOnly) {
         return;
     }
     Handle_ClosePath();
-    AddPathObject(FXFILL_WINDING, TRUE);
+    AddPathObject(FXFILL_WINDING, true);
 }
 void CPDF_StreamContentParser::Handle_FillStrokePath()
 {
     if (m_Options.m_bTextOnly) {
         return;
     }
-    AddPathObject(FXFILL_WINDING, TRUE);
+    AddPathObject(FXFILL_WINDING, true);
 }
 void CPDF_StreamContentParser::Handle_CloseEOFillStrokePath()
 {
     if (m_Options.m_bTextOnly) {
         return;
     }
     AddPathPoint(m_PathStartX, m_PathStartY, FXPT_LINETO | FXPT_CLOSEFIGURE);
-    AddPathObject(FXFILL_ALTERNATE, TRUE);
+    AddPathObject(FXFILL_ALTERNATE, true);
 }
 void CPDF_StreamContentParser::Handle_EOFillStrokePath()
 {
     if (m_Options.m_bTextOnly) {
         return;
     }
-    AddPathObject(FXFILL_ALTERNATE, TRUE);
+    AddPathObject(FXFILL_ALTERNATE, true);
 }
 void CPDF_StreamContentParser::Handle_BeginMarkedContent_Dictionary()
 {
     if (!m_Options.m_bMarkedContent) {
         return;
     }
     CFX_ByteString tag = GetString(1);
     CPDF_Object* pProperty = GetObject(0);
     if (pProperty == NULL) {
         return;
     }
-    FX_BOOL bDirect = TRUE;
+    bool bDirect = true;
     if (pProperty->GetType() == PDFOBJ_NAME) {
         pProperty = FindResourceObj(FX_BSTRC("Properties"), pProperty->GetString());
         if (pProperty == NULL) {
             return;
         }
-        bDirect = FALSE;
+        bDirect = false;
     }
     if (pProperty->GetType() != PDFOBJ_DICTIONARY) {
         return;
     }
     m_CurContentMark.GetModify()->AddMark(tag, (CPDF_Dictionary*)pProperty, bDirect);
 }
 void CPDF_StreamContentParser::Handle_BeginMarkedContent()
 {
     if (!m_Options.m_bMarkedContent) {
         return;
     }
     CFX_ByteString tag = GetString(0);
-    m_CurContentMark.GetModify()->AddMark(tag, NULL, FALSE);
+    m_CurContentMark.GetModify()->AddMark(tag, NULL, false);
 }
 struct _FX_BSTR {
     const FX_CHAR*      m_Ptr;
     int                 m_Size;
 };
 #define _FX_BSTRC(str) {str, sizeof(str)-1}
 const _FX_BSTR _PDF_InlineKeyAbbr[] = {
     _FX_BSTRC("BitsPerComponent"), _FX_BSTRC("BPC"),
     _FX_BSTRC("ColorSpace"), _FX_BSTRC("CS"),
     _FX_BSTRC("Decode"), _FX_BSTRC("D"),
@@ skipping 196 matching lines @@
     CPDF_Array* pArray = GetObject(1) ? GetObject(1)->GetArray() : NULL;
     if (pArray == NULL) {
         return;
     }
     m_pCurStates->SetLineDash(pArray, GetNumber(0), 1.0f);
 }
 void CPDF_StreamContentParser::Handle_SetCharWidth()
 {
     m_Type3Data[0] = GetNumber(1);
     m_Type3Data[1] = GetNumber(0);
-    m_bColored = TRUE;
+    m_bColored = true;
 }
 void CPDF_StreamContentParser::Handle_SetCachedDevice()
 {
     for (int i = 0; i < 6; i ++) {
         m_Type3Data[i] = GetNumber(5 - i);
     }
-    m_bColored = FALSE;
+    m_bColored = false;
 }
 void CPDF_StreamContentParser::Handle_ExecuteXObject()
 {
     CFX_ByteString name = GetString(0);
     if (name == m_LastImageName && m_pLastImage && m_pLastImage->GetStream() && m_pLastImage->GetStream()->GetObjNum()) {
-        AddImage(NULL, m_pLastImage, FALSE);
+        AddImage(NULL, m_pLastImage, false);
         return;
     }
     if (m_Options.m_bTextOnly) {
         CPDF_Object* pRes = NULL;
         if (m_pResources == NULL) {
             return;
         }
         if (m_pResources == m_pPageResources) {
             CPDF_Dictionary* pList = m_pResources->GetDict(FX_BSTRC("XObject"));
             if (pList == NULL) {
@@ skipping 17 matching lines @@
                 if (pRes == NULL || pRes->GetType() != PDFOBJ_REFERENCE) {
                     return;
                 }
             } else {
                 pRes = pList->GetElement(name);
                 if (pRes == NULL || pRes->GetType() != PDFOBJ_REFERENCE) {
                     return;
                 }
             }
         }
-        FX_BOOL bForm;
+        bool bForm;
         if (m_pDocument->IsFormStream(((CPDF_Reference*)pRes)->GetRefObjNum(), bForm) && !bForm) {
             return;
         }
     }
     CPDF_Stream* pXObject = (CPDF_Stream*)FindResourceObj(FX_BSTRC("XObject"), name);
     if (pXObject == NULL || pXObject->GetType() != PDFOBJ_STREAM) {
-        m_bResourceMissing = TRUE;
+        m_bResourceMissing = true;
         return;
     }
     CFX_ByteStringC type = pXObject->GetDict() ? pXObject->GetDict()->GetConstString(FX_BSTRC("Subtype")) : CFX_ByteStringC();
     if (type == FX_BSTRC("Image")) {
         if (m_Options.m_bTextOnly) {
             return;
         }
-        CPDF_ImageObject* pObj = AddImage(pXObject, NULL, FALSE);
+        CPDF_ImageObject* pObj = AddImage(pXObject, NULL, false);
         m_LastImageName = name;
         m_pLastImage = pObj->m_pImage;
     } else if (type == FX_BSTRC("Form")) {
         AddForm(pXObject);
     } else {
         return;
     }
 }
 void CPDF_StreamContentParser::AddForm(CPDF_Stream* pStream)
 {
@@ skipping 10 matching lines @@
             ClipPath.AppendRect(form_bbox.left, form_bbox.bottom, form_bbox.right, form_bbox.top);
             ClipPath.Transform(&form_matrix);
             form_bbox.Transform(&form_matrix);
         }
         CPDF_StreamContentParser parser(
             m_pDocument, m_pPageResources, m_pResources, &m_mtContentToUser,
             m_pObjectList, pResources, &form_bbox, &m_Options,
             m_pCurStates.get(), m_Level + 1);
         parser.m_pCurStates->m_CTM = form_matrix;
         if (ClipPath.NotNull()) {
-            parser.m_pCurStates->m_ClipPath.AppendPath(ClipPath, FXFILL_WINDING, TRUE);
+            parser.m_pCurStates->m_ClipPath.AppendPath(ClipPath, FXFILL_WINDING, true);
         }
         CPDF_StreamAcc stream;
-        stream.LoadAllData(pStream, FALSE);
+        stream.LoadAllData(pStream, false);
         if (stream.GetSize() == 0) {
             return;
         }
         parser.Parse(stream.GetData(), stream.GetSize(), 0);
         return;
     }
     CPDF_FormObject* pFormObj = new CPDF_FormObject;
     pFormObj->m_pForm = new CPDF_Form(m_pDocument, m_pPageResources, pStream, m_pResources);
     pFormObj->m_FormMatrix = m_pCurStates->m_CTM;
     pFormObj->m_FormMatrix.Concat(m_mtContentToUser);
     CPDF_AllStates status;
     status.m_GeneralState = m_pCurStates->m_GeneralState;
     status.m_GraphState = m_pCurStates->m_GraphState;
     status.m_ColorState = m_pCurStates->m_ColorState;
     status.m_TextState = m_pCurStates->m_TextState;
     pFormObj->m_pForm->ParseContent(&status, NULL, NULL, &m_Options, m_Level + 1);
     if (!m_pObjectList->m_bBackgroundAlphaNeeded && pFormObj->m_pForm->m_bBackgroundAlphaNeeded) {
-        m_pObjectList->m_bBackgroundAlphaNeeded = TRUE;
+        m_pObjectList->m_bBackgroundAlphaNeeded = true;
     }
     pFormObj->CalcBoundingBox();
-    SetGraphicStates(pFormObj, TRUE, TRUE, TRUE);
+    SetGraphicStates(pFormObj, true, true, true);
     m_pObjectList->m_ObjectList.AddTail(pFormObj);
 }
-CPDF_ImageObject* CPDF_StreamContentParser::AddImage(CPDF_Stream* pStream, CPDF_Image* pImage, FX_BOOL bInline)
+CPDF_ImageObject* CPDF_StreamContentParser::AddImage(CPDF_Stream* pStream, CPDF_Image* pImage, bool bInline)
 {
     if (pStream == NULL && pImage == NULL) {
         return NULL;
     }
     CFX_AffineMatrix ImageMatrix;
     ImageMatrix.Copy(m_pCurStates->m_CTM);
     ImageMatrix.Concat(m_mtContentToUser);
     CPDF_ImageObject* pImageObj = new CPDF_ImageObject;
     if (pImage) {
         pImageObj->m_pImage = m_pDocument->GetPageData()->GetImage(pImage->GetStream());
     } else if (pStream->GetObjNum()) {
         pImageObj->m_pImage = m_pDocument->LoadImageF(pStream);
     } else {
         pImageObj->m_pImage = new CPDF_Image(m_pDocument);
         pImageObj->m_pImage->LoadImageF(pStream, bInline);
     }
-    SetGraphicStates(pImageObj, pImageObj->m_pImage->IsMask(), FALSE, FALSE);
+    SetGraphicStates(pImageObj, pImageObj->m_pImage->IsMask(), false, false);
     pImageObj->m_Matrix = ImageMatrix;
     pImageObj->CalcBoundingBox();
     m_pObjectList->m_ObjectList.AddTail(pImageObj);
     return pImageObj;
 }
 void CPDF_StreamContentParser::Handle_MarkPlace_Dictionary()
 {
 }
 void CPDF_StreamContentParser::Handle_EndImage()
 {
@@ skipping 33 matching lines @@
 {
     if (m_CompatCount) {
         m_CompatCount --;
     }
 }
 void CPDF_StreamContentParser::Handle_FillPath()
 {
     if (m_Options.m_bTextOnly) {
         return;
     }
-    AddPathObject(FXFILL_WINDING, FALSE);
+    AddPathObject(FXFILL_WINDING, false);
 }
 void CPDF_StreamContentParser::Handle_FillPathOld()
 {
     if (m_Options.m_bTextOnly) {
         return;
     }
-    AddPathObject(FXFILL_WINDING, FALSE);
+    AddPathObject(FXFILL_WINDING, false);
 }
 void CPDF_StreamContentParser::Handle_EOFillPath()
 {
     if (m_Options.m_bTextOnly) {
         return;
     }
-    AddPathObject(FXFILL_ALTERNATE, FALSE);
+    AddPathObject(FXFILL_ALTERNATE, false);
 }
 void CPDF_StreamContentParser::Handle_SetGray_Fill()
 {
     FX_FLOAT value = GetNumber(0);
     CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
     m_pCurStates->m_ColorState.SetFillColor(pCS, &value, 1);
 }
 void CPDF_StreamContentParser::Handle_SetGray_Stroke()
 {
     FX_FLOAT value = GetNumber(0);
     CPDF_ColorSpace* pCS = CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
     m_pCurStates->m_ColorState.SetStrokeColor(pCS, &value, 1);
 }
 void CPDF_StreamContentParser::Handle_SetExtendGraphState()
 {
     CFX_ByteString name = GetString(0);
     CPDF_Dictionary* pGS = (CPDF_Dictionary*)FindResourceObj(FX_BSTRC("ExtGState"), name);
     if (pGS == NULL || pGS->GetType() != PDFOBJ_DICTIONARY) {
-        m_bResourceMissing = TRUE;
+        m_bResourceMissing = true;
         return;
     }
     m_pCurStates->ProcessExtGS(pGS, this);
 }
 void CPDF_StreamContentParser::Handle_ClosePath()
 {
     if (m_Options.m_bTextOnly) {
         return;
     }
     if (m_PathPointCount == 0) {
@@ skipping 63 matching lines @@
     m_pCurStates->m_GraphState.GetModify()->m_MiterLimit = GetNumber(0);
 }
 void CPDF_StreamContentParser::Handle_MarkPlace()
 {
 }
 void CPDF_StreamContentParser::Handle_EndPath()
 {
     if (m_Options.m_bTextOnly) {
         return;
     }
-    AddPathObject(0, FALSE);
+    AddPathObject(0, false);
 }
 void CPDF_StreamContentParser::Handle_SaveGraphState()
 {
     CPDF_AllStates* pStates = new CPDF_AllStates;
     pStates->Copy(*m_pCurStates);
     m_StateStack.Add(pStates);
 }
 void CPDF_StreamContentParser::Handle_RestoreGraphState()
 {
     int size = m_StateStack.GetSize();
@@ skipping 44 matching lines @@
 }
 void CPDF_StreamContentParser::Handle_SetRenderIntent()
 {
 }
 void CPDF_StreamContentParser::Handle_CloseStrokePath()
 {
     if (m_Options.m_bTextOnly) {
         return;
     }
     Handle_ClosePath();
-    AddPathObject(0, TRUE);
+    AddPathObject(0, true);
 }
 void CPDF_StreamContentParser::Handle_StrokePath()
 {
     if (m_Options.m_bTextOnly) {
         return;
     }
-    AddPathObject(0, TRUE);
+    AddPathObject(0, true);
 }
 void CPDF_StreamContentParser::Handle_SetColor_Fill()
 {
     if (m_Options.m_bTextOnly) {
         return;
     }
     FX_FLOAT values[4];
     int nargs = m_ParamCount;
     if (nargs > 4) {
         nargs = 4;
@@ skipping 33 matching lines @@
         nvalues --;
     }
     FX_FLOAT* values = NULL;
     if (nvalues) {
         values = FX_Alloc(FX_FLOAT, nvalues);
         for (int i = 0; i < nvalues; i ++) {
             values[i] = GetNumber(nargs - i - 1);
         }
     }
     if (nvalues != nargs) {
-        CPDF_Pattern* pPattern = FindPattern(GetString(0), FALSE);
+        CPDF_Pattern* pPattern = FindPattern(GetString(0), false);
         if (pPattern) {
             m_pCurStates->m_ColorState.SetFillPattern(pPattern, values, nvalues);
         }
     } else {
         m_pCurStates->m_ColorState.SetFillColor(NULL, values, nvalues);
     }
     if (values) {
         FX_Free(values);
     }
 }
@@ skipping 12 matching lines @@
         nvalues --;
     }
     FX_FLOAT* values = NULL;
     if (nvalues) {
         values = FX_Alloc(FX_FLOAT, nvalues);
         for (int i = 0; i < nvalues; i ++) {
             values[i] = GetNumber(nargs - i - 1);
         }
     }
     if (nvalues != nargs) {
-        CPDF_Pattern* pPattern = FindPattern(GetString(0), FALSE);
+        CPDF_Pattern* pPattern = FindPattern(GetString(0), false);
         if (pPattern) {
             m_pCurStates->m_ColorState.SetStrokePattern(pPattern, values, nvalues);
         }
     } else {
         m_pCurStates->m_ColorState.SetStrokeColor(NULL, values, nvalues);
     }
     if (values) {
         FX_Free(values);
     }
 }
 CFX_FloatRect _GetShadingBBox(CPDF_Stream* pStream, int type, const CFX_AffineMatrix* pMatrix,
                               CPDF_Function** pFuncs, int nFuncs, CPDF_ColorSpace* pCS);
 void CPDF_StreamContentParser::Handle_ShadeFill()
 {
     if (m_Options.m_bTextOnly) {
         return;
     }
-    CPDF_Pattern* pPattern = FindPattern(GetString(0), TRUE);
+    CPDF_Pattern* pPattern = FindPattern(GetString(0), true);
     if (pPattern == NULL) {
         return;
     }
     if (pPattern->m_PatternType != PATTERN_SHADING) {
         return;
     }
     CPDF_ShadingPattern* pShading = (CPDF_ShadingPattern*)pPattern;
     if (!pShading->m_bShadingObj) {
         return;
     }
     if (!pShading->Load()) {
         return;
     }
     CPDF_ShadingObject* pObj = new CPDF_ShadingObject;
     pObj->m_pShading = pShading;
-    SetGraphicStates(pObj, FALSE, FALSE, FALSE);
+    SetGraphicStates(pObj, false, false, false);
     pObj->m_Matrix = m_pCurStates->m_CTM;
     pObj->m_Matrix.Concat(m_mtContentToUser);
     CFX_FloatRect bbox;
     if (!pObj->m_ClipPath.IsNull()) {
         bbox = pObj->m_ClipPath.GetClipBox();
     } else {
         bbox = m_BBox;
     }
     if (pShading->m_ShadingType >= 4) {
         bbox.Intersect(_GetShadingBBox((CPDF_Stream*)pShading->m_pShadingObj, pShading->m_ShadingType, &pObj->m_Matrix,
@@ skipping 58 matching lines @@
         CPDF_Object* pRes = pList->GetElementValue(name);
         return pRes;
     }
     CPDF_Object* pRes = pList->GetElementValue(name);
     return pRes;
 }
 CPDF_Font* CPDF_StreamContentParser::FindFont(const CFX_ByteString& name)
 {
     CPDF_Dictionary* pFontDict = (CPDF_Dictionary*)FindResourceObj(FX_BSTRC("Font"), name);
     if (pFontDict == NULL || pFontDict->GetType() != PDFOBJ_DICTIONARY) {
-        m_bResourceMissing = TRUE;
+        m_bResourceMissing = true;
         return CPDF_Font::GetStockFont(m_pDocument, FX_BSTRC("Helvetica"));
     }
     CPDF_Font* pFont = m_pDocument->LoadFont(pFontDict);
     if (pFont && pFont->GetType3Font()) {
         pFont->GetType3Font()->SetPageResources(m_pResources);
         pFont->GetType3Font()->CheckType3FontMetrics();
     }
     return pFont;
 }
 CPDF_ColorSpace* CPDF_StreamContentParser::FindColorSpace(const CFX_ByteString& name)
@@ skipping 11 matching lines @@
             }
             if (name == FX_BSTRC("DeviceRGB")) {
                 return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
             }
             return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
         }
         return m_pDocument->LoadColorSpace(pDefObj);
     }
     CPDF_Object* pCSObj = FindResourceObj(FX_BSTRC("ColorSpace"), name);
     if (pCSObj == NULL) {
-        m_bResourceMissing = TRUE;
+        m_bResourceMissing = true;
         return NULL;
     }
     return m_pDocument->LoadColorSpace(pCSObj);
 }
-CPDF_Pattern* CPDF_StreamContentParser::FindPattern(const CFX_ByteString& name, FX_BOOL bShading)
+CPDF_Pattern* CPDF_StreamContentParser::FindPattern(const CFX_ByteString& name, bool bShading)
 {
     CPDF_Object* pPattern = FindResourceObj(bShading ? FX_BSTRC("Shading") : FX_BSTRC("Pattern"), name);
     if (pPattern == NULL || (pPattern->GetType() != PDFOBJ_DICTIONARY &&
                              pPattern->GetType() != PDFOBJ_STREAM)) {
-        m_bResourceMissing = TRUE;
+        m_bResourceMissing = true;
         return NULL;
     }
     return m_pDocument->LoadPattern(pPattern, bShading, &m_pCurStates->m_ParentMatrix);
 }
 void CPDF_StreamContentParser::ConvertTextSpace(FX_FLOAT& x, FX_FLOAT& y)
 {
     m_pCurStates->m_TextMatrix.Transform(x, y, x, y);
     ConvertUserSpace(x, y);
 }
 void CPDF_StreamContentParser::ConvertUserSpace(FX_FLOAT& x, FX_FLOAT& y)
@@ skipping 18 matching lines @@
         return;
     }
     int textmode;
     if (pFont->GetFontType() == PDFFONT_TYPE3) {
         textmode = 0;
     } else {
         textmode = m_pCurStates->m_TextState.GetObject()->m_TextMode;
     }
     CPDF_TextObject* pText = new CPDF_TextObject;
     m_pLastTextObject = pText;
-    SetGraphicStates(pText, TRUE, TRUE, TRUE);
+    SetGraphicStates(pText, true, true, true);
     if (textmode && textmode != 3 && textmode != 4 && textmode != 7) {
         FX_FLOAT* pCTM = pText->m_TextState.GetModify()->m_CTM;
         pCTM[0] = m_pCurStates->m_CTM.a;
         pCTM[1] = m_pCurStates->m_CTM.c;
         pCTM[2] = m_pCurStates->m_CTM.b;
         pCTM[3] = m_pCurStates->m_CTM.d;
     }
     pText->SetSegments(pStrs, pKerning, nsegs);
     pText->m_PosX = m_pCurStates->m_TextX;
     pText->m_PosY = m_pCurStates->m_TextY + m_pCurStates->m_TextRise;
@@ skipping 193 matching lines @@
             FXSYS_memcpy(pNewPoints, m_pPathPoints, m_PathAllocSize * sizeof(FX_PATHPOINT));
             FX_Free(m_pPathPoints);
         }
         m_pPathPoints = pNewPoints;
         m_PathAllocSize = newsize;
     }
     m_pPathPoints[m_PathPointCount - 1].m_Flag = flag;
     m_pPathPoints[m_PathPointCount - 1].m_PointX = x;
     m_pPathPoints[m_PathPointCount - 1].m_PointY = y;
 }
-void CPDF_StreamContentParser::AddPathObject(int FillType, FX_BOOL bStroke)
+void CPDF_StreamContentParser::AddPathObject(int FillType, bool bStroke)
 {
     int PathPointCount = m_PathPointCount, PathClipType = m_PathClipType;
     m_PathPointCount = 0;
     m_PathClipType = 0;
     if (PathPointCount <= 1) {
         if (PathPointCount && PathClipType) {
             CPDF_Path path;
             path.New()->AppendRect(0, 0, 0, 0);
-            m_pCurStates->m_ClipPath.AppendPath(path, FXFILL_WINDING, TRUE);
+            m_pCurStates->m_ClipPath.AppendPath(path, FXFILL_WINDING, true);
         }
         return;
     }
     if (PathPointCount && m_pPathPoints[PathPointCount - 1].m_Flag == FXPT_MOVETO) {
         PathPointCount --;
     }
     CPDF_Path Path;
     CFX_PathData* pPathData = Path.New();
     pPathData->SetPointCount(PathPointCount);
     FXSYS_memcpy(pPathData->GetPoints(), m_pPathPoints, sizeof(FX_PATHPOINT) * PathPointCount);
     CFX_AffineMatrix matrix = m_pCurStates->m_CTM;
     matrix.Concat(m_mtContentToUser);
     if (bStroke || FillType) {
         CPDF_PathObject* pPathObj = new CPDF_PathObject;
         pPathObj->m_bStroke = bStroke;
         pPathObj->m_FillType = FillType;
         pPathObj->m_Path = Path;
         pPathObj->m_Matrix = matrix;
-        SetGraphicStates(pPathObj, TRUE, FALSE, TRUE);
+        SetGraphicStates(pPathObj, true, false, true);
         pPathObj->CalcBoundingBox();
         m_pObjectList->m_ObjectList.AddTail(pPathObj);
     }
     if (PathClipType) {
         if (!matrix.IsIdentity()) {
             Path.Transform(&matrix);
             matrix.SetIdentity();
         }
-        m_pCurStates->m_ClipPath.AppendPath(Path, PathClipType, TRUE);
+        m_pCurStates->m_ClipPath.AppendPath(Path, PathClipType, true);
     }
 }
 CFX_ByteString _FPDF_ByteStringFromHex(CFX_BinaryBuf& src_buf)
 {
     CFX_ByteTextBuf buf;
-    FX_BOOL bFirst = TRUE;
+    bool bFirst = true;
     int code = 0;
     const uint8_t* str = src_buf.GetBuffer();
     FX_DWORD size = src_buf.GetSize();
     for (FX_DWORD i = 0; i < size; i ++) {
         uint8_t ch = str[i];
         if (ch >= '0' && ch <= '9') {
             if (bFirst) {
                 code = (ch - '0') * 16;
             } else {
                 code += ch - '0';
@@ skipping 16 matching lines @@
                 buf.AppendChar((char)code);
             }
             bFirst = !bFirst;
         }
     }
     if (!bFirst) {
         buf.AppendChar((char)code);
     }
     return buf.GetByteString();
 }