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.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 HBUINT16 Value;
  55
  56 typedef UnsizedArrayOf<Value> ValueRecord;
  57
  58 struct ValueFormat : HBUINT16
  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   HBINT16               xPlacement;             /* Horizontal adjustment for
  78                                          * placement--in design units */
  79   HBINT16               yPlacement;             /* Vertical adjustment for
  80                                          * placement--in design units */
  81   HBINT16               xAdvance;               /* Horizontal adjustment for
  82                                          * advance--in design units (only used
  83                                          * for horizontal writing) */
  84   HBINT16               yAdvance;               /* Vertical adjustment for advance--in
  85                                          * design units (only used for vertical
  86                                          * writing) */
  87   OffsetTo<Device>      xPlaDevice;     /* Offset to Device table for
  88                                          * horizontal placement--measured from
  89                                          * beginning of PosTable (may be NULL) */
  90   OffsetTo<Device>      yPlaDevice;     /* Offset to Device table for vertical
  91                                          * placement--measured from beginning
  92                                          * of PosTable (may be NULL) */
  93   OffsetTo<Device>      xAdvDevice;     /* Offset to Device table for
  94                                          * horizontal advance--measured from
  95                                          * beginning of PosTable (may be NULL) */
  96   OffsetTo<Device>      yAdvDevice;     /* Offset to Device table for vertical
  97                                          * advance--measured from beginning of
  98                                          * PosTable (may be NULL) */
  99 #endif
 100
 101   unsigned int get_len () const  { return hb_popcount ((unsigned int) *this); }
 102   unsigned int get_size () const { return get_len () * Value::static_size; }
 103
 104   bool apply_value (hb_ot_apply_context_t *c,
 105                     const void            *base,
 106                     const Value           *values,
 107                     hb_glyph_position_t   &glyph_pos) const
 108   {
 109     bool ret = false;
 110     unsigned int format = *this;
 111     if (!format) return ret;
 112
 113     hb_font_t *font = c->font;
 114     bool horizontal = HB_DIRECTION_IS_HORIZONTAL (c->direction);
 115
 116     if (format & xPlacement) glyph_pos.x_offset  += font->em_scale_x (get_short (values++, &ret));
 117     if (format & yPlacement) glyph_pos.y_offset  += font->em_scale_y (get_short (values++, &ret));
 118     if (format & xAdvance) {
 119       if (likely (horizontal)) glyph_pos.x_advance += font->em_scale_x (get_short (values, &ret));
 120       values++;
 121     }
 122     /* y_advance values grow downward but font-space grows upward, hence negation */
 123     if (format & yAdvance) {
 124       if (unlikely (!horizontal)) glyph_pos.y_advance -= font->em_scale_y (get_short (values, &ret));
 125       values++;
 126     }
 127
 128     if (!has_device ()) return ret;
 129
 130     bool use_x_device = font->x_ppem || font->num_coords;
 131     bool use_y_device = font->y_ppem || font->num_coords;
 132
 133     if (!use_x_device && !use_y_device) return ret;
 134
 135     const VariationStore &store = c->var_store;
 136
 137     /* pixel -> fractional pixel */
 138     if (format & xPlaDevice) {
 139       if (use_x_device) glyph_pos.x_offset  += (base + get_device (values, &ret)).get_x_delta (font, store);
 140       values++;
 141     }
 142     if (format & yPlaDevice) {
 143       if (use_y_device) glyph_pos.y_offset  += (base + get_device (values, &ret)).get_y_delta (font, store);
 144       values++;
 145     }
 146     if (format & xAdvDevice) {
 147       if (horizontal && use_x_device) glyph_pos.x_advance += (base + get_device (values, &ret)).get_x_delta (font, store);
 148       values++;
 149     }
 150     if (format & yAdvDevice) {
 151       /* y_advance values grow downward but font-space grows upward, hence negation */
 152       if (!horizontal && use_y_device) glyph_pos.y_advance -= (base + get_device (values, &ret)).get_y_delta (font, store);
 153       values++;
 154     }
 155     return ret;
 156   }
 157
 158   private:
 159   bool sanitize_value_devices (hb_sanitize_context_t *c, const void *base, const Value *values) const
 160   {
 161     unsigned int format = *this;
 162
 163     if (format & xPlacement) values++;
 164     if (format & yPlacement) values++;
 165     if (format & xAdvance)   values++;
 166     if (format & yAdvance)   values++;
 167
 168     if ((format & xPlaDevice) && !get_device (values++).sanitize (c, base)) return false;
 169     if ((format & yPlaDevice) && !get_device (values++).sanitize (c, base)) return false;
 170     if ((format & xAdvDevice) && !get_device (values++).sanitize (c, base)) return false;
 171     if ((format & yAdvDevice) && !get_device (values++).sanitize (c, base)) return false;
 172
 173     return true;
 174   }
 175
 176   HB_INTERNAL static OffsetTo<Device>& get_device (Value* value)
 177   { return *CastP<OffsetTo<Device>> (value); }
 178   HB_INTERNAL static const OffsetTo<Device>& get_device (const Value* value, bool *worked=nullptr)
 179   {
 180     if (worked) *worked |= bool (*value);
 181     return *CastP<OffsetTo<Device>> (value);
 182   }
 183
 184   HB_INTERNAL static const HBINT16& get_short (const Value* value, bool *worked=nullptr)
 185   {
 186     if (worked) *worked |= bool (*value);
 187     return *CastP<HBINT16> (value);
 188   }
 189
 190   public:
 191
 192   bool has_device () const
 193   {
 194     unsigned int format = *this;
 195     return (format & devices) != 0;
 196   }
 197
 198   bool sanitize_value (hb_sanitize_context_t *c, const void *base, const Value *values) const
 199   {
 200     TRACE_SANITIZE (this);
 201     return_trace (c->check_range (values, get_size ()) && (!has_device () || sanitize_value_devices (c, base, values)));
 202   }
 203
 204   bool sanitize_values (hb_sanitize_context_t *c, const void *base, const Value *values, unsigned int count) const
 205   {
 206     TRACE_SANITIZE (this);
 207     unsigned int len = get_len ();
 208
 209     if (!c->check_range (values, count, get_size ())) return_trace (false);
 210
 211     if (!has_device ()) return_trace (true);
 212
 213     for (unsigned int i = 0; i < count; i++) {
 214       if (!sanitize_value_devices (c, base, values))
 215         return_trace (false);
 216       values += len;
 217     }
 218
 219     return_trace (true);
 220   }
 221
 222   /* Just sanitize referenced Device tables.  Doesn't check the values themselves. */
 223   bool sanitize_values_stride_unsafe (hb_sanitize_context_t *c, const void *base, const Value *values, unsigned int count, unsigned int stride) const
 224   {
 225     TRACE_SANITIZE (this);
 226
 227     if (!has_device ()) return_trace (true);
 228
 229     for (unsigned int i = 0; i < count; i++) {
 230       if (!sanitize_value_devices (c, base, values))
 231         return_trace (false);
 232       values += stride;
 233     }
 234
 235     return_trace (true);
 236   }
 237 };
 238
 239 template<typename Iterator>
 240 static inline void SinglePos_serialize (hb_serialize_context_t *c,
 241                                         Iterator it,
 242                                         ValueFormat valFormat);
 243
 244
 245 struct AnchorFormat1
 246 {
 247   void get_anchor (hb_ot_apply_context_t *c, hb_codepoint_t glyph_id HB_UNUSED,
 248                    float *x, float *y) const
 249   {
 250     hb_font_t *font = c->font;
 251     *x = font->em_fscale_x (xCoordinate);
 252     *y = font->em_fscale_y (yCoordinate);
 253   }
 254
 255   bool sanitize (hb_sanitize_context_t *c) const
 256   {
 257     TRACE_SANITIZE (this);
 258     return_trace (c->check_struct (this));
 259   }
 260
 261   AnchorFormat1* copy (hb_serialize_context_t *c) const
 262   {
 263     TRACE_SERIALIZE (this);
 264     return_trace (c->embed<AnchorFormat1> (this));
 265   }
 266
 267   protected:
 268   HBUINT16      format;                 /* Format identifier--format = 1 */
 269   FWORD         xCoordinate;            /* Horizontal value--in design units */
 270   FWORD         yCoordinate;            /* Vertical value--in design units */
 271   public:
 272   DEFINE_SIZE_STATIC (6);
 273 };
 274
 275 struct AnchorFormat2
 276 {
 277   void get_anchor (hb_ot_apply_context_t *c, hb_codepoint_t glyph_id,
 278                    float *x, float *y) const
 279   {
 280     hb_font_t *font = c->font;
 281
 282 #ifdef HB_NO_HINTING
 283     *x = font->em_fscale_x (xCoordinate);
 284     *y = font->em_fscale_y (yCoordinate);
 285     return;
 286 #endif
 287
 288     unsigned int x_ppem = font->x_ppem;
 289     unsigned int y_ppem = font->y_ppem;
 290     hb_position_t cx = 0, cy = 0;
 291     bool ret;
 292
 293     ret = (x_ppem || y_ppem) &&
 294           font->get_glyph_contour_point_for_origin (glyph_id, anchorPoint, HB_DIRECTION_LTR, &cx, &cy);
 295     *x = ret && x_ppem ? cx : font->em_fscale_x (xCoordinate);
 296     *y = ret && y_ppem ? cy : font->em_fscale_y (yCoordinate);
 297   }
 298
 299   bool sanitize (hb_sanitize_context_t *c) const
 300   {
 301     TRACE_SANITIZE (this);
 302     return_trace (c->check_struct (this));
 303   }
 304
 305   AnchorFormat2* copy (hb_serialize_context_t *c) const
 306   {
 307     TRACE_SERIALIZE (this);
 308     return_trace (c->embed<AnchorFormat2> (this));
 309   }
 310
 311   protected:
 312   HBUINT16      format;                 /* Format identifier--format = 2 */
 313   FWORD         xCoordinate;            /* Horizontal value--in design units */
 314   FWORD         yCoordinate;            /* Vertical value--in design units */
 315   HBUINT16      anchorPoint;            /* Index to glyph contour point */
 316   public:
 317   DEFINE_SIZE_STATIC (8);
 318 };
 319
 320 struct AnchorFormat3
 321 {
 322   void get_anchor (hb_ot_apply_context_t *c, hb_codepoint_t glyph_id HB_UNUSED,
 323                    float *x, float *y) const
 324   {
 325     hb_font_t *font = c->font;
 326     *x = font->em_fscale_x (xCoordinate);
 327     *y = font->em_fscale_y (yCoordinate);
 328
 329     if (font->x_ppem || font->num_coords)
 330       *x += (this+xDeviceTable).get_x_delta (font, c->var_store);
 331     if (font->y_ppem || font->num_coords)
 332       *y += (this+yDeviceTable).get_y_delta (font, c->var_store);
 333   }
 334
 335   bool sanitize (hb_sanitize_context_t *c) const
 336   {
 337     TRACE_SANITIZE (this);
 338     return_trace (c->check_struct (this) && xDeviceTable.sanitize (c, this) && yDeviceTable.sanitize (c, this));
 339   }
 340
 341   AnchorFormat3* copy (hb_serialize_context_t *c) const
 342   {
 343     TRACE_SERIALIZE (this);
 344     auto *out = c->embed<AnchorFormat3> (this);
 345     if (unlikely (!out)) return_trace (nullptr);
 346
 347     out->xDeviceTable.serialize_copy (c, xDeviceTable, this, out);
 348     out->yDeviceTable.serialize_copy (c, yDeviceTable, this, out);
 349     return_trace (out);
 350   }
 351
 352   protected:
 353   HBUINT16      format;                 /* Format identifier--format = 3 */
 354   FWORD         xCoordinate;            /* Horizontal value--in design units */
 355   FWORD         yCoordinate;            /* Vertical value--in design units */
 356   OffsetTo<Device>
 357                 xDeviceTable;           /* Offset to Device table for X
 358                                          * coordinate-- from beginning of
 359                                          * Anchor table (may be NULL) */
 360   OffsetTo<Device>
 361                 yDeviceTable;           /* Offset to Device table for Y
 362                                          * coordinate-- from beginning of
 363                                          * Anchor table (may be NULL) */
 364   public:
 365   DEFINE_SIZE_STATIC (10);
 366 };
 367
 368 struct Anchor
 369 {
 370   void get_anchor (hb_ot_apply_context_t *c, hb_codepoint_t glyph_id,
 371                    float *x, float *y) const
 372   {
 373     *x = *y = 0;
 374     switch (u.format) {
 375     case 1: u.format1.get_anchor (c, glyph_id, x, y); return;
 376     case 2: u.format2.get_anchor (c, glyph_id, x, y); return;
 377     case 3: u.format3.get_anchor (c, glyph_id, x, y); return;
 378     default:                                          return;
 379     }
 380   }
 381
 382   bool sanitize (hb_sanitize_context_t *c) const
 383   {
 384     TRACE_SANITIZE (this);
 385     if (!u.format.sanitize (c)) return_trace (false);
 386     switch (u.format) {
 387     case 1: return_trace (u.format1.sanitize (c));
 388     case 2: return_trace (u.format2.sanitize (c));
 389     case 3: return_trace (u.format3.sanitize (c));
 390     default:return_trace (true);
 391     }
 392   }
 393
 394   Anchor* copy (hb_serialize_context_t *c) const
 395   {
 396     TRACE_SERIALIZE (this);
 397     switch (u.format) {
 398     case 1: return_trace (reinterpret_cast<Anchor *> (u.format1.copy (c)));
 399     case 2: return_trace (reinterpret_cast<Anchor *> (u.format2.copy (c)));
 400     case 3: return_trace (reinterpret_cast<Anchor *> (u.format3.copy (c)));
 401     default:return_trace (nullptr);
 402     }
 403   }
 404
 405   protected:
 406   union {
 407   HBUINT16              format;         /* Format identifier */
 408   AnchorFormat1         format1;
 409   AnchorFormat2         format2;
 410   AnchorFormat3         format3;
 411   } u;
 412   public:
 413   DEFINE_SIZE_UNION (2, format);
 414 };
 415
 416
 417 struct AnchorMatrix
 418 {
 419   const Anchor& get_anchor (unsigned int row, unsigned int col,
 420                             unsigned int cols, bool *found) const
 421   {
 422     *found = false;
 423     if (unlikely (row >= rows || col >= cols)) return Null(Anchor);
 424     *found = !matrixZ[row * cols + col].is_null ();
 425     return this+matrixZ[row * cols + col];
 426   }
 427
 428   bool sanitize (hb_sanitize_context_t *c, unsigned int cols) const
 429   {
 430     TRACE_SANITIZE (this);
 431     if (!c->check_struct (this)) return_trace (false);
 432     if (unlikely (hb_unsigned_mul_overflows (rows, cols))) return_trace (false);
 433     unsigned int count = rows * cols;
 434     if (!c->check_array (matrixZ.arrayZ, count)) return_trace (false);
 435     for (unsigned int i = 0; i < count; i++)
 436       if (!matrixZ[i].sanitize (c, this)) return_trace (false);
 437     return_trace (true);
 438   }
 439
 440   HBUINT16      rows;                   /* Number of rows */
 441   protected:
 442   UnsizedArrayOf<OffsetTo<Anchor>>
 443                 matrixZ;                /* Matrix of offsets to Anchor tables--
 444                                          * from beginning of AnchorMatrix table */
 445   public:
 446   DEFINE_SIZE_ARRAY (2, matrixZ);
 447 };
 448
 449
 450 struct MarkRecord
 451 {
 452   friend struct MarkArray;
 453
 454   bool sanitize (hb_sanitize_context_t *c, const void *base) const
 455   {
 456     TRACE_SANITIZE (this);
 457     return_trace (c->check_struct (this) && markAnchor.sanitize (c, base));
 458   }
 459
 460   protected:
 461   HBUINT16      klass;                  /* Class defined for this mark */
 462   OffsetTo<Anchor>
 463                 markAnchor;             /* Offset to Anchor table--from
 464                                          * beginning of MarkArray table */
 465   public:
 466   DEFINE_SIZE_STATIC (4);
 467 };
 468
 469 struct MarkArray : ArrayOf<MarkRecord>  /* Array of MarkRecords--in Coverage order */
 470 {
 471   bool apply (hb_ot_apply_context_t *c,
 472               unsigned int mark_index, unsigned int glyph_index,
 473               const AnchorMatrix &anchors, unsigned int class_count,
 474               unsigned int glyph_pos) const
 475   {
 476     TRACE_APPLY (this);
 477     hb_buffer_t *buffer = c->buffer;
 478     const MarkRecord &record = ArrayOf<MarkRecord>::operator[](mark_index);
 479     unsigned int mark_class = record.klass;
 480
 481     const Anchor& mark_anchor = this + record.markAnchor;
 482     bool found;
 483     const Anchor& glyph_anchor = anchors.get_anchor (glyph_index, mark_class, class_count, &found);
 484     /* If this subtable doesn't have an anchor for this base and this class,
 485      * return false such that the subsequent subtables have a chance at it. */
 486     if (unlikely (!found)) return_trace (false);
 487
 488     float mark_x, mark_y, base_x, base_y;
 489
 490     buffer->unsafe_to_break (glyph_pos, buffer->idx);
 491     mark_anchor.get_anchor (c, buffer->cur().codepoint, &mark_x, &mark_y);
 492     glyph_anchor.get_anchor (c, buffer->info[glyph_pos].codepoint, &base_x, &base_y);
 493
 494     hb_glyph_position_t &o = buffer->cur_pos();
 495     o.x_offset = roundf (base_x - mark_x);
 496     o.y_offset = roundf (base_y - mark_y);
 497     o.attach_type() = ATTACH_TYPE_MARK;
 498     o.attach_chain() = (int) glyph_pos - (int) buffer->idx;
 499     buffer->scratch_flags |= HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT;
 500
 501     buffer->idx++;
 502     return_trace (true);
 503   }
 504
 505   bool sanitize (hb_sanitize_context_t *c) const
 506   {
 507     TRACE_SANITIZE (this);
 508     return_trace (ArrayOf<MarkRecord>::sanitize (c, this));
 509   }
 510 };
 511
 512
 513 /* Lookups */
 514
 515 struct SinglePosFormat1
 516 {
 517   bool intersects (const hb_set_t *glyphs) const
 518   { return (this+coverage).intersects (glyphs); }
 519
 520   void collect_glyphs (hb_collect_glyphs_context_t *c) const
 521   { if (unlikely (!(this+coverage).add_coverage (c->input))) return; }
 522
 523   const Coverage &get_coverage () const { return this+coverage; }
 524
 525   bool apply (hb_ot_apply_context_t *c) const
 526   {
 527     TRACE_APPLY (this);
 528     hb_buffer_t *buffer = c->buffer;
 529     unsigned int index = (this+coverage).get_coverage  (buffer->cur().codepoint);
 530     if (likely (index == NOT_COVERED)) return_trace (false);
 531
 532     valueFormat.apply_value (c, this, values, buffer->cur_pos());
 533
 534     buffer->idx++;
 535     return_trace (true);
 536   }
 537
 538   template<typename Iterator,
 539            hb_requires (hb_is_iterator (Iterator))>
 540   void serialize (hb_serialize_context_t *c,
 541                   Iterator it,
 542                   ValueFormat valFormat)
 543   {
 544     if (unlikely (!c->extend_min (*this))) return;
 545     if (unlikely (!c->check_assign (valueFormat, valFormat))) return;
 546
 547     for (const auto &_ : hb_second (*it))
 548       c->copy (_);
 549
 550     auto glyphs =
 551     + it
 552     | hb_map_retains_sorting (hb_first)
 553     ;
 554
 555     coverage.serialize (c, this).serialize (c, glyphs);
 556   }
 557
 558   bool subset (hb_subset_context_t *c) const
 559   {
 560     TRACE_SUBSET (this);
 561     const hb_set_t &glyphset = *c->plan->glyphset ();
 562     const hb_map_t &glyph_map = *c->plan->glyph_map;
 563
 564     auto it =
 565     + hb_iter (this+coverage)
 566     | hb_filter (glyphset)
 567     | hb_map_retains_sorting (glyph_map)
 568     | hb_zip (hb_repeat (values.as_array (valueFormat.get_len ())))
 569     ;
 570
 571     bool ret = bool (it);
 572     SinglePos_serialize (c->serializer, it, valueFormat);
 573     return_trace (ret);
 574   }
 575
 576   bool sanitize (hb_sanitize_context_t *c) const
 577   {
 578     TRACE_SANITIZE (this);
 579     return_trace (c->check_struct (this) &&
 580                   coverage.sanitize (c, this) &&
 581                   valueFormat.sanitize_value (c, this, values));
 582   }
 583
 584   protected:
 585   HBUINT16      format;                 /* Format identifier--format = 1 */
 586   OffsetTo<Coverage>
 587                 coverage;               /* Offset to Coverage table--from
 588                                          * beginning of subtable */
 589   ValueFormat   valueFormat;            /* Defines the types of data in the
 590                                          * ValueRecord */
 591   ValueRecord   values;                 /* Defines positioning
 592                                          * value(s)--applied to all glyphs in
 593                                          * the Coverage table */
 594   public:
 595   DEFINE_SIZE_ARRAY (6, values);
 596 };
 597
 598 struct SinglePosFormat2
 599 {
 600   bool intersects (const hb_set_t *glyphs) const
 601   { return (this+coverage).intersects (glyphs); }
 602
 603   void collect_glyphs (hb_collect_glyphs_context_t *c) const
 604   { if (unlikely (!(this+coverage).add_coverage (c->input))) return; }
 605
 606   const Coverage &get_coverage () const { return this+coverage; }
 607
 608   bool apply (hb_ot_apply_context_t *c) const
 609   {
 610     TRACE_APPLY (this);
 611     hb_buffer_t *buffer = c->buffer;
 612     unsigned int index = (this+coverage).get_coverage  (buffer->cur().codepoint);
 613     if (likely (index == NOT_COVERED)) return_trace (false);
 614
 615     if (likely (index >= valueCount)) return_trace (false);
 616
 617     valueFormat.apply_value (c, this,
 618                              &values[index * valueFormat.get_len ()],
 619                              buffer->cur_pos());
 620
 621     buffer->idx++;
 622     return_trace (true);
 623   }
 624
 625   template<typename Iterator,
 626            hb_requires (hb_is_iterator (Iterator))>
 627   void serialize (hb_serialize_context_t *c,
 628                   Iterator it,
 629                   ValueFormat valFormat)
 630   {
 631     if (unlikely (!c->extend_min (*this))) return;
 632     if (unlikely (!c->check_assign (valueFormat, valFormat))) return;
 633     if (unlikely (!c->check_assign (valueCount, it.len ()))) return;
 634
 635     for (const auto iter : it)
 636       for (const auto &_ : iter.second)
 637         c->copy (_);
 638
 639     auto glyphs =
 640     + it
 641     | hb_map_retains_sorting (hb_first)
 642     ;
 643
 644     coverage.serialize (c, this).serialize (c, glyphs);
 645   }
 646
 647   bool subset (hb_subset_context_t *c) const
 648   {
 649     TRACE_SUBSET (this);
 650     const hb_set_t &glyphset = *c->plan->glyphset ();
 651     const hb_map_t &glyph_map = *c->plan->glyph_map;
 652
 653     unsigned sub_length = valueFormat.get_len ();
 654     auto values_array = values.as_array (valueCount * sub_length);
 655
 656     auto it =
 657     + hb_zip (this+coverage, hb_range ((unsigned) valueCount))
 658     | hb_filter (glyphset, hb_first)
 659     | hb_map_retains_sorting ([&] (const hb_pair_t<hb_codepoint_t, unsigned>& _)
 660                               {
 661                                 return hb_pair (glyph_map[_.first],
 662                                                 values_array.sub_array (_.second * sub_length,
 663                                                                         sub_length));
 664                               })
 665     ;
 666
 667     bool ret = bool (it);
 668     SinglePos_serialize (c->serializer, it, valueFormat);
 669     return_trace (ret);
 670   }
 671
 672   bool sanitize (hb_sanitize_context_t *c) const
 673   {
 674     TRACE_SANITIZE (this);
 675     return_trace (c->check_struct (this) &&
 676                   coverage.sanitize (c, this) &&
 677                   valueFormat.sanitize_values (c, this, values, valueCount));
 678   }
 679
 680   protected:
 681   HBUINT16      format;                 /* Format identifier--format = 2 */
 682   OffsetTo<Coverage>
 683                 coverage;               /* Offset to Coverage table--from
 684                                          * beginning of subtable */
 685   ValueFormat   valueFormat;            /* Defines the types of data in the
 686                                          * ValueRecord */
 687   HBUINT16      valueCount;             /* Number of ValueRecords */
 688   ValueRecord   values;                 /* Array of ValueRecords--positioning
 689                                          * values applied to glyphs */
 690   public:
 691   DEFINE_SIZE_ARRAY (8, values);
 692 };
 693
 694 struct SinglePos
 695 {
 696   template<typename Iterator,
 697            hb_requires (hb_is_iterator (Iterator))>
 698   unsigned get_format (Iterator glyph_val_iter_pairs)
 699   {
 700     hb_array_t<const Value> first_val_iter = hb_second (*glyph_val_iter_pairs);
 701
 702     for (const auto iter : glyph_val_iter_pairs)
 703       for (const auto _ : hb_zip (iter.second, first_val_iter))
 704         if (_.first != _.second)
 705           return 2;
 706
 707     return 1;
 708   }
 709
 710
 711   template<typename Iterator,
 712            hb_requires (hb_is_iterator (Iterator))>
 713   void serialize (hb_serialize_context_t *c,
 714                   Iterator glyph_val_iter_pairs,
 715                   ValueFormat valFormat)
 716   {
 717     if (unlikely (!c->extend_min (u.format))) return;
 718     unsigned format = 2;
 719
 720     if (glyph_val_iter_pairs) format = get_format (glyph_val_iter_pairs);
 721
 722     u.format = format;
 723     switch (u.format) {
 724     case 1: u.format1.serialize (c, glyph_val_iter_pairs, valFormat);
 725             return;
 726     case 2: u.format2.serialize (c, glyph_val_iter_pairs, valFormat);
 727             return;
 728     default:return;
 729     }
 730   }
 731
 732   template <typename context_t, typename ...Ts>
 733   typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const
 734   {
 735     TRACE_DISPATCH (this, u.format);
 736     if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ());
 737     switch (u.format) {
 738     case 1: return_trace (c->dispatch (u.format1, hb_forward<Ts> (ds)...));
 739     case 2: return_trace (c->dispatch (u.format2, hb_forward<Ts> (ds)...));
 740     default:return_trace (c->default_return_value ());
 741     }
 742   }
 743
 744   protected:
 745   union {
 746   HBUINT16              format;         /* Format identifier */
 747   SinglePosFormat1      format1;
 748   SinglePosFormat2      format2;
 749   } u;
 750 };
 751
 752 template<typename Iterator>
 753 static inline void
 754 SinglePos_serialize (hb_serialize_context_t *c,
 755                      Iterator it,
 756                      ValueFormat valFormat)
 757 { c->start_embed<SinglePos> ()->serialize (c, it, valFormat); }
 758
 759
 760 struct PairValueRecord
 761 {
 762   friend struct PairSet;
 763
 764   bool serialize (hb_serialize_context_t *c,
 765                   unsigned length,
 766                   const hb_map_t &glyph_map) const
 767   {
 768     TRACE_SERIALIZE (this);
 769     auto *out = c->start_embed (*this);
 770     if (unlikely (!c->extend_min (out))) return_trace (false);
 771
 772     out->secondGlyph = glyph_map[secondGlyph];
 773     return_trace (c->copy (values, length));
 774   }
 775
 776   protected:
 777   HBGlyphID     secondGlyph;            /* GlyphID of second glyph in the
 778                                          * pair--first glyph is listed in the
 779                                          * Coverage table */
 780   ValueRecord   values;                 /* Positioning data for the first glyph
 781                                          * followed by for second glyph */
 782   public:
 783   DEFINE_SIZE_ARRAY (2, values);
 784 };
 785
 786 struct PairSet
 787 {
 788   friend struct PairPosFormat1;
 789
 790   bool intersects (const hb_set_t *glyphs,
 791                    const ValueFormat *valueFormats) const
 792   {
 793     unsigned int len1 = valueFormats[0].get_len ();
 794     unsigned int len2 = valueFormats[1].get_len ();
 795     unsigned int record_size = HBUINT16::static_size * (1 + len1 + len2);
 796
 797     const PairValueRecord *record = &firstPairValueRecord;
 798     unsigned int count = len;
 799     for (unsigned int i = 0; i < count; i++)
 800     {
 801       if (glyphs->has (record->secondGlyph))
 802         return true;
 803       record = &StructAtOffset<const PairValueRecord> (record, record_size);
 804     }
 805     return false;
 806   }
 807
 808   void collect_glyphs (hb_collect_glyphs_context_t *c,
 809                               const ValueFormat *valueFormats) const
 810   {
 811     unsigned int len1 = valueFormats[0].get_len ();
 812     unsigned int len2 = valueFormats[1].get_len ();
 813     unsigned int record_size = HBUINT16::static_size * (1 + len1 + len2);
 814
 815     const PairValueRecord *record = &firstPairValueRecord;
 816     c->input->add_array (&record->secondGlyph, len, record_size);
 817   }
 818
 819   bool apply (hb_ot_apply_context_t *c,
 820                      const ValueFormat *valueFormats,
 821                      unsigned int pos) const
 822   {
 823     TRACE_APPLY (this);
 824     hb_buffer_t *buffer = c->buffer;
 825     unsigned int len1 = valueFormats[0].get_len ();
 826     unsigned int len2 = valueFormats[1].get_len ();
 827     unsigned int record_size = HBUINT16::static_size * (1 + len1 + len2);
 828
 829     unsigned int count = len;
 830
 831     /* Hand-coded bsearch. */
 832     if (unlikely (!count))
 833       return_trace (false);
 834     hb_codepoint_t x = buffer->info[pos].codepoint;
 835     int min = 0, max = (int) count - 1;
 836     while (min <= max)
 837     {
 838       int mid = ((unsigned int) min + (unsigned int) max) / 2;
 839       const PairValueRecord *record = &StructAtOffset<PairValueRecord> (&firstPairValueRecord, record_size * mid);
 840       hb_codepoint_t mid_x = record->secondGlyph;
 841       if (x < mid_x)
 842         max = mid - 1;
 843       else if (x > mid_x)
 844         min = mid + 1;
 845       else
 846       {
 847         /* Note the intentional use of "|" instead of short-circuit "||". */
 848         if (valueFormats[0].apply_value (c, this, &record->values[0], buffer->cur_pos()) |
 849             valueFormats[1].apply_value (c, this, &record->values[len1], buffer->pos[pos]))
 850           buffer->unsafe_to_break (buffer->idx, pos + 1);
 851         if (len2)
 852           pos++;
 853         buffer->idx = pos;
 854         return_trace (true);
 855       }
 856     }
 857
 858     return_trace (false);
 859   }
 860
 861   bool subset (hb_subset_context_t *c,
 862                const ValueFormat valueFormats[2]) const
 863   {
 864     TRACE_SUBSET (this);
 865     auto snap = c->serializer->snapshot ();
 866
 867     auto *out = c->serializer->start_embed (*this);
 868     if (unlikely (!c->serializer->extend_min (out))) return_trace (false);
 869     out->len = 0;
 870
 871     const hb_set_t &glyphset = *c->plan->glyphset ();
 872     const hb_map_t &glyph_map = *c->plan->glyph_map;
 873
 874     unsigned len1 = valueFormats[0].get_len ();
 875     unsigned len2 = valueFormats[1].get_len ();
 876     unsigned record_size = HBUINT16::static_size + Value::static_size * (len1 + len2);
 877
 878     const PairValueRecord *record = &firstPairValueRecord;
 879     unsigned count = len, num = 0;
 880     for (unsigned i = 0; i < count; i++)
 881     {
 882       if (!glyphset.has (record->secondGlyph)) continue;
 883       if (record->serialize (c->serializer, len1 + len2, glyph_map)) num++;
 884       record = &StructAtOffset<const PairValueRecord> (record, record_size);
 885     }
 886
 887     out->len = num;
 888     if (!num) c->serializer->revert (snap);
 889     return_trace (num);
 890   }
 891
 892   struct sanitize_closure_t
 893   {
 894     const void *base;
 895     const ValueFormat *valueFormats;
 896     unsigned int len1; /* valueFormats[0].get_len() */
 897     unsigned int stride; /* 1 + len1 + len2 */
 898   };
 899
 900   bool sanitize (hb_sanitize_context_t *c, const sanitize_closure_t *closure) const
 901   {
 902     TRACE_SANITIZE (this);
 903     if (!(c->check_struct (this)
 904        && c->check_range (&firstPairValueRecord,
 905                           len,
 906                           HBUINT16::static_size,
 907                           closure->stride))) return_trace (false);
 908
 909     unsigned int count = len;
 910     const PairValueRecord *record = &firstPairValueRecord;
 911     return_trace (closure->valueFormats[0].sanitize_values_stride_unsafe (c, closure->base, &record->values[0], count, closure->stride) &&
 912                   closure->valueFormats[1].sanitize_values_stride_unsafe (c, closure->base, &record->values[closure->len1], count, closure->stride));
 913   }
 914
 915   protected:
 916   HBUINT16              len;    /* Number of PairValueRecords */
 917   PairValueRecord       firstPairValueRecord;
 918                                 /* Array of PairValueRecords--ordered
 919                                  * by GlyphID of the second glyph */
 920   public:
 921   DEFINE_SIZE_MIN (2);
 922 };
 923
 924 struct PairPosFormat1
 925 {
 926   bool intersects (const hb_set_t *glyphs) const
 927   {
 928     return
 929     + hb_zip (this+coverage, pairSet)
 930     | hb_filter (*glyphs, hb_first)
 931     | hb_map (hb_second)
 932     | hb_map ([glyphs, this] (const OffsetTo<PairSet> &_)
 933               { return (this+_).intersects (glyphs, valueFormat); })
 934     | hb_any
 935     ;
 936   }
 937
 938   void collect_glyphs (hb_collect_glyphs_context_t *c) const
 939   {
 940     if (unlikely (!(this+coverage).add_coverage (c->input))) return;
 941     unsigned int count = pairSet.len;
 942     for (unsigned int i = 0; i < count; i++)
 943       (this+pairSet[i]).collect_glyphs (c, valueFormat);
 944   }
 945
 946   const Coverage &get_coverage () const { return this+coverage; }
 947
 948   bool apply (hb_ot_apply_context_t *c) const
 949   {
 950     TRACE_APPLY (this);
 951     hb_buffer_t *buffer = c->buffer;
 952     unsigned int index = (this+coverage).get_coverage  (buffer->cur().codepoint);
 953     if (likely (index == NOT_COVERED)) return_trace (false);
 954
 955     hb_ot_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
 956     skippy_iter.reset (buffer->idx, 1);
 957     if (!skippy_iter.next ()) return_trace (false);
 958
 959     return_trace ((this+pairSet[index]).apply (c, valueFormat, skippy_iter.idx));
 960   }
 961
 962   bool subset (hb_subset_context_t *c) const
 963   {
 964     TRACE_SUBSET (this);
 965
 966     const hb_set_t &glyphset = *c->plan->glyphset ();
 967     const hb_map_t &glyph_map = *c->plan->glyph_map;
 968
 969     auto *out = c->serializer->start_embed (*this);
 970     if (unlikely (!c->serializer->extend_min (out))) return_trace (false);
 971     out->format = format;
 972     out->valueFormat[0] = valueFormat[0];
 973     out->valueFormat[1] = valueFormat[1];
 974
 975     hb_sorted_vector_t<hb_codepoint_t> new_coverage;
 976
 977     + hb_zip (this+coverage, pairSet)
 978     | hb_filter (glyphset, hb_first)
 979     | hb_filter ([this, c, out] (const OffsetTo<PairSet>& _)
 980                  {
 981                    auto *o = out->pairSet.serialize_append (c->serializer);
 982                    if (unlikely (!o)) return false;
 983                    auto snap = c->serializer->snapshot ();
 984                    bool ret = o->serialize_subset (c, _, this, out, valueFormat);
 985                    if (!ret)
 986                    {
 987                      out->pairSet.pop ();
 988                      c->serializer->revert (snap);
 989                    }
 990                    return ret;
 991                  },
 992                  hb_second)
 993     | hb_map (hb_first)
 994     | hb_map (glyph_map)
 995     | hb_sink (new_coverage)
 996     ;
 997
 998     out->coverage.serialize (c->serializer, out)
 999                  .serialize (c->serializer, new_coverage.iter ());
1000
1001     return_trace (bool (new_coverage));
1002   }
1003
1004   bool sanitize (hb_sanitize_context_t *c) const
1005   {
1006     TRACE_SANITIZE (this);
1007
1008     if (!c->check_struct (this)) return_trace (false);
1009
1010     unsigned int len1 = valueFormat[0].get_len ();
1011     unsigned int len2 = valueFormat[1].get_len ();
1012     PairSet::sanitize_closure_t closure =
1013     {
1014       this,
1015       valueFormat,
1016       len1,
1017       1 + len1 + len2
1018     };
1019
1020     return_trace (coverage.sanitize (c, this) && pairSet.sanitize (c, this, &closure));
1021   }
1022
1023   protected:
1024   HBUINT16      format;                 /* Format identifier--format = 1 */
1025   OffsetTo<Coverage>
1026                 coverage;               /* Offset to Coverage table--from
1027                                          * beginning of subtable */
1028   ValueFormat   valueFormat[2];         /* [0] Defines the types of data in
1029                                          * ValueRecord1--for the first glyph
1030                                          * in the pair--may be zero (0) */
1031                                         /* [1] Defines the types of data in
1032                                          * ValueRecord2--for the second glyph
1033                                          * in the pair--may be zero (0) */
1034   OffsetArrayOf<PairSet>
1035                 pairSet;                /* Array of PairSet tables
1036                                          * ordered by Coverage Index */
1037   public:
1038   DEFINE_SIZE_ARRAY (10, pairSet);
1039 };
1040
1041 struct PairPosFormat2
1042 {
1043   bool intersects (const hb_set_t *glyphs) const
1044   {
1045     return (this+coverage).intersects (glyphs) &&
1046            (this+classDef2).intersects (glyphs);
1047   }
1048
1049   void collect_glyphs (hb_collect_glyphs_context_t *c) const
1050   {
1051     if (unlikely (!(this+coverage).add_coverage (c->input))) return;
1052     if (unlikely (!(this+classDef2).add_coverage (c->input))) return;
1053   }
1054
1055   const Coverage &get_coverage () const { return this+coverage; }
1056
1057   bool apply (hb_ot_apply_context_t *c) const
1058   {
1059     TRACE_APPLY (this);
1060     hb_buffer_t *buffer = c->buffer;
1061     unsigned int index = (this+coverage).get_coverage  (buffer->cur().codepoint);
1062     if (likely (index == NOT_COVERED)) return_trace (false);
1063
1064     hb_ot_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
1065     skippy_iter.reset (buffer->idx, 1);
1066     if (!skippy_iter.next ()) return_trace (false);
1067
1068     unsigned int len1 = valueFormat1.get_len ();
1069     unsigned int len2 = valueFormat2.get_len ();
1070     unsigned int record_len = len1 + len2;
1071
1072     unsigned int klass1 = (this+classDef1).get_class (buffer->cur().codepoint);
1073     unsigned int klass2 = (this+classDef2).get_class (buffer->info[skippy_iter.idx].codepoint);
1074     if (unlikely (klass1 >= class1Count || klass2 >= class2Count)) return_trace (false);
1075
1076     const Value *v = &values[record_len * (klass1 * class2Count + klass2)];
1077     /* Note the intentional use of "|" instead of short-circuit "||". */
1078     if (valueFormat1.apply_value (c, this, v, buffer->cur_pos()) |
1079         valueFormat2.apply_value (c, this, v + len1, buffer->pos[skippy_iter.idx]))
1080       buffer->unsafe_to_break (buffer->idx, skippy_iter.idx + 1);
1081
1082     buffer->idx = skippy_iter.idx;
1083     if (len2)
1084       buffer->idx++;
1085
1086     return_trace (true);
1087   }
1088
1089   bool subset (hb_subset_context_t *c) const
1090   {
1091     TRACE_SUBSET (this);
1092     auto *out = c->serializer->start_embed (*this);
1093     if (unlikely (!c->serializer->extend_min (out))) return_trace (false);
1094     out->format = format;
1095     out->valueFormat1 = valueFormat1;
1096     out->valueFormat2 = valueFormat2;
1097
1098     hb_map_t klass1_map;
1099     out->classDef1.serialize_subset (c, classDef1, this, out, &klass1_map);
1100     out->class1Count = klass1_map.get_population ();
1101
1102     hb_map_t klass2_map;
1103     out->classDef2.serialize_subset (c, classDef2, this, out, &klass2_map);
1104     out->class2Count = klass2_map.get_population ();
1105
1106     unsigned record_len = valueFormat1.get_len () + valueFormat2.get_len ();
1107
1108     + hb_range ((unsigned) class1Count)
1109     | hb_filter (klass1_map)
1110     | hb_apply ([&] (const unsigned class1_idx)
1111                 {
1112                   + hb_range ((unsigned) class2Count)
1113                   | hb_filter (klass2_map)
1114                   | hb_apply ([&] (const unsigned class2_idx)
1115                               {
1116                                 unsigned idx = (class1_idx * (unsigned) class2Count + class2_idx) * record_len;
1117                                 for (unsigned i = 0; i < record_len; i++)
1118                                   c->serializer->copy (values[idx+i]);
1119                               })
1120                   ;
1121                 })
1122     ;
1123
1124     const hb_set_t &glyphset = *c->plan->glyphset ();
1125     const hb_map_t &glyph_map = *c->plan->glyph_map;
1126
1127     auto it =
1128     + hb_iter (this+coverage)
1129     | hb_filter (glyphset)
1130     | hb_map_retains_sorting (glyph_map)
1131     ;
1132
1133     out->coverage.serialize (c->serializer, out).serialize (c->serializer, it);
1134     return_trace (out->class1Count && out->class2Count && bool (it));
1135   }
1136
1137   bool sanitize (hb_sanitize_context_t *c) const
1138   {
1139     TRACE_SANITIZE (this);
1140     if (!(c->check_struct (this)
1141        && coverage.sanitize (c, this)
1142        && classDef1.sanitize (c, this)
1143        && classDef2.sanitize (c, this))) return_trace (false);
1144
1145     unsigned int len1 = valueFormat1.get_len ();
1146     unsigned int len2 = valueFormat2.get_len ();
1147     unsigned int stride = len1 + len2;
1148     unsigned int record_size = valueFormat1.get_size () + valueFormat2.get_size ();
1149     unsigned int count = (unsigned int) class1Count * (unsigned int) class2Count;
1150     return_trace (c->check_range ((const void *) values,
1151                                   count,
1152                                   record_size) &&
1153                   valueFormat1.sanitize_values_stride_unsafe (c, this, &values[0], count, stride) &&
1154                   valueFormat2.sanitize_values_stride_unsafe (c, this, &values[len1], count, stride));
1155   }
1156
1157   protected:
1158   HBUINT16      format;                 /* Format identifier--format = 2 */
1159   OffsetTo<Coverage>
1160                 coverage;               /* Offset to Coverage table--from
1161                                          * beginning of subtable */
1162   ValueFormat   valueFormat1;           /* ValueRecord definition--for the
1163                                          * first glyph of the pair--may be zero
1164                                          * (0) */
1165   ValueFormat   valueFormat2;           /* ValueRecord definition--for the
1166                                          * second glyph of the pair--may be
1167                                          * zero (0) */
1168   OffsetTo<ClassDef>
1169                 classDef1;              /* Offset to ClassDef table--from
1170                                          * beginning of PairPos subtable--for
1171                                          * the first glyph of the pair */
1172   OffsetTo<ClassDef>
1173                 classDef2;              /* Offset to ClassDef table--from
1174                                          * beginning of PairPos subtable--for
1175                                          * the second glyph of the pair */
1176   HBUINT16      class1Count;            /* Number of classes in ClassDef1
1177                                          * table--includes Class0 */
1178   HBUINT16      class2Count;            /* Number of classes in ClassDef2
1179                                          * table--includes Class0 */
1180   ValueRecord   values;                 /* Matrix of value pairs:
1181                                          * class1-major, class2-minor,
1182                                          * Each entry has value1 and value2 */
1183   public:
1184   DEFINE_SIZE_ARRAY (16, values);
1185 };
1186
1187 struct PairPos
1188 {
1189   template <typename context_t, typename ...Ts>
1190   typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const
1191   {
1192     TRACE_DISPATCH (this, u.format);
1193     if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ());
1194     switch (u.format) {
1195     case 1: return_trace (c->dispatch (u.format1, hb_forward<Ts> (ds)...));
1196     case 2: return_trace (c->dispatch (u.format2, hb_forward<Ts> (ds)...));
1197     default:return_trace (c->default_return_value ());
1198     }
1199   }
1200
1201   protected:
1202   union {
1203   HBUINT16              format;         /* Format identifier */
1204   PairPosFormat1        format1;
1205   PairPosFormat2        format2;
1206   } u;
1207 };
1208
1209
1210 struct EntryExitRecord
1211 {
1212   friend struct CursivePosFormat1;
1213
1214   bool sanitize (hb_sanitize_context_t *c, const void *base) const
1215   {
1216     TRACE_SANITIZE (this);
1217     return_trace (entryAnchor.sanitize (c, base) && exitAnchor.sanitize (c, base));
1218   }
1219
1220   EntryExitRecord* copy (hb_serialize_context_t *c,
1221                          const void *src_base,
1222                          const void *dst_base) const
1223   {
1224     TRACE_SERIALIZE (this);
1225     auto *out = c->embed (this);
1226     if (unlikely (!out)) return_trace (nullptr);
1227
1228     out->entryAnchor.serialize_copy (c, entryAnchor, src_base, dst_base);
1229     out->exitAnchor.serialize_copy (c, exitAnchor, src_base, dst_base);
1230     return_trace (out);
1231   }
1232
1233   protected:
1234   OffsetTo<Anchor>
1235                 entryAnchor;            /* Offset to EntryAnchor table--from
1236                                          * beginning of CursivePos
1237                                          * subtable--may be NULL */
1238   OffsetTo<Anchor>
1239                 exitAnchor;             /* Offset to ExitAnchor table--from
1240                                          * beginning of CursivePos
1241                                          * subtable--may be NULL */
1242   public:
1243   DEFINE_SIZE_STATIC (4);
1244 };
1245
1246 static void
1247 reverse_cursive_minor_offset (hb_glyph_position_t *pos, unsigned int i, hb_direction_t direction, unsigned int new_parent);
1248
1249 struct CursivePosFormat1
1250 {
1251   bool intersects (const hb_set_t *glyphs) const
1252   { return (this+coverage).intersects (glyphs); }
1253
1254   void collect_glyphs (hb_collect_glyphs_context_t *c) const
1255   { if (unlikely (!(this+coverage).add_coverage (c->input))) return; }
1256
1257   const Coverage &get_coverage () const { return this+coverage; }
1258
1259   bool apply (hb_ot_apply_context_t *c) const
1260   {
1261     TRACE_APPLY (this);
1262     hb_buffer_t *buffer = c->buffer;
1263
1264     const EntryExitRecord &this_record = entryExitRecord[(this+coverage).get_coverage  (buffer->cur().codepoint)];
1265     if (!this_record.entryAnchor) return_trace (false);
1266
1267     hb_ot_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
1268     skippy_iter.reset (buffer->idx, 1);
1269     if (!skippy_iter.prev ()) return_trace (false);
1270
1271     const EntryExitRecord &prev_record = entryExitRecord[(this+coverage).get_coverage  (buffer->info[skippy_iter.idx].codepoint)];
1272     if (!prev_record.exitAnchor) return_trace (false);
1273
1274     unsigned int i = skippy_iter.idx;
1275     unsigned int j = buffer->idx;
1276
1277     buffer->unsafe_to_break (i, j);
1278     float entry_x, entry_y, exit_x, exit_y;
1279     (this+prev_record.exitAnchor).get_anchor (c, buffer->info[i].codepoint, &exit_x, &exit_y);
1280     (this+this_record.entryAnchor).get_anchor (c, buffer->info[j].codepoint, &entry_x, &entry_y);
1281
1282     hb_glyph_position_t *pos = buffer->pos;
1283
1284     hb_position_t d;
1285     /* Main-direction adjustment */
1286     switch (c->direction) {
1287       case HB_DIRECTION_LTR:
1288         pos[i].x_advance  = roundf (exit_x) + pos[i].x_offset;
1289
1290         d = roundf (entry_x) + pos[j].x_offset;
1291         pos[j].x_advance -= d;
1292         pos[j].x_offset  -= d;
1293         break;
1294       case HB_DIRECTION_RTL:
1295         d = roundf (exit_x) + pos[i].x_offset;
1296         pos[i].x_advance -= d;
1297         pos[i].x_offset  -= d;
1298
1299         pos[j].x_advance  = roundf (entry_x) + pos[j].x_offset;
1300         break;
1301       case HB_DIRECTION_TTB:
1302         pos[i].y_advance  = roundf (exit_y) + pos[i].y_offset;
1303
1304         d = roundf (entry_y) + pos[j].y_offset;
1305         pos[j].y_advance -= d;
1306         pos[j].y_offset  -= d;
1307         break;
1308       case HB_DIRECTION_BTT:
1309         d = roundf (exit_y) + pos[i].y_offset;
1310         pos[i].y_advance -= d;
1311         pos[i].y_offset  -= d;
1312
1313         pos[j].y_advance  = roundf (entry_y);
1314         break;
1315       case HB_DIRECTION_INVALID:
1316       default:
1317         break;
1318     }
1319
1320     /* Cross-direction adjustment */
1321
1322     /* We attach child to parent (think graph theory and rooted trees whereas
1323      * the root stays on baseline and each node aligns itself against its
1324      * parent.
1325      *
1326      * Optimize things for the case of RightToLeft, as that's most common in
1327      * Arabic. */
1328     unsigned int child  = i;
1329     unsigned int parent = j;
1330     hb_position_t x_offset = entry_x - exit_x;
1331     hb_position_t y_offset = entry_y - exit_y;
1332     if  (!(c->lookup_props & LookupFlag::RightToLeft))
1333     {
1334       unsigned int k = child;
1335       child = parent;
1336       parent = k;
1337       x_offset = -x_offset;
1338       y_offset = -y_offset;
1339     }
1340
1341     /* If child was already connected to someone else, walk through its old
1342      * chain and reverse the link direction, such that the whole tree of its
1343      * previous connection now attaches to new parent.  Watch out for case
1344      * where new parent is on the path from old chain...
1345      */
1346     reverse_cursive_minor_offset (pos, child, c->direction, parent);
1347
1348     pos[child].attach_type() = ATTACH_TYPE_CURSIVE;
1349     pos[child].attach_chain() = (int) parent - (int) child;
1350     buffer->scratch_flags |= HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT;
1351     if (likely (HB_DIRECTION_IS_HORIZONTAL (c->direction)))
1352       pos[child].y_offset = y_offset;
1353     else
1354       pos[child].x_offset = x_offset;
1355
1356     buffer->idx++;
1357     return_trace (true);
1358   }
1359
1360   template <typename Iterator,
1361             hb_requires (hb_is_iterator (Iterator))>
1362   void serialize (hb_serialize_context_t *c,
1363                   Iterator it,
1364                   const void *src_base)
1365   {
1366     if (unlikely (!c->extend_min ((*this)))) return;
1367     this->format = 1;
1368     this->entryExitRecord.len = it.len ();
1369
1370     for (const EntryExitRecord& entry_record : + it
1371                                                | hb_map (hb_second))
1372       c->copy (entry_record, src_base, this);
1373
1374     auto glyphs =
1375     + it
1376     | hb_map_retains_sorting (hb_first)
1377     ;
1378
1379     coverage.serialize (c, this).serialize (c, glyphs);
1380   }
1381
1382   bool subset (hb_subset_context_t *c) const
1383   {
1384     TRACE_SUBSET (this);
1385     const hb_set_t &glyphset = *c->plan->glyphset ();
1386     const hb_map_t &glyph_map = *c->plan->glyph_map;
1387
1388     auto *out = c->serializer->start_embed (*this);
1389     if (unlikely (!out)) return_trace (false);
1390
1391     auto it =
1392     + hb_zip (this+coverage, entryExitRecord)
1393     | hb_filter (glyphset, hb_first)
1394     | hb_map_retains_sorting ([&] (hb_pair_t<hb_codepoint_t, const EntryExitRecord&> p) -> hb_pair_t<hb_codepoint_t, const EntryExitRecord&>
1395                               { return hb_pair (glyph_map[p.first], p.second);})
1396     ;
1397
1398     bool ret = bool (it);
1399     out->serialize (c->serializer, it, this);
1400     return_trace (ret);
1401   }
1402
1403   bool sanitize (hb_sanitize_context_t *c) const
1404   {
1405     TRACE_SANITIZE (this);
1406     return_trace (coverage.sanitize (c, this) && entryExitRecord.sanitize (c, this));
1407   }
1408
1409   protected:
1410   HBUINT16      format;                 /* Format identifier--format = 1 */
1411   OffsetTo<Coverage>
1412                 coverage;               /* Offset to Coverage table--from
1413                                          * beginning of subtable */
1414   ArrayOf<EntryExitRecord>
1415                 entryExitRecord;        /* Array of EntryExit records--in
1416                                          * Coverage Index order */
1417   public:
1418   DEFINE_SIZE_ARRAY (6, entryExitRecord);
1419 };
1420
1421 struct CursivePos
1422 {
1423   template <typename context_t, typename ...Ts>
1424   typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const
1425   {
1426     TRACE_DISPATCH (this, u.format);
1427     if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ());
1428     switch (u.format) {
1429     case 1: return_trace (c->dispatch (u.format1, hb_forward<Ts> (ds)...));
1430     default:return_trace (c->default_return_value ());
1431     }
1432   }
1433
1434   protected:
1435   union {
1436   HBUINT16              format;         /* Format identifier */
1437   CursivePosFormat1     format1;
1438   } u;
1439 };
1440
1441
1442 typedef AnchorMatrix BaseArray;         /* base-major--
1443                                          * in order of BaseCoverage Index--,
1444                                          * mark-minor--
1445                                          * ordered by class--zero-based. */
1446
1447 struct MarkBasePosFormat1
1448 {
1449   bool intersects (const hb_set_t *glyphs) const
1450   { return (this+markCoverage).intersects (glyphs) &&
1451            (this+baseCoverage).intersects (glyphs); }
1452
1453   void collect_glyphs (hb_collect_glyphs_context_t *c) const
1454   {
1455     if (unlikely (!(this+markCoverage).add_coverage (c->input))) return;
1456     if (unlikely (!(this+baseCoverage).add_coverage (c->input))) return;
1457   }
1458
1459   const Coverage &get_coverage () const { return this+markCoverage; }
1460
1461   bool apply (hb_ot_apply_context_t *c) const
1462   {
1463     TRACE_APPLY (this);
1464     hb_buffer_t *buffer = c->buffer;
1465     unsigned int mark_index = (this+markCoverage).get_coverage  (buffer->cur().codepoint);
1466     if (likely (mark_index == NOT_COVERED)) return_trace (false);
1467
1468     /* Now we search backwards for a non-mark glyph */
1469     hb_ot_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
1470     skippy_iter.reset (buffer->idx, 1);
1471     skippy_iter.set_lookup_props (LookupFlag::IgnoreMarks);
1472     do {
1473       if (!skippy_iter.prev ()) return_trace (false);
1474       /* We only want to attach to the first of a MultipleSubst sequence.
1475        * https://github.com/harfbuzz/harfbuzz/issues/740
1476        * Reject others...
1477        * ...but stop if we find a mark in the MultipleSubst sequence:
1478        * https://github.com/harfbuzz/harfbuzz/issues/1020 */
1479       if (!_hb_glyph_info_multiplied (&buffer->info[skippy_iter.idx]) ||
1480           0 == _hb_glyph_info_get_lig_comp (&buffer->info[skippy_iter.idx]) ||
1481           (skippy_iter.idx == 0 ||
1482            _hb_glyph_info_is_mark (&buffer->info[skippy_iter.idx - 1]) ||
1483            _hb_glyph_info_get_lig_id (&buffer->info[skippy_iter.idx]) !=
1484            _hb_glyph_info_get_lig_id (&buffer->info[skippy_iter.idx - 1]) ||
1485            _hb_glyph_info_get_lig_comp (&buffer->info[skippy_iter.idx]) !=
1486            _hb_glyph_info_get_lig_comp (&buffer->info[skippy_iter.idx - 1]) + 1
1487            ))
1488         break;
1489       skippy_iter.reject ();
1490     } while (true);
1491
1492     /* Checking that matched glyph is actually a base glyph by GDEF is too strong; disabled */
1493     //if (!_hb_glyph_info_is_base_glyph (&buffer->info[skippy_iter.idx])) { return_trace (false); }
1494
1495     unsigned int base_index = (this+baseCoverage).get_coverage  (buffer->info[skippy_iter.idx].codepoint);
1496     if (base_index == NOT_COVERED) return_trace (false);
1497
1498     return_trace ((this+markArray).apply (c, mark_index, base_index, this+baseArray, classCount, skippy_iter.idx));
1499   }
1500
1501   bool subset (hb_subset_context_t *c) const
1502   {
1503     TRACE_SUBSET (this);
1504     // TODO(subset)
1505     return_trace (false);
1506   }
1507
1508   bool sanitize (hb_sanitize_context_t *c) const
1509   {
1510     TRACE_SANITIZE (this);
1511     return_trace (c->check_struct (this) &&
1512                   markCoverage.sanitize (c, this) &&
1513                   baseCoverage.sanitize (c, this) &&
1514                   markArray.sanitize (c, this) &&
1515                   baseArray.sanitize (c, this, (unsigned int) classCount));
1516   }
1517
1518   protected:
1519   HBUINT16      format;                 /* Format identifier--format = 1 */
1520   OffsetTo<Coverage>
1521                 markCoverage;           /* Offset to MarkCoverage table--from
1522                                          * beginning of MarkBasePos subtable */
1523   OffsetTo<Coverage>
1524                 baseCoverage;           /* Offset to BaseCoverage table--from
1525                                          * beginning of MarkBasePos subtable */
1526   HBUINT16      classCount;             /* Number of classes defined for marks */
1527   OffsetTo<MarkArray>
1528                 markArray;              /* Offset to MarkArray table--from
1529                                          * beginning of MarkBasePos subtable */
1530   OffsetTo<BaseArray>
1531                 baseArray;              /* Offset to BaseArray table--from
1532                                          * beginning of MarkBasePos subtable */
1533   public:
1534   DEFINE_SIZE_STATIC (12);
1535 };
1536
1537 struct MarkBasePos
1538 {
1539   template <typename context_t, typename ...Ts>
1540   typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const
1541   {
1542     TRACE_DISPATCH (this, u.format);
1543     if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ());
1544     switch (u.format) {
1545     case 1: return_trace (c->dispatch (u.format1, hb_forward<Ts> (ds)...));
1546     default:return_trace (c->default_return_value ());
1547     }
1548   }
1549
1550   protected:
1551   union {
1552   HBUINT16              format;         /* Format identifier */
1553   MarkBasePosFormat1    format1;
1554   } u;
1555 };
1556
1557
1558 typedef AnchorMatrix LigatureAttach;    /* component-major--
1559                                          * in order of writing direction--,
1560                                          * mark-minor--
1561                                          * ordered by class--zero-based. */
1562
1563 typedef OffsetListOf<LigatureAttach> LigatureArray;
1564                                         /* Array of LigatureAttach
1565                                          * tables ordered by
1566                                          * LigatureCoverage Index */
1567
1568 struct MarkLigPosFormat1
1569 {
1570   bool intersects (const hb_set_t *glyphs) const
1571   { return (this+markCoverage).intersects (glyphs) &&
1572            (this+ligatureCoverage).intersects (glyphs); }
1573
1574   void collect_glyphs (hb_collect_glyphs_context_t *c) const
1575   {
1576     if (unlikely (!(this+markCoverage).add_coverage (c->input))) return;
1577     if (unlikely (!(this+ligatureCoverage).add_coverage (c->input))) return;
1578   }
1579
1580   const Coverage &get_coverage () const { return this+markCoverage; }
1581
1582   bool apply (hb_ot_apply_context_t *c) const
1583   {
1584     TRACE_APPLY (this);
1585     hb_buffer_t *buffer = c->buffer;
1586     unsigned int mark_index = (this+markCoverage).get_coverage  (buffer->cur().codepoint);
1587     if (likely (mark_index == NOT_COVERED)) return_trace (false);
1588
1589     /* Now we search backwards for a non-mark glyph */
1590     hb_ot_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
1591     skippy_iter.reset (buffer->idx, 1);
1592     skippy_iter.set_lookup_props (LookupFlag::IgnoreMarks);
1593     if (!skippy_iter.prev ()) return_trace (false);
1594
1595     /* Checking that matched glyph is actually a ligature by GDEF is too strong; disabled */
1596     //if (!_hb_glyph_info_is_ligature (&buffer->info[skippy_iter.idx])) { return_trace (false); }
1597
1598     unsigned int j = skippy_iter.idx;
1599     unsigned int lig_index = (this+ligatureCoverage).get_coverage  (buffer->info[j].codepoint);
1600     if (lig_index == NOT_COVERED) return_trace (false);
1601
1602     const LigatureArray& lig_array = this+ligatureArray;
1603     const LigatureAttach& lig_attach = lig_array[lig_index];
1604
1605     /* Find component to attach to */
1606     unsigned int comp_count = lig_attach.rows;
1607     if (unlikely (!comp_count)) return_trace (false);
1608
1609     /* We must now check whether the ligature ID of the current mark glyph
1610      * is identical to the ligature ID of the found ligature.  If yes, we
1611      * can directly use the component index.  If not, we attach the mark
1612      * glyph to the last component of the ligature. */
1613     unsigned int comp_index;
1614     unsigned int lig_id = _hb_glyph_info_get_lig_id (&buffer->info[j]);
1615     unsigned int mark_id = _hb_glyph_info_get_lig_id (&buffer->cur());
1616     unsigned int mark_comp = _hb_glyph_info_get_lig_comp (&buffer->cur());
1617     if (lig_id && lig_id == mark_id && mark_comp > 0)
1618       comp_index = hb_min (comp_count, _hb_glyph_info_get_lig_comp (&buffer->cur())) - 1;
1619     else
1620       comp_index = comp_count - 1;
1621
1622     return_trace ((this+markArray).apply (c, mark_index, comp_index, lig_attach, classCount, j));
1623   }
1624
1625   bool subset (hb_subset_context_t *c) const
1626   {
1627     TRACE_SUBSET (this);
1628     // TODO(subset)
1629     return_trace (false);
1630   }
1631
1632   bool sanitize (hb_sanitize_context_t *c) const
1633   {
1634     TRACE_SANITIZE (this);
1635     return_trace (c->check_struct (this) &&
1636                   markCoverage.sanitize (c, this) &&
1637                   ligatureCoverage.sanitize (c, this) &&
1638                   markArray.sanitize (c, this) &&
1639                   ligatureArray.sanitize (c, this, (unsigned int) classCount));
1640   }
1641
1642   protected:
1643   HBUINT16      format;                 /* Format identifier--format = 1 */
1644   OffsetTo<Coverage>
1645                 markCoverage;           /* Offset to Mark Coverage table--from
1646                                          * beginning of MarkLigPos subtable */
1647   OffsetTo<Coverage>
1648                 ligatureCoverage;       /* Offset to Ligature Coverage
1649                                          * table--from beginning of MarkLigPos
1650                                          * subtable */
1651   HBUINT16      classCount;             /* Number of defined mark classes */
1652   OffsetTo<MarkArray>
1653                 markArray;              /* Offset to MarkArray table--from
1654                                          * beginning of MarkLigPos subtable */
1655   OffsetTo<LigatureArray>
1656                 ligatureArray;          /* Offset to LigatureArray table--from
1657                                          * beginning of MarkLigPos subtable */
1658   public:
1659   DEFINE_SIZE_STATIC (12);
1660 };
1661
1662 struct MarkLigPos
1663 {
1664   template <typename context_t, typename ...Ts>
1665   typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const
1666   {
1667     TRACE_DISPATCH (this, u.format);
1668     if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ());
1669     switch (u.format) {
1670     case 1: return_trace (c->dispatch (u.format1, hb_forward<Ts> (ds)...));
1671     default:return_trace (c->default_return_value ());
1672     }
1673   }
1674
1675   protected:
1676   union {
1677   HBUINT16              format;         /* Format identifier */
1678   MarkLigPosFormat1     format1;
1679   } u;
1680 };
1681
1682
1683 typedef AnchorMatrix Mark2Array;        /* mark2-major--
1684                                          * in order of Mark2Coverage Index--,
1685                                          * mark1-minor--
1686                                          * ordered by class--zero-based. */
1687
1688 struct MarkMarkPosFormat1
1689 {
1690   bool intersects (const hb_set_t *glyphs) const
1691   { return (this+mark1Coverage).intersects (glyphs) &&
1692            (this+mark2Coverage).intersects (glyphs); }
1693
1694   void collect_glyphs (hb_collect_glyphs_context_t *c) const
1695   {
1696     if (unlikely (!(this+mark1Coverage).add_coverage (c->input))) return;
1697     if (unlikely (!(this+mark2Coverage).add_coverage (c->input))) return;
1698   }
1699
1700   const Coverage &get_coverage () const { return this+mark1Coverage; }
1701
1702   bool apply (hb_ot_apply_context_t *c) const
1703   {
1704     TRACE_APPLY (this);
1705     hb_buffer_t *buffer = c->buffer;
1706     unsigned int mark1_index = (this+mark1Coverage).get_coverage  (buffer->cur().codepoint);
1707     if (likely (mark1_index == NOT_COVERED)) return_trace (false);
1708
1709     /* now we search backwards for a suitable mark glyph until a non-mark glyph */
1710     hb_ot_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;
1711     skippy_iter.reset (buffer->idx, 1);
1712     skippy_iter.set_lookup_props (c->lookup_props & ~LookupFlag::IgnoreFlags);
1713     if (!skippy_iter.prev ()) return_trace (false);
1714
1715     if (!_hb_glyph_info_is_mark (&buffer->info[skippy_iter.idx])) { return_trace (false); }
1716
1717     unsigned int j = skippy_iter.idx;
1718
1719     unsigned int id1 = _hb_glyph_info_get_lig_id (&buffer->cur());
1720     unsigned int id2 = _hb_glyph_info_get_lig_id (&buffer->info[j]);
1721     unsigned int comp1 = _hb_glyph_info_get_lig_comp (&buffer->cur());
1722     unsigned int comp2 = _hb_glyph_info_get_lig_comp (&buffer->info[j]);
1723
1724     if (likely (id1 == id2)) {
1725       if (id1 == 0) /* Marks belonging to the same base. */
1726         goto good;
1727       else if (comp1 == comp2) /* Marks belonging to the same ligature component. */
1728         goto good;
1729     } else {
1730       /* If ligature ids don't match, it may be the case that one of the marks
1731        * itself is a ligature.  In which case match. */
1732       if ((id1 > 0 && !comp1) || (id2 > 0 && !comp2))
1733         goto good;
1734     }
1735
1736     /* Didn't match. */
1737     return_trace (false);
1738
1739     good:
1740     unsigned int mark2_index = (this+mark2Coverage).get_coverage  (buffer->info[j].codepoint);
1741     if (mark2_index == NOT_COVERED) return_trace (false);
1742
1743     return_trace ((this+mark1Array).apply (c, mark1_index, mark2_index, this+mark2Array, classCount, j));
1744   }
1745
1746   bool subset (hb_subset_context_t *c) const
1747   {
1748     TRACE_SUBSET (this);
1749     // TODO(subset)
1750     return_trace (false);
1751   }
1752
1753   bool sanitize (hb_sanitize_context_t *c) const
1754   {
1755     TRACE_SANITIZE (this);
1756     return_trace (c->check_struct (this) &&
1757                   mark1Coverage.sanitize (c, this) &&
1758                   mark2Coverage.sanitize (c, this) &&
1759                   mark1Array.sanitize (c, this) &&
1760                   mark2Array.sanitize (c, this, (unsigned int) classCount));
1761   }
1762
1763   protected:
1764   HBUINT16      format;                 /* Format identifier--format = 1 */
1765   OffsetTo<Coverage>
1766                 mark1Coverage;          /* Offset to Combining Mark1 Coverage
1767                                          * table--from beginning of MarkMarkPos
1768                                          * subtable */
1769   OffsetTo<Coverage>
1770                 mark2Coverage;          /* Offset to Combining Mark2 Coverage
1771                                          * table--from beginning of MarkMarkPos
1772                                          * subtable */
1773   HBUINT16      classCount;             /* Number of defined mark classes */
1774   OffsetTo<MarkArray>
1775                 mark1Array;             /* Offset to Mark1Array table--from
1776                                          * beginning of MarkMarkPos subtable */
1777   OffsetTo<Mark2Array>
1778                 mark2Array;             /* Offset to Mark2Array table--from
1779                                          * beginning of MarkMarkPos subtable */
1780   public:
1781   DEFINE_SIZE_STATIC (12);
1782 };
1783
1784 struct MarkMarkPos
1785 {
1786   template <typename context_t, typename ...Ts>
1787   typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const
1788   {
1789     TRACE_DISPATCH (this, u.format);
1790     if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ());
1791     switch (u.format) {
1792     case 1: return_trace (c->dispatch (u.format1, hb_forward<Ts> (ds)...));
1793     default:return_trace (c->default_return_value ());
1794     }
1795   }
1796
1797   protected:
1798   union {
1799   HBUINT16              format;         /* Format identifier */
1800   MarkMarkPosFormat1    format1;
1801   } u;
1802 };
1803
1804
1805 struct ContextPos : Context {};
1806
1807 struct ChainContextPos : ChainContext {};
1808
1809 struct ExtensionPos : Extension<ExtensionPos>
1810 {
1811   typedef struct PosLookupSubTable SubTable;
1812 };
1813
1814
1815
1816 /*
1817  * PosLookup
1818  */
1819
1820
1821 struct PosLookupSubTable
1822 {
1823   friend struct Lookup;
1824   friend struct PosLookup;
1825
1826   enum Type {
1827     Single              = 1,
1828     Pair                = 2,
1829     Cursive             = 3,
1830     MarkBase            = 4,
1831     MarkLig             = 5,
1832     MarkMark            = 6,
1833     Context             = 7,
1834     ChainContext        = 8,
1835     Extension           = 9
1836   };
1837
1838   template <typename context_t, typename ...Ts>
1839   typename context_t::return_t dispatch (context_t *c, unsigned int lookup_type, Ts&&... ds) const
1840   {
1841     TRACE_DISPATCH (this, lookup_type);
1842     switch (lookup_type) {
1843     case Single:                return_trace (u.single.dispatch (c, hb_forward<Ts> (ds)...));
1844     case Pair:                  return_trace (u.pair.dispatch (c, hb_forward<Ts> (ds)...));
1845     case Cursive:               return_trace (u.cursive.dispatch (c, hb_forward<Ts> (ds)...));
1846     case MarkBase:              return_trace (u.markBase.dispatch (c, hb_forward<Ts> (ds)...));
1847     case MarkLig:               return_trace (u.markLig.dispatch (c, hb_forward<Ts> (ds)...));
1848     case MarkMark:              return_trace (u.markMark.dispatch (c, hb_forward<Ts> (ds)...));
1849     case Context:               return_trace (u.context.dispatch (c, hb_forward<Ts> (ds)...));
1850     case ChainContext:          return_trace (u.chainContext.dispatch (c, hb_forward<Ts> (ds)...));
1851     case Extension:             return_trace (u.extension.dispatch (c, hb_forward<Ts> (ds)...));
1852     default:                    return_trace (c->default_return_value ());
1853     }
1854   }
1855
1856   protected:
1857   union {
1858   SinglePos             single;
1859   PairPos               pair;
1860   CursivePos            cursive;
1861   MarkBasePos           markBase;
1862   MarkLigPos            markLig;
1863   MarkMarkPos           markMark;
1864   ContextPos            context;
1865   ChainContextPos       chainContext;
1866   ExtensionPos          extension;
1867   } u;
1868   public:
1869   DEFINE_SIZE_MIN (0);
1870 };
1871
1872
1873 struct PosLookup : Lookup
1874 {
1875   typedef struct PosLookupSubTable SubTable;
1876
1877   const SubTable& get_subtable (unsigned int i) const
1878   { return Lookup::get_subtable<SubTable> (i); }
1879
1880   bool is_reverse () const
1881   {
1882     return false;
1883   }
1884
1885   bool apply (hb_ot_apply_context_t *c) const
1886   {
1887     TRACE_APPLY (this);
1888     return_trace (dispatch (c));
1889   }
1890
1891   bool intersects (const hb_set_t *glyphs) const
1892   {
1893     hb_intersects_context_t c (glyphs);
1894     return dispatch (&c);
1895   }
1896
1897   hb_collect_glyphs_context_t::return_t collect_glyphs (hb_collect_glyphs_context_t *c) const
1898   { return dispatch (c); }
1899
1900   template <typename set_t>
1901   void add_coverage (set_t *glyphs) const
1902   {
1903     hb_add_coverage_context_t<set_t> c (glyphs);
1904     dispatch (&c);
1905   }
1906
1907   HB_INTERNAL static bool apply_recurse_func (hb_ot_apply_context_t *c, unsigned int lookup_index);
1908
1909   template <typename context_t>
1910   static typename context_t::return_t dispatch_recurse_func (context_t *c, unsigned int lookup_index);
1911
1912   template <typename context_t, typename ...Ts>
1913   typename context_t::return_t dispatch (context_t *c, Ts&&... ds) const
1914   { return Lookup::dispatch<SubTable> (c, hb_forward<Ts> (ds)...); }
1915
1916   bool subset (hb_subset_context_t *c) const
1917   { return Lookup::subset<SubTable> (c); }
1918
1919   bool sanitize (hb_sanitize_context_t *c) const
1920   { return Lookup::sanitize<SubTable> (c); }
1921 };
1922
1923 /*
1924  * GPOS -- Glyph Positioning
1925  * https://docs.microsoft.com/en-us/typography/opentype/spec/gpos
1926  */
1927
1928 struct GPOS : GSUBGPOS
1929 {
1930   static constexpr hb_tag_t tableTag = HB_OT_TAG_GPOS;
1931
1932   const PosLookup& get_lookup (unsigned int i) const
1933   { return CastR<PosLookup> (GSUBGPOS::get_lookup (i)); }
1934
1935   static inline void position_start (hb_font_t *font, hb_buffer_t *buffer);
1936   static inline void position_finish_advances (hb_font_t *font, hb_buffer_t *buffer);
1937   static inline void position_finish_offsets (hb_font_t *font, hb_buffer_t *buffer);
1938
1939   bool subset (hb_subset_context_t *c) const
1940   { return GSUBGPOS::subset<PosLookup> (c); }
1941
1942   bool sanitize (hb_sanitize_context_t *c) const
1943   { return GSUBGPOS::sanitize<PosLookup> (c); }
1944
1945   HB_INTERNAL bool is_blacklisted (hb_blob_t *blob,
1946                                    hb_face_t *face) const;
1947
1948   typedef GSUBGPOS::accelerator_t<GPOS> accelerator_t;
1949 };
1950
1951
1952 static void
1953 reverse_cursive_minor_offset (hb_glyph_position_t *pos, unsigned int i, hb_direction_t direction, unsigned int new_parent)
1954 {
1955   int chain = pos[i].attach_chain(), type = pos[i].attach_type();
1956   if (likely (!chain || 0 == (type & ATTACH_TYPE_CURSIVE)))
1957     return;
1958
1959   pos[i].attach_chain() = 0;
1960
1961   unsigned int j = (int) i + chain;
1962
1963   /* Stop if we see new parent in the chain. */
1964   if (j == new_parent)
1965     return;
1966
1967   reverse_cursive_minor_offset (pos, j, direction, new_parent);
1968
1969   if (HB_DIRECTION_IS_HORIZONTAL (direction))
1970     pos[j].y_offset = -pos[i].y_offset;
1971   else
1972     pos[j].x_offset = -pos[i].x_offset;
1973
1974   pos[j].attach_chain() = -chain;
1975   pos[j].attach_type() = type;
1976 }
1977 static void
1978 propagate_attachment_offsets (hb_glyph_position_t *pos,
1979                               unsigned int len,
1980                               unsigned int i,
1981                               hb_direction_t direction)
1982 {
1983   /* Adjusts offsets of attached glyphs (both cursive and mark) to accumulate
1984    * offset of glyph they are attached to. */
1985   int chain = pos[i].attach_chain(), type = pos[i].attach_type();
1986   if (likely (!chain))
1987     return;
1988
1989   pos[i].attach_chain() = 0;
1990
1991   unsigned int j = (int) i + chain;
1992
1993   if (unlikely (j >= len))
1994     return;
1995
1996   propagate_attachment_offsets (pos, len, j, direction);
1997
1998   assert (!!(type & ATTACH_TYPE_MARK) ^ !!(type & ATTACH_TYPE_CURSIVE));
1999
2000   if (type & ATTACH_TYPE_CURSIVE)
2001   {
2002     if (HB_DIRECTION_IS_HORIZONTAL (direction))
2003       pos[i].y_offset += pos[j].y_offset;
2004     else
2005       pos[i].x_offset += pos[j].x_offset;
2006   }
2007   else /*if (type & ATTACH_TYPE_MARK)*/
2008   {
2009     pos[i].x_offset += pos[j].x_offset;
2010     pos[i].y_offset += pos[j].y_offset;
2011
2012     assert (j < i);
2013     if (HB_DIRECTION_IS_FORWARD (direction))
2014       for (unsigned int k = j; k < i; k++) {
2015         pos[i].x_offset -= pos[k].x_advance;
2016         pos[i].y_offset -= pos[k].y_advance;
2017       }
2018     else
2019       for (unsigned int k = j + 1; k < i + 1; k++) {
2020         pos[i].x_offset += pos[k].x_advance;
2021         pos[i].y_offset += pos[k].y_advance;
2022       }
2023   }
2024 }
2025
2026 void
2027 GPOS::position_start (hb_font_t *font HB_UNUSED, hb_buffer_t *buffer)
2028 {
2029   unsigned int count = buffer->len;
2030   for (unsigned int i = 0; i < count; i++)
2031     buffer->pos[i].attach_chain() = buffer->pos[i].attach_type() = 0;
2032 }
2033
2034 void
2035 GPOS::position_finish_advances (hb_font_t *font HB_UNUSED, hb_buffer_t *buffer HB_UNUSED)
2036 {
2037   //_hb_buffer_assert_gsubgpos_vars (buffer);
2038 }
2039
2040 void
2041 GPOS::position_finish_offsets (hb_font_t *font HB_UNUSED, hb_buffer_t *buffer)
2042 {
2043   _hb_buffer_assert_gsubgpos_vars (buffer);
2044
2045   unsigned int len;
2046   hb_glyph_position_t *pos = hb_buffer_get_glyph_positions (buffer, &len);
2047   hb_direction_t direction = buffer->props.direction;
2048
2049   /* Handle attachments */
2050   if (buffer->scratch_flags & HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT)
2051     for (unsigned int i = 0; i < len; i++)
2052       propagate_attachment_offsets (pos, len, i, direction);
2053 }
2054
2055
2056 struct GPOS_accelerator_t : GPOS::accelerator_t {};
2057
2058
2059 /* Out-of-class implementation for methods recursing */
2060
2061 #ifndef HB_NO_OT_LAYOUT
2062 template <typename context_t>
2063 /*static*/ inline typename context_t::return_t PosLookup::dispatch_recurse_func (context_t *c, unsigned int lookup_index)
2064 {
2065   const PosLookup &l = c->face->table.GPOS.get_relaxed ()->table->get_lookup (lookup_index);
2066   return l.dispatch (c);
2067 }
2068 /*static*/ inline bool PosLookup::apply_recurse_func (hb_ot_apply_context_t *c, unsigned int lookup_index)
2069 {
2070   const PosLookup &l = c->face->table.GPOS.get_relaxed ()->table->get_lookup (lookup_index);
2071   unsigned int saved_lookup_props = c->lookup_props;
2072   unsigned int saved_lookup_index = c->lookup_index;
2073   c->set_lookup_index (lookup_index);
2074   c->set_lookup_props (l.get_props ());
2075   bool ret = l.dispatch (c);
2076   c->set_lookup_index (saved_lookup_index);
2077   c->set_lookup_props (saved_lookup_props);
2078   return ret;
2079 }
2080 #endif
2081
2082
2083 } /* namespace OT */
2084
2085
2086 #endif /* HB_OT_LAYOUT_GPOS_TABLE_HH */