Remove typdefs for pointer types in fx_system.h

core/include/fpdfapi/fpdf_parser.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_FPDFAPI_FPDF_PARSER_H_
 #define CORE_INCLUDE_FPDFAPI_FPDF_PARSER_H_
 
 #include "../fxcrt/fx_ext.h"
@@ skipping 184 matching lines @@
 
 #define PDFWORD_EOF                     0
 #define PDFWORD_NUMBER          1
 #define PDFWORD_TEXT            2
 #define PDFWORD_DELIMITER       3
 #define PDFWORD_NAME            4
 class CPDF_SimpleParser 
 {
 public:
 
-    CPDF_SimpleParser(FX_LPCBYTE pData, FX_DWORD dwSize);
+    CPDF_SimpleParser(const uint8_t* pData, FX_DWORD dwSize);
 
     CPDF_SimpleParser(FX_BSTR str);
 
     CFX_ByteStringC             GetWord();
 
     FX_BOOL                             SearchToken(FX_BSTR token);
 
     FX_BOOL                             SkipWord(FX_BSTR token);
 
     FX_BOOL                             FindTagPair(FX_BSTR start_token, FX_BSTR end_token,
                                     FX_DWORD& start_pos, FX_DWORD& end_pos);
 
     FX_BOOL                             FindTagParam(FX_BSTR token, int nParams);
 
     FX_DWORD                    GetPos()
     {
         return m_dwCurPos;
     }
 
     void                                SetPos(FX_DWORD pos)
     {
         ASSERT(pos <= m_dwSize);
         m_dwCurPos = pos;
     }
 private:
 
-    void                                ParseWord(FX_LPCBYTE& pStart, FX_DWORD& dwSize, int& type);
+    void                                ParseWord(const uint8_t*& pStart, FX_DWORD& dwSize, int& type);
 
-    FX_LPCBYTE                  m_pData;
+    const uint8_t*                      m_pData;
 
     FX_DWORD                    m_dwSize;
 
     FX_DWORD                    m_dwCurPos;
 };
 class CPDF_SyntaxParser 
 {
 public:
 
     CPDF_SyntaxParser();
@@ skipping 54 matching lines @@
 protected:
     static const int kParserMaxRecursionDepth = 64;
     static int s_CurrentRecursionDepth;
 
     virtual FX_BOOL                             GetNextChar(uint8_t& ch);
 
     FX_BOOL                             GetCharAtBackward(FX_FILESIZE pos, uint8_t& ch);
 
     void                                GetNextWord();
 
-    FX_BOOL                             IsWholeWord(FX_FILESIZE startpos, FX_FILESIZE limit, FX_LPCBYTE tag, FX_DWORD taglen);
+    FX_BOOL                             IsWholeWord(FX_FILESIZE startpos, FX_FILESIZE limit, const uint8_t* tag, FX_DWORD taglen);
 
     CFX_ByteString              ReadString();
 
     CFX_ByteString              ReadHexString();
 
     CPDF_Stream*                ReadStream(CPDF_Dictionary* pDict, PARSE_CONTEXT* pContext, FX_DWORD objnum, FX_DWORD gennum);
 
     FX_FILESIZE                 m_Pos;
 
     FX_BOOL                             m_bFileStream;
@@ skipping 46 matching lines @@
 #define PDFPARSE_ERROR_PASSWORD         3
 #define PDFPARSE_ERROR_HANDLER          4
 #define PDFPARSE_ERROR_CERT                     5
 
 class CPDF_Parser
 {
 public:
     CPDF_Parser();
     ~CPDF_Parser();
 
-    FX_DWORD                    StartParse(FX_LPCSTR filename, FX_BOOL bReParse = FALSE);
-    FX_DWORD                    StartParse(FX_LPCWSTR filename, FX_BOOL bReParse = FALSE);
+    FX_DWORD                    StartParse(const FX_CHAR* filename, FX_BOOL bReParse = FALSE);
+    FX_DWORD                    StartParse(const FX_WCHAR* filename, FX_BOOL bReParse = FALSE);
     FX_DWORD                    StartParse(IFX_FileRead* pFile, FX_BOOL bReParse = FALSE, FX_BOOL bOwnFileRead = TRUE);
 
     void                                CloseParser(FX_BOOL bReParse = FALSE);
 
     FX_DWORD    GetPermissions(FX_BOOL bCheckRevision = FALSE);
 
     FX_BOOL             IsOwner();
 
     void                                SetPassword(const FX_CHAR* password)
     {
@@ skipping 197 matching lines @@
 public:
 
     virtual ~CPDF_SecurityHandler() {}
 
     virtual FX_BOOL             OnInit(CPDF_Parser* pParser, CPDF_Dictionary* pEncryptDict) = 0;
 
     virtual FX_DWORD    GetPermissions() = 0;
 
     virtual FX_BOOL             IsOwner() = 0;
 
-    virtual FX_BOOL             GetCryptInfo(int& cipher, FX_LPCBYTE& buffer, int& keylen) = 0;
+    virtual FX_BOOL             GetCryptInfo(int& cipher, const uint8_t*& buffer, int& keylen) = 0;
 
     virtual FX_BOOL             IsMetadataEncrypted()
     {
         return TRUE;
     }
 
     virtual CPDF_CryptoHandler* CreateCryptoHandler() = 0;
 
     virtual CPDF_StandardSecurityHandler* GetStandardHandler()
     {
         return NULL;
     }
 };
 #define PDF_ENCRYPT_CONTENT                             0
 class CPDF_StandardSecurityHandler : public CPDF_SecurityHandler
 {
 public:
     CPDF_StandardSecurityHandler();
 
     virtual ~CPDF_StandardSecurityHandler();
     virtual FX_BOOL             OnInit(CPDF_Parser* pParser, CPDF_Dictionary* pEncryptDict);
     virtual FX_DWORD    GetPermissions();
     virtual FX_BOOL             IsOwner()
     {
         return m_bOwner;
     }
-    virtual FX_BOOL             GetCryptInfo(int& cipher, FX_LPCBYTE& buffer, int& keylen);
+    virtual FX_BOOL             GetCryptInfo(int& cipher, const uint8_t*& buffer, int& keylen);
     virtual FX_BOOL             IsMetadataEncrypted();
     virtual CPDF_CryptoHandler* CreateCryptoHandler();
     virtual CPDF_StandardSecurityHandler* GetStandardHandler()
     {
         return this;
     }
 
     void                                OnCreate(CPDF_Dictionary* pEncryptDict, CPDF_Array* pIdArray,
-                                 FX_LPCBYTE user_pass, FX_DWORD user_size,
-                                 FX_LPCBYTE owner_pass, FX_DWORD owner_size, FX_DWORD type = PDF_ENCRYPT_CONTENT);
+                                 const uint8_t* user_pass, FX_DWORD user_size,
+                                 const uint8_t* owner_pass, FX_DWORD owner_size, FX_DWORD type = PDF_ENCRYPT_CONTENT);
 
     void                                OnCreate(CPDF_Dictionary* pEncryptDict, CPDF_Array* pIdArray,
-                                 FX_LPCBYTE user_pass, FX_DWORD user_size, FX_DWORD type = PDF_ENCRYPT_CONTENT);
+                                 const uint8_t* user_pass, FX_DWORD user_size, FX_DWORD type = PDF_ENCRYPT_CONTENT);
 
-    CFX_ByteString              GetUserPassword(FX_LPCBYTE owner_pass, FX_DWORD pass_size);
-    CFX_ByteString              GetUserPassword(FX_LPCBYTE owner_pass, FX_DWORD pass_size, int32_t key_len);
+    CFX_ByteString              GetUserPassword(const uint8_t* owner_pass, FX_DWORD pass_size);
+    CFX_ByteString              GetUserPassword(const uint8_t* owner_pass, FX_DWORD pass_size, int32_t key_len);
     int                                 GetVersion()
     {
         return m_Version;
     }
     int                                 GetRevision()
     {
         return m_Revision;
     }
 
-    int                                 CheckPassword(FX_LPCBYTE password, FX_DWORD pass_size, FX_BOOL bOwner, FX_LPBYTE key);
-    int                                 CheckPassword(FX_LPCBYTE password, FX_DWORD pass_size, FX_BOOL bOwner, FX_LPBYTE key, int key_len);
+    int                                 CheckPassword(const uint8_t* password, FX_DWORD pass_size, FX_BOOL bOwner, uint8_t* key);
+    int                                 CheckPassword(const uint8_t* password, FX_DWORD pass_size, FX_BOOL bOwner, uint8_t* key, int key_len);
 private:
 
     int                                 m_Version;
 
     int                                 m_Revision;
 
     CPDF_Parser*                m_pParser;
 
     CPDF_Dictionary*    m_pEncryptDict;
 
     FX_BOOL                             LoadDict(CPDF_Dictionary* pEncryptDict);
     FX_BOOL                             LoadDict(CPDF_Dictionary* pEncryptDict, FX_DWORD type, int& cipher, int& key_len);
 
-    FX_BOOL                             CheckUserPassword(FX_LPCBYTE password, FX_DWORD pass_size,
-                                          FX_BOOL bIgnoreEncryptMeta, FX_LPBYTE key, int32_t key_len);
+    FX_BOOL                             CheckUserPassword(const uint8_t* password, FX_DWORD pass_size,
+                                          FX_BOOL bIgnoreEncryptMeta, uint8_t* key, int32_t key_len);
 
-    FX_BOOL                             CheckOwnerPassword(FX_LPCBYTE password, FX_DWORD pass_size, FX_LPBYTE key, int32_t key_len);
-    FX_BOOL                             AES256_CheckPassword(FX_LPCBYTE password, FX_DWORD size, FX_BOOL bOwner, FX_LPBYTE key);
-    void                                AES256_SetPassword(CPDF_Dictionary* pEncryptDict, FX_LPCBYTE password, FX_DWORD size, FX_BOOL bOwner, FX_LPCBYTE key);
-    void                                AES256_SetPerms(CPDF_Dictionary* pEncryptDict, FX_DWORD permission, FX_BOOL bEncryptMetadata, FX_LPCBYTE key);
+    FX_BOOL                             CheckOwnerPassword(const uint8_t* password, FX_DWORD pass_size, uint8_t* key, int32_t key_len);
+    FX_BOOL                             AES256_CheckPassword(const uint8_t* password, FX_DWORD size, FX_BOOL bOwner, uint8_t* key);
+    void                                AES256_SetPassword(CPDF_Dictionary* pEncryptDict, const uint8_t* password, FX_DWORD size, FX_BOOL bOwner, const uint8_t* key);
+    void                                AES256_SetPerms(CPDF_Dictionary* pEncryptDict, FX_DWORD permission, FX_BOOL bEncryptMetadata, const uint8_t* key);
     void                                OnCreate(CPDF_Dictionary* pEncryptDict, CPDF_Array* pIdArray,
-                                 FX_LPCBYTE user_pass, FX_DWORD user_size,
-                                 FX_LPCBYTE owner_pass, FX_DWORD owner_size, FX_BOOL bDefault, FX_DWORD type);
+                                 const uint8_t* user_pass, FX_DWORD user_size,
+                                 const uint8_t* owner_pass, FX_DWORD owner_size, FX_BOOL bDefault, FX_DWORD type);
     FX_BOOL                             CheckSecurity(int32_t key_len);
 
     FX_BOOL                             m_bOwner;
 
     FX_DWORD                    m_Permissions;
 
     int                                 m_Cipher;
 
     uint8_t                             m_EncryptKey[32];
 
     int                                 m_KeyLen;
 };
 class CPDF_CryptoHandler 
 {
 public:
 
     virtual ~CPDF_CryptoHandler() {}
 
     virtual FX_BOOL             Init(CPDF_Dictionary* pEncryptDict, CPDF_SecurityHandler* pSecurityHandler) = 0;
 
     virtual FX_DWORD    DecryptGetSize(FX_DWORD src_size) = 0;
 
-    virtual FX_LPVOID   DecryptStart(FX_DWORD objnum, FX_DWORD gennum) = 0;
+    virtual void*       DecryptStart(FX_DWORD objnum, FX_DWORD gennum) = 0;
 
-    virtual FX_BOOL             DecryptStream(FX_LPVOID context, FX_LPCBYTE src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf) = 0;
+    virtual FX_BOOL             DecryptStream(void* context, const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf) = 0;
 
-    virtual FX_BOOL             DecryptFinish(FX_LPVOID context, CFX_BinaryBuf& dest_buf) = 0;
+    virtual FX_BOOL             DecryptFinish(void* context, CFX_BinaryBuf& dest_buf) = 0;
 
 
-    virtual FX_DWORD    EncryptGetSize(FX_DWORD objnum, FX_DWORD version, FX_LPCBYTE src_buf, FX_DWORD src_size) = 0;
+    virtual FX_DWORD    EncryptGetSize(FX_DWORD objnum, FX_DWORD version, const uint8_t* src_buf, FX_DWORD src_size) = 0;
 
-    virtual FX_BOOL             EncryptContent(FX_DWORD objnum, FX_DWORD version, FX_LPCBYTE src_buf, FX_DWORD src_size,
-                                       FX_LPBYTE dest_buf, FX_DWORD& dest_size) = 0;
+    virtual FX_BOOL             EncryptContent(FX_DWORD objnum, FX_DWORD version, const uint8_t* src_buf, FX_DWORD src_size,
+                                       uint8_t* dest_buf, FX_DWORD& dest_size) = 0;
 
     void                                Decrypt(FX_DWORD objnum, FX_DWORD version, CFX_ByteString& str);
 };
 class CPDF_StandardCryptoHandler : public CPDF_CryptoHandler
 {
 public:
 
     CPDF_StandardCryptoHandler();
 
     virtual ~CPDF_StandardCryptoHandler();
 
-    FX_BOOL                             Init(int cipher, FX_LPCBYTE key, int keylen);
+    FX_BOOL                             Init(int cipher, const uint8_t* key, int keylen);
     virtual FX_BOOL             Init(CPDF_Dictionary* pEncryptDict, CPDF_SecurityHandler* pSecurityHandler);
     virtual FX_DWORD    DecryptGetSize(FX_DWORD src_size);
-    virtual FX_LPVOID   DecryptStart(FX_DWORD objnum, FX_DWORD gennum);
-    virtual FX_BOOL             DecryptStream(FX_LPVOID context, FX_LPCBYTE src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf);
-    virtual FX_BOOL             DecryptFinish(FX_LPVOID context, CFX_BinaryBuf& dest_buf);
-    virtual FX_DWORD    EncryptGetSize(FX_DWORD objnum, FX_DWORD version, FX_LPCBYTE src_buf, FX_DWORD src_size);
-    virtual FX_BOOL             EncryptContent(FX_DWORD objnum, FX_DWORD version, FX_LPCBYTE src_buf, FX_DWORD src_size,
-                                       FX_LPBYTE dest_buf, FX_DWORD& dest_size);
+    virtual void*       DecryptStart(FX_DWORD objnum, FX_DWORD gennum);
+    virtual FX_BOOL             DecryptStream(void* context, const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf);
+    virtual FX_BOOL             DecryptFinish(void* context, CFX_BinaryBuf& dest_buf);
+    virtual FX_DWORD    EncryptGetSize(FX_DWORD objnum, FX_DWORD version, const uint8_t* src_buf, FX_DWORD src_size);
+    virtual FX_BOOL             EncryptContent(FX_DWORD objnum, FX_DWORD version, const uint8_t* src_buf, FX_DWORD src_size,
+                                       uint8_t* dest_buf, FX_DWORD& dest_size);
 protected:
 
-    virtual void                CryptBlock(FX_BOOL bEncrypt, FX_DWORD objnum, FX_DWORD gennum, FX_LPCBYTE src_buf, FX_DWORD src_size,
-                                   FX_LPBYTE dest_buf, FX_DWORD& dest_size);
-    virtual FX_LPVOID   CryptStart(FX_DWORD objnum, FX_DWORD gennum, FX_BOOL bEncrypt);
-    virtual FX_BOOL             CryptStream(FX_LPVOID context, FX_LPCBYTE src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf, FX_BOOL bEncrypt);
-    virtual FX_BOOL             CryptFinish(FX_LPVOID context, CFX_BinaryBuf& dest_buf, FX_BOOL bEncrypt);
+    virtual void                CryptBlock(FX_BOOL bEncrypt, FX_DWORD objnum, FX_DWORD gennum, const uint8_t* src_buf, FX_DWORD src_size,
+                                   uint8_t* dest_buf, FX_DWORD& dest_size);
+    virtual void*       CryptStart(FX_DWORD objnum, FX_DWORD gennum, FX_BOOL bEncrypt);
+    virtual FX_BOOL             CryptStream(void* context, const uint8_t* src_buf, FX_DWORD src_size, CFX_BinaryBuf& dest_buf, FX_BOOL bEncrypt);
+    virtual FX_BOOL             CryptFinish(void* context, CFX_BinaryBuf& dest_buf, FX_BOOL bEncrypt);
 
     uint8_t                             m_EncryptKey[32];
 
     int                                 m_KeyLen;
 
     int                                 m_Cipher;
 
-    FX_LPBYTE                   m_pAESContext;
+    uint8_t*                    m_pAESContext;
 };
 class CPDF_Point 
 {
 public:
 
     CPDF_Point(FX_FLOAT xx, FX_FLOAT yy)
     {
         x = xx;
         y = yy;
     }
 
     FX_FLOAT                    x;
 
     FX_FLOAT                    y;
 };
 
 #define CPDF_Rect               CFX_FloatRect
 #define CPDF_Matrix             CFX_AffineMatrix
 CFX_ByteString PDF_NameDecode(FX_BSTR orig);
 CFX_ByteString PDF_NameDecode(const CFX_ByteString& orig);
 CFX_ByteString PDF_NameEncode(const CFX_ByteString& orig);
 CFX_ByteString PDF_EncodeString(const CFX_ByteString& src, FX_BOOL bHex = FALSE);
-CFX_WideString PDF_DecodeText(FX_LPCBYTE pData, FX_DWORD size, CFX_CharMap* pCharMap = NULL);
+CFX_WideString PDF_DecodeText(const uint8_t* pData, FX_DWORD size, CFX_CharMap* pCharMap = NULL);
 inline CFX_WideString PDF_DecodeText(const CFX_ByteString& bstr, CFX_CharMap* pCharMap = NULL) {
-    return PDF_DecodeText((FX_LPCBYTE)bstr.c_str(), bstr.GetLength(), pCharMap);
+    return PDF_DecodeText((const uint8_t*)bstr.c_str(), bstr.GetLength(), pCharMap);
 }
-CFX_ByteString PDF_EncodeText(FX_LPCWSTR pString, int len = -1, CFX_CharMap* pCharMap = NULL);
+CFX_ByteString PDF_EncodeText(const FX_WCHAR* pString, int len = -1, CFX_CharMap* pCharMap = NULL);
 inline CFX_ByteString PDF_EncodeText(const CFX_WideString& str, CFX_CharMap* pCharMap = NULL) {
     return PDF_EncodeText(str.c_str(), str.GetLength(), pCharMap);
 }
 FX_FLOAT PDF_ClipFloat(FX_FLOAT f);
 class CFDF_Document : public CPDF_IndirectObjects
 {
 public:
     static CFDF_Document* CreateNewDoc();
     static CFDF_Document* ParseFile(IFX_FileRead *pFile, FX_BOOL bOwnFile = FALSE);
-    static CFDF_Document* ParseMemory(FX_LPCBYTE pData, FX_DWORD size);
+    static CFDF_Document* ParseMemory(const uint8_t* pData, FX_DWORD size);
 
     ~CFDF_Document();
 
     FX_BOOL                                     WriteBuf(CFX_ByteTextBuf& buf) const;
 
     CPDF_Dictionary*            GetRoot() const
     {
         return m_pRootDict;
     }
 
     CFX_WideString                      GetWin32Path() const;
 protected:
 
     CFDF_Document();
     void        ParseStream(IFX_FileRead *pFile, FX_BOOL bOwnFile);
     CPDF_Dictionary*            m_pRootDict;
     IFX_FileRead*                       m_pFile;
     FX_BOOL                                     m_bOwnFile;
 };
 
 CFX_WideString  FPDF_FileSpec_GetWin32Path(const CPDF_Object* pFileSpec);
 void                    FPDF_FileSpec_SetWin32Path(CPDF_Object* pFileSpec, const CFX_WideString& fullpath);
 
-void FlateEncode(const uint8_t* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size);
-FX_DWORD FlateDecode(const uint8_t* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size);
-FX_DWORD RunLengthDecode(const uint8_t* src_buf, FX_DWORD src_size, FX_LPBYTE& dest_buf, FX_DWORD& dest_size);
+void FlateEncode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf, FX_DWORD& dest_size);
+FX_DWORD FlateDecode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf, FX_DWORD& dest_size);
+FX_DWORD RunLengthDecode(const uint8_t* src_buf, FX_DWORD src_size, uint8_t*& dest_buf, FX_DWORD& dest_size);
 class CPDF_NumberTree 
 {
 public:
 
     CPDF_NumberTree(CPDF_Dictionary* pRoot)
     {
         m_pRoot = pRoot;
     }
 
     CPDF_Object*                LookupValue(int num);
@@ skipping 95 matching lines @@
     PDF_DATAAVAIL_PAGE,
     PDF_DATAAVAIL_PAGE_LATERLOAD,
     PDF_DATAAVAIL_RESOURCES,
     PDF_DATAAVAIL_DONE,
     PDF_DATAAVAIL_ERROR,
     PDF_DATAAVAIL_LOADALLFILE,
     PDF_DATAAVAIL_TRAILER_APPEND
 };
 
 #endif  // CORE_INCLUDE_FPDFAPI_FPDF_PARSER_H_