Merge to XFA: Use stdint.h types throughout PDFium.

core/src/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 "../../../include/fpdfapi/fpdf_module.h"
 #include "../../../include/fpdfapi/fpdf_page.h"
 #include "font_int.h"
 #include "../fpdf_cmaps/cmap_int.h"
@@ skipping 106 matching lines @@
     m_Status = 0;
     m_CodeSeq = 0;
     m_AddMaps.EstimateSize(0, 10240);
     return TRUE;
 }
 static FX_DWORD CMap_GetCode(FX_BSTR word)
 {
     int num = 0;
     if (word.GetAt(0) == '<') {
         for (int i = 1; i < word.GetLength(); i ++) {
-            FX_BYTE digit = word.GetAt(i);
+            uint8_t digit = word.GetAt(i);
             if (digit >= '0' && digit <= '9') {
                 digit = digit - '0';
             } else if (digit >= 'a' && digit <= 'f') {
                 digit = digit - 'a' + 10;
             } else if (digit >= 'A' && digit <= 'F') {
                 digit = digit - 'A' + 10;
             } else {
                 return num;
             }
             num = num * 16 + digit;
@@ skipping 16 matching lines @@
     int i;
     for (i = 1; i < first.GetLength(); i ++)
         if (first.GetAt(i) == '>') {
             break;
         }
     range.m_CharSize = (i - 1) / 2;
     if (range.m_CharSize > 4) {
         return FALSE;
     }
     for (i = 0; i < range.m_CharSize; i ++) {
-        FX_BYTE digit1 = first.GetAt(i * 2 + 1);
-        FX_BYTE digit2 = first.GetAt(i * 2 + 2);
-        FX_BYTE byte = (digit1 >= '0' && digit1 <= '9') ? (digit1 - '0') : ((digit1 & 0xdf) - 'A' + 10);
+        uint8_t digit1 = first.GetAt(i * 2 + 1);
+        uint8_t digit2 = first.GetAt(i * 2 + 2);
+        uint8_t byte = (digit1 >= '0' && digit1 <= '9') ? (digit1 - '0') : ((digit1 & 0xdf) - 'A' + 10);
         byte = byte * 16 + ((digit2 >= '0' && digit2 <= '9') ? (digit2 - '0') : ((digit2 & 0xdf) - 'A' + 10));
         range.m_Lower[i] = byte;
     }
     FX_DWORD size = second.GetLength();
     for (i = 0; i < range.m_CharSize; i ++) {
-        FX_BYTE digit1 = ((FX_DWORD)i * 2 + 1 < size) ? second.GetAt((FX_STRSIZE)i * 2 + 1) : 0;
-        FX_BYTE digit2 = ((FX_DWORD)i * 2 + 2 < size) ? second.GetAt((FX_STRSIZE)i * 2 + 2) : 0;
-        FX_BYTE byte = (digit1 >= '0' && digit1 <= '9') ? (digit1 - '0') : ((digit1 & 0xdf) - 'A' + 10);
+        uint8_t digit1 = ((FX_DWORD)i * 2 + 1 < size) ? second.GetAt((FX_STRSIZE)i * 2 + 1) : 0;
+        uint8_t digit2 = ((FX_DWORD)i * 2 + 2 < size) ? second.GetAt((FX_STRSIZE)i * 2 + 2) : 0;
+        uint8_t byte = (digit1 >= '0' && digit1 <= '9') ? (digit1 - '0') : ((digit1 & 0xdf) - 'A' + 10);
         byte = byte * 16 + ((digit2 >= '0' && digit2 <= '9') ? (digit2 - '0') : ((digit2 & 0xdf) - 'A' + 10));
         range.m_Upper[i] = byte;
     }
     return TRUE;
 }
 static CFX_ByteString CMap_GetString(FX_BSTR word)
 {
     return word.Mid(1, word.GetLength() - 2);
 }
 void CPDF_CMapParser::ParseWord(FX_BSTR word)
@@ skipping 62 matching lines @@
         m_Status = 0;
     } else if (m_Status == 6) {
         m_pCMap->m_bVertical = CMap_GetCode(word);
         m_Status = 0;
     } else if (m_Status == 7) {
         if (word == FX_BSTRC("endcodespacerange")) {
             int nSegs = m_CodeRanges.GetSize();
             if (nSegs > 1) {
                 m_pCMap->m_CodingScheme = CPDF_CMap::MixedFourBytes;
                 m_pCMap->m_nCodeRanges = nSegs;
-                m_pCMap->m_pLeadingBytes = FX_Alloc2D(FX_BYTE, nSegs, sizeof(_CMap_CodeRange));
+                m_pCMap->m_pLeadingBytes = FX_Alloc2D(uint8_t, nSegs, sizeof(_CMap_CodeRange));
                 FXSYS_memcpy32(m_pCMap->m_pLeadingBytes, m_CodeRanges.GetData(), nSegs * sizeof(_CMap_CodeRange));
             } else if (nSegs == 1) {
                 m_pCMap->m_CodingScheme = (m_CodeRanges[0].m_CharSize == 2) ? CPDF_CMap::TwoBytes : CPDF_CMap::OneByte;
             }
             m_Status = 0;
         } else {
             if (word.GetLength() == 0 || word.GetAt(0) != '<') {
                 return;
             }
             if (m_CodeSeq % 2) {
@@ skipping 101 matching lines @@
         if (cmapid == CFX_ByteStringC(g_PredefinedCMaps[index].m_pName)) {
             break;
         }
         index ++;
     }
     const CPDF_PredefinedCMap& map = g_PredefinedCMaps[index];
     m_Charset = map.m_Charset;
     m_Coding = map.m_Coding;
     m_CodingScheme = map.m_CodingScheme;
     if (m_CodingScheme == MixedTwoBytes) {
-        m_pLeadingBytes = FX_Alloc(FX_BYTE, 256);
+        m_pLeadingBytes = FX_Alloc(uint8_t, 256);
         for (FX_DWORD i = 0; i < map.m_LeadingSegCount; i ++) {
             for (int b = map.m_LeadingSegs[i * 2]; b <= map.m_LeadingSegs[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;
@@ skipping 13 matching lines @@
     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(FX_BYTE, parser.m_AddMaps.GetSize() + 4);
+        m_pAddMapping = FX_Alloc(uint8_t, parser.m_AddMaps.GetSize() + 4);
         *(FX_DWORD*)m_pAddMapping = parser.m_AddMaps.GetSize() / 8;
         FXSYS_memcpy32(m_pAddMapping + 4, parser.m_AddMaps.GetBuffer(), parser.m_AddMaps.GetSize());
         FXSYS_qsort(m_pAddMapping + 4, parser.m_AddMaps.GetSize() / 8, 8, compare_dword);
     }
     return TRUE;
 }
 extern "C" {
     static int compareCID(const void* key, const void* element)
     {
         if ((*(FX_DWORD*)key) < (*(FX_DWORD*)element)) {
@@ skipping 69 matching lines @@
 }
 FX_DWORD CPDF_CMap::GetNextChar(FX_LPCSTR pString, int nStrLen, int& offset) const
 {
     switch (m_CodingScheme) {
         case OneByte:
             return ((FX_LPBYTE)pString)[offset++];
         case TwoBytes:
             offset += 2;
             return ((FX_LPBYTE)pString)[offset - 2] * 256 + ((FX_LPBYTE)pString)[offset - 1];
         case MixedTwoBytes: {
-                FX_BYTE byte1 = ((FX_LPBYTE)pString)[offset++];
+                uint8_t byte1 = ((FX_LPBYTE)pString)[offset++];
                 if (!m_pLeadingBytes[byte1]) {
                     return byte1;
                 }
-                FX_BYTE byte2 = ((FX_LPBYTE)pString)[offset++];
+                uint8_t byte2 = ((FX_LPBYTE)pString)[offset++];
                 return byte1 * 256 + byte2;
             }
         case MixedFourBytes: {
-                FX_BYTE codes[4];
+                uint8_t codes[4];
                 int char_size = 1;
                 codes[0] = ((FX_LPBYTE)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;
@@ skipping 60 matching lines @@
                 return count;
             }
     }
     return size;
 }
 int _GetCharSize(FX_DWORD charcode, _CMap_CodeRange* pRanges, int iRangesSize)
 {
     if (!iRangesSize) {
         return 1;
     }
-    FX_BYTE codes[4];
+    uint8_t codes[4];
     codes[0] = codes[1] = 0x00;
-    codes[2] = (FX_BYTE)(charcode >> 8 & 0xFF);
-    codes[3] = (FX_BYTE)charcode;
+    codes[2] = (uint8_t)(charcode >> 8 & 0xFF);
+    codes[3] = (uint8_t)charcode;
     int offset = 0, size = 4;
     for (int i = 0; i < 4; ++i) {
         int iSeg = iRangesSize - 1;
         while (iSeg >= 0) {
             if (pRanges[iSeg].m_CharSize < size) {
                 iSeg --;
                 continue;
             }
             int iChar = 0;
             while (iChar < size) {
@@ skipping 10 matching lines @@
         }
         size --;
         offset ++;
     }
     return 1;
 }
 int CPDF_CMap::AppendChar(FX_LPSTR str, FX_DWORD charcode) const
 {
     switch (m_CodingScheme) {
         case OneByte:
-            str[0] = (FX_BYTE)charcode;
+            str[0] = (uint8_t)charcode;
             return 1;
         case TwoBytes:
-            str[0] = (FX_BYTE)(charcode / 256);
-            str[1] = (FX_BYTE)(charcode % 256);
+            str[0] = (uint8_t)(charcode / 256);
+            str[1] = (uint8_t)(charcode % 256);
             return 2;
         case MixedTwoBytes:
         case MixedFourBytes:
             if (charcode < 0x100) {
                 _CMap_CodeRange* pRanges = (_CMap_CodeRange*)m_pLeadingBytes;
                 int iSize = _GetCharSize(charcode, pRanges, m_nCodeRanges);
                 if (iSize == 0) {
                     iSize = 1;
                 }
                 if (iSize > 1) {
-                    FXSYS_memset32(str, 0, sizeof(FX_BYTE) * iSize);
+                    FXSYS_memset32(str, 0, sizeof(uint8_t) * iSize);
                 }
-                str[iSize - 1] = (FX_BYTE)charcode;
+                str[iSize - 1] = (uint8_t)charcode;
                 return iSize;
             } else if (charcode < 0x10000) {
-                str[0] = (FX_BYTE)(charcode >> 8);
-                str[1] = (FX_BYTE)charcode;
+                str[0] = (uint8_t)(charcode >> 8);
+                str[1] = (uint8_t)charcode;
                 return 2;
             } else if (charcode < 0x1000000) {
-                str[0] = (FX_BYTE)(charcode >> 16);
-                str[1] = (FX_BYTE)(charcode >> 8);
-                str[2] = (FX_BYTE)charcode;
+                str[0] = (uint8_t)(charcode >> 16);
+                str[1] = (uint8_t)(charcode >> 8);
+                str[2] = (uint8_t)charcode;
                 return 3;
             } else {
-                str[0] = (FX_BYTE)(charcode >> 24);
-                str[1] = (FX_BYTE)(charcode >> 16);
-                str[2] = (FX_BYTE)(charcode >> 8);
-                str[3] = (FX_BYTE)charcode;
+                str[0] = (uint8_t)(charcode >> 24);
+                str[1] = (uint8_t)(charcode >> 16);
+                str[2] = (uint8_t)(charcode >> 8);
+                str[3] = (uint8_t)charcode;
                 return 4;
             }
     }
     return 0;
 }
 CPDF_CID2UnicodeMap::CPDF_CID2UnicodeMap()
 {
     m_EmbeddedCount = 0;
 }
 CPDF_CID2UnicodeMap::~CPDF_CID2UnicodeMap()
@@ skipping 161 matching lines @@
                 break;
             }
     }
         
     if (unicode < 0x80) {
         return static_cast<FX_DWORD>(unicode);
     } else if (m_pCMap->m_Coding == CIDCODING_CID) {
         return 0;
     }
 #if _FXM_PLATFORM_ == _FXM_PLATFORM_WINDOWS_
-    FX_BYTE buffer[32];
+    uint8_t buffer[32];
     int ret = FXSYS_WideCharToMultiByte(g_CharsetCPs[m_pCMap->m_Coding], 0, &unicode, 1, (char*)buffer, 4, NULL, NULL);
     if (ret == 1) {
         return buffer[0];
     } else if (ret == 2) {
         return buffer[0] * 256 + buffer[1];
     }
     return 0;
 #endif
     if (m_pCMap->m_pEmbedMap) {
         return _EmbeddedCharcodeFromUnicode(m_pCMap->m_pEmbedMap, m_pCMap->m_Charset, unicode);
@@ skipping 132 matching lines @@
         if (pDefaultArray) {
             m_DefaultVY = pDefaultArray->GetInteger(0);
             m_DefaultW1 = pDefaultArray->GetInteger(1);
         } else {
             m_DefaultVY = 880;
             m_DefaultW1 = -1000;
         }
     }
     return TRUE;
 }
-FX_FLOAT _CIDTransformToFloat(FX_BYTE ch)
+FX_FLOAT _CIDTransformToFloat(uint8_t ch)
 {
     if (ch < 128) {
         return ch * 1.0f / 127;
     }
     return (-255 + ch) * 1.0f / 127;
 }
 void CPDF_CIDFont::GetCharBBox(FX_DWORD charcode, FX_RECT& rect, int level)
 {
     if (charcode < 256 && m_CharBBox[charcode].Right != -1) {
         rect.bottom = m_CharBBox[charcode].Bottom;
@@ skipping 139 matching lines @@
                 if (pVertGlyph) {
                     *pVertGlyph = TRUE;
                 }
             }
             return index;
         }
         if (NULL == m_Font.m_pGsubData) {
             unsigned long length = 0;
             int error = FXFT_Load_Sfnt_Table( m_Font.m_Face, FT_MAKE_TAG('G', 'S', 'U', 'B'), 0, NULL, &length);
             if (!error) {
-                m_Font.m_pGsubData = (unsigned char*)FX_Alloc(FX_BYTE, length);
+                m_Font.m_pGsubData = (unsigned char*)FX_Alloc(uint8_t, length);
             }
         }
         int error = FXFT_Load_Sfnt_Table( m_Font.m_Face, FT_MAKE_TAG('G', 'S', 'U', 'B'), 0, m_Font.m_pGsubData, NULL);
         if (!error && m_Font.m_pGsubData) {
             m_pTTGSUBTable = new CFX_CTTGSUBTable;
             m_pTTGSUBTable->LoadGSUBTable((FT_Bytes)m_Font.m_pGsubData);
             TT_uint32_t vindex = 0;
             m_pTTGSUBTable->GetVerticalGlyph(index, &vindex);
             if (vindex) {
                 index = vindex;
@@ skipping 250 matching lines @@
     CheckFontMetrics();
     m_DefaultWidth = 1000;
     m_pAnsiWidths = FX_Alloc(FX_WORD, 128);
     for (int i = 32; i < 127; i ++) {
         m_pAnsiWidths[i] = 500;
     }
     return TRUE;
 }
 const struct _CIDTransform {
     FX_WORD             CID;
-    FX_BYTE             a, b, c, d, e, f;
+    uint8_t             a, b, c, d, e, f;
 }
 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},
@@ skipping 157 matching lines @@
         if (middlecode > CID) {
             end = middle - 1;
         } else if (middlecode < CID) {
             begin = middle + 1;
         } else {
             return &Japan1_VertCIDs[middle].a;
         }
     }
     return NULL;
 }