// Copyright 2017 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/font/cpdf_cmap.h" #include <memory> #include <utility> #include <vector> #include "core/fpdfapi/cmaps/cmap_int.h" #include "core/fpdfapi/font/cpdf_cmapmanager.h" #include "core/fpdfapi/font/cpdf_cmapparser.h" #include "core/fpdfapi/parser/cpdf_simple_parser.h" namespace { struct ByteRange { uint8_t m_First; uint8_t m_Last; // Inclusive. }; struct PredefinedCMap { const char* m_pName; CIDSet m_Charset; CIDCoding m_Coding; CPDF_CMap::CodingScheme m_CodingScheme; uint8_t m_LeadingSegCount; ByteRange m_LeadingSegs[2]; }; const PredefinedCMap g_PredefinedCMaps[] = { {"GB-EUC", CIDSET_GB1, CIDCODING_GB, CPDF_CMap::MixedTwoBytes, 1, {{0xa1, 0xfe}}}, {"GBpc-EUC", CIDSET_GB1, CIDCODING_GB, CPDF_CMap::MixedTwoBytes, 1, {{0xa1, 0xfc}}}, {"GBK-EUC", CIDSET_GB1, CIDCODING_GB, CPDF_CMap::MixedTwoBytes, 1, {{0x81, 0xfe}}}, {"GBKp-EUC", CIDSET_GB1, CIDCODING_GB, CPDF_CMap::MixedTwoBytes, 1, {{0x81, 0xfe}}}, {"GBK2K-EUC", CIDSET_GB1, CIDCODING_GB, CPDF_CMap::MixedTwoBytes, 1, {{0x81, 0xfe}}}, {"GBK2K", CIDSET_GB1, CIDCODING_GB, CPDF_CMap::MixedTwoBytes, 1, {{0x81, 0xfe}}}, {"UniGB-UCS2", CIDSET_GB1, CIDCODING_UCS2, CPDF_CMap::TwoBytes, 0, {}}, {"UniGB-UTF16", CIDSET_GB1, CIDCODING_UTF16, CPDF_CMap::TwoBytes, 0, {}}, {"B5pc", CIDSET_CNS1, CIDCODING_BIG5, CPDF_CMap::MixedTwoBytes, 1, {{0xa1, 0xfc}}}, {"HKscs-B5", CIDSET_CNS1, CIDCODING_BIG5, CPDF_CMap::MixedTwoBytes, 1, {{0x88, 0xfe}}}, {"ETen-B5", CIDSET_CNS1, CIDCODING_BIG5, CPDF_CMap::MixedTwoBytes, 1, {{0xa1, 0xfe}}}, {"ETenms-B5", CIDSET_CNS1, CIDCODING_BIG5, CPDF_CMap::MixedTwoBytes, 1, {{0xa1, 0xfe}}}, {"UniCNS-UCS2", CIDSET_CNS1, CIDCODING_UCS2, CPDF_CMap::TwoBytes, 0, {}}, {"UniCNS-UTF16", CIDSET_CNS1, CIDCODING_UTF16, CPDF_CMap::TwoBytes, 0, {}}, {"83pv-RKSJ", CIDSET_JAPAN1, CIDCODING_JIS, CPDF_CMap::MixedTwoBytes, 2, {{0x81, 0x9f}, {0xe0, 0xfc}}}, {"90ms-RKSJ", CIDSET_JAPAN1, CIDCODING_JIS, CPDF_CMap::MixedTwoBytes, 2, {{0x81, 0x9f}, {0xe0, 0xfc}}}, {"90msp-RKSJ", CIDSET_JAPAN1, CIDCODING_JIS, CPDF_CMap::MixedTwoBytes, 2, {{0x81, 0x9f}, {0xe0, 0xfc}}}, {"90pv-RKSJ", CIDSET_JAPAN1, CIDCODING_JIS, CPDF_CMap::MixedTwoBytes, 2, {{0x81, 0x9f}, {0xe0, 0xfc}}}, {"Add-RKSJ", CIDSET_JAPAN1, CIDCODING_JIS, CPDF_CMap::MixedTwoBytes, 2, {{0x81, 0x9f}, {0xe0, 0xfc}}}, {"EUC", CIDSET_JAPAN1, CIDCODING_JIS, CPDF_CMap::MixedTwoBytes, 2, {{0x8e, 0x8e}, {0xa1, 0xfe}}}, {"H", CIDSET_JAPAN1, CIDCODING_JIS, CPDF_CMap::TwoBytes, 1, {{0x21, 0x7e}}}, {"V", CIDSET_JAPAN1, CIDCODING_JIS, CPDF_CMap::TwoBytes, 1, {{0x21, 0x7e}}}, {"Ext-RKSJ", CIDSET_JAPAN1, CIDCODING_JIS, CPDF_CMap::MixedTwoBytes, 2, {{0x81, 0x9f}, {0xe0, 0xfc}}}, {"UniJIS-UCS2", CIDSET_JAPAN1, CIDCODING_UCS2, CPDF_CMap::TwoBytes, 0, {}}, {"UniJIS-UCS2-HW", CIDSET_JAPAN1, CIDCODING_UCS2, CPDF_CMap::TwoBytes, 0, {}}, {"UniJIS-UTF16", CIDSET_JAPAN1, CIDCODING_UTF16, CPDF_CMap::TwoBytes, 0, {}}, {"KSC-EUC", CIDSET_KOREA1, CIDCODING_KOREA, CPDF_CMap::MixedTwoBytes, 1, {{0xa1, 0xfe}}}, {"KSCms-UHC", CIDSET_KOREA1, CIDCODING_KOREA, CPDF_CMap::MixedTwoBytes, 1, {{0x81, 0xfe}}}, {"KSCms-UHC-HW", CIDSET_KOREA1, CIDCODING_KOREA, CPDF_CMap::MixedTwoBytes, 1, {{0x81, 0xfe}}}, {"KSCpc-EUC", CIDSET_KOREA1, CIDCODING_KOREA, CPDF_CMap::MixedTwoBytes, 1, {{0xa1, 0xfd}}}, {"UniKS-UCS2", CIDSET_KOREA1, CIDCODING_UCS2, CPDF_CMap::TwoBytes, 0, {}}, {"UniKS-UTF16", CIDSET_KOREA1, CIDCODING_UTF16, CPDF_CMap::TwoBytes, 0, {}}, }; int CheckFourByteCodeRange(uint8_t* codes, int size, const std::vector<CPDF_CMap::CodeRange>& ranges) { int iSeg = pdfium::CollectionSize<int>(ranges) - 1; while (iSeg >= 0) { if (ranges[iSeg].m_CharSize < size) { --iSeg; continue; } int iChar = 0; while (iChar < size) { if (codes[iChar] < ranges[iSeg].m_Lower[iChar] || codes[iChar] > ranges[iSeg].m_Upper[iChar]) { break; } ++iChar; } if (iChar == ranges[iSeg].m_CharSize) return 2; if (iChar) return (size == ranges[iSeg].m_CharSize) ? 2 : 1; iSeg--; } return 0; } int GetFourByteCharSizeImpl(uint32_t charcode, const std::vector<CPDF_CMap::CodeRange>& ranges) { if (ranges.empty()) 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; int size = 4; for (int i = 0; i < 4; ++i) { int iSeg = pdfium::CollectionSize<int>(ranges) - 1; while (iSeg >= 0) { if (ranges[iSeg].m_CharSize < size) { --iSeg; continue; } int iChar = 0; while (iChar < size) { if (codes[offset + iChar] < ranges[iSeg].m_Lower[iChar] || codes[offset + iChar] > ranges[iSeg].m_Upper[iChar]) { break; } ++iChar; } if (iChar == ranges[iSeg].m_CharSize) return size; --iSeg; } --size; ++offset; } return 1; } } // namespace CPDF_CMap::CPDF_CMap() : m_bLoaded(false), m_bVertical(false), m_Charset(CIDSET_UNKNOWN), m_CodingScheme(TwoBytes), m_Coding(CIDCODING_UNKNOWN), m_pEmbedMap(nullptr) {} CPDF_CMap::~CPDF_CMap() {} void CPDF_CMap::LoadPredefined(CPDF_CMapManager* pMgr, const CFX_ByteString& bsName, bool bPromptCJK) { m_PredefinedCMap = bsName; if (m_PredefinedCMap == "Identity-H" || m_PredefinedCMap == "Identity-V") { m_Coding = CIDCODING_CID; m_bVertical = bsName[9] == 'V'; m_bLoaded = true; return; } CFX_ByteString cmapid = m_PredefinedCMap; m_bVertical = cmapid.Right(1) == "V"; if (cmapid.GetLength() > 2) { cmapid = cmapid.Left(cmapid.GetLength() - 2); } const PredefinedCMap* map = nullptr; for (size_t i = 0; i < FX_ArraySize(g_PredefinedCMaps); ++i) { if (cmapid == CFX_ByteStringC(g_PredefinedCMaps[i].m_pName)) { map = &g_PredefinedCMaps[i]; break; } } if (!map) return; m_Charset = map->m_Charset; m_Coding = map->m_Coding; m_CodingScheme = map->m_CodingScheme; if (m_CodingScheme == MixedTwoBytes) { m_MixedTwoByteLeadingBytes = std::vector<bool>(256); for (uint32_t i = 0; i < map->m_LeadingSegCount; ++i) { const ByteRange& seg = map->m_LeadingSegs[i]; for (int b = seg.m_First; b <= seg.m_Last; ++b) m_MixedTwoByteLeadingBytes[b] = true; } } FPDFAPI_FindEmbeddedCMap(bsName, m_Charset, m_Coding, m_pEmbedMap); if (!m_pEmbedMap) return; m_bLoaded = true; } void CPDF_CMap::LoadEmbedded(const uint8_t* pData, uint32_t size) { m_DirectCharcodeToCIDTable = std::vector<uint16_t>(65536); CPDF_CMapParser parser(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.HasAdditionalMappings()) { m_AdditionalCharcodeToCIDMappings = parser.TakeAdditionalMappings(); std::sort( m_AdditionalCharcodeToCIDMappings.begin(), m_AdditionalCharcodeToCIDMappings.end(), [](const CPDF_CMap::CIDRange& arg1, const CPDF_CMap::CIDRange& arg2) { return arg1.m_EndCode < arg2.m_EndCode; }); } } uint16_t CPDF_CMap::CIDFromCharCode(uint32_t charcode) const { if (m_Coding == CIDCODING_CID) return static_cast<uint16_t>(charcode); if (m_pEmbedMap) return FPDFAPI_CIDFromCharCode(m_pEmbedMap, charcode); if (m_DirectCharcodeToCIDTable.empty()) return static_cast<uint16_t>(charcode); if (charcode < 0x10000) return m_DirectCharcodeToCIDTable[charcode]; auto it = std::lower_bound(m_AdditionalCharcodeToCIDMappings.begin(), m_AdditionalCharcodeToCIDMappings.end(), charcode, [](const CPDF_CMap::CIDRange& arg, uint32_t val) { return arg.m_EndCode < val; }); if (it == m_AdditionalCharcodeToCIDMappings.end() || it->m_StartCode > charcode) { return 0; } return it->m_StartCID + charcode - it->m_StartCode; } uint32_t CPDF_CMap::GetNextChar(const char* pString, int nStrLen, int& offset) const { auto* pBytes = reinterpret_cast<const uint8_t*>(pString); switch (m_CodingScheme) { case OneByte: { return pBytes[offset++]; } case TwoBytes: { uint8_t byte1 = pBytes[offset++]; return 256 * byte1 + pBytes[offset++]; } case MixedTwoBytes: { uint8_t byte1 = pBytes[offset++]; if (!m_MixedTwoByteLeadingBytes[byte1]) return byte1; return 256 * byte1 + pBytes[offset++]; } case MixedFourBytes: { uint8_t codes[4]; int char_size = 1; codes[0] = pBytes[offset++]; while (1) { int ret = CheckFourByteCodeRange(codes, char_size, m_MixedFourByteLeadingRanges); if (ret == 0) return 0; if (ret == 2) { 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++] = pBytes[offset++]; } break; } } return 0; } int CPDF_CMap::GetCharSize(uint32_t charcode) const { switch (m_CodingScheme) { case OneByte: return 1; case TwoBytes: return 2; case MixedTwoBytes: if (charcode < 0x100) return 1; return 2; case MixedFourBytes: if (charcode < 0x100) return 1; if (charcode < 0x10000) return 2; if (charcode < 0x1000000) return 3; return 4; } return 1; } int CPDF_CMap::CountChar(const char* pString, int size) const { switch (m_CodingScheme) { case OneByte: return size; case TwoBytes: return (size + 1) / 2; case MixedTwoBytes: { int count = 0; for (int i = 0; i < size; i++) { count++; if (m_MixedTwoByteLeadingBytes[reinterpret_cast<const uint8_t*>( pString)[i]]) { i++; } } return count; } case MixedFourBytes: { int count = 0, offset = 0; while (offset < size) { GetNextChar(pString, size, offset); count++; } return count; } } return size; } int CPDF_CMap::AppendChar(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: if (charcode < 0x100 && !m_MixedTwoByteLeadingBytes[(uint8_t)charcode]) { str[0] = (uint8_t)charcode; return 1; } str[0] = (uint8_t)(charcode >> 8); str[1] = (uint8_t)charcode; return 2; case MixedFourBytes: if (charcode < 0x100) { int iSize = GetFourByteCharSizeImpl(charcode, m_MixedFourByteLeadingRanges); if (iSize == 0) iSize = 1; str[iSize - 1] = (uint8_t)charcode; if (iSize > 1) memset(str, 0, iSize - 1); return iSize; } if (charcode < 0x10000) { str[0] = (uint8_t)(charcode >> 8); str[1] = (uint8_t)charcode; return 2; } if (charcode < 0x1000000) { str[0] = (uint8_t)(charcode >> 16); str[1] = (uint8_t)(charcode >> 8); str[2] = (uint8_t)charcode; return 3; } 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; }