Remove typdefs for pointer types in fx_system.h

core/src/fpdfapi/fpdf_font/fpdf_font.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_pageobj.h"
 #include "font_int.h"
@@ skipping 187 matching lines @@
             return charcode;
         }
     }
     return _CharCodeFromUnicode(unicode);
 }
 CFX_WideString CPDF_Font::DecodeString(const CFX_ByteString& str) const
 {
     CFX_WideString result;
     int src_len = str.GetLength();
     result.Reserve(src_len);
-    FX_LPCSTR src_buf = str;
+    const FX_CHAR* src_buf = str;
     int src_pos = 0;
     while (src_pos < src_len) {
         FX_DWORD charcode = GetNextChar(src_buf, src_len, src_pos);
         CFX_WideString unicode = UnicodeFromCharCode(charcode);
         if (!unicode.IsEmpty()) {
             result += unicode;
         } else {
             result += (FX_WCHAR)charcode;
         }
     }
     return result;
 }
 CFX_ByteString CPDF_Font::EncodeString(const CFX_WideString& str) const
 {
     CFX_ByteString result;
     int src_len = str.GetLength();
-    FX_LPSTR dest_buf = result.GetBuffer(src_len * 2);
-    FX_LPCWSTR src_buf = str.c_str();
+    FX_CHAR* dest_buf = result.GetBuffer(src_len * 2);
+    const FX_WCHAR* src_buf = str.c_str();
     int dest_pos = 0;
     for (int src_pos = 0; src_pos < src_len; src_pos ++) {
         FX_DWORD charcode = CharCodeFromUnicode(src_buf[src_pos]);
         dest_pos += AppendChar(dest_buf + dest_pos, charcode);
     }
     result.ReleaseBuffer(dest_pos);
     return result;
 }
 void CPDF_Font::LoadFontDescriptor(CPDF_Dictionary* pFontDesc)
 {
@@ skipping 45 matching lines @@
         pFontFile = pFontDesc->GetStream(FX_BSTRC("FontFile2"));
     }
     if (pFontFile == NULL) {
         pFontFile = pFontDesc->GetStream(FX_BSTRC("FontFile3"));
     }
     if (pFontFile) {
         m_pFontFile = m_pDocument->LoadFontFile(pFontFile);
         if (m_pFontFile == NULL) {
             return;
         }
-        FX_LPCBYTE pFontData = m_pFontFile->GetData();
+        const uint8_t* pFontData = m_pFontFile->GetData();
         FX_DWORD dwFontSize = m_pFontFile->GetSize();
         m_Font.LoadEmbedded(pFontData, dwFontSize);
         if (m_Font.m_Face == NULL) {
             m_pFontFile = NULL;
         }
     }
 }
 short TT2PDF(int m, FXFT_Face face)
 {
     int upm = FXFT_Get_Face_UnitsPerEM(face);
@@ skipping 59 matching lines @@
 void CPDF_Font::LoadUnicodeMap()
 {
     m_bToUnicodeLoaded = TRUE;
     CPDF_Stream* pStream = m_pFontDict->GetStream(FX_BSTRC("ToUnicode"));
     if (pStream == NULL) {
         return;
     }
     m_pToUnicodeMap = new CPDF_ToUnicodeMap;
     m_pToUnicodeMap->Load(pStream);
 }
-int CPDF_Font::GetStringWidth(FX_LPCSTR pString, int size)
+int CPDF_Font::GetStringWidth(const FX_CHAR* pString, int size)
 {
     int offset = 0;
     int width = 0;
     while (offset < size) {
         FX_DWORD charcode = GetNextChar(pString, size, offset);
         width += GetCharWidthF(charcode);
     }
     return width;
 }
 int CPDF_Font::GetCharTypeWidth(FX_DWORD charcode)
@@ skipping 41 matching lines @@
     CFX_ByteString type = pFontDict->GetString(FX_BSTRC("Subtype"));
     CPDF_Font* pFont;
     if (type == FX_BSTRC("TrueType")) {
         {
 #if _FXM_PLATFORM_  == _FXM_PLATFORM_WINDOWS_ || _FXM_PLATFORM_ == _FXM_PLATFORM_LINUX_ || _FXM_PLATFORM_ == _FXM_PLATFORM_ANDROID_ || _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
             CFX_ByteString basefont = pFontDict->GetString(FX_BSTRC("BaseFont"));
             CFX_ByteString tag = basefont.Left(4);
             int i;
             int count = sizeof(ChineseFontNames) / sizeof(ChineseFontNames[0]);
             for (i = 0; i < count; ++i) {
-                if (tag == CFX_ByteString((FX_LPCSTR)ChineseFontNames[i])) {
+                if (tag == CFX_ByteString((const FX_CHAR*)ChineseFontNames[i])) {
                     break;
                 }
             }
             if (i < count) {
                 CPDF_Dictionary* pFontDesc = pFontDict->GetDict(FX_BSTRC("FontDescriptor"));
                 if (pFontDesc == NULL || !pFontDesc->KeyExist(FX_BSTRC("FontFile2"))) {
                     pFont = new CPDF_CIDFont;
                     pFont->m_pFontDict = pFontDict;
                     pFont->m_pDocument = pDoc;
                     if (!pFont->Load()) {
@@ skipping 48 matching lines @@
     m_pFont = pFont;
 }
 CFX_WideString CPDF_ToUnicodeMap::Lookup(FX_DWORD charcode)
 {
     FX_DWORD value;
     if (m_Map.Lookup(charcode, value)) {
         FX_WCHAR unicode = (FX_WCHAR)(value & 0xffff);
         if (unicode != 0xffff) {
             return unicode;
         }
-        FX_LPCWSTR buf = m_MultiCharBuf.GetBuffer();
+        const FX_WCHAR* buf = m_MultiCharBuf.GetBuffer();
         FX_DWORD buf_len = m_MultiCharBuf.GetLength();
         if (buf == NULL || buf_len == 0) {
             return CFX_WideString();
         }
         FX_DWORD index = value >> 16;
         if (index >= buf_len) {
             return CFX_WideString();
         }
         FX_DWORD len = buf[index];
         if (index + len < index || index + len >= buf_len) {
@@ skipping 13 matching lines @@
         FX_DWORD key, value;
         m_Map.GetNextAssoc(pos, key, value);
         if ((FX_WCHAR)value == unicode) {
             return key;
         }
     }
     return 0;
 }
 static FX_DWORD _StringToCode(FX_BSTR str)
 {
-    FX_LPCSTR buf = str.GetCStr();
+    const FX_CHAR* buf = str.GetCStr();
     int len = str.GetLength();
     if (len == 0) {
         return 0;
     }
     int result = 0;
     if (buf[0] == '<') {
         for (int i = 1; i < len; i ++) {
             int digit;
             if (buf[i] >= '0' && buf[i] <= '9') {
                 digit = buf[i] - '0';
@@ skipping 31 matching lines @@
             value = 0;
         }
     }
     if (value) {
         ret.Insert(0, value);
     }
     return ret;
 }
 static CFX_WideString _StringToWideString(FX_BSTR str)
 {
-    FX_LPCSTR buf = str.GetCStr();
+    const FX_CHAR* buf = str.GetCStr();
     int len = str.GetLength();
     if (len == 0) {
         return CFX_WideString();
     }
     CFX_WideString result;
     if (buf[0] == '<') {
         int byte_pos = 0;
         FX_WCHAR ch = 0;
         for (int i = 1; i < len; i ++) {
             int digit;
@@ skipping 209 matching lines @@
         return FALSE;
     }
     if (m_pFontFile != NULL) {
         return FALSE;
     }
     if (((CPDF_Type1Font*)this)->GetBase14Font() < 0) {
         return FALSE;
     }
     return TRUE;
 }
-extern FX_LPCSTR PDF_CharNameFromPredefinedCharSet(int encoding, uint8_t charcode);
+extern const FX_CHAR* PDF_CharNameFromPredefinedCharSet(int encoding, uint8_t charcode);
 CPDF_SimpleFont::CPDF_SimpleFont(int fonttype) : CPDF_Font(fonttype)
 {
     FXSYS_memset8(m_CharBBox, 0xff, sizeof m_CharBBox);
     FXSYS_memset8(m_CharWidth, 0xff, sizeof m_CharWidth);
     FXSYS_memset8(m_GlyphIndex, 0xff, sizeof m_GlyphIndex);
     FXSYS_memset8(m_ExtGID, 0xff, sizeof m_ExtGID);
     m_pCharNames = NULL;
     m_BaseEncoding = PDFFONT_ENCODING_BUILTIN;
 }
 CPDF_SimpleFont::~CPDF_SimpleFont()
@@ skipping 70 matching lines @@
         charcode = 0;
     }
     if (m_CharBBox[charcode].Left == (int16_t)0xffff) {
         LoadCharMetrics(charcode);
     }
     rect.left = m_CharBBox[charcode].Left;
     rect.right = m_CharBBox[charcode].Right;
     rect.bottom = m_CharBBox[charcode].Bottom;
     rect.top = m_CharBBox[charcode].Top;
 }
-FX_LPCSTR GetAdobeCharName(int iBaseEncoding, const CFX_ByteString* pCharNames, int charcode)
+const FX_CHAR* GetAdobeCharName(int iBaseEncoding, const CFX_ByteString* pCharNames, int charcode)
 {
     ASSERT(charcode >= 0 && charcode < 256);
     if (charcode < 0 || charcode >= 256) {
         return NULL;
     }
-    FX_LPCSTR name = NULL;
+    const FX_CHAR* name = NULL;
     if (pCharNames) {
         name = pCharNames[charcode];
     }
     if ((name == NULL || name[0] == 0) && iBaseEncoding) {
         name = PDF_CharNameFromPredefinedCharSet(iBaseEncoding, charcode);
     }
     if (name == NULL || name[0] == 0) {
         return NULL;
     }
     return name;
@@ skipping 147 matching lines @@
         return -1;
     }
     int index = m_ExtGID[(uint8_t)charcode];
     if (index == 0xffff) {
         return -1;
     }
     return index;
 }
 #if _FXM_PLATFORM_  == _FXM_PLATFORM_APPLE_
 struct _GlyphNameMap {
-    FX_LPCSTR m_pStrAdobe;
-    FX_LPCSTR m_pStrUnicode;
+    const FX_CHAR* m_pStrAdobe;
+    const FX_CHAR* m_pStrUnicode;
 };
 static const _GlyphNameMap g_GlyphNameSubsts[] = {
     {"ff", "uniFB00"},
     {"fi", "uniFB01"},
     {"fl", "uniFB02"},
     {"ffi", "uniFB03"},
     {"ffl", "uniFB04"}
 };
 extern "C" {
     static int compareString(const void* key, const void* element)
     {
-        return FXSYS_stricmp((FX_LPCSTR)key, ((_GlyphNameMap*)element)->m_pStrAdobe);
+        return FXSYS_stricmp((const FX_CHAR*)key, ((_GlyphNameMap*)element)->m_pStrAdobe);
     }
 }
-static FX_LPCSTR _GlyphNameRemap(FX_LPCSTR pStrAdobe)
+static const FX_CHAR* _GlyphNameRemap(const FX_CHAR* pStrAdobe)
 {
     _GlyphNameMap* found = (_GlyphNameMap*)FXSYS_bsearch(pStrAdobe, g_GlyphNameSubsts,
                            sizeof g_GlyphNameSubsts / sizeof(_GlyphNameMap), sizeof(_GlyphNameMap),
                            compareString);
     if (found) {
         return found->m_pStrUnicode;
     }
     return NULL;
 }
 #endif
@@ skipping 46 matching lines @@
                 }
 #endif
                 return;
             }
         }
         FXFT_Select_Charmap(m_Font.m_Face, FXFT_ENCODING_UNICODE);
         if (m_BaseEncoding == 0) {
             m_BaseEncoding = PDFFONT_ENCODING_STANDARD;
         }
         for (int charcode = 0; charcode < 256; charcode ++) {
-            FX_LPCSTR name = GetAdobeCharName(m_BaseEncoding, m_pCharNames, charcode);
+            const FX_CHAR* name = GetAdobeCharName(m_BaseEncoding, m_pCharNames, charcode);
             if (name == NULL) {
                 continue;
             }
             m_Encoding.m_Unicodes[charcode] = PDF_UnicodeFromAdobeName(name);
             m_GlyphIndex[charcode] = FXFT_Get_Char_Index(m_Font.m_Face, m_Encoding.m_Unicodes[charcode]);
 #if _FXM_PLATFORM_  == _FXM_PLATFORM_APPLE_
             FX_CHAR name_glyph[256];
             FXFT_Get_Glyph_Name(m_Font.m_Face, m_GlyphIndex[charcode], name_glyph, 256);
             name_glyph[255] = 0;
             CFStringRef name_ct = CFStringCreateWithCStringNoCopy(kCFAllocatorDefault, name_glyph, kCFStringEncodingASCII, kCFAllocatorNull);
@@ skipping 22 matching lines @@
             FXSYS_memcpy32(m_ExtGID, m_GlyphIndex, 256);
         }
 #endif
         return;
     }
     FT_UseType1Charmap(m_Font.m_Face);
 #if _FXM_PLATFORM_  == _FXM_PLATFORM_APPLE_
     if (bCoreText) {
         if (m_Flags & PDFFONT_SYMBOLIC) {
             for (int charcode = 0; charcode < 256; charcode ++) {
-                FX_LPCSTR name = GetAdobeCharName(m_BaseEncoding, m_pCharNames, charcode);
+                const FX_CHAR* name = GetAdobeCharName(m_BaseEncoding, m_pCharNames, charcode);
                 if (name) {
                     m_Encoding.m_Unicodes[charcode] = PDF_UnicodeFromAdobeName(name);
                     m_GlyphIndex[charcode] = FXFT_Get_Name_Index(m_Font.m_Face, (char*)name);
                     CFStringRef name_ct = CFStringCreateWithCStringNoCopy(kCFAllocatorDefault, name, kCFStringEncodingASCII, kCFAllocatorNull);
                     m_ExtGID[charcode] = CGFontGetGlyphWithGlyphName((CGFontRef)m_Font.m_pPlatformFont, name_ct);
                     if (name_ct) {
                         CFRelease(name_ct);
                     }
                 } else {
                     m_GlyphIndex[charcode] = FXFT_Get_Char_Index(m_Font.m_Face, charcode);
@@ skipping 16 matching lines @@
                     }
                 }
             }
             return;
         }
         FX_BOOL bUnicode = FALSE;
         if (0 == FXFT_Select_Charmap(m_Font.m_Face, FXFT_ENCODING_UNICODE)) {
             bUnicode = TRUE;
         }
         for (int charcode = 0; charcode < 256; charcode ++) {
-            FX_LPCSTR name = GetAdobeCharName(m_BaseEncoding, m_pCharNames, charcode);
+            const FX_CHAR* name = GetAdobeCharName(m_BaseEncoding, m_pCharNames, charcode);
             if (name == NULL) {
                 continue;
             }
             m_Encoding.m_Unicodes[charcode] = PDF_UnicodeFromAdobeName(name);
-            FX_LPCSTR pStrUnicode = _GlyphNameRemap(name);
+            const FX_CHAR* pStrUnicode = _GlyphNameRemap(name);
             if (pStrUnicode && 0 == FXFT_Get_Name_Index(m_Font.m_Face, (char*)name)) {
                 name = pStrUnicode;
             }
             m_GlyphIndex[charcode] = FXFT_Get_Name_Index(m_Font.m_Face, (char*)name);
             CFStringRef name_ct = CFStringCreateWithCStringNoCopy(kCFAllocatorDefault, name, kCFStringEncodingASCII, kCFAllocatorNull);
             m_ExtGID[charcode] = CGFontGetGlyphWithGlyphName((CGFontRef)m_Font.m_pPlatformFont, name_ct);
             if (name_ct) {
                 CFRelease(name_ct);
             }
             if (m_GlyphIndex[charcode] == 0) {
@@ skipping 19 matching lines @@
                         CFRelease(name_ct);
                     }
                 }
             }
         }
         return;
     }
 #endif
     if (m_Flags & PDFFONT_SYMBOLIC) {
         for (int charcode = 0; charcode < 256; charcode ++) {
-            FX_LPCSTR name = GetAdobeCharName(m_BaseEncoding, m_pCharNames, charcode);
+            const FX_CHAR* name = GetAdobeCharName(m_BaseEncoding, m_pCharNames, charcode);
             if (name) {
                 m_Encoding.m_Unicodes[charcode] = PDF_UnicodeFromAdobeName(name);
                 m_GlyphIndex[charcode] = FXFT_Get_Name_Index(m_Font.m_Face, (char*)name);
             } else {
                 m_GlyphIndex[charcode] = FXFT_Get_Char_Index(m_Font.m_Face, charcode);
                 if (m_GlyphIndex[charcode]) {
                     FX_WCHAR unicode = FT_UnicodeFromCharCode(PDFFONT_ENCODING_STANDARD, charcode);
                     if (unicode == 0) {
                         FX_CHAR name_glyph[256];
                         FXSYS_memset32(name_glyph, 0, sizeof(name_glyph));
@@ skipping 12 matching lines @@
             FXSYS_memcpy32(m_ExtGID, m_GlyphIndex, 256);
         }
 #endif
         return;
     }
     FX_BOOL bUnicode = FALSE;
     if (0 == FXFT_Select_Charmap(m_Font.m_Face, FXFT_ENCODING_UNICODE)) {
         bUnicode = TRUE;
     }
     for (int charcode = 0; charcode < 256; charcode ++) {
-        FX_LPCSTR name = GetAdobeCharName(m_BaseEncoding, m_pCharNames, charcode);
+        const FX_CHAR* name = GetAdobeCharName(m_BaseEncoding, m_pCharNames, charcode);
         if (name == NULL) {
             continue;
         }
         m_Encoding.m_Unicodes[charcode] = PDF_UnicodeFromAdobeName(name);
         m_GlyphIndex[charcode] = FXFT_Get_Name_Index(m_Font.m_Face, (char*)name);
         if (m_GlyphIndex[charcode] == 0) {
             if (FXSYS_strcmp(name, ".notdef") != 0 && FXSYS_strcmp(name, "space") != 0) {
                 m_GlyphIndex[charcode] = FXFT_Get_Char_Index(m_Font.m_Face, bUnicode ? m_Encoding.m_Unicodes[charcode] : charcode);
             } else {
                 m_Encoding.m_Unicodes[charcode] = 0x20;
@@ skipping 132 matching lines @@
             if (m_Flags & PDFFONT_NONSYMBOLIC) {
                 bMacRoman = FT_UseTTCharmap(m_Font.m_Face, 1, 0);
                 bMSSymbol = !bMacRoman && FT_UseTTCharmap(m_Font.m_Face, 3, 0);
             } else {
                 bMSSymbol = FT_UseTTCharmap(m_Font.m_Face, 3, 0);
                 bMacRoman = !bMSSymbol && FT_UseTTCharmap(m_Font.m_Face, 1, 0);
             }
         }
         FX_BOOL bToUnicode = m_pFontDict->KeyExist(FX_BSTRC("ToUnicode"));
         for (int charcode = 0; charcode < 256; charcode ++) {
-            FX_LPCSTR name = GetAdobeCharName(baseEncoding, m_pCharNames, charcode);
+            const FX_CHAR* name = GetAdobeCharName(baseEncoding, m_pCharNames, charcode);
             if (name == NULL) {
                 m_GlyphIndex[charcode] = m_pFontFile ? FXFT_Get_Char_Index(m_Font.m_Face, charcode) : -1;
                 continue;
             }
             m_Encoding.m_Unicodes[charcode] = PDF_UnicodeFromAdobeName(name);
             if (bMSSymbol) {
                 const uint8_t prefix[4] = {0x00, 0xf0, 0xf1, 0xf2};
                 for (int j = 0; j < 4; j ++) {
                     FX_WORD unicode = prefix[j] * 256 + charcode;
                     m_GlyphIndex[charcode] = FXFT_Get_Char_Index(m_Font.m_Face, unicode);
@@ skipping 44 matching lines @@
                 m_GlyphIndex[charcode] = FXFT_Get_Char_Index(m_Font.m_Face, unicode);
                 if (m_GlyphIndex[charcode]) {
                     bGotOne = TRUE;
                     break;
                 }
             }
         }
         if (bGotOne) {
             if (baseEncoding != PDFFONT_ENCODING_BUILTIN) {
                 for (int charcode = 0; charcode < 256; charcode ++) {
-                    FX_LPCSTR name = GetAdobeCharName(baseEncoding, m_pCharNames, charcode);
+                    const FX_CHAR* name = GetAdobeCharName(baseEncoding, m_pCharNames, charcode);
                     if (name == NULL) {
                         continue;
                     }
                     m_Encoding.m_Unicodes[charcode] = PDF_UnicodeFromAdobeName(name);
                 }
             } else if (FT_UseTTCharmap(m_Font.m_Face, 1, 0)) {
                 for (int charcode = 0; charcode < 256; charcode ++) {
                     m_Encoding.m_Unicodes[charcode] = FT_UnicodeFromCharCode(FXFT_ENCODING_APPLE_ROMAN, charcode);
                 }
             }
@@ skipping 11 matching lines @@
         }
         if (m_pFontFile || bGotOne) {
             return;
         }
     }
     if (FXFT_Select_Charmap(m_Font.m_Face, FXFT_ENCODING_UNICODE) == 0) {
         FX_BOOL bGotOne = FALSE;
         const FX_WORD* pUnicodes = PDF_UnicodesForPredefinedCharSet(baseEncoding);
         for (int charcode = 0; charcode < 256; charcode ++) {
             if (m_pFontFile == NULL) {
-                FX_LPCSTR name = GetAdobeCharName(0, m_pCharNames, charcode);
+                const FX_CHAR* name = GetAdobeCharName(0, m_pCharNames, charcode);
                 if (name != NULL) {
                     m_Encoding.m_Unicodes[charcode] = PDF_UnicodeFromAdobeName(name);
                 } else if (pUnicodes) {
                     m_Encoding.m_Unicodes[charcode] = pUnicodes[charcode];
                 }
             } else {
                 m_Encoding.m_Unicodes[charcode] = charcode;
             }
             m_GlyphIndex[charcode] = FXFT_Get_Char_Index(m_Font.m_Face, m_Encoding.m_Unicodes[charcode]);
             if (m_GlyphIndex[charcode]) {
@@ skipping 10 matching lines @@
 }
 CPDF_Type3Font::CPDF_Type3Font() : CPDF_SimpleFont(PDFFONT_TYPE3)
 {
     m_pPageResources = NULL;
     FXSYS_memset32(m_CharWidthL, 0, sizeof m_CharWidthL);
 }
 CPDF_Type3Font::~CPDF_Type3Font()
 {
     FX_POSITION pos = m_CacheMap.GetStartPosition();
     while (pos) {
-        FX_LPVOID key, value;
+        void* key;
+        void* value;
         m_CacheMap.GetNextAssoc(pos, key, value);
         delete (CPDF_Type3Char*)value;
     }
     m_CacheMap.RemoveAll();
     pos = m_DeletedMap.GetStartPosition();
     while (pos) {
-        FX_LPVOID key, value;
+        void* key;
+        void* value;
         m_DeletedMap.GetNextAssoc(pos, key, value);
         delete (CPDF_Type3Char*)key;
     }
 }
 FX_BOOL CPDF_Type3Font::_Load()
 {
     m_pFontResources = m_pFontDict->GetDict(FX_BSTRC("Resources"));
     CPDF_Array* pMatrix = m_pFontDict->GetArray(FX_BSTRC("FontMatrix"));
     FX_FLOAT xscale = 1.0f, yscale = 1.0f;
     if (pMatrix) {
@@ skipping 40 matching lines @@
 void CPDF_Type3Font::CheckType3FontMetrics()
 {
     CheckFontMetrics();
 }
 CPDF_Type3Char* CPDF_Type3Font::LoadChar(FX_DWORD charcode, int level)
 {
     if (level >= _FPDF_MAX_TYPE3_FORM_LEVEL_) {
         return NULL;
     }
     CPDF_Type3Char* pChar = NULL;
-    if (m_CacheMap.Lookup((FX_LPVOID)(uintptr_t)charcode, (FX_LPVOID&)pChar)) {
+    if (m_CacheMap.Lookup((void*)(uintptr_t)charcode, (void*&)pChar)) {
         if (pChar->m_bPageRequired && m_pPageResources) {
             delete pChar;
-            m_CacheMap.RemoveKey((FX_LPVOID)(uintptr_t)charcode);
+            m_CacheMap.RemoveKey((void*)(uintptr_t)charcode);
             return LoadChar(charcode, level + 1);
         }
         return pChar;
     }
-    FX_LPCSTR name = GetAdobeCharName(m_BaseEncoding, m_pCharNames, charcode);
+    const FX_CHAR* name = GetAdobeCharName(m_BaseEncoding, m_pCharNames, charcode);
     if (name == NULL) {
         return NULL;
     }
     CPDF_Stream* pStream = (CPDF_Stream*)(m_pCharProcs ? m_pCharProcs->GetElementValue(name) : NULL);
     if (pStream == NULL || pStream->GetType() != PDFOBJ_STREAM) {
         return NULL;
     }
     pChar = new CPDF_Type3Char;
     pChar->m_pForm = new CPDF_Form(m_pDocument, m_pFontResources ? m_pFontResources : m_pPageResources, pStream, NULL);
     pChar->m_pForm->ParseContent(NULL, NULL, pChar, NULL, level + 1);
     FX_FLOAT scale = m_FontMatrix.GetXUnit();
     pChar->m_Width = (int32_t)(pChar->m_Width * scale + 0.5f);
     FX_RECT &rcBBox = pChar->m_BBox;
     CFX_FloatRect char_rect((FX_FLOAT)rcBBox.left / 1000.0f, (FX_FLOAT)rcBBox.bottom / 1000.0f,
                             (FX_FLOAT)rcBBox.right / 1000.0f, (FX_FLOAT)rcBBox.top / 1000.0f);
     if (rcBBox.right <= rcBBox.left || rcBBox.bottom >= rcBBox.top) {
         char_rect = pChar->m_pForm->CalcBoundingBox();
     }
     char_rect.Transform(&m_FontMatrix);
     rcBBox.left = FXSYS_round(char_rect.left * 1000);
     rcBBox.right = FXSYS_round(char_rect.right * 1000);
     rcBBox.top = FXSYS_round(char_rect.top * 1000);
     rcBBox.bottom = FXSYS_round(char_rect.bottom * 1000);
-    m_CacheMap.SetAt((FX_LPVOID)(uintptr_t)charcode, pChar);
+    m_CacheMap.SetAt((void*)(uintptr_t)charcode, pChar);
     if (pChar->m_pForm->CountObjects() == 0) {
         delete pChar->m_pForm;
         pChar->m_pForm = NULL;
     }
     return pChar;
 }
 int CPDF_Type3Font::GetCharWidthF(FX_DWORD charcode, int level)
 {
     if (charcode > 0xff) {
         charcode = 0;
@@ skipping 25 matching lines @@
 }
 CPDF_Type3Char::~CPDF_Type3Char()
 {
     if (m_pForm) {
         delete m_pForm;
     }
     if (m_pBitmap) {
         delete m_pBitmap;
     }
 }