1/*
2 * Copyright © 2014 Google, Inc.
3 *
4 * This is part of HarfBuzz, a text shaping library.
5 *
6 * Permission is hereby granted, without written agreement and without
7 * license or royalty fees, to use, copy, modify, and distribute this
8 * software and its documentation for any purpose, provided that the
9 * above copyright notice and the following two paragraphs appear in
10 * all copies of this software.
11 *
12 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
13 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
14 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
15 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
16 * DAMAGE.
17 *
18 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
19 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
20 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
21 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
22 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
23 *
24 * Google Author(s): Behdad Esfahbod
25 */
26
27#ifndef HB_OT_CMAP_TABLE_HH
28#define HB_OT_CMAP_TABLE_HH
29
30#include "hb-open-type.hh"
31#include "hb-set.hh"
32
33/*
34 * cmap -- Character to Glyph Index Mapping
35 * https://docs.microsoft.com/en-us/typography/opentype/spec/cmap
36 */
37#define HB_OT_TAG_cmap HB_TAG('c','m','a','p')
38
39namespace OT {
40
41
42struct CmapSubtableFormat0
43{
44 bool get_glyph (hb_codepoint_t codepoint, hb_codepoint_t *glyph) const
45 {
46 hb_codepoint_t gid = codepoint < 256 ? glyphIdArray[codepoint] : 0;
47 if (!gid)
48 return false;
49 *glyph = gid;
50 return true;
51 }
52 void collect_unicodes (hb_set_t *out) const
53 {
54 for (unsigned int i = 0; i < 256; i++)
55 if (glyphIdArray[i])
56 out->add (i);
57 }
58
59 bool sanitize (hb_sanitize_context_t *c) const
60 {
61 TRACE_SANITIZE (this);
62 return_trace (c->check_struct (this));
63 }
64
65 protected:
66 HBUINT16 format; /* Format number is set to 0. */
67 HBUINT16 length; /* Byte length of this subtable. */
68 HBUINT16 language; /* Ignore. */
69 HBUINT8 glyphIdArray[256];/* An array that maps character
70 * code to glyph index values. */
71 public:
72 DEFINE_SIZE_STATIC (6 + 256);
73};
74
75struct CmapSubtableFormat4
76{
77
78 template<typename Iterator,
79 hb_requires (hb_is_iterator (Iterator))>
80 HBUINT16* serialize_endcode_array (hb_serialize_context_t *c,
81 Iterator it)
82 {
83 HBUINT16 *endCode = c->start_embed<HBUINT16> ();
84 hb_codepoint_t prev_endcp = 0xFFFF;
85
86 + it
87 | hb_apply ([&] (const hb_item_type<Iterator> _)
88 {
89 if (prev_endcp != 0xFFFF && prev_endcp + 1u != _.first)
90 {
91 HBUINT16 end_code;
92 end_code = prev_endcp;
93 c->copy<HBUINT16> (end_code);
94 }
95 prev_endcp = _.first;
96 })
97 ;
98
99 {
100 // last endCode
101 HBUINT16 endcode;
102 endcode = prev_endcp;
103 if (unlikely (!c->copy<HBUINT16> (endcode))) return nullptr;
104 // There must be a final entry with end_code == 0xFFFF.
105 if (prev_endcp != 0xFFFF)
106 {
107 HBUINT16 finalcode;
108 finalcode = 0xFFFF;
109 if (unlikely (!c->copy<HBUINT16> (finalcode))) return nullptr;
110 }
111 }
112
113 return endCode;
114 }
115
116 template<typename Iterator,
117 hb_requires (hb_is_iterator (Iterator))>
118 HBUINT16* serialize_startcode_array (hb_serialize_context_t *c,
119 Iterator it)
120 {
121 HBUINT16 *startCode = c->start_embed<HBUINT16> ();
122 hb_codepoint_t prev_cp = 0xFFFF;
123
124 + it
125 | hb_apply ([&] (const hb_item_type<Iterator> _)
126 {
127 if (prev_cp == 0xFFFF || prev_cp + 1u != _.first)
128 {
129 HBUINT16 start_code;
130 start_code = _.first;
131 c->copy<HBUINT16> (start_code);
132 }
133
134 prev_cp = _.first;
135 })
136 ;
137
138 // There must be a final entry with end_code == 0xFFFF.
139 if (it.len () == 0 || prev_cp != 0xFFFF)
140 {
141 HBUINT16 finalcode;
142 finalcode = 0xFFFF;
143 if (unlikely (!c->copy<HBUINT16> (finalcode))) return nullptr;
144 }
145
146 return startCode;
147 }
148
149 template<typename Iterator,
150 hb_requires (hb_is_iterator (Iterator))>
151 HBINT16* serialize_idDelta_array (hb_serialize_context_t *c,
152 Iterator it,
153 HBUINT16 *endCode,
154 HBUINT16 *startCode,
155 unsigned segcount)
156 {
157 unsigned i = 0;
158 hb_codepoint_t last_gid = 0, start_gid = 0, last_cp = 0xFFFF;
159 bool use_delta = true;
160
161 HBINT16 *idDelta = c->start_embed<HBINT16> ();
162 if ((char *)idDelta - (char *)startCode != (int) segcount * (int) HBINT16::static_size)
163 return nullptr;
164
165 + it
166 | hb_apply ([&] (const hb_item_type<Iterator> _)
167 {
168 if (_.first == startCode[i])
169 {
170 use_delta = true;
171 start_gid = _.second;
172 }
173 else if (_.second != last_gid + 1) use_delta = false;
174
175 if (_.first == endCode[i])
176 {
177 HBINT16 delta;
178 if (use_delta) delta = (int)start_gid - (int)startCode[i];
179 else delta = 0;
180 c->copy<HBINT16> (delta);
181
182 i++;
183 }
184
185 last_gid = _.second;
186 last_cp = _.first;
187 })
188 ;
189
190 if (it.len () == 0 || last_cp != 0xFFFF)
191 {
192 HBINT16 delta;
193 delta = 1;
194 if (unlikely (!c->copy<HBINT16> (delta))) return nullptr;
195 }
196
197 return idDelta;
198 }
199
200 template<typename Iterator,
201 hb_requires (hb_is_iterator (Iterator))>
202 HBUINT16* serialize_rangeoffset_glyid (hb_serialize_context_t *c,
203 Iterator it,
204 HBUINT16 *endCode,
205 HBUINT16 *startCode,
206 HBINT16 *idDelta,
207 unsigned segcount)
208 {
209 HBUINT16 *idRangeOffset = c->allocate_size<HBUINT16> (HBUINT16::static_size * segcount);
210 if (unlikely (!c->check_success (idRangeOffset))) return nullptr;
211 if (unlikely ((char *)idRangeOffset - (char *)idDelta != (int) segcount * (int) HBINT16::static_size)) return nullptr;
212
213 + hb_range (segcount)
214 | hb_filter ([&] (const unsigned _) { return idDelta[_] == 0; })
215 | hb_apply ([&] (const unsigned i)
216 {
217 idRangeOffset[i] = 2 * (c->start_embed<HBUINT16> () - idRangeOffset - i);
218
219 + it
220 | hb_filter ([&] (const hb_item_type<Iterator> _) { return _.first >= startCode[i] && _.first <= endCode[i]; })
221 | hb_apply ([&] (const hb_item_type<Iterator> _)
222 {
223 HBUINT16 glyID;
224 glyID = _.second;
225 c->copy<HBUINT16> (glyID);
226 })
227 ;
228
229
230 })
231 ;
232
233 return idRangeOffset;
234 }
235
236 template<typename Iterator,
237 hb_requires (hb_is_iterator (Iterator))>
238 void serialize (hb_serialize_context_t *c,
239 Iterator it)
240 {
241 unsigned table_initpos = c->length ();
242 if (unlikely (!c->extend_min (*this))) return;
243 this->format = 4;
244
245 //serialize endCode[]
246 HBUINT16 *endCode = serialize_endcode_array (c, it);
247 if (unlikely (!endCode)) return;
248
249 unsigned segcount = (c->length () - min_size) / HBUINT16::static_size;
250
251 // 2 bytes of padding.
252 if (unlikely (!c->allocate_size<HBUINT16> (HBUINT16::static_size))) return; // 2 bytes of padding.
253
254 // serialize startCode[]
255 HBUINT16 *startCode = serialize_startcode_array (c, it);
256 if (unlikely (!startCode)) return;
257
258 //serialize idDelta[]
259 HBINT16 *idDelta = serialize_idDelta_array (c, it, endCode, startCode, segcount);
260 if (unlikely (!idDelta)) return;
261
262 HBUINT16 *idRangeOffset = serialize_rangeoffset_glyid (c, it, endCode, startCode, idDelta, segcount);
263 if (unlikely (!c->check_success (idRangeOffset))) return;
264
265 if (unlikely (!c->check_assign(this->length, c->length () - table_initpos))) return;
266 this->segCountX2 = segcount * 2;
267 this->entrySelector = hb_max (1u, hb_bit_storage (segcount)) - 1;
268 this->searchRange = 2 * (1u << this->entrySelector);
269 this->rangeShift = segcount * 2 > this->searchRange
270 ? 2 * segcount - this->searchRange
271 : 0;
272 }
273
274 struct accelerator_t
275 {
276 accelerator_t () {}
277 accelerator_t (const CmapSubtableFormat4 *subtable) { init (subtable); }
278 ~accelerator_t () { fini (); }
279
280 void init (const CmapSubtableFormat4 *subtable)
281 {
282 segCount = subtable->segCountX2 / 2;
283 endCount = subtable->values.arrayZ;
284 startCount = endCount + segCount + 1;
285 idDelta = startCount + segCount;
286 idRangeOffset = idDelta + segCount;
287 glyphIdArray = idRangeOffset + segCount;
288 glyphIdArrayLength = (subtable->length - 16 - 8 * segCount) / 2;
289 }
290 void fini () {}
291
292 bool get_glyph (hb_codepoint_t codepoint, hb_codepoint_t *glyph) const
293 {
294 /* Custom two-array bsearch. */
295 int min = 0, max = (int) this->segCount - 1;
296 const HBUINT16 *startCount = this->startCount;
297 const HBUINT16 *endCount = this->endCount;
298 unsigned int i;
299 while (min <= max)
300 {
301 int mid = ((unsigned int) min + (unsigned int) max) / 2;
302 if (codepoint < startCount[mid])
303 max = mid - 1;
304 else if (codepoint > endCount[mid])
305 min = mid + 1;
306 else
307 {
308 i = mid;
309 goto found;
310 }
311 }
312 return false;
313
314 found:
315 hb_codepoint_t gid;
316 unsigned int rangeOffset = this->idRangeOffset[i];
317 if (rangeOffset == 0)
318 gid = codepoint + this->idDelta[i];
319 else
320 {
321 /* Somebody has been smoking... */
322 unsigned int index = rangeOffset / 2 + (codepoint - this->startCount[i]) + i - this->segCount;
323 if (unlikely (index >= this->glyphIdArrayLength))
324 return false;
325 gid = this->glyphIdArray[index];
326 if (unlikely (!gid))
327 return false;
328 gid += this->idDelta[i];
329 }
330 gid &= 0xFFFFu;
331 if (!gid)
332 return false;
333 *glyph = gid;
334 return true;
335 }
336 HB_INTERNAL static bool get_glyph_func (const void *obj, hb_codepoint_t codepoint, hb_codepoint_t *glyph)
337 { return ((const accelerator_t *) obj)->get_glyph (codepoint, glyph); }
338 void collect_unicodes (hb_set_t *out) const
339 {
340 unsigned int count = this->segCount;
341 if (count && this->startCount[count - 1] == 0xFFFFu)
342 count--; /* Skip sentinel segment. */
343 for (unsigned int i = 0; i < count; i++)
344 {
345 hb_codepoint_t start = this->startCount[i];
346 hb_codepoint_t end = this->endCount[i];
347 unsigned int rangeOffset = this->idRangeOffset[i];
348 if (rangeOffset == 0)
349 {
350 for (hb_codepoint_t codepoint = start; codepoint <= end; codepoint++)
351 {
352 hb_codepoint_t gid = (codepoint + this->idDelta[i]) & 0xFFFFu;
353 if (unlikely (!gid))
354 continue;
355 out->add (codepoint);
356 }
357 }
358 else
359 {
360 for (hb_codepoint_t codepoint = start; codepoint <= end; codepoint++)
361 {
362 unsigned int index = rangeOffset / 2 + (codepoint - this->startCount[i]) + i - this->segCount;
363 if (unlikely (index >= this->glyphIdArrayLength))
364 break;
365 hb_codepoint_t gid = this->glyphIdArray[index];
366 if (unlikely (!gid))
367 continue;
368 out->add (codepoint);
369 }
370 }
371 }
372 }
373
374 const HBUINT16 *endCount;
375 const HBUINT16 *startCount;
376 const HBUINT16 *idDelta;
377 const HBUINT16 *idRangeOffset;
378 const HBUINT16 *glyphIdArray;
379 unsigned int segCount;
380 unsigned int glyphIdArrayLength;
381 };
382
383 bool get_glyph (hb_codepoint_t codepoint, hb_codepoint_t *glyph) const
384 {
385 accelerator_t accel (this);
386 return accel.get_glyph_func (&accel, codepoint, glyph);
387 }
388 void collect_unicodes (hb_set_t *out) const
389 {
390 accelerator_t accel (this);
391 accel.collect_unicodes (out);
392 }
393
394 bool sanitize (hb_sanitize_context_t *c) const
395 {
396 TRACE_SANITIZE (this);
397 if (unlikely (!c->check_struct (this)))
398 return_trace (false);
399
400 if (unlikely (!c->check_range (this, length)))
401 {
402 /* Some broken fonts have too long of a "length" value.
403 * If that is the case, just change the value to truncate
404 * the subtable at the end of the blob. */
405 uint16_t new_length = (uint16_t) hb_min ((uintptr_t) 65535,
406 (uintptr_t) (c->end -
407 (char *) this));
408 if (!c->try_set (&length, new_length))
409 return_trace (false);
410 }
411
412 return_trace (16 + 4 * (unsigned int) segCountX2 <= length);
413 }
414
415
416
417 protected:
418 HBUINT16 format; /* Format number is set to 4. */
419 HBUINT16 length; /* This is the length in bytes of the
420 * subtable. */
421 HBUINT16 language; /* Ignore. */
422 HBUINT16 segCountX2; /* 2 x segCount. */
423 HBUINT16 searchRange; /* 2 * (2**floor(log2(segCount))) */
424 HBUINT16 entrySelector; /* log2(searchRange/2) */
425 HBUINT16 rangeShift; /* 2 x segCount - searchRange */
426
427 UnsizedArrayOf<HBUINT16>
428 values;
429#if 0
430 HBUINT16 endCount[segCount]; /* End characterCode for each segment,
431 * last=0xFFFFu. */
432 HBUINT16 reservedPad; /* Set to 0. */
433 HBUINT16 startCount[segCount]; /* Start character code for each segment. */
434 HBINT16 idDelta[segCount]; /* Delta for all character codes in segment. */
435 HBUINT16 idRangeOffset[segCount];/* Offsets into glyphIdArray or 0 */
436 UnsizedArrayOf<HBUINT16>
437 glyphIdArray; /* Glyph index array (arbitrary length) */
438#endif
439
440 public:
441 DEFINE_SIZE_ARRAY (14, values);
442};
443
444struct CmapSubtableLongGroup
445{
446 friend struct CmapSubtableFormat12;
447 friend struct CmapSubtableFormat13;
448 template<typename U>
449 friend struct CmapSubtableLongSegmented;
450 friend struct cmap;
451
452 int cmp (hb_codepoint_t codepoint) const
453 {
454 if (codepoint < startCharCode) return -1;
455 if (codepoint > endCharCode) return +1;
456 return 0;
457 }
458
459 bool sanitize (hb_sanitize_context_t *c) const
460 {
461 TRACE_SANITIZE (this);
462 return_trace (c->check_struct (this));
463 }
464
465 private:
466 HBUINT32 startCharCode; /* First character code in this group. */
467 HBUINT32 endCharCode; /* Last character code in this group. */
468 HBUINT32 glyphID; /* Glyph index; interpretation depends on
469 * subtable format. */
470 public:
471 DEFINE_SIZE_STATIC (12);
472};
473DECLARE_NULL_NAMESPACE_BYTES (OT, CmapSubtableLongGroup);
474
475template <typename UINT>
476struct CmapSubtableTrimmed
477{
478 bool get_glyph (hb_codepoint_t codepoint, hb_codepoint_t *glyph) const
479 {
480 /* Rely on our implicit array bound-checking. */
481 hb_codepoint_t gid = glyphIdArray[codepoint - startCharCode];
482 if (!gid)
483 return false;
484 *glyph = gid;
485 return true;
486 }
487 void collect_unicodes (hb_set_t *out) const
488 {
489 hb_codepoint_t start = startCharCode;
490 unsigned int count = glyphIdArray.len;
491 for (unsigned int i = 0; i < count; i++)
492 if (glyphIdArray[i])
493 out->add (start + i);
494 }
495
496 bool sanitize (hb_sanitize_context_t *c) const
497 {
498 TRACE_SANITIZE (this);
499 return_trace (c->check_struct (this) && glyphIdArray.sanitize (c));
500 }
501
502 protected:
503 UINT formatReserved; /* Subtable format and (maybe) padding. */
504 UINT length; /* Byte length of this subtable. */
505 UINT language; /* Ignore. */
506 UINT startCharCode; /* First character code covered. */
507 ArrayOf<HBGlyphID, UINT>
508 glyphIdArray; /* Array of glyph index values for character
509 * codes in the range. */
510 public:
511 DEFINE_SIZE_ARRAY (5 * sizeof (UINT), glyphIdArray);
512};
513
514struct CmapSubtableFormat6 : CmapSubtableTrimmed<HBUINT16> {};
515struct CmapSubtableFormat10 : CmapSubtableTrimmed<HBUINT32 > {};
516
517template <typename T>
518struct CmapSubtableLongSegmented
519{
520 friend struct cmap;
521
522 bool get_glyph (hb_codepoint_t codepoint, hb_codepoint_t *glyph) const
523 {
524 hb_codepoint_t gid = T::group_get_glyph (groups.bsearch (codepoint), codepoint);
525 if (!gid)
526 return false;
527 *glyph = gid;
528 return true;
529 }
530
531 void collect_unicodes (hb_set_t *out) const
532 {
533 for (unsigned int i = 0; i < this->groups.len; i++)
534 {
535 hb_codepoint_t start = this->groups[i].startCharCode;
536 hb_codepoint_t end = hb_min ((hb_codepoint_t) this->groups[i].endCharCode,
537 (hb_codepoint_t) HB_UNICODE_MAX);
538 for (hb_codepoint_t codepoint = start; codepoint <= end; codepoint++)
539 {
540 hb_codepoint_t gid = T::group_get_glyph (this->groups[i], codepoint);
541 if (unlikely (!gid))
542 continue;
543 out->add (codepoint);
544 }
545 }
546 }
547
548 bool sanitize (hb_sanitize_context_t *c) const
549 {
550 TRACE_SANITIZE (this);
551 return_trace (c->check_struct (this) && groups.sanitize (c));
552 }
553
554 protected:
555 HBUINT16 format; /* Subtable format; set to 12. */
556 HBUINT16 reserved; /* Reserved; set to 0. */
557 HBUINT32 length; /* Byte length of this subtable. */
558 HBUINT32 language; /* Ignore. */
559 SortedArrayOf<CmapSubtableLongGroup, HBUINT32>
560 groups; /* Groupings. */
561 public:
562 DEFINE_SIZE_ARRAY (16, groups);
563};
564
565struct CmapSubtableFormat12 : CmapSubtableLongSegmented<CmapSubtableFormat12>
566{
567 static hb_codepoint_t group_get_glyph (const CmapSubtableLongGroup &group,
568 hb_codepoint_t u)
569 { return likely (group.startCharCode <= group.endCharCode) ?
570 group.glyphID + (u - group.startCharCode) : 0; }
571
572
573 template<typename Iterator,
574 hb_requires (hb_is_iterator (Iterator))>
575 void serialize (hb_serialize_context_t *c,
576 Iterator it)
577 {
578 if (it.len () == 0) return;
579 unsigned table_initpos = c->length ();
580 if (unlikely (!c->extend_min (*this))) return;
581
582 hb_codepoint_t startCharCode = 0xFFFF, endCharCode = 0xFFFF;
583 hb_codepoint_t glyphID = 0;
584
585 + it
586 | hb_apply ([&] (const hb_item_type<Iterator> _)
587 {
588 if (startCharCode == 0xFFFF)
589 {
590 startCharCode = _.first;
591 endCharCode = _.first;
592 glyphID = _.second;
593 }
594 else if (!_is_gid_consecutive (endCharCode, startCharCode, glyphID, _.first, _.second))
595 {
596 CmapSubtableLongGroup grouprecord;
597 grouprecord.startCharCode = startCharCode;
598 grouprecord.endCharCode = endCharCode;
599 grouprecord.glyphID = glyphID;
600 c->copy<CmapSubtableLongGroup> (grouprecord);
601
602 startCharCode = _.first;
603 endCharCode = _.first;
604 glyphID = _.second;
605 }
606 else
607 {
608 endCharCode = _.first;
609 }
610 })
611 ;
612
613 CmapSubtableLongGroup record;
614 record.startCharCode = startCharCode;
615 record.endCharCode = endCharCode;
616 record.glyphID = glyphID;
617 c->copy<CmapSubtableLongGroup> (record);
618
619 this->format = 12;
620 this->reserved = 0;
621 this->length = c->length () - table_initpos;
622 this->groups.len = (this->length - min_size)/CmapSubtableLongGroup::static_size;
623 }
624
625 static size_t get_sub_table_size (const hb_sorted_vector_t<CmapSubtableLongGroup> &groups_data)
626 { return 16 + 12 * groups_data.length; }
627
628 private:
629 static bool _is_gid_consecutive (hb_codepoint_t endCharCode,
630 hb_codepoint_t startCharCode,
631 hb_codepoint_t glyphID,
632 hb_codepoint_t cp,
633 hb_codepoint_t new_gid)
634 {
635 return (cp - 1 == endCharCode) &&
636 new_gid == glyphID + (cp - startCharCode);
637 }
638
639};
640
641struct CmapSubtableFormat13 : CmapSubtableLongSegmented<CmapSubtableFormat13>
642{
643 static hb_codepoint_t group_get_glyph (const CmapSubtableLongGroup &group,
644 hb_codepoint_t u HB_UNUSED)
645 { return group.glyphID; }
646};
647
648typedef enum
649{
650 GLYPH_VARIANT_NOT_FOUND = 0,
651 GLYPH_VARIANT_FOUND = 1,
652 GLYPH_VARIANT_USE_DEFAULT = 2
653} glyph_variant_t;
654
655struct UnicodeValueRange
656{
657 int cmp (const hb_codepoint_t &codepoint) const
658 {
659 if (codepoint < startUnicodeValue) return -1;
660 if (codepoint > startUnicodeValue + additionalCount) return +1;
661 return 0;
662 }
663
664 bool sanitize (hb_sanitize_context_t *c) const
665 {
666 TRACE_SANITIZE (this);
667 return_trace (c->check_struct (this));
668 }
669
670 HBUINT24 startUnicodeValue; /* First value in this range. */
671 HBUINT8 additionalCount; /* Number of additional values in this
672 * range. */
673 public:
674 DEFINE_SIZE_STATIC (4);
675};
676
677struct DefaultUVS : SortedArrayOf<UnicodeValueRange, HBUINT32>
678{
679 void collect_unicodes (hb_set_t *out) const
680 {
681 unsigned int count = len;
682 for (unsigned int i = 0; i < count; i++)
683 {
684 hb_codepoint_t first = arrayZ[i].startUnicodeValue;
685 hb_codepoint_t last = hb_min ((hb_codepoint_t) (first + arrayZ[i].additionalCount),
686 (hb_codepoint_t) HB_UNICODE_MAX);
687 out->add_range (first, last);
688 }
689 }
690
691 DefaultUVS* copy (hb_serialize_context_t *c,
692 const hb_set_t *unicodes) const
693 {
694 DefaultUVS *out = c->start_embed<DefaultUVS> ();
695 if (unlikely (!out)) return nullptr;
696 auto snap = c->snapshot ();
697
698 HBUINT32 len;
699 len = 0;
700 if (unlikely (!c->copy<HBUINT32> (len))) return nullptr;
701 unsigned init_len = c->length ();
702
703 hb_codepoint_t lastCode = HB_MAP_VALUE_INVALID;
704 int count = -1;
705
706 for (const UnicodeValueRange& _ : as_array ())
707 {
708 for (const unsigned addcnt : hb_range ((unsigned) _.additionalCount + 1))
709 {
710 unsigned curEntry = (unsigned) _.startUnicodeValue + addcnt;
711 if (!unicodes->has (curEntry)) continue;
712 count += 1;
713 if (lastCode == HB_MAP_VALUE_INVALID)
714 lastCode = curEntry;
715 else if (lastCode + count != curEntry)
716 {
717 UnicodeValueRange rec;
718 rec.startUnicodeValue = lastCode;
719 rec.additionalCount = count - 1;
720 c->copy<UnicodeValueRange> (rec);
721
722 lastCode = curEntry;
723 count = 0;
724 }
725 }
726 }
727
728 if (lastCode != HB_MAP_VALUE_INVALID)
729 {
730 UnicodeValueRange rec;
731 rec.startUnicodeValue = lastCode;
732 rec.additionalCount = count;
733 c->copy<UnicodeValueRange> (rec);
734 }
735
736 if (c->length () - init_len == 0)
737 {
738 c->revert (snap);
739 return nullptr;
740 }
741 else
742 {
743 if (unlikely (!c->check_assign (out->len, (c->length () - init_len) / UnicodeValueRange::static_size))) return nullptr;
744 return out;
745 }
746 }
747
748 public:
749 DEFINE_SIZE_ARRAY (4, *this);
750};
751
752struct UVSMapping
753{
754 int cmp (const hb_codepoint_t &codepoint) const
755 { return unicodeValue.cmp (codepoint); }
756
757 bool sanitize (hb_sanitize_context_t *c) const
758 {
759 TRACE_SANITIZE (this);
760 return_trace (c->check_struct (this));
761 }
762
763 HBUINT24 unicodeValue; /* Base Unicode value of the UVS */
764 HBGlyphID glyphID; /* Glyph ID of the UVS */
765 public:
766 DEFINE_SIZE_STATIC (5);
767};
768
769struct NonDefaultUVS : SortedArrayOf<UVSMapping, HBUINT32>
770{
771 void collect_unicodes (hb_set_t *out) const
772 {
773 unsigned int count = len;
774 for (unsigned int i = 0; i < count; i++)
775 out->add (arrayZ[i].glyphID);
776 }
777
778 void closure_glyphs (const hb_set_t *unicodes,
779 hb_set_t *glyphset) const
780 {
781 + as_array ()
782 | hb_filter (unicodes, &UVSMapping::unicodeValue)
783 | hb_map (&UVSMapping::glyphID)
784 | hb_sink (glyphset)
785 ;
786 }
787
788 NonDefaultUVS* copy (hb_serialize_context_t *c,
789 const hb_set_t *unicodes,
790 const hb_set_t *glyphs,
791 const hb_map_t *glyph_map) const
792 {
793 NonDefaultUVS *out = c->start_embed<NonDefaultUVS> ();
794 if (unlikely (!out)) return nullptr;
795
796 auto it =
797 + as_array ()
798 | hb_filter ([&] (const UVSMapping& _)
799 {
800 return unicodes->has (_.unicodeValue) || glyphs->has (_.glyphID);
801 })
802 ;
803
804 if (!it) return nullptr;
805
806 HBUINT32 len;
807 len = it.len ();
808 if (unlikely (!c->copy<HBUINT32> (len))) return nullptr;
809
810 for (const UVSMapping& _ : it)
811 {
812 UVSMapping mapping;
813 mapping.unicodeValue = _.unicodeValue;
814 mapping.glyphID = glyph_map->get (_.glyphID);
815 c->copy<UVSMapping> (mapping);
816 }
817
818 return out;
819 }
820
821 public:
822 DEFINE_SIZE_ARRAY (4, *this);
823};
824
825struct VariationSelectorRecord
826{
827 glyph_variant_t get_glyph (hb_codepoint_t codepoint,
828 hb_codepoint_t *glyph,
829 const void *base) const
830 {
831 if ((base+defaultUVS).bfind (codepoint))
832 return GLYPH_VARIANT_USE_DEFAULT;
833 const UVSMapping &nonDefault = (base+nonDefaultUVS).bsearch (codepoint);
834 if (nonDefault.glyphID)
835 {
836 *glyph = nonDefault.glyphID;
837 return GLYPH_VARIANT_FOUND;
838 }
839 return GLYPH_VARIANT_NOT_FOUND;
840 }
841
842 void collect_unicodes (hb_set_t *out, const void *base) const
843 {
844 (base+defaultUVS).collect_unicodes (out);
845 (base+nonDefaultUVS).collect_unicodes (out);
846 }
847
848 int cmp (const hb_codepoint_t &variation_selector) const
849 { return varSelector.cmp (variation_selector); }
850
851 bool sanitize (hb_sanitize_context_t *c, const void *base) const
852 {
853 TRACE_SANITIZE (this);
854 return_trace (c->check_struct (this) &&
855 defaultUVS.sanitize (c, base) &&
856 nonDefaultUVS.sanitize (c, base));
857 }
858
859 VariationSelectorRecord* copy (hb_serialize_context_t *c,
860 const hb_set_t *unicodes,
861 const hb_set_t *glyphs,
862 const hb_map_t *glyph_map,
863 const void *src_base,
864 const void *dst_base) const
865 {
866 auto snap = c->snapshot ();
867 auto *out = c->embed<VariationSelectorRecord> (*this);
868 if (unlikely (!out)) return nullptr;
869
870 out->defaultUVS = 0;
871 out->nonDefaultUVS = 0;
872
873 bool drop = true;
874
875 if (defaultUVS != 0)
876 {
877 c->push ();
878 if (c->copy (src_base+defaultUVS, unicodes))
879 {
880 c->add_link (out->defaultUVS, c->pop_pack (), dst_base);
881 drop = false;
882 }
883 else c->pop_discard ();
884 }
885
886 if (nonDefaultUVS != 0)
887 {
888 c->push ();
889 if (c->copy (src_base+nonDefaultUVS, unicodes, glyphs, glyph_map))
890 {
891 c->add_link (out->nonDefaultUVS, c->pop_pack (), dst_base);
892 drop = false;
893 }
894 else c->pop_discard ();
895 }
896
897 if (drop)
898 {
899 c->revert (snap);
900 return nullptr;
901 }
902 else return out;
903 }
904
905 HBUINT24 varSelector; /* Variation selector. */
906 LOffsetTo<DefaultUVS>
907 defaultUVS; /* Offset to Default UVS Table. May be 0. */
908 LOffsetTo<NonDefaultUVS>
909 nonDefaultUVS; /* Offset to Non-Default UVS Table. May be 0. */
910 public:
911 DEFINE_SIZE_STATIC (11);
912};
913
914struct CmapSubtableFormat14
915{
916 glyph_variant_t get_glyph_variant (hb_codepoint_t codepoint,
917 hb_codepoint_t variation_selector,
918 hb_codepoint_t *glyph) const
919 { return record.bsearch (variation_selector).get_glyph (codepoint, glyph, this); }
920
921 void collect_variation_selectors (hb_set_t *out) const
922 {
923 unsigned int count = record.len;
924 for (unsigned int i = 0; i < count; i++)
925 out->add (record.arrayZ[i].varSelector);
926 }
927 void collect_variation_unicodes (hb_codepoint_t variation_selector,
928 hb_set_t *out) const
929 { record.bsearch (variation_selector).collect_unicodes (out, this); }
930
931 void serialize (hb_serialize_context_t *c,
932 const hb_set_t *unicodes,
933 const hb_set_t *glyphs,
934 const hb_map_t *glyph_map,
935 const void *src_base)
936 {
937 auto snap = c->snapshot ();
938 unsigned table_initpos = c->length ();
939 const char* init_tail = c->tail;
940
941 if (unlikely (!c->extend_min (*this))) return;
942 this->format = 14;
943
944 const CmapSubtableFormat14 *src_tbl = reinterpret_cast<const CmapSubtableFormat14*> (src_base);
945 for (const VariationSelectorRecord& _ : src_tbl->record)
946 c->copy (_, unicodes, glyphs, glyph_map, src_base, this);
947
948 if (c->length () - table_initpos == CmapSubtableFormat14::min_size)
949 c->revert (snap);
950 else
951 {
952 int tail_len = init_tail - c->tail;
953 c->check_assign (this->length, c->length () - table_initpos + tail_len);
954 c->check_assign (this->record.len, (c->length () - table_initpos - CmapSubtableFormat14::min_size) / VariationSelectorRecord::static_size);
955 }
956 }
957
958 void closure_glyphs (const hb_set_t *unicodes,
959 hb_set_t *glyphset) const
960 {
961 + hb_iter (record)
962 | hb_filter (hb_bool, &VariationSelectorRecord::nonDefaultUVS)
963 | hb_map (&VariationSelectorRecord::nonDefaultUVS)
964 | hb_map (hb_add (this))
965 | hb_apply ([=] (const NonDefaultUVS& _) { _.closure_glyphs (unicodes, glyphset); })
966 ;
967 }
968
969 bool sanitize (hb_sanitize_context_t *c) const
970 {
971 TRACE_SANITIZE (this);
972 return_trace (c->check_struct (this) &&
973 record.sanitize (c, this));
974 }
975
976 protected:
977 HBUINT16 format; /* Format number is set to 14. */
978 HBUINT32 length; /* Byte length of this subtable. */
979 SortedArrayOf<VariationSelectorRecord, HBUINT32>
980 record; /* Variation selector records; sorted
981 * in increasing order of `varSelector'. */
982 public:
983 DEFINE_SIZE_ARRAY (10, record);
984};
985
986struct CmapSubtable
987{
988 /* Note: We intentionally do NOT implement subtable formats 2 and 8. */
989
990 bool get_glyph (hb_codepoint_t codepoint,
991 hb_codepoint_t *glyph) const
992 {
993 switch (u.format) {
994 case 0: return u.format0 .get_glyph (codepoint, glyph);
995 case 4: return u.format4 .get_glyph (codepoint, glyph);
996 case 6: return u.format6 .get_glyph (codepoint, glyph);
997 case 10: return u.format10.get_glyph (codepoint, glyph);
998 case 12: return u.format12.get_glyph (codepoint, glyph);
999 case 13: return u.format13.get_glyph (codepoint, glyph);
1000 case 14:
1001 default: return false;
1002 }
1003 }
1004 void collect_unicodes (hb_set_t *out) const
1005 {
1006 switch (u.format) {
1007 case 0: u.format0 .collect_unicodes (out); return;
1008 case 4: u.format4 .collect_unicodes (out); return;
1009 case 6: u.format6 .collect_unicodes (out); return;
1010 case 10: u.format10.collect_unicodes (out); return;
1011 case 12: u.format12.collect_unicodes (out); return;
1012 case 13: u.format13.collect_unicodes (out); return;
1013 case 14:
1014 default: return;
1015 }
1016 }
1017
1018 template<typename Iterator,
1019 hb_requires (hb_is_iterator (Iterator))>
1020 void serialize (hb_serialize_context_t *c,
1021 Iterator it,
1022 unsigned format,
1023 const hb_subset_plan_t *plan,
1024 const void *src_base)
1025 {
1026 switch (format) {
1027 case 4: u.format4.serialize (c, it); return;
1028 case 12: u.format12.serialize (c, it); return;
1029 case 14: u.format14.serialize (c, plan->unicodes, plan->_glyphset, plan->glyph_map, src_base); return;
1030 default: return;
1031 }
1032 }
1033
1034 bool sanitize (hb_sanitize_context_t *c) const
1035 {
1036 TRACE_SANITIZE (this);
1037 if (!u.format.sanitize (c)) return_trace (false);
1038 switch (u.format) {
1039 case 0: return_trace (u.format0 .sanitize (c));
1040 case 4: return_trace (u.format4 .sanitize (c));
1041 case 6: return_trace (u.format6 .sanitize (c));
1042 case 10: return_trace (u.format10.sanitize (c));
1043 case 12: return_trace (u.format12.sanitize (c));
1044 case 13: return_trace (u.format13.sanitize (c));
1045 case 14: return_trace (u.format14.sanitize (c));
1046 default:return_trace (true);
1047 }
1048 }
1049
1050 public:
1051 union {
1052 HBUINT16 format; /* Format identifier */
1053 CmapSubtableFormat0 format0;
1054 CmapSubtableFormat4 format4;
1055 CmapSubtableFormat6 format6;
1056 CmapSubtableFormat10 format10;
1057 CmapSubtableFormat12 format12;
1058 CmapSubtableFormat13 format13;
1059 CmapSubtableFormat14 format14;
1060 } u;
1061 public:
1062 DEFINE_SIZE_UNION (2, format);
1063};
1064
1065
1066struct EncodingRecord
1067{
1068 int cmp (const EncodingRecord &other) const
1069 {
1070 int ret;
1071 ret = platformID.cmp (other.platformID);
1072 if (ret) return ret;
1073 ret = encodingID.cmp (other.encodingID);
1074 if (ret) return ret;
1075 return 0;
1076 }
1077
1078 bool sanitize (hb_sanitize_context_t *c, const void *base) const
1079 {
1080 TRACE_SANITIZE (this);
1081 return_trace (c->check_struct (this) &&
1082 subtable.sanitize (c, base));
1083 }
1084
1085 template<typename Iterator,
1086 hb_requires (hb_is_iterator (Iterator))>
1087 EncodingRecord* copy (hb_serialize_context_t *c,
1088 Iterator it,
1089 unsigned format,
1090 const void *src_base,
1091 const void *dst_base,
1092 const hb_subset_plan_t *plan,
1093 /* INOUT */ unsigned *objidx) const
1094 {
1095 TRACE_SERIALIZE (this);
1096 auto snap = c->snapshot ();
1097 auto *out = c->embed (this);
1098 if (unlikely (!out)) return_trace (nullptr);
1099 out->subtable = 0;
1100
1101 if (*objidx == 0)
1102 {
1103 CmapSubtable *cmapsubtable = c->push<CmapSubtable> ();
1104 unsigned origin_length = c->length ();
1105 cmapsubtable->serialize (c, it, format, plan, &(src_base+subtable));
1106 if (c->length () - origin_length > 0) *objidx = c->pop_pack ();
1107 else c->pop_discard ();
1108 }
1109
1110 if (*objidx == 0)
1111 {
1112 c->revert (snap);
1113 return_trace (nullptr);
1114 }
1115
1116 c->add_link (out->subtable, *objidx, dst_base);
1117 return_trace (out);
1118 }
1119
1120 HBUINT16 platformID; /* Platform ID. */
1121 HBUINT16 encodingID; /* Platform-specific encoding ID. */
1122 LOffsetTo<CmapSubtable>
1123 subtable; /* Byte offset from beginning of table to the subtable for this encoding. */
1124 public:
1125 DEFINE_SIZE_STATIC (8);
1126};
1127
1128struct cmap
1129{
1130 static constexpr hb_tag_t tableTag = HB_OT_TAG_cmap;
1131
1132 template<typename Iterator, typename EncodingRecIter,
1133 hb_requires (hb_is_iterator (Iterator))>
1134 void serialize (hb_serialize_context_t *c,
1135 Iterator it,
1136 EncodingRecIter encodingrec_iter,
1137 const void *src_base,
1138 const hb_subset_plan_t *plan)
1139 {
1140 if (unlikely (!c->extend_min ((*this)))) return;
1141 this->version = 0;
1142
1143 unsigned format4objidx = 0, format12objidx = 0, format14objidx = 0;
1144
1145 for (const EncodingRecord& _ : encodingrec_iter)
1146 {
1147 unsigned format = (src_base+_.subtable).u.format;
1148
1149 if (format == 4) c->copy (_, it, 4u, src_base, this, plan, &format4objidx);
1150 else if (format == 12) c->copy (_, it, 12u, src_base, this, plan, &format12objidx);
1151 else if (format == 14) c->copy (_, it, 14u, src_base, this, plan, &format14objidx);
1152 }
1153
1154 c->check_assign(this->encodingRecord.len, (c->length () - cmap::min_size)/EncodingRecord::static_size);
1155 }
1156
1157 void closure_glyphs (const hb_set_t *unicodes,
1158 hb_set_t *glyphset) const
1159 {
1160 + hb_iter (encodingRecord)
1161 | hb_map (&EncodingRecord::subtable)
1162 | hb_map (hb_add (this))
1163 | hb_filter ([&] (const CmapSubtable& _) { return _.u.format == 14; })
1164 | hb_apply ([=] (const CmapSubtable& _) { _.u.format14.closure_glyphs (unicodes, glyphset); })
1165 ;
1166 }
1167
1168 bool subset (hb_subset_context_t *c) const
1169 {
1170 TRACE_SUBSET (this);
1171
1172 cmap *cmap_prime = c->serializer->start_embed<cmap> ();
1173 if (unlikely (!c->serializer->check_success (cmap_prime))) return_trace (false);
1174
1175 auto encodingrec_iter =
1176 + hb_iter (encodingRecord)
1177 | hb_filter ([&] (const EncodingRecord& _)
1178 {
1179 if ((_.platformID == 0 && _.encodingID == 3) ||
1180 (_.platformID == 0 && _.encodingID == 4) ||
1181 (_.platformID == 3 && _.encodingID == 1) ||
1182 (_.platformID == 3 && _.encodingID == 10) ||
1183 (this + _.subtable).u.format == 14)
1184 return true;
1185
1186 return false;
1187 })
1188 ;
1189
1190
1191 if (unlikely (!encodingrec_iter.len ())) return_trace (false);
1192
1193 const EncodingRecord *unicode_bmp= nullptr, *unicode_ucs4 = nullptr, *ms_bmp = nullptr, *ms_ucs4 = nullptr;
1194 bool has_format12 = false;
1195
1196 for (const EncodingRecord& _ : encodingrec_iter)
1197 {
1198 unsigned format = (this + _.subtable).u.format;
1199 if (format == 12) has_format12 = true;
1200
1201 const EncodingRecord *table = hb_addressof (_);
1202 if (_.platformID == 0 && _.encodingID == 3) unicode_bmp = table;
1203 else if (_.platformID == 0 && _.encodingID == 4) unicode_ucs4 = table;
1204 else if (_.platformID == 3 && _.encodingID == 1) ms_bmp = table;
1205 else if (_.platformID == 3 && _.encodingID == 10) ms_ucs4 = table;
1206 }
1207
1208 if (unlikely (!unicode_bmp && !ms_bmp)) return_trace (false);
1209 if (unlikely (has_format12 && (!unicode_ucs4 && !ms_ucs4))) return_trace (false);
1210
1211 auto it =
1212 + hb_iter (c->plan->unicodes)
1213 | hb_map ([&] (hb_codepoint_t _)
1214 {
1215 hb_codepoint_t new_gid = HB_MAP_VALUE_INVALID;
1216 c->plan->new_gid_for_codepoint (_, &new_gid);
1217 return hb_pair_t<hb_codepoint_t, hb_codepoint_t> (_, new_gid);
1218 })
1219 | hb_filter ([&] (const hb_pair_t<hb_codepoint_t, hb_codepoint_t> _)
1220 { return (_.second != HB_MAP_VALUE_INVALID); })
1221 ;
1222
1223 cmap_prime->serialize (c->serializer, it, encodingrec_iter, this, c->plan);
1224 return_trace (true);
1225 }
1226
1227 const CmapSubtable *find_best_subtable (bool *symbol = nullptr) const
1228 {
1229 if (symbol) *symbol = false;
1230
1231 const CmapSubtable *subtable;
1232
1233 /* Symbol subtable.
1234 * Prefer symbol if available.
1235 * https://github.com/harfbuzz/harfbuzz/issues/1918 */
1236 if ((subtable = this->find_subtable (3, 0)))
1237 {
1238 if (symbol) *symbol = true;
1239 return subtable;
1240 }
1241
1242 /* 32-bit subtables. */
1243 if ((subtable = this->find_subtable (3, 10))) return subtable;
1244 if ((subtable = this->find_subtable (0, 6))) return subtable;
1245 if ((subtable = this->find_subtable (0, 4))) return subtable;
1246
1247 /* 16-bit subtables. */
1248 if ((subtable = this->find_subtable (3, 1))) return subtable;
1249 if ((subtable = this->find_subtable (0, 3))) return subtable;
1250 if ((subtable = this->find_subtable (0, 2))) return subtable;
1251 if ((subtable = this->find_subtable (0, 1))) return subtable;
1252 if ((subtable = this->find_subtable (0, 0))) return subtable;
1253
1254 /* Meh. */
1255 return &Null (CmapSubtable);
1256 }
1257
1258 struct accelerator_t
1259 {
1260 void init (hb_face_t *face)
1261 {
1262 this->table = hb_sanitize_context_t ().reference_table<cmap> (face);
1263 bool symbol;
1264 this->subtable = table->find_best_subtable (&symbol);
1265 this->subtable_uvs = &Null (CmapSubtableFormat14);
1266 {
1267 const CmapSubtable *st = table->find_subtable (0, 5);
1268 if (st && st->u.format == 14)
1269 subtable_uvs = &st->u.format14;
1270 }
1271
1272 this->get_glyph_data = subtable;
1273 if (unlikely (symbol))
1274 this->get_glyph_funcZ = get_glyph_from_symbol<CmapSubtable>;
1275 else
1276 {
1277 switch (subtable->u.format) {
1278 /* Accelerate format 4 and format 12. */
1279 default:
1280 this->get_glyph_funcZ = get_glyph_from<CmapSubtable>;
1281 break;
1282 case 12:
1283 this->get_glyph_funcZ = get_glyph_from<CmapSubtableFormat12>;
1284 break;
1285 case 4:
1286 {
1287 this->format4_accel.init (&subtable->u.format4);
1288 this->get_glyph_data = &this->format4_accel;
1289 this->get_glyph_funcZ = this->format4_accel.get_glyph_func;
1290 break;
1291 }
1292 }
1293 }
1294 }
1295
1296 void fini () { this->table.destroy (); }
1297
1298 bool get_nominal_glyph (hb_codepoint_t unicode,
1299 hb_codepoint_t *glyph) const
1300 {
1301 if (unlikely (!this->get_glyph_funcZ)) return false;
1302 return this->get_glyph_funcZ (this->get_glyph_data, unicode, glyph);
1303 }
1304 unsigned int get_nominal_glyphs (unsigned int count,
1305 const hb_codepoint_t *first_unicode,
1306 unsigned int unicode_stride,
1307 hb_codepoint_t *first_glyph,
1308 unsigned int glyph_stride) const
1309 {
1310 if (unlikely (!this->get_glyph_funcZ)) return 0;
1311
1312 hb_cmap_get_glyph_func_t get_glyph_funcZ = this->get_glyph_funcZ;
1313 const void *get_glyph_data = this->get_glyph_data;
1314
1315 unsigned int done;
1316 for (done = 0;
1317 done < count && get_glyph_funcZ (get_glyph_data, *first_unicode, first_glyph);
1318 done++)
1319 {
1320 first_unicode = &StructAtOffsetUnaligned<hb_codepoint_t> (first_unicode, unicode_stride);
1321 first_glyph = &StructAtOffsetUnaligned<hb_codepoint_t> (first_glyph, glyph_stride);
1322 }
1323 return done;
1324 }
1325
1326 bool get_variation_glyph (hb_codepoint_t unicode,
1327 hb_codepoint_t variation_selector,
1328 hb_codepoint_t *glyph) const
1329 {
1330 switch (this->subtable_uvs->get_glyph_variant (unicode,
1331 variation_selector,
1332 glyph))
1333 {
1334 case GLYPH_VARIANT_NOT_FOUND: return false;
1335 case GLYPH_VARIANT_FOUND: return true;
1336 case GLYPH_VARIANT_USE_DEFAULT: break;
1337 }
1338
1339 return get_nominal_glyph (unicode, glyph);
1340 }
1341
1342 void collect_unicodes (hb_set_t *out) const
1343 { subtable->collect_unicodes (out); }
1344 void collect_variation_selectors (hb_set_t *out) const
1345 { subtable_uvs->collect_variation_selectors (out); }
1346 void collect_variation_unicodes (hb_codepoint_t variation_selector,
1347 hb_set_t *out) const
1348 { subtable_uvs->collect_variation_unicodes (variation_selector, out); }
1349
1350 protected:
1351 typedef bool (*hb_cmap_get_glyph_func_t) (const void *obj,
1352 hb_codepoint_t codepoint,
1353 hb_codepoint_t *glyph);
1354
1355 template <typename Type>
1356 HB_INTERNAL static bool get_glyph_from (const void *obj,
1357 hb_codepoint_t codepoint,
1358 hb_codepoint_t *glyph)
1359 {
1360 const Type *typed_obj = (const Type *) obj;
1361 return typed_obj->get_glyph (codepoint, glyph);
1362 }
1363
1364 template <typename Type>
1365 HB_INTERNAL static bool get_glyph_from_symbol (const void *obj,
1366 hb_codepoint_t codepoint,
1367 hb_codepoint_t *glyph)
1368 {
1369 const Type *typed_obj = (const Type *) obj;
1370 if (likely (typed_obj->get_glyph (codepoint, glyph)))
1371 return true;
1372
1373 if (codepoint <= 0x00FFu)
1374 {
1375 /* For symbol-encoded OpenType fonts, we duplicate the
1376 * U+F000..F0FF range at U+0000..U+00FF. That's what
1377 * Windows seems to do, and that's hinted about at:
1378 * https://docs.microsoft.com/en-us/typography/opentype/spec/recom
1379 * under "Non-Standard (Symbol) Fonts". */
1380 return typed_obj->get_glyph (0xF000u + codepoint, glyph);
1381 }
1382
1383 return false;
1384 }
1385
1386 private:
1387 hb_nonnull_ptr_t<const CmapSubtable> subtable;
1388 hb_nonnull_ptr_t<const CmapSubtableFormat14> subtable_uvs;
1389
1390 hb_cmap_get_glyph_func_t get_glyph_funcZ;
1391 const void *get_glyph_data;
1392
1393 CmapSubtableFormat4::accelerator_t format4_accel;
1394
1395 public:
1396 hb_blob_ptr_t<cmap> table;
1397 };
1398
1399 protected:
1400
1401 const CmapSubtable *find_subtable (unsigned int platform_id,
1402 unsigned int encoding_id) const
1403 {
1404 EncodingRecord key;
1405 key.platformID = platform_id;
1406 key.encodingID = encoding_id;
1407
1408 const EncodingRecord &result = encodingRecord.bsearch (key);
1409 if (!result.subtable)
1410 return nullptr;
1411
1412 return &(this+result.subtable);
1413 }
1414
1415 const EncodingRecord *find_encodingrec (unsigned int platform_id,
1416 unsigned int encoding_id) const
1417 {
1418 EncodingRecord key;
1419 key.platformID = platform_id;
1420 key.encodingID = encoding_id;
1421
1422 return encodingRecord.as_array ().bsearch (key);
1423 }
1424
1425 bool find_subtable (unsigned format) const
1426 {
1427 auto it =
1428 + hb_iter (encodingRecord)
1429 | hb_map (&EncodingRecord::subtable)
1430 | hb_map (hb_add (this))
1431 | hb_filter ([&] (const CmapSubtable& _) { return _.u.format == format; })
1432 ;
1433
1434 return it.len ();
1435 }
1436
1437 public:
1438
1439 bool sanitize (hb_sanitize_context_t *c) const
1440 {
1441 TRACE_SANITIZE (this);
1442 return_trace (c->check_struct (this) &&
1443 likely (version == 0) &&
1444 encodingRecord.sanitize (c, this));
1445 }
1446
1447 protected:
1448 HBUINT16 version; /* Table version number (0). */
1449 SortedArrayOf<EncodingRecord>
1450 encodingRecord; /* Encoding tables. */
1451 public:
1452 DEFINE_SIZE_ARRAY (4, encodingRecord);
1453};
1454
1455struct cmap_accelerator_t : cmap::accelerator_t {};
1456
1457} /* namespace OT */
1458
1459
1460#endif /* HB_OT_CMAP_TABLE_HH */
1461