Remove typdefs for pointer types in fx_system.h

core/src/fxge/ge/fx_ge_fontmap.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 <limits>
 
 #include "../../../include/fxge/fx_ge.h"
 #include "../../../include/fxge/fx_freetype.h"
@@ skipping 99 matching lines @@
         FXFT_Face face = m_pExtMapper->FindSubstFont(face_name, bTrueType, flags, weight, italic_angle,
                          CharsetCP, pSubstFont);
         if (face) {
             return face;
         }
     }
     return m_pBuiltinMapper->FindSubstFont(face_name, bTrueType, flags, weight, italic_angle,
                                            CharsetCP, pSubstFont);
 }
 FXFT_Face CFX_FontMgr::GetCachedFace(const CFX_ByteString& face_name,
-                                     int weight, FX_BOOL bItalic, FX_LPBYTE& pFontData)
+                                     int weight, FX_BOOL bItalic, uint8_t*& pFontData)
 {
     CFX_ByteString key(face_name);
     key += ',';
     key += CFX_ByteString::FormatInteger(weight);
     key += bItalic ? 'I' : 'N';
     CTTFontDesc* pFontDesc = NULL;
     m_FaceMap.Lookup(key, (void*&)pFontDesc);
     if(pFontDesc) {
         pFontData = pFontDesc->m_pFontData;
         pFontDesc->m_RefCount ++;
         return pFontDesc->m_SingleFace.m_pFace;
     }
     return NULL;
 }
 FXFT_Face CFX_FontMgr::AddCachedFace(const CFX_ByteString& face_name,
-                                     int weight, FX_BOOL bItalic, FX_LPBYTE pData, FX_DWORD size, int face_index)
+                                     int weight, FX_BOOL bItalic, uint8_t* pData, FX_DWORD size, int face_index)
 {
     CTTFontDesc* pFontDesc = new CTTFontDesc;
     pFontDesc->m_Type = 1;
     pFontDesc->m_SingleFace.m_pFace = NULL;
     pFontDesc->m_SingleFace.m_bBold = weight;
     pFontDesc->m_SingleFace.m_bItalic = bItalic;
     pFontDesc->m_pFontData = pData;
     pFontDesc->m_RefCount = 1;
     FXFT_Library library;
     if (m_FTLibrary == NULL) {
@@ skipping 10 matching lines @@
         delete pFontDesc;
         return NULL;
     }
     CFX_ByteString key(face_name);
     key += ',';
     key += CFX_ByteString::FormatInteger(weight);
     key += bItalic ? 'I' : 'N';
     m_FaceMap.SetAt(key, pFontDesc);
     return pFontDesc->m_SingleFace.m_pFace;
 }
-const FX_LPCSTR g_Base14FontNames[14] = {
+const FX_CHAR* const g_Base14FontNames[14] = {
     "Courier",
     "Courier-Bold",
     "Courier-BoldOblique",
     "Courier-Oblique",
     "Helvetica",
     "Helvetica-Bold",
     "Helvetica-BoldOblique",
     "Helvetica-Oblique",
     "Times-Roman",
     "Times-Bold",
@@ skipping 93 matching lines @@
     {"TimesNewRomanPS-ItalicMT", 11},
     {"TimesNewRomanPSMT", 8},
     {"TimesNewRomanPSMT,Bold", 9},
     {"TimesNewRomanPSMT,BoldItalic", 10},
     {"TimesNewRomanPSMT,Italic", 11},
     {"ZapfDingbats", 13},
 };
 extern "C" {
     static int compareString(const void* key, const void* element)
     {
-        return FXSYS_stricmp((FX_LPCSTR)key, ((_AltFontName*)element)->m_pName);
+        return FXSYS_stricmp((const FX_CHAR*)key, ((_AltFontName*)element)->m_pName);
     }
 }
 int _PDF_GetStandardFontName(CFX_ByteString& name)
 {
     _AltFontName* found = (_AltFontName*)FXSYS_bsearch(name.c_str(), g_AltFontNames,
                           sizeof g_AltFontNames / sizeof (_AltFontName), sizeof (_AltFontName), compareString);
     if (found == NULL) {
         return -1;
     }
     name = g_Base14FontNames[found->m_Index];
     return found->m_Index;
 }
-int GetTTCIndex(FX_LPCBYTE pFontData, FX_DWORD ttc_size, FX_DWORD font_offset)
+int GetTTCIndex(const uint8_t* pFontData, FX_DWORD ttc_size, FX_DWORD font_offset)
 {
     int face_index = 0;
-    FX_LPCBYTE p = pFontData + 8;
+    const uint8_t* p = pFontData + 8;
     FX_DWORD nfont = GET_TT_LONG(p);
     FX_DWORD index;
     for (index = 0; index < nfont; index ++) {
         p = pFontData + 12 + index * 4;
         if (GET_TT_LONG(p) == font_offset) {
             break;
         }
     }
     if(index >= nfont) {
         face_index = 0;
     } else {
         face_index = index;
     }
     return face_index;
 }
 FXFT_Face CFX_FontMgr::GetCachedTTCFace(int ttc_size, FX_DWORD checksum,
-                                        int font_offset, FX_LPBYTE& pFontData)
+                                        int font_offset, uint8_t*& pFontData)
 {
     CFX_ByteString key;
     key.Format("%d:%d", ttc_size, checksum);
     CTTFontDesc* pFontDesc = NULL;
     m_FaceMap.Lookup(key, (void*&)pFontDesc);
     if (pFontDesc == NULL) {
         return NULL;
     }
     pFontData = pFontDesc->m_pFontData;
     pFontDesc->m_RefCount ++;
     int face_index = GetTTCIndex(pFontDesc->m_pFontData, ttc_size, font_offset);
     if (pFontDesc->m_TTCFace.m_pFaces[face_index] == NULL) {
         pFontDesc->m_TTCFace.m_pFaces[face_index] = GetFixedFace(pFontDesc->m_pFontData, ttc_size, face_index);
     }
     return pFontDesc->m_TTCFace.m_pFaces[face_index];
 }
 FXFT_Face CFX_FontMgr::AddCachedTTCFace(int ttc_size, FX_DWORD checksum,
-                                        FX_LPBYTE pData, FX_DWORD size, int font_offset)
+                                        uint8_t* pData, FX_DWORD size, int font_offset)
 {
     CFX_ByteString key;
     key.Format("%d:%d", ttc_size, checksum);
     CTTFontDesc* pFontDesc = new CTTFontDesc;
     pFontDesc->m_Type = 2;
     pFontDesc->m_pFontData = pData;
     for (int i = 0; i < 16; i ++) {
         pFontDesc->m_TTCFace.m_pFaces[i] = NULL;
     }
     pFontDesc->m_RefCount ++;
     key.Format("%d:%d", ttc_size, checksum);
     m_FaceMap.SetAt(key, pFontDesc);
     int face_index = GetTTCIndex(pFontDesc->m_pFontData, ttc_size, font_offset);
     pFontDesc->m_TTCFace.m_pFaces[face_index] = GetFixedFace(pFontDesc->m_pFontData, ttc_size, face_index);
     return pFontDesc->m_TTCFace.m_pFaces[face_index];
 }
-FXFT_Face CFX_FontMgr::GetFixedFace(FX_LPCBYTE pData, FX_DWORD size, int face_index)
+FXFT_Face CFX_FontMgr::GetFixedFace(const uint8_t* pData, FX_DWORD size, int face_index)
 {
     FXFT_Library library;
     if (m_FTLibrary == NULL) {
         FXFT_Init_FreeType(&m_FTLibrary);
     }
     library = m_FTLibrary;
     FXFT_Face face = NULL;
     int ret = FXFT_New_Memory_Face(library, pData, size, face_index, &face);
     if (ret) {
         return NULL;
     }
     ret = FXFT_Set_Pixel_Sizes(face, 64, 64);
     if (ret) {
         return NULL;
     }
     return face;
 }
-FXFT_Face CFX_FontMgr::GetFileFace(FX_LPCSTR filename, int face_index)
+FXFT_Face CFX_FontMgr::GetFileFace(const FX_CHAR* filename, int face_index)
 {
     FXFT_Library library;
     if (m_FTLibrary == NULL) {
         FXFT_Init_FreeType(&m_FTLibrary);
     }
     library = m_FTLibrary;
     FXFT_Face face = NULL;
     int ret = FXFT_New_Face(library, filename, face_index, &face);
     if (ret) {
         return NULL;
@@ skipping 46 matching lines @@
     {g_FoxitSansBoldFontData, 16344},
     {g_FoxitSansBoldItalicFontData, 16418},
     {g_FoxitSansItalicFontData, 16339},
     {g_FoxitSerifFontData, 19469},
     {g_FoxitSerifBoldFontData, 19395},
     {g_FoxitSerifBoldItalicFontData, 20733},
     {g_FoxitSerifItalicFontData, 21227},
     {g_FoxitSymbolFontData, 16729},
     {g_FoxitDingbatsFontData, 29513},
 };
-void _FPDFAPI_GetInternalFontData(int id, FX_LPCBYTE& data, FX_DWORD& size)
+void _FPDFAPI_GetInternalFontData(int id, const uint8_t*& data, FX_DWORD& size)
 {
     CFX_GEModule::Get()->GetFontMgr()->GetStandardFont(data, size, id);
 }
-FX_BOOL CFX_FontMgr::GetStandardFont(FX_LPCBYTE& pFontData, FX_DWORD& size, int index)
+FX_BOOL CFX_FontMgr::GetStandardFont(const uint8_t*& pFontData, FX_DWORD& size, int index)
 {
     if (index > 15 || index < 0) {
         return FALSE;
     }
     {
         if (index >= 14) {
             if (index == 14) {
                 pFontData = g_FoxitSerifMMFontData;
                 size = 113417;
             } else {
@@ skipping 34 matching lines @@
 void CFX_FontMapper::SetSystemFontInfo(IFX_SystemFontInfo* pFontInfo)
 {
     if (pFontInfo == NULL) {
         return;
     }
     if (m_pFontInfo) {
         m_pFontInfo->Release();
     }
     m_pFontInfo = pFontInfo;
 }
-static CFX_ByteString _TT_NormalizeName(FX_LPCSTR family)
+static CFX_ByteString _TT_NormalizeName(const FX_CHAR* family)
 {
     CFX_ByteString norm(family, -1);
     norm.Remove(' ');
     norm.Remove('-');
     norm.Remove(',');
     int pos = norm.Find('+');
     if (pos > 0) {
         norm = norm.Left(pos);
     }
     norm.MakeLower();
     return norm;
 }
-CFX_ByteString _FPDF_GetNameFromTT(FX_LPCBYTE name_table, FX_DWORD name_id)
+CFX_ByteString _FPDF_GetNameFromTT(const uint8_t* name_table, FX_DWORD name_id)
 {
-    FX_LPCBYTE ptr = name_table + 2;
+    const uint8_t* ptr = name_table + 2;
     int name_count = GET_TT_SHORT(ptr);
     int string_offset = GET_TT_SHORT(ptr + 2);
-    FX_LPCBYTE string_ptr = name_table + string_offset;
+    const uint8_t* string_ptr = name_table + string_offset;
     ptr += 4;
     for (int i = 0; i < name_count; i ++) {
         if (GET_TT_SHORT(ptr + 6) == name_id && GET_TT_SHORT(ptr) == 1 && GET_TT_SHORT(ptr + 2) == 0) {
             return CFX_ByteStringC(string_ptr + GET_TT_SHORT(ptr + 10), GET_TT_SHORT(ptr + 8));
         }
         ptr += 12;
     }
     return CFX_ByteString();
 }
 static CFX_ByteString _FPDF_ReadStringFromFile(FXSYS_FILE* pFile, FX_DWORD size)
 {
     CFX_ByteString buffer;
     if (!FXSYS_fread(buffer.GetBuffer(size), size, 1, pFile)) {
         return CFX_ByteString();
     }
     buffer.ReleaseBuffer(size);
     return buffer;
 }
-CFX_ByteString _FPDF_LoadTableFromTT(FXSYS_FILE* pFile, FX_LPCBYTE pTables, FX_DWORD nTables, FX_DWORD tag)
+CFX_ByteString _FPDF_LoadTableFromTT(FXSYS_FILE* pFile, const uint8_t* pTables, FX_DWORD nTables, FX_DWORD tag)
 {
     for (FX_DWORD i = 0; i < nTables; i ++) {
-        FX_LPCBYTE p = pTables + i * 16;
+        const uint8_t* p = pTables + i * 16;
         if (GET_TT_LONG(p) == tag) {
             FX_DWORD offset = GET_TT_LONG(p + 8);
             FX_DWORD size = GET_TT_LONG(p + 12);
             FXSYS_fseek(pFile, offset, FXSYS_SEEK_SET);
             return _FPDF_ReadStringFromFile(pFile, size);
         }
     }
     return CFX_ByteString();
 }
-CFX_ByteString _FPDF_LoadTableFromTTStreamFile(IFX_FileStream* pFile, FX_LPCBYTE pTables, FX_DWORD nTables, FX_DWORD tag)
+CFX_ByteString _FPDF_LoadTableFromTTStreamFile(IFX_FileStream* pFile, const uint8_t* pTables, FX_DWORD nTables, FX_DWORD tag)
 {
     for (FX_DWORD i = 0; i < nTables; i ++) {
-        FX_LPCBYTE p = pTables + i * 16;
+        const uint8_t* p = pTables + i * 16;
         if (GET_TT_LONG(p) == tag) {
             FX_DWORD offset = GET_TT_LONG(p + 8);
             FX_DWORD size = GET_TT_LONG(p + 12);
             CFX_ByteString buffer;
             if (!pFile->ReadBlock(buffer.GetBuffer(size), offset, size)) {
                 return CFX_ByteString();
             }
             buffer.ReleaseBuffer(size);
             return buffer;
         }
     }
     return CFX_ByteString();
 }
 CFX_ByteString CFX_FontMapper::GetPSNameFromTT(void* hFont)
 {
     if (m_pFontInfo == NULL) {
         CFX_ByteString();
     }
     CFX_ByteString result;
     FX_DWORD size = m_pFontInfo->GetFontData(hFont, 0x6e616d65, NULL, 0);
     if (size) {
-        FX_LPBYTE buffer = FX_Alloc(uint8_t, size);
+        uint8_t* buffer = FX_Alloc(uint8_t, size);
         m_pFontInfo->GetFontData(hFont, 0x6e616d65, buffer, size);
         result = _FPDF_GetNameFromTT(buffer, 6);
         FX_Free(buffer);
     }
     return result;
 }
 void CFX_FontMapper::AddInstalledFont(const CFX_ByteString& name, int charset)
 {
     if (m_pFontInfo == NULL) {
         return;
     }
     if (m_CharsetArray.Find((FX_DWORD)charset) == -1) {
         m_CharsetArray.Add((FX_DWORD)charset);
         m_FaceArray.Add(name);
     }
     if (name == m_LastFamily) {
         return;
     }
-    FX_LPCBYTE ptr = name;
+    const uint8_t* ptr = name;
     FX_BOOL bLocalized = FALSE;
     for (int i = 0; i < name.GetLength(); i ++)
         if (ptr[i] > 0x80) {
             bLocalized = TRUE;
             break;
         }
     if (bLocalized) {
         void* hFont = m_pFontInfo->GetFont(name);
         if (hFont == NULL) {
             FX_BOOL bExact;
@@ skipping 139 matching lines @@
         return 1 << 31;
     }
     return 1 << 21;
 }
 FXFT_Face CFX_FontMapper::UseInternalSubst(CFX_SubstFont* pSubstFont, int iBaseFont, int italic_angle, int weight, int picthfamily)
 {
     if (iBaseFont < 12) {
         if (m_FoxitFaces[iBaseFont]) {
             return m_FoxitFaces[iBaseFont];
         }
-        FX_LPCBYTE pFontData = NULL;
+        const uint8_t* pFontData = NULL;
         FX_DWORD size = 0;
         if (m_pFontMgr->GetStandardFont(pFontData, size, iBaseFont)) {
             m_FoxitFaces[iBaseFont] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
             return m_FoxitFaces[iBaseFont];
         }
     }
     pSubstFont->m_SubstFlags |= FXFONT_SUBST_MM;
     pSubstFont->m_ItalicAngle = italic_angle;
     if (weight) {
         pSubstFont->m_Weight = weight;
     }
     if (picthfamily & FXFONT_FF_ROMAN) {
         pSubstFont->m_Weight = pSubstFont->m_Weight * 4 / 5;
         pSubstFont->m_Family = "Chrome Serif";
         if (m_MMFaces[1]) {
             return m_MMFaces[1];
         }
-        FX_LPCBYTE pFontData = NULL;
+        const uint8_t* pFontData = NULL;
         FX_DWORD size;
         m_pFontMgr->GetStandardFont(pFontData, size, 14);
         m_MMFaces[1] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
         return m_MMFaces[1];
     }
     pSubstFont->m_Family = "Chrome Sans";
     if (m_MMFaces[0]) {
         return m_MMFaces[0];
     }
-    FX_LPCBYTE pFontData = NULL;
+    const uint8_t* pFontData = NULL;
     FX_DWORD size = 0;
     m_pFontMgr->GetStandardFont(pFontData, size, 15);
     m_MMFaces[0] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
     return m_MMFaces[0];
 }
 const struct _AltFontFamily {
-    FX_LPCSTR m_pFontName;
-    FX_LPCSTR m_pFontFamily;
+    const FX_CHAR* m_pFontName;
+    const FX_CHAR* m_pFontFamily;
 }
 g_AltFontFamilies[] = {
     {"AGaramondPro", "Adobe Garamond Pro"},
     {"BankGothicBT-Medium", "BankGothic Md BT"},
     {"ForteMT", "Forte"},
 };
 extern "C" {
     static int compareFontFamilyString(const void* key, const void* element)
     {
-        CFX_ByteString str_key((FX_LPCSTR)key);
+        CFX_ByteString str_key((const FX_CHAR*)key);
         if (str_key.Find(((_AltFontFamily*)element)->m_pFontName) != -1) {
             return 0;
         }
-        return FXSYS_stricmp((FX_LPCSTR)key, ((_AltFontFamily*)element)->m_pFontName);
+        return FXSYS_stricmp((const FX_CHAR*)key, ((_AltFontFamily*)element)->m_pFontName);
     }
 }
 #define FX_FONT_STYLE_None              0x00
 #define FX_FONT_STYLE_Bold              0x01
 #define FX_FONT_STYLE_Italic    0x02
 #define FX_FONT_STYLE_BoldBold  0x04
 static CFX_ByteString _GetFontFamily(CFX_ByteString fontName, int nStyle)
 {
     if (fontName.Find("Script") >= 0) {
         if ((nStyle & FX_FONT_STYLE_Bold) == FX_FONT_STYLE_Bold) {
             fontName = "ScriptMTBold";
         } else if (fontName.Find("Palace") >= 0) {
             fontName = "PalaceScriptMT";
         } else if (fontName.Find("French") >= 0) {
             fontName = "FrenchScriptMT";
         } else if (fontName.Find("FreeStyle") >= 0) {
             fontName = "FreeStyleScript";
         }
         return fontName;
     }
     _AltFontFamily* found = (_AltFontFamily*)FXSYS_bsearch(fontName.c_str(), g_AltFontFamilies,
                             sizeof g_AltFontFamilies / sizeof (_AltFontFamily), sizeof (_AltFontFamily), compareFontFamilyString);
     if (found == NULL) {
         return fontName;
     }
     return found->m_pFontFamily;
 };
 typedef struct _FX_FontStyle {
-    FX_LPCSTR style;
+    const FX_CHAR* style;
     int32_t len;
 } FX_FontStyle;
 const FX_FontStyle g_FontStyles[] = {
   { "Bold", 4 },
   { "Italic", 6 },
   { "BoldItalic", 10 },
   { "Reg", 3 },
   { "Regular", 7 },
 };
-CFX_ByteString ParseStyle(FX_LPCSTR pStyle, int iLen, int iIndex)
+CFX_ByteString ParseStyle(const FX_CHAR* pStyle, int iLen, int iIndex)
 {
     CFX_ByteTextBuf buf;
     if (!iLen || iLen <= iIndex) {
         return buf.GetByteString();
     }
     while (iIndex < iLen) {
         if (pStyle[iIndex] == ',') {
             break;
         }
         buf.AppendChar(pStyle[iIndex]);
@@ skipping 49 matching lines @@
         }
     }
     _PDF_GetStandardFontName(SubstName);
     if (SubstName == FX_BSTRC("Symbol") && !bTrueType) {
         pSubstFont->m_Family = "Chrome Symbol";
         pSubstFont->m_Charset = FXFONT_SYMBOL_CHARSET;
         pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
         if (m_FoxitFaces[12]) {
             return m_FoxitFaces[12];
         }
-        FX_LPCBYTE pFontData = NULL;
+        const uint8_t* pFontData = NULL;
         FX_DWORD size = 0;
         m_pFontMgr->GetStandardFont(pFontData, size, 12);
         m_FoxitFaces[12] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
         return m_FoxitFaces[12];
     }
     if (SubstName == FX_BSTRC("ZapfDingbats")) {
         pSubstFont->m_Family = "Chrome Dingbats";
         pSubstFont->m_Charset = FXFONT_SYMBOL_CHARSET;
         pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
         if (m_FoxitFaces[13]) {
             return m_FoxitFaces[13];
         }
-        FX_LPCBYTE pFontData = NULL;
+        const uint8_t* pFontData = NULL;
         FX_DWORD size = 0;
         m_pFontMgr->GetStandardFont(pFontData, size, 13);
         m_FoxitFaces[13] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
         return m_FoxitFaces[13];
     }
     int iBaseFont = 0;
     CFX_ByteString family, style;
     FX_BOOL     bHasComma = FALSE;
     FX_BOOL bHasHypen = FALSE;
     int find = SubstName.Find(FX_BSTRC(","), 0);
@@ skipping 57 matching lines @@
         }
         if (flags & FXFONT_SCRIPT) {
             PitchFamily |= FXFONT_FF_SCRIPT;
         }
         if (flags & FXFONT_FIXED_PITCH) {
             PitchFamily |= FXFONT_FF_FIXEDPITCH;
         }
     }
     if (!style.IsEmpty()) {
         int nLen = style.GetLength();
-        FX_LPCSTR pStyle = style;
+        const FX_CHAR* pStyle = style;
         int i = 0;
         FX_BOOL bFirstItem = TRUE;
         CFX_ByteString buf;
         while (i < nLen) {
             buf = ParseStyle(pStyle, nLen, i);
             int32_t nRet = GetStyleType(buf, FALSE);
             if ((i && !bStyleAvail) || (!i && nRet < 0)) {
                 family = SubstName;
                 iBaseFont = 12;
                 break;
@@ skipping 141 matching lines @@
         } else {
             if (Charset == FXFONT_SYMBOL_CHARSET) {
 #if _FXM_PLATFORM_  == _FXM_PLATFORM_APPLE_ || _FXM_PLATFORM_  == _FXM_PLATFORM_ANDROID_
                 if (SubstName == FX_BSTRC("Symbol")) {
                     pSubstFont->m_Family = "Chrome Symbol";
                     pSubstFont->m_SubstFlags |= FXFONT_SUBST_STANDARD;
                     pSubstFont->m_Charset = FXFONT_SYMBOL_CHARSET;
                     if (m_FoxitFaces[12]) {
                         return m_FoxitFaces[12];
                     }
-                    FX_LPCBYTE pFontData = NULL;
+                    const uint8_t* pFontData = NULL;
                     FX_DWORD size = 0;
                     m_pFontMgr->GetStandardFont(pFontData, size, 12);
                     m_FoxitFaces[12] = m_pFontMgr->GetFixedFace(pFontData, size, 0);
                     return m_FoxitFaces[12];
                 } else {
                     pSubstFont->m_SubstFlags |= FXFONT_SUBST_NONSYMBOL;
                     return FindSubstFont(family, bTrueType, flags & ~FXFONT_SYMBOLIC, weight, italic_angle, 0, pSubstFont);
                 }
 #else
                 pSubstFont->m_SubstFlags |= FXFONT_SUBST_NONSYMBOL;
@@ skipping 27 matching lines @@
         return NULL;
     }
     FXFT_Face face = NULL;
     if (ttc_size) {
         uint8_t temp[1024];
         m_pFontInfo->GetFontData(hFont, 0x74746366, temp, 1024);
         FX_DWORD checksum = 0;
         for (int i = 0; i < 256; i ++) {
             checksum += ((FX_DWORD*)temp)[i];
         }
-        FX_LPBYTE pFontData;
+        uint8_t* pFontData;
         face = m_pFontMgr->GetCachedTTCFace(ttc_size, checksum, ttc_size - font_size, pFontData);
         if (face == NULL) {
             pFontData = FX_Alloc(uint8_t, ttc_size);
             m_pFontInfo->GetFontData(hFont, 0x74746366, pFontData, ttc_size);
             face = m_pFontMgr->AddCachedTTCFace(ttc_size, checksum, pFontData, ttc_size,
                                                 ttc_size - font_size);
         }
     } else {
-        FX_LPBYTE pFontData;
+        uint8_t* pFontData;
         face = m_pFontMgr->GetCachedFace(SubstName, weight, bItalic, pFontData);
         if (face == NULL) {
             pFontData = FX_Alloc(uint8_t, font_size);
             m_pFontInfo->GetFontData(hFont, 0, pFontData, font_size);
             face = m_pFontMgr->AddCachedFace(SubstName, weight, bItalic, pFontData, font_size, m_pFontInfo->GetFaceIndex(hFont));
         }
     }
     if (face == NULL) {
         m_pFontInfo->DeleteFont(hFont);
         return NULL;
@@ skipping 59 matching lines @@
 }
 #endif
 CFX_FolderFontInfo::CFX_FolderFontInfo()
 {
 }
 CFX_FolderFontInfo::~CFX_FolderFontInfo()
 {
     FX_POSITION pos = m_FontList.GetStartPosition();
     while (pos) {
         CFX_ByteString key;
-        FX_LPVOID value;
+        void* value;
         m_FontList.GetNextAssoc(pos, key, value);
         delete (CFontFaceInfo*)value;
     }
 }
 void CFX_FolderFontInfo::AddPath(FX_BSTR path)
 {
     m_PathList.Add(path);
 }
 void CFX_FolderFontInfo::Release()
 {
@@ skipping 58 matching lines @@
         return;
     }
 
     if (GET_TT_LONG(buffer) == 0x74746366) {
         FX_DWORD nFaces = GET_TT_LONG(buffer + 8);
         if (nFaces > std::numeric_limits<FX_DWORD>::max() / 4) {
             FXSYS_fclose(pFile);
             return;
         }
         FX_DWORD face_bytes = nFaces * 4;
-        FX_LPBYTE offsets = FX_Alloc(uint8_t, face_bytes);
+        uint8_t* offsets = FX_Alloc(uint8_t, face_bytes);
         readCnt = FXSYS_fread(offsets, face_bytes, 1, pFile);
         if (readCnt != face_bytes) {
             FX_Free(offsets);
             FXSYS_fclose(pFile);
             return;
         }
         for (FX_DWORD i = 0; i < nFaces; i ++) {
-            FX_LPBYTE p = offsets + i * 4;
+            uint8_t* p = offsets + i * 4;
             ReportFace(path, pFile, filesize, GET_TT_LONG(p));
         }
         FX_Free(offsets);
     } else {
         ReportFace(path, pFile, filesize, 0);
     }
     FXSYS_fclose(pFile);
 }
 void CFX_FolderFontInfo::ReportFace(CFX_ByteString& path, FXSYS_FILE* pFile, FX_DWORD filesize, FX_DWORD offset)
 {
     FXSYS_fseek(pFile, offset, FXSYS_SEEK_SET);
     char buffer[16];
     if (!FXSYS_fread(buffer, 12, 1, pFile)) {
         return;
     }
     FX_DWORD nTables = GET_TT_SHORT(buffer + 4);
     CFX_ByteString tables = _FPDF_ReadStringFromFile(pFile, nTables * 16);
     if (tables.IsEmpty()) {
         return;
     }
     CFX_ByteString names = _FPDF_LoadTableFromTT(pFile, tables, nTables, 0x6e616d65);
     CFX_ByteString facename = _FPDF_GetNameFromTT(names, 1);
     CFX_ByteString style = _FPDF_GetNameFromTT(names, 2);
     if (style != "Regular") {
         facename += " " + style;
     }
-    FX_LPVOID p;
+    void* p;
     if (m_FontList.Lookup(facename, p)) {
         return;
     }
     CFontFaceInfo* pInfo = new CFontFaceInfo;
     pInfo->m_FilePath = path;
     pInfo->m_FaceName = facename;
     pInfo->m_FontTables = tables;
     pInfo->m_FontOffset = offset;
     pInfo->m_FileSize = filesize;
     pInfo->m_Charsets = 0;
     CFX_ByteString os2 = _FPDF_LoadTableFromTT(pFile, tables, nTables, 0x4f532f32);
     if (os2.GetLength() >= 86) {
-        FX_LPCBYTE p = (FX_LPCBYTE)os2 + 78;
+        const uint8_t* p = (const uint8_t*)os2 + 78;
         FX_DWORD codepages = GET_TT_LONG(p);
         if (codepages & (1 << 17)) {
             m_pMapper->AddInstalledFont(facename, FXFONT_SHIFTJIS_CHARSET);
             pInfo->m_Charsets |= CHARSET_FLAG_SHIFTJIS;
         }
         if (codepages & (1 << 18)) {
             m_pMapper->AddInstalledFont(facename, FXFONT_GB2312_CHARSET);
             pInfo->m_Charsets |= CHARSET_FLAG_GB;
         }
         if (codepages & (1 << 20)) {
@@ skipping 16 matching lines @@
         pInfo->m_Styles |= FXFONT_BOLD;
     }
     if (style.Find(FX_BSTRC("Italic")) > -1 || style.Find(FX_BSTRC("Oblique")) > -1) {
         pInfo->m_Styles |= FXFONT_ITALIC;
     }
     if (facename.Find(FX_BSTRC("Serif")) > -1) {
         pInfo->m_Styles |= FXFONT_SERIF;
     }
     m_FontList.SetAt(facename, pInfo);
 }
-void* CFX_FolderFontInfo::MapFont(int weight, FX_BOOL bItalic, int charset, int pitch_family, FX_LPCSTR family, FX_BOOL& bExact)
+void* CFX_FolderFontInfo::MapFont(int weight, FX_BOOL bItalic, int charset, int pitch_family, const FX_CHAR* family, FX_BOOL& bExact)
 {
     return NULL;
 }
-void* CFX_FolderFontInfo::GetFont(FX_LPCSTR face)
+void* CFX_FolderFontInfo::GetFont(const FX_CHAR* face)
 {
-    FX_LPVOID p;
+    void* p;
     if (!m_FontList.Lookup(face, p)) {
         return NULL;
     }
     return p;
 }
-FX_DWORD CFX_FolderFontInfo::GetFontData(void* hFont, FX_DWORD table, FX_LPBYTE buffer, FX_DWORD size)
+FX_DWORD CFX_FolderFontInfo::GetFontData(void* hFont, FX_DWORD table, uint8_t* buffer, FX_DWORD size)
 {
     if (hFont == NULL) {
         return 0;
     }
     CFontFaceInfo* pFont = (CFontFaceInfo*)hFont;
     FXSYS_FILE* pFile = NULL;
     if (size > 0) {
         pFile = FXSYS_fopen(pFont->m_FilePath, "rb");
         if (pFile == NULL) {
             return 0;
         }
     }
     FX_DWORD datasize = 0;
     FX_DWORD offset;
     if (table == 0)     {
         datasize = pFont->m_FontOffset ? 0 : pFont->m_FileSize;
         offset = 0;
     } else if (table == 0x74746366)     {
         datasize = pFont->m_FontOffset ? pFont->m_FileSize : 0;
         offset = 0;
     } else {
         FX_DWORD nTables = pFont->m_FontTables.GetLength() / 16;
         for (FX_DWORD i = 0; i < nTables; i ++) {
-            FX_LPCBYTE p = (FX_LPCBYTE)pFont->m_FontTables + i * 16;
+            const uint8_t* p = (const uint8_t*)pFont->m_FontTables + i * 16;
             if (GET_TT_LONG(p) == table) {
                 offset = GET_TT_LONG(p + 8);
                 datasize = GET_TT_LONG(p + 12);
             }
         }
     }
     if (datasize && size >= datasize && pFile) {
         FXSYS_fseek(pFile, offset, FXSYS_SEEK_SET);
         FXSYS_fread(buffer, datasize, 1, pFile);
     }
@@ skipping 11 matching lines @@
         return FALSE;
     }
     CFontFaceInfo* pFont = (CFontFaceInfo*)hFont;
     name = pFont->m_FaceName;
     return TRUE;
 }
 FX_BOOL CFX_FolderFontInfo::GetFontCharset(void* hFont, int& charset)
 {
     return FALSE;
 }