src/hb-ot-layout-gpos-table.hh

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