Use stdint.h types throughout PDFium.

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 547 matching lines @@
     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(FX_BYTE, size);
+        FX_LPBYTE 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;
@@ skipping 58 matching lines @@
     if (i < 0) {
         return CFX_ByteString();
     }
     CFX_ByteString match = m_InstalledTTFonts[i];
     if (match[0] == ' ') {
         match = m_InstalledTTFonts[i + 1];
     }
     return match;
 }
 typedef struct _CHARSET_MAP_ {
-    FX_BYTE charset;
+    uint8_t charset;
     FX_WORD codepage;
 } CHARSET_MAP;
 static const CHARSET_MAP g_Codepage2CharsetTable[] = {
     { 1  , 0    },
     { 2  , 42   },
     { 254, 437  },
     { 255, 850  },
     { 222, 874  },
     { 128, 932  },
     { 134, 936  },
@@ skipping 15 matching lines @@
     { 80, 10008 },
     { 81, 10002 },
     { 83, 10005 },
     { 84, 10004 },
     { 85, 10006 },
     { 86, 10081 },
     { 87, 10021 },
     { 88, 10029 },
     { 89, 10007 },
 };
-FX_BYTE _GetCharsetFromCodePage(FX_WORD codepage)
+uint8_t _GetCharsetFromCodePage(FX_WORD codepage)
 {
-    FX_INT32 iEnd = sizeof(g_Codepage2CharsetTable) / sizeof(CHARSET_MAP) - 1;
+    int32_t iEnd = sizeof(g_Codepage2CharsetTable) / sizeof(CHARSET_MAP) - 1;
     FXSYS_assert(iEnd >= 0);
-    FX_INT32 iStart = 0, iMid;
+    int32_t iStart = 0, iMid;
     do {
         iMid = (iStart + iEnd) / 2;
         const CHARSET_MAP & cp = g_Codepage2CharsetTable[iMid];
         if (codepage == cp.codepage) {
             return cp.charset;
         } else if (codepage < cp.codepage) {
             iEnd = iMid - 1;
         } else {
             iStart = iMid + 1;
         }
@@ skipping 119 matching lines @@
     }
     _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;
-    FX_INT32 len;
+    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_ByteTextBuf buf;
     if (!iLen || iLen <= iIndex) {
         return buf.GetByteString();
     }
     while (iIndex < iLen) {
         if (pStyle[iIndex] == ',') {
             break;
         }
         buf.AppendChar(pStyle[iIndex]);
         ++iIndex;
     }
     return buf.GetByteString();
 }
-FX_INT32 GetStyleType(const CFX_ByteString &bsStyle, FX_BOOL bRevert)
+int32_t GetStyleType(const CFX_ByteString &bsStyle, FX_BOOL bRevert)
 {
-    FX_INT32 iLen = bsStyle.GetLength();
+    int32_t iLen = bsStyle.GetLength();
     if (!iLen) {
         return -1;
     }
     int iSize = sizeof(g_FontStyles) / sizeof(FX_FontStyle);
     const FX_FontStyle *pStyle = NULL;
     for (int i = iSize - 1; i >= 0; --i) {
         pStyle = g_FontStyles + i;
         if (!pStyle || pStyle->len > iLen) {
             continue;
         }
@@ skipping 97 matching lines @@
         if (!bHasComma) {
             find = family.ReverseFind('-');
             if (find >= 0) {
                 style = family.Mid(find + 1);
                 family = family.Left(find);
                 bHasHypen = TRUE;
             }
         }
         if (!bHasHypen) {
             int nLen = family.GetLength();
-            FX_INT32 nRet = GetStyleType(family, TRUE);
+            int32_t nRet = GetStyleType(family, TRUE);
             if (nRet > -1) {
                 family = family.Left(nLen - g_FontStyles[nRet].len);
                 if (nRet == 0) {
                     nStyle |= FX_FONT_STYLE_Bold;
                 }
                 if (nRet == 1) {
                     nStyle |= FX_FONT_STYLE_Italic;
                 }
                 if (nRet == 2) {
                     nStyle |= (FX_FONT_STYLE_Bold | FX_FONT_STYLE_Italic);
@@ skipping 11 matching lines @@
         }
     }
     if (!style.IsEmpty()) {
         int nLen = style.GetLength();
         FX_LPCSTR pStyle = style;
         int i = 0;
         FX_BOOL bFirstItem = TRUE;
         CFX_ByteString buf;
         while (i < nLen) {
             buf = ParseStyle(pStyle, nLen, i);
-            FX_INT32 nRet = GetStyleType(buf, FALSE);
+            int32_t nRet = GetStyleType(buf, FALSE);
             if ((i && !bStyleAvail) || (!i && nRet < 0)) {
                 family = SubstName;
                 iBaseFont = 12;
                 break;
             } else if (nRet >= 0) {
                 bStyleAvail = TRUE;
             }
             if (nRet == 0) {
                 if (nStyle & FX_FONT_STYLE_Bold) {
                     nStyle |= FX_FONT_STYLE_BoldBold;
@@ skipping 177 matching lines @@
         m_pFontInfo->GetFontCharset(hFont, Charset);
     }
     FX_DWORD ttc_size = m_pFontInfo->GetFontData(hFont, 0x74746366, NULL, 0);
     FX_DWORD font_size = m_pFontInfo->GetFontData(hFont, 0, NULL, 0);
     if(font_size == 0 && ttc_size == 0) {
         m_pFontInfo->DeleteFont(hFont);
         return NULL;
     }
     FXFT_Face face = NULL;
     if (ttc_size) {
-        FX_BYTE temp[1024];
+        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;
         face = m_pFontMgr->GetCachedTTCFace(ttc_size, checksum, ttc_size - font_size, pFontData);
         if (face == NULL) {
-            pFontData = FX_Alloc(FX_BYTE, ttc_size);
+            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;
         face = m_pFontMgr->GetCachedFace(SubstName, weight, bItalic, pFontData);
         if (face == NULL) {
-            pFontData = FX_Alloc(FX_BYTE, font_size);
+            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;
     }
     pSubstFont->m_Family = SubstName;
     pSubstFont->m_Charset = Charset;
@@ skipping 120 matching lines @@
     FX_CloseFolder(handle);
 }
 void CFX_FolderFontInfo::ScanFile(CFX_ByteString& path)
 {
     FXSYS_FILE* pFile = FXSYS_fopen(path, "rb");
     if (pFile == NULL) {
         return;
     }
     FXSYS_fseek(pFile, 0, FXSYS_SEEK_END);
     FX_DWORD filesize = FXSYS_ftell(pFile);
-    FX_BYTE buffer[16];
+    uint8_t buffer[16];
     FXSYS_fseek(pFile, 0, FXSYS_SEEK_SET);
     size_t readCnt = FXSYS_fread(buffer, 12, 1, pFile);
     if (readCnt != 1) {
         FXSYS_fclose(pFile);
         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(FX_BYTE, face_bytes);
+        FX_LPBYTE 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;
             ReportFace(path, pFile, filesize, GET_TT_LONG(p));
         }
@@ skipping 132 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;
 }