hb-ot-layout-gsub-private.h 24.8 KB
Newer Older
B
Behdad Esfahbod 已提交
1
/*
2
 * Copyright (C) 2007,2008,2009  Red Hat, Inc.
B
Behdad Esfahbod 已提交
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
 *
 *  This is part of HarfBuzz, an OpenType Layout engine 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.
 *
 * Red Hat Author(s): Behdad Esfahbod
 */

#ifndef HB_OT_LAYOUT_GSUB_PRIVATE_H
#define HB_OT_LAYOUT_GSUB_PRIVATE_H

30
#include "hb-ot-layout-gsubgpos-private.h"
B
Behdad Esfahbod 已提交
31 32

struct SingleSubstFormat1 {
B
Behdad Esfahbod 已提交
33 34 35 36

  friend struct SingleSubst;

  private:
B
Behdad Esfahbod 已提交
37

38
  inline bool single_substitute (hb_codepoint_t &glyph_id) const {
B
Behdad Esfahbod 已提交
39

B
Behdad Esfahbod 已提交
40
    unsigned int index = (this+coverage) (glyph_id);
41
    if (NOT_COVERED == index)
B
Behdad Esfahbod 已提交
42 43 44 45 46
      return false;

    glyph_id += deltaGlyphID;

    return true;
47
  }
B
Behdad Esfahbod 已提交
48

B
Behdad Esfahbod 已提交
49 50
  private:
  USHORT	substFormat;		/* Format identifier--format = 1 */
B
Behdad Esfahbod 已提交
51 52
  OffsetTo<Coverage>
		coverage;		/* Offset to Coverage table--from
B
Behdad Esfahbod 已提交
53 54 55 56 57 58 59
					 * beginning of Substitution table */
  SHORT		deltaGlyphID;		/* Add to original GlyphID to get
					 * substitute GlyphID */
};
ASSERT_SIZE (SingleSubstFormat1, 6);

struct SingleSubstFormat2 {
60 61 62 63 64 65 66

  friend struct SingleSubst;

  private:

  inline bool single_substitute (hb_codepoint_t &glyph_id) const {

B
Behdad Esfahbod 已提交
67
    unsigned int index = (this+coverage) (glyph_id);
68

B
Behdad Esfahbod 已提交
69
    if (index >= substitute.len)
70 71 72 73 74
      return false;

    glyph_id = substitute[index];
    return true;
  }
B
Behdad Esfahbod 已提交
75 76 77

  private:
  USHORT	substFormat;		/* Format identifier--format = 2 */
B
Behdad Esfahbod 已提交
78 79
  OffsetTo<Coverage>
		coverage;		/* Offset to Coverage table--from
B
Behdad Esfahbod 已提交
80
					 * beginning of Substitution table */
B
Behdad Esfahbod 已提交
81 82 83
  ArrayOf<GlyphID>
		substitute;		/* Array of substitute
					 * GlyphIDs--ordered by Coverage Index */
B
Behdad Esfahbod 已提交
84 85 86
};
ASSERT_SIZE (SingleSubstFormat2, 6);

87 88 89 90
struct SingleSubst {

  friend struct SubstLookupSubTable;

91 92
  private:

B
Behdad Esfahbod 已提交
93 94 95 96 97 98 99 100
  inline bool single_substitute (hb_codepoint_t &glyph_id) const {
    switch (u.substFormat) {
    case 1: return u.format1.single_substitute (glyph_id);
    case 2: return u.format2.single_substitute (glyph_id);
    default:return false;
    }
  }

101
  inline bool substitute (LOOKUP_ARGS_DEF) const {
102

103
    hb_codepoint_t glyph_id = IN_CURGLYPH ();
104

B
Behdad Esfahbod 已提交
105 106
    if (!single_substitute (glyph_id))
      return false;
107

B
Behdad Esfahbod 已提交
108
    _hb_buffer_replace_glyph (buffer, glyph_id);
109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124

    if ( _hb_ot_layout_has_new_glyph_classes (layout) )
    {
      /* we inherit the old glyph class to the substituted glyph */
      _hb_ot_layout_set_glyph_property (layout, glyph_id, property);
    }

    return true;
  }

  private:
  union {
  USHORT	substFormat;	/* Format identifier */
  SingleSubstFormat1	format1;
  SingleSubstFormat2	format2;
  } u;
B
Behdad Esfahbod 已提交
125
};
126 127
DEFINE_NULL (SingleSubst, 2);

B
Behdad Esfahbod 已提交
128 129

struct Sequence {
130 131 132 133 134 135 136

  friend struct MultipleSubstFormat1;

  private:

  inline void set_glyph_class (hb_ot_layout_t *layout, unsigned int property) const {

B
Behdad Esfahbod 已提交
137
    unsigned int count = substitute.len;
138
    for (unsigned int n = 0; n < count; n++)
139 140
      _hb_ot_layout_set_glyph_property (layout, substitute[n], property);
  }
B
Behdad Esfahbod 已提交
141

142
  inline bool substitute_sequence (LOOKUP_ARGS_DEF) const {
B
Behdad Esfahbod 已提交
143

B
Behdad Esfahbod 已提交
144
    if (HB_UNLIKELY (!substitute.len))
B
Behdad Esfahbod 已提交
145 146 147
      return false;

    _hb_buffer_add_output_glyph_ids (buffer, 1,
B
Behdad Esfahbod 已提交
148
				     substitute.len, substitute.array,
B
Behdad Esfahbod 已提交
149 150 151 152 153 154 155 156 157 158 159 160 161 162 163
				     0xFFFF, 0xFFFF);

    if ( _hb_ot_layout_has_new_glyph_classes (layout) )
    {
      /* this is a guess only ... */

      if ( property == HB_OT_LAYOUT_GLYPH_CLASS_LIGATURE )
        property = HB_OT_LAYOUT_GLYPH_CLASS_BASE_GLYPH;

      set_glyph_class (layout, property);
    }

    return true;
  }

B
Behdad Esfahbod 已提交
164
  private:
B
Behdad Esfahbod 已提交
165 166
  ArrayOf<GlyphID>
		substitute;		/* String of GlyphIDs to substitute */
B
Behdad Esfahbod 已提交
167
};
168
ASSERT_SIZE (Sequence, 2);
B
Behdad Esfahbod 已提交
169

170 171 172 173 174 175
struct MultipleSubstFormat1 {

  friend struct MultipleSubst;

  private:

176
  inline bool substitute (LOOKUP_ARGS_DEF) const {
177

B
Behdad Esfahbod 已提交
178
    unsigned int index = (this+coverage) (IN_CURGLYPH ());
179
    return (this+sequence[index]).substitute_sequence (LOOKUP_ARGS);
180
  }
B
Behdad Esfahbod 已提交
181 182 183

  private:
  USHORT	substFormat;		/* Format identifier--format = 1 */
B
Behdad Esfahbod 已提交
184 185
  OffsetTo<Coverage>
		coverage;		/* Offset to Coverage table--from
B
Behdad Esfahbod 已提交
186
					 * beginning of Substitution table */
B
Behdad Esfahbod 已提交
187 188 189
  OffsetArrayOf<Sequence>
		sequence;		/* Array of Sequence tables
					 * ordered by Coverage Index */
B
Behdad Esfahbod 已提交
190
};
191 192 193 194
ASSERT_SIZE (MultipleSubstFormat1, 6);

struct MultipleSubst {

195 196 197 198
  friend struct SubstLookupSubTable;

  private:

199
  inline bool substitute (LOOKUP_ARGS_DEF) const {
200
    switch (u.substFormat) {
201
    case 1: return u.format1.substitute (LOOKUP_ARGS);
202 203 204 205 206 207 208 209 210 211 212 213
    default:return false;
    }
  }

  private:
  union {
  USHORT	substFormat;	/* Format identifier */
  MultipleSubstFormat1	format1;
  } u;
};
DEFINE_NULL (MultipleSubst, 2);

B
Behdad Esfahbod 已提交
214

B
Behdad Esfahbod 已提交
215
typedef ArrayOf<GlyphID> AlternateSet;	/* Array of alternate GlyphIDs--in
B
Behdad Esfahbod 已提交
216
					 * arbitrary order */
217
ASSERT_SIZE (AlternateSet, 2);
B
Behdad Esfahbod 已提交
218

219
struct AlternateSubstFormat1 {
220 221 222 223 224

  friend struct AlternateSubst;

  private:

225
  inline bool substitute (LOOKUP_ARGS_DEF) const {
226

227
    hb_codepoint_t glyph_id = IN_CURGLYPH ();
228

B
Behdad Esfahbod 已提交
229
    unsigned int index = (this+coverage) (glyph_id);
B
Behdad Esfahbod 已提交
230
    const AlternateSet &alt_set = this+alternateSet[index];
231

B
Behdad Esfahbod 已提交
232
    if (HB_UNLIKELY (!alt_set.len))
233 234 235 236 237 238 239 240 241 242 243
      return false;

    unsigned int alt_index = 0;

    /* XXX callback to user to choose alternate
    if ( gsub->altfunc )
      alt_index = (gsub->altfunc)( buffer->out_pos, glyph_id,
				   aset.GlyphCount, aset.Alternate,
				   gsub->data );
				   */

B
Behdad Esfahbod 已提交
244
    if (HB_UNLIKELY (alt_index >= alt_set.len))
245 246 247 248
      return false;

    glyph_id = alt_set[alt_index];

B
Behdad Esfahbod 已提交
249
    _hb_buffer_replace_glyph (buffer, glyph_id);
250 251 252 253 254 255 256 257 258

    if ( _hb_ot_layout_has_new_glyph_classes (layout) )
    {
      /* we inherit the old glyph class to the substituted glyph */
      _hb_ot_layout_set_glyph_property (layout, glyph_id, property);
    }

    return true;
  }
B
Behdad Esfahbod 已提交
259 260 261

  private:
  USHORT	substFormat;		/* Format identifier--format = 1 */
B
Behdad Esfahbod 已提交
262 263
  OffsetTo<Coverage>
		coverage;		/* Offset to Coverage table--from
B
Behdad Esfahbod 已提交
264
					 * beginning of Substitution table */
B
Behdad Esfahbod 已提交
265 266 267
  OffsetArrayOf<AlternateSet>
		alternateSet;		/* Array of AlternateSet tables
					 * ordered by Coverage Index */
B
Behdad Esfahbod 已提交
268
};
269 270
ASSERT_SIZE (AlternateSubstFormat1, 6);

271 272 273 274 275 276
struct AlternateSubst {

  friend struct SubstLookupSubTable;

  private:

277
  inline bool substitute (LOOKUP_ARGS_DEF) const {
278
    switch (u.substFormat) {
279
    case 1: return u.format1.substitute (LOOKUP_ARGS);
280 281 282 283 284 285 286 287 288 289 290 291
    default:return false;
    }
  }

  private:
  union {
  USHORT	substFormat;	/* Format identifier */
  AlternateSubstFormat1	format1;
  } u;
};
DEFINE_NULL (AlternateSubst, 2);

292 293

struct Ligature {
294 295 296 297 298 299

  friend struct LigatureSet;

  private:
  DEFINE_ARRAY_TYPE (GlyphID, component, (compCount ? compCount - 1 : 0));

B
Behdad Esfahbod 已提交
300
  inline bool substitute_ligature (LOOKUP_ARGS_DEF, bool is_mark) const {
301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348

    unsigned int i, j;
    unsigned int count = compCount;

    if (HB_UNLIKELY (buffer->in_pos + count > buffer->in_length ||
		     context_length < count))
      return false; /* Not enough glyphs in input or context */

    for (i = 1, j = buffer->in_pos + 1; i < count; i++, j++) {
      while (!_hb_ot_layout_check_glyph_property (layout, IN_ITEM (j), lookup_flag, &property)) {
	if (HB_UNLIKELY (j + count - i == buffer->in_length))
	  return false;
	j++;
      }

      if (!(property == HB_OT_LAYOUT_GLYPH_CLASS_MARK ||
	    property &  LookupFlag::MarkAttachmentType))
	is_mark = FALSE;

      if (HB_LIKELY (IN_GLYPH(j) != (*this)[i - 1]))
        return false;
    }
    if ( _hb_ot_layout_has_new_glyph_classes (layout) )
      /* this is just a guess ... */
      hb_ot_layout_set_glyph_class (layout, ligGlyph,
				    is_mark ? HB_OT_LAYOUT_GLYPH_CLASS_MARK
					    : HB_OT_LAYOUT_GLYPH_CLASS_LIGATURE);

    if (j == buffer->in_pos + i) /* No input glyphs skipped */
      /* We don't use a new ligature ID if there are no skipped
	 glyphs and the ligature already has an ID. */
      _hb_buffer_add_output_glyph_ids (buffer, i,
				       1, &ligGlyph,
				       0xFFFF,
				       IN_LIGID (buffer->in_pos) ?
				       0xFFFF : _hb_buffer_allocate_ligid (buffer));
    else
    {
      unsigned int lig_id = _hb_buffer_allocate_ligid (buffer);
      _hb_buffer_add_output_glyph (buffer, ligGlyph, 0xFFFF, lig_id);

      /* Now we must do a second loop to copy the skipped glyphs to
	 `out' and assign component values to it.  We start with the
	 glyph after the first component.  Glyphs between component
	 i and i+1 belong to component i.  Together with the lig_id
	 value it is later possible to check whether a specific
	 component value really belongs to a given ligature. */

B
Behdad Esfahbod 已提交
349
      for ( i = 1; i < count; i++ )
350 351
      {
	while (!_hb_ot_layout_check_glyph_property (layout, IN_CURITEM(), lookup_flag, &property))
B
Behdad Esfahbod 已提交
352
	  _hb_buffer_add_output_glyph (buffer, IN_CURGLYPH(), i - 1, lig_id);
353 354 355 356 357 358 359 360 361 362 363

	(buffer->in_pos)++;
      }

      /* XXX We  should possibly reassign lig_id and component for any
       * components of a previous ligature that s now being removed as part of
       * this ligature. */
    }

    return true;
  }
364 365 366 367 368 369 370 371

  private:
  GlyphID	ligGlyph;		/* GlyphID of ligature to substitute */
  USHORT	compCount;		/* Number of components in the ligature */
  GlyphID	component[];		/* Array of component GlyphIDs--start
					 * with the second  component--ordered
					 * in writing direction */
};
372
ASSERT_SIZE (Ligature, 4);
B
Behdad Esfahbod 已提交
373 374

struct LigatureSet {
375 376 377 378 379

  friend struct LigatureSubstFormat1;

  private:

B
Behdad Esfahbod 已提交
380
  inline bool substitute_ligature (LOOKUP_ARGS_DEF, bool is_mark) const {
381

B
Behdad Esfahbod 已提交
382
    unsigned int num_ligs = ligature.len;
383
    for (unsigned int i = 0; i < num_ligs; i++) {
B
Behdad Esfahbod 已提交
384
      const Ligature &lig = this+ligature[i];
B
Behdad Esfahbod 已提交
385
      if (lig.substitute_ligature (LOOKUP_ARGS, is_mark))
386 387 388 389 390
        return true;
    }

    return false;
  }
B
Behdad Esfahbod 已提交
391 392

  private:
B
Behdad Esfahbod 已提交
393 394 395
  OffsetArrayOf<Ligature>
		ligature;		/* Array LigatureSet tables
					 * ordered by preference */
B
Behdad Esfahbod 已提交
396
};
397
ASSERT_SIZE (LigatureSet, 2);
B
Behdad Esfahbod 已提交
398

399
struct LigatureSubstFormat1 {
400 401 402 403 404

  friend struct LigatureSubst;

  private:

405
  inline bool substitute (LOOKUP_ARGS_DEF) const {
406 407 408 409 410 411

    hb_codepoint_t glyph_id = IN_CURGLYPH ();

    bool first_is_mark = (property == HB_OT_LAYOUT_GLYPH_CLASS_MARK ||
			  property &  LookupFlag::MarkAttachmentType);

B
Behdad Esfahbod 已提交
412 413
    unsigned int index = (this+coverage) (glyph_id);
    const LigatureSet &lig_set = this+ligatureSet[index];
B
Behdad Esfahbod 已提交
414
    return lig_set.substitute_ligature (LOOKUP_ARGS, first_is_mark);
415
  }
B
Behdad Esfahbod 已提交
416 417

  private:
418
  USHORT	substFormat;		/* Format identifier--format = 1 */
B
Behdad Esfahbod 已提交
419 420
  OffsetTo<Coverage>
		coverage;		/* Offset to Coverage table--from
421
					 * beginning of Substitution table */
B
Behdad Esfahbod 已提交
422 423 424
  OffsetArrayOf<LigatureSet>\
		ligatureSet;		/* Array LigatureSet tables
					 * ordered by Coverage Index */
B
Behdad Esfahbod 已提交
425
};
426 427
ASSERT_SIZE (LigatureSubstFormat1, 6);

428 429 430 431 432 433
struct LigatureSubst {

  friend struct SubstLookupSubTable;

  private:

434
  inline bool substitute (LOOKUP_ARGS_DEF) const {
435
    switch (u.substFormat) {
436
    case 1: return u.format1.substitute (LOOKUP_ARGS);
437 438 439 440 441 442 443 444 445 446 447 448
    default:return false;
    }
  }

  private:
  union {
  USHORT	substFormat;	/* Format identifier */
  LigatureSubstFormat1	format1;
  } u;
};
DEFINE_NULL (LigatureSubst, 2);

B
Behdad Esfahbod 已提交
449

450

451
static inline bool substitute_lookup (LOOKUP_ARGS_DEF, unsigned int lookup_index);
B
Behdad Esfahbod 已提交
452

453
struct ContextSubst : Context {
B
Behdad Esfahbod 已提交
454

455
  inline bool substitute (LOOKUP_ARGS_DEF) const {
456
    return this->apply (LOOKUP_ARGS, substitute_lookup);
457 458
  }
};
459 460 461
DEFINE_NULL (ContextSubst, 2);


B
Behdad Esfahbod 已提交
462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481
struct ChainSubRule {
  /* TODO */

  private:
  USHORT	backtrackGlyphCount;	/* Total number of glyphs in the
					 * backtrack sequence (number of
					 * glyphs to be matched before the
					 * first glyph) */
  GlyphID	backtrack[];		/* Array of backtracking GlyphID's
					 * (to be matched before the input
					 * sequence) */
  USHORT	inputGlyphCount;	/* Total number of glyphs in the input
					 * sequence (includes the first  glyph) */
  GlyphID	input[];		/* Array of input GlyphIDs (start with
					 * second glyph) */
  USHORT	lookaheadGlyphCount;	/* Total number of glyphs in the look
					 * ahead sequence (number of  glyphs to
					 * be matched after the input sequence) */
  GlyphID	lookAhead[];		/* Array of lookahead GlyphID's (to be
					 * matched after  the input sequence) */
482 483
  USHORT	substCount;		/* Number of LookupRecords */
  LookupRecord	substLookupRecord[];	/* Array of LookupRecords--in
B
Behdad Esfahbod 已提交
484 485
					 * design order) */
};
486
ASSERT_SIZE (ChainSubRule, 8);
B
Behdad Esfahbod 已提交
487

B
Behdad Esfahbod 已提交
488
struct ChainSubRuleSet {
B
Behdad Esfahbod 已提交
489 490 491
  /* TODO */

  private:
B
Behdad Esfahbod 已提交
492 493
  USHORT	chainSubRuleCount;	/* Number of ChainSubRule tables */
  Offset	chainSubRule[];		/* Array of offsets to ChainSubRule
B
Behdad Esfahbod 已提交
494
					 * tables--from beginning of
B
Behdad Esfahbod 已提交
495 496
					 * ChainSubRuleSet table--ordered
					 * by preference */
B
Behdad Esfahbod 已提交
497
};
498
ASSERT_SIZE (ChainSubRuleSet, 2);
B
Behdad Esfahbod 已提交
499

B
Behdad Esfahbod 已提交
500
struct ChainContextSubstFormat1 {
B
Behdad Esfahbod 已提交
501
  /* TODO */
502
  inline bool substitute (LOOKUP_ARGS_DEF) const {
B
Behdad Esfahbod 已提交
503 504
    return false;
  }
B
Behdad Esfahbod 已提交
505 506

  private:
B
Behdad Esfahbod 已提交
507 508 509 510 511 512 513
  USHORT	substFormat;		/* Format identifier--format = 1 */
  Offset	coverage;		/* Offset to Coverage table--from
					 * beginning of Substitution table */
  USHORT	chainSubRuleSetCount;	/* Number of ChainSubRuleSet
					 * tables--must equal GlyphCount in
					 * Coverage table */
  Offset	chainSubRuleSet[];	/* Array of offsets to ChainSubRuleSet
B
Behdad Esfahbod 已提交
514
					 * tables--from beginning of
B
Behdad Esfahbod 已提交
515 516
					 * Substitution table--ordered by
					 * Coverage Index */
B
Behdad Esfahbod 已提交
517
};
B
Behdad Esfahbod 已提交
518
ASSERT_SIZE (ChainContextSubstFormat1, 6);
B
Behdad Esfahbod 已提交
519 520 521 522 523 524 525 526 527

struct ChainSubClassRule {
  /* TODO */

  private:
  USHORT	backtrackGlyphCount;	/* Total number of glyphs in the
					 * backtrack sequence (number of
					 * glyphs to be matched before the
					 * first glyph) */
B
Behdad Esfahbod 已提交
528
  USHORT	backtrack[];		/* Array of backtracking classes (to be
B
Behdad Esfahbod 已提交
529 530 531 532 533 534 535 536 537 538
					 * matched before the input  sequence) */
  USHORT	inputGlyphCount;	/* Total number of classes in the input
					 * sequence (includes the  first class) */
  USHORT	input[];		/* Array of input classes(start with
					 * second class; to  be matched with
					 * the input glyph sequence) */
  USHORT	lookaheadGlyphCount;	/* Total number of classes in the
					 * look ahead sequence (number of
					 * classes to be matched after the
					 * input sequence) */
B
Behdad Esfahbod 已提交
539
  USHORT	lookAhead[];		/* Array of lookahead classes (to be
B
Behdad Esfahbod 已提交
540
					 * matched after the  input sequence) */
541 542
  USHORT	substCount;		/* Number of LookupRecords */
  LookupRecord	substLookupRecord[];	/* Array of LookupRecords--in
B
Behdad Esfahbod 已提交
543 544
					 * design order) */
};
545
ASSERT_SIZE (ChainSubClassRule, 8);
B
Behdad Esfahbod 已提交
546

B
Behdad Esfahbod 已提交
547 548 549 550 551 552 553 554 555 556 557
struct ChainSubClassSet {
  /* TODO */

  private:
  USHORT	chainSubClassRuleCnt;	/* Number of ChainSubClassRule tables */
  Offset	chainSubClassRule[];	/* Array of offsets
					 * to ChainSubClassRule
					 * tables--from beginning of
					 * ChainSubClassSet--ordered by
					 * preference */
};
558
ASSERT_SIZE (ChainSubClassSet, 2);
B
Behdad Esfahbod 已提交
559 560 561

struct ChainContextSubstFormat2 {
  /* TODO */
562
  inline bool substitute (LOOKUP_ARGS_DEF) const {
B
Behdad Esfahbod 已提交
563 564
    return false;
  }
B
Behdad Esfahbod 已提交
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

  private:
  USHORT	substFormat;		/* Format identifier--format = 2 */
  Offset	coverage;		/* Offset to Coverage table--from
					 * beginning of Substitution table */
  Offset	backtrackClassDef;	/* Offset to glyph ClassDef table
					 * containing backtrack sequence
					 * data--from beginning of Substitution
					 * table */
  Offset	inputClassDef;		/* Offset to glyph ClassDef
					 * table containing input sequence
					 * data--from beginning of Substitution
					 * table */
  Offset	lookaheadClassDef;	/* Offset to glyph ClassDef table
					 * containing lookahead sequence
					 * data--from beginning of Substitution
					 * table */
  USHORT	chainSubClassSetCnt;	/* Number of ChainSubClassSet tables */
  Offset	chainSubClassSet[];	/* Array of offsets to ChainSubClassSet
					 * tables--from beginning of
					 * Substitution table--ordered by input
					 * class--may be NULL */
};
ASSERT_SIZE (ChainContextSubstFormat2, 12);

B
Behdad Esfahbod 已提交
590 591
struct ChainContextSubstFormat3 {
  /* TODO */
592
  inline bool substitute (LOOKUP_ARGS_DEF) const {
B
Behdad Esfahbod 已提交
593 594
    return false;
  }
B
Behdad Esfahbod 已提交
595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611

  private:
  USHORT	substFormat;		/* Format identifier--format = 3 */
  USHORT	backtrackGlyphCount;	/* Number of glyphs in the backtracking
					 * sequence */
  Offset	backtrackCoverage[];	/* Array of offsets to coverage tables
					 * in backtracking sequence, in  glyph
					 * sequence order */
  USHORT	inputGlyphCount;	/* Number of glyphs in input sequence */
  Offset	inputCoverage[];	/* Array of offsets to coverage
					 * tables in input sequence, in glyph
					 * sequence order */
  USHORT	lookaheadGlyphCount;	/* Number of glyphs in lookahead
					 * sequence */
  Offset	lookaheadCoverage[];	/* Array of offsets to coverage tables
					 * in lookahead sequence, in  glyph
					 * sequence order */
612 613
  USHORT	substCount;		/* Number of LookupRecords */
  LookupRecord	substLookupRecord[];	/* Array of LookupRecords--in
B
Behdad Esfahbod 已提交
614 615 616 617
					 * design order */
};
ASSERT_SIZE (ChainContextSubstFormat3, 10);

B
Behdad Esfahbod 已提交
618 619 620 621 622 623
struct ChainContextSubst {

  friend struct SubstLookupSubTable;

  private:

624
  inline bool substitute (LOOKUP_ARGS_DEF) const {
B
Behdad Esfahbod 已提交
625
    switch (u.substFormat) {
626 627 628
    case 1: return u.format1.substitute (LOOKUP_ARGS);
    case 2: return u.format2.substitute (LOOKUP_ARGS);
    case 3: return u.format3.substitute (LOOKUP_ARGS);
B
Behdad Esfahbod 已提交
629 630 631 632 633 634 635 636 637 638 639 640 641 642
    default:return false;
    }
  }

  private:
  union {
  USHORT	substFormat;	/* Format identifier */
  ChainContextSubstFormat1	format1;
  ChainContextSubstFormat2	format2;
  ChainContextSubstFormat3	format3;
  } u;
};
DEFINE_NULL (ChainContextSubst, 2);

643

B
Behdad Esfahbod 已提交
644
struct ExtensionSubstFormat1 {
645 646 647 648 649

  friend struct ExtensionSubst;

  private:
  inline unsigned int get_type (void) const { return extensionLookupType; }
650
  inline bool substitute (LOOKUP_ARGS_DEF) const;
B
Behdad Esfahbod 已提交
651 652 653 654 655 656 657 658 659 660 661

  private:
  USHORT	substFormat;		/* Format identifier. Set to 1. */
  USHORT	extensionLookupType;	/* Lookup type of subtable referenced
					 * by ExtensionOffset (i.e. the
					 * extension subtable). */
  ULONG		extensionOffset;	/* Offset to the extension subtable,
					 * of lookup type  subtable. */
};
ASSERT_SIZE (ExtensionSubstFormat1, 8);

662 663 664 665 666 667 668 669 670 671 672 673 674 675
struct ExtensionSubst {

  friend struct SubstLookup;
  friend struct SubstLookupSubTable;

  private:

  inline unsigned int get_type (void) const {
    switch (u.substFormat) {
    case 1: return u.format1.get_type ();
    default:return 0;
    }
  }

676
  inline bool substitute (LOOKUP_ARGS_DEF) const {
677
    switch (u.substFormat) {
678
    case 1: return u.format1.substitute (LOOKUP_ARGS);
679 680 681 682 683 684 685 686 687 688 689 690 691 692
    default:return false;
    }
  }

  private:
  union {
  USHORT	substFormat;	/* Format identifier */
  ExtensionSubstFormat1	format1;
  } u;
};
DEFINE_NULL (ExtensionSubst, 2);



B
Behdad Esfahbod 已提交
693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716
struct ReverseChainSingleSubstFormat1 {
  /* TODO */

  private:
  USHORT	substFormat;		/* Format identifier--format = 1 */
  Offset	coverage;		/* Offset to Coverage table -- from
					 * beginning of Substitution table */
  USHORT	backtrackGlyphCount;	/* Number of glyphs in the backtracking
					 * sequence */
  Offset	backtrackCoverage[];	/* Array of offsets to coverage tables
					 * in backtracking sequence, in  glyph
					 * sequence order */
  USHORT	lookaheadGlyphCount;	/* Number of glyphs in lookahead
					 * sequence */
  Offset	lookaheadCoverage[];	/* Array of offsets to coverage tables
					 * in lookahead sequence, in  glyph
					 * sequence order */
  USHORT	glyphCount;		/* Number of GlyphIDs in the Substitute
					 * array */
  GlyphID	substitute[];		/* Array of substitute
					 * GlyphIDs--ordered by Coverage  Index */
};
ASSERT_SIZE (ReverseChainSingleSubstFormat1, 10);

B
Behdad Esfahbod 已提交
717 718 719 720
/*
 * SubstLookup
 */

721 722 723
enum {
  GSUB_Single				= 1,
  GSUB_Multiple				= 2,
724
  GSUB_Alternate			= 3,
725 726 727
  GSUB_Ligature				= 4,
  GSUB_Context				= 5,
  GSUB_ChainingContext			= 6,
728 729
  GSUB_Extension			= 7,
  GSUB_ReverseChainingContextSingle	= 8,
730 731
};

B
Behdad Esfahbod 已提交
732 733 734 735
struct SubstLookupSubTable {

  friend struct SubstLookup;

B
Behdad Esfahbod 已提交
736
  inline bool substitute (LOOKUP_ARGS_DEF,
737
			  unsigned int lookup_type) const {
738

739
    switch (lookup_type) {
740 741 742 743 744
    case GSUB_Single:				return u.single.substitute (LOOKUP_ARGS);
    case GSUB_Multiple:				return u.multiple.substitute (LOOKUP_ARGS);
    case GSUB_Alternate:			return u.alternate.substitute (LOOKUP_ARGS);
    case GSUB_Ligature:				return u.ligature.substitute (LOOKUP_ARGS);
    case GSUB_Context:				return u.context.substitute (LOOKUP_ARGS);
745
    /*
746
    case GSUB_ChainingContext:			return u.chainingContext.substitute (LOOKUP_ARGS);
747
    */
748
    case GSUB_Extension:			return u.extension.substitute (LOOKUP_ARGS);
749
			/*
750
    case GSUB_ReverseChainingContextSingle:	return u.reverseChainingContextSingle.substitute (LOOKUP_ARGS);
751 752 753
    */
    default:return false;
    }
B
Behdad Esfahbod 已提交
754 755 756 757
  }

  private:
  union {
758 759 760 761 762 763
  USHORT				substFormat;
  SingleSubst				single;
  MultipleSubst				multiple;
  AlternateSubst			alternate;
  LigatureSubst				ligature;
  ContextSubst				context;
764
  /*
765 766 767 768 769 770
  ChainingContextSubst			chainingContext;
  */
  ExtensionSubst			extension;
  /*
  ReverseChainingContextSingleSubst	reverseChainingContextSingle;
  */
B
Behdad Esfahbod 已提交
771 772 773
  } u;
};

774

B
Behdad Esfahbod 已提交
775 776 777 778 779 780 781
struct SubstLookup : Lookup {

  inline const SubstLookupSubTable& get_subtable (unsigned int i) const {
    return *(SubstLookupSubTable*)&(((Lookup *)this)->get_subtable (i));
  }

  /* Like get_type(), but looks through extension lookups.
782
   * Never returns Extension */
B
Behdad Esfahbod 已提交
783 784 785
  inline unsigned int get_effective_type (void) const {
    unsigned int type = get_type ();

786
    if (HB_UNLIKELY (type == GSUB_Extension)) {
B
Behdad Esfahbod 已提交
787 788 789
      /* Return lookup type of first extension subtable.
       * The spec says all of them should have the same type.
       * XXX check for that somehow */
790
      type = get_subtable(0).u.extension.get_type ();
B
Behdad Esfahbod 已提交
791 792 793 794 795 796 797
    }

    return type;
  }

  inline bool is_reverse (void) const {
    switch (get_effective_type ()) {
798 799
    case GSUB_ReverseChainingContextSingle:	return true;
    default:					return false;
B
Behdad Esfahbod 已提交
800 801 802
    }
  }

803 804 805 806 807
  inline bool substitute_subtables (hb_ot_layout_t *layout,
				    hb_buffer_t    *buffer,
				    unsigned int    context_length,
				    unsigned int    nesting_level_left,
				    unsigned int    property) const {
B
Behdad Esfahbod 已提交
808
    unsigned int lookup_type = get_type ();
B
Behdad Esfahbod 已提交
809
    unsigned int lookup_flag = get_flag ();
B
Behdad Esfahbod 已提交
810 811

    for (unsigned int i = 0; i < get_subtable_count (); i++)
B
Behdad Esfahbod 已提交
812
      if (get_subtable (i).substitute (LOOKUP_ARGS,
813
				       lookup_type))
B
Behdad Esfahbod 已提交
814
	return true;
B
Behdad Esfahbod 已提交
815

B
Behdad Esfahbod 已提交
816 817
    return false;
  }
818

819 820 821 822 823 824 825 826 827 828 829 830
  inline bool substitute_once (hb_ot_layout_t *layout,
			       hb_buffer_t    *buffer) const {

    unsigned int lookup_flag = get_flag ();

    unsigned int property;
    if (!_hb_ot_layout_check_glyph_property (layout, IN_CURITEM (), lookup_flag, &property))
      return false;

    return substitute_subtables (layout, buffer, NO_CONTEXT, MAX_NESTING_LEVEL, property);
  }

831 832 833
  bool substitute_string (hb_ot_layout_t *layout,
			  hb_buffer_t    *buffer,
			  hb_ot_layout_feature_mask_t mask) const {
834 835 836

    bool ret = false;

B
Behdad Esfahbod 已提交
837 838 839
    if (HB_UNLIKELY (!buffer->in_length))
      return false;

840
    if (HB_LIKELY (!is_reverse ())) {
841 842 843 844 845 846 847

	/* in/out forward substitution */
	_hb_buffer_clear_output (buffer);
	buffer->in_pos = 0;
	while (buffer->in_pos < buffer->in_length) {

	  if ((~IN_PROPERTIES (buffer->in_pos) & mask) &&
848
	      substitute_once (layout, buffer))
849 850
	    ret = true;
	  else
B
Behdad Esfahbod 已提交
851
	    _hb_buffer_next_glyph (buffer);
852 853 854 855 856 857 858 859 860 861 862 863

	}
	if (ret)
	  _hb_buffer_swap (buffer);

    } else {

	/* in-place backward substitution */
	buffer->in_pos = buffer->in_length - 1;
	do {

	  if ((~IN_PROPERTIES (buffer->in_pos) & mask) &&
864
	      substitute_once (layout, buffer))
865 866 867 868
	    ret = true;
	  else
	    buffer->in_pos--;

869
	} while ((int) buffer->in_pos >= 0);
870 871 872 873
    }

    return ret;
  }
B
Behdad Esfahbod 已提交
874 875
};

876

B
Minor  
Behdad Esfahbod 已提交
877 878 879 880 881 882 883 884 885
/*
 * GSUB
 */

struct GSUB : GSUBGPOS {
  static const hb_tag_t Tag		= HB_TAG ('G','S','U','B');

  STATIC_DEFINE_GET_FOR_DATA (GSUB);
  /* XXX check version here? */
B
Behdad Esfahbod 已提交
886 887 888 889 890

  inline const SubstLookup& get_lookup (unsigned int i) const {
    return *(SubstLookup*)&(((GSUBGPOS *)this)->get_lookup (i));
  }

891 892 893 894 895 896
  inline bool substitute_lookup (hb_ot_layout_t *layout,
				 hb_buffer_t    *buffer,
			         unsigned int    lookup_index,
				 hb_ot_layout_feature_mask_t  mask) const {
    return get_lookup (lookup_index).substitute_string (layout, buffer, mask);
  }
B
Behdad Esfahbod 已提交
897

B
Minor  
Behdad Esfahbod 已提交
898 899 900
};


901 902 903 904


/* Out-of-class implementation for methods chaining */

905
inline bool ExtensionSubstFormat1::substitute (LOOKUP_ARGS_DEF) const {
906 907
  /* XXX either check in sanitize or here that the lookuptype is not 7 again,
   * or we can loop indefinitely. */
B
Behdad Esfahbod 已提交
908
  return (*(SubstLookupSubTable *)(((char *) this) + extensionOffset)).substitute (LOOKUP_ARGS,
909 910 911
										   get_type ());
}

912
static inline bool substitute_lookup (LOOKUP_ARGS_DEF, unsigned int lookup_index) {
913
  const GSUB &gsub = *(layout->gsub);
914
  const SubstLookup &l = gsub.get_lookup (lookup_index);
915

916 917 918 919 920 921 922
  if (HB_UNLIKELY (nesting_level_left == 0))
    return false;
  nesting_level_left--;

  if (HB_UNLIKELY (context_length < 1))
    return false;

923
  return l.substitute_subtables (layout, buffer, context_length, nesting_level_left, property);
924 925 926
}


B
Behdad Esfahbod 已提交
927
#endif /* HB_OT_LAYOUT_GSUB_PRIVATE_H */