1 /*
2 * Copyright 2011 Google Inc. All Rights Reserved.
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "sfntly/table/core/name_table.h"
18
19 #include <stdio.h>
20 #include <string.h>
21
22 #include <unicode/unistr.h>
23
24 #include "sfntly/font.h"
25 #include "sfntly/port/exception_type.h"
26
27 namespace sfntly {
28 /******************************************************************************
29 * NameTable::NameEntryId class
30 ******************************************************************************/
NameEntryId()31 NameTable::NameEntryId::NameEntryId()
32 : platform_id_(0),
33 encoding_id_(0),
34 language_id_(0),
35 name_id_(0) {
36 }
37
NameEntryId(int32_t platform_id,int32_t encoding_id,int32_t language_id,int32_t name_id)38 NameTable::NameEntryId::NameEntryId(int32_t platform_id,
39 int32_t encoding_id,
40 int32_t language_id,
41 int32_t name_id)
42 : platform_id_(platform_id),
43 encoding_id_(encoding_id),
44 language_id_(language_id),
45 name_id_(name_id) {
46 }
47
NameEntryId(const NameTable::NameEntryId & rhs)48 NameTable::NameEntryId::NameEntryId(const NameTable::NameEntryId& rhs) {
49 *this = rhs;
50 }
51
52 const NameTable::NameEntryId&
operator =(const NameTable::NameEntryId & rhs) const53 NameTable::NameEntryId::operator=(const NameTable::NameEntryId& rhs) const {
54 platform_id_ = rhs.platform_id_;
55 encoding_id_ = rhs.encoding_id_;
56 language_id_ = rhs.language_id_;
57 name_id_ = rhs.name_id_;
58 return *this;
59 }
60
operator ==(const NameEntryId & rhs) const61 bool NameTable::NameEntryId::operator==(const NameEntryId& rhs) const {
62 return platform_id_ == rhs.platform_id_ &&
63 encoding_id_ == rhs.encoding_id_ &&
64 language_id_ == rhs.language_id_ &&
65 name_id_ == rhs.name_id_;
66 }
67
operator <(const NameEntryId & rhs) const68 bool NameTable::NameEntryId::operator<(const NameEntryId& rhs) const {
69 if (platform_id_ != rhs.platform_id_) return platform_id_ < rhs.platform_id_;
70 if (encoding_id_ != rhs.encoding_id_) return encoding_id_ < rhs.encoding_id_;
71 if (language_id_ != rhs.language_id_) return language_id_ < rhs.language_id_;
72 return name_id_ < rhs.name_id_;
73 }
74
75 /******************************************************************************
76 * NameTable::NameEntry class
77 ******************************************************************************/
NameEntry()78 NameTable::NameEntry::NameEntry() {
79 Init(0, 0, 0, 0, NULL);
80 }
81
NameEntry(const NameEntryId & name_entry_id,const ByteVector & name_bytes)82 NameTable::NameEntry::NameEntry(const NameEntryId& name_entry_id,
83 const ByteVector& name_bytes) {
84 Init(name_entry_id.platform_id(),
85 name_entry_id.encoding_id(),
86 name_entry_id.language_id(),
87 name_entry_id.name_id(),
88 &name_bytes);
89 }
90
NameEntry(int32_t platform_id,int32_t encoding_id,int32_t language_id,int32_t name_id,const ByteVector & name_bytes)91 NameTable::NameEntry::NameEntry(int32_t platform_id,
92 int32_t encoding_id,
93 int32_t language_id,
94 int32_t name_id,
95 const ByteVector& name_bytes) {
96 Init(platform_id, encoding_id, language_id, name_id, &name_bytes);
97 }
98
~NameEntry()99 NameTable::NameEntry::~NameEntry() {}
100
NameAsBytes()101 ByteVector* NameTable::NameEntry::NameAsBytes() {
102 return &name_bytes_;
103 }
104
NameBytesLength()105 int32_t NameTable::NameEntry::NameBytesLength() {
106 return name_bytes_.size();
107 }
108
Name()109 UChar* NameTable::NameEntry::Name() {
110 return NameTable::ConvertFromNameBytes(&name_bytes_,
111 platform_id(),
112 encoding_id());
113 }
114
operator ==(const NameEntry & rhs) const115 bool NameTable::NameEntry::operator==(const NameEntry& rhs) const {
116 return (name_entry_id_ == rhs.name_entry_id_ &&
117 name_bytes_ == rhs.name_bytes_);
118 }
119
Init(int32_t platform_id,int32_t encoding_id,int32_t language_id,int32_t name_id,const ByteVector * name_bytes)120 void NameTable::NameEntry::Init(int32_t platform_id,
121 int32_t encoding_id,
122 int32_t language_id,
123 int32_t name_id,
124 const ByteVector* name_bytes) {
125 name_entry_id_ = NameEntryId(platform_id, encoding_id, language_id, name_id);
126 if (name_bytes) {
127 name_bytes_ = *name_bytes;
128 } else {
129 name_bytes_.clear();
130 }
131 }
132
133 /******************************************************************************
134 * NameTable::NameEntryBuilder class
135 ******************************************************************************/
NameEntryBuilder()136 NameTable::NameEntryBuilder::NameEntryBuilder() {
137 Init(0, 0, 0, 0, NULL);
138 }
139
NameEntryBuilder(const NameEntryId & name_entry_id,const ByteVector & name_bytes)140 NameTable::NameEntryBuilder::NameEntryBuilder(const NameEntryId& name_entry_id,
141 const ByteVector& name_bytes) {
142 Init(name_entry_id.platform_id(),
143 name_entry_id.encoding_id(),
144 name_entry_id.language_id(),
145 name_entry_id.name_id(),
146 &name_bytes);
147 }
148
NameEntryBuilder(const NameEntryId & name_entry_id)149 NameTable::NameEntryBuilder::NameEntryBuilder(
150 const NameEntryId& name_entry_id) {
151 Init(name_entry_id.platform_id(),
152 name_entry_id.encoding_id(),
153 name_entry_id.language_id(),
154 name_entry_id.name_id(),
155 NULL);
156 }
157
NameEntryBuilder(NameEntry * b)158 NameTable::NameEntryBuilder::NameEntryBuilder(NameEntry* b) {
159 Init(b->platform_id(),
160 b->encoding_id(),
161 b->language_id(),
162 b->name_id(),
163 b->NameAsBytes());
164 }
165
~NameEntryBuilder()166 NameTable::NameEntryBuilder::~NameEntryBuilder() {}
167
SetName(const UChar * name)168 void NameTable::NameEntryBuilder::SetName(const UChar* name) {
169 if (name == NULL) {
170 name_entry_->name_bytes_.clear();
171 return;
172 }
173 NameTable::ConvertToNameBytes(name,
174 name_entry_->platform_id(),
175 name_entry_->encoding_id(),
176 &name_entry_->name_bytes_);
177 }
178
SetName(const ByteVector & name_bytes)179 void NameTable::NameEntryBuilder::SetName(const ByteVector& name_bytes) {
180 name_entry_->name_bytes_.clear();
181 std::copy(name_bytes.begin(),
182 name_bytes.end(),
183 name_entry_->name_bytes_.begin());
184 }
185
SetName(const ByteVector & name_bytes,int32_t offset,int32_t length)186 void NameTable::NameEntryBuilder::SetName(const ByteVector& name_bytes,
187 int32_t offset,
188 int32_t length) {
189 name_entry_->name_bytes_.clear();
190 std::copy(name_bytes.begin() + offset,
191 name_bytes.begin() + offset + length,
192 name_entry_->name_bytes_.begin());
193 }
194
Init(int32_t platform_id,int32_t encoding_id,int32_t language_id,int32_t name_id,const ByteVector * name_bytes)195 void NameTable::NameEntryBuilder::Init(int32_t platform_id,
196 int32_t encoding_id,
197 int32_t language_id,
198 int32_t name_id,
199 const ByteVector* name_bytes) {
200 name_entry_ = new NameEntry();
201 name_entry_->Init(platform_id, encoding_id, language_id, name_id, name_bytes);
202 }
203
204 /******************************************************************************
205 * NameTable::NameEntryFilterInPlace class (C++ port only)
206 ******************************************************************************/
NameEntryFilterInPlace(int32_t platform_id,int32_t encoding_id,int32_t language_id,int32_t name_id)207 NameTable::NameEntryFilterInPlace::NameEntryFilterInPlace(int32_t platform_id,
208 int32_t encoding_id,
209 int32_t language_id,
210 int32_t name_id)
211 : platform_id_(platform_id),
212 encoding_id_(encoding_id),
213 language_id_(language_id),
214 name_id_(name_id) {
215 }
216
Accept(int32_t platform_id,int32_t encoding_id,int32_t language_id,int32_t name_id)217 bool NameTable::NameEntryFilterInPlace::Accept(int32_t platform_id,
218 int32_t encoding_id,
219 int32_t language_id,
220 int32_t name_id) {
221 return (platform_id_ == platform_id &&
222 encoding_id_ == encoding_id &&
223 language_id_ == language_id &&
224 name_id_ == name_id);
225 }
226
227 /******************************************************************************
228 * NameTable::NameEntryIterator class
229 ******************************************************************************/
NameEntryIterator(NameTable * table)230 NameTable::NameEntryIterator::NameEntryIterator(NameTable* table)
231 : RefIterator<NameEntry, NameTable>(table),
232 name_index_(0),
233 filter_(NULL) {
234 }
235
NameEntryIterator(NameTable * table,NameEntryFilter * filter)236 NameTable::NameEntryIterator::NameEntryIterator(NameTable* table,
237 NameEntryFilter* filter)
238 : RefIterator<NameEntry, NameTable>(table),
239 name_index_(0),
240 filter_(filter) {
241 }
242
HasNext()243 bool NameTable::NameEntryIterator::HasNext() {
244 if (!filter_) {
245 if (name_index_ < container()->NameCount()) {
246 return true;
247 }
248 return false;
249 }
250 for (; name_index_ < container()->NameCount(); ++name_index_) {
251 if (filter_->Accept(container()->PlatformId(name_index_),
252 container()->EncodingId(name_index_),
253 container()->LanguageId(name_index_),
254 container()->NameId(name_index_))) {
255 return true;
256 }
257 }
258 return false;
259 }
260
Next()261 CALLER_ATTACH NameTable::NameEntry* NameTable::NameEntryIterator::Next() {
262 if (!HasNext())
263 return NULL;
264 return container()->GetNameEntry(name_index_++);
265 }
266
267 /******************************************************************************
268 * NameTable::Builder class
269 ******************************************************************************/
Builder(Header * header,WritableFontData * data)270 NameTable::Builder::Builder(Header* header, WritableFontData* data)
271 : SubTableContainerTable::Builder(header, data) {
272 }
273
Builder(Header * header,ReadableFontData * data)274 NameTable::Builder::Builder(Header* header, ReadableFontData* data)
275 : SubTableContainerTable::Builder(header, data) {
276 }
277
278 CALLER_ATTACH NameTable::Builder*
CreateBuilder(Header * header,WritableFontData * data)279 NameTable::Builder::CreateBuilder(Header* header,
280 WritableFontData* data) {
281 Ptr<NameTable::Builder> builder;
282 builder = new NameTable::Builder(header, data);
283 return builder.Detach();
284 }
285
RevertNames()286 void NameTable::Builder::RevertNames() {
287 name_entry_map_.clear();
288 set_model_changed(false);
289 }
290
BuilderCount()291 int32_t NameTable::Builder::BuilderCount() {
292 GetNameBuilders(); // Ensure name_entry_map_ is built.
293 return (int32_t)name_entry_map_.size();
294 }
295
Has(int32_t platform_id,int32_t encoding_id,int32_t language_id,int32_t name_id)296 bool NameTable::Builder::Has(int32_t platform_id,
297 int32_t encoding_id,
298 int32_t language_id,
299 int32_t name_id) {
300 NameEntryId probe(platform_id, encoding_id, language_id, name_id);
301 GetNameBuilders(); // Ensure name_entry_map_ is built.
302 return (name_entry_map_.find(probe) != name_entry_map_.end());
303 }
304
305 CALLER_ATTACH NameTable::NameEntryBuilder*
NameBuilder(int32_t platform_id,int32_t encoding_id,int32_t language_id,int32_t name_id)306 NameTable::Builder::NameBuilder(int32_t platform_id,
307 int32_t encoding_id,
308 int32_t language_id,
309 int32_t name_id) {
310 NameEntryId probe(platform_id, encoding_id, language_id, name_id);
311 NameEntryBuilderMap builders;
312 GetNameBuilders(); // Ensure name_entry_map_ is built.
313 if (name_entry_map_.find(probe) != name_entry_map_.end()) {
314 return name_entry_map_[probe];
315 }
316 NameEntryBuilderPtr builder = new NameEntryBuilder(probe);
317 name_entry_map_[probe] = builder;
318 return builder.Detach();
319 }
320
Remove(int32_t platform_id,int32_t encoding_id,int32_t language_id,int32_t name_id)321 bool NameTable::Builder::Remove(int32_t platform_id,
322 int32_t encoding_id,
323 int32_t language_id,
324 int32_t name_id) {
325 NameEntryId probe(platform_id, encoding_id, language_id, name_id);
326 GetNameBuilders(); // Ensure name_entry_map_ is built.
327 NameEntryBuilderMap::iterator position = name_entry_map_.find(probe);
328 if (position != name_entry_map_.end()) {
329 name_entry_map_.erase(position);
330 return true;
331 }
332 return false;
333 }
334
335 CALLER_ATTACH FontDataTable*
SubBuildTable(ReadableFontData * data)336 NameTable::Builder::SubBuildTable(ReadableFontData* data) {
337 FontDataTablePtr table = new NameTable(header(), data);
338 return table.Detach();
339 }
340
SubDataSet()341 void NameTable::Builder::SubDataSet() {
342 name_entry_map_.clear();
343 set_model_changed(false);
344 }
345
SubDataSizeToSerialize()346 int32_t NameTable::Builder::SubDataSizeToSerialize() {
347 if (name_entry_map_.empty()) {
348 return 0;
349 }
350
351 int32_t size = NameTable::Offset::kNameRecordStart +
352 name_entry_map_.size() * NameTable::Offset::kNameRecordSize;
353 for (NameEntryBuilderMap::iterator b = name_entry_map_.begin(),
354 end = name_entry_map_.end();
355 b != end; ++b) {
356 NameEntryBuilderPtr p = b->second;
357 NameEntry* entry = p->name_entry();
358 size += entry->NameBytesLength();
359 }
360 return size;
361 }
362
SubReadyToSerialize()363 bool NameTable::Builder::SubReadyToSerialize() {
364 return !name_entry_map_.empty();
365 }
366
SubSerialize(WritableFontData * new_data)367 int32_t NameTable::Builder::SubSerialize(WritableFontData* new_data) {
368 int32_t string_table_start_offset =
369 NameTable::Offset::kNameRecordStart +
370 name_entry_map_.size() * NameTable::Offset::kNameRecordSize;
371
372 // Header
373 new_data->WriteUShort(NameTable::Offset::kFormat, 0);
374 new_data->WriteUShort(NameTable::Offset::kCount, name_entry_map_.size());
375 new_data->WriteUShort(NameTable::Offset::kStringOffset,
376 string_table_start_offset);
377 int32_t name_record_offset = NameTable::Offset::kNameRecordStart;
378 int32_t string_offset = 0;
379 // Note: we offered operator< in NameEntryId, which will be used by std::less,
380 // and therefore our map will act like TreeMap in Java to provide
381 // sorted key set.
382 for (NameEntryBuilderMap::iterator b = name_entry_map_.begin(),
383 end = name_entry_map_.end();
384 b != end; ++b) {
385 new_data->WriteUShort(
386 name_record_offset + NameTable::Offset::kNameRecordPlatformId,
387 b->first.platform_id());
388 new_data->WriteUShort(
389 name_record_offset + NameTable::Offset::kNameRecordEncodingId,
390 b->first.encoding_id());
391 new_data->WriteUShort(
392 name_record_offset + NameTable::Offset::kNameRecordLanguageId,
393 b->first.language_id());
394 new_data->WriteUShort(
395 name_record_offset + NameTable::Offset::kNameRecordNameId,
396 b->first.name_id());
397 NameEntry* builder_entry = b->second->name_entry();
398 new_data->WriteUShort(
399 name_record_offset + NameTable::Offset::kNameRecordStringLength,
400 builder_entry->NameBytesLength());
401 new_data->WriteUShort(
402 name_record_offset + NameTable::Offset::kNameRecordStringOffset,
403 string_offset);
404 name_record_offset += NameTable::Offset::kNameRecordSize;
405 string_offset += new_data->WriteBytes(
406 string_offset + string_table_start_offset,
407 builder_entry->NameAsBytes());
408 }
409
410 return string_offset + string_table_start_offset;
411 }
412
Initialize(ReadableFontData * data)413 void NameTable::Builder::Initialize(ReadableFontData* data) {
414 if (data) {
415 NameTablePtr table = new NameTable(header(), data);
416 Ptr<NameEntryIterator> name_iter;
417 name_iter.Attach(table->Iterator());
418 while (name_iter->HasNext()) {
419 NameEntryPtr name_entry;
420 name_entry.Attach(name_iter->Next());
421 NameEntryBuilderPtr name_entry_builder = new NameEntryBuilder(name_entry);
422 NameEntry* builder_entry = name_entry_builder->name_entry();
423 NameEntryId probe = builder_entry->name_entry_id();
424 name_entry_map_[probe] = name_entry_builder;
425 }
426 }
427 }
428
GetNameBuilders()429 NameTable::NameEntryBuilderMap* NameTable::Builder::GetNameBuilders() {
430 if (name_entry_map_.empty()) {
431 Initialize(InternalReadData());
432 }
433 set_model_changed();
434 return &name_entry_map_;
435 }
436
437 /******************************************************************************
438 * NameTable class
439 ******************************************************************************/
~NameTable()440 NameTable::~NameTable() {}
441
Format()442 int32_t NameTable::Format() {
443 return data_->ReadUShort(Offset::kFormat);
444 }
445
NameCount()446 int32_t NameTable::NameCount() {
447 return data_->ReadUShort(Offset::kCount);
448 }
449
PlatformId(int32_t index)450 int32_t NameTable::PlatformId(int32_t index) {
451 return data_->ReadUShort(Offset::kNameRecordPlatformId +
452 OffsetForNameRecord(index));
453 }
454
EncodingId(int32_t index)455 int32_t NameTable::EncodingId(int32_t index) {
456 return data_->ReadUShort(Offset::kNameRecordEncodingId +
457 OffsetForNameRecord(index));
458 }
459
LanguageId(int32_t index)460 int32_t NameTable::LanguageId(int32_t index) {
461 return data_->ReadUShort(Offset::kNameRecordLanguageId +
462 OffsetForNameRecord(index));
463 }
464
NameId(int32_t index)465 int32_t NameTable::NameId(int32_t index) {
466 return data_->ReadUShort(Offset::kNameRecordNameId +
467 OffsetForNameRecord(index));
468 }
469
NameAsBytes(int32_t index,ByteVector * b)470 void NameTable::NameAsBytes(int32_t index, ByteVector* b) {
471 assert(b);
472 int32_t length = NameLength(index);
473 b->clear();
474 b->resize(length);
475 if (length > 0) {
476 data_->ReadBytes(NameOffset(index), &((*b)[0]), 0, length);
477 }
478 }
479
NameAsBytes(int32_t platform_id,int32_t encoding_id,int32_t language_id,int32_t name_id,ByteVector * b)480 void NameTable::NameAsBytes(int32_t platform_id,
481 int32_t encoding_id,
482 int32_t language_id,
483 int32_t name_id,
484 ByteVector* b) {
485 assert(b);
486 NameEntryPtr entry;
487 entry.Attach(GetNameEntry(platform_id, encoding_id, language_id, name_id));
488 if (entry) {
489 ByteVector* name = entry->NameAsBytes();
490 std::copy(name->begin(), name->end(), b->begin());
491 }
492 }
493
Name(int32_t index)494 UChar* NameTable::Name(int32_t index) {
495 ByteVector b;
496 NameAsBytes(index, &b);
497 return ConvertFromNameBytes(&b, PlatformId(index), EncodingId(index));
498 }
499
Name(int32_t platform_id,int32_t encoding_id,int32_t language_id,int32_t name_id)500 UChar* NameTable::Name(int32_t platform_id,
501 int32_t encoding_id,
502 int32_t language_id,
503 int32_t name_id) {
504 NameEntryPtr entry;
505 entry.Attach(GetNameEntry(platform_id, encoding_id, language_id, name_id));
506 if (entry) {
507 return entry->Name();
508 }
509 return NULL;
510 }
511
GetNameEntry(int32_t index)512 CALLER_ATTACH NameTable::NameEntry* NameTable::GetNameEntry(int32_t index) {
513 ByteVector b;
514 NameAsBytes(index, &b);
515 NameEntryPtr instance = new NameEntry(PlatformId(index),
516 EncodingId(index),
517 LanguageId(index),
518 NameId(index), b);
519 return instance.Detach();
520 }
521
GetNameEntry(int32_t platform_id,int32_t encoding_id,int32_t language_id,int32_t name_id)522 CALLER_ATTACH NameTable::NameEntry* NameTable::GetNameEntry(int32_t platform_id,
523 int32_t encoding_id,
524 int32_t language_id,
525 int32_t name_id) {
526 NameTable::NameEntryFilterInPlace
527 filter(platform_id, encoding_id, language_id, name_id);
528 Ptr<NameTable::NameEntryIterator> name_entry_iter;
529 name_entry_iter.Attach(Iterator(&filter));
530 NameEntryPtr result;
531 if (name_entry_iter->HasNext()) {
532 result = name_entry_iter->Next();
533 }
534 return result;
535 }
536
Iterator()537 CALLER_ATTACH NameTable::NameEntryIterator* NameTable::Iterator() {
538 Ptr<NameEntryIterator> output = new NameTable::NameEntryIterator(this);
539 return output.Detach();
540 }
541
542 CALLER_ATTACH
Iterator(NameEntryFilter * filter)543 NameTable::NameEntryIterator* NameTable::Iterator(NameEntryFilter* filter) {
544 Ptr<NameEntryIterator> output =
545 new NameTable::NameEntryIterator(this, filter);
546 return output.Detach();
547 }
548
NameTable(Header * header,ReadableFontData * data)549 NameTable::NameTable(Header* header, ReadableFontData* data)
550 : SubTableContainerTable(header, data) {}
551
StringOffset()552 int32_t NameTable::StringOffset() {
553 return data_->ReadUShort(Offset::kStringOffset);
554 }
555
OffsetForNameRecord(int32_t index)556 int32_t NameTable::OffsetForNameRecord(int32_t index) {
557 return Offset::kNameRecordStart + index * Offset::kNameRecordSize;
558 }
559
NameLength(int32_t index)560 int32_t NameTable::NameLength(int32_t index) {
561 return data_->ReadUShort(Offset::kNameRecordStringLength +
562 OffsetForNameRecord(index));
563 }
564
NameOffset(int32_t index)565 int32_t NameTable::NameOffset(int32_t index) {
566 return data_->ReadUShort(Offset::kNameRecordStringOffset +
567 OffsetForNameRecord(index)) + StringOffset();
568 }
569
GetEncodingName(int32_t platform_id,int32_t encoding_id)570 const char* NameTable::GetEncodingName(int32_t platform_id,
571 int32_t encoding_id) {
572 switch (platform_id) {
573 case PlatformId::kUnicode:
574 return "UTF-16BE";
575 case PlatformId::kMacintosh:
576 switch (encoding_id) {
577 case MacintoshEncodingId::kRoman:
578 return "MacRoman";
579 case MacintoshEncodingId::kJapanese:
580 return "Shift-JIS";
581 case MacintoshEncodingId::kChineseTraditional:
582 return "Big5";
583 case MacintoshEncodingId::kKorean:
584 return "EUC-KR";
585 case MacintoshEncodingId::kArabic:
586 return "MacArabic";
587 case MacintoshEncodingId::kHebrew:
588 return "MacHebrew";
589 case MacintoshEncodingId::kGreek:
590 return "MacGreek";
591 case MacintoshEncodingId::kRussian:
592 return "MacCyrillic";
593 case MacintoshEncodingId::kRSymbol:
594 return "MacSymbol";
595 case MacintoshEncodingId::kThai:
596 return "MacThai";
597 case MacintoshEncodingId::kChineseSimplified:
598 return "EUC-CN";
599 default: // Note: unknown/unconfirmed cases are not ported.
600 break;
601 }
602 break;
603 case PlatformId::kISO:
604 break;
605 case PlatformId::kWindows:
606 switch (encoding_id) {
607 case WindowsEncodingId::kSymbol:
608 case WindowsEncodingId::kUnicodeUCS2:
609 return "UTF-16BE";
610 case WindowsEncodingId::kShiftJIS:
611 return "windows-933";
612 case WindowsEncodingId::kPRC:
613 return "windows-936";
614 case WindowsEncodingId::kBig5:
615 return "windows-950";
616 case WindowsEncodingId::kWansung:
617 return "windows-949";
618 case WindowsEncodingId::kJohab:
619 return "ms1361";
620 case WindowsEncodingId::kUnicodeUCS4:
621 return "UCS-4";
622 }
623 break;
624 case PlatformId::kCustom:
625 break;
626 default:
627 break;
628 }
629 return NULL;
630 }
631
GetCharset(int32_t platform_id,int32_t encoding_id)632 UConverter* NameTable::GetCharset(int32_t platform_id, int32_t encoding_id) {
633 UErrorCode error_code = U_ZERO_ERROR;
634 UConverter* conv = ucnv_open(GetEncodingName(platform_id, encoding_id),
635 &error_code);
636 if (U_SUCCESS(error_code)) {
637 return conv;
638 }
639
640 if (conv) {
641 ucnv_close(conv);
642 }
643 return NULL;
644 }
645
ConvertToNameBytes(const UChar * name,int32_t platform_id,int32_t encoding_id,ByteVector * b)646 void NameTable::ConvertToNameBytes(const UChar* name,
647 int32_t platform_id,
648 int32_t encoding_id,
649 ByteVector* b) {
650 assert(b);
651 assert(name);
652 b->clear();
653 UConverter* cs = GetCharset(platform_id, encoding_id);
654 if (cs == NULL) {
655 return;
656 }
657
658 // Preflight to get buffer size.
659 UErrorCode error_code = U_ZERO_ERROR;
660 int32_t length = ucnv_fromUChars(cs, NULL, 0, name, -1, &error_code);
661 b->resize(length + 4); // The longest termination "\0" is 4 bytes.
662 memset(&((*b)[0]), 0, length + 4);
663 error_code = U_ZERO_ERROR;
664 ucnv_fromUChars(cs,
665 reinterpret_cast<char*>(&((*b)[0])),
666 length + 4,
667 name,
668 -1,
669 &error_code);
670 if (!U_SUCCESS(error_code)) {
671 b->clear();
672 }
673 ucnv_close(cs);
674 }
675
ConvertFromNameBytes(ByteVector * name_bytes,int32_t platform_id,int32_t encoding_id)676 UChar* NameTable::ConvertFromNameBytes(ByteVector* name_bytes,
677 int32_t platform_id,
678 int32_t encoding_id) {
679 if (name_bytes == NULL || name_bytes->size() == 0) {
680 return NULL;
681 }
682 UConverter* cs = GetCharset(platform_id, encoding_id);
683 UErrorCode error_code = U_ZERO_ERROR;
684 if (cs == NULL) {
685 char buffer[11] = {0};
686 #if defined (WIN32)
687 _itoa_s(platform_id, buffer, 16);
688 #else
689 snprintf(buffer, sizeof(buffer), "%x", platform_id);
690 #endif
691 UChar* result = new UChar[12];
692 memset(result, 0, sizeof(UChar) * 12);
693 cs = ucnv_open("utf-8", &error_code);
694 if (U_SUCCESS(error_code)) {
695 ucnv_toUChars(cs, result, 12, buffer, 11, &error_code);
696 ucnv_close(cs);
697 if (U_SUCCESS(error_code)) {
698 return result;
699 }
700 }
701 delete[] result;
702 return NULL;
703 }
704
705 // No preflight needed here, we will be bigger.
706 UChar* output_buffer = new UChar[name_bytes->size() + 1];
707 memset(output_buffer, 0, sizeof(UChar) * (name_bytes->size() + 1));
708 int32_t length = ucnv_toUChars(cs,
709 output_buffer,
710 name_bytes->size(),
711 reinterpret_cast<char*>(&((*name_bytes)[0])),
712 name_bytes->size(),
713 &error_code);
714 ucnv_close(cs);
715 if (length > 0) {
716 return output_buffer;
717 }
718
719 delete[] output_buffer;
720 return NULL;
721 }
722
723 } // namespace sfntly
724