2008-01-23 23:01:55 +01:00
|
|
|
/*
|
2009-04-16 10:45:30 +02:00
|
|
|
* Copyright (C) 2007,2008,2009 Red Hat, Inc.
|
2008-01-23 23:01:55 +01:00
|
|
|
*
|
|
|
|
* 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
|
|
|
|
|
2009-05-17 14:28:42 +02:00
|
|
|
#include "hb-ot-layout-gsubgpos-private.h"
|
2008-01-23 23:01:55 +01:00
|
|
|
|
2009-05-18 02:13:02 +02:00
|
|
|
/* XXX */
|
|
|
|
#include "harfbuzz-impl.h"
|
|
|
|
HB_INTERNAL HB_Error
|
|
|
|
_hb_buffer_add_output_glyph_ids( HB_Buffer buffer,
|
|
|
|
HB_UShort num_in,
|
|
|
|
HB_UShort num_out,
|
|
|
|
const GlyphID *glyph_data,
|
|
|
|
HB_UShort component,
|
|
|
|
HB_UShort ligID );
|
|
|
|
|
2009-05-18 02:28:01 +02:00
|
|
|
|
2008-01-23 23:01:55 +01:00
|
|
|
struct SingleSubstFormat1 {
|
2009-04-16 01:50:16 +02:00
|
|
|
|
|
|
|
friend struct SingleSubst;
|
|
|
|
|
|
|
|
private:
|
2009-04-16 04:56:15 +02:00
|
|
|
|
2009-04-16 10:45:30 +02:00
|
|
|
inline bool single_substitute (hb_codepoint_t &glyph_id) const {
|
2009-04-16 04:56:15 +02:00
|
|
|
|
2009-05-17 06:22:37 +02:00
|
|
|
unsigned int index = (this+coverage) (glyph_id);
|
2009-05-18 11:29:29 +02:00
|
|
|
if (HB_LIKELY (index == NOT_COVERED))
|
2009-04-16 04:56:15 +02:00
|
|
|
return false;
|
|
|
|
|
|
|
|
glyph_id += deltaGlyphID;
|
|
|
|
|
|
|
|
return true;
|
2009-04-16 10:45:30 +02:00
|
|
|
}
|
2009-04-16 04:56:15 +02:00
|
|
|
|
2008-01-23 23:01:55 +01:00
|
|
|
private:
|
2009-05-18 02:13:02 +02:00
|
|
|
USHORT format; /* Format identifier--format = 1 */
|
2009-05-17 06:22:37 +02:00
|
|
|
OffsetTo<Coverage>
|
|
|
|
coverage; /* Offset to Coverage table--from
|
2008-01-23 23:01:55 +01:00
|
|
|
* beginning of Substitution table */
|
|
|
|
SHORT deltaGlyphID; /* Add to original GlyphID to get
|
|
|
|
* substitute GlyphID */
|
|
|
|
};
|
|
|
|
ASSERT_SIZE (SingleSubstFormat1, 6);
|
|
|
|
|
|
|
|
struct SingleSubstFormat2 {
|
2009-04-16 10:45:30 +02:00
|
|
|
|
|
|
|
friend struct SingleSubst;
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
|
|
|
inline bool single_substitute (hb_codepoint_t &glyph_id) const {
|
|
|
|
|
2009-05-17 06:22:37 +02:00
|
|
|
unsigned int index = (this+coverage) (glyph_id);
|
2009-05-18 11:29:29 +02:00
|
|
|
if (HB_LIKELY (index == NOT_COVERED))
|
2009-05-18 05:17:56 +02:00
|
|
|
return false;
|
2009-04-16 10:45:30 +02:00
|
|
|
|
2009-05-18 11:29:29 +02:00
|
|
|
if (HB_UNLIKELY (index >= substitute.len))
|
2009-04-16 10:45:30 +02:00
|
|
|
return false;
|
|
|
|
|
|
|
|
glyph_id = substitute[index];
|
|
|
|
return true;
|
|
|
|
}
|
2008-01-23 23:01:55 +01:00
|
|
|
|
|
|
|
private:
|
2009-05-18 02:13:02 +02:00
|
|
|
USHORT format; /* Format identifier--format = 2 */
|
2009-05-17 06:22:37 +02:00
|
|
|
OffsetTo<Coverage>
|
|
|
|
coverage; /* Offset to Coverage table--from
|
2008-01-23 23:01:55 +01:00
|
|
|
* beginning of Substitution table */
|
2009-05-17 07:22:51 +02:00
|
|
|
ArrayOf<GlyphID>
|
|
|
|
substitute; /* Array of substitute
|
|
|
|
* GlyphIDs--ordered by Coverage Index */
|
2008-01-23 23:01:55 +01:00
|
|
|
};
|
|
|
|
ASSERT_SIZE (SingleSubstFormat2, 6);
|
|
|
|
|
2009-04-16 10:45:30 +02:00
|
|
|
struct SingleSubst {
|
|
|
|
|
|
|
|
friend struct SubstLookupSubTable;
|
|
|
|
|
2009-04-16 19:40:13 +02:00
|
|
|
private:
|
|
|
|
|
2009-05-05 02:21:57 +02:00
|
|
|
inline bool single_substitute (hb_codepoint_t &glyph_id) const {
|
2009-05-18 01:47:54 +02:00
|
|
|
switch (u.format) {
|
|
|
|
case 1: return u.format1->single_substitute (glyph_id);
|
|
|
|
case 2: return u.format2->single_substitute (glyph_id);
|
2009-05-05 02:21:57 +02:00
|
|
|
default:return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-05-17 15:34:41 +02:00
|
|
|
inline bool substitute (LOOKUP_ARGS_DEF) const {
|
2009-04-16 10:45:30 +02:00
|
|
|
|
2009-04-16 22:53:40 +02:00
|
|
|
hb_codepoint_t glyph_id = IN_CURGLYPH ();
|
2009-04-16 10:45:30 +02:00
|
|
|
|
2009-05-05 02:21:57 +02:00
|
|
|
if (!single_substitute (glyph_id))
|
|
|
|
return false;
|
2009-04-16 10:45:30 +02:00
|
|
|
|
2009-05-17 12:03:42 +02:00
|
|
|
_hb_buffer_replace_glyph (buffer, glyph_id);
|
2009-04-16 10:45:30 +02:00
|
|
|
|
|
|
|
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 {
|
2009-05-18 01:47:54 +02:00
|
|
|
USHORT format; /* Format identifier */
|
|
|
|
SingleSubstFormat1 format1[];
|
|
|
|
SingleSubstFormat2 format2[];
|
2009-04-16 10:45:30 +02:00
|
|
|
} u;
|
2008-01-23 23:01:55 +01:00
|
|
|
};
|
2009-05-18 01:47:54 +02:00
|
|
|
ASSERT_SIZE (SingleSubst, 2);
|
2009-04-16 10:45:30 +02:00
|
|
|
|
2008-01-23 23:01:55 +01:00
|
|
|
|
|
|
|
struct Sequence {
|
2009-04-16 10:45:30 +02:00
|
|
|
|
|
|
|
friend struct MultipleSubstFormat1;
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
|
|
|
inline void set_glyph_class (hb_ot_layout_t *layout, unsigned int property) const {
|
|
|
|
|
2009-05-17 07:22:51 +02:00
|
|
|
unsigned int count = substitute.len;
|
2009-04-16 22:53:40 +02:00
|
|
|
for (unsigned int n = 0; n < count; n++)
|
2009-04-16 10:45:30 +02:00
|
|
|
_hb_ot_layout_set_glyph_property (layout, substitute[n], property);
|
|
|
|
}
|
2008-01-23 23:01:55 +01:00
|
|
|
|
2009-05-17 15:34:41 +02:00
|
|
|
inline bool substitute_sequence (LOOKUP_ARGS_DEF) const {
|
2009-05-05 22:22:02 +02:00
|
|
|
|
2009-05-17 07:22:51 +02:00
|
|
|
if (HB_UNLIKELY (!substitute.len))
|
2009-05-05 22:22:02 +02:00
|
|
|
return false;
|
|
|
|
|
|
|
|
_hb_buffer_add_output_glyph_ids (buffer, 1,
|
2009-05-17 07:22:51 +02:00
|
|
|
substitute.len, substitute.array,
|
2009-05-05 22:22:02 +02:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2008-01-23 23:01:55 +01:00
|
|
|
private:
|
2009-05-17 07:22:51 +02:00
|
|
|
ArrayOf<GlyphID>
|
|
|
|
substitute; /* String of GlyphIDs to substitute */
|
2008-01-23 23:01:55 +01:00
|
|
|
};
|
2009-05-17 04:48:14 +02:00
|
|
|
ASSERT_SIZE (Sequence, 2);
|
2008-01-23 23:01:55 +01:00
|
|
|
|
2009-04-16 10:45:30 +02:00
|
|
|
struct MultipleSubstFormat1 {
|
|
|
|
|
|
|
|
friend struct MultipleSubst;
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
2009-05-17 15:34:41 +02:00
|
|
|
inline bool substitute (LOOKUP_ARGS_DEF) const {
|
2009-04-16 10:45:30 +02:00
|
|
|
|
2009-05-17 07:22:51 +02:00
|
|
|
unsigned int index = (this+coverage) (IN_CURGLYPH ());
|
2009-05-18 11:29:29 +02:00
|
|
|
if (HB_LIKELY (index == NOT_COVERED))
|
2009-05-18 05:17:56 +02:00
|
|
|
return false;
|
|
|
|
|
2009-05-17 15:34:41 +02:00
|
|
|
return (this+sequence[index]).substitute_sequence (LOOKUP_ARGS);
|
2009-04-16 10:45:30 +02:00
|
|
|
}
|
2008-01-23 23:01:55 +01:00
|
|
|
|
|
|
|
private:
|
2009-05-18 02:13:02 +02:00
|
|
|
USHORT format; /* Format identifier--format = 1 */
|
2009-05-17 06:22:37 +02:00
|
|
|
OffsetTo<Coverage>
|
|
|
|
coverage; /* Offset to Coverage table--from
|
2008-01-23 23:01:55 +01:00
|
|
|
* beginning of Substitution table */
|
2009-05-17 07:22:51 +02:00
|
|
|
OffsetArrayOf<Sequence>
|
|
|
|
sequence; /* Array of Sequence tables
|
|
|
|
* ordered by Coverage Index */
|
2008-01-23 23:01:55 +01:00
|
|
|
};
|
2009-04-16 10:45:30 +02:00
|
|
|
ASSERT_SIZE (MultipleSubstFormat1, 6);
|
|
|
|
|
|
|
|
struct MultipleSubst {
|
|
|
|
|
2009-04-16 19:40:13 +02:00
|
|
|
friend struct SubstLookupSubTable;
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
2009-05-17 15:34:41 +02:00
|
|
|
inline bool substitute (LOOKUP_ARGS_DEF) const {
|
2009-05-18 01:47:54 +02:00
|
|
|
switch (u.format) {
|
|
|
|
case 1: return u.format1->substitute (LOOKUP_ARGS);
|
2009-04-16 10:45:30 +02:00
|
|
|
default:return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
union {
|
2009-05-18 01:47:54 +02:00
|
|
|
USHORT format; /* Format identifier */
|
|
|
|
MultipleSubstFormat1 format1[];
|
2009-04-16 10:45:30 +02:00
|
|
|
} u;
|
|
|
|
};
|
2009-05-18 01:47:54 +02:00
|
|
|
ASSERT_SIZE (MultipleSubst, 2);
|
2009-04-16 10:45:30 +02:00
|
|
|
|
2008-01-23 23:01:55 +01:00
|
|
|
|
2009-05-17 07:22:51 +02:00
|
|
|
typedef ArrayOf<GlyphID> AlternateSet; /* Array of alternate GlyphIDs--in
|
2008-01-23 23:01:55 +01:00
|
|
|
* arbitrary order */
|
2009-05-17 04:48:14 +02:00
|
|
|
ASSERT_SIZE (AlternateSet, 2);
|
2008-01-23 23:01:55 +01:00
|
|
|
|
2009-04-16 10:45:30 +02:00
|
|
|
struct AlternateSubstFormat1 {
|
2009-04-16 20:19:42 +02:00
|
|
|
|
|
|
|
friend struct AlternateSubst;
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
2009-05-17 15:34:41 +02:00
|
|
|
inline bool substitute (LOOKUP_ARGS_DEF) const {
|
2009-04-16 20:19:42 +02:00
|
|
|
|
2009-04-16 22:53:40 +02:00
|
|
|
hb_codepoint_t glyph_id = IN_CURGLYPH ();
|
2009-04-16 20:19:42 +02:00
|
|
|
|
2009-05-17 06:22:37 +02:00
|
|
|
unsigned int index = (this+coverage) (glyph_id);
|
2009-05-18 11:29:29 +02:00
|
|
|
if (HB_LIKELY (index == NOT_COVERED))
|
2009-05-18 05:17:56 +02:00
|
|
|
return false;
|
|
|
|
|
2009-05-17 07:22:51 +02:00
|
|
|
const AlternateSet &alt_set = this+alternateSet[index];
|
2009-04-16 20:19:42 +02:00
|
|
|
|
2009-05-17 07:22:51 +02:00
|
|
|
if (HB_UNLIKELY (!alt_set.len))
|
2009-04-16 20:19:42 +02:00
|
|
|
return false;
|
|
|
|
|
|
|
|
unsigned int alt_index = 0;
|
|
|
|
|
|
|
|
/* XXX callback to user to choose alternate
|
2009-05-18 10:25:22 +02:00
|
|
|
if (layout->altfunc)
|
|
|
|
alt_index = (layout->altfunc)(layout, buffer,
|
|
|
|
buffer->out_pos, glyph_id,
|
|
|
|
alt_set.len, alt_set.array);
|
2009-04-16 20:19:42 +02:00
|
|
|
*/
|
|
|
|
|
2009-05-17 07:22:51 +02:00
|
|
|
if (HB_UNLIKELY (alt_index >= alt_set.len))
|
2009-04-16 20:19:42 +02:00
|
|
|
return false;
|
|
|
|
|
|
|
|
glyph_id = alt_set[alt_index];
|
|
|
|
|
2009-05-17 12:03:42 +02:00
|
|
|
_hb_buffer_replace_glyph (buffer, glyph_id);
|
2009-04-16 20:19:42 +02:00
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
2008-01-23 23:01:55 +01:00
|
|
|
|
|
|
|
private:
|
2009-05-18 02:13:02 +02:00
|
|
|
USHORT format; /* Format identifier--format = 1 */
|
2009-05-17 06:22:37 +02:00
|
|
|
OffsetTo<Coverage>
|
|
|
|
coverage; /* Offset to Coverage table--from
|
2008-01-23 23:01:55 +01:00
|
|
|
* beginning of Substitution table */
|
2009-05-17 07:22:51 +02:00
|
|
|
OffsetArrayOf<AlternateSet>
|
|
|
|
alternateSet; /* Array of AlternateSet tables
|
|
|
|
* ordered by Coverage Index */
|
2008-01-23 23:01:55 +01:00
|
|
|
};
|
2009-04-16 10:45:30 +02:00
|
|
|
ASSERT_SIZE (AlternateSubstFormat1, 6);
|
|
|
|
|
2009-04-16 20:19:42 +02:00
|
|
|
struct AlternateSubst {
|
|
|
|
|
|
|
|
friend struct SubstLookupSubTable;
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
2009-05-17 15:34:41 +02:00
|
|
|
inline bool substitute (LOOKUP_ARGS_DEF) const {
|
2009-05-18 01:47:54 +02:00
|
|
|
switch (u.format) {
|
|
|
|
case 1: return u.format1->substitute (LOOKUP_ARGS);
|
2009-04-16 20:19:42 +02:00
|
|
|
default:return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
union {
|
2009-05-18 01:47:54 +02:00
|
|
|
USHORT format; /* Format identifier */
|
|
|
|
AlternateSubstFormat1 format1[];
|
2009-04-16 20:19:42 +02:00
|
|
|
} u;
|
|
|
|
};
|
2009-05-18 01:47:54 +02:00
|
|
|
ASSERT_SIZE (AlternateSubst, 2);
|
2009-04-16 20:19:42 +02:00
|
|
|
|
2009-04-16 10:45:30 +02:00
|
|
|
|
|
|
|
struct Ligature {
|
2009-05-05 19:25:13 +02:00
|
|
|
|
|
|
|
friend struct LigatureSet;
|
|
|
|
|
|
|
|
private:
|
2009-05-17 13:39:34 +02:00
|
|
|
inline bool substitute_ligature (LOOKUP_ARGS_DEF, bool is_mark) const {
|
2009-05-05 19:25:13 +02:00
|
|
|
|
|
|
|
unsigned int i, j;
|
2009-05-18 08:03:58 +02:00
|
|
|
unsigned int count = component.len;
|
2009-05-18 10:21:53 +02:00
|
|
|
unsigned int end = MIN (buffer->in_length, buffer->in_pos + context_length);
|
|
|
|
if (HB_UNLIKELY (buffer->in_pos + count > end))
|
|
|
|
return false;
|
2009-05-05 19:25:13 +02:00
|
|
|
|
|
|
|
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)) {
|
2009-05-18 10:21:53 +02:00
|
|
|
if (HB_UNLIKELY (j + count - i == end))
|
2009-05-05 19:25:13 +02:00
|
|
|
return false;
|
|
|
|
j++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(property == HB_OT_LAYOUT_GLYPH_CLASS_MARK ||
|
|
|
|
property & LookupFlag::MarkAttachmentType))
|
|
|
|
is_mark = FALSE;
|
|
|
|
|
2009-05-18 08:03:58 +02:00
|
|
|
if (HB_LIKELY (IN_GLYPH(j) != component[i]))
|
2009-05-05 19:25:13 +02:00
|
|
|
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. */
|
|
|
|
|
2009-05-17 15:45:32 +02:00
|
|
|
for ( i = 1; i < count; i++ )
|
2009-05-05 19:25:13 +02:00
|
|
|
{
|
|
|
|
while (!_hb_ot_layout_check_glyph_property (layout, IN_CURITEM(), lookup_flag, &property))
|
2009-05-17 15:45:32 +02:00
|
|
|
_hb_buffer_add_output_glyph (buffer, IN_CURGLYPH(), i - 1, lig_id);
|
2009-05-05 19:25:13 +02:00
|
|
|
|
|
|
|
(buffer->in_pos)++;
|
|
|
|
}
|
|
|
|
|
2009-05-18 10:25:22 +02:00
|
|
|
/* TODO We should possibly reassign lig_id and component for any
|
2009-05-05 19:25:13 +02:00
|
|
|
* components of a previous ligature that s now being removed as part of
|
|
|
|
* this ligature. */
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
2009-04-16 10:45:30 +02:00
|
|
|
|
|
|
|
private:
|
|
|
|
GlyphID ligGlyph; /* GlyphID of ligature to substitute */
|
2009-05-18 08:03:58 +02:00
|
|
|
HeadlessArrayOf<GlyphID>
|
|
|
|
component; /* Array of component GlyphIDs--start
|
2009-04-16 10:45:30 +02:00
|
|
|
* with the second component--ordered
|
|
|
|
* in writing direction */
|
|
|
|
};
|
2009-05-17 04:48:14 +02:00
|
|
|
ASSERT_SIZE (Ligature, 4);
|
2008-01-23 23:01:55 +01:00
|
|
|
|
|
|
|
struct LigatureSet {
|
2009-05-05 19:25:13 +02:00
|
|
|
|
|
|
|
friend struct LigatureSubstFormat1;
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
2009-05-17 13:39:34 +02:00
|
|
|
inline bool substitute_ligature (LOOKUP_ARGS_DEF, bool is_mark) const {
|
2009-05-05 19:25:13 +02:00
|
|
|
|
2009-05-17 07:22:51 +02:00
|
|
|
unsigned int num_ligs = ligature.len;
|
2009-05-05 19:25:13 +02:00
|
|
|
for (unsigned int i = 0; i < num_ligs; i++) {
|
2009-05-17 07:22:51 +02:00
|
|
|
const Ligature &lig = this+ligature[i];
|
2009-05-17 13:39:34 +02:00
|
|
|
if (lig.substitute_ligature (LOOKUP_ARGS, is_mark))
|
2009-05-05 19:25:13 +02:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
2008-01-23 23:01:55 +01:00
|
|
|
|
|
|
|
private:
|
2009-05-17 07:22:51 +02:00
|
|
|
OffsetArrayOf<Ligature>
|
|
|
|
ligature; /* Array LigatureSet tables
|
|
|
|
* ordered by preference */
|
2008-01-23 23:01:55 +01:00
|
|
|
};
|
2009-05-17 04:48:14 +02:00
|
|
|
ASSERT_SIZE (LigatureSet, 2);
|
2008-01-23 23:01:55 +01:00
|
|
|
|
2009-04-16 10:45:30 +02:00
|
|
|
struct LigatureSubstFormat1 {
|
2009-04-16 22:53:40 +02:00
|
|
|
|
|
|
|
friend struct LigatureSubst;
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
2009-05-17 15:34:41 +02:00
|
|
|
inline bool substitute (LOOKUP_ARGS_DEF) const {
|
2009-04-16 22:53:40 +02:00
|
|
|
|
|
|
|
hb_codepoint_t glyph_id = IN_CURGLYPH ();
|
|
|
|
|
|
|
|
bool first_is_mark = (property == HB_OT_LAYOUT_GLYPH_CLASS_MARK ||
|
|
|
|
property & LookupFlag::MarkAttachmentType);
|
|
|
|
|
2009-05-17 07:22:51 +02:00
|
|
|
unsigned int index = (this+coverage) (glyph_id);
|
2009-05-18 11:29:29 +02:00
|
|
|
if (HB_LIKELY (index == NOT_COVERED))
|
2009-05-18 05:17:56 +02:00
|
|
|
return false;
|
|
|
|
|
2009-05-17 07:22:51 +02:00
|
|
|
const LigatureSet &lig_set = this+ligatureSet[index];
|
2009-05-17 13:39:34 +02:00
|
|
|
return lig_set.substitute_ligature (LOOKUP_ARGS, first_is_mark);
|
2009-04-16 22:53:40 +02:00
|
|
|
}
|
2008-01-23 23:01:55 +01:00
|
|
|
|
|
|
|
private:
|
2009-05-18 02:13:02 +02:00
|
|
|
USHORT format; /* Format identifier--format = 1 */
|
2009-05-17 06:22:37 +02:00
|
|
|
OffsetTo<Coverage>
|
|
|
|
coverage; /* Offset to Coverage table--from
|
2009-04-16 10:45:30 +02:00
|
|
|
* beginning of Substitution table */
|
2009-05-17 07:22:51 +02:00
|
|
|
OffsetArrayOf<LigatureSet>\
|
|
|
|
ligatureSet; /* Array LigatureSet tables
|
|
|
|
* ordered by Coverage Index */
|
2008-01-23 23:01:55 +01:00
|
|
|
};
|
2009-04-16 10:45:30 +02:00
|
|
|
ASSERT_SIZE (LigatureSubstFormat1, 6);
|
|
|
|
|
2009-04-16 22:53:40 +02:00
|
|
|
struct LigatureSubst {
|
|
|
|
|
|
|
|
friend struct SubstLookupSubTable;
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
2009-05-17 15:34:41 +02:00
|
|
|
inline bool substitute (LOOKUP_ARGS_DEF) const {
|
2009-05-18 01:47:54 +02:00
|
|
|
switch (u.format) {
|
|
|
|
case 1: return u.format1->substitute (LOOKUP_ARGS);
|
2009-04-16 22:53:40 +02:00
|
|
|
default:return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
union {
|
2009-05-18 01:47:54 +02:00
|
|
|
USHORT format; /* Format identifier */
|
|
|
|
LigatureSubstFormat1 format1[];
|
2009-04-16 22:53:40 +02:00
|
|
|
} u;
|
|
|
|
};
|
2009-05-18 01:47:54 +02:00
|
|
|
ASSERT_SIZE (LigatureSubst, 2);
|
2009-04-16 22:53:40 +02:00
|
|
|
|
2008-01-23 23:01:55 +01:00
|
|
|
|
2009-05-16 00:54:53 +02:00
|
|
|
|
2009-05-17 14:28:42 +02:00
|
|
|
static inline bool substitute_lookup (LOOKUP_ARGS_DEF, unsigned int lookup_index);
|
2009-05-09 01:09:17 +02:00
|
|
|
|
2009-05-18 02:48:27 +02:00
|
|
|
|
2009-05-17 14:28:42 +02:00
|
|
|
struct ContextSubst : Context {
|
2009-05-09 01:09:17 +02:00
|
|
|
|
2009-05-17 15:34:41 +02:00
|
|
|
inline bool substitute (LOOKUP_ARGS_DEF) const {
|
2009-05-17 14:28:42 +02:00
|
|
|
return this->apply (LOOKUP_ARGS, substitute_lookup);
|
2009-05-17 13:52:11 +02:00
|
|
|
}
|
|
|
|
};
|
2009-05-18 01:47:54 +02:00
|
|
|
ASSERT_SIZE (ContextSubst, 2);
|
2009-05-06 06:12:29 +02:00
|
|
|
|
|
|
|
|
2009-05-18 02:48:27 +02:00
|
|
|
struct ChainContextSubst : ChainContext {
|
2009-05-17 01:59:15 +02:00
|
|
|
|
2009-05-17 15:34:41 +02:00
|
|
|
inline bool substitute (LOOKUP_ARGS_DEF) const {
|
2009-05-18 02:48:27 +02:00
|
|
|
return this->apply (LOOKUP_ARGS, substitute_lookup);
|
2009-05-17 01:59:15 +02:00
|
|
|
}
|
|
|
|
};
|
2009-05-18 01:47:54 +02:00
|
|
|
ASSERT_SIZE (ChainContextSubst, 2);
|
2009-05-17 01:59:15 +02:00
|
|
|
|
2009-04-16 19:40:13 +02:00
|
|
|
|
2008-01-23 23:01:55 +01:00
|
|
|
struct ExtensionSubstFormat1 {
|
2009-04-16 19:40:13 +02:00
|
|
|
|
|
|
|
friend struct ExtensionSubst;
|
|
|
|
|
|
|
|
private:
|
|
|
|
inline unsigned int get_type (void) const { return extensionLookupType; }
|
2009-05-18 01:47:54 +02:00
|
|
|
inline unsigned int get_offset (void) const { return (extensionOffset[0] << 16) + extensionOffset[1]; }
|
2009-05-17 15:34:41 +02:00
|
|
|
inline bool substitute (LOOKUP_ARGS_DEF) const;
|
2008-01-23 23:01:55 +01:00
|
|
|
|
|
|
|
private:
|
2009-05-18 02:13:02 +02:00
|
|
|
USHORT format; /* Format identifier. Set to 1. */
|
2008-01-23 23:01:55 +01:00
|
|
|
USHORT extensionLookupType; /* Lookup type of subtable referenced
|
|
|
|
* by ExtensionOffset (i.e. the
|
|
|
|
* extension subtable). */
|
2009-05-18 01:47:54 +02:00
|
|
|
USHORT extensionOffset[2]; /* Offset to the extension subtable,
|
|
|
|
* of lookup type subtable.
|
|
|
|
* Defined as two shorts to avoid
|
|
|
|
* alignment requirements. */
|
2008-01-23 23:01:55 +01:00
|
|
|
};
|
|
|
|
ASSERT_SIZE (ExtensionSubstFormat1, 8);
|
|
|
|
|
2009-04-16 19:40:13 +02:00
|
|
|
struct ExtensionSubst {
|
|
|
|
|
|
|
|
friend struct SubstLookup;
|
|
|
|
friend struct SubstLookupSubTable;
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
|
|
|
inline unsigned int get_type (void) const {
|
2009-05-18 01:47:54 +02:00
|
|
|
switch (u.format) {
|
|
|
|
case 1: return u.format1->get_type ();
|
2009-04-16 19:40:13 +02:00
|
|
|
default:return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-05-17 15:34:41 +02:00
|
|
|
inline bool substitute (LOOKUP_ARGS_DEF) const {
|
2009-05-18 01:47:54 +02:00
|
|
|
switch (u.format) {
|
|
|
|
case 1: return u.format1->substitute (LOOKUP_ARGS);
|
2009-04-16 19:40:13 +02:00
|
|
|
default:return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
union {
|
2009-05-18 01:47:54 +02:00
|
|
|
USHORT format; /* Format identifier */
|
|
|
|
ExtensionSubstFormat1 format1[];
|
2009-04-16 19:40:13 +02:00
|
|
|
} u;
|
|
|
|
};
|
2009-05-18 01:47:54 +02:00
|
|
|
ASSERT_SIZE (ExtensionSubst, 2);
|
2009-04-16 19:40:13 +02:00
|
|
|
|
|
|
|
|
2008-01-23 23:01:55 +01:00
|
|
|
struct ReverseChainSingleSubstFormat1 {
|
2009-05-18 11:47:47 +02:00
|
|
|
|
|
|
|
friend struct ReverseChainSingleSubst;
|
|
|
|
|
|
|
|
private:
|
2009-05-18 02:48:27 +02:00
|
|
|
inline bool substitute (LOOKUP_ARGS_DEF) const {
|
2009-05-18 11:47:47 +02:00
|
|
|
|
|
|
|
if (HB_UNLIKELY (context_length != NO_CONTEXT))
|
|
|
|
return false; /* No chaining to this type */
|
|
|
|
|
|
|
|
unsigned int index = (this+coverage) (IN_CURGLYPH ());
|
|
|
|
if (HB_LIKELY (index == NOT_COVERED))
|
|
|
|
return false;
|
|
|
|
|
|
|
|
const OffsetArrayOf<Coverage> &lookahead = * (const OffsetArrayOf<Coverage> *)
|
|
|
|
((const char *) &backtrack + backtrack.get_size ());
|
|
|
|
const ArrayOf<GlyphID> &substitute = * (const ArrayOf<GlyphID> *)
|
|
|
|
((const char *) &lookahead + lookahead.get_size ());
|
|
|
|
|
|
|
|
if (match_backtrack (LOOKUP_ARGS,
|
|
|
|
backtrack.len, (USHORT *) backtrack.array,
|
|
|
|
match_coverage, (char *) this) &&
|
|
|
|
match_lookahead (LOOKUP_ARGS,
|
|
|
|
lookahead.len, (USHORT *) lookahead.array,
|
|
|
|
match_coverage, (char *) this,
|
|
|
|
1))
|
|
|
|
{
|
|
|
|
IN_CURGLYPH() = substitute[index];
|
|
|
|
buffer->in_pos--; /* Reverse! */
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2009-05-18 02:48:27 +02:00
|
|
|
return false;
|
|
|
|
}
|
2008-01-23 23:01:55 +01:00
|
|
|
|
|
|
|
private:
|
2009-05-18 02:13:02 +02:00
|
|
|
USHORT format; /* Format identifier--format = 1 */
|
2009-05-18 11:47:47 +02:00
|
|
|
OffsetTo<Coverage>
|
|
|
|
coverage; /* Offset to Coverage table--from
|
|
|
|
* beginning of table */
|
|
|
|
OffsetArrayOf<Coverage>
|
|
|
|
backtrack; /* Array of coverage tables
|
2008-01-23 23:01:55 +01:00
|
|
|
* in backtracking sequence, in glyph
|
|
|
|
* sequence order */
|
2009-05-18 11:47:47 +02:00
|
|
|
OffsetArrayOf<Coverage>
|
|
|
|
lookaheadX; /* Array of coverage tables
|
|
|
|
* in lookahead sequence, in glyph
|
2008-01-23 23:01:55 +01:00
|
|
|
* sequence order */
|
2009-05-18 11:47:47 +02:00
|
|
|
ArrayOf<GlyphID>
|
|
|
|
substituteX; /* Array of substitute
|
|
|
|
* GlyphIDs--ordered by Coverage Index */
|
2008-01-23 23:01:55 +01:00
|
|
|
};
|
|
|
|
ASSERT_SIZE (ReverseChainSingleSubstFormat1, 10);
|
|
|
|
|
2009-05-18 02:48:27 +02:00
|
|
|
struct ReverseChainSingleSubst {
|
|
|
|
|
|
|
|
friend struct SubstLookupSubTable;
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
|
|
|
inline bool substitute (LOOKUP_ARGS_DEF) const {
|
|
|
|
switch (u.format) {
|
|
|
|
case 1: return u.format1->substitute (LOOKUP_ARGS);
|
|
|
|
default:return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
union {
|
|
|
|
USHORT format; /* Format identifier */
|
|
|
|
ReverseChainSingleSubstFormat1 format1[];
|
|
|
|
} u;
|
|
|
|
};
|
|
|
|
ASSERT_SIZE (ReverseChainSingleSubst, 2);
|
|
|
|
|
|
|
|
|
|
|
|
|
2009-04-16 01:50:16 +02:00
|
|
|
/*
|
|
|
|
* SubstLookup
|
|
|
|
*/
|
|
|
|
|
2009-04-16 10:45:30 +02:00
|
|
|
enum {
|
2009-05-18 02:48:27 +02:00
|
|
|
GSUB_Single = 1,
|
|
|
|
GSUB_Multiple = 2,
|
|
|
|
GSUB_Alternate = 3,
|
|
|
|
GSUB_Ligature = 4,
|
|
|
|
GSUB_Context = 5,
|
|
|
|
GSUB_ChainContext = 6,
|
|
|
|
GSUB_Extension = 7,
|
|
|
|
GSUB_ReverseChainSingle = 8,
|
2009-04-16 10:45:30 +02:00
|
|
|
};
|
|
|
|
|
2009-04-16 01:50:16 +02:00
|
|
|
struct SubstLookupSubTable {
|
|
|
|
|
|
|
|
friend struct SubstLookup;
|
|
|
|
|
2009-05-17 13:39:34 +02:00
|
|
|
inline bool substitute (LOOKUP_ARGS_DEF,
|
2009-05-17 15:07:27 +02:00
|
|
|
unsigned int lookup_type) const {
|
2009-05-17 14:59:01 +02:00
|
|
|
|
2009-04-16 10:45:30 +02:00
|
|
|
switch (lookup_type) {
|
2009-05-18 02:48:27 +02:00
|
|
|
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);
|
|
|
|
case GSUB_ChainContext: return u.chainingContext->substitute (LOOKUP_ARGS);
|
|
|
|
case GSUB_Extension: return u.extension->substitute (LOOKUP_ARGS);
|
|
|
|
case GSUB_ReverseChainSingle: return u.reverseChainContextSingle->substitute (LOOKUP_ARGS);
|
2009-04-16 10:45:30 +02:00
|
|
|
default:return false;
|
|
|
|
}
|
2009-04-16 01:50:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
union {
|
2009-05-18 02:48:27 +02:00
|
|
|
USHORT format;
|
|
|
|
SingleSubst single[];
|
|
|
|
MultipleSubst multiple[];
|
|
|
|
AlternateSubst alternate[];
|
|
|
|
LigatureSubst ligature[];
|
|
|
|
ContextSubst context[];
|
|
|
|
ChainContextSubst chainingContext[];
|
|
|
|
ExtensionSubst extension[];
|
|
|
|
ReverseChainSingleSubst reverseChainContextSingle[];
|
2009-04-16 01:50:16 +02:00
|
|
|
} u;
|
|
|
|
};
|
2009-05-18 02:13:02 +02:00
|
|
|
ASSERT_SIZE (SubstLookupSubTable, 2);
|
2009-04-16 01:50:16 +02:00
|
|
|
|
2009-04-16 19:40:13 +02:00
|
|
|
|
2009-04-16 01:50:16 +02:00
|
|
|
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.
|
2009-04-16 10:45:30 +02:00
|
|
|
* Never returns Extension */
|
2009-04-16 01:50:16 +02:00
|
|
|
inline unsigned int get_effective_type (void) const {
|
|
|
|
unsigned int type = get_type ();
|
|
|
|
|
2009-04-16 10:45:30 +02:00
|
|
|
if (HB_UNLIKELY (type == GSUB_Extension)) {
|
2009-04-16 01:50:16 +02:00
|
|
|
/* Return lookup type of first extension subtable.
|
|
|
|
* The spec says all of them should have the same type.
|
2009-05-18 03:11:49 +02:00
|
|
|
* XXX check for that in sanitize() */
|
2009-05-18 02:13:02 +02:00
|
|
|
type = get_subtable(0).u.extension->get_type ();
|
2009-04-16 01:50:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return type;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline bool is_reverse (void) const {
|
|
|
|
switch (get_effective_type ()) {
|
2009-05-18 02:48:27 +02:00
|
|
|
case GSUB_ReverseChainSingle: return true;
|
|
|
|
default: return false;
|
2009-04-16 01:50:16 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-05-17 15:34:41 +02:00
|
|
|
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 {
|
2009-04-16 01:50:16 +02:00
|
|
|
unsigned int lookup_type = get_type ();
|
2009-04-16 04:56:15 +02:00
|
|
|
unsigned int lookup_flag = get_flag ();
|
2009-04-16 01:50:16 +02:00
|
|
|
|
|
|
|
for (unsigned int i = 0; i < get_subtable_count (); i++)
|
2009-05-17 13:39:34 +02:00
|
|
|
if (get_subtable (i).substitute (LOOKUP_ARGS,
|
2009-04-16 19:40:13 +02:00
|
|
|
lookup_type))
|
2009-04-16 01:50:16 +02:00
|
|
|
return true;
|
2009-11-02 20:35:51 +01:00
|
|
|
|
2009-04-16 01:50:16 +02:00
|
|
|
return false;
|
|
|
|
}
|
2009-04-16 10:45:30 +02:00
|
|
|
|
2009-05-17 15:34:41 +02:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2009-04-16 19:40:13 +02:00
|
|
|
bool substitute_string (hb_ot_layout_t *layout,
|
|
|
|
hb_buffer_t *buffer,
|
|
|
|
hb_ot_layout_feature_mask_t mask) const {
|
2009-04-16 10:45:30 +02:00
|
|
|
|
|
|
|
bool ret = false;
|
|
|
|
|
2009-05-17 15:45:32 +02:00
|
|
|
if (HB_UNLIKELY (!buffer->in_length))
|
|
|
|
return false;
|
|
|
|
|
2009-04-16 22:53:40 +02:00
|
|
|
if (HB_LIKELY (!is_reverse ())) {
|
2009-04-16 10:45:30 +02:00
|
|
|
|
|
|
|
/* 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) &&
|
2009-05-17 15:34:41 +02:00
|
|
|
substitute_once (layout, buffer))
|
2009-04-16 10:45:30 +02:00
|
|
|
ret = true;
|
|
|
|
else
|
2009-05-17 12:03:42 +02:00
|
|
|
_hb_buffer_next_glyph (buffer);
|
2009-04-16 10:45:30 +02:00
|
|
|
|
|
|
|
}
|
|
|
|
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) &&
|
2009-05-17 15:34:41 +02:00
|
|
|
substitute_once (layout, buffer))
|
2009-04-16 10:45:30 +02:00
|
|
|
ret = true;
|
|
|
|
else
|
|
|
|
buffer->in_pos--;
|
|
|
|
|
2009-04-16 18:30:51 +02:00
|
|
|
} while ((int) buffer->in_pos >= 0);
|
2009-04-16 10:45:30 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2009-04-16 01:50:16 +02:00
|
|
|
};
|
2009-05-18 02:13:02 +02:00
|
|
|
ASSERT_SIZE (SubstLookup, 6);
|
2009-04-16 01:50:16 +02:00
|
|
|
|
2009-05-16 00:54:53 +02:00
|
|
|
|
2008-01-24 00:02:28 +01:00
|
|
|
/*
|
|
|
|
* 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? */
|
2009-04-16 01:50:16 +02:00
|
|
|
|
|
|
|
inline const SubstLookup& get_lookup (unsigned int i) const {
|
|
|
|
return *(SubstLookup*)&(((GSUBGPOS *)this)->get_lookup (i));
|
|
|
|
}
|
|
|
|
|
2009-05-16 02:11:10 +02:00
|
|
|
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);
|
|
|
|
}
|
2009-04-16 01:50:16 +02:00
|
|
|
|
2008-01-24 00:02:28 +01:00
|
|
|
};
|
2009-05-18 02:13:02 +02:00
|
|
|
ASSERT_SIZE (GSUB, 10);
|
2009-05-16 00:54:53 +02:00
|
|
|
|
|
|
|
|
2009-05-18 03:06:08 +02:00
|
|
|
/* Out-of-class implementation for methods recursing */
|
2009-05-16 00:54:53 +02:00
|
|
|
|
2009-05-17 15:34:41 +02:00
|
|
|
inline bool ExtensionSubstFormat1::substitute (LOOKUP_ARGS_DEF) const {
|
2009-05-18 03:11:49 +02:00
|
|
|
unsigned int lookup_type = get_type ();
|
|
|
|
|
2009-05-18 11:22:32 +02:00
|
|
|
if (HB_UNLIKELY (lookup_type == GSUB_Extension))
|
2009-05-18 03:11:49 +02:00
|
|
|
return false;
|
|
|
|
|
2009-05-18 01:47:54 +02:00
|
|
|
return (*(SubstLookupSubTable *)(((char *) this) + get_offset ())).substitute (LOOKUP_ARGS,
|
2009-05-18 03:11:49 +02:00
|
|
|
lookup_type);
|
2009-05-16 00:54:53 +02:00
|
|
|
}
|
|
|
|
|
2009-05-17 14:28:42 +02:00
|
|
|
static inline bool substitute_lookup (LOOKUP_ARGS_DEF, unsigned int lookup_index) {
|
2009-05-16 00:54:53 +02:00
|
|
|
const GSUB &gsub = *(layout->gsub);
|
2009-05-17 13:52:11 +02:00
|
|
|
const SubstLookup &l = gsub.get_lookup (lookup_index);
|
2009-05-16 00:54:53 +02:00
|
|
|
|
2009-05-17 15:07:27 +02:00
|
|
|
if (HB_UNLIKELY (nesting_level_left == 0))
|
|
|
|
return false;
|
|
|
|
nesting_level_left--;
|
|
|
|
|
|
|
|
if (HB_UNLIKELY (context_length < 1))
|
|
|
|
return false;
|
|
|
|
|
2009-05-17 15:34:41 +02:00
|
|
|
return l.substitute_subtables (layout, buffer, context_length, nesting_level_left, property);
|
2009-05-16 00:54:53 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-01-23 23:01:55 +01:00
|
|
|
#endif /* HB_OT_LAYOUT_GSUB_PRIVATE_H */
|