?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Restore variadic macros in DevToolsEmbedderMessageDispatcher
[chromium-blink-merge.git] / third_party / harfbuzz-ng / src / hb-ot-layout-gpos-table.hh
blobda9506c76653db0a90288effbdec86e9ccf88caa
1 /*
2 * Copyright © 2007,2008,2009,2010 Red Hat, Inc.
3 * Copyright © 2010,2012,2013 Google, Inc.
4 *
5 * This is part of HarfBuzz, a text shaping library.
6 *
7 * Permission is hereby granted, without written agreement and without
8 * license or royalty fees, to use, copy, modify, and distribute this
9 * software and its documentation for any purpose, provided that the
10 * above copyright notice and the following two paragraphs appear in
11 * all copies of this software.
12 *
13 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
14 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
15 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
16 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
17 * DAMAGE.
18 *
19 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
20 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
21 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
22 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
23 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
24 *
25 * Red Hat Author(s): Behdad Esfahbod
26 * Google Author(s): Behdad Esfahbod
27 */
28
29 #ifndef HB_OT_LAYOUT_GPOS_TABLE_HH
30 #define HB_OT_LAYOUT_GPOS_TABLE_HH
31
32 #include "hb-ot-layout-gsubgpos-private.hh"
33
34
35 namespace OT {
36
37
38 /* buffer **position** var allocations */
39 #define attach_lookback() var.u16[0] /* number of glyphs to go back to attach this glyph to its base */
40 #define cursive_chain() var.i16[1] /* character to which this connects, may be positive or negative */
41
42
43 /* Shared Tables: ValueRecord, Anchor Table, and MarkArray */
44
45 typedef USHORT Value;
46
47 typedef Value ValueRecord[VAR];
48
49 struct ValueFormat : USHORT
50 {
51 enum Flags {
52 xPlacement = 0x0001u, /* Includes horizontal adjustment for placement */
53 yPlacement = 0x0002u, /* Includes vertical adjustment for placement */
54 xAdvance = 0x0004u, /* Includes horizontal adjustment for advance */
55 yAdvance = 0x0008u, /* Includes vertical adjustment for advance */
56 xPlaDevice = 0x0010u, /* Includes horizontal Device table for placement */
57 yPlaDevice = 0x0020u, /* Includes vertical Device table for placement */
58 xAdvDevice = 0x0040u, /* Includes horizontal Device table for advance */
59 yAdvDevice = 0x0080u, /* Includes vertical Device table for advance */
60 ignored = 0x0F00u, /* Was used in TrueType Open for MM fonts */
61 reserved = 0xF000u, /* For future use */
62
63 devices = 0x00F0u /* Mask for having any Device table */
64 };
65
66 /* All fields are options. Only those available advance the value pointer. */
67 #if 0
68 SHORT xPlacement; /* Horizontal adjustment for
69 * placement--in design units */
70 SHORT yPlacement; /* Vertical adjustment for
71 * placement--in design units */
72 SHORT xAdvance; /* Horizontal adjustment for
73 * advance--in design units (only used
74 * for horizontal writing) */
75 SHORT yAdvance; /* Vertical adjustment for advance--in
76 * design units (only used for vertical
77 * writing) */
78 Offset xPlaDevice; /* Offset to Device table for
79 * horizontal placement--measured from
80 * beginning of PosTable (may be NULL) */
81 Offset yPlaDevice; /* Offset to Device table for vertical
82 * placement--measured from beginning
83 * of PosTable (may be NULL) */
84 Offset xAdvDevice; /* Offset to Device table for
85 * horizontal advance--measured from
86 * beginning of PosTable (may be NULL) */
87 Offset yAdvDevice; /* Offset to Device table for vertical
88 * advance--measured from beginning of
89 * PosTable (may be NULL) */
90 #endif
91
92 inline unsigned int get_len (void) const
93 { return _hb_popcount32 ((unsigned int) *this); }
94 inline unsigned int get_size (void) const
95 { return get_len () * Value::static_size; }
96
97 void apply_value (hb_font_t *font,
98 hb_direction_t direction,
99 const void *base,
100 const Value *values,
101 hb_glyph_position_t &glyph_pos) const
102 {
103 unsigned int x_ppem, y_ppem;
104 unsigned int format = *this;
105 hb_bool_t horizontal = HB_DIRECTION_IS_HORIZONTAL (direction);
106
107 if (!format) return;
108
109 if (format & xPlacement) glyph_pos.x_offset += font->em_scale_x (get_short (values++));
110 if (format & yPlacement) glyph_pos.y_offset += font->em_scale_y (get_short (values++));
111 if (format & xAdvance) {
112 if (likely (horizontal)) glyph_pos.x_advance += font->em_scale_x (get_short (values));
113 values++;
114 }
115 /* y_advance values grow downward but font-space grows upward, hence negation */
116 if (format & yAdvance) {
117 if (unlikely (!horizontal)) glyph_pos.y_advance -= font->em_scale_y (get_short (values));
118 values++;
119 }
120
121 if (!has_device ()) return;
122
123 x_ppem = font->x_ppem;
124 y_ppem = font->y_ppem;
125
126 if (!x_ppem && !y_ppem) return;
127
128 /* pixel -> fractional pixel */
129 if (format & xPlaDevice) {
130 if (x_ppem) glyph_pos.x_offset += (base + get_device (values)).get_x_delta (font);
131 values++;
132 }
133 if (format & yPlaDevice) {
134 if (y_ppem) glyph_pos.y_offset += (base + get_device (values)).get_y_delta (font);
135 values++;
136 }
137 if (format & xAdvDevice) {
138 if (horizontal && x_ppem) glyph_pos.x_advance += (base + get_device (values)).get_x_delta (font);
139 values++;
140 }
141 if (format & yAdvDevice) {
142 /* y_advance values grow downward but font-space grows upward, hence negation */
143 if (!horizontal && y_ppem) glyph_pos.y_advance -= (base + get_device (values)).get_y_delta (font);
144 values++;
145 }
146 }
147
148 private:
149 inline bool sanitize_value_devices (hb_sanitize_context_t *c, const void *base, const Value *values) const
150 {
151 unsigned int format = *this;
152
153 if (format & xPlacement) values++;
154 if (format & yPlacement) values++;
155 if (format & xAdvance) values++;
156 if (format & yAdvance) values++;
157
158 if ((format & xPlaDevice) && !get_device (values++).sanitize (c, base)) return false;
159 if ((format & yPlaDevice) && !get_device (values++).sanitize (c, base)) return false;
160 if ((format & xAdvDevice) && !get_device (values++).sanitize (c, base)) return false;
161 if ((format & yAdvDevice) && !get_device (values++).sanitize (c, base)) return false;
162
163 return true;
164 }
165
166 static inline OffsetTo<Device>& get_device (Value* value)
167 { return *CastP<OffsetTo<Device> > (value); }
168 static inline const OffsetTo<Device>& get_device (const Value* value)
169 { return *CastP<OffsetTo<Device> > (value); }
170
171 static inline const SHORT& get_short (const Value* value)
172 { return *CastP<SHORT> (value); }
173
174 public:
175
176 inline bool has_device (void) const {
177 unsigned int format = *this;
178 return (format & devices) != 0;
179 }
180
181 inline bool sanitize_value (hb_sanitize_context_t *c, const void *base, const Value *values) const
182 {
183 TRACE_SANITIZE (this);
184 return TRACE_RETURN (c->check_range (values, get_size ()) && (!has_device () || sanitize_value_devices (c, base, values)));
185 }
186
187 inline bool sanitize_values (hb_sanitize_context_t *c, const void *base, const Value *values, unsigned int count) const
188 {
189 TRACE_SANITIZE (this);
190 unsigned int len = get_len ();
191
192 if (!c->check_array (values, get_size (), count)) return TRACE_RETURN (false);
193
194 if (!has_device ()) return TRACE_RETURN (true);
195
196 for (unsigned int i = 0; i < count; i++) {
197 if (!sanitize_value_devices (c, base, values))
198 return TRACE_RETURN (false);
199 values += len;
200 }
201
202 return TRACE_RETURN (true);
203 }
204
205 /* Just sanitize referenced Device tables. Doesn't check the values themselves. */
206 inline bool sanitize_values_stride_unsafe (hb_sanitize_context_t *c, const void *base, const Value *values, unsigned int count, unsigned int stride) const
207 {
208 TRACE_SANITIZE (this);
209
210 if (!has_device ()) return TRACE_RETURN (true);
211
212 for (unsigned int i = 0; i < count; i++) {
213 if (!sanitize_value_devices (c, base, values))
214 return TRACE_RETURN (false);
215 values += stride;
216 }
217
218 return TRACE_RETURN (true);
219 }
220 };
221
222
223 struct AnchorFormat1
224 {
225 inline void get_anchor (hb_font_t *font, hb_codepoint_t glyph_id HB_UNUSED,
226 hb_position_t *x, hb_position_t *y) const
227 {
228 *x = font->em_scale_x (xCoordinate);
229 *y = font->em_scale_y (yCoordinate);
230 }
231
232 inline bool sanitize (hb_sanitize_context_t *c) const
233 {
234 TRACE_SANITIZE (this);
235 return TRACE_RETURN (c->check_struct (this));
236 }
237
238 protected:
239 USHORT format; /* Format identifier--format = 1 */
240 SHORT xCoordinate; /* Horizontal value--in design units */
241 SHORT yCoordinate; /* Vertical value--in design units */
242 public:
243 DEFINE_SIZE_STATIC (6);
244 };
245
246 struct AnchorFormat2
247 {
248 inline void get_anchor (hb_font_t *font, hb_codepoint_t glyph_id,
249 hb_position_t *x, hb_position_t *y) const
250 {
251 unsigned int x_ppem = font->x_ppem;
252 unsigned int y_ppem = font->y_ppem;
253 hb_position_t cx, cy;
254 hb_bool_t ret;
255
256 ret = (x_ppem || y_ppem) &&
257 font->get_glyph_contour_point_for_origin (glyph_id, anchorPoint, HB_DIRECTION_LTR, &cx, &cy);
258 *x = ret && x_ppem ? cx : font->em_scale_x (xCoordinate);
259 *y = ret && y_ppem ? cy : font->em_scale_y (yCoordinate);
260 }
261
262 inline bool sanitize (hb_sanitize_context_t *c) const
263 {
264 TRACE_SANITIZE (this);
265 return TRACE_RETURN (c->check_struct (this));
266 }
267
268 protected:
269 USHORT format; /* Format identifier--format = 2 */
270 SHORT xCoordinate; /* Horizontal value--in design units */
271 SHORT yCoordinate; /* Vertical value--in design units */
272 USHORT anchorPoint; /* Index to glyph contour point */
273 public:
274 DEFINE_SIZE_STATIC (8);
275 };
276
277 struct AnchorFormat3
278 {
279 inline void get_anchor (hb_font_t *font, hb_codepoint_t glyph_id HB_UNUSED,
280 hb_position_t *x, hb_position_t *y) const
281 {
282 *x = font->em_scale_x (xCoordinate);
283 *y = font->em_scale_y (yCoordinate);
284
285 if (font->x_ppem)
286 *x += (this+xDeviceTable).get_x_delta (font);
287 if (font->y_ppem)
288 *y += (this+yDeviceTable).get_x_delta (font);
289 }
290
291 inline bool sanitize (hb_sanitize_context_t *c) const
292 {
293 TRACE_SANITIZE (this);
294 return TRACE_RETURN (c->check_struct (this) && xDeviceTable.sanitize (c, this) && yDeviceTable.sanitize (c, this));
295 }
296
297 protected:
298 USHORT format; /* Format identifier--format = 3 */
299 SHORT xCoordinate; /* Horizontal value--in design units */
300 SHORT yCoordinate; /* Vertical value--in design units */
301 OffsetTo<Device>
302 xDeviceTable; /* Offset to Device table for X
303 * coordinate-- from beginning of
304 * Anchor table (may be NULL) */
305 OffsetTo<Device>
306 yDeviceTable; /* Offset to Device table for Y
307 * coordinate-- from beginning of
308 * Anchor table (may be NULL) */
309 public:
310 DEFINE_SIZE_STATIC (10);
311 };
312
313 struct Anchor
314 {
315 inline void get_anchor (hb_font_t *font, hb_codepoint_t glyph_id,
316 hb_position_t *x, hb_position_t *y) const
317 {
318 *x = *y = 0;
319 switch (u.format) {
320 case 1: u.format1.get_anchor (font, glyph_id, x, y); return;
321 case 2: u.format2.get_anchor (font, glyph_id, x, y); return;
322 case 3: u.format3.get_anchor (font, glyph_id, x, y); return;
323 default: return;
324 }
325 }
326
327 inline bool sanitize (hb_sanitize_context_t *c) const
328 {
329 TRACE_SANITIZE (this);
330 if (!u.format.sanitize (c)) return TRACE_RETURN (false);
331 switch (u.format) {
332 case 1: return TRACE_RETURN (u.format1.sanitize (c));
333 case 2: return TRACE_RETURN (u.format2.sanitize (c));
334 case 3: return TRACE_RETURN (u.format3.sanitize (c));
335 default:return TRACE_RETURN (true);
336 }
337 }
338
339 protected:
340 union {
341 USHORT format; /* Format identifier */
342 AnchorFormat1 format1;
343 AnchorFormat2 format2;
344 AnchorFormat3 format3;
345 } u;
346 public:
347 DEFINE_SIZE_UNION (2, format);
348 };
349
350
351 struct AnchorMatrix
352 {
353 inline const Anchor& get_anchor (unsigned int row, unsigned int col, unsigned int cols, bool *found) const {
354 *found = false;
355 if (unlikely (row >= rows || col >= cols)) return Null(Anchor);
356 *found = !matrixZ[row * cols + col].is_null ();
357 return this+matrixZ[row * cols + col];
358 }
359
360 inline bool sanitize (hb_sanitize_context_t *c, unsigned int cols) const
361 {
362 TRACE_SANITIZE (this);
363 if (!c->check_struct (this)) return TRACE_RETURN (false);
364 if (unlikely (rows > 0 && cols >= ((unsigned int) -1) / rows)) return TRACE_RETURN (false);
365 unsigned int count = rows * cols;
366 if (!c->check_array (matrixZ, matrixZ[0].static_size, count)) return TRACE_RETURN (false);
367 for (unsigned int i = 0; i < count; i++)
368 if (!matrixZ[i].sanitize (c, this)) return TRACE_RETURN (false);
369 return TRACE_RETURN (true);
370 }
371
372 USHORT rows; /* Number of rows */
373 protected:
374 OffsetTo<Anchor>
375 matrixZ[VAR]; /* Matrix of offsets to Anchor tables--
376 * from beginning of AnchorMatrix table */
377 public:
378 DEFINE_SIZE_ARRAY (2, matrixZ);
379 };
380
381
382 struct MarkRecord
383 {
384 friend struct MarkArray;
385
386 inline bool sanitize (hb_sanitize_context_t *c, const void *base) const
387 {
388 TRACE_SANITIZE (this);
389 return TRACE_RETURN (c->check_struct (this) && markAnchor.sanitize (c, base));
390 }
391
392 protected:
393 USHORT klass; /* Class defined for this mark */
394 OffsetTo<Anchor>
395 markAnchor; /* Offset to Anchor table--from
396 * beginning of MarkArray table */
397 public:
398 DEFINE_SIZE_STATIC (4);
399 };
400
401 struct MarkArray : ArrayOf<MarkRecord> /* Array of MarkRecords--in Coverage order */
402 {
403 inline bool apply (hb_apply_context_t *c,
404 unsigned int mark_index, unsigned int glyph_index,
405 const AnchorMatrix &anchors, unsigned int class_count,
406 unsigned int glyph_pos) const
407 {
408 TRACE_APPLY (this);
409 hb_buffer_t *buffer = c->buffer;
410 const MarkRecord &record = ArrayOf<MarkRecord>::operator[](mark_index);
411 unsigned int mark_class = record.klass;
412
413 const Anchor& mark_anchor = this + record.markAnchor;
414 bool found;
415 const Anchor& glyph_anchor = anchors.get_anchor (glyph_index, mark_class, class_count, &found);
416 /* If this subtable doesn't have an anchor for this base and this class,
417 * return false such that the subsequent subtables have a chance at it. */
418 if (unlikely (!found)) return TRACE_RETURN (false);
419
420 hb_position_t mark_x, mark_y, base_x, base_y;
421
422 mark_anchor.get_anchor (c->font, buffer->cur().codepoint, &mark_x, &mark_y);
423 glyph_anchor.get_anchor (c->font, buffer->info[glyph_pos].codepoint, &base_x, &base_y);
424
425 hb_glyph_position_t &o = buffer->cur_pos();
426 o.x_offset = base_x - mark_x;
427 o.y_offset = base_y - mark_y;
428 o.attach_lookback() = buffer->idx - glyph_pos;
429
430 buffer->idx++;
431 return TRACE_RETURN (true);
432 }
433
434 inline bool sanitize (hb_sanitize_context_t *c) const
435 {
436 TRACE_SANITIZE (this);
437 return TRACE_RETURN (ArrayOf<MarkRecord>::sanitize (c, this));
438 }
439 };
440
441
442 /* Lookups */
443
444 struct SinglePosFormat1
445 {
446 inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
447 {
448 TRACE_COLLECT_GLYPHS (this);
449 (this+coverage).add_coverage (c->input);
450 }
451
452 inline const Coverage &get_coverage (void) const
453 {
454 return this+coverage;
455 }
456
457 inline bool apply (hb_apply_context_t *c) const
458 {
459 TRACE_APPLY (this);
460 hb_buffer_t *buffer = c->buffer;
461 unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint);
462 if (likely (index == NOT_COVERED)) return TRACE_RETURN (false);
463
464 valueFormat.apply_value (c->font, c->direction, this,
465 values, buffer->cur_pos());
466
467 buffer->idx++;
468 return TRACE_RETURN (true);
469 }
470
471 inline bool sanitize (hb_sanitize_context_t *c) const
472 {
473 TRACE_SANITIZE (this);
474 return TRACE_RETURN (c->check_struct (this)
475 && coverage.sanitize (c, this)
476 && valueFormat.sanitize_value (c, this, values));
477 }
478
479 protected:
480 USHORT format; /* Format identifier--format = 1 */
481 OffsetTo<Coverage>
482 coverage; /* Offset to Coverage table--from
483 * beginning of subtable */
484 ValueFormat valueFormat; /* Defines the types of data in the
485 * ValueRecord */
486 ValueRecord values; /* Defines positioning
487 * value(s)--applied to all glyphs in
488 * the Coverage table */
489 public:
490 DEFINE_SIZE_ARRAY (6, values);
491 };
492
493 struct SinglePosFormat2
494 {
495 inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
496 {
497 TRACE_COLLECT_GLYPHS (this);
498 (this+coverage).add_coverage (c->input);
499 }
500
501 inline const Coverage &get_coverage (void) const
502 {
503 return this+coverage;
504 }
505
506 inline bool apply (hb_apply_context_t *c) const
507 {
508 TRACE_APPLY (this);
509 hb_buffer_t *buffer = c->buffer;
510 unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint);
511 if (likely (index == NOT_COVERED)) return TRACE_RETURN (false);
512
513 if (likely (index >= valueCount)) return TRACE_RETURN (false);
514
515 valueFormat.apply_value (c->font, c->direction, this,
516 &values[index * valueFormat.get_len ()],
517 buffer->cur_pos());
518
519 buffer->idx++;
520 return TRACE_RETURN (true);
521 }
522
523 inline bool sanitize (hb_sanitize_context_t *c) const
524 {
525 TRACE_SANITIZE (this);
526 return TRACE_RETURN (c->check_struct (this)
527 && coverage.sanitize (c, this)
528 && valueFormat.sanitize_values (c, this, values, valueCount));
529 }
530
531 protected:
532 USHORT format; /* Format identifier--format = 2 */
533 OffsetTo<Coverage>
534 coverage; /* Offset to Coverage table--from
535 * beginning of subtable */
536 ValueFormat valueFormat; /* Defines the types of data in the
537 * ValueRecord */
538 USHORT valueCount; /* Number of ValueRecords */
539 ValueRecord values; /* Array of ValueRecords--positioning
540 * values applied to glyphs */
541 public:
542 DEFINE_SIZE_ARRAY (8, values);
543 };
544
545 struct SinglePos
546 {
547 template <typename context_t>
548 inline typename context_t::return_t dispatch (context_t *c) const
549 {
550 TRACE_DISPATCH (this, u.format);
551 if (unlikely (!c->may_dispatch (this, &u.format))) TRACE_RETURN (c->default_return_value ());
552 switch (u.format) {
553 case 1: return TRACE_RETURN (c->dispatch (u.format1));
554 case 2: return TRACE_RETURN (c->dispatch (u.format2));
555 default:return TRACE_RETURN (c->default_return_value ());
556 }
557 }
558
559 protected:
560 union {
561 USHORT format; /* Format identifier */
562 SinglePosFormat1 format1;
563 SinglePosFormat2 format2;
564 } u;
565 };
566
567
568 struct PairValueRecord
569 {
570 friend struct PairSet;
571
572 protected:
573 GlyphID secondGlyph; /* GlyphID of second glyph in the
574 * pair--first glyph is listed in the
575 * Coverage table */
576 ValueRecord values; /* Positioning data for the first glyph
577 * followed by for second glyph */
578 public:
579 DEFINE_SIZE_ARRAY (2, values);
580 };
581
582 struct PairSet
583 {
584 friend struct PairPosFormat1;
585
586 inline void collect_glyphs (hb_collect_glyphs_context_t *c,
587 const ValueFormat *valueFormats) const
588 {
589 TRACE_COLLECT_GLYPHS (this);
590 unsigned int len1 = valueFormats[0].get_len ();
591 unsigned int len2 = valueFormats[1].get_len ();
592 unsigned int record_size = USHORT::static_size * (1 + len1 + len2);
593
594 const PairValueRecord *record = CastP<PairValueRecord> (arrayZ);
595 unsigned int count = len;
596 for (unsigned int i = 0; i < count; i++)
597 {
598 c->input->add (record->secondGlyph);
599 record = &StructAtOffset<PairValueRecord> (record, record_size);
600 }
601 }
602
603 inline bool apply (hb_apply_context_t *c,
604 const ValueFormat *valueFormats,
605 unsigned int pos) const
606 {
607 TRACE_APPLY (this);
608 hb_buffer_t *buffer = c->buffer;
609 unsigned int len1 = valueFormats[0].get_len ();
610 unsigned int len2 = valueFormats[1].get_len ();
611 unsigned int record_size = USHORT::static_size * (1 + len1 + len2);
612
613 const PairValueRecord *record_array = CastP<PairValueRecord> (arrayZ);
614 unsigned int count = len;
615
616 /* Hand-coded bsearch. */
617 if (unlikely (!count))
618 return TRACE_RETURN (false);
619 hb_codepoint_t x = buffer->info[pos].codepoint;
620 int min = 0, max = (int) count - 1;
621 while (min <= max)
622 {
623 int mid = (min + max) / 2;
624 const PairValueRecord *record = &StructAtOffset<PairValueRecord> (record_array, record_size * mid);
625 hb_codepoint_t mid_x = record->secondGlyph;
626 if (x < mid_x)
627 max = mid - 1;
628 else if (x > mid_x)
629 min = mid + 1;
630 else
631 {
632 valueFormats[0].apply_value (c->font, c->direction, this,
633 &record->values[0], buffer->cur_pos());
634 valueFormats[1].apply_value (c->font, c->direction, this,
635 &record->values[len1], buffer->pos[pos]);
636 if (len2)
637 pos++;
638 buffer->idx = pos;
639 return TRACE_RETURN (true);
640 }
641 }
642
643 return TRACE_RETURN (false);
644 }
645
646 struct sanitize_closure_t {
647 const void *base;
648 const ValueFormat *valueFormats;
649 unsigned int len1; /* valueFormats[0].get_len() */
650 unsigned int stride; /* 1 + len1 + len2 */
651 };
652
653 inline bool sanitize (hb_sanitize_context_t *c, const sanitize_closure_t *closure) const
654 {
655 TRACE_SANITIZE (this);
656 if (!(c->check_struct (this)
657 && c->check_array (arrayZ, USHORT::static_size * closure->stride, len))) return TRACE_RETURN (false);
658
659 unsigned int count = len;
660 const PairValueRecord *record = CastP<PairValueRecord> (arrayZ);
661 return TRACE_RETURN (closure->valueFormats[0].sanitize_values_stride_unsafe (c, closure->base, &record->values[0], count, closure->stride)
662 && closure->valueFormats[1].sanitize_values_stride_unsafe (c, closure->base, &record->values[closure->len1], count, closure->stride));
663 }
664
665 protected:
666 USHORT len; /* Number of PairValueRecords */
667 USHORT arrayZ[VAR]; /* Array of PairValueRecords--ordered
668 * by GlyphID of the second glyph */
669 public:
670 DEFINE_SIZE_ARRAY (2, arrayZ);
671 };
672
673 struct PairPosFormat1
674 {
675 inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
676 {
677 TRACE_COLLECT_GLYPHS (this);
678 (this+coverage).add_coverage (c->input);
679 unsigned int count = pairSet.len;
680 for (unsigned int i = 0; i < count; i++)
681 (this+pairSet[i]).collect_glyphs (c, &valueFormat1);
682 }
683
684 inline const Coverage &get_coverage (void) const
685 {
686 return this+coverage;
687 }
688
689 inline bool apply (hb_apply_context_t *c) const
690 {
691 TRACE_APPLY (this);
692 hb_buffer_t *buffer = c->buffer;
693 unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint);
694 if (likely (index == NOT_COVERED)) return TRACE_RETURN (false);
695
696 hb_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
697 skippy_iter.reset (buffer->idx, 1);
698 if (!skippy_iter.next ()) return TRACE_RETURN (false);
699
700 return TRACE_RETURN ((this+pairSet[index]).apply (c, &valueFormat1, skippy_iter.idx));
701 }
702
703 inline bool sanitize (hb_sanitize_context_t *c) const
704 {
705 TRACE_SANITIZE (this);
706
707 unsigned int len1 = valueFormat1.get_len ();
708 unsigned int len2 = valueFormat2.get_len ();
709 PairSet::sanitize_closure_t closure = {
710 this,
711 &valueFormat1,
712 len1,
713 1 + len1 + len2
714 };
715
716 return TRACE_RETURN (c->check_struct (this) && coverage.sanitize (c, this) && pairSet.sanitize (c, this, &closure));
717 }
718
719 protected:
720 USHORT format; /* Format identifier--format = 1 */
721 OffsetTo<Coverage>
722 coverage; /* Offset to Coverage table--from
723 * beginning of subtable */
724 ValueFormat valueFormat1; /* Defines the types of data in
725 * ValueRecord1--for the first glyph
726 * in the pair--may be zero (0) */
727 ValueFormat valueFormat2; /* Defines the types of data in
728 * ValueRecord2--for the second glyph
729 * in the pair--may be zero (0) */
730 OffsetArrayOf<PairSet>
731 pairSet; /* Array of PairSet tables
732 * ordered by Coverage Index */
733 public:
734 DEFINE_SIZE_ARRAY (10, pairSet);
735 };
736
737 struct PairPosFormat2
738 {
739 inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
740 {
741 TRACE_COLLECT_GLYPHS (this);
742 /* (this+coverage).add_coverage (c->input); // Don't need this. */
743
744 unsigned int count1 = class1Count;
745 const ClassDef &klass1 = this+classDef1;
746 for (unsigned int i = 0; i < count1; i++)
747 klass1.add_class (c->input, i);
748
749 unsigned int count2 = class2Count;
750 const ClassDef &klass2 = this+classDef2;
751 for (unsigned int i = 0; i < count2; i++)
752 klass2.add_class (c->input, i);
753 }
754
755 inline const Coverage &get_coverage (void) const
756 {
757 return this+coverage;
758 }
759
760 inline bool apply (hb_apply_context_t *c) const
761 {
762 TRACE_APPLY (this);
763 hb_buffer_t *buffer = c->buffer;
764 unsigned int index = (this+coverage).get_coverage (buffer->cur().codepoint);
765 if (likely (index == NOT_COVERED)) return TRACE_RETURN (false);
766
767 hb_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
768 skippy_iter.reset (buffer->idx, 1);
769 if (!skippy_iter.next ()) return TRACE_RETURN (false);
770
771 unsigned int len1 = valueFormat1.get_len ();
772 unsigned int len2 = valueFormat2.get_len ();
773 unsigned int record_len = len1 + len2;
774
775 unsigned int klass1 = (this+classDef1).get_class (buffer->cur().codepoint);
776 unsigned int klass2 = (this+classDef2).get_class (buffer->info[skippy_iter.idx].codepoint);
777 if (unlikely (klass1 >= class1Count || klass2 >= class2Count)) return TRACE_RETURN (false);
778
779 const Value *v = &values[record_len * (klass1 * class2Count + klass2)];
780 valueFormat1.apply_value (c->font, c->direction, this,
781 v, buffer->cur_pos());
782 valueFormat2.apply_value (c->font, c->direction, this,
783 v + len1, buffer->pos[skippy_iter.idx]);
784
785 buffer->idx = skippy_iter.idx;
786 if (len2)
787 buffer->idx++;
788
789 return TRACE_RETURN (true);
790 }
791
792 inline bool sanitize (hb_sanitize_context_t *c) const
793 {
794 TRACE_SANITIZE (this);
795 if (!(c->check_struct (this)
796 && coverage.sanitize (c, this)
797 && classDef1.sanitize (c, this)
798 && classDef2.sanitize (c, this))) return TRACE_RETURN (false);
799
800 unsigned int len1 = valueFormat1.get_len ();
801 unsigned int len2 = valueFormat2.get_len ();
802 unsigned int stride = len1 + len2;
803 unsigned int record_size = valueFormat1.get_size () + valueFormat2.get_size ();
804 unsigned int count = (unsigned int) class1Count * (unsigned int) class2Count;
805 return TRACE_RETURN (c->check_array (values, record_size, count) &&
806 valueFormat1.sanitize_values_stride_unsafe (c, this, &values[0], count, stride) &&
807 valueFormat2.sanitize_values_stride_unsafe (c, this, &values[len1], count, stride));
808 }
809
810 protected:
811 USHORT format; /* Format identifier--format = 2 */
812 OffsetTo<Coverage>
813 coverage; /* Offset to Coverage table--from
814 * beginning of subtable */
815 ValueFormat valueFormat1; /* ValueRecord definition--for the
816 * first glyph of the pair--may be zero
817 * (0) */
818 ValueFormat valueFormat2; /* ValueRecord definition--for the
819 * second glyph of the pair--may be
820 * zero (0) */
821 OffsetTo<ClassDef>
822 classDef1; /* Offset to ClassDef table--from
823 * beginning of PairPos subtable--for
824 * the first glyph of the pair */
825 OffsetTo<ClassDef>
826 classDef2; /* Offset to ClassDef table--from
827 * beginning of PairPos subtable--for
828 * the second glyph of the pair */
829 USHORT class1Count; /* Number of classes in ClassDef1
830 * table--includes Class0 */
831 USHORT class2Count; /* Number of classes in ClassDef2
832 * table--includes Class0 */
833 ValueRecord values; /* Matrix of value pairs:
834 * class1-major, class2-minor,
835 * Each entry has value1 and value2 */
836 public:
837 DEFINE_SIZE_ARRAY (16, values);
838 };
839
840 struct PairPos
841 {
842 template <typename context_t>
843 inline typename context_t::return_t dispatch (context_t *c) const
844 {
845 TRACE_DISPATCH (this, u.format);
846 if (unlikely (!c->may_dispatch (this, &u.format))) TRACE_RETURN (c->default_return_value ());
847 switch (u.format) {
848 case 1: return TRACE_RETURN (c->dispatch (u.format1));
849 case 2: return TRACE_RETURN (c->dispatch (u.format2));
850 default:return TRACE_RETURN (c->default_return_value ());
851 }
852 }
853
854 protected:
855 union {
856 USHORT format; /* Format identifier */
857 PairPosFormat1 format1;
858 PairPosFormat2 format2;
859 } u;
860 };
861
862
863 struct EntryExitRecord
864 {
865 friend struct CursivePosFormat1;
866
867 inline bool sanitize (hb_sanitize_context_t *c, const void *base) const
868 {
869 TRACE_SANITIZE (this);
870 return TRACE_RETURN (entryAnchor.sanitize (c, base) && exitAnchor.sanitize (c, base));
871 }
872
873 protected:
874 OffsetTo<Anchor>
875 entryAnchor; /* Offset to EntryAnchor table--from
876 * beginning of CursivePos
877 * subtable--may be NULL */
878 OffsetTo<Anchor>
879 exitAnchor; /* Offset to ExitAnchor table--from
880 * beginning of CursivePos
881 * subtable--may be NULL */
882 public:
883 DEFINE_SIZE_STATIC (4);
884 };
885
886 struct CursivePosFormat1
887 {
888 inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
889 {
890 TRACE_COLLECT_GLYPHS (this);
891 (this+coverage).add_coverage (c->input);
892 }
893
894 inline const Coverage &get_coverage (void) const
895 {
896 return this+coverage;
897 }
898
899 inline bool apply (hb_apply_context_t *c) const
900 {
901 TRACE_APPLY (this);
902 hb_buffer_t *buffer = c->buffer;
903
904 /* We don't handle mark glyphs here. */
905 if (unlikely (_hb_glyph_info_is_mark (&buffer->cur()))) return TRACE_RETURN (false);
906
907 const EntryExitRecord &this_record = entryExitRecord[(this+coverage).get_coverage (buffer->cur().codepoint)];
908 if (!this_record.exitAnchor) return TRACE_RETURN (false);
909
910 hb_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
911 skippy_iter.reset (buffer->idx, 1);
912 if (!skippy_iter.next ()) return TRACE_RETURN (false);
913
914 const EntryExitRecord &next_record = entryExitRecord[(this+coverage).get_coverage (buffer->info[skippy_iter.idx].codepoint)];
915 if (!next_record.entryAnchor) return TRACE_RETURN (false);
916
917 unsigned int i = buffer->idx;
918 unsigned int j = skippy_iter.idx;
919
920 hb_position_t entry_x, entry_y, exit_x, exit_y;
921 (this+this_record.exitAnchor).get_anchor (c->font, buffer->info[i].codepoint, &exit_x, &exit_y);
922 (this+next_record.entryAnchor).get_anchor (c->font, buffer->info[j].codepoint, &entry_x, &entry_y);
923
924 hb_glyph_position_t *pos = buffer->pos;
925
926 hb_position_t d;
927 /* Main-direction adjustment */
928 switch (c->direction) {
929 case HB_DIRECTION_LTR:
930 pos[i].x_advance = exit_x + pos[i].x_offset;
931
932 d = entry_x + pos[j].x_offset;
933 pos[j].x_advance -= d;
934 pos[j].x_offset -= d;
935 break;
936 case HB_DIRECTION_RTL:
937 d = exit_x + pos[i].x_offset;
938 pos[i].x_advance -= d;
939 pos[i].x_offset -= d;
940
941 pos[j].x_advance = entry_x + pos[j].x_offset;
942 break;
943 case HB_DIRECTION_TTB:
944 pos[i].y_advance = exit_y + pos[i].y_offset;
945
946 d = entry_y + pos[j].y_offset;
947 pos[j].y_advance -= d;
948 pos[j].y_offset -= d;
949 break;
950 case HB_DIRECTION_BTT:
951 d = exit_y + pos[i].y_offset;
952 pos[i].y_advance -= d;
953 pos[i].y_offset -= d;
954
955 pos[j].y_advance = entry_y;
956 break;
957 case HB_DIRECTION_INVALID:
958 default:
959 break;
960 }
961
962 /* Cross-direction adjustment */
963 if (c->lookup_props & LookupFlag::RightToLeft) {
964 pos[i].cursive_chain() = j - i;
965 if (likely (HB_DIRECTION_IS_HORIZONTAL (c->direction)))
966 pos[i].y_offset = entry_y - exit_y;
967 else
968 pos[i].x_offset = entry_x - exit_x;
969 } else {
970 pos[j].cursive_chain() = i - j;
971 if (likely (HB_DIRECTION_IS_HORIZONTAL (c->direction)))
972 pos[j].y_offset = exit_y - entry_y;
973 else
974 pos[j].x_offset = exit_x - entry_x;
975 }
976
977 buffer->idx = j;
978 return TRACE_RETURN (true);
979 }
980
981 inline bool sanitize (hb_sanitize_context_t *c) const
982 {
983 TRACE_SANITIZE (this);
984 return TRACE_RETURN (coverage.sanitize (c, this) && entryExitRecord.sanitize (c, this));
985 }
986
987 protected:
988 USHORT format; /* Format identifier--format = 1 */
989 OffsetTo<Coverage>
990 coverage; /* Offset to Coverage table--from
991 * beginning of subtable */
992 ArrayOf<EntryExitRecord>
993 entryExitRecord; /* Array of EntryExit records--in
994 * Coverage Index order */
995 public:
996 DEFINE_SIZE_ARRAY (6, entryExitRecord);
997 };
998
999 struct CursivePos
1000 {
1001 template <typename context_t>
1002 inline typename context_t::return_t dispatch (context_t *c) const
1003 {
1004 TRACE_DISPATCH (this, u.format);
1005 if (unlikely (!c->may_dispatch (this, &u.format))) TRACE_RETURN (c->default_return_value ());
1006 switch (u.format) {
1007 case 1: return TRACE_RETURN (c->dispatch (u.format1));
1008 default:return TRACE_RETURN (c->default_return_value ());
1009 }
1010 }
1011
1012 protected:
1013 union {
1014 USHORT format; /* Format identifier */
1015 CursivePosFormat1 format1;
1016 } u;
1017 };
1018
1019
1020 typedef AnchorMatrix BaseArray; /* base-major--
1021 * in order of BaseCoverage Index--,
1022 * mark-minor--
1023 * ordered by class--zero-based. */
1024
1025 struct MarkBasePosFormat1
1026 {
1027 inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
1028 {
1029 TRACE_COLLECT_GLYPHS (this);
1030 (this+markCoverage).add_coverage (c->input);
1031 (this+baseCoverage).add_coverage (c->input);
1032 }
1033
1034 inline const Coverage &get_coverage (void) const
1035 {
1036 return this+markCoverage;
1037 }
1038
1039 inline bool apply (hb_apply_context_t *c) const
1040 {
1041 TRACE_APPLY (this);
1042 hb_buffer_t *buffer = c->buffer;
1043 unsigned int mark_index = (this+markCoverage).get_coverage (buffer->cur().codepoint);
1044 if (likely (mark_index == NOT_COVERED)) return TRACE_RETURN (false);
1045
1046 /* now we search backwards for a non-mark glyph */
1047 hb_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
1048 skippy_iter.reset (buffer->idx, 1);
1049 skippy_iter.set_lookup_props (LookupFlag::IgnoreMarks);
1050 do {
1051 if (!skippy_iter.prev ()) return TRACE_RETURN (false);
1052 /* We only want to attach to the first of a MultipleSubst sequence. Reject others. */
1053 if (0 == _hb_glyph_info_get_lig_comp (&buffer->info[skippy_iter.idx])) break;
1054 skippy_iter.reject ();
1055 } while (1);
1056
1057 /* Checking that matched glyph is actually a base glyph by GDEF is too strong; disabled */
1058 if (!_hb_glyph_info_is_base_glyph (&buffer->info[skippy_iter.idx])) { /*return TRACE_RETURN (false);*/ }
1059
1060 unsigned int base_index = (this+baseCoverage).get_coverage (buffer->info[skippy_iter.idx].codepoint);
1061 if (base_index == NOT_COVERED) return TRACE_RETURN (false);
1062
1063 return TRACE_RETURN ((this+markArray).apply (c, mark_index, base_index, this+baseArray, classCount, skippy_iter.idx));
1064 }
1065
1066 inline bool sanitize (hb_sanitize_context_t *c) const
1067 {
1068 TRACE_SANITIZE (this);
1069 return TRACE_RETURN (c->check_struct (this) && markCoverage.sanitize (c, this) && baseCoverage.sanitize (c, this) &&
1070 markArray.sanitize (c, this) && baseArray.sanitize (c, this, (unsigned int) classCount));
1071 }
1072
1073 protected:
1074 USHORT format; /* Format identifier--format = 1 */
1075 OffsetTo<Coverage>
1076 markCoverage; /* Offset to MarkCoverage table--from
1077 * beginning of MarkBasePos subtable */
1078 OffsetTo<Coverage>
1079 baseCoverage; /* Offset to BaseCoverage table--from
1080 * beginning of MarkBasePos subtable */
1081 USHORT classCount; /* Number of classes defined for marks */
1082 OffsetTo<MarkArray>
1083 markArray; /* Offset to MarkArray table--from
1084 * beginning of MarkBasePos subtable */
1085 OffsetTo<BaseArray>
1086 baseArray; /* Offset to BaseArray table--from
1087 * beginning of MarkBasePos subtable */
1088 public:
1089 DEFINE_SIZE_STATIC (12);
1090 };
1091
1092 struct MarkBasePos
1093 {
1094 template <typename context_t>
1095 inline typename context_t::return_t dispatch (context_t *c) const
1096 {
1097 TRACE_DISPATCH (this, u.format);
1098 if (unlikely (!c->may_dispatch (this, &u.format))) TRACE_RETURN (c->default_return_value ());
1099 switch (u.format) {
1100 case 1: return TRACE_RETURN (c->dispatch (u.format1));
1101 default:return TRACE_RETURN (c->default_return_value ());
1102 }
1103 }
1104
1105 protected:
1106 union {
1107 USHORT format; /* Format identifier */
1108 MarkBasePosFormat1 format1;
1109 } u;
1110 };
1111
1112
1113 typedef AnchorMatrix LigatureAttach; /* component-major--
1114 * in order of writing direction--,
1115 * mark-minor--
1116 * ordered by class--zero-based. */
1117
1118 typedef OffsetListOf<LigatureAttach> LigatureArray;
1119 /* Array of LigatureAttach
1120 * tables ordered by
1121 * LigatureCoverage Index */
1122
1123 struct MarkLigPosFormat1
1124 {
1125 inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
1126 {
1127 TRACE_COLLECT_GLYPHS (this);
1128 (this+markCoverage).add_coverage (c->input);
1129 (this+ligatureCoverage).add_coverage (c->input);
1130 }
1131
1132 inline const Coverage &get_coverage (void) const
1133 {
1134 return this+markCoverage;
1135 }
1136
1137 inline bool apply (hb_apply_context_t *c) const
1138 {
1139 TRACE_APPLY (this);
1140 hb_buffer_t *buffer = c->buffer;
1141 unsigned int mark_index = (this+markCoverage).get_coverage (buffer->cur().codepoint);
1142 if (likely (mark_index == NOT_COVERED)) return TRACE_RETURN (false);
1143
1144 /* now we search backwards for a non-mark glyph */
1145 hb_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
1146 skippy_iter.reset (buffer->idx, 1);
1147 skippy_iter.set_lookup_props (LookupFlag::IgnoreMarks);
1148 if (!skippy_iter.prev ()) return TRACE_RETURN (false);
1149
1150 /* Checking that matched glyph is actually a ligature by GDEF is too strong; disabled */
1151 if (!_hb_glyph_info_is_ligature (&buffer->info[skippy_iter.idx])) { /*return TRACE_RETURN (false);*/ }
1152
1153 unsigned int j = skippy_iter.idx;
1154 unsigned int lig_index = (this+ligatureCoverage).get_coverage (buffer->info[j].codepoint);
1155 if (lig_index == NOT_COVERED) return TRACE_RETURN (false);
1156
1157 const LigatureArray& lig_array = this+ligatureArray;
1158 const LigatureAttach& lig_attach = lig_array[lig_index];
1159
1160 /* Find component to attach to */
1161 unsigned int comp_count = lig_attach.rows;
1162 if (unlikely (!comp_count)) return TRACE_RETURN (false);
1163
1164 /* We must now check whether the ligature ID of the current mark glyph
1165 * is identical to the ligature ID of the found ligature. If yes, we
1166 * can directly use the component index. If not, we attach the mark
1167 * glyph to the last component of the ligature. */
1168 unsigned int comp_index;
1169 unsigned int lig_id = _hb_glyph_info_get_lig_id (&buffer->info[j]);
1170 unsigned int mark_id = _hb_glyph_info_get_lig_id (&buffer->cur());
1171 unsigned int mark_comp = _hb_glyph_info_get_lig_comp (&buffer->cur());
1172 if (lig_id && lig_id == mark_id && mark_comp > 0)
1173 comp_index = MIN (comp_count, _hb_glyph_info_get_lig_comp (&buffer->cur())) - 1;
1174 else
1175 comp_index = comp_count - 1;
1176
1177 return TRACE_RETURN ((this+markArray).apply (c, mark_index, comp_index, lig_attach, classCount, j));
1178 }
1179
1180 inline bool sanitize (hb_sanitize_context_t *c) const
1181 {
1182 TRACE_SANITIZE (this);
1183 return TRACE_RETURN (c->check_struct (this) && markCoverage.sanitize (c, this) && ligatureCoverage.sanitize (c, this) &&
1184 markArray.sanitize (c, this) && ligatureArray.sanitize (c, this, (unsigned int) classCount));
1185 }
1186
1187 protected:
1188 USHORT format; /* Format identifier--format = 1 */
1189 OffsetTo<Coverage>
1190 markCoverage; /* Offset to Mark Coverage table--from
1191 * beginning of MarkLigPos subtable */
1192 OffsetTo<Coverage>
1193 ligatureCoverage; /* Offset to Ligature Coverage
1194 * table--from beginning of MarkLigPos
1195 * subtable */
1196 USHORT classCount; /* Number of defined mark classes */
1197 OffsetTo<MarkArray>
1198 markArray; /* Offset to MarkArray table--from
1199 * beginning of MarkLigPos subtable */
1200 OffsetTo<LigatureArray>
1201 ligatureArray; /* Offset to LigatureArray table--from
1202 * beginning of MarkLigPos subtable */
1203 public:
1204 DEFINE_SIZE_STATIC (12);
1205 };
1206
1207 struct MarkLigPos
1208 {
1209 template <typename context_t>
1210 inline typename context_t::return_t dispatch (context_t *c) const
1211 {
1212 TRACE_DISPATCH (this, u.format);
1213 if (unlikely (!c->may_dispatch (this, &u.format))) TRACE_RETURN (c->default_return_value ());
1214 switch (u.format) {
1215 case 1: return TRACE_RETURN (c->dispatch (u.format1));
1216 default:return TRACE_RETURN (c->default_return_value ());
1217 }
1218 }
1219
1220 protected:
1221 union {
1222 USHORT format; /* Format identifier */
1223 MarkLigPosFormat1 format1;
1224 } u;
1225 };
1226
1227
1228 typedef AnchorMatrix Mark2Array; /* mark2-major--
1229 * in order of Mark2Coverage Index--,
1230 * mark1-minor--
1231 * ordered by class--zero-based. */
1232
1233 struct MarkMarkPosFormat1
1234 {
1235 inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
1236 {
1237 TRACE_COLLECT_GLYPHS (this);
1238 (this+mark1Coverage).add_coverage (c->input);
1239 (this+mark2Coverage).add_coverage (c->input);
1240 }
1241
1242 inline const Coverage &get_coverage (void) const
1243 {
1244 return this+mark1Coverage;
1245 }
1246
1247 inline bool apply (hb_apply_context_t *c) const
1248 {
1249 TRACE_APPLY (this);
1250 hb_buffer_t *buffer = c->buffer;
1251 unsigned int mark1_index = (this+mark1Coverage).get_coverage (buffer->cur().codepoint);
1252 if (likely (mark1_index == NOT_COVERED)) return TRACE_RETURN (false);
1253
1254 /* now we search backwards for a suitable mark glyph until a non-mark glyph */
1255 hb_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
1256 skippy_iter.reset (buffer->idx, 1);
1257 skippy_iter.set_lookup_props (c->lookup_props & ~LookupFlag::IgnoreFlags);
1258 if (!skippy_iter.prev ()) return TRACE_RETURN (false);
1259
1260 if (!_hb_glyph_info_is_mark (&buffer->info[skippy_iter.idx])) { return TRACE_RETURN (false); }
1261
1262 unsigned int j = skippy_iter.idx;
1263
1264 unsigned int id1 = _hb_glyph_info_get_lig_id (&buffer->cur());
1265 unsigned int id2 = _hb_glyph_info_get_lig_id (&buffer->info[j]);
1266 unsigned int comp1 = _hb_glyph_info_get_lig_comp (&buffer->cur());
1267 unsigned int comp2 = _hb_glyph_info_get_lig_comp (&buffer->info[j]);
1268
1269 if (likely (id1 == id2)) {
1270 if (id1 == 0) /* Marks belonging to the same base. */
1271 goto good;
1272 else if (comp1 == comp2) /* Marks belonging to the same ligature component. */
1273 goto good;
1274 } else {
1275 /* If ligature ids don't match, it may be the case that one of the marks
1276 * itself is a ligature. In which case match. */
1277 if ((id1 > 0 && !comp1) || (id2 > 0 && !comp2))
1278 goto good;
1279 }
1280
1281 /* Didn't match. */
1282 return TRACE_RETURN (false);
1283
1284 good:
1285 unsigned int mark2_index = (this+mark2Coverage).get_coverage (buffer->info[j].codepoint);
1286 if (mark2_index == NOT_COVERED) return TRACE_RETURN (false);
1287
1288 return TRACE_RETURN ((this+mark1Array).apply (c, mark1_index, mark2_index, this+mark2Array, classCount, j));
1289 }
1290
1291 inline bool sanitize (hb_sanitize_context_t *c) const
1292 {
1293 TRACE_SANITIZE (this);
1294 return TRACE_RETURN (c->check_struct (this) && mark1Coverage.sanitize (c, this) &&
1295 mark2Coverage.sanitize (c, this) && mark1Array.sanitize (c, this)
1296 && mark2Array.sanitize (c, this, (unsigned int) classCount));
1297 }
1298
1299 protected:
1300 USHORT format; /* Format identifier--format = 1 */
1301 OffsetTo<Coverage>
1302 mark1Coverage; /* Offset to Combining Mark1 Coverage
1303 * table--from beginning of MarkMarkPos
1304 * subtable */
1305 OffsetTo<Coverage>
1306 mark2Coverage; /* Offset to Combining Mark2 Coverage
1307 * table--from beginning of MarkMarkPos
1308 * subtable */
1309 USHORT classCount; /* Number of defined mark classes */
1310 OffsetTo<MarkArray>
1311 mark1Array; /* Offset to Mark1Array table--from
1312 * beginning of MarkMarkPos subtable */
1313 OffsetTo<Mark2Array>
1314 mark2Array; /* Offset to Mark2Array table--from
1315 * beginning of MarkMarkPos subtable */
1316 public:
1317 DEFINE_SIZE_STATIC (12);
1318 };
1319
1320 struct MarkMarkPos
1321 {
1322 template <typename context_t>
1323 inline typename context_t::return_t dispatch (context_t *c) const
1324 {
1325 TRACE_DISPATCH (this, u.format);
1326 if (unlikely (!c->may_dispatch (this, &u.format))) TRACE_RETURN (c->default_return_value ());
1327 switch (u.format) {
1328 case 1: return TRACE_RETURN (c->dispatch (u.format1));
1329 default:return TRACE_RETURN (c->default_return_value ());
1330 }
1331 }
1332
1333 protected:
1334 union {
1335 USHORT format; /* Format identifier */
1336 MarkMarkPosFormat1 format1;
1337 } u;
1338 };
1339
1340
1341 struct ContextPos : Context {};
1342
1343 struct ChainContextPos : ChainContext {};
1344
1345 struct ExtensionPos : Extension<ExtensionPos>
1346 {
1347 typedef struct PosLookupSubTable LookupSubTable;
1348 };
1349
1350
1351
1352 /*
1353 * PosLookup
1354 */
1355
1356
1357 struct PosLookupSubTable
1358 {
1359 friend struct PosLookup;
1360
1361 enum Type {
1362 Single = 1,
1363 Pair = 2,
1364 Cursive = 3,
1365 MarkBase = 4,
1366 MarkLig = 5,
1367 MarkMark = 6,
1368 Context = 7,
1369 ChainContext = 8,
1370 Extension = 9
1371 };
1372
1373 template <typename context_t>
1374 inline typename context_t::return_t dispatch (context_t *c, unsigned int lookup_type) const
1375 {
1376 TRACE_DISPATCH (this, lookup_type);
1377 /* The sub_format passed to may_dispatch is unnecessary but harmless. */
1378 if (unlikely (!c->may_dispatch (this, &u.sub_format))) TRACE_RETURN (c->default_return_value ());
1379 switch (lookup_type) {
1380 case Single: return TRACE_RETURN (u.single.dispatch (c));
1381 case Pair: return TRACE_RETURN (u.pair.dispatch (c));
1382 case Cursive: return TRACE_RETURN (u.cursive.dispatch (c));
1383 case MarkBase: return TRACE_RETURN (u.markBase.dispatch (c));
1384 case MarkLig: return TRACE_RETURN (u.markLig.dispatch (c));
1385 case MarkMark: return TRACE_RETURN (u.markMark.dispatch (c));
1386 case Context: return TRACE_RETURN (u.context.dispatch (c));
1387 case ChainContext: return TRACE_RETURN (u.chainContext.dispatch (c));
1388 case Extension: return TRACE_RETURN (u.extension.dispatch (c));
1389 default: return TRACE_RETURN (c->default_return_value ());
1390 }
1391 }
1392
1393 protected:
1394 union {
1395 USHORT sub_format;
1396 SinglePos single;
1397 PairPos pair;
1398 CursivePos cursive;
1399 MarkBasePos markBase;
1400 MarkLigPos markLig;
1401 MarkMarkPos markMark;
1402 ContextPos context;
1403 ChainContextPos chainContext;
1404 ExtensionPos extension;
1405 } u;
1406 public:
1407 DEFINE_SIZE_UNION (2, sub_format);
1408 };
1409
1410
1411 struct PosLookup : Lookup
1412 {
1413 inline const PosLookupSubTable& get_subtable (unsigned int i) const
1414 { return Lookup::get_subtable<PosLookupSubTable> (i); }
1415
1416 inline bool is_reverse (void) const
1417 {
1418 return false;
1419 }
1420
1421 inline bool apply (hb_apply_context_t *c) const
1422 {
1423 TRACE_APPLY (this);
1424 return TRACE_RETURN (dispatch (c));
1425 }
1426
1427 inline hb_collect_glyphs_context_t::return_t collect_glyphs (hb_collect_glyphs_context_t *c) const
1428 {
1429 TRACE_COLLECT_GLYPHS (this);
1430 return TRACE_RETURN (dispatch (c));
1431 }
1432
1433 template <typename set_t>
1434 inline void add_coverage (set_t *glyphs) const
1435 {
1436 hb_add_coverage_context_t<set_t> c (glyphs);
1437 dispatch (&c);
1438 }
1439
1440 static bool apply_recurse_func (hb_apply_context_t *c, unsigned int lookup_index);
1441
1442 template <typename context_t>
1443 static inline typename context_t::return_t dispatch_recurse_func (context_t *c, unsigned int lookup_index);
1444
1445 template <typename context_t>
1446 inline typename context_t::return_t dispatch (context_t *c) const
1447 { return Lookup::dispatch<PosLookupSubTable> (c); }
1448
1449 inline bool sanitize (hb_sanitize_context_t *c) const
1450 {
1451 TRACE_SANITIZE (this);
1452 if (unlikely (!Lookup::sanitize (c))) return TRACE_RETURN (false);
1453 return TRACE_RETURN (dispatch (c));
1454 }
1455 };
1456
1457 typedef OffsetListOf<PosLookup> PosLookupList;
1458
1459 /*
1460 * GPOS -- The Glyph Positioning Table
1461 */
1462
1463 struct GPOS : GSUBGPOS
1464 {
1465 static const hb_tag_t tableTag = HB_OT_TAG_GPOS;
1466
1467 inline const PosLookup& get_lookup (unsigned int i) const
1468 { return CastR<PosLookup> (GSUBGPOS::get_lookup (i)); }
1469
1470 static inline void position_start (hb_font_t *font, hb_buffer_t *buffer);
1471 static inline void position_finish (hb_font_t *font, hb_buffer_t *buffer);
1472
1473 inline bool sanitize (hb_sanitize_context_t *c) const
1474 {
1475 TRACE_SANITIZE (this);
1476 if (unlikely (!GSUBGPOS::sanitize (c))) return TRACE_RETURN (false);
1477 const OffsetTo<PosLookupList> &list = CastR<OffsetTo<PosLookupList> > (lookupList);
1478 return TRACE_RETURN (list.sanitize (c, this));
1479 }
1480 public:
1481 DEFINE_SIZE_STATIC (10);
1482 };
1483
1484
1485 static void
1486 fix_cursive_minor_offset (hb_glyph_position_t *pos, unsigned int i, hb_direction_t direction)
1487 {
1488 unsigned int j = pos[i].cursive_chain();
1489 if (likely (!j))
1490 return;
1491
1492 j += i;
1493
1494 pos[i].cursive_chain() = 0;
1495
1496 fix_cursive_minor_offset (pos, j, direction);
1497
1498 if (HB_DIRECTION_IS_HORIZONTAL (direction))
1499 pos[i].y_offset += pos[j].y_offset;
1500 else
1501 pos[i].x_offset += pos[j].x_offset;
1502 }
1503
1504 static void
1505 fix_mark_attachment (hb_glyph_position_t *pos, unsigned int i, hb_direction_t direction)
1506 {
1507 if (likely (!(pos[i].attach_lookback())))
1508 return;
1509
1510 unsigned int j = i - pos[i].attach_lookback();
1511
1512 pos[i].x_offset += pos[j].x_offset;
1513 pos[i].y_offset += pos[j].y_offset;
1514
1515 if (HB_DIRECTION_IS_FORWARD (direction))
1516 for (unsigned int k = j; k < i; k++) {
1517 pos[i].x_offset -= pos[k].x_advance;
1518 pos[i].y_offset -= pos[k].y_advance;
1519 }
1520 else
1521 for (unsigned int k = j + 1; k < i + 1; k++) {
1522 pos[i].x_offset += pos[k].x_advance;
1523 pos[i].y_offset += pos[k].y_advance;
1524 }
1525 }
1526
1527 void
1528 GPOS::position_start (hb_font_t *font HB_UNUSED, hb_buffer_t *buffer)
1529 {
1530 buffer->clear_positions ();
1531
1532 unsigned int count = buffer->len;
1533 for (unsigned int i = 0; i < count; i++)
1534 buffer->pos[i].attach_lookback() = buffer->pos[i].cursive_chain() = 0;
1535 }
1536
1537 void
1538 GPOS::position_finish (hb_font_t *font HB_UNUSED, hb_buffer_t *buffer)
1539 {
1540 _hb_buffer_assert_gsubgpos_vars (buffer);
1541
1542 unsigned int len;
1543 hb_glyph_position_t *pos = hb_buffer_get_glyph_positions (buffer, &len);
1544 hb_direction_t direction = buffer->props.direction;
1545
1546 /* Handle cursive connections */
1547 for (unsigned int i = 0; i < len; i++)
1548 fix_cursive_minor_offset (pos, i, direction);
1549
1550 /* Handle attachments */
1551 for (unsigned int i = 0; i < len; i++)
1552 fix_mark_attachment (pos, i, direction);
1553 }
1554
1555
1556 /* Out-of-class implementation for methods recursing */
1557
1558 template <typename context_t>
1559 /*static*/ inline typename context_t::return_t PosLookup::dispatch_recurse_func (context_t *c, unsigned int lookup_index)
1560 {
1561 const GPOS &gpos = *(hb_ot_layout_from_face (c->face)->gpos);
1562 const PosLookup &l = gpos.get_lookup (lookup_index);
1563 return l.dispatch (c);
1564 }
1565
1566 /*static*/ inline bool PosLookup::apply_recurse_func (hb_apply_context_t *c, unsigned int lookup_index)
1567 {
1568 const GPOS &gpos = *(hb_ot_layout_from_face (c->face)->gpos);
1569 const PosLookup &l = gpos.get_lookup (lookup_index);
1570 unsigned int saved_lookup_props = c->lookup_props;
1571 unsigned int saved_lookup_index = c->lookup_index;
1572 c->set_lookup_index (lookup_index);
1573 c->set_lookup_props (l.get_props ());
1574 bool ret = l.dispatch (c);
1575 c->set_lookup_index (saved_lookup_index);
1576 c->set_lookup_props (saved_lookup_props);
1577 return ret;
1578 }
1579
1580
1581 #undef attach_lookback
1582 #undef cursive_chain
1583
1584
1585 } /* namespace OT */
1586
1587
1588 #endif /* HB_OT_LAYOUT_GPOS_TABLE_HH */