Use stdint.h types throughout PDFium.

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 394 matching lines @@
     }
     CPDF_Dictionary* pDict = CPDF_Dictionary::Create();
     pDict->SetAtName(FX_BSTRC("Type"), FX_BSTRC("Font"));
     pDict->SetAtName(FX_BSTRC("Subtype"), FX_BSTRC("Type1"));
     pDict->SetAtName(FX_BSTRC("BaseFont"), fontname);
     pDict->SetAtName(FX_BSTRC("Encoding"), FX_BSTRC("WinAnsiEncoding"));
     pFont = CPDF_Font::CreateFontF(NULL, pDict);
     pFontGlobals->Set(pDoc, font_id, pFont);
     return pFont;
 }
-const FX_BYTE ChineseFontNames[][5] = {
+const uint8_t ChineseFontNames[][5] = {
     {0xCB, 0xCE, 0xCC, 0xE5, 0x00},
     {0xBF, 0xAC, 0xCC, 0xE5, 0x00},
     {0xBA, 0xDA, 0xCC, 0xE5, 0x00},
     {0xB7, 0xC2, 0xCB, 0xCE, 0x00},
     {0xD0, 0xC2, 0xCB, 0xCE, 0x00}
 };
 CPDF_Font* CPDF_Font::CreateFontF(CPDF_Document* pDoc, CPDF_Dictionary* pFontDict)
 {
     CFX_ByteString type = pFontDict->GetString(FX_BSTRC("Subtype"));
     CPDF_Font* pFont;
@@ skipping 383 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, FX_BYTE charcode);
+extern FX_LPCSTR 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()
 {
     delete[] m_pCharNames;
 }
 int CPDF_SimpleFont::GlyphFromCharCode(FX_DWORD charcode, FX_BOOL *pVertGlyph)
 {
     if (pVertGlyph) {
         *pVertGlyph = FALSE;
     }
     if (charcode > 0xff) {
         return -1;
     }
-    int index = m_GlyphIndex[(FX_BYTE)charcode];
+    int index = m_GlyphIndex[(uint8_t)charcode];
     if (index == 0xffff) {
         return -1;
     }
     return index;
 }
 void CPDF_SimpleFont::LoadCharMetrics(int charcode)
 {
     if (m_Font.m_Face == NULL) {
         return;
     }
@@ skipping 33 matching lines @@
 {
     if (charcode > 0xff) {
         charcode = 0;
     }
     if (m_CharWidth[charcode] == 0xffff) {
         LoadCharMetrics(charcode);
         if (m_CharWidth[charcode] == 0xffff) {
             m_CharWidth[charcode] = 0;
         }
     }
-    return (FX_INT16)m_CharWidth[charcode];
+    return (int16_t)m_CharWidth[charcode];
 }
 void CPDF_SimpleFont::GetCharBBox(FX_DWORD charcode, FX_RECT& rect, int level)
 {
     if (charcode > 0xff) {
         charcode = 0;
     }
-    if (m_CharBBox[charcode].Left == (FX_SHORT)0xffff) {
+    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)
 {
     ASSERT(charcode >= 0 && charcode < 256);
@@ skipping 153 matching lines @@
 }
 extern FX_WCHAR FT_UnicodeFromCharCode(int encoding, FX_DWORD charcode);
 #if _FXM_PLATFORM_  == _FXM_PLATFORM_APPLE_
 #include "../../fxge/apple/apple_int.h"
 #endif
 int CPDF_Type1Font::GlyphFromCharCodeExt(FX_DWORD charcode)
 {
     if (charcode > 0xff) {
         return -1;
     }
-    int index = m_ExtGID[(FX_BYTE)charcode];
+    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;
 };
@@ skipping 36 matching lines @@
         m_Font.m_pPlatformFont = quartz2d.CreateFont(m_Font.m_pFontData, m_Font.m_dwSize);
         if (NULL == m_Font.m_pPlatformFont) {
             bCoreText = FALSE;
         }
     }
 #endif
     if (!IsEmbedded() && (m_Base14Font < 12) && m_Font.IsTTFont()) {
         if (FT_UseTTCharmap(m_Font.m_Face, 3, 0)) {
             FX_BOOL bGotOne = FALSE;
             for (int charcode = 0; charcode < 256; charcode ++) {
-                const FX_BYTE prefix[4] = {0x00, 0xf0, 0xf1, 0xf2};
+                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);
 #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);
                     m_ExtGID[charcode] = CGFontGetGlyphWithGlyphName((CGFontRef)m_Font.m_pPlatformFont, name_ct);
                     if (name_ct) {
@@ skipping 331 matching lines @@
         }
         FX_BOOL bToUnicode = m_pFontDict->KeyExist(FX_BSTRC("ToUnicode"));
         for (int charcode = 0; charcode < 256; charcode ++) {
             FX_LPCSTR 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 FX_BYTE prefix[4] = {0x00, 0xf0, 0xf1, 0xf2};
+                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);
                     if (m_GlyphIndex[charcode]) {
                         break;
                     }
                 }
             } else if (m_Encoding.m_Unicodes[charcode]) {
                 if (bMSUnicode) {
                     m_GlyphIndex[charcode] = FXFT_Get_Char_Index(m_Font.m_Face, m_Encoding.m_Unicodes[charcode]);
@@ skipping 22 matching lines @@
                         if (m_GlyphIndex[charcode] == 0) {
                             m_GlyphIndex[charcode] = FXFT_Get_Char_Index(m_Font.m_Face, charcode);
                         }
                     }
                 }
             }
         }
         return;
     }
     if (FT_UseTTCharmap(m_Font.m_Face, 3, 0)) {
-        const FX_BYTE prefix[4] = {0x00, 0xf0, 0xf1, 0xf2};
+        const uint8_t prefix[4] = {0x00, 0xf0, 0xf1, 0xf2};
         FX_BOOL bGotOne = FALSE;
         for (int charcode = 0; charcode < 256; charcode ++) {
             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);
                 if (m_GlyphIndex[charcode]) {
                     bGotOne = TRUE;
                     break;
                 }
             }
@@ skipping 81 matching lines @@
     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) {
         m_FontMatrix = pMatrix->GetMatrix();
         xscale = m_FontMatrix.a;
         yscale = m_FontMatrix.d;
     }
     CPDF_Array* pBBox = m_pFontDict->GetArray(FX_BSTRC("FontBBox"));
     if (pBBox) {
-        m_FontBBox.left = (FX_INT32)(FXSYS_Mul(pBBox->GetNumber(0), xscale) * 1000);
-        m_FontBBox.bottom = (FX_INT32)(FXSYS_Mul(pBBox->GetNumber(1), yscale) * 1000);
-        m_FontBBox.right = (FX_INT32)(FXSYS_Mul(pBBox->GetNumber(2), xscale) * 1000);
-        m_FontBBox.top = (FX_INT32)(FXSYS_Mul(pBBox->GetNumber(3), yscale) * 1000);
+        m_FontBBox.left = (int32_t)(FXSYS_Mul(pBBox->GetNumber(0), xscale) * 1000);
+        m_FontBBox.bottom = (int32_t)(FXSYS_Mul(pBBox->GetNumber(1), yscale) * 1000);
+        m_FontBBox.right = (int32_t)(FXSYS_Mul(pBBox->GetNumber(2), xscale) * 1000);
+        m_FontBBox.top = (int32_t)(FXSYS_Mul(pBBox->GetNumber(3), yscale) * 1000);
     }
     int StartChar = m_pFontDict->GetInteger(FX_BSTRC("FirstChar"));
     CPDF_Array* pWidthArray = m_pFontDict->GetArray(FX_BSTRC("Widths"));
     if (pWidthArray && (StartChar >= 0 && StartChar < 256)) {
         FX_DWORD count = pWidthArray->GetCount();
         if (count > 256) {
             count = 256;
         }
         if (StartChar + count > 256) {
             count = 256 - StartChar;
@@ skipping 20 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)(FX_UINTPTR)charcode, (FX_LPVOID&)pChar)) {
+    if (m_CacheMap.Lookup((FX_LPVOID)(uintptr_t)charcode, (FX_LPVOID&)pChar)) {
         if (pChar->m_bPageRequired && m_pPageResources) {
             delete pChar;
-            m_CacheMap.RemoveKey((FX_LPVOID)(FX_UINTPTR)charcode);
+            m_CacheMap.RemoveKey((FX_LPVOID)(uintptr_t)charcode);
             return LoadChar(charcode, level + 1);
         }
         return pChar;
     }
     FX_LPCSTR 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 = (FX_INT32)(pChar->m_Width * scale + 0.5f);
+    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)(FX_UINTPTR)charcode, pChar);
+    m_CacheMap.SetAt((FX_LPVOID)(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;
     }
 }