hb-aat-layout-morx-table.hh 29.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
/*
 * Copyright © 2017  Google, Inc.
 *
 *  This is part of HarfBuzz, a text shaping library.
 *
 * Permission is hereby granted, without written agreement and without
 * license or royalty fees, to use, copy, modify, and distribute this
 * software and its documentation for any purpose, provided that the
 * above copyright notice and the following two paragraphs appear in
 * all copies of this software.
 *
 * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
 * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
 * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
 * DAMAGE.
 *
 * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
 *
 * Google Author(s): Behdad Esfahbod
 */

#ifndef HB_AAT_LAYOUT_MORX_TABLE_HH
#define HB_AAT_LAYOUT_MORX_TABLE_HH

30 31 32
#include "hb-open-type.hh"
#include "hb-aat-layout-common.hh"
#include "hb-ot-layout-common.hh"
33

34 35 36 37
/*
 * morx -- Extended Glyph Metamorphosis
 * https://developer.apple.com/fonts/TrueType-Reference-Manual/RM06/Chap6morx.html
 */
38
#define HB_AAT_TAG_morx HB_TAG('m','o','r','x')
39 40 41 42 43 44 45 46 47


namespace AAT {

using namespace OT;


struct RearrangementSubtable
{
B
Minor  
Behdad Esfahbod 已提交
48 49
  typedef void EntryData;

50
  struct driver_context_t
51
  {
52
    static const bool in_place = true;
53 54
    enum Flags
    {
B
Behdad Esfahbod 已提交
55 56
      MarkFirst		= 0x8000,	/* If set, make the current glyph the first
					 * glyph to be rearranged. */
57
      DontAdvance	= 0x4000,	/* If set, don't advance to the next glyph
B
Behdad Esfahbod 已提交
58 59 60 61 62 63 64
					 * before going to the new state. This means
					 * that the glyph index doesn't change, even
					 * if the glyph at that index has changed. */
      MarkLast		= 0x2000,	/* If set, make the current glyph the last
					 * glyph to be rearranged. */
      Reserved		= 0x1FF0,	/* These bits are reserved and should be set to 0. */
      Verb		= 0x000F,	/* The type of rearrangement specified. */
65 66 67 68
    };

    inline driver_context_t (const RearrangementSubtable *table) :
	ret (false),
B
Behdad Esfahbod 已提交
69
	start (0), end (0) {}
70

B
Minor  
Behdad Esfahbod 已提交
71 72
    inline bool is_actionable (StateTableDriver<EntryData> *driver,
			       const Entry<EntryData> *entry)
B
Behdad Esfahbod 已提交
73 74 75
    {
      return (entry->flags & Verb) && start < end;
    }
B
Minor  
Behdad Esfahbod 已提交
76 77
    inline bool transition (StateTableDriver<EntryData> *driver,
			    const Entry<EntryData> *entry)
78
    {
79
      hb_buffer_t *buffer = driver->buffer;
80 81 82
      unsigned int flags = entry->flags;

      if (flags & MarkFirst)
83
	start = buffer->idx;
84

85
      if (flags & MarkLast)
86
	end = MIN (buffer->idx + 1, buffer->len);
87 88 89 90 91 92 93

      if ((flags & Verb) && start < end)
      {
	/* The following map has two nibbles, for start-side
	 * and end-side. Values of 0,1,2 mean move that many
	 * to the other side. Value of 3 means move 2 and
	 * flip them. */
B
Behdad Esfahbod 已提交
94
	const unsigned char map[16] =
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121
	{
	  0x00,	/* 0	no change */
	  0x10,	/* 1	Ax => xA */
	  0x01,	/* 2	xD => Dx */
	  0x11,	/* 3	AxD => DxA */
	  0x20,	/* 4	ABx => xAB */
	  0x30,	/* 5	ABx => xBA */
	  0x02,	/* 6	xCD => CDx */
	  0x03,	/* 7	xCD => DCx */
	  0x12,	/* 8	AxCD => CDxA */
	  0x13,	/* 9	AxCD => DCxA */
	  0x21,	/* 10	ABxD => DxAB */
	  0x31,	/* 11	ABxD => DxBA */
	  0x22,	/* 12	ABxCD => CDxAB */
	  0x32,	/* 13	ABxCD => CDxBA */
	  0x23,	/* 14	ABxCD => DCxAB */
	  0x33,	/* 15	ABxCD => DCxBA */
	};

	unsigned int m = map[flags & Verb];
	unsigned int l = MIN<unsigned int> (2, m >> 4);
	unsigned int r = MIN<unsigned int> (2, m & 0x0F);
	bool reverse_l = 3 == (m >> 4);
	bool reverse_r = 3 == (m & 0x0F);

	if (end - start >= l + r)
	{
B
Behdad Esfahbod 已提交
122
	  buffer->merge_clusters (start, MIN (buffer->idx + 1, buffer->len));
123
	  buffer->merge_clusters (start, end);
124

125
	  hb_glyph_info_t *info = buffer->info;
126
	  hb_glyph_info_t buf[4];
127

128 129 130 131
	  memcpy (buf, info + start, l * sizeof (buf[0]));
	  memcpy (buf + 2, info + end - r, r * sizeof (buf[0]));

	  if (l != r)
132
	    memmove (info + start + r, info + start + l, (end - start - l - r) * sizeof (buf[0]));
133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149

	  memcpy (info + start, buf + 2, r * sizeof (buf[0]));
	  memcpy (info + end - l, buf, l * sizeof (buf[0]));
	  if (reverse_l)
	  {
	    buf[0] = info[end - 1];
	    info[end - 1] = info[end - 2];
	    info[end - 2] = buf[0];
	  }
	  if (reverse_r)
	  {
	    buf[0] = info[start];
	    info[start] = info[start + 1];
	    info[start + 1] = buf[0];
	  }
	}
      }
150 151

      return true;
152 153 154 155 156
    }

    public:
    bool ret;
    private:
B
Behdad Esfahbod 已提交
157 158
    unsigned int start;
    unsigned int end;
159
  };
160

161
  inline bool apply (hb_aat_apply_context_t *c) const
162 163
  {
    TRACE_APPLY (this);
164

165 166 167 168
    driver_context_t dc (this);

    StateTableDriver<void> driver (machine, c->buffer, c->face);
    driver.drive (&dc);
169

170
    return_trace (dc.ret);
171 172
  }

173 174 175
  inline bool sanitize (hb_sanitize_context_t *c) const
  {
    TRACE_SANITIZE (this);
176
    return_trace (machine.sanitize (c));
177
  }
178 179

  protected:
B
Behdad Esfahbod 已提交
180
  StateTable<EntryData>	machine;
181
  public:
B
Behdad Esfahbod 已提交
182
  DEFINE_SIZE_STATIC (16);
183 184 185 186
};

struct ContextualSubtable
{
187 188 189 190 191 192
  struct EntryData
  {
    HBUINT16	markIndex;	/* Index of the substitution table for the
				 * marked glyph (use 0xFFFF for none). */
    HBUINT16	currentIndex;	/* Index of the substitution table for the
				 * current glyph (use 0xFFFF for none). */
B
Behdad Esfahbod 已提交
193
    public:
194
    DEFINE_SIZE_STATIC (4);
195 196
  };

197
  struct driver_context_t
198
  {
199
    static const bool in_place = true;
200 201
    enum Flags
    {
202 203 204 205 206 207 208 209
      SetMark		= 0x8000,	/* If set, make the current glyph the marked glyph. */
      DontAdvance	= 0x4000,	/* If set, don't advance to the next glyph before
					 * going to the new state. */
      Reserved		= 0x3FFF,	/* These bits are reserved and should be set to 0. */
    };

    inline driver_context_t (const ContextualSubtable *table) :
	ret (false),
210
	mark_set (false),
211 212 213
	mark (0),
	subs (table+table->substitutionTables) {}

B
Behdad Esfahbod 已提交
214 215 216 217 218 219 220 221 222 223
    inline bool is_actionable (StateTableDriver<EntryData> *driver,
			       const Entry<EntryData> *entry)
    {
      hb_buffer_t *buffer = driver->buffer;

      if (buffer->idx == buffer->len && !mark_set)
        return false;

      return entry->data.markIndex != 0xFFFF || entry->data.currentIndex != 0xFFFF;
    }
224
    inline bool transition (StateTableDriver<EntryData> *driver,
225
			    const Entry<EntryData> *entry)
226
    {
227
      hb_buffer_t *buffer = driver->buffer;
228

229 230 231 232 233
      /* Looks like CoreText applies neither mark nor current substitution for
       * end-of-text if mark was not explicitly set. */
      if (buffer->idx == buffer->len && !mark_set)
        return true;

B
Behdad Esfahbod 已提交
234
      if (entry->data.markIndex != 0xFFFF)
235
      {
236
	const Lookup<GlyphID> &lookup = subs[entry->data.markIndex];
237 238
	hb_glyph_info_t *info = buffer->info;
	const GlyphID *replacement = lookup.get_value (info[mark].codepoint, driver->num_glyphs);
239 240
	if (replacement)
	{
B
Behdad Esfahbod 已提交
241
	  buffer->unsafe_to_break (mark, MIN (buffer->idx + 1, buffer->len));
242 243 244 245
	  info[mark].codepoint = *replacement;
	  ret = true;
	}
      }
246
      if (entry->data.currentIndex != 0xFFFF)
247
      {
248
        unsigned int idx = MIN (buffer->idx, buffer->len - 1);
249
	const Lookup<GlyphID> &lookup = subs[entry->data.currentIndex];
250
	hb_glyph_info_t *info = buffer->info;
251
	const GlyphID *replacement = lookup.get_value (info[idx].codepoint, driver->num_glyphs);
252 253
	if (replacement)
	{
254
	  info[idx].codepoint = *replacement;
255 256 257
	  ret = true;
	}
      }
258

259 260
      if (entry->flags & SetMark)
      {
261
	mark_set = true;
262 263 264
	mark = buffer->idx;
      }

265
      return true;
266
    }
267

268 269 270
    public:
    bool ret;
    private:
271
    bool mark_set;
272 273 274
    unsigned int mark;
    const UnsizedOffsetListOf<Lookup<GlyphID>, HBUINT32> &subs;
  };
275

276
  inline bool apply (hb_aat_apply_context_t *c) const
277 278
  {
    TRACE_APPLY (this);
279

280 281 282 283 284 285
    driver_context_t dc (this);

    StateTableDriver<EntryData> driver (machine, c->buffer, c->face);
    driver.drive (&dc);

    return_trace (dc.ret);
286 287
  }

288 289 290
  inline bool sanitize (hb_sanitize_context_t *c) const
  {
    TRACE_SANITIZE (this);
291

B
Behdad Esfahbod 已提交
292
    unsigned int num_entries = 0;
B
Behdad Esfahbod 已提交
293
    if (unlikely (!machine.sanitize (c, &num_entries))) return_trace (false);
294 295 296 297 298 299 300 301

    unsigned int num_lookups = 0;

    const Entry<EntryData> *entries = machine.get_entries ();
    for (unsigned int i = 0; i < num_entries; i++)
    {
      const EntryData &data = entries[i].data;

302 303 304 305
      if (data.markIndex != 0xFFFF)
	num_lookups = MAX<unsigned int> (num_lookups, 1 + data.markIndex);
      if (data.currentIndex != 0xFFFF)
	num_lookups = MAX<unsigned int> (num_lookups, 1 + data.currentIndex);
306 307 308
    }

    return_trace (substitutionTables.sanitize (c, this, num_lookups));
309
  }
310 311

  protected:
312 313
  StateTable<EntryData>
		machine;
314
  LOffsetTo<UnsizedOffsetListOf<Lookup<GlyphID>, HBUINT32>, false>
315
		substitutionTables;
316
  public:
B
Behdad Esfahbod 已提交
317
  DEFINE_SIZE_STATIC (20);
318 319 320 321
};

struct LigatureSubtable
{
322 323 324 325 326 327 328 329 330 331 332 333
  struct EntryData
  {
    HBUINT16	ligActionIndex;	/* Index to the first ligActionTable entry
				 * for processing this group, if indicated
				 * by the flags. */
    public:
    DEFINE_SIZE_STATIC (2);
  };

  struct driver_context_t
  {
    static const bool in_place = false;
334 335
    enum Flags
    {
336 337 338 339 340 341 342 343
      SetComponent	= 0x8000,	/* Push this glyph onto the component stack for
					 * eventual processing. */
      DontAdvance	= 0x4000,	/* Leave the glyph pointer at this glyph for the
					   next iteration. */
      PerformAction	= 0x2000,	/* Use the ligActionIndex to process a ligature
					 * group. */
      Reserved		= 0x1FFF,	/* These bits are reserved and should be set to 0. */
    };
344 345
    enum LigActionFlags
    {
346 347 348 349 350 351 352 353 354
      LigActionLast	= 0x80000000,	/* This is the last action in the list. This also
					 * implies storage. */
      LigActionStore	= 0x40000000,	/* Store the ligature at the current cumulated index
					 * in the ligature table in place of the marked
					 * (i.e. currently-popped) glyph. */
      LigActionOffset	= 0x3FFFFFFF,	/* A 30-bit value which is sign-extended to 32-bits
					 * and added to the glyph ID, resulting in an index
					 * into the component table. */
    };
355

356 357 358 359 360 361 362 363
    inline driver_context_t (const LigatureSubtable *table,
			     hb_aat_apply_context_t *c_) :
	ret (false),
	c (c_),
	ligAction (table+table->ligAction),
	component (table+table->component),
	ligature (table+table->ligature),
	match_length (0) {}
364

B
Behdad Esfahbod 已提交
365 366 367 368 369
    inline bool is_actionable (StateTableDriver<EntryData> *driver,
			       const Entry<EntryData> *entry)
    {
      return !!(entry->flags & PerformAction);
    }
370
    inline bool transition (StateTableDriver<EntryData> *driver,
371 372 373
			    const Entry<EntryData> *entry)
    {
      hb_buffer_t *buffer = driver->buffer;
374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398
      unsigned int flags = entry->flags;

      if (flags & SetComponent)
      {
        if (unlikely (match_length >= ARRAY_LENGTH (match_positions)))
	  return false;

	/* Never mark same index twice, in case DontAdvance was used... */
	if (match_length && match_positions[match_length - 1] == buffer->out_len)
	  match_length--;

	match_positions[match_length++] = buffer->out_len;
      }

      if (flags & PerformAction)
      {
	unsigned int end = buffer->out_len;
	unsigned int action_idx = entry->data.ligActionIndex;
	unsigned int action;
	unsigned int ligature_idx = 0;
        do
	{
	  if (unlikely (!match_length))
	    return false;

B
Behdad Esfahbod 已提交
399
	  buffer->move_to (match_positions[--match_length]);
400

401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420
	  const HBUINT32 &actionData = ligAction[action_idx];
	  if (unlikely (!actionData.sanitize (&c->sanitizer))) return false;
	  action = actionData;

	  uint32_t uoffset = action & LigActionOffset;
	  if (uoffset & 0x20000000)
	    uoffset += 0xC0000000;
	  int32_t offset = (int32_t) uoffset;
	  unsigned int component_idx = buffer->cur().codepoint + offset;

	  const HBUINT16 &componentData = component[component_idx];
	  if (unlikely (!componentData.sanitize (&c->sanitizer))) return false;
	  ligature_idx += componentData;

	  if (action & (LigActionStore | LigActionLast))
	  {
	    const GlyphID &ligatureData = ligature[ligature_idx];
	    if (unlikely (!ligatureData.sanitize (&c->sanitizer))) return false;
	    hb_codepoint_t lig = ligatureData;

B
Behdad Esfahbod 已提交
421
	    match_positions[match_length++] = buffer->out_len;
422 423 424 425 426 427 428 429 430
	    buffer->replace_glyph (lig);

	    //ligature_idx = 0; // XXX Yes or no?
	  }
	  else
	  {
	    buffer->skip_glyph ();
	    end--;
	  }
B
Behdad Esfahbod 已提交
431
	  /* TODO merge_clusters / unsafe_to_break */
432 433 434 435 436 437 438 439

	  action_idx++;
	}
	while (!(action & LigActionLast));
	buffer->move_to (end);
      }

      return true;
440 441 442 443 444
    }

    public:
    bool ret;
    private:
445 446 447 448 449 450
    hb_aat_apply_context_t *c;
    const UnsizedArrayOf<HBUINT32> &ligAction;
    const UnsizedArrayOf<HBUINT16> &component;
    const UnsizedArrayOf<GlyphID> &ligature;
    unsigned int match_length;
    unsigned int match_positions[HB_MAX_CONTEXT_LENGTH];
451 452
  };

453
  inline bool apply (hb_aat_apply_context_t *c) const
454 455
  {
    TRACE_APPLY (this);
456

457
    driver_context_t dc (this, c);
458 459 460 461 462

    StateTableDriver<EntryData> driver (machine, c->buffer, c->face);
    driver.drive (&dc);

    return_trace (dc.ret);
463 464
  }

465 466 467
  inline bool sanitize (hb_sanitize_context_t *c) const
  {
    TRACE_SANITIZE (this);
468
    /* The rest of array sanitizations are done at run-time. */
B
Behdad Esfahbod 已提交
469 470
    return_trace (c->check_struct (this) && machine.sanitize (c) &&
		  ligAction && component && ligature);
471
  }
472 473

  protected:
474 475
  StateTable<EntryData>
		machine;
476
  LOffsetTo<UnsizedArrayOf<HBUINT32>, false>
477
		ligAction;	/* Offset to the ligature action table. */
478
  LOffsetTo<UnsizedArrayOf<HBUINT16>, false>
479
		component;	/* Offset to the component table. */
480
  LOffsetTo<UnsizedArrayOf<GlyphID>, false>
481 482 483
		ligature;	/* Offset to the actual ligature lists. */
  public:
  DEFINE_SIZE_STATIC (28);
484 485 486 487
};

struct NoncontextualSubtable
{
488
  inline bool apply (hb_aat_apply_context_t *c) const
489 490
  {
    TRACE_APPLY (this);
491

492
    bool ret = false;
493 494 495 496
    unsigned int num_glyphs = c->face->get_num_glyphs ();

    hb_glyph_info_t *info = c->buffer->info;
    unsigned int count = c->buffer->len;
497 498 499 500 501 502 503 504 505
    for (unsigned int i = 0; i < count; i++)
    {
      const GlyphID *replacement = substitute.get_value (info[i].codepoint, num_glyphs);
      if (replacement)
      {
	info[i].codepoint = *replacement;
	ret = true;
      }
    }
506

507 508 509
    return_trace (ret);
  }

510 511 512
  inline bool sanitize (hb_sanitize_context_t *c) const
  {
    TRACE_SANITIZE (this);
B
Behdad Esfahbod 已提交
513
    return_trace (substitute.sanitize (c));
514
  }
B
Behdad Esfahbod 已提交
515 516 517 518 519

  protected:
  Lookup<GlyphID>	substitute;
  public:
  DEFINE_SIZE_MIN (2);
520 521 522 523
};

struct InsertionSubtable
{
524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609
  struct EntryData
  {
    HBUINT16	currentInsertIndex;	/* Zero-based index into the insertion glyph table.
					 * The number of glyphs to be inserted is contained
					 * in the currentInsertCount field in the flags.
					 * A value of 0xFFFF indicates no insertion is to
					 * be done. */
    HBUINT16	markedInsertIndex;	/* Zero-based index into the insertion glyph table.
					 * The number of glyphs to be inserted is contained
					 * in the markedInsertCount field in the flags.
					 * A value of 0xFFFF indicates no insertion is to
					 * be done. */
    public:
    DEFINE_SIZE_STATIC (4);
  };

  struct driver_context_t
  {
    static const bool in_place = false;
    enum Flags
    {
      SetMark		= 0x8000,	/* If set, mark the current glyph. */
      DontAdvance	= 0x4000,	/* If set, don't advance to the next glyph before
					 * going to the new state.  This does not mean
					 * that the glyph pointed to is the same one as
					 * before. If you've made insertions immediately
					 * downstream of the current glyph, the next glyph
					 * processed would in fact be the first one
					 * inserted. */
      CurrentIsKashidaLike= 0x2000,	/* If set, and the currentInsertList is nonzero,
					 * then the specified glyph list will be inserted
					 * as a kashida-like insertion, either before or
					 * after the current glyph (depending on the state
					 * of the currentInsertBefore flag). If clear, and
					 * the currentInsertList is nonzero, then the
					 * specified glyph list will be inserted as a
					 * split-vowel-like insertion, either before or
					 * after the current glyph (depending on the state
					 * of the currentInsertBefore flag). */
      MarkedIsKashidaLike= 0x1000,	/* If set, and the markedInsertList is nonzero,
					 * then the specified glyph list will be inserted
					 * as a kashida-like insertion, either before or
					 * after the marked glyph (depending on the state
					 * of the markedInsertBefore flag). If clear, and
					 * the markedInsertList is nonzero, then the
					 * specified glyph list will be inserted as a
					 * split-vowel-like insertion, either before or
					 * after the marked glyph (depending on the state
					 * of the markedInsertBefore flag). */
      CurrentInsertBefore= 0x0800,	/* If set, specifies that insertions are to be made
					 * to the left of the current glyph. If clear,
					 * they're made to the right of the current glyph. */
      MarkedInsertBefore= 0x0400,	/* If set, specifies that insertions are to be
					 * made to the left of the marked glyph. If clear,
					 * they're made to the right of the marked glyph. */
      CurrentInsertCount= 0x3E0,	/* This 5-bit field is treated as a count of the
					 * number of glyphs to insert at the current
					 * position. Since zero means no insertions, the
					 * largest number of insertions at any given
					 * current location is 31 glyphs. */
      MarkedInsertCount= 0x001F,	/* This 5-bit field is treated as a count of the
					 * number of glyphs to insert at the marked
					 * position. Since zero means no insertions, the
					 * largest number of insertions at any given
					 * marked location is 31 glyphs. */
    };

    inline driver_context_t (const InsertionSubtable *table,
			     hb_aat_apply_context_t *c_) :
	ret (false),
	c (c_),
	mark (0),
	insertionAction (table+table->insertionAction) {}

    inline bool is_actionable (StateTableDriver<EntryData> *driver,
			       const Entry<EntryData> *entry)
    {
      return (entry->flags & (CurrentInsertCount | MarkedInsertCount)) &&
	     (entry->data.currentInsertIndex != 0xFFFF ||entry->data.markedInsertIndex != 0xFFFF);
    }
    inline bool transition (StateTableDriver<EntryData> *driver,
			    const Entry<EntryData> *entry)
    {
      hb_buffer_t *buffer = driver->buffer;
      unsigned int flags = entry->flags;

610
      if (entry->data.markedInsertIndex != 0xFFFF)
611
      {
612
	unsigned int count = (flags & MarkedInsertCount);
613 614 615
	unsigned int start = entry->data.markedInsertIndex;
	const GlyphID *glyphs = &insertionAction[start];
	if (unlikely (!c->sanitizer.check_array (glyphs, count))) return false;
616

617
	bool before = flags & MarkedInsertBefore;
618 619

	unsigned int end = buffer->out_len;
620
	buffer->move_to (mark);
621

622 623 624 625 626 627 628
	if (!before)
	  buffer->copy_glyph ();
	/* TODO We ignore KashidaLike setting. */
	for (unsigned int i = 0; i < count; i++)
	  buffer->output_glyph (glyphs[i]);
	if (!before)
	  buffer->skip_glyph ();
629

630
	buffer->move_to (end + count);
631 632

	buffer->unsafe_to_break_from_outbuffer (mark, MIN (buffer->idx + 1, buffer->len));
633
      }
634

635 636
      if (entry->data.currentInsertIndex != 0xFFFF)
      {
637
	unsigned int count = (flags & CurrentInsertCount) >> 5;
638 639 640
	unsigned int start = entry->data.currentInsertIndex;
	const GlyphID *glyphs = &insertionAction[start];
	if (unlikely (!c->sanitizer.check_array (glyphs, count))) return false;
641

642
	bool before = flags & CurrentInsertBefore;
643

644
	unsigned int end = buffer->out_len;
645

646 647 648 649 650 651 652
	if (!before)
	  buffer->copy_glyph ();
	/* TODO We ignore KashidaLike setting. */
	for (unsigned int i = 0; i < count; i++)
	  buffer->output_glyph (glyphs[i]);
	if (!before)
	  buffer->skip_glyph ();
653

654 655 656 657 658 659 660 661 662 663 664 665 666 667
	/* Humm. Not sure where to move to.  There's this wording under
	 * DontAdvance flag:
	 *
	 * "If set, don't update the glyph index before going to the new state.
	 * This does not mean that the glyph pointed to is the same one as
	 * before. If you've made insertions immediately downstream of the
	 * current glyph, the next glyph processed would in fact be the first
	 * one inserted."
	 *
	 * This suggests that if DontAdvance is NOT set, we should move to
	 * end+count.  If it *was*, then move to end, such that newly inserted
	 * glyphs are now visible.
	 */
	buffer->move_to ((flags & DontAdvance) ? end : end + count);
668 669 670
      }

      if (flags & SetMark)
671
	mark = buffer->out_len;
672 673 674 675 676 677 678 679 680 681 682 683

      return true;
    }

    public:
    bool ret;
    private:
    hb_aat_apply_context_t *c;
    unsigned int mark;
    const UnsizedArrayOf<GlyphID> &insertionAction;
  };

684
  inline bool apply (hb_aat_apply_context_t *c) const
685 686
  {
    TRACE_APPLY (this);
687 688 689 690 691 692 693

    driver_context_t dc (this, c);

    StateTableDriver<EntryData> driver (machine, c->buffer, c->face);
    driver.drive (&dc);

    return_trace (dc.ret);
694 695
  }

696 697 698
  inline bool sanitize (hb_sanitize_context_t *c) const
  {
    TRACE_SANITIZE (this);
699 700 701
    /* The rest of array sanitizations are done at run-time. */
    return_trace (c->check_struct (this) && machine.sanitize (c) &&
		  insertionAction);
702
  }
703 704 705 706

  protected:
  StateTable<EntryData>
		machine;
707
  LOffsetTo<UnsizedArrayOf<GlyphID>, false>
708 709 710 711
		insertionAction;	/* Byte offset from stateHeader to the start of
					 * the insertion glyph table. */
  public:
  DEFINE_SIZE_STATIC (20);
712 713 714 715 716 717 718 719 720 721 722 723
};


struct Feature
{
  inline bool sanitize (hb_sanitize_context_t *c) const
  {
    TRACE_SANITIZE (this);
    return_trace (c->check_struct (this));
  }

  public:
B
Behdad Esfahbod 已提交
724 725 726
  HBUINT16	featureType;	/* The type of feature. */
  HBUINT16	featureSetting;	/* The feature's setting (aka selector). */
  HBUINT32	enableFlags;	/* Flags for the settings that this feature
727
				 * and setting enables. */
B
Behdad Esfahbod 已提交
728
  HBUINT32	disableFlags;	/* Complement of flags for the settings that this
729 730 731 732 733 734 735 736 737
				 * feature and setting disable. */

  public:
  DEFINE_SIZE_STATIC (12);
};


struct ChainSubtable
{
B
Behdad Esfahbod 已提交
738
  friend struct Chain;
739 740

  inline unsigned int get_size (void) const { return length; }
741
  inline unsigned int get_type (void) const { return coverage & SubtableType; }
742

743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759
  enum Coverage
  {
    Vertical		= 0x80000000,	/* If set, this subtable will only be applied
					 * to vertical text. If clear, this subtable
					 * will only be applied to horizontal text. */
    Descending		= 0x40000000,	/* If set, this subtable will process glyphs
					 * in descending order. If clear, it will
					 * process the glyphs in ascending order. */
    AllDirections	= 0x20000000,	/* If set, this subtable will be applied to
					 * both horizontal and vertical text (i.e.
					 * the state of bit 0x80000000 is ignored). */
    Logical		= 0x10000000,	/* If set, this subtable will process glyphs
					 * in logical order (or reverse logical order,
					 * depending on the value of bit 0x80000000). */
    Reserved		= 0x0FFFFF00,	/* Reserved, set to zero. */
    SubtableType	= 0x000000FF,	/* Subtable type; see following table. */
  };
760 761
  enum Type
  {
762 763 764 765 766 767 768 769
    Rearrangement	= 0,
    Contextual		= 1,
    Ligature		= 2,
    Noncontextual	= 4,
    Insertion		= 5
  };

  template <typename context_t>
770
  inline typename context_t::return_t dispatch (context_t *c) const
771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791
  {
    unsigned int subtable_type = get_type ();
    TRACE_DISPATCH (this, subtable_type);
    switch (subtable_type) {
    case Rearrangement:		return_trace (c->dispatch (u.rearrangement));
    case Contextual:		return_trace (c->dispatch (u.contextual));
    case Ligature:		return_trace (c->dispatch (u.ligature));
    case Noncontextual:		return_trace (c->dispatch (u.noncontextual));
    case Insertion:		return_trace (c->dispatch (u.insertion));
    default:			return_trace (c->default_return_value ());
    }
  }

  inline bool sanitize (hb_sanitize_context_t *c) const
  {
    TRACE_SANITIZE (this);
    if (!length.sanitize (c) ||
	length < min_size ||
	!c->check_range (this, length))
      return_trace (false);

792
    return_trace (dispatch (c));
793 794 795
  }

  protected:
B
Behdad Esfahbod 已提交
796 797 798
  HBUINT32	length;		/* Total subtable length, including this header. */
  HBUINT32	coverage;	/* Coverage flags and subtable type. */
  HBUINT32	subFeatureFlags;/* The 32-bit mask identifying which subtable this is. */
799
  union {
B
Behdad Esfahbod 已提交
800 801 802 803 804
  RearrangementSubtable		rearrangement;
  ContextualSubtable		contextual;
  LigatureSubtable		ligature;
  NoncontextualSubtable		noncontextual;
  InsertionSubtable		insertion;
805 806
  } u;
  public:
B
Behdad Esfahbod 已提交
807
  DEFINE_SIZE_MIN (12);
808 809 810 811
};

struct Chain
{
812
  inline void apply (hb_aat_apply_context_t *c) const
813
  {
814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829
    uint32_t flags = defaultFlags;
    {
      /* Compute applicable flags.  TODO Should move this to planning
       * stage and take user-requested features into account. */
      unsigned int count = featureCount;
      for (unsigned i = 0; i < count; i++)
      {
        const Feature &feature = featureZ[i];
	if (false) /* XXX Check if feature enabled... */
	{
	  flags &= feature.disableFlags;
	  flags |= feature.enableFlags;
	}
      }
    }

830
    const ChainSubtable *subtable = &StructAtOffset<ChainSubtable> (&featureZ, featureZ[0].static_size * featureCount);
831 832 833
    unsigned int count = subtableCount;
    for (unsigned int i = 0; i < count; i++)
    {
834 835
      bool reverse;

836 837 838
      if (!(subtable->subFeatureFlags & flags))
        goto skip;

839 840 841 842 843
      if (!(subtable->coverage & ChainSubtable::AllDirections) &&
	  HB_DIRECTION_IS_VERTICAL (c->buffer->props.direction) !=
	  bool (subtable->coverage & ChainSubtable::Vertical))
        goto skip;

844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875
      /* Buffer contents is always in logical direction.  Determine if
       * we need to reverse before applying this subtable.  We reverse
       * back after if we did reverse indeed.
       *
       * Quoting the spac:
       * """
       * Bits 28 and 30 of the coverage field control the order in which
       * glyphs are processed when the subtable is run by the layout engine.
       * Bit 28 is used to indicate if the glyph processing direction is
       * the same as logical order or layout order. Bit 30 is used to
       * indicate whether glyphs are processed forwards or backwards within
       * that order.

		Bit 30	Bit 28	Interpretation for Horizontal Text
		0	0	The subtable is processed in layout order
				(the same order as the glyphs, which is
				always left-to-right).
		1	0	The subtable is processed in reverse layout order
				(the order opposite that of the glyphs, which is
				always right-to-left).
		0	1	The subtable is processed in logical order
				(the same order as the characters, which may be
				left-to-right or right-to-left).
		1	1	The subtable is processed in reverse logical order
				(the order opposite that of the characters, which
				may be right-to-left or left-to-right).
       */
      reverse = subtable->coverage & ChainSubtable::Logical ?
		bool (subtable->coverage & ChainSubtable::Descending) :
		bool (subtable->coverage & ChainSubtable::Descending) !=
		HB_DIRECTION_IS_BACKWARD (c->buffer->props.direction);

B
Behdad Esfahbod 已提交
876
      if (!c->buffer->message (c->font, "start chain subtable %d", c->lookup_index))
877
        goto skip;
B
Behdad Esfahbod 已提交
878

879 880 881
      if (reverse)
        c->buffer->reverse ();

882
      subtable->dispatch (c);
B
Behdad Esfahbod 已提交
883

884 885 886
      if (reverse)
        c->buffer->reverse ();

B
Behdad Esfahbod 已提交
887 888
      (void) c->buffer->message (c->font, "end chain subtable %d", c->lookup_index);

889 890
      if (unlikely (!c->buffer->successful)) return;

891 892
    skip:
      subtable = &StructAfter<ChainSubtable> (*subtable);
B
Behdad Esfahbod 已提交
893
      c->set_lookup_index (c->lookup_index + 1);
894 895
    }
  }
896 897 898

  inline unsigned int get_size (void) const { return length; }

B
Behdad Esfahbod 已提交
899
  inline bool sanitize (hb_sanitize_context_t *c, unsigned int version) const
900 901 902 903 904 905 906
  {
    TRACE_SANITIZE (this);
    if (!length.sanitize (c) ||
	length < min_size ||
	!c->check_range (this, length))
      return_trace (false);

907
    if (!c->check_array (featureZ.arrayZ, featureCount))
908 909
      return_trace (false);

910
    const ChainSubtable *subtable = &StructAtOffset<ChainSubtable> (&featureZ, featureZ[0].static_size * featureCount);
911 912 913 914 915
    unsigned int count = subtableCount;
    for (unsigned int i = 0; i < count; i++)
    {
      if (!subtable->sanitize (c))
	return_trace (false);
B
Behdad Esfahbod 已提交
916
      subtable = &StructAfter<ChainSubtable> (*subtable);
917 918 919 920 921 922
    }

    return_trace (true);
  }

  protected:
B
Behdad Esfahbod 已提交
923 924
  HBUINT32	defaultFlags;	/* The default specification for subtables. */
  HBUINT32	length;		/* Total byte count, including this header. */
B
Behdad Esfahbod 已提交
925 926
  HBUINT32	featureCount;	/* Number of feature subtable entries. */
  HBUINT32	subtableCount;	/* The number of subtables in the chain. */
927

928 929
  UnsizedArrayOf<Feature>	featureZ;	/* Features. */
/*ChainSubtable	firstSubtable;*//* Subtables. */
B
Behdad Esfahbod 已提交
930
/*subtableGlyphCoverageArray*/	/* Only if version >= 3. We don't use. */
931 932

  public:
B
Behdad Esfahbod 已提交
933
  DEFINE_SIZE_MIN (16);
934 935 936 937 938 939 940
};


/*
 * The 'mort'/'morx' Tables
 */

B
Behdad Esfahbod 已提交
941
struct morx
942
{
943
  static const hb_tag_t tableTag = HB_AAT_TAG_morx;
944

945
  inline void apply (hb_aat_apply_context_t *c) const
946
  {
947
    if (unlikely (!c->buffer->successful)) return;
B
Behdad Esfahbod 已提交
948
    c->set_lookup_index (0);
949
    const Chain *chain = &firstChain;
950 951 952
    unsigned int count = chainCount;
    for (unsigned int i = 0; i < count; i++)
    {
953
      chain->apply (c);
954
      if (unlikely (!c->buffer->successful)) return;
B
Behdad Esfahbod 已提交
955
      chain = &StructAfter<Chain> (*chain);
956 957 958
    }
  }

959 960 961
  inline bool sanitize (hb_sanitize_context_t *c) const
  {
    TRACE_SANITIZE (this);
B
Behdad Esfahbod 已提交
962
    if (!version.sanitize (c) || version < 2 ||
963 964 965
	!chainCount.sanitize (c))
      return_trace (false);

966
    const Chain *chain = &firstChain;
967 968 969
    unsigned int count = chainCount;
    for (unsigned int i = 0; i < count; i++)
    {
B
Behdad Esfahbod 已提交
970
      if (!chain->sanitize (c, version))
971
	return_trace (false);
B
Behdad Esfahbod 已提交
972
      chain = &StructAfter<Chain> (*chain);
973 974 975 976 977 978
    }

    return_trace (true);
  }

  protected:
B
Behdad Esfahbod 已提交
979 980 981
  HBUINT16	version;	/* Version number of the glyph metamorphosis table.
				 * 2 or 3. */
  HBUINT16	unused;		/* Set to 0. */
B
Behdad Esfahbod 已提交
982
  HBUINT32	chainCount;	/* Number of metamorphosis chains contained in this
983
				 * table. */
984
  Chain		firstChain;	/* Chains. */
985 986 987 988 989 990 991 992 993

  public:
  DEFINE_SIZE_MIN (8);
};

} /* namespace AAT */


#endif /* HB_AAT_LAYOUT_MORX_TABLE_HH */