1 /*

     2  * Copyright © 2007,2008,2009,2010  Red Hat, Inc.

     3  * Copyright © 2010,2012,2013  Google, Inc.

     4  *

     5  *  This is part of HarfBuzz, a text shaping library.

     6  *

     7  * Permission is hereby granted, without written agreement and without

     8  * license or royalty fees, to use, copy, modify, and distribute this

     9  * software and its documentation for any purpose, provided that the

    10  * above copyright notice and the following two paragraphs appear in

    11  * all copies of this software.

    12  *

    13  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR

    14  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES

    15  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN

    16  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH

    17  * DAMAGE.

    18  *

    19  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,

    20  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND

    21  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS

    22  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO

    23  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.

    24  *

    25  * Red Hat Author(s): Behdad Esfahbod

    26  * Google Author(s): Behdad Esfahbod

    27  */

    28 

    29 #ifndef HB_OT_LAYOUT_GPOS_TABLE_HH

    30 #define HB_OT_LAYOUT_GPOS_TABLE_HH

    31 

    32 #include "hb-ot-layout-gsubgpos-private.hh"

    33 

    34 

    35 namespace OT {

    36 

    37 

    38 /* buffer **position** var allocations */

    39 #define attach_lookback() var.u16[0] /* number of glyphs to go back to attach this glyph to its base */

    40 #define cursive_chain() var.i16[1] /* character to which this connects, may be positive or negative */

    41 

    42 

    43 /* Shared Tables: ValueRecord, Anchor Table, and MarkArray */

    44 

    45 typedef USHORT Value;

    46 

    47 typedef Value ValueRecord[VAR];

    48 

    49 struct ValueFormat : USHORT

    50 {

    51   enum Flags {

    52     xPlacement  = 0x0001u,      /* Includes horizontal adjustment for placement */

    53     yPlacement  = 0x0002u,      /* Includes vertical adjustment for placement */

    54     xAdvance    = 0x0004u,      /* Includes horizontal adjustment for advance */

    55     yAdvance    = 0x0008u,      /* Includes vertical adjustment for advance */

    56     xPlaDevice  = 0x0010u,      /* Includes horizontal Device table for placement */

    57     yPlaDevice  = 0x0020u,      /* Includes vertical Device table for placement */

    58     xAdvDevice  = 0x0040u,      /* Includes horizontal Device table for advance */

    59     yAdvDevice  = 0x0080u,      /* Includes vertical Device table for advance */

    60     ignored     = 0x0F00u,      /* Was used in TrueType Open for MM fonts */

    61     reserved    = 0xF000u,      /* For future use */

    62 

    63     devices     = 0x00F0u       /* Mask for having any Device table */

    64   };

    65 

    66 /* All fields are options.  Only those available advance the value pointer. */

    67 #if 0

    68   SHORT         xPlacement;             /* Horizontal adjustment for

    69                                          * placement--in design units */

    70   SHORT         yPlacement;             /* Vertical adjustment for

    71                                          * placement--in design units */

    72   SHORT         xAdvance;               /* Horizontal adjustment for

    73                                          * advance--in design units (only used

    74                                          * for horizontal writing) */

    75   SHORT         yAdvance;               /* Vertical adjustment for advance--in

    76                                          * design units (only used for vertical

    77                                          * writing) */

    78   Offset        xPlaDevice;             /* Offset to Device table for

    79                                          * horizontal placement--measured from

    80                                          * beginning of PosTable (may be NULL) */

    81   Offset        yPlaDevice;             /* Offset to Device table for vertical

    82                                          * placement--measured from beginning

    83                                          * of PosTable (may be NULL) */

    84   Offset        xAdvDevice;             /* Offset to Device table for

    85                                          * horizontal advance--measured from

    86                                          * beginning of PosTable (may be NULL) */

    87   Offset        yAdvDevice;             /* Offset to Device table for vertical

    88                                          * advance--measured from beginning of

    89                                          * PosTable (may be NULL) */

    90 #endif

    91 

    92   inline unsigned int get_len (void) const

    93   { return _hb_popcount32 ((unsigned int) *this); }

    94   inline unsigned int get_size (void) const

    95   { return get_len () * Value::static_size; }

    96 

    97   void apply_value (hb_font_t            *font,

    98                     hb_direction_t        direction,

    99                     const void           *base,

   100                     const Value          *values,

   101                     hb_glyph_position_t  &glyph_pos) const

   102   {

   103     unsigned int x_ppem, y_ppem;

   104     unsigned int format = *this;

   105     hb_bool_t horizontal = HB_DIRECTION_IS_HORIZONTAL (direction);

   106 

   107     if (!format) return;

   108 

   109     if (format & xPlacement) glyph_pos.x_offset  += font->em_scale_x (get_short (values++));

   110     if (format & yPlacement) glyph_pos.y_offset  += font->em_scale_y (get_short (values++));

   111     if (format & xAdvance) {

   112       if (likely (horizontal)) glyph_pos.x_advance += font->em_scale_x (get_short (values));

   113       values++;

   114     }

   115     /* y_advance values grow downward but font-space grows upward, hence negation */

   116     if (format & yAdvance) {

   117       if (unlikely (!horizontal)) glyph_pos.y_advance -= font->em_scale_y (get_short (values));

   118       values++;

   119     }

   120 

   121     if (!has_device ()) return;

   122 

   123     x_ppem = font->x_ppem;

   124     y_ppem = font->y_ppem;

   125 

   126     if (!x_ppem && !y_ppem) return;

   127 

   128     /* pixel -> fractional pixel */

   129     if (format & xPlaDevice) {

   130       if (x_ppem) glyph_pos.x_offset  += (base + get_device (values)).get_x_delta (font);

   131       values++;

   132     }

   133     if (format & yPlaDevice) {

   134       if (y_ppem) glyph_pos.y_offset  += (base + get_device (values)).get_y_delta (font);

   135       values++;

   136     }

   137     if (format & xAdvDevice) {

   138       if (horizontal && x_ppem) glyph_pos.x_advance += (base + get_device (values)).get_x_delta (font);

   139       values++;

   140     }

   141     if (format & yAdvDevice) {

   142       /* y_advance values grow downward but font-space grows upward, hence negation */

   143       if (!horizontal && y_ppem) glyph_pos.y_advance -= (base + get_device (values)).get_y_delta (font);

   144       values++;

   145     }

   146   }

   147 

   148   private:

   149   inline bool sanitize_value_devices (hb_sanitize_context_t *c, const void *base, const Value *values) const

   150   {

   151     unsigned int format = *this;

   152 

   153     if (format & xPlacement) values++;

   154     if (format & yPlacement) values++;

   155     if (format & xAdvance)   values++;

   156     if (format & yAdvance)   values++;

   157 

   158     if ((format & xPlaDevice) && !get_device (values++).sanitize (c, base)) return false;

   159     if ((format & yPlaDevice) && !get_device (values++).sanitize (c, base)) return false;

   160     if ((format & xAdvDevice) && !get_device (values++).sanitize (c, base)) return false;

   161     if ((format & yAdvDevice) && !get_device (values++).sanitize (c, base)) return false;

   162 

   163     return true;

   164   }

   165 

   166   static inline OffsetTo<Device>& get_device (Value* value)

   167   { return *CastP<OffsetTo<Device> > (value); }

   168   static inline const OffsetTo<Device>& get_device (const Value* value)

   169   { return *CastP<OffsetTo<Device> > (value); }

   170 

   171   static inline const SHORT& get_short (const Value* value)

   172   { return *CastP<SHORT> (value); }

   173 

   174   public:

   175 

   176   inline bool has_device (void) const {

   177     unsigned int format = *this;

   178     return (format & devices) != 0;

   179   }

   180 

   181   inline bool sanitize_value (hb_sanitize_context_t *c, const void *base, const Value *values) const

   182   {

   183     TRACE_SANITIZE (this);

   184     return_trace (c->check_range (values, get_size ()) && (!has_device () || sanitize_value_devices (c, base, values)));

   185   }

   186 

   187   inline bool sanitize_values (hb_sanitize_context_t *c, const void *base, const Value *values, unsigned int count) const

   188   {

   189     TRACE_SANITIZE (this);

   190     unsigned int len = get_len ();

   191 

   192     if (!c->check_array (values, get_size (), count)) return_trace (false);

   193 

   194     if (!has_device ()) return_trace (true);

   195 

   196     for (unsigned int i = 0; i < count; i++) {

   197       if (!sanitize_value_devices (c, base, values))

   198         return_trace (false);

   199       values += len;

   200     }

   201 

   202     return_trace (true);

   203   }

   204 

   205   /* Just sanitize referenced Device tables.  Doesn't check the values themselves. */

   206   inline bool sanitize_values_stride_unsafe (hb_sanitize_context_t *c, const void *base, const Value *values, unsigned int count, unsigned int stride) const

   207   {

   208     TRACE_SANITIZE (this);

   209 

   210     if (!has_device ()) return_trace (true);

   211 

   212     for (unsigned int i = 0; i < count; i++) {

   213       if (!sanitize_value_devices (c, base, values))

   214         return_trace (false);

   215       values += stride;

   216     }

   217 

   218     return_trace (true);

   219   }

   220 };

   221 

   222 

   223 struct AnchorFormat1

   224 {

   225   inline void get_anchor (hb_font_t *font, hb_codepoint_t glyph_id HB_UNUSED,

   226                           hb_position_t *x, hb_position_t *y) const

   227   {

   228       *x = font->em_scale_x (xCoordinate);

   229       *y = font->em_scale_y (yCoordinate);

   230   }

   231 

   232   inline bool sanitize (hb_sanitize_context_t *c) const

   233   {

   234     TRACE_SANITIZE (this);

   235     return_trace (c->check_struct (this));

   236   }

   237 

   238   protected:

   239   USHORT        format;                 /* Format identifier--format = 1 */

   240   SHORT         xCoordinate;            /* Horizontal value--in design units */

   241   SHORT         yCoordinate;            /* Vertical value--in design units */

   242   public:

   243   DEFINE_SIZE_STATIC (6);

   244 };

   245 

   246 struct AnchorFormat2

   247 {

   248   inline void get_anchor (hb_font_t *font, hb_codepoint_t glyph_id,

   249                           hb_position_t *x, hb_position_t *y) const

   250   {

   251       unsigned int x_ppem = font->x_ppem;

   252       unsigned int y_ppem = font->y_ppem;

   253       hb_position_t cx, cy;

   254       hb_bool_t ret;

   255 

   256       ret = (x_ppem || y_ppem) &&

   257              font->get_glyph_contour_point_for_origin (glyph_id, anchorPoint, HB_DIRECTION_LTR, &cx, &cy);

   258       *x = ret && x_ppem ? cx : font->em_scale_x (xCoordinate);

   259       *y = ret && y_ppem ? cy : font->em_scale_y (yCoordinate);

   260   }

   261 

   262   inline bool sanitize (hb_sanitize_context_t *c) const

   263   {

   264     TRACE_SANITIZE (this);

   265     return_trace (c->check_struct (this));

   266   }

   267 

   268   protected:

   269   USHORT        format;                 /* Format identifier--format = 2 */

   270   SHORT         xCoordinate;            /* Horizontal value--in design units */

   271   SHORT         yCoordinate;            /* Vertical value--in design units */

   272   USHORT        anchorPoint;            /* Index to glyph contour point */

   273   public:

   274   DEFINE_SIZE_STATIC (8);

   275 };

   276 

   277 struct AnchorFormat3

   278 {

   279   inline void get_anchor (hb_font_t *font, hb_codepoint_t glyph_id HB_UNUSED,

   280                           hb_position_t *x, hb_position_t *y) const

   281   {

   282       *x = font->em_scale_x (xCoordinate);

   283       *y = font->em_scale_y (yCoordinate);

   284 

   285       if (font->x_ppem)

   286         *x += (this+xDeviceTable).get_x_delta (font);

   287       if (font->y_ppem)

   288         *y += (this+yDeviceTable).get_x_delta (font);

   289   }

   290 

   291   inline bool sanitize (hb_sanitize_context_t *c) const

   292   {

   293     TRACE_SANITIZE (this);

   294     return_trace (c->check_struct (this) && xDeviceTable.sanitize (c, this) && yDeviceTable.sanitize (c, this));

   295   }

   296 

   297   protected:

   298   USHORT        format;                 /* Format identifier--format = 3 */

   299   SHORT         xCoordinate;            /* Horizontal value--in design units */

   300   SHORT         yCoordinate;            /* Vertical value--in design units */

   301   OffsetTo<Device>

   302                 xDeviceTable;           /* Offset to Device table for X

   303                                          * coordinate-- from beginning of

   304                                          * Anchor table (may be NULL) */

   305   OffsetTo<Device>

   306                 yDeviceTable;           /* Offset to Device table for Y

   307                                          * coordinate-- from beginning of

   308                                          * Anchor table (may be NULL) */

   309   public:

   310   DEFINE_SIZE_STATIC (10);

   311 };

   312 

   313 struct Anchor

   314 {

   315   inline void get_anchor (hb_font_t *font, hb_codepoint_t glyph_id,

   316                           hb_position_t *x, hb_position_t *y) const

   317   {

   318     *x = *y = 0;

   319     switch (u.format) {

   320     case 1: u.format1.get_anchor (font, glyph_id, x, y); return;

   321     case 2: u.format2.get_anchor (font, glyph_id, x, y); return;

   322     case 3: u.format3.get_anchor (font, glyph_id, x, y); return;

   323     default:                                             return;

   324     }

   325   }

   326 

   327   inline bool sanitize (hb_sanitize_context_t *c) const

   328   {

   329     TRACE_SANITIZE (this);

   330     if (!u.format.sanitize (c)) return_trace (false);

   331     switch (u.format) {

   332     case 1: return_trace (u.format1.sanitize (c));

   333     case 2: return_trace (u.format2.sanitize (c));

   334     case 3: return_trace (u.format3.sanitize (c));

   335     default:return_trace (true);

   336     }

   337   }

   338 

   339   protected:

   340   union {

   341   USHORT                format;         /* Format identifier */

   342   AnchorFormat1         format1;

   343   AnchorFormat2         format2;

   344   AnchorFormat3         format3;

   345   } u;

   346   public:

   347   DEFINE_SIZE_UNION (2, format);

   348 };

   349 

   350 

   351 struct AnchorMatrix

   352 {

   353   inline const Anchor& get_anchor (unsigned int row, unsigned int col, unsigned int cols, bool *found) const {

   354     *found = false;

   355     if (unlikely (row >= rows || col >= cols)) return Null(Anchor);

   356     *found = !matrixZ[row * cols + col].is_null ();

   357     return this+matrixZ[row * cols + col];

   358   }

   359 

   360   inline bool sanitize (hb_sanitize_context_t *c, unsigned int cols) const

   361   {

   362     TRACE_SANITIZE (this);

   363     if (!c->check_struct (this)) return_trace (false);

   364     if (unlikely (rows > 0 && cols >= ((unsigned int) -1) / rows)) return_trace (false);

   365     unsigned int count = rows * cols;

   366     if (!c->check_array (matrixZ, matrixZ[0].static_size, count)) return_trace (false);

   367     for (unsigned int i = 0; i < count; i++)

   368       if (!matrixZ[i].sanitize (c, this)) return_trace (false);

   369     return_trace (true);

   370   }

   371 

   372   USHORT        rows;                   /* Number of rows */

   373   protected:

   374   OffsetTo<Anchor>

   375                 matrixZ[VAR];           /* Matrix of offsets to Anchor tables--

   376                                          * from beginning of AnchorMatrix table */

   377   public:

   378   DEFINE_SIZE_ARRAY (2, matrixZ);

   379 };

   380 

   381 

   382 struct MarkRecord

   383 {

   384   friend struct MarkArray;

   385 

   386   inline bool sanitize (hb_sanitize_context_t *c, const void *base) const

   387   {

   388     TRACE_SANITIZE (this);

   389     return_trace (c->check_struct (this) && markAnchor.sanitize (c, base));

   390   }

   391 

   392   protected:

   393   USHORT        klass;                  /* Class defined for this mark */

   394   OffsetTo<Anchor>

   395                 markAnchor;             /* Offset to Anchor table--from

   396                                          * beginning of MarkArray table */

   397   public:

   398   DEFINE_SIZE_STATIC (4);

   399 };

   400 

   401 struct MarkArray : ArrayOf<MarkRecord>  /* Array of MarkRecords--in Coverage order */

   402 {

   403   inline bool apply (hb_apply_context_t *c,

   404                      unsigned int mark_index, unsigned int glyph_index,

   405                      const AnchorMatrix &anchors, unsigned int class_count,

   406                      unsigned int glyph_pos) const

   407   {

   408     TRACE_APPLY (this);

   409     hb_buffer_t *buffer = c->buffer;

   410     const MarkRecord &record = ArrayOf<MarkRecord>::operator[](mark_index);

   411     unsigned int mark_class = record.klass;

   412 

   413     const Anchor& mark_anchor = this + record.markAnchor;

   414     bool found;

   415     const Anchor& glyph_anchor = anchors.get_anchor (glyph_index, mark_class, class_count, &found);

   416     /* If this subtable doesn't have an anchor for this base and this class,

   417      * return false such that the subsequent subtables have a chance at it. */

   418     if (unlikely (!found)) return_trace (false);

   419 

   420     hb_position_t mark_x, mark_y, base_x, base_y;

   421 

   422     mark_anchor.get_anchor (c->font, buffer->cur().codepoint, &mark_x, &mark_y);

   423     glyph_anchor.get_anchor (c->font, buffer->info[glyph_pos].codepoint, &base_x, &base_y);

   424 

   425     hb_glyph_position_t &o = buffer->cur_pos();

   426     o.x_offset = base_x - mark_x;

   427     o.y_offset = base_y - mark_y;

   428     o.attach_lookback() = buffer->idx - glyph_pos;

   429 

   430     buffer->idx++;

   431     return_trace (true);

   432   }

   433 

   434   inline bool sanitize (hb_sanitize_context_t *c) const

   435   {

   436     TRACE_SANITIZE (this);

   437     return_trace (ArrayOf<MarkRecord>::sanitize (c, this));

   438   }

   439 };

   440 

   441 

   442 /* Lookups */

   443 

   444 struct SinglePosFormat1

   445 {

   446   inline void collect_glyphs (hb_collect_glyphs_context_t *c) const

   447   {

   448     TRACE_COLLECT_GLYPHS (this);

   449     (this+coverage).add_coverage (c->input);

   450   }

   451 

   452   inline const Coverage &get_coverage (void) const

   453   {

   454     return this+coverage;

   455   }

   456 

   457   inline bool apply (hb_apply_context_t *c) const

   458   {

   459     TRACE_APPLY (this);

   460     hb_buffer_t *buffer = c->buffer;

   461     unsigned int index = (this+coverage).get_coverage  (buffer->cur().codepoint);

   462     if (likely (index == NOT_COVERED)) return_trace (false);

   463 

   464     valueFormat.apply_value (c->font, c->direction, this,

   465                              values, buffer->cur_pos());

   466 

   467     buffer->idx++;

   468     return_trace (true);

   469   }

   470 

   471   inline bool sanitize (hb_sanitize_context_t *c) const

   472   {

   473     TRACE_SANITIZE (this);

   474     return_trace (c->check_struct (this) &&

   475                   coverage.sanitize (c, this) &&

   476                   valueFormat.sanitize_value (c, this, values));

   477   }

   478 

   479   protected:

   480   USHORT        format;                 /* Format identifier--format = 1 */

   481   OffsetTo<Coverage>

   482                 coverage;               /* Offset to Coverage table--from

   483                                          * beginning of subtable */

   484   ValueFormat   valueFormat;            /* Defines the types of data in the

   485                                          * ValueRecord */

   486   ValueRecord   values;                 /* Defines positioning

   487                                          * value(s)--applied to all glyphs in

   488                                          * the Coverage table */

   489   public:

   490   DEFINE_SIZE_ARRAY (6, values);

   491 };

   492 

   493 struct SinglePosFormat2

   494 {

   495   inline void collect_glyphs (hb_collect_glyphs_context_t *c) const

   496   {

   497     TRACE_COLLECT_GLYPHS (this);

   498     (this+coverage).add_coverage (c->input);

   499   }

   500 

   501   inline const Coverage &get_coverage (void) const

   502   {

   503     return this+coverage;

   504   }

   505 

   506   inline bool apply (hb_apply_context_t *c) const

   507   {

   508     TRACE_APPLY (this);

   509     hb_buffer_t *buffer = c->buffer;

   510     unsigned int index = (this+coverage).get_coverage  (buffer->cur().codepoint);

   511     if (likely (index == NOT_COVERED)) return_trace (false);

   512 

   513     if (likely (index >= valueCount)) return_trace (false);

   514 

   515     valueFormat.apply_value (c->font, c->direction, this,

   516                              &values[index * valueFormat.get_len ()],

   517                              buffer->cur_pos());

   518 

   519     buffer->idx++;

   520     return_trace (true);

   521   }

   522 

   523   inline bool sanitize (hb_sanitize_context_t *c) const

   524   {

   525     TRACE_SANITIZE (this);

   526     return_trace (c->check_struct (this) &&

   527                   coverage.sanitize (c, this) &&

   528                   valueFormat.sanitize_values (c, this, values, valueCount));

   529   }

   530 

   531   protected:

   532   USHORT        format;                 /* Format identifier--format = 2 */

   533   OffsetTo<Coverage>

   534                 coverage;               /* Offset to Coverage table--from

   535                                          * beginning of subtable */

   536   ValueFormat   valueFormat;            /* Defines the types of data in the

   537                                          * ValueRecord */

   538   USHORT        valueCount;             /* Number of ValueRecords */

   539   ValueRecord   values;                 /* Array of ValueRecords--positioning

   540                                          * values applied to glyphs */

   541   public:

   542   DEFINE_SIZE_ARRAY (8, values);

   543 };

   544 

   545 struct SinglePos

   546 {

   547   template <typename context_t>

   548   inline typename context_t::return_t dispatch (context_t *c) const

   549   {

   550     TRACE_DISPATCH (this, u.format);

   551     if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ());

   552     switch (u.format) {

   553     case 1: return_trace (c->dispatch (u.format1));

   554     case 2: return_trace (c->dispatch (u.format2));

   555     default:return_trace (c->default_return_value ());

   556     }

   557   }

   558 

   559   protected:

   560   union {

   561   USHORT                format;         /* Format identifier */

   562   SinglePosFormat1      format1;

   563   SinglePosFormat2      format2;

   564   } u;

   565 };

   566 

   567 

   568 struct PairValueRecord

   569 {

   570   friend struct PairSet;

   571 

   572   protected:

   573   GlyphID       secondGlyph;            /* GlyphID of second glyph in the

   574                                          * pair--first glyph is listed in the

   575                                          * Coverage table */

   576   ValueRecord   values;                 /* Positioning data for the first glyph

   577                                          * followed by for second glyph */

   578   public:

   579   DEFINE_SIZE_ARRAY (2, values);

   580 };

   581 

   582 struct PairSet

   583 {

   584   friend struct PairPosFormat1;

   585 

   586   inline void collect_glyphs (hb_collect_glyphs_context_t *c,

   587                               const ValueFormat *valueFormats) const

   588   {

   589     TRACE_COLLECT_GLYPHS (this);

   590     unsigned int len1 = valueFormats[0].get_len ();

   591     unsigned int len2 = valueFormats[1].get_len ();

   592     unsigned int record_size = USHORT::static_size * (1 + len1 + len2);

   593 

   594     const PairValueRecord *record = CastP<PairValueRecord> (arrayZ);

   595     unsigned int count = len;

   596     for (unsigned int i = 0; i < count; i++)

   597     {

   598       c->input->add (record->secondGlyph);

   599       record = &StructAtOffset<PairValueRecord> (record, record_size);

   600     }

   601   }

   602 

   603   inline bool apply (hb_apply_context_t *c,

   604                      const ValueFormat *valueFormats,

   605                      unsigned int pos) const

   606   {

   607     TRACE_APPLY (this);

   608     hb_buffer_t *buffer = c->buffer;

   609     unsigned int len1 = valueFormats[0].get_len ();

   610     unsigned int len2 = valueFormats[1].get_len ();

   611     unsigned int record_size = USHORT::static_size * (1 + len1 + len2);

   612 

   613     const PairValueRecord *record_array = CastP<PairValueRecord> (arrayZ);

   614     unsigned int count = len;

   615 

   616     /* Hand-coded bsearch. */

   617     if (unlikely (!count))

   618       return_trace (false);

   619     hb_codepoint_t x = buffer->info[pos].codepoint;

   620     int min = 0, max = (int) count - 1;

   621     while (min <= max)

   622     {

   623       int mid = (min + max) / 2;

   624       const PairValueRecord *record = &StructAtOffset<PairValueRecord> (record_array, record_size * mid);

   625       hb_codepoint_t mid_x = record->secondGlyph;

   626       if (x < mid_x)

   627         max = mid - 1;

   628       else if (x > mid_x)

   629         min = mid + 1;

   630       else

   631       {

   632         valueFormats[0].apply_value (c->font, c->direction, this,

   633                                      &record->values[0], buffer->cur_pos());

   634         valueFormats[1].apply_value (c->font, c->direction, this,

   635                                      &record->values[len1], buffer->pos[pos]);

   636         if (len2)

   637           pos++;

   638         buffer->idx = pos;

   639         return_trace (true);

   640       }

   641     }

   642 

   643     return_trace (false);

   644   }

   645 

   646   struct sanitize_closure_t {

   647     const void *base;

   648     const ValueFormat *valueFormats;

   649     unsigned int len1; /* valueFormats[0].get_len() */

   650     unsigned int stride; /* 1 + len1 + len2 */

   651   };

   652 

   653   inline bool sanitize (hb_sanitize_context_t *c, const sanitize_closure_t *closure) const

   654   {

   655     TRACE_SANITIZE (this);

   656     if (!(c->check_struct (this)

   657        && c->check_array (arrayZ, USHORT::static_size * closure->stride, len))) return_trace (false);

   658 

   659     unsigned int count = len;

   660     const PairValueRecord *record = CastP<PairValueRecord> (arrayZ);

   661     return_trace (closure->valueFormats[0].sanitize_values_stride_unsafe (c, closure->base, &record->values[0], count, closure->stride) &&

   662                   closure->valueFormats[1].sanitize_values_stride_unsafe (c, closure->base, &record->values[closure->len1], count, closure->stride));

   663   }

   664 

   665   protected:

   666   USHORT        len;                    /* Number of PairValueRecords */

   667   USHORT        arrayZ[VAR];            /* Array of PairValueRecords--ordered

   668                                          * by GlyphID of the second glyph */

   669   public:

   670   DEFINE_SIZE_ARRAY (2, arrayZ);

   671 };

   672 

   673 struct PairPosFormat1

   674 {

   675   inline void collect_glyphs (hb_collect_glyphs_context_t *c) const

   676   {

   677     TRACE_COLLECT_GLYPHS (this);

   678     (this+coverage).add_coverage (c->input);

   679     unsigned int count = pairSet.len;

   680     for (unsigned int i = 0; i < count; i++)

   681       (this+pairSet[i]).collect_glyphs (c, &valueFormat1);

   682   }

   683 

   684   inline const Coverage &get_coverage (void) const

   685   {

   686     return this+coverage;

   687   }

   688 

   689   inline bool apply (hb_apply_context_t *c) const

   690   {

   691     TRACE_APPLY (this);

   692     hb_buffer_t *buffer = c->buffer;

   693     unsigned int index = (this+coverage).get_coverage  (buffer->cur().codepoint);

   694     if (likely (index == NOT_COVERED)) return_trace (false);

   695 

   696     hb_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;

   697     skippy_iter.reset (buffer->idx, 1);

   698     if (!skippy_iter.next ()) return_trace (false);

   699 

   700     return_trace ((this+pairSet[index]).apply (c, &valueFormat1, skippy_iter.idx));

   701   }

   702 

   703   inline bool sanitize (hb_sanitize_context_t *c) const

   704   {

   705     TRACE_SANITIZE (this);

   706 

   707     if (!c->check_struct (this)) return_trace (false);

   708 

   709     unsigned int len1 = valueFormat1.get_len ();

   710     unsigned int len2 = valueFormat2.get_len ();

   711     PairSet::sanitize_closure_t closure = {

   712       this,

   713       &valueFormat1,

   714       len1,

   715       1 + len1 + len2

   716     };

   717 

   718     return_trace (coverage.sanitize (c, this) && pairSet.sanitize (c, this, &closure));

   719   }

   720 

   721   protected:

   722   USHORT        format;                 /* Format identifier--format = 1 */

   723   OffsetTo<Coverage>

   724                 coverage;               /* Offset to Coverage table--from

   725                                          * beginning of subtable */

   726   ValueFormat   valueFormat1;           /* Defines the types of data in

   727                                          * ValueRecord1--for the first glyph

   728                                          * in the pair--may be zero (0) */

   729   ValueFormat   valueFormat2;           /* Defines the types of data in

   730                                          * ValueRecord2--for the second glyph

   731                                          * in the pair--may be zero (0) */

   732   OffsetArrayOf<PairSet>

   733                 pairSet;                /* Array of PairSet tables

   734                                          * ordered by Coverage Index */

   735   public:

   736   DEFINE_SIZE_ARRAY (10, pairSet);

   737 };

   738 

   739 struct PairPosFormat2

   740 {

   741   inline void collect_glyphs (hb_collect_glyphs_context_t *c) const

   742   {

   743     TRACE_COLLECT_GLYPHS (this);

   744     /* (this+coverage).add_coverage (c->input); // Don't need this. */

   745 

   746     unsigned int count1 = class1Count;

   747     const ClassDef &klass1 = this+classDef1;

   748     for (unsigned int i = 0; i < count1; i++)

   749       klass1.add_class (c->input, i);

   750 

   751     unsigned int count2 = class2Count;

   752     const ClassDef &klass2 = this+classDef2;

   753     for (unsigned int i = 0; i < count2; i++)

   754       klass2.add_class (c->input, i);

   755   }

   756 

   757   inline const Coverage &get_coverage (void) const

   758   {

   759     return this+coverage;

   760   }

   761 

   762   inline bool apply (hb_apply_context_t *c) const

   763   {

   764     TRACE_APPLY (this);

   765     hb_buffer_t *buffer = c->buffer;

   766     unsigned int index = (this+coverage).get_coverage  (buffer->cur().codepoint);

   767     if (likely (index == NOT_COVERED)) return_trace (false);

   768 

   769     hb_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;

   770     skippy_iter.reset (buffer->idx, 1);

   771     if (!skippy_iter.next ()) return_trace (false);

   772 

   773     unsigned int len1 = valueFormat1.get_len ();

   774     unsigned int len2 = valueFormat2.get_len ();

   775     unsigned int record_len = len1 + len2;

   776 

   777     unsigned int klass1 = (this+classDef1).get_class (buffer->cur().codepoint);

   778     unsigned int klass2 = (this+classDef2).get_class (buffer->info[skippy_iter.idx].codepoint);

   779     if (unlikely (klass1 >= class1Count || klass2 >= class2Count)) return_trace (false);

   780 

   781     const Value *v = &values[record_len * (klass1 * class2Count + klass2)];

   782     valueFormat1.apply_value (c->font, c->direction, this,

   783                               v, buffer->cur_pos());

   784     valueFormat2.apply_value (c->font, c->direction, this,

   785                               v + len1, buffer->pos[skippy_iter.idx]);

   786 

   787     buffer->idx = skippy_iter.idx;

   788     if (len2)

   789       buffer->idx++;

   790 

   791     return_trace (true);

   792   }

   793 

   794   inline bool sanitize (hb_sanitize_context_t *c) const

   795   {

   796     TRACE_SANITIZE (this);

   797     if (!(c->check_struct (this)

   798        && coverage.sanitize (c, this)

   799        && classDef1.sanitize (c, this)

   800        && classDef2.sanitize (c, this))) return_trace (false);

   801 

   802     unsigned int len1 = valueFormat1.get_len ();

   803     unsigned int len2 = valueFormat2.get_len ();

   804     unsigned int stride = len1 + len2;

   805     unsigned int record_size = valueFormat1.get_size () + valueFormat2.get_size ();

   806     unsigned int count = (unsigned int) class1Count * (unsigned int) class2Count;

   807     return_trace (c->check_array (values, record_size, count) &&

   808                   valueFormat1.sanitize_values_stride_unsafe (c, this, &values[0], count, stride) &&

   809                   valueFormat2.sanitize_values_stride_unsafe (c, this, &values[len1], count, stride));

   810   }

   811 

   812   protected:

   813   USHORT        format;                 /* Format identifier--format = 2 */

   814   OffsetTo<Coverage>

   815                 coverage;               /* Offset to Coverage table--from

   816                                          * beginning of subtable */

   817   ValueFormat   valueFormat1;           /* ValueRecord definition--for the

   818                                          * first glyph of the pair--may be zero

   819                                          * (0) */

   820   ValueFormat   valueFormat2;           /* ValueRecord definition--for the

   821                                          * second glyph of the pair--may be

   822                                          * zero (0) */

   823   OffsetTo<ClassDef>

   824                 classDef1;              /* Offset to ClassDef table--from

   825                                          * beginning of PairPos subtable--for

   826                                          * the first glyph of the pair */

   827   OffsetTo<ClassDef>

   828                 classDef2;              /* Offset to ClassDef table--from

   829                                          * beginning of PairPos subtable--for

   830                                          * the second glyph of the pair */

   831   USHORT        class1Count;            /* Number of classes in ClassDef1

   832                                          * table--includes Class0 */

   833   USHORT        class2Count;            /* Number of classes in ClassDef2

   834                                          * table--includes Class0 */

   835   ValueRecord   values;                 /* Matrix of value pairs:

   836                                          * class1-major, class2-minor,

   837                                          * Each entry has value1 and value2 */

   838   public:

   839   DEFINE_SIZE_ARRAY (16, values);

   840 };

   841 

   842 struct PairPos

   843 {

   844   template <typename context_t>

   845   inline typename context_t::return_t dispatch (context_t *c) const

   846   {

   847     TRACE_DISPATCH (this, u.format);

   848     if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ());

   849     switch (u.format) {

   850     case 1: return_trace (c->dispatch (u.format1));

   851     case 2: return_trace (c->dispatch (u.format2));

   852     default:return_trace (c->default_return_value ());

   853     }

   854   }

   855 

   856   protected:

   857   union {

   858   USHORT                format;         /* Format identifier */

   859   PairPosFormat1        format1;

   860   PairPosFormat2        format2;

   861   } u;

   862 };

   863 

   864 

   865 struct EntryExitRecord

   866 {

   867   friend struct CursivePosFormat1;

   868 

   869   inline bool sanitize (hb_sanitize_context_t *c, const void *base) const

   870   {

   871     TRACE_SANITIZE (this);

   872     return_trace (entryAnchor.sanitize (c, base) && exitAnchor.sanitize (c, base));

   873   }

   874 

   875   protected:

   876   OffsetTo<Anchor>

   877                 entryAnchor;            /* Offset to EntryAnchor table--from

   878                                          * beginning of CursivePos

   879                                          * subtable--may be NULL */

   880   OffsetTo<Anchor>

   881                 exitAnchor;             /* Offset to ExitAnchor table--from

   882                                          * beginning of CursivePos

   883                                          * subtable--may be NULL */

   884   public:

   885   DEFINE_SIZE_STATIC (4);

   886 };

   887 

   888 static void

   889 reverse_cursive_minor_offset (hb_glyph_position_t *pos, unsigned int i, hb_direction_t direction, unsigned int new_parent);

   890 

   891 struct CursivePosFormat1

   892 {

   893   inline void collect_glyphs (hb_collect_glyphs_context_t *c) const

   894   {

   895     TRACE_COLLECT_GLYPHS (this);

   896     (this+coverage).add_coverage (c->input);

   897   }

   898 

   899   inline const Coverage &get_coverage (void) const

   900   {

   901     return this+coverage;

   902   }

   903 

   904   inline bool apply (hb_apply_context_t *c) const

   905   {

   906     TRACE_APPLY (this);

   907     hb_buffer_t *buffer = c->buffer;

   908 

   909     /* We don't handle mark glyphs here. */

   910     if (unlikely (_hb_glyph_info_is_mark (&buffer->cur()))) return_trace (false);

   911 

   912     const EntryExitRecord &this_record = entryExitRecord[(this+coverage).get_coverage  (buffer->cur().codepoint)];

   913     if (!this_record.exitAnchor) return_trace (false);

   914 

   915     hb_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;

   916     skippy_iter.reset (buffer->idx, 1);

   917     if (!skippy_iter.next ()) return_trace (false);

   918 

   919     const EntryExitRecord &next_record = entryExitRecord[(this+coverage).get_coverage  (buffer->info[skippy_iter.idx].codepoint)];

   920     if (!next_record.entryAnchor) return_trace (false);

   921 

   922     unsigned int i = buffer->idx;

   923     unsigned int j = skippy_iter.idx;

   924 

   925     hb_position_t entry_x, entry_y, exit_x, exit_y;

   926     (this+this_record.exitAnchor).get_anchor (c->font, buffer->info[i].codepoint, &exit_x, &exit_y);

   927     (this+next_record.entryAnchor).get_anchor (c->font, buffer->info[j].codepoint, &entry_x, &entry_y);

   928 

   929     hb_glyph_position_t *pos = buffer->pos;

   930 

   931     hb_position_t d;

   932     /* Main-direction adjustment */

   933     switch (c->direction) {

   934       case HB_DIRECTION_LTR:

   935         pos[i].x_advance  =  exit_x + pos[i].x_offset;

   936 

   937         d = entry_x + pos[j].x_offset;

   938         pos[j].x_advance -= d;

   939         pos[j].x_offset  -= d;

   940         break;

   941       case HB_DIRECTION_RTL:

   942         d = exit_x + pos[i].x_offset;

   943         pos[i].x_advance -= d;

   944         pos[i].x_offset  -= d;

   945 

   946         pos[j].x_advance  =  entry_x + pos[j].x_offset;

   947         break;

   948       case HB_DIRECTION_TTB:

   949         pos[i].y_advance  =  exit_y + pos[i].y_offset;

   950 

   951         d = entry_y + pos[j].y_offset;

   952         pos[j].y_advance -= d;

   953         pos[j].y_offset  -= d;

   954         break;

   955       case HB_DIRECTION_BTT:

   956         d = exit_y + pos[i].y_offset;

   957         pos[i].y_advance -= d;

   958         pos[i].y_offset  -= d;

   959 

   960         pos[j].y_advance  =  entry_y;

   961         break;

   962       case HB_DIRECTION_INVALID:

   963       default:

   964         break;

   965     }

   966 

   967     /* Cross-direction adjustment */

   968 

   969     /* We attach child to parent (think graph theory and rooted trees whereas

   970      * the root stays on baseline and each node aligns itself against its

   971      * parent.

   972      *

   973      * Optimize things for the case of RightToLeft, as that's most common in

   974      * Arabinc. */

   975     unsigned int child  = i;

   976     unsigned int parent = j;

   977     hb_position_t x_offset = entry_x - exit_x;

   978     hb_position_t y_offset = entry_y - exit_y;

   979     if  (!(c->lookup_props & LookupFlag::RightToLeft))

   980     {

   981       unsigned int k = child;

   982       child = parent;

   983       parent = k;

   984       x_offset = -x_offset;

   985       y_offset = -y_offset;

   986     }

   987 

   988     /* If child was already connected to someone else, walk through its old

   989      * chain and reverse the link direction, such that the whole tree of its

   990      * previous connection now attaches to new parent.  Watch out for case

   991      * where new parent is on the path from old chain...

   992      */

   993     reverse_cursive_minor_offset (pos, child, c->direction, parent);

   994 

   995     pos[child].cursive_chain() = parent - child;

   996     if (likely (HB_DIRECTION_IS_HORIZONTAL (c->direction)))

   997       pos[child].y_offset = y_offset;

   998     else

   999       pos[child].x_offset = x_offset;

  1000 

  1001     buffer->idx = j;

  1002     return_trace (true);

  1003   }

  1004 

  1005   inline bool sanitize (hb_sanitize_context_t *c) const

  1006   {

  1007     TRACE_SANITIZE (this);

  1008     return_trace (coverage.sanitize (c, this) && entryExitRecord.sanitize (c, this));

  1009   }

  1010 

  1011   protected:

  1012   USHORT        format;                 /* Format identifier--format = 1 */

  1013   OffsetTo<Coverage>

  1014                 coverage;               /* Offset to Coverage table--from

  1015                                          * beginning of subtable */

  1016   ArrayOf<EntryExitRecord>

  1017                 entryExitRecord;        /* Array of EntryExit records--in

  1018                                          * Coverage Index order */

  1019   public:

  1020   DEFINE_SIZE_ARRAY (6, entryExitRecord);

  1021 };

  1022 

  1023 struct CursivePos

  1024 {

  1025   template <typename context_t>

  1026   inline typename context_t::return_t dispatch (context_t *c) const

  1027   {

  1028     TRACE_DISPATCH (this, u.format);

  1029     if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ());

  1030     switch (u.format) {

  1031     case 1: return_trace (c->dispatch (u.format1));

  1032     default:return_trace (c->default_return_value ());

  1033     }

  1034   }

  1035 

  1036   protected:

  1037   union {

  1038   USHORT                format;         /* Format identifier */

  1039   CursivePosFormat1     format1;

  1040   } u;

  1041 };

  1042 

  1043 

  1044 typedef AnchorMatrix BaseArray;         /* base-major--

  1045                                          * in order of BaseCoverage Index--,

  1046                                          * mark-minor--

  1047                                          * ordered by class--zero-based. */

  1048 

  1049 struct MarkBasePosFormat1

  1050 {

  1051   inline void collect_glyphs (hb_collect_glyphs_context_t *c) const

  1052   {

  1053     TRACE_COLLECT_GLYPHS (this);

  1054     (this+markCoverage).add_coverage (c->input);

  1055     (this+baseCoverage).add_coverage (c->input);

  1056   }

  1057 

  1058   inline const Coverage &get_coverage (void) const

  1059   {

  1060     return this+markCoverage;

  1061   }

  1062 

  1063   inline bool apply (hb_apply_context_t *c) const

  1064   {

  1065     TRACE_APPLY (this);

  1066     hb_buffer_t *buffer = c->buffer;

  1067     unsigned int mark_index = (this+markCoverage).get_coverage  (buffer->cur().codepoint);

  1068     if (likely (mark_index == NOT_COVERED)) return_trace (false);

  1069 

  1070     /* now we search backwards for a non-mark glyph */

  1071     hb_apply_context_t::skipping_iterator_t &skippy_iter = c->iter_input;

  1072     skippy_iter.reset (buffer->idx, 1);

  1073     skippy_iter.set_lookup_props (LookupFlag::IgnoreMarks);

  1074     do {

  1075       if (!skippy_iter.prev ()) return_trace (false);

  1076       /* We only want to attach to the first of a MultipleSubst sequence.  Reject others. */

  1077       if (0 == _hb_glyph_info_get_lig_comp (&buffer->info[skippy_iter.idx])) break;

  1078       skippy_iter.reject ();

  1079     } while (1);

  1080 

  1081     /* Checking that matched glyph is actually a base glyph by GDEF is too strong; disabled */

  1082     if (!_hb_glyph_info_is_base_glyph (&buffer->info[skippy_iter.idx])) { /*return_trace (false);*/ }

  1083 

  1084     unsigned int base_index = (this+baseCoverage).get_coverage  (buffer->info[skippy_iter.idx].codepoint);

  1085     if (base_index == NOT_COVERED) return_trace (false);

  1086 

  1087     return_trace ((this+markArray).apply (c, mark_index, base_index, this+baseArray, classCount, skippy_iter.idx));

  1088   }

  1089 

  1090   inline bool sanitize (hb_sanitize_context_t *c) const

  1091   {

  1092     TRACE_SANITIZE (this);

  1093     return_trace (c->check_struct (this) &&

  1094                   markCoverage.sanitize (c, this) &&

  1095                   baseCoverage.sanitize (c, this) &&

  1096                   markArray.sanitize (c, this) &&

  1097                   baseArray.sanitize (c, this, (unsigned int) classCount));

  1098   }

  1099 

  1100   protected:

  1101   USHORT        format;                 /* Format identifier--format = 1 */

  1102   OffsetTo<Coverage>

  1103                 markCoverage;           /* Offset to MarkCoverage table--from

  1104                                          * beginning of MarkBasePos subtable */

  1105   OffsetTo<Coverage>

  1106                 baseCoverage;           /* Offset to BaseCoverage table--from

  1107                                          * beginning of MarkBasePos subtable */

  1108   USHORT        classCount;             /* Number of classes defined for marks */

  1109   OffsetTo<MarkArray>

  1110                 markArray;              /* Offset to MarkArray table--from

  1111                                          * beginning of MarkBasePos subtable */

  1112   OffsetTo<BaseArray>

  1113                 baseArray;              /* Offset to BaseArray table--from

  1114                                          * beginning of MarkBasePos subtable */

  1115   public:

  1116   DEFINE_SIZE_STATIC (12);

  1117 };

  1118 

  1119 struct MarkBasePos

  1120 {

  1121   template <typename context_t>

  1122   inline typename context_t::return_t dispatch (context_t *c) const

  1123   {

  1124     TRACE_DISPATCH (this, u.format);

  1125     if (unlikely (!c->may_dispatch (this, &u.format))) return_trace (c->no_dispatch_return_value ());

  1126     switch (u.format) {

  1127     case 1: return_trace (c->dispatch (u.format1));

  1128     default:return_trace (c->default_return_value ());

  1129     }

  1130   }

  1131 

  1132   protected:

  1133   union {

  1134   USHORT                format;         /* Format identifier */

  1135   MarkBasePosFormat1    format1;