src/hb-ot-layout-gsub-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_GSUB_TABLE_HH
  30 #define HB_OT_LAYOUT_GSUB_TABLE_HH
  31
  32 #include "hb-ot-layout-gsubgpos-private.hh"
  33
  34
  35 namespace OT {
  36
  37
  38 struct SingleSubstFormat1
  39 {
  40   inline void closure (hb_closure_context_t *c) const
  41   {
  42     TRACE_CLOSURE (this);
  43     Coverage::Iter iter;
  44     for (iter.init (this+coverage); iter.more (); iter.next ()) {
  45       hb_codepoint_t glyph_id = iter.get_glyph ();
  46       if (c->glyphs->has (glyph_id))
  47         c->glyphs->add ((glyph_id + deltaGlyphID) & 0xFFFFu);
  48     }
  49   }
  50
  51   inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
  52   {
  53     TRACE_COLLECT_GLYPHS (this);
  54     Coverage::Iter iter;
  55     for (iter.init (this+coverage); iter.more (); iter.next ()) {
  56       hb_codepoint_t glyph_id = iter.get_glyph ();
  57       c->input->add (glyph_id);
  58       c->output->add ((glyph_id + deltaGlyphID) & 0xFFFFu);
  59     }
  60   }
  61
  62   inline const Coverage &get_coverage (void) const
  63   {
  64     return this+coverage;
  65   }
  66
  67   inline bool would_apply (hb_would_apply_context_t *c) const
  68   {
  69     TRACE_WOULD_APPLY (this);
  70     return TRACE_RETURN (c->len == 1 && (this+coverage).get_coverage (c->glyphs[0]) != NOT_COVERED);
  71   }
  72
  73   inline bool apply (hb_apply_context_t *c) const
  74   {
  75     TRACE_APPLY (this);
  76     hb_codepoint_t glyph_id = c->buffer->cur().codepoint;
  77     unsigned int index = (this+coverage).get_coverage (glyph_id);
  78     if (likely (index == NOT_COVERED)) return TRACE_RETURN (false);
  79
  80     /* According to the Adobe Annotated OpenType Suite, result is always
  81      * limited to 16bit. */
  82     glyph_id = (glyph_id + deltaGlyphID) & 0xFFFFu;
  83     c->replace_glyph (glyph_id);
  84
  85     return TRACE_RETURN (true);
  86   }
  87
  88   inline bool serialize (hb_serialize_context_t *c,
  89                          Supplier<GlyphID> &glyphs,
  90                          unsigned int num_glyphs,
  91                          int delta)
  92   {
  93     TRACE_SERIALIZE (this);
  94     if (unlikely (!c->extend_min (*this))) return TRACE_RETURN (false);
  95     if (unlikely (!coverage.serialize (c, this).serialize (c, glyphs, num_glyphs))) return TRACE_RETURN (false);
  96     deltaGlyphID.set (delta); /* TODO(serilaize) overflow? */
  97     return TRACE_RETURN (true);
  98   }
  99
 100   inline bool sanitize (hb_sanitize_context_t *c) {
 101     TRACE_SANITIZE (this);
 102     return TRACE_RETURN (coverage.sanitize (c, this) && deltaGlyphID.sanitize (c));
 103   }
 104
 105   protected:
 106   USHORT        format;                 /* Format identifier--format = 1 */
 107   OffsetTo<Coverage>
 108                 coverage;               /* Offset to Coverage table--from
 109                                          * beginning of Substitution table */
 110   SHORT         deltaGlyphID;           /* Add to original GlyphID to get
 111                                          * substitute GlyphID */
 112   public:
 113   DEFINE_SIZE_STATIC (6);
 114 };
 115
 116 struct SingleSubstFormat2
 117 {
 118   inline void closure (hb_closure_context_t *c) const
 119   {
 120     TRACE_CLOSURE (this);
 121     Coverage::Iter iter;
 122     for (iter.init (this+coverage); iter.more (); iter.next ()) {
 123       if (c->glyphs->has (iter.get_glyph ()))
 124         c->glyphs->add (substitute[iter.get_coverage ()]);
 125     }
 126   }
 127
 128   inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
 129   {
 130     TRACE_COLLECT_GLYPHS (this);
 131     Coverage::Iter iter;
 132     for (iter.init (this+coverage); iter.more (); iter.next ()) {
 133       c->input->add (iter.get_glyph ());
 134       c->output->add (substitute[iter.get_coverage ()]);
 135     }
 136   }
 137
 138   inline const Coverage &get_coverage (void) const
 139   {
 140     return this+coverage;
 141   }
 142
 143   inline bool would_apply (hb_would_apply_context_t *c) const
 144   {
 145     TRACE_WOULD_APPLY (this);
 146     return TRACE_RETURN (c->len == 1 && (this+coverage).get_coverage (c->glyphs[0]) != NOT_COVERED);
 147   }
 148
 149   inline bool apply (hb_apply_context_t *c) const
 150   {
 151     TRACE_APPLY (this);
 152     hb_codepoint_t glyph_id = c->buffer->cur().codepoint;
 153     unsigned int index = (this+coverage).get_coverage (glyph_id);
 154     if (likely (index == NOT_COVERED)) return TRACE_RETURN (false);
 155
 156     if (unlikely (index >= substitute.len)) return TRACE_RETURN (false);
 157
 158     glyph_id = substitute[index];
 159     c->replace_glyph (glyph_id);
 160
 161     return TRACE_RETURN (true);
 162   }
 163
 164   inline bool serialize (hb_serialize_context_t *c,
 165                          Supplier<GlyphID> &glyphs,
 166                          Supplier<GlyphID> &substitutes,
 167                          unsigned int num_glyphs)
 168   {
 169     TRACE_SERIALIZE (this);
 170     if (unlikely (!c->extend_min (*this))) return TRACE_RETURN (false);
 171     if (unlikely (!substitute.serialize (c, substitutes, num_glyphs))) return TRACE_RETURN (false);
 172     if (unlikely (!coverage.serialize (c, this).serialize (c, glyphs, num_glyphs))) return TRACE_RETURN (false);
 173     return TRACE_RETURN (true);
 174   }
 175
 176   inline bool sanitize (hb_sanitize_context_t *c) {
 177     TRACE_SANITIZE (this);
 178     return TRACE_RETURN (coverage.sanitize (c, this) && substitute.sanitize (c));
 179   }
 180
 181   protected:
 182   USHORT        format;                 /* Format identifier--format = 2 */
 183   OffsetTo<Coverage>
 184                 coverage;               /* Offset to Coverage table--from
 185                                          * beginning of Substitution table */
 186   ArrayOf<GlyphID>
 187                 substitute;             /* Array of substitute
 188                                          * GlyphIDs--ordered by Coverage Index */
 189   public:
 190   DEFINE_SIZE_ARRAY (6, substitute);
 191 };
 192
 193 struct SingleSubst
 194 {
 195   inline bool serialize (hb_serialize_context_t *c,
 196                          Supplier<GlyphID> &glyphs,
 197                          Supplier<GlyphID> &substitutes,
 198                          unsigned int num_glyphs)
 199   {
 200     TRACE_SERIALIZE (this);
 201     if (unlikely (!c->extend_min (u.format))) return TRACE_RETURN (false);
 202     unsigned int format = 2;
 203     int delta;
 204     if (num_glyphs) {
 205       format = 1;
 206       /* TODO(serialize) check for wrap-around */
 207       delta = substitutes[0] - glyphs[0];
 208       for (unsigned int i = 1; i < num_glyphs; i++)
 209         if (delta != substitutes[i] - glyphs[i]) {
 210           format = 2;
 211           break;
 212         }
 213     }
 214     u.format.set (format);
 215     switch (u.format) {
 216     case 1: return TRACE_RETURN (u.format1.serialize (c, glyphs, num_glyphs, delta));
 217     case 2: return TRACE_RETURN (u.format2.serialize (c, glyphs, substitutes, num_glyphs));
 218     default:return TRACE_RETURN (false);
 219     }
 220   }
 221
 222   template <typename context_t>
 223   inline typename context_t::return_t dispatch (context_t *c) const
 224   {
 225     TRACE_DISPATCH (this);
 226     switch (u.format) {
 227     case 1: return TRACE_RETURN (c->dispatch (u.format1));
 228     case 2: return TRACE_RETURN (c->dispatch (u.format2));
 229     default:return TRACE_RETURN (c->default_return_value ());
 230     }
 231   }
 232
 233   inline bool sanitize (hb_sanitize_context_t *c) {
 234     TRACE_SANITIZE (this);
 235     if (!u.format.sanitize (c)) return TRACE_RETURN (false);
 236     switch (u.format) {
 237     case 1: return TRACE_RETURN (u.format1.sanitize (c));
 238     case 2: return TRACE_RETURN (u.format2.sanitize (c));
 239     default:return TRACE_RETURN (true);
 240     }
 241   }
 242
 243   protected:
 244   union {
 245   USHORT                format;         /* Format identifier */
 246   SingleSubstFormat1    format1;
 247   SingleSubstFormat2    format2;
 248   } u;
 249 };
 250
 251
 252 struct Sequence
 253 {
 254   inline void closure (hb_closure_context_t *c) const
 255   {
 256     TRACE_CLOSURE (this);
 257     unsigned int count = substitute.len;
 258     for (unsigned int i = 0; i < count; i++)
 259       c->glyphs->add (substitute[i]);
 260   }
 261
 262   inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
 263   {
 264     TRACE_COLLECT_GLYPHS (this);
 265     unsigned int count = substitute.len;
 266     for (unsigned int i = 0; i < count; i++)
 267       c->output->add (substitute[i]);
 268   }
 269
 270   inline bool apply (hb_apply_context_t *c) const
 271   {
 272     TRACE_APPLY (this);
 273     unsigned int count = substitute.len;
 274
 275     /* TODO:
 276      * Testing shows that Uniscribe actually allows zero-len susbstitute,
 277      * which essentially deletes a glyph.  We don't allow for now.  It
 278      * can be confusing to the client since the cluster from the deleted
 279      * glyph won't be merged with any output cluster...  Also, currently
 280      * buffer->move_to() makes assumptions about this too.  Perhaps fix
 281      * in the future after figuring out what to do with the clusters.
 282      */
 283     if (unlikely (!count)) return TRACE_RETURN (false);
 284
 285     /* Special-case to make it in-place and not consider this
 286      * as a "multiplied" substitution. */
 287     if (unlikely (count == 1))
 288     {
 289       c->replace_glyph (substitute.array[0]);
 290       return TRACE_RETURN (true);
 291     }
 292
 293     unsigned int klass = _hb_glyph_info_is_ligature (&c->buffer->cur()) ?
 294                          HB_OT_LAYOUT_GLYPH_PROPS_BASE_GLYPH : 0;
 295
 296     for (unsigned int i = 0; i < count; i++) {
 297       _hb_glyph_info_set_lig_props_for_component (&c->buffer->cur(), i);
 298       c->output_glyph_for_component (substitute.array[i], klass);
 299     }
 300     c->buffer->skip_glyph ();
 301
 302     return TRACE_RETURN (true);
 303   }
 304
 305   inline bool serialize (hb_serialize_context_t *c,
 306                          Supplier<GlyphID> &glyphs,
 307                          unsigned int num_glyphs)
 308   {
 309     TRACE_SERIALIZE (this);
 310     if (unlikely (!c->extend_min (*this))) return TRACE_RETURN (false);
 311     if (unlikely (!substitute.serialize (c, glyphs, num_glyphs))) return TRACE_RETURN (false);
 312     return TRACE_RETURN (true);
 313   }
 314
 315   inline bool sanitize (hb_sanitize_context_t *c) {
 316     TRACE_SANITIZE (this);
 317     return TRACE_RETURN (substitute.sanitize (c));
 318   }
 319
 320   protected:
 321   ArrayOf<GlyphID>
 322                 substitute;             /* String of GlyphIDs to substitute */
 323   public:
 324   DEFINE_SIZE_ARRAY (2, substitute);
 325 };
 326
 327 struct MultipleSubstFormat1
 328 {
 329   inline void closure (hb_closure_context_t *c) const
 330   {
 331     TRACE_CLOSURE (this);
 332     Coverage::Iter iter;
 333     for (iter.init (this+coverage); iter.more (); iter.next ()) {
 334       if (c->glyphs->has (iter.get_glyph ()))
 335         (this+sequence[iter.get_coverage ()]).closure (c);
 336     }
 337   }
 338
 339   inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
 340   {
 341     TRACE_COLLECT_GLYPHS (this);
 342     (this+coverage).add_coverage (c->input);
 343     unsigned int count = sequence.len;
 344     for (unsigned int i = 0; i < count; i++)
 345         (this+sequence[i]).collect_glyphs (c);
 346   }
 347
 348   inline const Coverage &get_coverage (void) const
 349   {
 350     return this+coverage;
 351   }
 352
 353   inline bool would_apply (hb_would_apply_context_t *c) const
 354   {
 355     TRACE_WOULD_APPLY (this);
 356     return TRACE_RETURN (c->len == 1 && (this+coverage).get_coverage (c->glyphs[0]) != NOT_COVERED);
 357   }
 358
 359   inline bool apply (hb_apply_context_t *c) const
 360   {
 361     TRACE_APPLY (this);
 362
 363     unsigned int index = (this+coverage).get_coverage (c->buffer->cur().codepoint);
 364     if (likely (index == NOT_COVERED)) return TRACE_RETURN (false);
 365
 366     return TRACE_RETURN ((this+sequence[index]).apply (c));
 367   }
 368
 369   inline bool serialize (hb_serialize_context_t *c,
 370                          Supplier<GlyphID> &glyphs,
 371                          Supplier<unsigned int> &substitute_len_list,
 372                          unsigned int num_glyphs,
 373                          Supplier<GlyphID> &substitute_glyphs_list)
 374   {
 375     TRACE_SERIALIZE (this);
 376     if (unlikely (!c->extend_min (*this))) return TRACE_RETURN (false);
 377     if (unlikely (!sequence.serialize (c, num_glyphs))) return TRACE_RETURN (false);
 378     for (unsigned int i = 0; i < num_glyphs; i++)
 379       if (unlikely (!sequence[i].serialize (c, this).serialize (c,
 380                                                                 substitute_glyphs_list,
 381                                                                 substitute_len_list[i]))) return TRACE_RETURN (false);
 382     substitute_len_list.advance (num_glyphs);
 383     if (unlikely (!coverage.serialize (c, this).serialize (c, glyphs, num_glyphs))) return TRACE_RETURN (false);
 384     return TRACE_RETURN (true);
 385   }
 386
 387   inline bool sanitize (hb_sanitize_context_t *c) {
 388     TRACE_SANITIZE (this);
 389     return TRACE_RETURN (coverage.sanitize (c, this) && sequence.sanitize (c, this));
 390   }
 391
 392   protected:
 393   USHORT        format;                 /* Format identifier--format = 1 */
 394   OffsetTo<Coverage>
 395                 coverage;               /* Offset to Coverage table--from
 396                                          * beginning of Substitution table */
 397   OffsetArrayOf<Sequence>
 398                 sequence;               /* Array of Sequence tables
 399                                          * ordered by Coverage Index */
 400   public:
 401   DEFINE_SIZE_ARRAY (6, sequence);
 402 };
 403
 404 struct MultipleSubst
 405 {
 406   inline bool serialize (hb_serialize_context_t *c,
 407                          Supplier<GlyphID> &glyphs,
 408                          Supplier<unsigned int> &substitute_len_list,
 409                          unsigned int num_glyphs,
 410                          Supplier<GlyphID> &substitute_glyphs_list)
 411   {
 412     TRACE_SERIALIZE (this);
 413     if (unlikely (!c->extend_min (u.format))) return TRACE_RETURN (false);
 414     unsigned int format = 1;
 415     u.format.set (format);
 416     switch (u.format) {
 417     case 1: return TRACE_RETURN (u.format1.serialize (c, glyphs, substitute_len_list, num_glyphs, substitute_glyphs_list));
 418     default:return TRACE_RETURN (false);
 419     }
 420   }
 421
 422   template <typename context_t>
 423   inline typename context_t::return_t dispatch (context_t *c) const
 424   {
 425     TRACE_DISPATCH (this);
 426     switch (u.format) {
 427     case 1: return TRACE_RETURN (c->dispatch (u.format1));
 428     default:return TRACE_RETURN (c->default_return_value ());
 429     }
 430   }
 431
 432   inline bool sanitize (hb_sanitize_context_t *c) {
 433     TRACE_SANITIZE (this);
 434     if (!u.format.sanitize (c)) return TRACE_RETURN (false);
 435     switch (u.format) {
 436     case 1: return TRACE_RETURN (u.format1.sanitize (c));
 437     default:return TRACE_RETURN (true);
 438     }
 439   }
 440
 441   protected:
 442   union {
 443   USHORT                format;         /* Format identifier */
 444   MultipleSubstFormat1  format1;
 445   } u;
 446 };
 447
 448
 449 typedef ArrayOf<GlyphID> AlternateSet;  /* Array of alternate GlyphIDs--in
 450                                          * arbitrary order */
 451
 452 struct AlternateSubstFormat1
 453 {
 454   inline void closure (hb_closure_context_t *c) const
 455   {
 456     TRACE_CLOSURE (this);
 457     Coverage::Iter iter;
 458     for (iter.init (this+coverage); iter.more (); iter.next ()) {
 459       if (c->glyphs->has (iter.get_glyph ())) {
 460         const AlternateSet &alt_set = this+alternateSet[iter.get_coverage ()];
 461         unsigned int count = alt_set.len;
 462         for (unsigned int i = 0; i < count; i++)
 463           c->glyphs->add (alt_set[i]);
 464       }
 465     }
 466   }
 467
 468   inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
 469   {
 470     TRACE_COLLECT_GLYPHS (this);
 471     Coverage::Iter iter;
 472     for (iter.init (this+coverage); iter.more (); iter.next ()) {
 473       c->input->add (iter.get_glyph ());
 474       const AlternateSet &alt_set = this+alternateSet[iter.get_coverage ()];
 475       unsigned int count = alt_set.len;
 476       for (unsigned int i = 0; i < count; i++)
 477         c->output->add (alt_set[i]);
 478     }
 479   }
 480
 481   inline const Coverage &get_coverage (void) const
 482   {
 483     return this+coverage;
 484   }
 485
 486   inline bool would_apply (hb_would_apply_context_t *c) const
 487   {
 488     TRACE_WOULD_APPLY (this);
 489     return TRACE_RETURN (c->len == 1 && (this+coverage).get_coverage (c->glyphs[0]) != NOT_COVERED);
 490   }
 491
 492   inline bool apply (hb_apply_context_t *c) const
 493   {
 494     TRACE_APPLY (this);
 495     hb_codepoint_t glyph_id = c->buffer->cur().codepoint;
 496
 497     unsigned int index = (this+coverage).get_coverage (glyph_id);
 498     if (likely (index == NOT_COVERED)) return TRACE_RETURN (false);
 499
 500     const AlternateSet &alt_set = this+alternateSet[index];
 501
 502     if (unlikely (!alt_set.len)) return TRACE_RETURN (false);
 503
 504     hb_mask_t glyph_mask = c->buffer->cur().mask;
 505     hb_mask_t lookup_mask = c->lookup_mask;
 506
 507     /* Note: This breaks badly if two features enabled this lookup together. */
 508     unsigned int shift = _hb_ctz (lookup_mask);
 509     unsigned int alt_index = ((lookup_mask & glyph_mask) >> shift);
 510
 511     if (unlikely (alt_index > alt_set.len || alt_index == 0)) return TRACE_RETURN (false);
 512
 513     glyph_id = alt_set[alt_index - 1];
 514
 515     c->replace_glyph (glyph_id);
 516
 517     return TRACE_RETURN (true);
 518   }
 519
 520   inline bool serialize (hb_serialize_context_t *c,
 521                          Supplier<GlyphID> &glyphs,
 522                          Supplier<unsigned int> &alternate_len_list,
 523                          unsigned int num_glyphs,
 524                          Supplier<GlyphID> &alternate_glyphs_list)
 525   {
 526     TRACE_SERIALIZE (this);
 527     if (unlikely (!c->extend_min (*this))) return TRACE_RETURN (false);
 528     if (unlikely (!alternateSet.serialize (c, num_glyphs))) return TRACE_RETURN (false);
 529     for (unsigned int i = 0; i < num_glyphs; i++)
 530       if (unlikely (!alternateSet[i].serialize (c, this).serialize (c,
 531                                                                     alternate_glyphs_list,
 532                                                                     alternate_len_list[i]))) return TRACE_RETURN (false);
 533     alternate_len_list.advance (num_glyphs);
 534     if (unlikely (!coverage.serialize (c, this).serialize (c, glyphs, num_glyphs))) return TRACE_RETURN (false);
 535     return TRACE_RETURN (true);
 536   }
 537
 538   inline bool sanitize (hb_sanitize_context_t *c) {
 539     TRACE_SANITIZE (this);
 540     return TRACE_RETURN (coverage.sanitize (c, this) && alternateSet.sanitize (c, this));
 541   }
 542
 543   protected:
 544   USHORT        format;                 /* Format identifier--format = 1 */
 545   OffsetTo<Coverage>
 546                 coverage;               /* Offset to Coverage table--from
 547                                          * beginning of Substitution table */
 548   OffsetArrayOf<AlternateSet>
 549                 alternateSet;           /* Array of AlternateSet tables
 550                                          * ordered by Coverage Index */
 551   public:
 552   DEFINE_SIZE_ARRAY (6, alternateSet);
 553 };
 554
 555 struct AlternateSubst
 556 {
 557   inline bool serialize (hb_serialize_context_t *c,
 558                          Supplier<GlyphID> &glyphs,
 559                          Supplier<unsigned int> &alternate_len_list,
 560                          unsigned int num_glyphs,
 561                          Supplier<GlyphID> &alternate_glyphs_list)
 562   {
 563     TRACE_SERIALIZE (this);
 564     if (unlikely (!c->extend_min (u.format))) return TRACE_RETURN (false);
 565     unsigned int format = 1;
 566     u.format.set (format);
 567     switch (u.format) {
 568     case 1: return TRACE_RETURN (u.format1.serialize (c, glyphs, alternate_len_list, num_glyphs, alternate_glyphs_list));
 569     default:return TRACE_RETURN (false);
 570     }
 571   }
 572
 573   template <typename context_t>
 574   inline typename context_t::return_t dispatch (context_t *c) const
 575   {
 576     TRACE_DISPATCH (this);
 577     switch (u.format) {
 578     case 1: return TRACE_RETURN (c->dispatch (u.format1));
 579     default:return TRACE_RETURN (c->default_return_value ());
 580     }
 581   }
 582
 583   inline bool sanitize (hb_sanitize_context_t *c) {
 584     TRACE_SANITIZE (this);
 585     if (!u.format.sanitize (c)) return TRACE_RETURN (false);
 586     switch (u.format) {
 587     case 1: return TRACE_RETURN (u.format1.sanitize (c));
 588     default:return TRACE_RETURN (true);
 589     }
 590   }
 591
 592   protected:
 593   union {
 594   USHORT                format;         /* Format identifier */
 595   AlternateSubstFormat1 format1;
 596   } u;
 597 };
 598
 599
 600 struct Ligature
 601 {
 602   inline void closure (hb_closure_context_t *c) const
 603   {
 604     TRACE_CLOSURE (this);
 605     unsigned int count = component.len;
 606     for (unsigned int i = 1; i < count; i++)
 607       if (!c->glyphs->has (component[i]))
 608         return;
 609     c->glyphs->add (ligGlyph);
 610   }
 611
 612   inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
 613   {
 614     TRACE_COLLECT_GLYPHS (this);
 615     unsigned int count = component.len;
 616     for (unsigned int i = 1; i < count; i++)
 617       c->input->add (component[i]);
 618     c->output->add (ligGlyph);
 619   }
 620
 621   inline bool would_apply (hb_would_apply_context_t *c) const
 622   {
 623     TRACE_WOULD_APPLY (this);
 624     if (c->len != component.len)
 625       return TRACE_RETURN (false);
 626
 627     for (unsigned int i = 1; i < c->len; i++)
 628       if (likely (c->glyphs[i] != component[i]))
 629         return TRACE_RETURN (false);
 630
 631     return TRACE_RETURN (true);
 632   }
 633
 634   inline bool apply (hb_apply_context_t *c) const
 635   {
 636     TRACE_APPLY (this);
 637     unsigned int count = component.len;
 638
 639     if (unlikely (!count)) return TRACE_RETURN (false);
 640
 641     /* Special-case to make it in-place and not consider this
 642      * as a "ligated" substitution. */
 643     if (unlikely (count == 1))
 644     {
 645       c->replace_glyph (ligGlyph);
 646       return TRACE_RETURN (true);
 647     }
 648
 649     bool is_mark_ligature = false;
 650     unsigned int total_component_count = 0;
 651
 652     unsigned int match_length = 0;
 653     unsigned int match_positions[MAX_CONTEXT_LENGTH];
 654
 655     if (likely (!match_input (c, count,
 656                               &component[1],
 657                               match_glyph,
 658                               NULL,
 659                               &match_length,
 660                               match_positions,
 661                               &is_mark_ligature,
 662                               &total_component_count)))
 663       return TRACE_RETURN (false);
 664
 665     ligate_input (c,
 666                   count,
 667                   match_positions,
 668                   match_length,
 669                   ligGlyph,
 670                   is_mark_ligature,
 671                   total_component_count);
 672
 673     return TRACE_RETURN (true);
 674   }
 675
 676   inline bool serialize (hb_serialize_context_t *c,
 677                          GlyphID ligature,
 678                          Supplier<GlyphID> &components, /* Starting from second */
 679                          unsigned int num_components /* Including first component */)
 680   {
 681     TRACE_SERIALIZE (this);
 682     if (unlikely (!c->extend_min (*this))) return TRACE_RETURN (false);
 683     ligGlyph = ligature;
 684     if (unlikely (!component.serialize (c, components, num_components))) return TRACE_RETURN (false);
 685     return TRACE_RETURN (true);
 686   }
 687
 688   public:
 689   inline bool sanitize (hb_sanitize_context_t *c) {
 690     TRACE_SANITIZE (this);
 691     return TRACE_RETURN (ligGlyph.sanitize (c) && component.sanitize (c));
 692   }
 693
 694   protected:
 695   GlyphID       ligGlyph;               /* GlyphID of ligature to substitute */
 696   HeadlessArrayOf<GlyphID>
 697                 component;              /* Array of component GlyphIDs--start
 698                                          * with the second  component--ordered
 699                                          * in writing direction */
 700   public:
 701   DEFINE_SIZE_ARRAY (4, component);
 702 };
 703
 704 struct LigatureSet
 705 {
 706   inline void closure (hb_closure_context_t *c) const
 707   {
 708     TRACE_CLOSURE (this);
 709     unsigned int num_ligs = ligature.len;
 710     for (unsigned int i = 0; i < num_ligs; i++)
 711       (this+ligature[i]).closure (c);
 712   }
 713
 714   inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
 715   {
 716     TRACE_COLLECT_GLYPHS (this);
 717     unsigned int num_ligs = ligature.len;
 718     for (unsigned int i = 0; i < num_ligs; i++)
 719       (this+ligature[i]).collect_glyphs (c);
 720   }
 721
 722   inline bool would_apply (hb_would_apply_context_t *c) const
 723   {
 724     TRACE_WOULD_APPLY (this);
 725     unsigned int num_ligs = ligature.len;
 726     for (unsigned int i = 0; i < num_ligs; i++)
 727     {
 728       const Ligature &lig = this+ligature[i];
 729       if (lig.would_apply (c))
 730         return TRACE_RETURN (true);
 731     }
 732     return TRACE_RETURN (false);
 733   }
 734
 735   inline bool apply (hb_apply_context_t *c) const
 736   {
 737     TRACE_APPLY (this);
 738     unsigned int num_ligs = ligature.len;
 739     for (unsigned int i = 0; i < num_ligs; i++)
 740     {
 741       const Ligature &lig = this+ligature[i];
 742       if (lig.apply (c)) return TRACE_RETURN (true);
 743     }
 744
 745     return TRACE_RETURN (false);
 746   }
 747
 748   inline bool serialize (hb_serialize_context_t *c,
 749                          Supplier<GlyphID> &ligatures,
 750                          Supplier<unsigned int> &component_count_list,
 751                          unsigned int num_ligatures,
 752                          Supplier<GlyphID> &component_list /* Starting from second for each ligature */)
 753   {
 754     TRACE_SERIALIZE (this);
 755     if (unlikely (!c->extend_min (*this))) return TRACE_RETURN (false);
 756     if (unlikely (!ligature.serialize (c, num_ligatures))) return TRACE_RETURN (false);
 757     for (unsigned int i = 0; i < num_ligatures; i++)
 758       if (unlikely (!ligature[i].serialize (c, this).serialize (c,
 759                                                                 ligatures[i],
 760                                                                 component_list,
 761                                                                 component_count_list[i]))) return TRACE_RETURN (false);
 762     ligatures.advance (num_ligatures);
 763     component_count_list.advance (num_ligatures);
 764     return TRACE_RETURN (true);
 765   }
 766
 767   inline bool sanitize (hb_sanitize_context_t *c) {
 768     TRACE_SANITIZE (this);
 769     return TRACE_RETURN (ligature.sanitize (c, this));
 770   }
 771
 772   protected:
 773   OffsetArrayOf<Ligature>
 774                 ligature;               /* Array LigatureSet tables
 775                                          * ordered by preference */
 776   public:
 777   DEFINE_SIZE_ARRAY (2, ligature);
 778 };
 779
 780 struct LigatureSubstFormat1
 781 {
 782   inline void closure (hb_closure_context_t *c) const
 783   {
 784     TRACE_CLOSURE (this);
 785     Coverage::Iter iter;
 786     for (iter.init (this+coverage); iter.more (); iter.next ()) {
 787       if (c->glyphs->has (iter.get_glyph ()))
 788         (this+ligatureSet[iter.get_coverage ()]).closure (c);
 789     }
 790   }
 791
 792   inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
 793   {
 794     TRACE_COLLECT_GLYPHS (this);
 795     Coverage::Iter iter;
 796     for (iter.init (this+coverage); iter.more (); iter.next ()) {
 797       c->input->add (iter.get_glyph ());
 798       (this+ligatureSet[iter.get_coverage ()]).collect_glyphs (c);
 799     }
 800   }
 801
 802   inline const Coverage &get_coverage (void) const
 803   {
 804     return this+coverage;
 805   }
 806
 807   inline bool would_apply (hb_would_apply_context_t *c) const
 808   {
 809     TRACE_WOULD_APPLY (this);
 810     unsigned int index = (this+coverage).get_coverage (c->glyphs[0]);
 811     if (likely (index == NOT_COVERED)) return TRACE_RETURN (false);
 812
 813     const LigatureSet &lig_set = this+ligatureSet[index];
 814     return TRACE_RETURN (lig_set.would_apply (c));
 815   }
 816
 817   inline bool apply (hb_apply_context_t *c) const
 818   {
 819     TRACE_APPLY (this);
 820     hb_codepoint_t glyph_id = c->buffer->cur().codepoint;
 821
 822     unsigned int index = (this+coverage).get_coverage (glyph_id);
 823     if (likely (index == NOT_COVERED)) return TRACE_RETURN (false);
 824
 825     const LigatureSet &lig_set = this+ligatureSet[index];
 826     return TRACE_RETURN (lig_set.apply (c));
 827   }
 828
 829   inline bool serialize (hb_serialize_context_t *c,
 830                          Supplier<GlyphID> &first_glyphs,
 831                          Supplier<unsigned int> &ligature_per_first_glyph_count_list,
 832                          unsigned int num_first_glyphs,
 833                          Supplier<GlyphID> &ligatures_list,
 834                          Supplier<unsigned int> &component_count_list,
 835                          Supplier<GlyphID> &component_list /* Starting from second for each ligature */)
 836   {
 837     TRACE_SERIALIZE (this);
 838     if (unlikely (!c->extend_min (*this))) return TRACE_RETURN (false);
 839     if (unlikely (!ligatureSet.serialize (c, num_first_glyphs))) return TRACE_RETURN (false);
 840     for (unsigned int i = 0; i < num_first_glyphs; i++)
 841       if (unlikely (!ligatureSet[i].serialize (c, this).serialize (c,
 842                                                                    ligatures_list,
 843                                                                    component_count_list,
 844                                                                    ligature_per_first_glyph_count_list[i],
 845                                                                    component_list))) return TRACE_RETURN (false);
 846     ligature_per_first_glyph_count_list.advance (num_first_glyphs);
 847     if (unlikely (!coverage.serialize (c, this).serialize (c, first_glyphs, num_first_glyphs))) return TRACE_RETURN (false);
 848     return TRACE_RETURN (true);
 849   }
 850
 851   inline bool sanitize (hb_sanitize_context_t *c) {
 852     TRACE_SANITIZE (this);
 853     return TRACE_RETURN (coverage.sanitize (c, this) && ligatureSet.sanitize (c, this));
 854   }
 855
 856   protected:
 857   USHORT        format;                 /* Format identifier--format = 1 */
 858   OffsetTo<Coverage>
 859                 coverage;               /* Offset to Coverage table--from
 860                                          * beginning of Substitution table */
 861   OffsetArrayOf<LigatureSet>
 862                 ligatureSet;            /* Array LigatureSet tables
 863                                          * ordered by Coverage Index */
 864   public:
 865   DEFINE_SIZE_ARRAY (6, ligatureSet);
 866 };
 867
 868 struct LigatureSubst
 869 {
 870   inline bool serialize (hb_serialize_context_t *c,
 871                          Supplier<GlyphID> &first_glyphs,
 872                          Supplier<unsigned int> &ligature_per_first_glyph_count_list,
 873                          unsigned int num_first_glyphs,
 874                          Supplier<GlyphID> &ligatures_list,
 875                          Supplier<unsigned int> &component_count_list,
 876                          Supplier<GlyphID> &component_list /* Starting from second for each ligature */)
 877   {
 878     TRACE_SERIALIZE (this);
 879     if (unlikely (!c->extend_min (u.format))) return TRACE_RETURN (false);
 880     unsigned int format = 1;
 881     u.format.set (format);
 882     switch (u.format) {
 883     case 1: return TRACE_RETURN (u.format1.serialize (c, first_glyphs, ligature_per_first_glyph_count_list, num_first_glyphs,
 884                                                       ligatures_list, component_count_list, component_list));
 885     default:return TRACE_RETURN (false);
 886     }
 887   }
 888
 889   template <typename context_t>
 890   inline typename context_t::return_t dispatch (context_t *c) const
 891   {
 892     TRACE_DISPATCH (this);
 893     switch (u.format) {
 894     case 1: return TRACE_RETURN (c->dispatch (u.format1));
 895     default:return TRACE_RETURN (c->default_return_value ());
 896     }
 897   }
 898
 899   inline bool sanitize (hb_sanitize_context_t *c) {
 900     TRACE_SANITIZE (this);
 901     if (!u.format.sanitize (c)) return TRACE_RETURN (false);
 902     switch (u.format) {
 903     case 1: return TRACE_RETURN (u.format1.sanitize (c));
 904     default:return TRACE_RETURN (true);
 905     }
 906   }
 907
 908   protected:
 909   union {
 910   USHORT                format;         /* Format identifier */
 911   LigatureSubstFormat1  format1;
 912   } u;
 913 };
 914
 915
 916 struct ContextSubst : Context {};
 917
 918 struct ChainContextSubst : ChainContext {};
 919
 920 struct ExtensionSubst : Extension<ExtensionSubst>
 921 {
 922   typedef struct SubstLookupSubTable LookupSubTable;
 923
 924   inline bool is_reverse (void) const;
 925 };
 926
 927
 928 struct ReverseChainSingleSubstFormat1
 929 {
 930   inline void closure (hb_closure_context_t *c) const
 931   {
 932     TRACE_CLOSURE (this);
 933     const OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage> > (backtrack);
 934
 935     unsigned int count;
 936
 937     count = backtrack.len;
 938     for (unsigned int i = 0; i < count; i++)
 939       if (!(this+backtrack[i]).intersects (c->glyphs))
 940         return;
 941
 942     count = lookahead.len;
 943     for (unsigned int i = 0; i < count; i++)
 944       if (!(this+lookahead[i]).intersects (c->glyphs))
 945         return;
 946
 947     const ArrayOf<GlyphID> &substitute = StructAfter<ArrayOf<GlyphID> > (lookahead);
 948     Coverage::Iter iter;
 949     for (iter.init (this+coverage); iter.more (); iter.next ()) {
 950       if (c->glyphs->has (iter.get_glyph ()))
 951         c->glyphs->add (substitute[iter.get_coverage ()]);
 952     }
 953   }
 954
 955   inline void collect_glyphs (hb_collect_glyphs_context_t *c) const
 956   {
 957     TRACE_COLLECT_GLYPHS (this);
 958
 959     const OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage> > (backtrack);
 960
 961     unsigned int count;
 962
 963     (this+coverage).add_coverage (c->input);
 964
 965     count = backtrack.len;
 966     for (unsigned int i = 0; i < count; i++)
 967       (this+backtrack[i]).add_coverage (c->before);
 968
 969     count = lookahead.len;
 970     for (unsigned int i = 0; i < count; i++)
 971       (this+lookahead[i]).add_coverage (c->after);
 972
 973     const ArrayOf<GlyphID> &substitute = StructAfter<ArrayOf<GlyphID> > (lookahead);
 974     count = substitute.len;
 975     for (unsigned int i = 0; i < count; i++)
 976       c->output->add (substitute[i]);
 977   }
 978
 979   inline const Coverage &get_coverage (void) const
 980   {
 981     return this+coverage;
 982   }
 983
 984   inline bool would_apply (hb_would_apply_context_t *c) const
 985   {
 986     TRACE_WOULD_APPLY (this);
 987     return TRACE_RETURN (c->len == 1 && (this+coverage).get_coverage (c->glyphs[0]) != NOT_COVERED);
 988   }
 989
 990   inline bool apply (hb_apply_context_t *c) const
 991   {
 992     TRACE_APPLY (this);
 993     if (unlikely (c->nesting_level_left != MAX_NESTING_LEVEL))
 994       return TRACE_RETURN (false); /* No chaining to this type */
 995
 996     unsigned int index = (this+coverage).get_coverage (c->buffer->cur().codepoint);
 997     if (likely (index == NOT_COVERED)) return TRACE_RETURN (false);
 998
 999     const OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage> > (backtrack);
1000     const ArrayOf<GlyphID> &substitute = StructAfter<ArrayOf<GlyphID> > (lookahead);
1001
1002     if (match_backtrack (c,
1003                          backtrack.len, (USHORT *) backtrack.array,
1004                          match_coverage, this) &&
1005         match_lookahead (c,
1006                          lookahead.len, (USHORT *) lookahead.array,
1007                          match_coverage, this,
1008                          1))
1009     {
1010       c->replace_glyph_inplace (substitute[index]);
1011       /* Note: We DON'T decrease buffer->idx.  The main loop does it
1012        * for us.  This is useful for preventing surprises if someone
1013        * calls us through a Context lookup. */
1014       return TRACE_RETURN (true);
1015     }
1016
1017     return TRACE_RETURN (false);
1018   }
1019
1020   inline bool sanitize (hb_sanitize_context_t *c) {
1021     TRACE_SANITIZE (this);
1022     if (!(coverage.sanitize (c, this) && backtrack.sanitize (c, this)))
1023       return TRACE_RETURN (false);
1024     OffsetArrayOf<Coverage> &lookahead = StructAfter<OffsetArrayOf<Coverage> > (backtrack);
1025     if (!lookahead.sanitize (c, this))
1026       return TRACE_RETURN (false);
1027     ArrayOf<GlyphID> &substitute = StructAfter<ArrayOf<GlyphID> > (lookahead);
1028     return TRACE_RETURN (substitute.sanitize (c));
1029   }
1030
1031   protected:
1032   USHORT        format;                 /* Format identifier--format = 1 */
1033   OffsetTo<Coverage>
1034                 coverage;               /* Offset to Coverage table--from
1035                                          * beginning of table */
1036   OffsetArrayOf<Coverage>
1037                 backtrack;              /* Array of coverage tables
1038                                          * in backtracking sequence, in  glyph
1039                                          * sequence order */
1040   OffsetArrayOf<Coverage>
1041                 lookaheadX;             /* Array of coverage tables
1042                                          * in lookahead sequence, in glyph
1043                                          * sequence order */
1044   ArrayOf<GlyphID>
1045                 substituteX;            /* Array of substitute
1046                                          * GlyphIDs--ordered by Coverage Index */
1047   public:
1048   DEFINE_SIZE_MIN (10);
1049 };
1050
1051 struct ReverseChainSingleSubst
1052 {
1053   template <typename context_t>
1054   inline typename context_t::return_t dispatch (context_t *c) const
1055   {
1056     TRACE_DISPATCH (this);
1057     switch (u.format) {
1058     case 1: return TRACE_RETURN (c->dispatch (u.format1));
1059     default:return TRACE_RETURN (c->default_return_value ());
1060     }
1061   }
1062
1063   inline bool sanitize (hb_sanitize_context_t *c) {
1064     TRACE_SANITIZE (this);
1065     if (!u.format.sanitize (c)) return TRACE_RETURN (false);
1066     switch (u.format) {
1067     case 1: return TRACE_RETURN (u.format1.sanitize (c));
1068     default:return TRACE_RETURN (true);
1069     }
1070   }
1071
1072   protected:
1073   union {
1074   USHORT                                format;         /* Format identifier */
1075   ReverseChainSingleSubstFormat1        format1;
1076   } u;
1077 };
1078
1079
1080
1081 /*
1082  * SubstLookup
1083  */
1084
1085 struct SubstLookupSubTable
1086 {
1087   friend struct SubstLookup;
1088
1089   enum Type {
1090     Single              = 1,
1091     Multiple            = 2,
1092     Alternate           = 3,
1093     Ligature            = 4,
1094     Context             = 5,
1095     ChainContext        = 6,
1096     Extension           = 7,
1097     ReverseChainSingle  = 8
1098   };
1099
1100   template <typename context_t>
1101   inline typename context_t::return_t dispatch (context_t *c, unsigned int lookup_type) const
1102   {
1103     TRACE_DISPATCH (this);
1104     switch (lookup_type) {
1105     case Single:                return TRACE_RETURN (u.single.dispatch (c));
1106     case Multiple:              return TRACE_RETURN (u.multiple.dispatch (c));
1107     case Alternate:             return TRACE_RETURN (u.alternate.dispatch (c));
1108     case Ligature:              return TRACE_RETURN (u.ligature.dispatch (c));
1109     case Context:               return TRACE_RETURN (u.context.dispatch (c));
1110     case ChainContext:          return TRACE_RETURN (u.chainContext.dispatch (c));
1111     case Extension:             return TRACE_RETURN (u.extension.dispatch (c));
1112     case ReverseChainSingle:    return TRACE_RETURN (u.reverseChainContextSingle.dispatch (c));
1113     default:                    return TRACE_RETURN (c->default_return_value ());
1114     }
1115   }
1116
1117   inline bool sanitize (hb_sanitize_context_t *c, unsigned int lookup_type) {
1118     TRACE_SANITIZE (this);
1119     if (!u.header.sub_format.sanitize (c))
1120       return TRACE_RETURN (false);
1121     switch (lookup_type) {
1122     case Single:                return TRACE_RETURN (u.single.sanitize (c));
1123     case Multiple:              return TRACE_RETURN (u.multiple.sanitize (c));
1124     case Alternate:             return TRACE_RETURN (u.alternate.sanitize (c));
1125     case Ligature:              return TRACE_RETURN (u.ligature.sanitize (c));
1126     case Context:               return TRACE_RETURN (u.context.sanitize (c));
1127     case ChainContext:          return TRACE_RETURN (u.chainContext.sanitize (c));
1128     case Extension:             return TRACE_RETURN (u.extension.sanitize (c));
1129     case ReverseChainSingle:    return TRACE_RETURN (u.reverseChainContextSingle.sanitize (c));
1130     default:                    return TRACE_RETURN (true);
1131     }
1132   }
1133
1134   protected:
1135   union {
1136   struct {
1137     USHORT                      sub_format;
1138   } header;
1139   SingleSubst                   single;
1140   MultipleSubst                 multiple;
1141   AlternateSubst                alternate;
1142   LigatureSubst                 ligature;
1143   ContextSubst                  context;
1144   ChainContextSubst             chainContext;
1145   ExtensionSubst                extension;
1146   ReverseChainSingleSubst       reverseChainContextSingle;
1147   } u;
1148   public:
1149   DEFINE_SIZE_UNION (2, header.sub_format);
1150 };
1151
1152
1153 struct SubstLookup : Lookup
1154 {
1155   inline const SubstLookupSubTable& get_subtable (unsigned int i) const
1156   { return this+CastR<OffsetArrayOf<SubstLookupSubTable> > (subTable)[i]; }
1157
1158   inline static bool lookup_type_is_reverse (unsigned int lookup_type)
1159   { return lookup_type == SubstLookupSubTable::ReverseChainSingle; }
1160
1161   inline bool is_reverse (void) const
1162   {
1163     unsigned int type = get_type ();
1164     if (unlikely (type == SubstLookupSubTable::Extension))
1165       return CastR<ExtensionSubst> (get_subtable(0)).is_reverse ();
1166     return lookup_type_is_reverse (type);
1167   }
1168
1169   inline hb_closure_context_t::return_t closure (hb_closure_context_t *c) const
1170   {
1171     TRACE_CLOSURE (this);
1172     c->set_recurse_func (dispatch_recurse_func<hb_closure_context_t>);
1173     return TRACE_RETURN (dispatch (c));
1174   }
1175
1176   inline hb_collect_glyphs_context_t::return_t collect_glyphs (hb_collect_glyphs_context_t *c) const
1177   {
1178     TRACE_COLLECT_GLYPHS (this);
1179     c->set_recurse_func (dispatch_recurse_func<hb_collect_glyphs_context_t>);
1180     return TRACE_RETURN (dispatch (c));
1181   }
1182
1183   template <typename set_t>
1184   inline void add_coverage (set_t *glyphs) const
1185   {
1186     hb_get_coverage_context_t c;
1187     const Coverage *last = NULL;
1188     unsigned int count = get_subtable_count ();
1189     for (unsigned int i = 0; i < count; i++) {
1190       const Coverage *coverage = &get_subtable (i).dispatch (&c, get_type ());
1191       if (coverage != last) {
1192         coverage->add_coverage (glyphs);
1193         last = coverage;
1194       }
1195     }
1196   }
1197
1198   inline bool would_apply (hb_would_apply_context_t *c, const hb_set_digest_t *digest) const
1199   {
1200     TRACE_WOULD_APPLY (this);
1201     if (unlikely (!c->len))  return TRACE_RETURN (false);
1202     if (!digest->may_have (c->glyphs[0]))  return TRACE_RETURN (false);
1203       return TRACE_RETURN (dispatch (c));
1204   }
1205
1206   inline bool apply_once (hb_apply_context_t *c) const
1207   {
1208     TRACE_APPLY (this);
1209     if (!c->check_glyph_property (&c->buffer->cur(), c->lookup_props))
1210       return TRACE_RETURN (false);
1211     return TRACE_RETURN (dispatch (c));
1212   }
1213
1214   static bool apply_recurse_func (hb_apply_context_t *c, unsigned int lookup_index);
1215
1216   inline SubstLookupSubTable& serialize_subtable (hb_serialize_context_t *c,
1217                                                   unsigned int i)
1218   { return CastR<OffsetArrayOf<SubstLookupSubTable> > (subTable)[i].serialize (c, this); }
1219
1220   inline bool serialize_single (hb_serialize_context_t *c,
1221                                 uint32_t lookup_props,
1222                                 Supplier<GlyphID> &glyphs,
1223                                 Supplier<GlyphID> &substitutes,
1224                                 unsigned int num_glyphs)
1225   {
1226     TRACE_SERIALIZE (this);
1227     if (unlikely (!Lookup::serialize (c, SubstLookupSubTable::Single, lookup_props, 1))) return TRACE_RETURN (false);
1228     return TRACE_RETURN (serialize_subtable (c, 0).u.single.serialize (c, glyphs, substitutes, num_glyphs));
1229   }
1230
1231   inline bool serialize_multiple (hb_serialize_context_t *c,
1232                                   uint32_t lookup_props,
1233                                   Supplier<GlyphID> &glyphs,
1234                                   Supplier<unsigned int> &substitute_len_list,
1235                                   unsigned int num_glyphs,
1236                                   Supplier<GlyphID> &substitute_glyphs_list)
1237   {
1238     TRACE_SERIALIZE (this);
1239     if (unlikely (!Lookup::serialize (c, SubstLookupSubTable::Multiple, lookup_props, 1))) return TRACE_RETURN (false);
1240     return TRACE_RETURN (serialize_subtable (c, 0).u.multiple.serialize (c, glyphs, substitute_len_list, num_glyphs,
1241                                                                          substitute_glyphs_list));
1242   }
1243
1244   inline bool serialize_alternate (hb_serialize_context_t *c,
1245                                    uint32_t lookup_props,
1246                                    Supplier<GlyphID> &glyphs,
1247                                    Supplier<unsigned int> &alternate_len_list,
1248                                    unsigned int num_glyphs,
1249                                    Supplier<GlyphID> &alternate_glyphs_list)
1250   {
1251     TRACE_SERIALIZE (this);
1252     if (unlikely (!Lookup::serialize (c, SubstLookupSubTable::Alternate, lookup_props, 1))) return TRACE_RETURN (false);
1253     return TRACE_RETURN (serialize_subtable (c, 0).u.alternate.serialize (c, glyphs, alternate_len_list, num_glyphs,
1254                                                                           alternate_glyphs_list));
1255   }
1256
1257   inline bool serialize_ligature (hb_serialize_context_t *c,
1258                                   uint32_t lookup_props,
1259                                   Supplier<GlyphID> &first_glyphs,
1260                                   Supplier<unsigned int> &ligature_per_first_glyph_count_list,
1261                                   unsigned int num_first_glyphs,
1262                                   Supplier<GlyphID> &ligatures_list,
1263                                   Supplier<unsigned int> &component_count_list,
1264                                   Supplier<GlyphID> &component_list /* Starting from second for each ligature */)
1265   {
1266     TRACE_SERIALIZE (this);
1267     if (unlikely (!Lookup::serialize (c, SubstLookupSubTable::Ligature, lookup_props, 1))) return TRACE_RETURN (false);
1268     return TRACE_RETURN (serialize_subtable (c, 0).u.ligature.serialize (c, first_glyphs, ligature_per_first_glyph_count_list, num_first_glyphs,
1269                                                                          ligatures_list, component_count_list, component_list));
1270   }
1271
1272   template <typename context_t>
1273   static inline typename context_t::return_t dispatch_recurse_func (context_t *c, unsigned int lookup_index);
1274
1275   template <typename context_t>
1276   inline typename context_t::return_t dispatch (context_t *c) const
1277   {
1278     TRACE_DISPATCH (this);
1279     unsigned int lookup_type = get_type ();
1280     unsigned int count = get_subtable_count ();
1281     for (unsigned int i = 0; i < count; i++) {
1282       typename context_t::return_t r = get_subtable (i).dispatch (c, lookup_type);
1283       if (c->stop_sublookup_iteration (r))
1284         return TRACE_RETURN (r);
1285     }
1286     return TRACE_RETURN (c->default_return_value ());
1287   }
1288
1289   inline bool sanitize (hb_sanitize_context_t *c)
1290   {
1291     TRACE_SANITIZE (this);
1292     if (unlikely (!Lookup::sanitize (c))) return TRACE_RETURN (false);
1293     OffsetArrayOf<SubstLookupSubTable> &list = CastR<OffsetArrayOf<SubstLookupSubTable> > (subTable);
1294     if (unlikely (!list.sanitize (c, this, get_type ()))) return TRACE_RETURN (false);
1295
1296     if (unlikely (get_type () == SubstLookupSubTable::Extension))
1297     {
1298       /* The spec says all subtables of an Extension lookup should
1299        * have the same type.  This is specially important if one has
1300        * a reverse type! */
1301       unsigned int type = get_subtable (0).u.extension.get_type ();
1302       unsigned int count = get_subtable_count ();
1303       for (unsigned int i = 1; i < count; i++)
1304         if (get_subtable (i).u.extension.get_type () != type)
1305           return TRACE_RETURN (false);
1306     }
1307     return TRACE_RETURN (true);
1308   }
1309 };
1310
1311 typedef OffsetListOf<SubstLookup> SubstLookupList;
1312
1313 /*
1314  * GSUB -- The Glyph Substitution Table
1315  */
1316
1317 struct GSUB : GSUBGPOS
1318 {
1319   static const hb_tag_t tableTag        = HB_OT_TAG_GSUB;
1320
1321   inline const SubstLookup& get_lookup (unsigned int i) const
1322   { return CastR<SubstLookup> (GSUBGPOS::get_lookup (i)); }
1323
1324   static inline void substitute_start (hb_font_t *font, hb_buffer_t *buffer);
1325   static inline void substitute_finish (hb_font_t *font, hb_buffer_t *buffer);
1326
1327   inline bool sanitize (hb_sanitize_context_t *c) {
1328     TRACE_SANITIZE (this);
1329     if (unlikely (!GSUBGPOS::sanitize (c))) return TRACE_RETURN (false);
1330     OffsetTo<SubstLookupList> &list = CastR<OffsetTo<SubstLookupList> > (lookupList);
1331     return TRACE_RETURN (list.sanitize (c, this));
1332   }
1333   public:
1334   DEFINE_SIZE_STATIC (10);
1335 };
1336
1337
1338 void
1339 GSUB::substitute_start (hb_font_t *font, hb_buffer_t *buffer)
1340 {
1341   _hb_buffer_assert_gsubgpos_vars (buffer);
1342
1343   const GDEF &gdef = *hb_ot_layout_from_face (font->face)->gdef;
1344   unsigned int count = buffer->len;
1345   for (unsigned int i = 0; i < count; i++)
1346   {
1347     _hb_glyph_info_set_glyph_props (&buffer->info[i], gdef.get_glyph_props (buffer->info[i].codepoint));
1348     _hb_glyph_info_clear_lig_props (&buffer->info[i]);
1349     buffer->info[i].syllable() = 0;
1350   }
1351 }
1352
1353 void
1354 GSUB::substitute_finish (hb_font_t *font HB_UNUSED, hb_buffer_t *buffer HB_UNUSED)
1355 {
1356 }
1357
1358
1359 /* Out-of-class implementation for methods recursing */
1360
1361 /*static*/ inline bool ExtensionSubst::is_reverse (void) const
1362 {
1363   unsigned int type = get_type ();
1364   if (unlikely (type == SubstLookupSubTable::Extension))
1365     return CastR<ExtensionSubst> (get_subtable<SubstLookupSubTable>()).is_reverse ();
1366   return SubstLookup::lookup_type_is_reverse (type);
1367 }
1368
1369 template <typename context_t>
1370 /*static*/ inline typename context_t::return_t SubstLookup::dispatch_recurse_func (context_t *c, unsigned int lookup_index)
1371 {
1372   const GSUB &gsub = *(hb_ot_layout_from_face (c->face)->gsub);
1373   const SubstLookup &l = gsub.get_lookup (lookup_index);
1374   return l.dispatch (c);
1375 }
1376
1377 /*static*/ inline bool SubstLookup::apply_recurse_func (hb_apply_context_t *c, unsigned int lookup_index)
1378 {
1379   const GSUB &gsub = *(hb_ot_layout_from_face (c->face)->gsub);
1380   const SubstLookup &l = gsub.get_lookup (lookup_index);
1381   unsigned int saved_lookup_props = c->lookup_props;
1382   c->set_lookup (l);
1383   bool ret = l.apply_once (c);
1384   c->lookup_props = saved_lookup_props;
1385   return ret;
1386 }
1387
1388
1389 } /* namespace OT */
1390
1391
1392 #endif /* HB_OT_LAYOUT_GSUB_TABLE_HH */