Remove FX_WORD in favor of uint16_t.

core/fpdfapi/fpdf_font/fpdf_font_cid.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_cmaps/cmap_int.h"
 #include "core/fpdfapi/fpdf_font/ttgsubtable.h"
@@ skipping 288 matching lines @@
 
 #if _FXM_PLATFORM_ != _FXM_PLATFORM_WINDOWS_
 FX_DWORD EmbeddedCharcodeFromUnicode(const FXCMAP_CMap* pEmbedMap,
                                      CIDSet charset,
                                      FX_WCHAR unicode) {
   if (!IsValidEmbeddedCharcodeFromUnicodeCharset(charset))
     return 0;
 
   CPDF_FontGlobals* pFontGlobals =
       CPDF_ModuleMgr::Get()->GetPageModule()->GetFontGlobals();
-  const FX_WORD* pCodes = pFontGlobals->m_EmbeddedToUnicodes[charset].m_pMap;
+  const uint16_t* pCodes = pFontGlobals->m_EmbeddedToUnicodes[charset].m_pMap;
   if (!pCodes)
     return 0;
 
   int nCodes = pFontGlobals->m_EmbeddedToUnicodes[charset].m_Count;
   for (int i = 0; i < nCodes; ++i) {
     if (pCodes[i] == unicode) {
       FX_DWORD CharCode = FPDFAPI_CharCodeFromCID(pEmbedMap, i);
       if (CharCode != 0) {
         return CharCode;
       }
     }
   }
   return 0;
 }
 #endif  // _FXM_PLATFORM_ != _FXM_PLATFORM_WINDOWS_
 
 FX_WCHAR EmbeddedUnicodeFromCharcode(const FXCMAP_CMap* pEmbedMap,
                                      CIDSet charset,
                                      FX_DWORD charcode) {
   if (!IsValidEmbeddedCharcodeFromUnicodeCharset(charset))
     return 0;
 
-  FX_WORD cid = FPDFAPI_CIDFromCharCode(pEmbedMap, charcode);
+  uint16_t cid = FPDFAPI_CIDFromCharCode(pEmbedMap, charcode);
   if (cid == 0)
     return 0;
 
   CPDF_FontGlobals* pFontGlobals =
       CPDF_ModuleMgr::Get()->GetPageModule()->GetFontGlobals();
-  const FX_WORD* pCodes = pFontGlobals->m_EmbeddedToUnicodes[charset].m_pMap;
+  const uint16_t* pCodes = pFontGlobals->m_EmbeddedToUnicodes[charset].m_pMap;
   if (!pCodes)
     return 0;
 
   if (cid < pFontGlobals->m_EmbeddedToUnicodes[charset].m_Count)
     return pCodes[cid];
   return 0;
 }
 
 void FT_UseCIDCharmap(FXFT_Face face, int coding) {
   int encoding;
@@ skipping 16 matching lines @@
   int err = FXFT_Select_Charmap(face, encoding);
   if (err) {
     err = FXFT_Select_Charmap(face, FXFT_ENCODING_UNICODE);
   }
   if (err && FXFT_Get_Face_Charmaps(face)) {
     FXFT_Set_Charmap(face, *FXFT_Get_Face_Charmaps(face));
   }
 }
 
 const struct CIDTransform {
-  FX_WORD CID;
+  uint16_t CID;
   uint8_t a, b, c, d, e, f;
 } g_Japan1_VertCIDs[] = {
     {97, 129, 0, 0, 127, 55, 0},     {7887, 127, 0, 0, 127, 76, 89},
     {7888, 127, 0, 0, 127, 79, 94},  {7889, 0, 129, 127, 0, 17, 127},
     {7890, 0, 129, 127, 0, 17, 127}, {7891, 0, 129, 127, 0, 17, 127},
     {7892, 0, 129, 127, 0, 17, 127}, {7893, 0, 129, 127, 0, 17, 127},
     {7894, 0, 129, 127, 0, 17, 127}, {7895, 0, 129, 127, 0, 17, 127},
     {7896, 0, 129, 127, 0, 17, 127}, {7897, 0, 129, 127, 0, 17, 127},
     {7898, 0, 129, 127, 0, 17, 127}, {7899, 0, 129, 127, 0, 17, 104},
     {7900, 0, 129, 127, 0, 17, 127}, {7901, 0, 129, 127, 0, 17, 104},
@@ skipping 62 matching lines @@
     {8806, 0, 129, 127, 0, 19, 108}, {8807, 0, 129, 127, 0, 19, 108},
     {8808, 0, 129, 127, 0, 19, 108}, {8809, 0, 129, 127, 0, 19, 108},
     {8810, 0, 129, 127, 0, 19, 108}, {8811, 0, 129, 127, 0, 19, 114},
     {8812, 0, 129, 127, 0, 19, 102}, {8813, 0, 129, 127, 0, 19, 114},
     {8814, 0, 129, 127, 0, 76, 102}, {8815, 0, 129, 127, 0, 13, 121},
     {8816, 0, 129, 127, 0, 19, 114}, {8817, 0, 129, 127, 0, 19, 127},
     {8818, 0, 129, 127, 0, 19, 114}, {8819, 0, 129, 127, 0, 218, 108},
 };
 
 int CompareCIDTransform(const void* key, const void* element) {
-  FX_WORD CID = *static_cast<const FX_WORD*>(key);
+  uint16_t CID = *static_cast<const uint16_t*>(key);
   return CID - static_cast<const struct CIDTransform*>(element)->CID;
 }
 
 }  // namespace
 
 CPDF_CMapManager::CPDF_CMapManager() {
   m_bPrompted = FALSE;
   FXSYS_memset(m_CID2UnicodeMaps, 0, sizeof m_CID2UnicodeMaps);
 }
 CPDF_CMapManager::~CPDF_CMapManager() {
@@ skipping 89 matching lines @@
   } else if (word == "/Supplement") {
     m_Status = 5;
   } else if (word == "begincodespacerange") {
     m_Status = 7;
     m_CodeSeq = 0;
   } else if (word == "usecmap") {
   } else if (m_Status == 1 || m_Status == 2) {
     m_CodePoints[m_CodeSeq] = CMap_GetCode(word);
     m_CodeSeq++;
     FX_DWORD StartCode, EndCode;
-    FX_WORD StartCID;
+    uint16_t StartCID;
     if (m_Status == 1) {
       if (m_CodeSeq < 2) {
         return;
       }
       EndCode = StartCode = m_CodePoints[0];
-      StartCID = (FX_WORD)m_CodePoints[1];
+      StartCID = (uint16_t)m_CodePoints[1];
     } else {
       if (m_CodeSeq < 3) {
         return;
       }
       StartCode = m_CodePoints[0];
       EndCode = m_CodePoints[1];
-      StartCID = (FX_WORD)m_CodePoints[2];
+      StartCID = (uint16_t)m_CodePoints[2];
     }
     if (EndCode < 0x10000) {
       for (FX_DWORD code = StartCode; code <= EndCode; code++) {
-        m_pCMap->m_pMapping[code] = (FX_WORD)(StartCID + code - StartCode);
+        m_pCMap->m_pMapping[code] = (uint16_t)(StartCID + code - StartCode);
       }
     } else {
       FX_DWORD buf[2];
       buf[0] = StartCode;
       buf[1] = ((EndCode - StartCode) << 16) + StartCID;
       m_AddMaps.AppendBlock(buf, sizeof buf);
     }
     m_CodeSeq = 0;
   } else if (m_Status == 3) {
     CMap_GetString(word);
@@ skipping 152 matching lines @@
     }
   }
   FPDFAPI_FindEmbeddedCMap(pName, m_Charset, m_Coding, m_pEmbedMap);
   if (m_pEmbedMap) {
     m_bLoaded = TRUE;
     return TRUE;
   }
   return FALSE;
 }
 FX_BOOL CPDF_CMap::LoadEmbedded(const uint8_t* pData, FX_DWORD size) {
-  m_pMapping = FX_Alloc(FX_WORD, 65536);
+  m_pMapping = FX_Alloc(uint16_t, 65536);
   CPDF_CMapParser parser;
   parser.Initialize(this);
   CPDF_SimpleParser syntax(pData, size);
   while (1) {
     CFX_ByteStringC word = syntax.GetWord();
     if (word.IsEmpty()) {
       break;
     }
     parser.ParseWord(word);
   }
   if (m_CodingScheme == MixedFourBytes && parser.m_AddMaps.GetSize()) {
     m_pAddMapping = FX_Alloc(uint8_t, parser.m_AddMaps.GetSize() + 4);
     *(FX_DWORD*)m_pAddMapping = parser.m_AddMaps.GetSize() / 8;
     FXSYS_memcpy(m_pAddMapping + 4, parser.m_AddMaps.GetBuffer(),
                  parser.m_AddMaps.GetSize());
     FXSYS_qsort(m_pAddMapping + 4, parser.m_AddMaps.GetSize() / 8, 8,
                 CompareDWORD);
   }
   return TRUE;
 }
 
-FX_WORD CPDF_CMap::CIDFromCharCode(FX_DWORD charcode) const {
+uint16_t CPDF_CMap::CIDFromCharCode(FX_DWORD charcode) const {
   if (m_Coding == CIDCODING_CID) {
-    return (FX_WORD)charcode;
+    return (uint16_t)charcode;
   }
   if (m_pEmbedMap) {
     return FPDFAPI_CIDFromCharCode(m_pEmbedMap, charcode);
   }
   if (!m_pMapping) {
-    return (FX_WORD)charcode;
+    return (uint16_t)charcode;
   }
   if (charcode >> 16) {
     if (m_pAddMapping) {
       void* found = FXSYS_bsearch(&charcode, m_pAddMapping + 4,
                                   *(FX_DWORD*)m_pAddMapping, 8, CompareCID);
       if (!found) {
         if (m_pUseMap) {
           return m_pUseMap->CIDFromCharCode(charcode);
         }
         return 0;
       }
-      return (FX_WORD)(((FX_DWORD*)found)[1] % 65536 + charcode -
-                       *(FX_DWORD*)found);
+      return (uint16_t)(((FX_DWORD*)found)[1] % 65536 + charcode -
+                        *(FX_DWORD*)found);
     }
     if (m_pUseMap)
       return m_pUseMap->CIDFromCharCode(charcode);
     return 0;
   }
   FX_DWORD CID = m_pMapping[charcode];
   if (!CID && m_pUseMap)
     return m_pUseMap->CIDFromCharCode(charcode);
-  return (FX_WORD)CID;
+  return (uint16_t)CID;
 }
 
 FX_DWORD CPDF_CMap::GetNextChar(const FX_CHAR* pString,
                                 int nStrLen,
                                 int& offset) const {
   switch (m_CodingScheme) {
     case OneByte:
       return ((uint8_t*)pString)[offset++];
     case TwoBytes:
       offset += 2;
@@ skipping 128 matching lines @@
 CPDF_CID2UnicodeMap::CPDF_CID2UnicodeMap() {
   m_EmbeddedCount = 0;
 }
 CPDF_CID2UnicodeMap::~CPDF_CID2UnicodeMap() {}
 FX_BOOL CPDF_CID2UnicodeMap::Initialize() {
   return TRUE;
 }
 FX_BOOL CPDF_CID2UnicodeMap::IsLoaded() {
   return m_EmbeddedCount != 0;
 }
-FX_WCHAR CPDF_CID2UnicodeMap::UnicodeFromCID(FX_WORD CID) {
+FX_WCHAR CPDF_CID2UnicodeMap::UnicodeFromCID(uint16_t CID) {
   if (m_Charset == CIDSET_UNICODE) {
     return CID;
   }
   if (CID < m_EmbeddedCount) {
     return m_pEmbeddedMap[CID];
   }
   return 0;
 }
 
 void CPDF_CID2UnicodeMap::Load(CPDF_CMapManager* pMgr,
@@ skipping 27 matching lines @@
 }
 
 const CPDF_CIDFont* CPDF_CIDFont::AsCIDFont() const {
   return this;
 }
 
 CPDF_CIDFont* CPDF_CIDFont::AsCIDFont() {
   return this;
 }
 
-FX_WORD CPDF_CIDFont::CIDFromCharCode(FX_DWORD charcode) const {
+uint16_t CPDF_CIDFont::CIDFromCharCode(FX_DWORD charcode) const {
   if (!m_pCMap) {
-    return (FX_WORD)charcode;
+    return (uint16_t)charcode;
   }
   return m_pCMap->CIDFromCharCode(charcode);
 }
 
 FX_BOOL CPDF_CIDFont::IsVertWriting() const {
   return m_pCMap ? m_pCMap->IsVertWriting() : FALSE;
 }
 
 CFX_WideString CPDF_CIDFont::UnicodeFromCharCode(FX_DWORD charcode) const {
   CFX_WideString str = CPDF_Font::UnicodeFromCharCode(charcode);
   if (!str.IsEmpty())
     return str;
   FX_WCHAR ret = GetUnicodeFromCharCode(charcode);
   if (ret == 0)
     return CFX_WideString();
   return ret;
 }
 
 FX_WCHAR CPDF_CIDFont::GetUnicodeFromCharCode(FX_DWORD charcode) const {
   switch (m_pCMap->m_Coding) {
     case CIDCODING_UCS2:
     case CIDCODING_UTF16:
       return (FX_WCHAR)charcode;
     case CIDCODING_CID:
       if (!m_pCID2UnicodeMap || !m_pCID2UnicodeMap->IsLoaded()) {
         return 0;
       }
-      return m_pCID2UnicodeMap->UnicodeFromCID((FX_WORD)charcode);
+      return m_pCID2UnicodeMap->UnicodeFromCID((uint16_t)charcode);
   }
   if (!m_pCMap->IsLoaded() || !m_pCID2UnicodeMap ||
       !m_pCID2UnicodeMap->IsLoaded()) {
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
     FX_WCHAR unicode;
     int charsize = 1;
     if (charcode > 255) {
       charcode = (charcode % 256) * 256 + (charcode / 256);
       charsize = 2;
     }
@@ skipping 23 matching lines @@
       return 0;
     case CIDCODING_UCS2:
     case CIDCODING_UTF16:
       return unicode;
     case CIDCODING_CID: {
       if (!m_pCID2UnicodeMap || !m_pCID2UnicodeMap->IsLoaded()) {
         return 0;
       }
       FX_DWORD CID = 0;
       while (CID < 65536) {
-        FX_WCHAR this_unicode = m_pCID2UnicodeMap->UnicodeFromCID((FX_WORD)CID);
+        FX_WCHAR this_unicode =
+            m_pCID2UnicodeMap->UnicodeFromCID((uint16_t)CID);
         if (this_unicode == unicode) {
           return CID;
         }
         CID++;
       }
       break;
     }
   }
 
   if (unicode < 0x80) {
@@ skipping 188 matching lines @@
                                   FXFT_Get_Glyph_Width(face),
                               face),
                        TT2PDF(FXFT_Get_Glyph_HoriBearingY(face) -
                                   FXFT_Get_Glyph_Height(face),
                               face));
         rect.top += rect.top / 64;
       }
     }
   }
   if (!m_pFontFile && m_Charset == CIDSET_JAPAN1) {
-    FX_WORD CID = CIDFromCharCode(charcode);
+    uint16_t CID = CIDFromCharCode(charcode);
     const uint8_t* pTransform = GetCIDTransform(CID);
     if (pTransform && !bVert) {
       CFX_Matrix matrix(CIDTransformToFloat(pTransform[0]),
                         CIDTransformToFloat(pTransform[1]),
                         CIDTransformToFloat(pTransform[2]),
                         CIDTransformToFloat(pTransform[3]),
                         CIDTransformToFloat(pTransform[4]) * 1000,
                         CIDTransformToFloat(pTransform[5]) * 1000);
       CFX_FloatRect rect_f(rect);
       rect_f.Transform(&matrix);
       rect = rect_f.GetOutterRect();
     }
   }
   if (charcode < 256)
     m_CharBBox[charcode] = rect.ToSmallRect();
 
   return rect;
 }
 int CPDF_CIDFont::GetCharWidthF(FX_DWORD charcode, int level) {
   if (m_pAnsiWidths && charcode < 0x80) {
     return m_pAnsiWidths[charcode];
   }
-  FX_WORD cid = CIDFromCharCode(charcode);
+  uint16_t cid = CIDFromCharCode(charcode);
   int size = m_WidthList.GetSize();
   FX_DWORD* list = m_WidthList.GetData();
   for (int i = 0; i < size; i += 3) {
     if (cid >= list[i] && cid <= list[i + 1]) {
       return (int)list[i + 2];
     }
   }
   return m_DefaultWidth;
 }
-short CPDF_CIDFont::GetVertWidth(FX_WORD CID) const {
+short CPDF_CIDFont::GetVertWidth(uint16_t CID) const {
   FX_DWORD vertsize = m_VertMetrics.GetSize() / 5;
   if (vertsize == 0) {
     return m_DefaultW1;
   }
   const FX_DWORD* pTable = m_VertMetrics.GetData();
   for (FX_DWORD i = 0; i < vertsize; i++)
     if (pTable[i * 5] <= CID && pTable[i * 5 + 1] >= CID) {
       return (short)(int)pTable[i * 5 + 2];
     }
   return m_DefaultW1;
 }
-void CPDF_CIDFont::GetVertOrigin(FX_WORD CID, short& vx, short& vy) const {
+void CPDF_CIDFont::GetVertOrigin(uint16_t CID, short& vx, short& vy) const {
   FX_DWORD vertsize = m_VertMetrics.GetSize() / 5;
   if (vertsize) {
     const FX_DWORD* pTable = m_VertMetrics.GetData();
     for (FX_DWORD i = 0; i < vertsize; i++)
       if (pTable[i * 5] <= CID && pTable[i * 5 + 1] >= CID) {
         vx = (short)(int)pTable[i * 5 + 3];
         vy = (short)(int)pTable[i * 5 + 4];
         return;
       }
   }
   FX_DWORD dwWidth = m_DefaultWidth;
   int size = m_WidthList.GetSize();
   const FX_DWORD* list = m_WidthList.GetData();
   for (int i = 0; i < size; i += 3) {
     if (CID >= list[i] && CID <= list[i + 1]) {
-      dwWidth = (FX_WORD)list[i + 2];
+      dwWidth = (uint16_t)list[i + 2];
       break;
     }
   }
   vx = (short)dwWidth / 2;
   vy = (short)m_DefaultVY;
 }
 int CPDF_CIDFont::GetGlyphIndex(FX_DWORD unicode, FX_BOOL* pVertGlyph) {
   if (pVertGlyph) {
     *pVertGlyph = FALSE;
   }
@@ skipping 41 matching lines @@
   if (pVertGlyph) {
     *pVertGlyph = FALSE;
   }
   return index;
 }
 int CPDF_CIDFont::GlyphFromCharCode(FX_DWORD charcode, FX_BOOL* pVertGlyph) {
   if (pVertGlyph) {
     *pVertGlyph = FALSE;
   }
   if (!m_pFontFile && !m_pCIDToGIDMap) {
-    FX_WORD cid = CIDFromCharCode(charcode);
+    uint16_t cid = CIDFromCharCode(charcode);
     FX_WCHAR unicode = 0;
     if (m_bCIDIsGID) {
 #if _FXM_PLATFORM_ != _FXM_PLATFORM_APPLE_
       return cid;
 #else
       if (m_Flags & PDFFONT_SYMBOLIC) {
         return cid;
       }
       CFX_WideString uni_str = UnicodeFromCharCode(charcode);
       if (uni_str.IsEmpty()) {
@@ skipping 27 matching lines @@
       iBaseEncoding = PDFFONT_ENCODING_STANDARD;
       if (bMSUnicode) {
         iBaseEncoding = PDFFONT_ENCODING_WINANSI;
       } else if (bMacRoman) {
         iBaseEncoding = PDFFONT_ENCODING_MACROMAN;
       }
       const FX_CHAR* name = GetAdobeCharName(iBaseEncoding, NULL, charcode);
       if (!name) {
         return charcode == 0 ? -1 : (int)charcode;
       }
-      FX_WORD unicode = PDF_UnicodeFromAdobeName(name);
+      uint16_t unicode = PDF_UnicodeFromAdobeName(name);
       if (unicode) {
         if (bMSUnicode) {
           index = FXFT_Get_Char_Index(face, unicode);
         } else if (bMacRoman) {
           FX_DWORD maccode =
               FT_CharCodeFromUnicode(FXFT_ENCODING_APPLE_ROMAN, unicode);
           index = !maccode ? FXFT_Get_Name_Index(face, (char*)name)
                            : FXFT_Get_Char_Index(face, maccode);
         } else {
           return FXFT_Get_Char_Index(face, unicode);
@@ skipping 41 matching lines @@
       int index = GetGlyphIndex(unicode, pVertGlyph);
       if (index == 0)
         return -1;
       return index;
     }
     return unicode;
   }
   if (!m_Font.GetFace())
     return -1;
 
-  FX_WORD cid = CIDFromCharCode(charcode);
+  uint16_t cid = CIDFromCharCode(charcode);
   if (m_bType1) {
     if (!m_pCIDToGIDMap) {
       return cid;
     }
   } else {
     if (!m_pCIDToGIDMap) {
       if (m_pFontFile && !m_pCMap->m_pMapping)
         return cid;
       if (m_pCMap->m_Coding == CIDCODING_UNKNOWN ||
           !FXFT_Get_Face_Charmap(m_Font.GetFace())) {
@@ skipping 117 matching lines @@
                 ->m_CMapManager.GetPredefinedCMap("GBK-EUC-H", FALSE);
   m_pCID2UnicodeMap = CPDF_ModuleMgr::Get()
                           ->GetPageModule()
                           ->GetFontGlobals()
                           ->m_CMapManager.GetCID2UnicodeMap(m_Charset, FALSE);
   if (!IsEmbedded()) {
     LoadSubstFont();
   }
   CheckFontMetrics();
   m_DefaultWidth = 1000;
-  m_pAnsiWidths = FX_Alloc(FX_WORD, 128);
+  m_pAnsiWidths = FX_Alloc(uint16_t, 128);
   for (int i = 32; i < 127; i++) {
     m_pAnsiWidths[i] = 500;
   }
   return TRUE;
 }
 
-const uint8_t* CPDF_CIDFont::GetCIDTransform(FX_WORD CID) const {
+const uint8_t* CPDF_CIDFont::GetCIDTransform(uint16_t CID) const {
   if (m_Charset != CIDSET_JAPAN1 || m_pFontFile)
     return nullptr;
 
   const struct CIDTransform* found = (const struct CIDTransform*)FXSYS_bsearch(
       &CID, g_Japan1_VertCIDs, FX_ArraySize(g_Japan1_VertCIDs),
       sizeof(g_Japan1_VertCIDs[0]), CompareCIDTransform);
   return found ? &found->a : nullptr;
 }