Remove FX_DWORD from core/ and delete definition

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 177 matching lines @@
     return CIDSET_UNKNOWN;
   }
   return static_cast<CIDSet>(index);
 }
 
 CFX_ByteString CMap_GetString(const CFX_ByteStringC& word) {
   return word.Mid(1, word.GetLength() - 2);
 }
 
 int CompareDWORD(const void* data1, const void* data2) {
-  return (*(FX_DWORD*)data1) - (*(FX_DWORD*)data2);
+  return (*(uint32_t*)data1) - (*(uint32_t*)data2);
 }
 
 int CompareCID(const void* key, const void* element) {
-  if ((*(FX_DWORD*)key) < (*(FX_DWORD*)element)) {
+  if ((*(uint32_t*)key) < (*(uint32_t*)element)) {
     return -1;
   }
-  if ((*(FX_DWORD*)key) >
-      (*(FX_DWORD*)element) + ((FX_DWORD*)element)[1] / 65536) {
+  if ((*(uint32_t*)key) >
+      (*(uint32_t*)element) + ((uint32_t*)element)[1] / 65536) {
     return 1;
   }
   return 0;
 }
 
 int CheckCodeRange(uint8_t* codes,
                    int size,
                    CMap_CodeRange* pRanges,
                    int nRanges) {
   int iSeg = nRanges - 1;
@@ skipping 13 matching lines @@
     if (iChar == pRanges[iSeg].m_CharSize)
       return 2;
 
     if (iChar)
       return (size == pRanges[iSeg].m_CharSize) ? 2 : 1;
     iSeg--;
   }
   return 0;
 }
 
-int GetCharSizeImpl(FX_DWORD charcode,
+int GetCharSizeImpl(uint32_t charcode,
                     CMap_CodeRange* pRanges,
                     int iRangesSize) {
   if (!iRangesSize)
     return 1;
 
   uint8_t codes[4];
   codes[0] = codes[1] = 0x00;
   codes[2] = (uint8_t)(charcode >> 8 & 0xFF);
   codes[3] = (uint8_t)charcode;
   int offset = 0;
@@ skipping 121 matching lines @@
     m_Status = 4;
   } 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;
+    uint32_t StartCode, EndCode;
     uint16_t StartCID;
     if (m_Status == 1) {
       if (m_CodeSeq < 2) {
         return;
       }
       EndCode = StartCode = m_CodePoints[0];
       StartCID = (uint16_t)m_CodePoints[1];
     } else {
       if (m_CodeSeq < 3) {
         return;
       }
       StartCode = m_CodePoints[0];
       EndCode = m_CodePoints[1];
       StartCID = (uint16_t)m_CodePoints[2];
     }
     if (EndCode < 0x10000) {
-      for (FX_DWORD code = StartCode; code <= EndCode; code++) {
+      for (uint32_t code = StartCode; code <= EndCode; code++) {
         m_pCMap->m_pMapping[code] = (uint16_t)(StartCID + code - StartCode);
       }
     } else {
-      FX_DWORD buf[2];
+      uint32_t 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);
     m_Status = 0;
   } else if (m_Status == 4) {
     m_pCMap->m_Charset = CharsetFromOrdering(CMap_GetString(word));
@@ skipping 30 matching lines @@
           m_CodeRanges.Add(range);
         }
       }
       m_CodeSeq++;
     }
   }
   m_LastWord = word;
 }
 
 // Static.
-FX_DWORD CPDF_CMapParser::CMap_GetCode(const CFX_ByteStringC& word) {
+uint32_t CPDF_CMapParser::CMap_GetCode(const CFX_ByteStringC& word) {
   int num = 0;
   if (word.GetAt(0) == '<') {
     for (int i = 1; i < word.GetLength() && std::isxdigit(word.GetAt(i)); ++i)
       num = num * 16 + FXSYS_toHexDigit(word.GetAt(i));
     return num;
   }
 
   for (int i = 0; i < word.GetLength() && std::isdigit(word.GetAt(i)); ++i)
     num = num * 10 + FXSYS_toDecimalDigit(static_cast<FX_WCHAR>(word.GetAt(i)));
   return num;
@@ skipping 15 matching lines @@
   range.m_CharSize = (i - 1) / 2;
   if (range.m_CharSize > 4)
     return false;
 
   for (i = 0; i < range.m_CharSize; ++i) {
     uint8_t digit1 = first.GetAt(i * 2 + 1);
     uint8_t digit2 = first.GetAt(i * 2 + 2);
     range.m_Lower[i] = FXSYS_toHexDigit(digit1) * 16 + FXSYS_toHexDigit(digit2);
   }
 
-  FX_DWORD size = second.GetLength();
+  uint32_t size = second.GetLength();
   for (i = 0; i < range.m_CharSize; ++i) {
-    uint8_t digit1 = ((FX_DWORD)i * 2 + 1 < size)
+    uint8_t digit1 = ((uint32_t)i * 2 + 1 < size)
                          ? second.GetAt((FX_STRSIZE)i * 2 + 1)
                          : '0';
-    uint8_t digit2 = ((FX_DWORD)i * 2 + 2 < size)
+    uint8_t digit2 = ((uint32_t)i * 2 + 2 < size)
                          ? second.GetAt((FX_STRSIZE)i * 2 + 2)
                          : '0';
     range.m_Upper[i] = FXSYS_toHexDigit(digit1) * 16 + FXSYS_toHexDigit(digit2);
   }
   return true;
 }
 
 CPDF_CMap::CPDF_CMap() {
   m_Charset = CIDSET_UNKNOWN;
   m_Coding = CIDCODING_UNKNOWN;
@@ skipping 42 matching lines @@
     }
   }
   if (!map)
     return FALSE;
 
   m_Charset = map->m_Charset;
   m_Coding = map->m_Coding;
   m_CodingScheme = map->m_CodingScheme;
   if (m_CodingScheme == MixedTwoBytes) {
     m_pLeadingBytes = FX_Alloc(uint8_t, 256);
-    for (FX_DWORD i = 0; i < map->m_LeadingSegCount; ++i) {
+    for (uint32_t i = 0; i < map->m_LeadingSegCount; ++i) {
       const uint8_t* segs = map->m_LeadingSegs;
       for (int b = segs[i * 2]; b <= segs[i * 2 + 1]; ++b) {
         m_pLeadingBytes[b] = 1;
       }
     }
   }
   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) {
+FX_BOOL CPDF_CMap::LoadEmbedded(const uint8_t* pData, uint32_t size) {
   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;
+    *(uint32_t*)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;
 }
 
-uint16_t CPDF_CMap::CIDFromCharCode(FX_DWORD charcode) const {
+uint16_t CPDF_CMap::CIDFromCharCode(uint32_t charcode) const {
   if (m_Coding == CIDCODING_CID) {
     return (uint16_t)charcode;
   }
   if (m_pEmbedMap) {
     return FPDFAPI_CIDFromCharCode(m_pEmbedMap, charcode);
   }
   if (!m_pMapping) {
     return (uint16_t)charcode;
   }
   if (charcode >> 16) {
     if (m_pAddMapping) {
       void* found = FXSYS_bsearch(&charcode, m_pAddMapping + 4,
-                                  *(FX_DWORD*)m_pAddMapping, 8, CompareCID);
+                                  *(uint32_t*)m_pAddMapping, 8, CompareCID);
       if (!found) {
         if (m_pUseMap) {
           return m_pUseMap->CIDFromCharCode(charcode);
         }
         return 0;
       }
-      return (uint16_t)(((FX_DWORD*)found)[1] % 65536 + charcode -
-                        *(FX_DWORD*)found);
+      return (uint16_t)(((uint32_t*)found)[1] % 65536 + charcode -
+                        *(uint32_t*)found);
     }
     if (m_pUseMap)
       return m_pUseMap->CIDFromCharCode(charcode);
     return 0;
   }
-  FX_DWORD CID = m_pMapping[charcode];
+  uint32_t CID = m_pMapping[charcode];
   if (!CID && m_pUseMap)
     return m_pUseMap->CIDFromCharCode(charcode);
   return (uint16_t)CID;
 }
 
-FX_DWORD CPDF_CMap::GetNextChar(const FX_CHAR* pString,
+uint32_t 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;
       return ((uint8_t*)pString)[offset - 2] * 256 +
              ((uint8_t*)pString)[offset - 1];
     case MixedTwoBytes: {
       uint8_t byte1 = ((uint8_t*)pString)[offset++];
       if (!m_pLeadingBytes[byte1]) {
         return byte1;
       }
       uint8_t byte2 = ((uint8_t*)pString)[offset++];
       return byte1 * 256 + byte2;
     }
     case MixedFourBytes: {
       uint8_t codes[4];
       int char_size = 1;
       codes[0] = ((uint8_t*)pString)[offset++];
       CMap_CodeRange* pRanges = (CMap_CodeRange*)m_pLeadingBytes;
       while (1) {
         int ret = CheckCodeRange(codes, char_size, pRanges, m_nCodeRanges);
         if (ret == 0) {
           return 0;
         }
         if (ret == 2) {
-          FX_DWORD charcode = 0;
+          uint32_t charcode = 0;
           for (int i = 0; i < char_size; i++) {
             charcode = (charcode << 8) + codes[i];
           }
           return charcode;
         }
         if (char_size == 4 || offset == nStrLen) {
           return 0;
         }
         codes[char_size++] = ((uint8_t*)pString)[offset++];
       }
       break;
     }
   }
   return 0;
 }
-int CPDF_CMap::GetCharSize(FX_DWORD charcode) const {
+int CPDF_CMap::GetCharSize(uint32_t charcode) const {
   switch (m_CodingScheme) {
     case OneByte:
       return 1;
     case TwoBytes:
       return 2;
     case MixedTwoBytes:
     case MixedFourBytes:
       if (charcode < 0x100) {
         return 1;
       }
@@ skipping 28 matching lines @@
       while (offset < size) {
         GetNextChar(pString, size, offset);
         count++;
       }
       return count;
     }
   }
   return size;
 }
 
-int CPDF_CMap::AppendChar(FX_CHAR* str, FX_DWORD charcode) const {
+int CPDF_CMap::AppendChar(FX_CHAR* str, uint32_t charcode) const {
   switch (m_CodingScheme) {
     case OneByte:
       str[0] = (uint8_t)charcode;
       return 1;
     case TwoBytes:
       str[0] = (uint8_t)(charcode / 256);
       str[1] = (uint8_t)(charcode % 256);
       return 2;
     case MixedTwoBytes:
     case MixedFourBytes:
@@ skipping 55 matching lines @@
   FPDFAPI_LoadCID2UnicodeMap(charset, m_pEmbeddedMap, m_EmbeddedCount);
 }
 
 CIDSet CharsetFromOrdering(const CFX_ByteString& ordering) {
   for (size_t charset = 1; charset < FX_ArraySize(g_CharsetNames); ++charset) {
     if (ordering == CFX_ByteStringC(g_CharsetNames[charset]))
       return CIDSetFromSizeT(charset);
   }
   return CIDSET_UNKNOWN;
 }