Remove FX_WORD in favor of uint16_t.

core/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 "core/fpdfapi/fpdf_font/font_int.h"
 
 #include "core/fpdfapi/fpdf_page/include/cpdf_form.h"
 #include "core/fpdfapi/fpdf_page/pageint.h"
@@ skipping 513 matching lines @@
     if (index >= buf_len) {
       return CFX_WideString();
     }
     FX_DWORD len = buf[index];
     if (index + len < index || index + len >= buf_len) {
       return CFX_WideString();
     }
     return CFX_WideString(buf + index + 1, len);
   }
   if (m_pBaseMap) {
-    return m_pBaseMap->UnicodeFromCID((FX_WORD)charcode);
+    return m_pBaseMap->UnicodeFromCID((uint16_t)charcode);
   }
   return CFX_WideString();
 }
 
 FX_DWORD CPDF_ToUnicodeMap::ReverseLookup(FX_WCHAR unicode) {
   for (const auto& pair : m_Map) {
     if (pair.second == unicode)
       return pair.first;
   }
   return 0;
@@ skipping 554 matching lines @@
       bCoreText = FALSE;
     }
   }
 #endif
   if (!IsEmbedded() && (m_Base14Font < 12) && m_Font.IsTTFont()) {
     if (FT_UseTTCharmap(m_Font.GetFace(), 3, 0)) {
       FX_BOOL bGotOne = FALSE;
       for (int charcode = 0; charcode < 256; charcode++) {
         const uint8_t prefix[4] = {0x00, 0xf0, 0xf1, 0xf2};
         for (int j = 0; j < 4; j++) {
-          FX_WORD unicode = prefix[j] * 256 + charcode;
+          uint16_t unicode = prefix[j] * 256 + charcode;
           m_GlyphIndex[charcode] =
               FXFT_Get_Char_Index(m_Font.GetFace(), unicode);
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_APPLE_
           FX_CHAR name_glyph[256];
           FXFT_Get_Glyph_Name(m_Font.GetFace(), m_GlyphIndex[charcode],
                               name_glyph, 256);
           name_glyph[255] = 0;
           CFStringRef name_ct = CFStringCreateWithCStringNoCopy(
               kCFAllocatorDefault, name_glyph, kCFStringEncodingASCII,
               kCFAllocatorNull);
@@ skipping 256 matching lines @@
 
 int CPDF_FontEncoding::CharCodeFromUnicode(FX_WCHAR unicode) const {
   for (int i = 0; i < 256; i++)
     if (m_Unicodes[i] == unicode) {
       return i;
     }
   return -1;
 }
 
 CPDF_FontEncoding::CPDF_FontEncoding(int PredefinedEncoding) {
-  const FX_WORD* pSrc = PDF_UnicodesForPredefinedCharSet(PredefinedEncoding);
+  const uint16_t* pSrc = PDF_UnicodesForPredefinedCharSet(PredefinedEncoding);
   if (!pSrc) {
     FXSYS_memset(m_Unicodes, 0, sizeof(m_Unicodes));
   } else {
     for (int i = 0; i < 256; i++)
       m_Unicodes[i] = pSrc[i];
   }
 }
 
 FX_BOOL CPDF_FontEncoding::IsIdentical(CPDF_FontEncoding* pAnother) const {
   return FXSYS_memcmp(m_Unicodes, pAnother->m_Unicodes, sizeof(m_Unicodes)) ==
          0;
 }
 
 CPDF_Object* CPDF_FontEncoding::Realize() {
   int predefined = 0;
   for (int cs = PDFFONT_ENCODING_WINANSI; cs < PDFFONT_ENCODING_ZAPFDINGBATS;
        cs++) {
-    const FX_WORD* pSrc = PDF_UnicodesForPredefinedCharSet(cs);
+    const uint16_t* pSrc = PDF_UnicodesForPredefinedCharSet(cs);
     FX_BOOL match = TRUE;
     for (int i = 0; i < 256; ++i) {
       if (m_Unicodes[i] != pSrc[i]) {
         match = FALSE;
         break;
       }
     }
     if (match) {
       predefined = cs;
       break;
     }
   }
   if (predefined) {
     if (predefined == PDFFONT_ENCODING_WINANSI) {
       return new CPDF_Name("WinAnsiEncoding");
     }
     if (predefined == PDFFONT_ENCODING_MACROMAN) {
       return new CPDF_Name("MacRomanEncoding");
     }
     if (predefined == PDFFONT_ENCODING_MACEXPERT) {
       return new CPDF_Name("MacExpertEncoding");
     }
     return NULL;
   }
-  const FX_WORD* pStandard =
+  const uint16_t* pStandard =
       PDF_UnicodesForPredefinedCharSet(PDFFONT_ENCODING_WINANSI);
   CPDF_Array* pDiff = new CPDF_Array;
   for (int i = 0; i < 256; i++) {
     if (pStandard[i] == m_Unicodes[i]) {
       continue;
     }
     pDiff->Add(new CPDF_Number(i));
     pDiff->Add(new CPDF_Name(PDF_AdobeNameFromUnicode(m_Unicodes[i])));
   }
 
@@ skipping 56 matching lines @@
     if (!FXFT_Has_Glyph_Names(m_Font.GetFace()) &&
         (!m_Font.GetFace()->num_charmaps || !m_Font.GetFace()->charmaps)) {
       int nStartChar = m_pFontDict->GetIntegerBy("FirstChar");
       if (nStartChar < 0 || nStartChar > 255)
         return;
 
       int charcode = 0;
       for (; charcode < nStartChar; charcode++) {
         m_GlyphIndex[charcode] = 0;
       }
-      FX_WORD nGlyph = charcode - nStartChar + 3;
+      uint16_t nGlyph = charcode - nStartChar + 3;
       for (; charcode < 256; charcode++, nGlyph++) {
         m_GlyphIndex[charcode] = nGlyph;
       }
       return;
     }
     FX_BOOL bMSUnicode = FT_UseTTCharmap(m_Font.GetFace(), 3, 1);
     FX_BOOL bMacRoman = FALSE, bMSSymbol = FALSE;
     if (!bMSUnicode) {
       if (m_Flags & PDFFONT_NONSYMBOLIC) {
         bMacRoman = FT_UseTTCharmap(m_Font.GetFace(), 1, 0);
         bMSSymbol = !bMacRoman && FT_UseTTCharmap(m_Font.GetFace(), 3, 0);
       } else {
         bMSSymbol = FT_UseTTCharmap(m_Font.GetFace(), 3, 0);
         bMacRoman = !bMSSymbol && FT_UseTTCharmap(m_Font.GetFace(), 1, 0);
       }
     }
     FX_BOOL bToUnicode = m_pFontDict->KeyExist("ToUnicode");
     for (int charcode = 0; charcode < 256; charcode++) {
       const FX_CHAR* name =
           GetAdobeCharName(baseEncoding, m_pCharNames, charcode);
       if (!name) {
         m_GlyphIndex[charcode] =
             m_pFontFile ? FXFT_Get_Char_Index(m_Font.GetFace(), 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;
+          uint16_t unicode = prefix[j] * 256 + charcode;
           m_GlyphIndex[charcode] =
               FXFT_Get_Char_Index(m_Font.GetFace(), unicode);
           if (m_GlyphIndex[charcode]) {
             break;
           }
         }
       } else if (m_Encoding.m_Unicodes[charcode]) {
         if (bMSUnicode) {
           m_GlyphIndex[charcode] = FXFT_Get_Char_Index(
               m_Font.GetFace(), m_Encoding.m_Unicodes[charcode]);
@@ skipping 33 matching lines @@
         }
       }
     }
     return;
   }
   if (FT_UseTTCharmap(m_Font.GetFace(), 3, 0)) {
     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;
+        uint16_t unicode = prefix[j] * 256 + charcode;
         m_GlyphIndex[charcode] = FXFT_Get_Char_Index(m_Font.GetFace(), unicode);
         if (m_GlyphIndex[charcode]) {
           bGotOne = TRUE;
           break;
         }
       }
     }
     if (bGotOne) {
       if (baseEncoding != PDFFONT_ENCODING_BUILTIN) {
         for (int charcode = 0; charcode < 256; charcode++) {
@@ skipping 22 matching lines @@
       if (m_GlyphIndex[charcode]) {
         bGotOne = TRUE;
       }
     }
     if (m_pFontFile || bGotOne) {
       return;
     }
   }
   if (FXFT_Select_Charmap(m_Font.GetFace(), FXFT_ENCODING_UNICODE) == 0) {
     FX_BOOL bGotOne = FALSE;
-    const FX_WORD* pUnicodes = PDF_UnicodesForPredefinedCharSet(baseEncoding);
+    const uint16_t* pUnicodes = PDF_UnicodesForPredefinedCharSet(baseEncoding);
     for (int charcode = 0; charcode < 256; charcode++) {
       if (m_pFontFile) {
         m_Encoding.m_Unicodes[charcode] = charcode;
       } else {
         const FX_CHAR* name = GetAdobeCharName(0, m_pCharNames, charcode);
         if (name) {
           m_Encoding.m_Unicodes[charcode] = PDF_UnicodeFromAdobeName(name);
         } else if (pUnicodes) {
           m_Encoding.m_Unicodes[charcode] = pUnicodes[charcode];
         }
@@ skipping 160 matching lines @@
   return pChar ? pChar->m_BBox : FX_RECT();
 }
 
 CPDF_Type3Char::CPDF_Type3Char(CPDF_Form* pForm)
     : m_pForm(pForm), m_pBitmap(nullptr), m_bColored(FALSE) {}
 
 CPDF_Type3Char::~CPDF_Type3Char() {
   delete m_pForm;
   delete m_pBitmap;
 }