Revert "FX_BOOL considered harmful, part 2."

core/src/fpdfapi/fpdf_page/fpdf_page_parser_old.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/fxcodec/fx_codec.h"
 #include "pageint.h"
 #include <limits.h>
 const FX_CHAR* const _PDF_OpCharType =
     "IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII"
     "IIVIIIIVIIVIIIIIVVIIIIIIIIIIIIII"
     "IIVVVVVVIVVVVVVIVVVVVIIVVIIIIIII"
     "IIVVVVVVVVVVVVVVIVVVIIVVIVVIIIII"
     "IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII"
     "IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII"
     "IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII"
     "IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII";
-bool _PDF_HasInvalidOpChar(const FX_CHAR* op)
+FX_BOOL _PDF_HasInvalidOpChar(const FX_CHAR* op)
 {
     if(!op) {
-        return false;
+        return FALSE;
     }
     uint8_t ch;
     while((ch = *op++)) {
         if(_PDF_OpCharType[ch] == 'I') {
-            return true;
+            return TRUE;
         }
     }
-    return false;
+    return FALSE;
 }
 class CPDF_StreamParserAutoClearer {
   public:
     CPDF_StreamParserAutoClearer(CPDF_StreamParser** scoped_variable, CPDF_StreamParser* new_parser)
             : scoped_variable_(scoped_variable) {
         *scoped_variable_ = new_parser;
     }
     ~CPDF_StreamParserAutoClearer() { *scoped_variable_ = NULL; }
   private:
     CPDF_StreamParser** scoped_variable_;
@@ skipping 10 matching lines @@
     while (1) {
         FX_DWORD cost = m_pObjectList->CountObjects() - InitObjCount;
         if (max_cost && cost >= max_cost) {
             break;
         }
         switch (syntax.ParseNextElement()) {
             case CPDF_StreamParser::EndOfData:
                 return m_pSyntax->GetPos();
             case CPDF_StreamParser::Keyword:
                 if(!OnOperator((char*)syntax.GetWordBuf()) && _PDF_HasInvalidOpChar((char*)syntax.GetWordBuf())) {
-                    m_bAbort = true;
+                    m_bAbort = TRUE;
                 }
                 if (m_bAbort) {
                     return m_pSyntax->GetPos();
                 }
                 ClearAllParams();
                 break;
             case CPDF_StreamParser::Number:
                 AddNumberParam((char*)syntax.GetWordBuf(), syntax.GetWordSize());
                 break;
             case CPDF_StreamParser::Name:
@@ skipping 62 matching lines @@
     }
     if (m_Options.m_bTextOnly) {
         if (pStream) {
             pStream->Release();
         } else {
             pDict->Release();
         }
         return;
     }
     pDict->SetAtName(FX_BSTRC("Subtype"), FX_BSTRC("Image"));
-    CPDF_ImageObject *pImgObj = AddImage(pStream, NULL, true);
+    CPDF_ImageObject *pImgObj = AddImage(pStream, NULL, TRUE);
     if (!pImgObj) {
         if (pStream) {
             pStream->Release();
         } else {
             pDict->Release();
         }
     }
 }
 void CPDF_StreamContentParser::ParsePathObject()
 {
     FX_FLOAT params[6] = {};
     int nParams = 0;
     int last_pos = m_pSyntax->GetPos();
     while (1) {
         CPDF_StreamParser::SyntaxType type = m_pSyntax->ParseNextElement();
-        bool bProcessed = true;
+        FX_BOOL bProcessed = TRUE;
         switch (type) {
             case CPDF_StreamParser::EndOfData:
                 return;
             case CPDF_StreamParser::Keyword: {
                     int len = m_pSyntax->GetWordSize();
                     if (len == 1) {
                         switch (m_pSyntax->GetWordBuf()[0]) {
                             case 'm':
                                 AddPathPoint(params[0], params[1], FXPT_MOVETO);
                                 nParams = 0;
@@ skipping 18 matching lines @@
                                 AddPathPoint(params[0], params[1], FXPT_BEZIERTO);
                                 AddPathPoint(params[2], params[3], FXPT_BEZIERTO);
                                 AddPathPoint(params[2], params[3], FXPT_BEZIERTO);
                                 nParams = 0;
                                 break;
                             case 'h':
                                 Handle_ClosePath();
                                 nParams = 0;
                                 break;
                             default:
-                                bProcessed = false;
+                                bProcessed = FALSE;
                                 break;
                         }
                     } else if (len == 2) {
                         if (m_pSyntax->GetWordBuf()[0] == 'r' && m_pSyntax->GetWordBuf()[1] == 'e') {
                             AddPathRect(params[0], params[1], params[2], params[3]);
                             nParams = 0;
                         } else {
-                            bProcessed = false;
+                            bProcessed = FALSE;
                         }
                     } else {
-                        bProcessed = false;
+                        bProcessed = FALSE;
                     }
                     if (bProcessed) {
                         last_pos = m_pSyntax->GetPos();
                     }
                     break;
                 }
             case CPDF_StreamParser::Number: {
                     if (nParams == 6) {
                         break;
                     }
-                    bool bInteger;
+                    FX_BOOL bInteger;
                     int value;
                     FX_atonum(CFX_ByteStringC(m_pSyntax->GetWordBuf(), m_pSyntax->GetWordSize()), bInteger, &value);
                     params[nParams++] = bInteger ? (FX_FLOAT)value : *(FX_FLOAT*)&value;
                     break;
                 }
             default:
-                bProcessed = false;
+                bProcessed = FALSE;
         }
         if (!bProcessed) {
             m_pSyntax->SetPos(last_pos);
             return;
         }
     }
 }
 CPDF_StreamParser::CPDF_StreamParser(const uint8_t* pData, FX_DWORD dwSize)
 {
     m_pBuf = pData;
@@ skipping 31 matching lines @@
         FXSYS_memcpy(dest_buf + row * pitch, pLine, pitch);
     }
     FX_DWORD srcoff = pDecoder->GetSrcOffset();
     delete pDecoder;
     return srcoff;
 }
 ICodec_ScanlineDecoder* FPDFAPI_CreateFaxDecoder(const uint8_t* src_buf, FX_DWORD src_size, int width, int height,
         const CPDF_Dictionary* pParams);
 FX_DWORD _A85Decode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf, FX_DWORD& dest_size);
 FX_DWORD _HexDecode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf, FX_DWORD& dest_size);
-FX_DWORD FPDFAPI_FlateOrLZWDecode(bool bLZW, const uint8_t* src_buf, FX_DWORD src_size, CPDF_Dictionary* pParams,
+FX_DWORD FPDFAPI_FlateOrLZWDecode(FX_BOOL bLZW, const uint8_t* src_buf, FX_DWORD src_size, CPDF_Dictionary* pParams,
                                   FX_DWORD estimated_size, uint8_t*& dest_buf, FX_DWORD& dest_size);
 FX_DWORD PDF_DecodeInlineStream(const uint8_t* src_buf, FX_DWORD limit,
                                 int width, int height, CFX_ByteString& decoder,
                                 CPDF_Dictionary* pParam, uint8_t*& dest_buf, FX_DWORD& dest_size)
 {
     if (decoder == FX_BSTRC("CCITTFaxDecode") || decoder == FX_BSTRC("CCF")) {
         ICodec_ScanlineDecoder* pDecoder = FPDFAPI_CreateFaxDecoder(src_buf, limit, width, height, pParam);
         return _DecodeAllScanlines(pDecoder, dest_buf, dest_size);
     }
     if (decoder == FX_BSTRC("ASCII85Decode") || decoder == FX_BSTRC("A85")) {
         return _A85Decode(src_buf, limit, dest_buf, dest_size);
     }
     if (decoder == FX_BSTRC("ASCIIHexDecode") || decoder == FX_BSTRC("AHx")) {
         return _HexDecode(src_buf, limit, dest_buf, dest_size);
     }
     if (decoder == FX_BSTRC("FlateDecode") || decoder == FX_BSTRC("Fl")) {
-        return FPDFAPI_FlateOrLZWDecode(false, src_buf, limit, pParam, dest_size, dest_buf, dest_size);
+        return FPDFAPI_FlateOrLZWDecode(FALSE, src_buf, limit, pParam, dest_size, dest_buf, dest_size);
     }
     if (decoder == FX_BSTRC("LZWDecode") || decoder == FX_BSTRC("LZW")) {
-        return FPDFAPI_FlateOrLZWDecode(true, src_buf, limit, pParam, 0, dest_buf, dest_size);
+        return FPDFAPI_FlateOrLZWDecode(TRUE, src_buf, limit, pParam, 0, dest_buf, dest_size);
     }
     if (decoder == FX_BSTRC("DCTDecode") || decoder == FX_BSTRC("DCT")) {
         ICodec_ScanlineDecoder* pDecoder = CPDF_ModuleMgr::Get()->GetJpegModule()->CreateDecoder(
             src_buf, limit, width, height, 0, pParam ? pParam->GetInteger(FX_BSTRC("ColorTransform"), 1) : 1);
         return _DecodeAllScanlines(pDecoder, dest_buf, dest_size);
     }
     if (decoder == FX_BSTRC("RunLengthDecode") || decoder == FX_BSTRC("RL")) {
         return RunLengthDecode(src_buf, limit, dest_buf, dest_size);
     }
     dest_size = 0;
     dest_buf = 0;
     return (FX_DWORD) - 1;
 }
-CPDF_Stream* CPDF_StreamParser::ReadInlineStream(CPDF_Document* pDoc, CPDF_Dictionary* pDict, CPDF_Object* pCSObj, bool bDecode)
+CPDF_Stream* CPDF_StreamParser::ReadInlineStream(CPDF_Document* pDoc, CPDF_Dictionary* pDict, CPDF_Object* pCSObj, FX_BOOL bDecode)
 {
     if (m_Pos == m_Size) {
         return NULL;
     }
     if (PDF_CharType[m_pBuf[m_Pos]] == 'W') {
         m_Pos ++;
     }
     CFX_ByteString Decoder;
     CPDF_Dictionary* pParam = NULL;
     CPDF_Object* pFilter = pDict->GetElementValue(FX_BSTRC("Filter"));
@@ skipping 113 matching lines @@
 #define FXDWORD_TRUE FXDWORD_FROM_LSBFIRST(0x65757274)
 #define FXDWORD_NULL FXDWORD_FROM_LSBFIRST(0x6c6c756e)
 #define FXDWORD_FALS FXDWORD_FROM_LSBFIRST(0x736c6166)
 CPDF_StreamParser::SyntaxType CPDF_StreamParser::ParseNextElement()
 {
     if (m_pLastObj) {
         m_pLastObj->Release();
         m_pLastObj = NULL;
     }
     m_WordSize = 0;
-    bool bIsNumber = true;
+    FX_BOOL bIsNumber = TRUE;
     if (m_Pos >= m_Size) {
         return EndOfData;
     }
     int ch = m_pBuf[m_Pos++];
     int type = PDF_CharType[ch];
     while (1) {
         while (type == 'W') {
             if (m_Size <= m_Pos) {
                 return EndOfData;
             }
@@ skipping 17 matching lines @@
     if (type == 'D' && ch != '/') {
         m_Pos --;
         m_pLastObj = ReadNextObject();
         return Others;
     }
     while (1) {
         if (m_WordSize < MAX_WORD_BUFFER) {
             m_WordBuffer[m_WordSize++] = ch;
         }
         if (type != 'N') {
-            bIsNumber = false;
+            bIsNumber = FALSE;
         }
         if (m_Size <= m_Pos) {
             break;
         }
         ch = m_pBuf[m_Pos++];
         type = PDF_CharType[ch];
         if (type == 'D' || type == 'W') {
             m_Pos --;
             break;
         }
     }
     m_WordBuffer[m_WordSize] = 0;
     if (bIsNumber) {
         return Number;
     }
     if (m_WordBuffer[0] == '/') {
         return Name;
     }
     if (m_WordSize == 4) {
         if (*(FX_DWORD*)m_WordBuffer == FXDWORD_TRUE) {
-            m_pLastObj = CPDF_Boolean::Create(true);
+            m_pLastObj = CPDF_Boolean::Create(TRUE);
             return Others;
         }
         if (*(FX_DWORD*)m_WordBuffer == FXDWORD_NULL) {
             m_pLastObj = CPDF_Null::Create();
             return Others;
         }
     } else if (m_WordSize == 5) {
         if (*(FX_DWORD*)m_WordBuffer == FXDWORD_FALS && m_WordBuffer[4] == 'e') {
-            m_pLastObj = CPDF_Boolean::Create(false);
+            m_pLastObj = CPDF_Boolean::Create(FALSE);
             return Others;
         }
     }
     return Keyword;
 }
 void CPDF_StreamParser::SkipPathObject()
 {
     FX_DWORD command_startpos = m_Pos;
     if (m_Pos >= m_Size) {
         return;
@@ skipping 48 matching lines @@
                 if (m_pBuf[op_startpos] == 'r' && m_pBuf[op_startpos + 1] == 'e') {
                     command_startpos = m_Pos;
                     break;
                 }
             }
             m_Pos = command_startpos;
             return;
         }
     }
 }
-CPDF_Object* CPDF_StreamParser::ReadNextObject(bool bAllowNestedArray, bool bInArray)
+CPDF_Object* CPDF_StreamParser::ReadNextObject(FX_BOOL bAllowNestedArray, FX_BOOL bInArray)
 {
-    bool bIsNumber;
+    FX_BOOL bIsNumber;
     GetNextWord(bIsNumber);
     if (m_WordSize == 0) {
         return NULL;
     }
     if (bIsNumber) {
         m_WordBuffer[m_WordSize] = 0;
         return CPDF_Number::Create(CFX_ByteStringC(m_WordBuffer, m_WordSize));
     }
     int first_char = m_WordBuffer[0];
     if (first_char == '/') {
         return CPDF_Name::Create(PDF_NameDecode(CFX_ByteStringC(m_WordBuffer + 1, m_WordSize - 1)));
     }
     if (first_char == '(') {
         return CPDF_String::Create(ReadString());
     }
     if (first_char == '<') {
         if (m_WordSize == 1) {
-            return CPDF_String::Create(ReadHexString(), true);
+            return CPDF_String::Create(ReadHexString(), TRUE);
         }
         CPDF_Dictionary* pDict = CPDF_Dictionary::Create();
         while (1) {
             GetNextWord(bIsNumber);
             if (m_WordSize == 0) {
                 pDict->Release();
                 return NULL;
             }
             if (m_WordSize == 2 && m_WordBuffer[0] == '>') {
                 break;
             }
             if (m_WordBuffer[0] != '/') {
                 pDict->Release();
                 return NULL;
             }
             CFX_ByteString key = PDF_NameDecode(CFX_ByteStringC(m_WordBuffer + 1, m_WordSize - 1));
-            CPDF_Object* pObj = ReadNextObject(true);
+            CPDF_Object* pObj = ReadNextObject(TRUE);
             if (pObj == NULL) {
                 if (pDict) {
                     pDict->Release();
                 }
                 return NULL;
             }
             if (!key.IsEmpty()) {
                 pDict->SetAt(key, pObj);
             } else {
                 pObj->Release();
             }
         }
         return pDict;
     }
     if (first_char == '[') {
         if (!bAllowNestedArray && bInArray) {
             return NULL;
         }
         CPDF_Array* pArray = CPDF_Array::Create();
         while (1) {
-            CPDF_Object* pObj = ReadNextObject(bAllowNestedArray, true);
+            CPDF_Object* pObj = ReadNextObject(bAllowNestedArray, TRUE);
             if (pObj == NULL) {
                 if (m_WordSize == 0 || m_WordBuffer[0] == ']') {
                     return pArray;
                 }
                 if (m_WordBuffer[0] == '[') {
                     continue;
                 }
             } else {
                 pArray->Add(pObj);
             }
         }
     }
     if (m_WordSize == 4) {
         if (*(FX_DWORD*)m_WordBuffer == FXDWORD_TRUE) {
-            return CPDF_Boolean::Create(true);
+            return CPDF_Boolean::Create(TRUE);
         }
         if (*(FX_DWORD*)m_WordBuffer == FXDWORD_NULL) {
             return CPDF_Null::Create();
         }
     } else if (m_WordSize == 5) {
         if (*(FX_DWORD*)m_WordBuffer == FXDWORD_FALS && m_WordBuffer[4] == 'e') {
-            return CPDF_Boolean::Create(false);
+            return CPDF_Boolean::Create(FALSE);
         }
     }
     return NULL;
 }
-void CPDF_StreamParser::GetNextWord(bool& bIsNumber)
+void CPDF_StreamParser::GetNextWord(FX_BOOL& bIsNumber)
 {
     m_WordSize = 0;
-    bIsNumber = true;
+    bIsNumber = TRUE;
     if (m_Size <= m_Pos) {
         return;
     }
     int ch = m_pBuf[m_Pos++];
     int type = PDF_CharType[ch];
     while (1) {
         while (type == 'W') {
             if (m_Size <= m_Pos) {
                 return;
             }
             ch = m_pBuf[m_Pos++];
             type = PDF_CharType[ch];
         }
         if (ch != '%') {
             break;
         }
         while (1) {
             if (m_Size <= m_Pos) {
                 return;
             }
             ch = m_pBuf[m_Pos++];
             if (ch == '\r' || ch == '\n') {
                 break;
             }
         }
         type = PDF_CharType[ch];
     }
     if (type == 'D') {
-        bIsNumber = false;
+        bIsNumber = FALSE;
         m_WordBuffer[m_WordSize++] = ch;
         if (ch == '/') {
             while (1) {
                 if (m_Size <= m_Pos) {
                     return;
                 }
                 ch = m_pBuf[m_Pos++];
                 type = PDF_CharType[ch];
                 if (type != 'R' && type != 'N') {
                     m_Pos --;
@@ skipping 24 matching lines @@
                 m_Pos --;
             }
         }
         return;
     }
     while (1) {
         if (m_WordSize < MAX_WORD_BUFFER) {
             m_WordBuffer[m_WordSize++] = ch;
         }
         if (type != 'N') {
-            bIsNumber = false;
+            bIsNumber = FALSE;
         }
         if (m_Size <= m_Pos) {
             return;
         }
         ch = m_pBuf[m_Pos++];
         type = PDF_CharType[ch];
         if (type == 'D' || type == 'W') {
             m_Pos --;
             break;
         }
@@ skipping 95 matching lines @@
     }
     return buf.GetByteString();
 }
 CFX_ByteString CPDF_StreamParser::ReadHexString()
 {
     if (m_Size <= m_Pos) {
         return CFX_ByteString();
     }
     int ch = m_pBuf[m_Pos++];
     CFX_ByteTextBuf buf;
-    bool bFirst = true;
+    FX_BOOL bFirst = TRUE;
     int code = 0;
     while (1) {
         if (ch == '>') {
             break;
         }
         if (ch >= '0' && ch <= '9') {
             if (bFirst) {
                 code = (ch - '0') * 16;
             } else {
                 code += ch - '0';
@@ skipping 64 matching lines @@
     m_pData = NULL;
     m_Status = Ready;
 }
 void CPDF_ContentParser::Start(CPDF_Page* pPage, CPDF_ParseOptions* pOptions)
 {
     if (m_Status != Ready || pPage == NULL || pPage->m_pDocument == NULL || pPage->m_pFormDict == NULL) {
         m_Status = Done;
         return;
     }
     m_pObjects = pPage;
-    m_bForm = false;
+    m_bForm = FALSE;
     if (pOptions) {
         m_Options = *pOptions;
     }
     m_Status = ToBeContinued;
     m_InternalStage = PAGEPARSE_STAGE_GETCONTENT;
     m_CurrentOffset = 0;
     CPDF_Object* pContent = pPage->m_pFormDict->GetElementValue(FX_BSTRC("Contents"));
     if (pContent == NULL) {
         m_Status = Done;
         return;
     }
     if (pContent->GetType() == PDFOBJ_STREAM) {
         m_nStreams = 0;
         m_pSingleStream = new CPDF_StreamAcc;
-        m_pSingleStream->LoadAllData((CPDF_Stream*)pContent, false);
+        m_pSingleStream->LoadAllData((CPDF_Stream*)pContent, FALSE);
     } else if (pContent->GetType() == PDFOBJ_ARRAY) {
         CPDF_Array* pArray = (CPDF_Array*)pContent;
         m_nStreams = pArray->GetCount();
         if (m_nStreams == 0) {
             m_Status = Done;
             return;
         }
         m_pStreamArray = FX_Alloc(CPDF_StreamAcc*, m_nStreams);
     } else {
         m_Status = Done;
         return;
     }
 }
 void CPDF_ContentParser::Start(CPDF_Form* pForm, CPDF_AllStates* pGraphicStates,
                                CFX_AffineMatrix* pParentMatrix, CPDF_Type3Char* pType3Char, CPDF_ParseOptions* pOptions, int level)
 {
     m_pType3Char = pType3Char;
     m_pObjects = pForm;
-    m_bForm = true;
+    m_bForm = TRUE;
     CFX_AffineMatrix form_matrix = pForm->m_pFormDict->GetMatrix(FX_BSTRC("Matrix"));
     if (pGraphicStates) {
         form_matrix.Concat(pGraphicStates->m_CTM);
     }
     CPDF_Array* pBBox = pForm->m_pFormDict->GetArray(FX_BSTRC("BBox"));
     CFX_FloatRect form_bbox;
     CPDF_Path ClipPath;
     if (pBBox) {
         form_bbox = pBBox->GetRect();
         ClipPath.New();
         ClipPath.AppendRect(form_bbox.left, form_bbox.bottom, form_bbox.right, form_bbox.top);
         ClipPath.Transform(&form_matrix);
         if (pParentMatrix) {
             ClipPath.Transform(pParentMatrix);
         }
         form_bbox.Transform(&form_matrix);
         if (pParentMatrix) {
             form_bbox.Transform(pParentMatrix);
         }
     }
     CPDF_Dictionary* pResources = pForm->m_pFormDict->GetDict(FX_BSTRC("Resources"));
     m_pParser = new CPDF_StreamContentParser(
         pForm->m_pDocument, pForm->m_pPageResources, pForm->m_pResources,
         pParentMatrix, pForm, pResources, &form_bbox, pOptions, pGraphicStates,
         level);
     
     m_pParser->GetCurStates()->m_CTM = form_matrix;
     m_pParser->GetCurStates()->m_ParentMatrix = form_matrix;
     if (ClipPath.NotNull()) {
-        m_pParser->GetCurStates()->m_ClipPath.AppendPath(ClipPath, FXFILL_WINDING, true);
+        m_pParser->GetCurStates()->m_ClipPath.AppendPath(ClipPath, FXFILL_WINDING, TRUE);
     }
     if (pForm->m_Transparency & PDFTRANS_GROUP) {
         CPDF_GeneralStateData* pData = m_pParser->GetCurStates()->m_GeneralState.GetModify();
         pData->m_BlendType = FXDIB_BLEND_NORMAL;
         pData->m_StrokeAlpha = 1.0f;
         pData->m_FillAlpha = 1.0f;
         pData->m_pSoftMask = NULL;
     }
     m_nStreams = 0;
     m_pSingleStream = new CPDF_StreamAcc;
     if (pForm->m_pDocument) {
-        m_pSingleStream->LoadAllData(pForm->m_pFormStream, false);
+        m_pSingleStream->LoadAllData(pForm->m_pFormStream, FALSE);
     } else {
-        m_pSingleStream->LoadAllData(pForm->m_pFormStream, false);
+        m_pSingleStream->LoadAllData(pForm->m_pFormStream, FALSE);
     }
     m_pData = (uint8_t*)m_pSingleStream->GetData();
     m_Size = m_pSingleStream->GetSize();
     m_Status = ToBeContinued;
     m_InternalStage = PAGEPARSE_STAGE_PARSE;
     m_CurrentOffset = 0;
 }
 void CPDF_ContentParser::Continue(IFX_Pause* pPause)
 {
     int steps = 0;
@@ skipping 24 matching lines @@
                 } else {
                     m_pData = (uint8_t*)m_pSingleStream->GetData();
                     m_Size = m_pSingleStream->GetSize();
                 }
                 m_InternalStage = PAGEPARSE_STAGE_PARSE;
                 m_CurrentOffset = 0;
             } else {
                 CPDF_Array* pContent = m_pObjects->m_pFormDict->GetArray(FX_BSTRC("Contents"));
                 m_pStreamArray[m_CurrentOffset] = new CPDF_StreamAcc;
                 CPDF_Stream* pStreamObj = (CPDF_Stream*)(pContent ? pContent->GetElementValue(m_CurrentOffset) : NULL);
-                m_pStreamArray[m_CurrentOffset]->LoadAllData(pStreamObj, false);
+                m_pStreamArray[m_CurrentOffset]->LoadAllData(pStreamObj, FALSE);
                 m_CurrentOffset ++;
             }
         }
         if (m_InternalStage == PAGEPARSE_STAGE_PARSE) {
             if (!m_pParser) {
                 m_pParser = new CPDF_StreamContentParser(
                     m_pObjects->m_pDocument, m_pObjects->m_pPageResources,
                     nullptr, nullptr, m_pObjects, m_pObjects->m_pResources,
                     &m_pObjects->m_BBox, &m_Options, nullptr, 0);
                 m_pParser->GetCurStates()->m_ColorState.GetModify()->Default();
@@ skipping 58 matching lines @@
         return 100;
     }
     if (m_InternalStage == PAGEPARSE_STAGE_GETCONTENT) {
         return 10;
     }
     if (m_InternalStage == PAGEPARSE_STAGE_CHECKCLIP) {
         return 90;
     }
     return 10 + 80 * m_CurrentOffset / m_Size;
 }