1 // Copyright 2014 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
6 
7 #include "core/fpdfapi/font/cpdf_cmapparser.h"
8 
9 #include "core/fpdfapi/cmaps/fpdf_cmaps.h"
10 #include "core/fpdfapi/parser/cpdf_array.h"
11 #include "core/fpdfapi/parser/cpdf_dictionary.h"
12 #include "core/fpdfapi/parser/cpdf_simple_parser.h"
13 #include "core/fxcrt/fx_extension.h"
14 #include "core/fxcrt/fx_safe_types.h"
15 #include "core/fxge/fx_freetype.h"
16 #include "third_party/base/stl_util.h"
17 
18 namespace {
19 
CMap_GetString(ByteStringView word)20 ByteStringView CMap_GetString(ByteStringView word) {
21   if (word.GetLength() <= 2)
22     return ByteStringView();
23   return word.Last(word.GetLength() - 2);
24 }
25 
26 }  // namespace
27 
CPDF_CMapParser(CPDF_CMap * pCMap)28 CPDF_CMapParser::CPDF_CMapParser(CPDF_CMap* pCMap) : m_pCMap(pCMap) {}
29 
~CPDF_CMapParser()30 CPDF_CMapParser::~CPDF_CMapParser() {
31   m_pCMap->SetAdditionalMappings(std::move(m_AdditionalCharcodeToCIDMappings));
32   m_pCMap->SetMixedFourByteLeadingRanges(std::move(m_Ranges));
33 }
34 
ParseWord(ByteStringView word)35 void CPDF_CMapParser::ParseWord(ByteStringView word) {
36   ASSERT(!word.IsEmpty());
37 
38   if (word == "begincidchar") {
39     m_Status = kProcessingCidChar;
40     m_CodeSeq = 0;
41   } else if (word == "begincidrange") {
42     m_Status = kProcessingCidRange;
43     m_CodeSeq = 0;
44   } else if (word == "endcidrange" || word == "endcidchar") {
45     m_Status = kStart;
46   } else if (word == "/WMode") {
47     m_Status = kProcessingWMode;
48   } else if (word == "/Registry") {
49     m_Status = kProcessingRegistry;
50   } else if (word == "/Ordering") {
51     m_Status = kProcessingOrdering;
52   } else if (word == "/Supplement") {
53     m_Status = kProcessingSupplement;
54   } else if (word == "begincodespacerange") {
55     m_Status = kProcessingCodeSpaceRange;
56     m_CodeSeq = 0;
57   } else if (word == "usecmap") {
58   } else if (m_Status == kProcessingCidChar) {
59     HandleCid(word);
60   } else if (m_Status == kProcessingCidRange) {
61     HandleCid(word);
62   } else if (m_Status == kProcessingRegistry) {
63     m_Status = kStart;
64   } else if (m_Status == kProcessingOrdering) {
65     m_pCMap->SetCharset(CharsetFromOrdering(CMap_GetString(word)));
66     m_Status = kStart;
67   } else if (m_Status == kProcessingSupplement) {
68     m_Status = kStart;
69   } else if (m_Status == kProcessingWMode) {
70     m_pCMap->SetVertical(GetCode(word) != 0);
71     m_Status = kStart;
72   } else if (m_Status == kProcessingCodeSpaceRange) {
73     HandleCodeSpaceRange(word);
74   }
75   m_LastWord = word;
76 }
77 
HandleCid(ByteStringView word)78 void CPDF_CMapParser::HandleCid(ByteStringView word) {
79   ASSERT(m_Status == kProcessingCidChar || m_Status == kProcessingCidRange);
80   bool bChar = m_Status == kProcessingCidChar;
81 
82   m_CodePoints[m_CodeSeq] = GetCode(word);
83   m_CodeSeq++;
84   int nRequiredCodePoints = bChar ? 2 : 3;
85   if (m_CodeSeq < nRequiredCodePoints)
86     return;
87 
88   uint32_t StartCode = m_CodePoints[0];
89   uint32_t EndCode;
90   uint16_t StartCID;
91   if (bChar) {
92     EndCode = StartCode;
93     StartCID = static_cast<uint16_t>(m_CodePoints[1]);
94   } else {
95     EndCode = m_CodePoints[1];
96     StartCID = static_cast<uint16_t>(m_CodePoints[2]);
97   }
98   if (EndCode < 0x10000) {
99     for (uint32_t code = StartCode; code <= EndCode; code++) {
100       m_pCMap->SetDirectCharcodeToCIDTable(
101           code, static_cast<uint16_t>(StartCID + code - StartCode));
102     }
103   } else {
104     m_AdditionalCharcodeToCIDMappings.push_back({StartCode, EndCode, StartCID});
105   }
106   m_CodeSeq = 0;
107 }
108 
HandleCodeSpaceRange(ByteStringView word)109 void CPDF_CMapParser::HandleCodeSpaceRange(ByteStringView word) {
110   if (word != "endcodespacerange") {
111     if (word.IsEmpty() || word[0] != '<')
112       return;
113 
114     if (m_CodeSeq % 2) {
115       Optional<CPDF_CMap::CodeRange> range =
116           GetCodeRange(m_LastWord.AsStringView(), word);
117       if (range.has_value())
118         m_PendingRanges.push_back(range.value());
119     }
120     m_CodeSeq++;
121     return;
122   }
123 
124   size_t nSegs = m_Ranges.size() + m_PendingRanges.size();
125   if (nSegs == 1) {
126     const auto& first_range =
127         !m_Ranges.empty() ? m_Ranges[0] : m_PendingRanges[0];
128     m_pCMap->SetCodingScheme(first_range.m_CharSize == 2 ? CPDF_CMap::TwoBytes
129                                                          : CPDF_CMap::OneByte);
130   } else if (nSegs > 1) {
131     m_pCMap->SetCodingScheme(CPDF_CMap::MixedFourBytes);
132     m_Ranges.reserve(nSegs);
133     std::move(m_PendingRanges.begin(), m_PendingRanges.end(),
134               std::back_inserter(m_Ranges));
135     m_PendingRanges.clear();
136   }
137   m_Status = kStart;
138 }
139 
140 // static
GetCode(ByteStringView word)141 uint32_t CPDF_CMapParser::GetCode(ByteStringView word) {
142   if (word.IsEmpty())
143     return 0;
144 
145   FX_SAFE_UINT32 num = 0;
146   if (word[0] == '<') {
147     for (size_t i = 1; i < word.GetLength() && std::isxdigit(word[i]); ++i) {
148       num = num * 16 + FXSYS_HexCharToInt(word[i]);
149       if (!num.IsValid())
150         return 0;
151     }
152     return num.ValueOrDie();
153   }
154 
155   for (size_t i = 0; i < word.GetLength() && std::isdigit(word[i]); ++i) {
156     num = num * 10 + FXSYS_DecimalCharToInt(static_cast<wchar_t>(word[i]));
157     if (!num.IsValid())
158       return 0;
159   }
160   return num.ValueOrDie();
161 }
162 
163 // static
GetCodeRange(ByteStringView first,ByteStringView second)164 Optional<CPDF_CMap::CodeRange> CPDF_CMapParser::GetCodeRange(
165     ByteStringView first,
166     ByteStringView second) {
167   if (first.IsEmpty() || first[0] != '<')
168     return pdfium::nullopt;
169 
170   size_t i;
171   for (i = 1; i < first.GetLength(); ++i) {
172     if (first[i] == '>')
173       break;
174   }
175   size_t char_size = (i - 1) / 2;
176   if (char_size > 4)
177     return pdfium::nullopt;
178 
179   CPDF_CMap::CodeRange range;
180   range.m_CharSize = char_size;
181   for (i = 0; i < range.m_CharSize; ++i) {
182     uint8_t digit1 = first[i * 2 + 1];
183     uint8_t digit2 = first[i * 2 + 2];
184     range.m_Lower[i] =
185         FXSYS_HexCharToInt(digit1) * 16 + FXSYS_HexCharToInt(digit2);
186   }
187 
188   size_t size = second.GetLength();
189   for (i = 0; i < range.m_CharSize; ++i) {
190     size_t i1 = i * 2 + 1;
191     size_t i2 = i1 + 1;
192     uint8_t digit1 = i1 < size ? second[i1] : '0';
193     uint8_t digit2 = i2 < size ? second[i2] : '0';
194     range.m_Upper[i] =
195         FXSYS_HexCharToInt(digit1) * 16 + FXSYS_HexCharToInt(digit2);
196   }
197   return range;
198 }
199 
200 // static
CharsetFromOrdering(ByteStringView ordering)201 CIDSet CPDF_CMapParser::CharsetFromOrdering(ByteStringView ordering) {
202   static const char* const kCharsetNames[CIDSET_NUM_SETS] = {
203       nullptr, "GB1", "CNS1", "Japan1", "Korea1", "UCS"};
204   static_assert(pdfium::size(kCharsetNames) == CIDSET_NUM_SETS,
205                 "Too many CID sets");
206 
207   for (size_t charset = 1; charset < pdfium::size(kCharsetNames); ++charset) {
208     if (ordering == kCharsetNames[charset])
209       return static_cast<CIDSet>(charset);
210   }
211   return CIDSET_UNKNOWN;
212 }
213