2008-01-24 09:11:09 +01:00
|
|
|
/*
|
2011-04-21 23:14:28 +02:00
|
|
|
* Copyright © 2007,2008,2009 Red Hat, Inc.
|
2013-10-17 21:01:57 +02:00
|
|
|
* Copyright © 2012,2013 Google, Inc.
|
2008-01-24 09:11:09 +01:00
|
|
|
*
|
2010-04-22 06:11:43 +02:00
|
|
|
* This is part of HarfBuzz, a text shaping library.
|
2008-01-24 09:11:09 +01:00
|
|
|
*
|
|
|
|
* 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
|
2012-07-30 08:38:39 +02:00
|
|
|
* Google Author(s): Behdad Esfahbod
|
2008-01-24 09:11:09 +01:00
|
|
|
*/
|
|
|
|
|
2010-06-09 12:32:56 +02:00
|
|
|
#ifndef HB_OT_LAYOUT_PRIVATE_HH
|
|
|
|
#define HB_OT_LAYOUT_PRIVATE_HH
|
2008-01-24 09:11:09 +01:00
|
|
|
|
2011-04-21 00:50:27 +02:00
|
|
|
#include "hb-private.hh"
|
2009-08-02 21:20:22 +02:00
|
|
|
|
2011-04-21 00:50:27 +02:00
|
|
|
#include "hb-font-private.hh"
|
2010-05-13 00:23:21 +02:00
|
|
|
#include "hb-buffer-private.hh"
|
2017-10-15 14:09:05 +02:00
|
|
|
#include "hb-set-digest-private.hh"
|
2017-01-10 08:50:56 +01:00
|
|
|
#include "hb-open-type-private.hh"
|
2008-01-24 09:11:09 +01:00
|
|
|
|
2009-08-04 03:40:20 +02:00
|
|
|
|
2015-07-23 12:52:11 +02:00
|
|
|
/* Private API corresponding to hb-ot-layout.h: */
|
|
|
|
|
|
|
|
HB_INTERNAL hb_bool_t
|
|
|
|
hb_ot_layout_table_find_feature (hb_face_t *face,
|
|
|
|
hb_tag_t table_tag,
|
|
|
|
hb_tag_t feature_tag,
|
|
|
|
unsigned int *feature_index);
|
|
|
|
|
|
|
|
|
2013-10-17 21:16:20 +02:00
|
|
|
/*
|
|
|
|
* GDEF
|
|
|
|
*/
|
|
|
|
|
2015-11-05 01:25:57 +01:00
|
|
|
enum hb_ot_layout_glyph_props_flags_t
|
2013-10-18 00:45:59 +02:00
|
|
|
{
|
2013-10-17 21:16:20 +02:00
|
|
|
/* The following three match LookupFlags::Ignore* numbers. */
|
|
|
|
HB_OT_LAYOUT_GLYPH_PROPS_BASE_GLYPH = 0x02u,
|
|
|
|
HB_OT_LAYOUT_GLYPH_PROPS_LIGATURE = 0x04u,
|
2013-10-18 00:45:59 +02:00
|
|
|
HB_OT_LAYOUT_GLYPH_PROPS_MARK = 0x08u,
|
|
|
|
|
|
|
|
/* The following are used internally; not derived from GDEF. */
|
2013-10-18 01:05:58 +02:00
|
|
|
HB_OT_LAYOUT_GLYPH_PROPS_SUBSTITUTED = 0x10u,
|
|
|
|
HB_OT_LAYOUT_GLYPH_PROPS_LIGATED = 0x20u,
|
[indic] Don't reorder reph/pref if ligature was expanded
Normally if you want to, say, conditionally prevent a 'pref', you
would use blocking contextual matching. Some designers instead
form the 'pref' form, then undo it in context. To detect that
we now also remember glyphs that went through MultipleSubst.
In the only place that this is used, Uniscribe seems to only care
about the "last" transformation between Ligature and Multiple
substitions. Ie. if you ligate, expand, and ligate again, it
moves the pref, but if you ligate and expand it doesn't. That's
why we clear the MULTIPLIED bit when setting LIGATED.
Micro-test added. Test: U+0D2F,0D4D,0D30 with font from:
[1]
https://code.google.com/a/google.com/p/noto-alpha/issues/detail?id=186#c29
2014-06-04 22:57:42 +02:00
|
|
|
HB_OT_LAYOUT_GLYPH_PROPS_MULTIPLIED = 0x40u,
|
2013-10-17 21:16:20 +02:00
|
|
|
|
2013-10-18 01:05:58 +02:00
|
|
|
HB_OT_LAYOUT_GLYPH_PROPS_PRESERVE = HB_OT_LAYOUT_GLYPH_PROPS_SUBSTITUTED |
|
[indic] Don't reorder reph/pref if ligature was expanded
Normally if you want to, say, conditionally prevent a 'pref', you
would use blocking contextual matching. Some designers instead
form the 'pref' form, then undo it in context. To detect that
we now also remember glyphs that went through MultipleSubst.
In the only place that this is used, Uniscribe seems to only care
about the "last" transformation between Ligature and Multiple
substitions. Ie. if you ligate, expand, and ligate again, it
moves the pref, but if you ligate and expand it doesn't. That's
why we clear the MULTIPLIED bit when setting LIGATED.
Micro-test added. Test: U+0D2F,0D4D,0D30 with font from:
[1]
https://code.google.com/a/google.com/p/noto-alpha/issues/detail?id=186#c29
2014-06-04 22:57:42 +02:00
|
|
|
HB_OT_LAYOUT_GLYPH_PROPS_LIGATED |
|
|
|
|
HB_OT_LAYOUT_GLYPH_PROPS_MULTIPLIED
|
2015-11-05 01:25:57 +01:00
|
|
|
};
|
2015-11-09 10:17:56 +01:00
|
|
|
HB_MARK_AS_FLAG_T (hb_ot_layout_glyph_props_flags_t);
|
2013-10-17 21:16:20 +02:00
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* GSUB/GPOS
|
|
|
|
*/
|
|
|
|
|
|
|
|
HB_INTERNAL hb_bool_t
|
|
|
|
hb_ot_layout_lookup_would_substitute_fast (hb_face_t *face,
|
|
|
|
unsigned int lookup_index,
|
|
|
|
const hb_codepoint_t *glyphs,
|
|
|
|
unsigned int glyphs_length,
|
|
|
|
hb_bool_t zero_context);
|
|
|
|
|
|
|
|
|
|
|
|
/* Should be called before all the substitute_lookup's are done. */
|
|
|
|
HB_INTERNAL void
|
|
|
|
hb_ot_layout_substitute_start (hb_font_t *font,
|
|
|
|
hb_buffer_t *buffer);
|
|
|
|
|
|
|
|
|
|
|
|
struct hb_ot_layout_lookup_accelerator_t;
|
|
|
|
|
|
|
|
namespace OT {
|
2018-01-18 01:46:51 +01:00
|
|
|
struct hb_ot_apply_context_t;
|
2013-10-17 21:16:20 +02:00
|
|
|
struct SubstLookup;
|
|
|
|
}
|
|
|
|
|
|
|
|
HB_INTERNAL void
|
2018-01-18 01:46:51 +01:00
|
|
|
hb_ot_layout_substitute_lookup (OT::hb_ot_apply_context_t *c,
|
2013-10-17 21:16:20 +02:00
|
|
|
const OT::SubstLookup &lookup,
|
|
|
|
const hb_ot_layout_lookup_accelerator_t &accel);
|
|
|
|
|
|
|
|
|
2016-02-11 10:34:28 +01:00
|
|
|
/* Should be called before all the position_lookup's are done. */
|
2013-10-17 21:16:20 +02:00
|
|
|
HB_INTERNAL void
|
|
|
|
hb_ot_layout_position_start (hb_font_t *font,
|
|
|
|
hb_buffer_t *buffer);
|
|
|
|
|
2016-02-11 10:34:28 +01:00
|
|
|
/* Should be called after all the position_lookup's are done, to finish advances. */
|
|
|
|
HB_INTERNAL void
|
|
|
|
hb_ot_layout_position_finish_advances (hb_font_t *font,
|
|
|
|
hb_buffer_t *buffer);
|
|
|
|
|
|
|
|
/* Should be called after hb_ot_layout_position_finish_advances, to finish offsets. */
|
2013-10-17 21:16:20 +02:00
|
|
|
HB_INTERNAL void
|
2016-02-11 10:34:28 +01:00
|
|
|
hb_ot_layout_position_finish_offsets (hb_font_t *font,
|
|
|
|
hb_buffer_t *buffer);
|
2013-10-17 21:16:20 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* hb_ot_layout_t
|
|
|
|
*/
|
|
|
|
|
|
|
|
namespace OT {
|
|
|
|
struct GDEF;
|
|
|
|
struct GSUB;
|
|
|
|
struct GPOS;
|
2016-08-25 10:47:15 +02:00
|
|
|
struct MATH;
|
2017-01-20 04:35:48 +01:00
|
|
|
struct fvar;
|
|
|
|
struct avar;
|
2013-10-17 21:16:20 +02:00
|
|
|
}
|
|
|
|
|
2017-08-15 02:24:36 +02:00
|
|
|
namespace AAT {
|
|
|
|
struct morx;
|
|
|
|
}
|
|
|
|
|
2013-10-17 21:16:20 +02:00
|
|
|
struct hb_ot_layout_lookup_accelerator_t
|
|
|
|
{
|
|
|
|
template <typename TLookup>
|
|
|
|
inline void init (const TLookup &lookup)
|
|
|
|
{
|
|
|
|
digest.init ();
|
|
|
|
lookup.add_coverage (&digest);
|
|
|
|
}
|
|
|
|
|
2014-12-29 01:03:26 +01:00
|
|
|
inline void fini (void)
|
2013-10-17 21:16:20 +02:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2015-01-29 05:55:42 +01:00
|
|
|
inline bool may_have (hb_codepoint_t g) const {
|
|
|
|
return digest.may_have (g);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2013-10-17 21:16:20 +02:00
|
|
|
hb_set_digest_t digest;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct hb_ot_layout_t
|
|
|
|
{
|
|
|
|
hb_blob_t *gdef_blob;
|
|
|
|
hb_blob_t *gsub_blob;
|
|
|
|
hb_blob_t *gpos_blob;
|
|
|
|
|
|
|
|
const struct OT::GDEF *gdef;
|
|
|
|
const struct OT::GSUB *gsub;
|
|
|
|
const struct OT::GPOS *gpos;
|
2017-01-20 04:35:48 +01:00
|
|
|
|
|
|
|
/* TODO Move the following out of this struct. */
|
2017-01-10 08:50:56 +01:00
|
|
|
OT::hb_lazy_table_loader_t<struct OT::MATH> math;
|
2017-01-20 04:35:48 +01:00
|
|
|
OT::hb_lazy_table_loader_t<struct OT::fvar> fvar;
|
|
|
|
OT::hb_lazy_table_loader_t<struct OT::avar> avar;
|
2017-08-15 02:24:36 +02:00
|
|
|
OT::hb_lazy_table_loader_t<struct AAT::morx> morx;
|
2013-10-17 21:16:20 +02:00
|
|
|
|
|
|
|
unsigned int gsub_lookup_count;
|
|
|
|
unsigned int gpos_lookup_count;
|
|
|
|
|
|
|
|
hb_ot_layout_lookup_accelerator_t *gsub_accels;
|
|
|
|
hb_ot_layout_lookup_accelerator_t *gpos_accels;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
HB_INTERNAL hb_ot_layout_t *
|
|
|
|
_hb_ot_layout_create (hb_face_t *face);
|
|
|
|
|
|
|
|
HB_INTERNAL void
|
|
|
|
_hb_ot_layout_destroy (hb_ot_layout_t *layout);
|
|
|
|
|
|
|
|
|
|
|
|
#define hb_ot_layout_from_face(face) ((hb_ot_layout_t *) face->shaper_data.ot)
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Buffer var routines.
|
|
|
|
*/
|
|
|
|
|
2013-10-18 00:42:39 +02:00
|
|
|
/* buffer var allocations, used during the entire shaping process */
|
2015-11-03 02:36:51 +01:00
|
|
|
#define unicode_props() var2.u16[0]
|
2013-10-18 00:42:39 +02:00
|
|
|
|
|
|
|
/* buffer var allocations, used during the GSUB/GPOS processing */
|
|
|
|
#define glyph_props() var1.u16[0] /* GDEF glyph properties */
|
|
|
|
#define lig_props() var1.u8[2] /* GSUB/GPOS ligature tracking */
|
|
|
|
#define syllable() var1.u8[3] /* GSUB/GPOS shaping boundaries */
|
|
|
|
|
2015-07-22 12:54:02 +02:00
|
|
|
|
2017-08-12 04:06:07 +02:00
|
|
|
/* Loop over syllables. Based on foreach_cluster(). */
|
2015-07-22 12:54:02 +02:00
|
|
|
#define foreach_syllable(buffer, start, end) \
|
|
|
|
for (unsigned int \
|
|
|
|
_count = buffer->len, \
|
|
|
|
start = 0, end = _count ? _next_syllable (buffer, 0) : 0; \
|
|
|
|
start < _count; \
|
|
|
|
start = end, end = _next_syllable (buffer, start))
|
|
|
|
|
|
|
|
static inline unsigned int
|
|
|
|
_next_syllable (hb_buffer_t *buffer, unsigned int start)
|
|
|
|
{
|
|
|
|
hb_glyph_info_t *info = buffer->info;
|
|
|
|
unsigned int count = buffer->len;
|
|
|
|
|
|
|
|
unsigned int syllable = info[start].syllable();
|
|
|
|
while (++start < count && syllable == info[start].syllable())
|
|
|
|
;
|
|
|
|
|
|
|
|
return start;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-10-17 21:16:20 +02:00
|
|
|
/* unicode_props */
|
|
|
|
|
2015-11-04 23:18:39 +01:00
|
|
|
/* Design:
|
|
|
|
* unicode_props() is a two-byte number. The low byte includes:
|
|
|
|
* - General_Category: 5 bits.
|
|
|
|
* - A bit each for:
|
|
|
|
* * Is it Default_Ignorable(); we have a modified Default_Ignorable().
|
2017-10-15 10:48:19 +02:00
|
|
|
* * Whether it's one of the three Mongolian Free Variation Selectors,
|
|
|
|
* CGJ, or other characters that are hidden but should not be ignored
|
|
|
|
* like most other Default_Ignorable()s do during matching.
|
2016-04-27 01:41:17 +02:00
|
|
|
* * One free bit right now.
|
2015-11-04 23:18:39 +01:00
|
|
|
*
|
|
|
|
* The high-byte has different meanings, switched by the Gen-Cat:
|
|
|
|
* - For Mn,Mc,Me: the modified Combining_Class.
|
2016-04-27 01:02:04 +02:00
|
|
|
* - For Cf: whether it's ZWJ, ZWNJ, or something else.
|
2015-11-04 23:18:39 +01:00
|
|
|
* - For Ws: index of which space character this is, if space fallback
|
|
|
|
* is needed, ie. we don't set this by default, only if asked to.
|
|
|
|
*/
|
|
|
|
|
2015-11-05 01:25:57 +01:00
|
|
|
enum hb_unicode_props_flags_t {
|
2016-04-27 01:02:04 +02:00
|
|
|
UPROPS_MASK_GEN_CAT = 0x001Fu,
|
|
|
|
UPROPS_MASK_IGNORABLE = 0x0020u,
|
2017-05-17 20:32:47 +02:00
|
|
|
UPROPS_MASK_HIDDEN = 0x0040u, /* MONGOLIAN FREE VARIATION SELECTOR 1..3,
|
|
|
|
* or TAG characters */
|
2016-04-27 01:02:04 +02:00
|
|
|
|
|
|
|
/* If GEN_CAT=FORMAT, top byte masks: */
|
|
|
|
UPROPS_MASK_Cf_ZWJ = 0x0100u,
|
|
|
|
UPROPS_MASK_Cf_ZWNJ = 0x0200u
|
2013-10-16 13:42:18 +02:00
|
|
|
};
|
2015-11-09 10:17:56 +01:00
|
|
|
HB_MARK_AS_FLAG_T (hb_unicode_props_flags_t);
|
2013-10-16 13:42:18 +02:00
|
|
|
|
2014-04-28 23:29:39 +02:00
|
|
|
static inline void
|
2015-11-05 03:46:22 +01:00
|
|
|
_hb_glyph_info_set_unicode_props (hb_glyph_info_t *info, hb_buffer_t *buffer)
|
[OTLayout] Ignore default-ignorables when matching GSUB/GPOS
When matching lookups, be smart about default-ignorable characters.
In particular:
Do nothing specific about ZWNJ, but for the other default-ignorables:
If the lookup in question uses the ignorable character in a sequence,
then match it as we used to do. However, if the sequence match will
fail because the default-ignorable blocked it, try skipping the
ignorable character and continue.
The most immediate thing it means is that if Lam-Alef forms a ligature,
then Lam-ZWJ-Alef will do to. Finally!
One exception: when matching for GPOS, or for backtrack/lookahead of
GSUB, we ignore ZWNJ too. That's the right thing to do.
It certainly is possible to build fonts that this feature will result
in undesirable glyphs, but it's hard to think of a real-world case
that that would happen.
This *does* break Indic shaping right now, since Indic Unicode has
specific rules for what ZWJ/ZWNJ mean, and skipping ZWJ is breaking
those rules. That will be fixed in upcoming commits.
2013-02-14 13:43:13 +01:00
|
|
|
{
|
2015-11-05 03:46:22 +01:00
|
|
|
hb_unicode_funcs_t *unicode = buffer->unicode;
|
2015-11-03 02:58:12 +01:00
|
|
|
unsigned int u = info->codepoint;
|
|
|
|
unsigned int gen_cat = (unsigned int) unicode->general_category (u);
|
2015-11-03 02:36:51 +01:00
|
|
|
unsigned int props = gen_cat;
|
|
|
|
|
2015-11-03 02:58:12 +01:00
|
|
|
if (u >= 0x80)
|
2015-11-03 02:36:51 +01:00
|
|
|
{
|
2015-11-05 03:58:02 +01:00
|
|
|
buffer->scratch_flags |= HB_BUFFER_SCRATCH_FLAG_HAS_NON_ASCII;
|
2015-11-03 02:58:12 +01:00
|
|
|
if (unlikely (unicode->is_default_ignorable (u)))
|
|
|
|
{
|
2015-11-05 03:46:22 +01:00
|
|
|
buffer->scratch_flags |= HB_BUFFER_SCRATCH_FLAG_HAS_DEFAULT_IGNORABLES;
|
2015-11-03 02:58:12 +01:00
|
|
|
props |= UPROPS_MASK_IGNORABLE;
|
2016-04-27 01:02:04 +02:00
|
|
|
if (u == 0x200Cu) props |= UPROPS_MASK_Cf_ZWNJ;
|
2017-10-15 10:48:19 +02:00
|
|
|
else if (u == 0x200Du) props |= UPROPS_MASK_Cf_ZWJ;
|
2016-04-27 01:41:17 +02:00
|
|
|
/* Mongolian Free Variation Selectors need to be remembered
|
|
|
|
* because although we need to hide them like default-ignorables,
|
|
|
|
* they need to non-ignorable during shaping. This is similar to
|
|
|
|
* what we do for joiners in Indic-like shapers, but since the
|
|
|
|
* FVSes are GC=Mn, we have use a separate bit to remember them.
|
|
|
|
* Fixes:
|
2017-11-20 20:49:22 +01:00
|
|
|
* https://github.com/harfbuzz/harfbuzz/issues/234 */
|
2017-10-15 10:48:19 +02:00
|
|
|
else if (unlikely (hb_in_range (u, 0x180Bu, 0x180Du))) props |= UPROPS_MASK_HIDDEN;
|
2017-05-17 20:32:47 +02:00
|
|
|
/* TAG characters need similar treatment. Fixes:
|
2017-11-20 20:49:22 +01:00
|
|
|
* https://github.com/harfbuzz/harfbuzz/issues/463 */
|
2017-10-15 10:48:19 +02:00
|
|
|
else if (unlikely (hb_in_range (u, 0xE0020u, 0xE007Fu))) props |= UPROPS_MASK_HIDDEN;
|
|
|
|
/* COMBINING GRAPHEME JOINER should not be skipped; at least some times.
|
2017-11-20 20:49:22 +01:00
|
|
|
* https://github.com/harfbuzz/harfbuzz/issues/554 */
|
2018-01-05 13:46:12 +01:00
|
|
|
else if (unlikely (u == 0x034Fu))
|
|
|
|
{
|
|
|
|
buffer->scratch_flags |= HB_BUFFER_SCRATCH_FLAG_HAS_CGJ;
|
|
|
|
props |= UPROPS_MASK_HIDDEN;
|
|
|
|
}
|
2015-11-03 02:58:12 +01:00
|
|
|
}
|
2016-02-18 11:06:25 +01:00
|
|
|
else if (unlikely (HB_UNICODE_GENERAL_CATEGORY_IS_NON_ENCLOSING_MARK_OR_MODIFIER_SYMBOL (gen_cat)))
|
2015-11-03 02:58:12 +01:00
|
|
|
{
|
2016-02-18 11:06:25 +01:00
|
|
|
/* The above check is just an optimization to let in only things we need further
|
|
|
|
* processing on. */
|
|
|
|
|
2015-11-03 21:58:12 +01:00
|
|
|
/* Only Mn and Mc can have non-zero ccc:
|
|
|
|
* http://www.unicode.org/policies/stability_policy.html#Property_Value
|
|
|
|
* """
|
|
|
|
* Canonical_Combining_Class, General_Category
|
|
|
|
* All characters other than those with General_Category property values
|
|
|
|
* Spacing_Mark (Mc) and Nonspacing_Mark (Mn) have the Canonical_Combining_Class
|
|
|
|
* property value 0.
|
|
|
|
* 1.1.5+
|
|
|
|
* """
|
2015-11-04 23:18:39 +01:00
|
|
|
*
|
|
|
|
* Also, all Mn's that are Default_Ignorable, have ccc=0, hence
|
|
|
|
* the "else if".
|
2015-11-03 21:58:12 +01:00
|
|
|
*/
|
2015-11-03 02:58:12 +01:00
|
|
|
props |= unicode->modified_combining_class (info->codepoint)<<8;
|
2016-02-18 11:06:25 +01:00
|
|
|
|
|
|
|
/* Recategorize emoji skin-tone modifiers as Unicode mark, so they
|
|
|
|
* behave correctly in non-native directionality. They originally
|
|
|
|
* are MODIFIER_SYMBOL. Fixes:
|
2017-11-20 20:49:22 +01:00
|
|
|
* https://github.com/harfbuzz/harfbuzz/issues/169
|
2016-02-18 11:06:25 +01:00
|
|
|
*/
|
|
|
|
if (unlikely (hb_in_range (u, 0x1F3FBu, 0x1F3FFu)))
|
|
|
|
{
|
|
|
|
props = gen_cat = HB_UNICODE_GENERAL_CATEGORY_ENCLOSING_MARK;
|
|
|
|
}
|
2015-11-03 02:58:12 +01:00
|
|
|
}
|
2015-11-03 02:36:51 +01:00
|
|
|
}
|
2015-11-03 02:58:12 +01:00
|
|
|
|
2015-11-03 02:36:51 +01:00
|
|
|
info->unicode_props() = props;
|
[OTLayout] Ignore default-ignorables when matching GSUB/GPOS
When matching lookups, be smart about default-ignorable characters.
In particular:
Do nothing specific about ZWNJ, but for the other default-ignorables:
If the lookup in question uses the ignorable character in a sequence,
then match it as we used to do. However, if the sequence match will
fail because the default-ignorable blocked it, try skipping the
ignorable character and continue.
The most immediate thing it means is that if Lam-Alef forms a ligature,
then Lam-ZWJ-Alef will do to. Finally!
One exception: when matching for GPOS, or for backtrack/lookahead of
GSUB, we ignore ZWNJ too. That's the right thing to do.
It certainly is possible to build fonts that this feature will result
in undesirable glyphs, but it's hard to think of a real-world case
that that would happen.
This *does* break Indic shaping right now, since Indic Unicode has
specific rules for what ZWJ/ZWNJ mean, and skipping ZWJ is breaking
those rules. That will be fixed in upcoming commits.
2013-02-14 13:43:13 +01:00
|
|
|
}
|
|
|
|
|
2014-04-28 23:29:39 +02:00
|
|
|
static inline void
|
2013-10-18 00:02:43 +02:00
|
|
|
_hb_glyph_info_set_general_category (hb_glyph_info_t *info,
|
|
|
|
hb_unicode_general_category_t gen_cat)
|
2013-05-27 20:48:34 +02:00
|
|
|
{
|
2015-11-04 22:21:25 +01:00
|
|
|
/* Clears top-byte. */
|
|
|
|
info->unicode_props() = (unsigned int) gen_cat | (info->unicode_props() & (0xFF & ~UPROPS_MASK_GEN_CAT));
|
2013-05-27 20:48:34 +02:00
|
|
|
}
|
|
|
|
|
2014-04-28 23:29:39 +02:00
|
|
|
static inline hb_unicode_general_category_t
|
[OTLayout] Ignore default-ignorables when matching GSUB/GPOS
When matching lookups, be smart about default-ignorable characters.
In particular:
Do nothing specific about ZWNJ, but for the other default-ignorables:
If the lookup in question uses the ignorable character in a sequence,
then match it as we used to do. However, if the sequence match will
fail because the default-ignorable blocked it, try skipping the
ignorable character and continue.
The most immediate thing it means is that if Lam-Alef forms a ligature,
then Lam-ZWJ-Alef will do to. Finally!
One exception: when matching for GPOS, or for backtrack/lookahead of
GSUB, we ignore ZWNJ too. That's the right thing to do.
It certainly is possible to build fonts that this feature will result
in undesirable glyphs, but it's hard to think of a real-world case
that that would happen.
This *does* break Indic shaping right now, since Indic Unicode has
specific rules for what ZWJ/ZWNJ mean, and skipping ZWJ is breaking
those rules. That will be fixed in upcoming commits.
2013-02-14 13:43:13 +01:00
|
|
|
_hb_glyph_info_get_general_category (const hb_glyph_info_t *info)
|
|
|
|
{
|
2015-11-03 02:36:51 +01:00
|
|
|
return (hb_unicode_general_category_t) (info->unicode_props() & UPROPS_MASK_GEN_CAT);
|
[OTLayout] Ignore default-ignorables when matching GSUB/GPOS
When matching lookups, be smart about default-ignorable characters.
In particular:
Do nothing specific about ZWNJ, but for the other default-ignorables:
If the lookup in question uses the ignorable character in a sequence,
then match it as we used to do. However, if the sequence match will
fail because the default-ignorable blocked it, try skipping the
ignorable character and continue.
The most immediate thing it means is that if Lam-Alef forms a ligature,
then Lam-ZWJ-Alef will do to. Finally!
One exception: when matching for GPOS, or for backtrack/lookahead of
GSUB, we ignore ZWNJ too. That's the right thing to do.
It certainly is possible to build fonts that this feature will result
in undesirable glyphs, but it's hard to think of a real-world case
that that would happen.
This *does* break Indic shaping right now, since Indic Unicode has
specific rules for what ZWJ/ZWNJ mean, and skipping ZWJ is breaking
those rules. That will be fixed in upcoming commits.
2013-02-14 13:43:13 +01:00
|
|
|
}
|
|
|
|
|
2015-11-04 22:17:33 +01:00
|
|
|
static inline bool
|
|
|
|
_hb_glyph_info_is_unicode_mark (const hb_glyph_info_t *info)
|
|
|
|
{
|
|
|
|
return HB_UNICODE_GENERAL_CATEGORY_IS_MARK (info->unicode_props() & UPROPS_MASK_GEN_CAT);
|
|
|
|
}
|
2014-04-28 23:29:39 +02:00
|
|
|
static inline void
|
2013-10-18 00:02:43 +02:00
|
|
|
_hb_glyph_info_set_modified_combining_class (hb_glyph_info_t *info,
|
|
|
|
unsigned int modified_class)
|
[OTLayout] Ignore default-ignorables when matching GSUB/GPOS
When matching lookups, be smart about default-ignorable characters.
In particular:
Do nothing specific about ZWNJ, but for the other default-ignorables:
If the lookup in question uses the ignorable character in a sequence,
then match it as we used to do. However, if the sequence match will
fail because the default-ignorable blocked it, try skipping the
ignorable character and continue.
The most immediate thing it means is that if Lam-Alef forms a ligature,
then Lam-ZWJ-Alef will do to. Finally!
One exception: when matching for GPOS, or for backtrack/lookahead of
GSUB, we ignore ZWNJ too. That's the right thing to do.
It certainly is possible to build fonts that this feature will result
in undesirable glyphs, but it's hard to think of a real-world case
that that would happen.
This *does* break Indic shaping right now, since Indic Unicode has
specific rules for what ZWJ/ZWNJ mean, and skipping ZWJ is breaking
those rules. That will be fixed in upcoming commits.
2013-02-14 13:43:13 +01:00
|
|
|
{
|
2015-11-04 22:26:17 +01:00
|
|
|
if (unlikely (!_hb_glyph_info_is_unicode_mark (info)))
|
|
|
|
return;
|
2015-11-03 02:36:51 +01:00
|
|
|
info->unicode_props() = (modified_class<<8) | (info->unicode_props() & 0xFF);
|
[OTLayout] Ignore default-ignorables when matching GSUB/GPOS
When matching lookups, be smart about default-ignorable characters.
In particular:
Do nothing specific about ZWNJ, but for the other default-ignorables:
If the lookup in question uses the ignorable character in a sequence,
then match it as we used to do. However, if the sequence match will
fail because the default-ignorable blocked it, try skipping the
ignorable character and continue.
The most immediate thing it means is that if Lam-Alef forms a ligature,
then Lam-ZWJ-Alef will do to. Finally!
One exception: when matching for GPOS, or for backtrack/lookahead of
GSUB, we ignore ZWNJ too. That's the right thing to do.
It certainly is possible to build fonts that this feature will result
in undesirable glyphs, but it's hard to think of a real-world case
that that would happen.
This *does* break Indic shaping right now, since Indic Unicode has
specific rules for what ZWJ/ZWNJ mean, and skipping ZWJ is breaking
those rules. That will be fixed in upcoming commits.
2013-02-14 13:43:13 +01:00
|
|
|
}
|
2014-04-28 23:29:39 +02:00
|
|
|
static inline unsigned int
|
[OTLayout] Ignore default-ignorables when matching GSUB/GPOS
When matching lookups, be smart about default-ignorable characters.
In particular:
Do nothing specific about ZWNJ, but for the other default-ignorables:
If the lookup in question uses the ignorable character in a sequence,
then match it as we used to do. However, if the sequence match will
fail because the default-ignorable blocked it, try skipping the
ignorable character and continue.
The most immediate thing it means is that if Lam-Alef forms a ligature,
then Lam-ZWJ-Alef will do to. Finally!
One exception: when matching for GPOS, or for backtrack/lookahead of
GSUB, we ignore ZWNJ too. That's the right thing to do.
It certainly is possible to build fonts that this feature will result
in undesirable glyphs, but it's hard to think of a real-world case
that that would happen.
This *does* break Indic shaping right now, since Indic Unicode has
specific rules for what ZWJ/ZWNJ mean, and skipping ZWJ is breaking
those rules. That will be fixed in upcoming commits.
2013-02-14 13:43:13 +01:00
|
|
|
_hb_glyph_info_get_modified_combining_class (const hb_glyph_info_t *info)
|
|
|
|
{
|
2015-11-04 22:26:17 +01:00
|
|
|
return _hb_glyph_info_is_unicode_mark (info) ? info->unicode_props()>>8 : 0;
|
[OTLayout] Ignore default-ignorables when matching GSUB/GPOS
When matching lookups, be smart about default-ignorable characters.
In particular:
Do nothing specific about ZWNJ, but for the other default-ignorables:
If the lookup in question uses the ignorable character in a sequence,
then match it as we used to do. However, if the sequence match will
fail because the default-ignorable blocked it, try skipping the
ignorable character and continue.
The most immediate thing it means is that if Lam-Alef forms a ligature,
then Lam-ZWJ-Alef will do to. Finally!
One exception: when matching for GPOS, or for backtrack/lookahead of
GSUB, we ignore ZWNJ too. That's the right thing to do.
It certainly is possible to build fonts that this feature will result
in undesirable glyphs, but it's hard to think of a real-world case
that that would happen.
This *does* break Indic shaping right now, since Indic Unicode has
specific rules for what ZWJ/ZWNJ mean, and skipping ZWJ is breaking
those rules. That will be fixed in upcoming commits.
2013-02-14 13:43:13 +01:00
|
|
|
}
|
|
|
|
|
2017-10-04 13:37:08 +02:00
|
|
|
#define info_cc(info) (_hb_glyph_info_get_modified_combining_class (&(info)))
|
|
|
|
|
2015-11-04 23:18:39 +01:00
|
|
|
static inline bool
|
|
|
|
_hb_glyph_info_is_unicode_space (const hb_glyph_info_t *info)
|
|
|
|
{
|
|
|
|
return _hb_glyph_info_get_general_category (info) ==
|
|
|
|
HB_UNICODE_GENERAL_CATEGORY_SPACE_SEPARATOR;
|
|
|
|
}
|
|
|
|
static inline void
|
2015-11-04 23:48:46 +01:00
|
|
|
_hb_glyph_info_set_unicode_space_fallback_type (hb_glyph_info_t *info, hb_unicode_funcs_t::space_t s)
|
2015-11-04 23:18:39 +01:00
|
|
|
{
|
|
|
|
if (unlikely (!_hb_glyph_info_is_unicode_space (info)))
|
|
|
|
return;
|
|
|
|
info->unicode_props() = (((unsigned int) s)<<8) | (info->unicode_props() & 0xFF);
|
|
|
|
}
|
2015-11-04 23:48:46 +01:00
|
|
|
static inline hb_unicode_funcs_t::space_t
|
|
|
|
_hb_glyph_info_get_unicode_space_fallback_type (const hb_glyph_info_t *info)
|
2015-11-04 23:18:39 +01:00
|
|
|
{
|
2015-11-04 23:48:46 +01:00
|
|
|
return _hb_glyph_info_is_unicode_space (info) ?
|
|
|
|
(hb_unicode_funcs_t::space_t) (info->unicode_props()>>8) :
|
|
|
|
hb_unicode_funcs_t::NOT_SPACE;
|
2015-11-04 23:18:39 +01:00
|
|
|
}
|
|
|
|
|
2015-07-22 18:41:31 +02:00
|
|
|
static inline bool _hb_glyph_info_ligated (const hb_glyph_info_t *info);
|
|
|
|
|
2014-04-28 23:29:39 +02:00
|
|
|
static inline hb_bool_t
|
[OTLayout] Ignore default-ignorables when matching GSUB/GPOS
When matching lookups, be smart about default-ignorable characters.
In particular:
Do nothing specific about ZWNJ, but for the other default-ignorables:
If the lookup in question uses the ignorable character in a sequence,
then match it as we used to do. However, if the sequence match will
fail because the default-ignorable blocked it, try skipping the
ignorable character and continue.
The most immediate thing it means is that if Lam-Alef forms a ligature,
then Lam-ZWJ-Alef will do to. Finally!
One exception: when matching for GPOS, or for backtrack/lookahead of
GSUB, we ignore ZWNJ too. That's the right thing to do.
It certainly is possible to build fonts that this feature will result
in undesirable glyphs, but it's hard to think of a real-world case
that that would happen.
This *does* break Indic shaping right now, since Indic Unicode has
specific rules for what ZWJ/ZWNJ mean, and skipping ZWJ is breaking
those rules. That will be fixed in upcoming commits.
2013-02-14 13:43:13 +01:00
|
|
|
_hb_glyph_info_is_default_ignorable (const hb_glyph_info_t *info)
|
|
|
|
{
|
2016-04-27 01:41:17 +02:00
|
|
|
return (info->unicode_props() & UPROPS_MASK_IGNORABLE) &&
|
|
|
|
!_hb_glyph_info_ligated (info);
|
|
|
|
}
|
|
|
|
static inline hb_bool_t
|
2017-05-17 20:32:47 +02:00
|
|
|
_hb_glyph_info_is_default_ignorable_and_not_hidden (const hb_glyph_info_t *info)
|
2016-04-27 01:41:17 +02:00
|
|
|
{
|
2017-05-17 20:32:47 +02:00
|
|
|
return ((info->unicode_props() & (UPROPS_MASK_IGNORABLE|UPROPS_MASK_HIDDEN))
|
2016-04-27 01:41:17 +02:00
|
|
|
== UPROPS_MASK_IGNORABLE) &&
|
|
|
|
!_hb_glyph_info_ligated (info);
|
[OTLayout] Ignore default-ignorables when matching GSUB/GPOS
When matching lookups, be smart about default-ignorable characters.
In particular:
Do nothing specific about ZWNJ, but for the other default-ignorables:
If the lookup in question uses the ignorable character in a sequence,
then match it as we used to do. However, if the sequence match will
fail because the default-ignorable blocked it, try skipping the
ignorable character and continue.
The most immediate thing it means is that if Lam-Alef forms a ligature,
then Lam-ZWJ-Alef will do to. Finally!
One exception: when matching for GPOS, or for backtrack/lookahead of
GSUB, we ignore ZWNJ too. That's the right thing to do.
It certainly is possible to build fonts that this feature will result
in undesirable glyphs, but it's hard to think of a real-world case
that that would happen.
This *does* break Indic shaping right now, since Indic Unicode has
specific rules for what ZWJ/ZWNJ mean, and skipping ZWJ is breaking
those rules. That will be fixed in upcoming commits.
2013-02-14 13:43:13 +01:00
|
|
|
}
|
2018-01-05 13:46:12 +01:00
|
|
|
static inline void
|
|
|
|
_hb_glyph_info_unhide (hb_glyph_info_t *info)
|
|
|
|
{
|
|
|
|
info->unicode_props() &= ~ UPROPS_MASK_HIDDEN;
|
|
|
|
}
|
[OTLayout] Ignore default-ignorables when matching GSUB/GPOS
When matching lookups, be smart about default-ignorable characters.
In particular:
Do nothing specific about ZWNJ, but for the other default-ignorables:
If the lookup in question uses the ignorable character in a sequence,
then match it as we used to do. However, if the sequence match will
fail because the default-ignorable blocked it, try skipping the
ignorable character and continue.
The most immediate thing it means is that if Lam-Alef forms a ligature,
then Lam-ZWJ-Alef will do to. Finally!
One exception: when matching for GPOS, or for backtrack/lookahead of
GSUB, we ignore ZWNJ too. That's the right thing to do.
It certainly is possible to build fonts that this feature will result
in undesirable glyphs, but it's hard to think of a real-world case
that that would happen.
This *does* break Indic shaping right now, since Indic Unicode has
specific rules for what ZWJ/ZWNJ mean, and skipping ZWJ is breaking
those rules. That will be fixed in upcoming commits.
2013-02-14 13:43:13 +01:00
|
|
|
|
2016-04-27 01:02:04 +02:00
|
|
|
static inline bool
|
|
|
|
_hb_glyph_info_is_unicode_format (const hb_glyph_info_t *info)
|
|
|
|
{
|
|
|
|
return _hb_glyph_info_get_general_category (info) ==
|
|
|
|
HB_UNICODE_GENERAL_CATEGORY_FORMAT;
|
|
|
|
}
|
2014-04-28 23:29:39 +02:00
|
|
|
static inline hb_bool_t
|
[OTLayout] Ignore default-ignorables when matching GSUB/GPOS
When matching lookups, be smart about default-ignorable characters.
In particular:
Do nothing specific about ZWNJ, but for the other default-ignorables:
If the lookup in question uses the ignorable character in a sequence,
then match it as we used to do. However, if the sequence match will
fail because the default-ignorable blocked it, try skipping the
ignorable character and continue.
The most immediate thing it means is that if Lam-Alef forms a ligature,
then Lam-ZWJ-Alef will do to. Finally!
One exception: when matching for GPOS, or for backtrack/lookahead of
GSUB, we ignore ZWNJ too. That's the right thing to do.
It certainly is possible to build fonts that this feature will result
in undesirable glyphs, but it's hard to think of a real-world case
that that would happen.
This *does* break Indic shaping right now, since Indic Unicode has
specific rules for what ZWJ/ZWNJ mean, and skipping ZWJ is breaking
those rules. That will be fixed in upcoming commits.
2013-02-14 13:43:13 +01:00
|
|
|
_hb_glyph_info_is_zwnj (const hb_glyph_info_t *info)
|
|
|
|
{
|
2016-04-27 01:02:04 +02:00
|
|
|
return _hb_glyph_info_is_unicode_format (info) && (info->unicode_props() & UPROPS_MASK_Cf_ZWNJ);
|
[OTLayout] Ignore default-ignorables when matching GSUB/GPOS
When matching lookups, be smart about default-ignorable characters.
In particular:
Do nothing specific about ZWNJ, but for the other default-ignorables:
If the lookup in question uses the ignorable character in a sequence,
then match it as we used to do. However, if the sequence match will
fail because the default-ignorable blocked it, try skipping the
ignorable character and continue.
The most immediate thing it means is that if Lam-Alef forms a ligature,
then Lam-ZWJ-Alef will do to. Finally!
One exception: when matching for GPOS, or for backtrack/lookahead of
GSUB, we ignore ZWNJ too. That's the right thing to do.
It certainly is possible to build fonts that this feature will result
in undesirable glyphs, but it's hard to think of a real-world case
that that would happen.
This *does* break Indic shaping right now, since Indic Unicode has
specific rules for what ZWJ/ZWNJ mean, and skipping ZWJ is breaking
those rules. That will be fixed in upcoming commits.
2013-02-14 13:43:13 +01:00
|
|
|
}
|
2014-04-28 23:29:39 +02:00
|
|
|
static inline hb_bool_t
|
2013-02-14 16:46:52 +01:00
|
|
|
_hb_glyph_info_is_zwj (const hb_glyph_info_t *info)
|
|
|
|
{
|
2016-04-27 01:02:04 +02:00
|
|
|
return _hb_glyph_info_is_unicode_format (info) && (info->unicode_props() & UPROPS_MASK_Cf_ZWJ);
|
2013-02-14 16:46:52 +01:00
|
|
|
}
|
2016-02-22 10:22:44 +01:00
|
|
|
static inline hb_bool_t
|
|
|
|
_hb_glyph_info_is_joiner (const hb_glyph_info_t *info)
|
|
|
|
{
|
2016-04-27 01:02:04 +02:00
|
|
|
return _hb_glyph_info_is_unicode_format (info) && (info->unicode_props() & (UPROPS_MASK_Cf_ZWNJ|UPROPS_MASK_Cf_ZWJ));
|
2016-02-22 10:22:44 +01:00
|
|
|
}
|
2014-04-28 23:29:39 +02:00
|
|
|
static inline void
|
2013-10-16 13:42:38 +02:00
|
|
|
_hb_glyph_info_flip_joiners (hb_glyph_info_t *info)
|
|
|
|
{
|
2016-04-27 01:02:04 +02:00
|
|
|
if (!_hb_glyph_info_is_unicode_format (info))
|
|
|
|
return;
|
|
|
|
info->unicode_props() ^= UPROPS_MASK_Cf_ZWNJ | UPROPS_MASK_Cf_ZWJ;
|
2013-10-16 13:42:38 +02:00
|
|
|
}
|
|
|
|
|
2013-10-17 21:16:20 +02:00
|
|
|
/* lig_props: aka lig_id / lig_comp
|
2012-07-26 00:37:51 +02:00
|
|
|
*
|
|
|
|
* When a ligature is formed:
|
|
|
|
*
|
2012-07-29 03:05:25 +02:00
|
|
|
* - The ligature glyph and any marks in between all the same newly allocated
|
|
|
|
* lig_id,
|
2012-07-30 06:42:07 +02:00
|
|
|
* - The ligature glyph will get lig_num_comps set to the number of components
|
2012-07-26 00:37:51 +02:00
|
|
|
* - The marks get lig_comp > 0, reflecting which component of the ligature
|
|
|
|
* they were applied to.
|
|
|
|
* - This is used in GPOS to attach marks to the right component of a ligature
|
2013-10-17 21:16:20 +02:00
|
|
|
* in MarkLigPos,
|
|
|
|
* - Note that when marks are ligated together, much of the above is skipped
|
|
|
|
* and the current lig_id reused.
|
2012-07-26 00:37:51 +02:00
|
|
|
*
|
|
|
|
* When a multiple-substitution is done:
|
|
|
|
*
|
|
|
|
* - All resulting glyphs will have lig_id = 0,
|
|
|
|
* - The resulting glyphs will have lig_comp = 0, 1, 2, ... respectively.
|
2012-07-29 03:05:25 +02:00
|
|
|
* - This is used in GPOS to attach marks to the first component of a
|
2012-07-26 00:37:51 +02:00
|
|
|
* multiple substitution in MarkBasePos.
|
|
|
|
*
|
|
|
|
* The numbers are also used in GPOS to do mark-to-mark positioning only
|
2013-10-17 21:16:20 +02:00
|
|
|
* to marks that belong to the same component of the same ligature.
|
2012-07-26 00:37:51 +02:00
|
|
|
*/
|
2013-10-18 00:42:39 +02:00
|
|
|
|
|
|
|
static inline void
|
|
|
|
_hb_glyph_info_clear_lig_props (hb_glyph_info_t *info)
|
|
|
|
{
|
|
|
|
info->lig_props() = 0;
|
|
|
|
}
|
|
|
|
|
2012-07-30 06:42:07 +02:00
|
|
|
#define IS_LIG_BASE 0x10
|
2013-10-18 00:42:39 +02:00
|
|
|
|
2012-07-24 02:14:13 +02:00
|
|
|
static inline void
|
2013-10-18 00:02:43 +02:00
|
|
|
_hb_glyph_info_set_lig_props_for_ligature (hb_glyph_info_t *info,
|
|
|
|
unsigned int lig_id,
|
|
|
|
unsigned int lig_num_comps)
|
2012-07-30 04:02:24 +02:00
|
|
|
{
|
2013-10-18 00:02:43 +02:00
|
|
|
info->lig_props() = (lig_id << 5) | IS_LIG_BASE | (lig_num_comps & 0x0F);
|
2012-07-30 04:02:24 +02:00
|
|
|
}
|
2013-10-18 00:42:39 +02:00
|
|
|
|
2012-07-30 04:02:24 +02:00
|
|
|
static inline void
|
2013-10-18 00:02:43 +02:00
|
|
|
_hb_glyph_info_set_lig_props_for_mark (hb_glyph_info_t *info,
|
|
|
|
unsigned int lig_id,
|
|
|
|
unsigned int lig_comp)
|
2012-07-30 04:02:24 +02:00
|
|
|
{
|
2013-10-18 00:02:43 +02:00
|
|
|
info->lig_props() = (lig_id << 5) | (lig_comp & 0x0F);
|
2012-07-30 04:02:24 +02:00
|
|
|
}
|
2013-10-18 00:42:39 +02:00
|
|
|
|
2012-07-30 04:02:24 +02:00
|
|
|
static inline void
|
2013-10-18 00:02:43 +02:00
|
|
|
_hb_glyph_info_set_lig_props_for_component (hb_glyph_info_t *info, unsigned int comp)
|
2012-07-30 04:02:24 +02:00
|
|
|
{
|
2013-10-18 00:02:43 +02:00
|
|
|
_hb_glyph_info_set_lig_props_for_mark (info, 0, comp);
|
2012-07-30 04:02:24 +02:00
|
|
|
}
|
|
|
|
|
2012-07-24 02:14:13 +02:00
|
|
|
static inline unsigned int
|
2013-10-18 00:02:43 +02:00
|
|
|
_hb_glyph_info_get_lig_id (const hb_glyph_info_t *info)
|
2012-07-24 02:14:13 +02:00
|
|
|
{
|
2013-10-18 00:02:43 +02:00
|
|
|
return info->lig_props() >> 5;
|
2012-07-24 02:14:13 +02:00
|
|
|
}
|
2013-10-18 00:42:39 +02:00
|
|
|
|
2012-07-30 06:42:07 +02:00
|
|
|
static inline bool
|
2013-10-18 01:09:08 +02:00
|
|
|
_hb_glyph_info_ligated_internal (const hb_glyph_info_t *info)
|
2012-07-30 06:42:07 +02:00
|
|
|
{
|
2013-10-18 00:02:43 +02:00
|
|
|
return !!(info->lig_props() & IS_LIG_BASE);
|
2012-07-30 06:42:07 +02:00
|
|
|
}
|
2013-10-18 00:42:39 +02:00
|
|
|
|
2012-07-24 02:14:13 +02:00
|
|
|
static inline unsigned int
|
2013-10-18 00:02:43 +02:00
|
|
|
_hb_glyph_info_get_lig_comp (const hb_glyph_info_t *info)
|
2012-07-24 02:14:13 +02:00
|
|
|
{
|
2013-10-18 01:09:08 +02:00
|
|
|
if (_hb_glyph_info_ligated_internal (info))
|
2012-07-30 04:02:24 +02:00
|
|
|
return 0;
|
|
|
|
else
|
2013-10-18 00:02:43 +02:00
|
|
|
return info->lig_props() & 0x0F;
|
2012-07-30 04:02:24 +02:00
|
|
|
}
|
2013-10-18 00:42:39 +02:00
|
|
|
|
2012-07-30 04:02:24 +02:00
|
|
|
static inline unsigned int
|
2013-10-18 00:02:43 +02:00
|
|
|
_hb_glyph_info_get_lig_num_comps (const hb_glyph_info_t *info)
|
2012-07-30 04:02:24 +02:00
|
|
|
{
|
2013-10-18 00:02:43 +02:00
|
|
|
if ((info->glyph_props() & HB_OT_LAYOUT_GLYPH_PROPS_LIGATURE) &&
|
2013-10-18 01:09:08 +02:00
|
|
|
_hb_glyph_info_ligated_internal (info))
|
2013-10-18 00:02:43 +02:00
|
|
|
return info->lig_props() & 0x0F;
|
2012-07-30 04:02:24 +02:00
|
|
|
else
|
|
|
|
return 1;
|
2012-07-24 02:14:13 +02:00
|
|
|
}
|
|
|
|
|
2013-10-18 00:02:43 +02:00
|
|
|
static inline uint8_t
|
|
|
|
_hb_allocate_lig_id (hb_buffer_t *buffer) {
|
2012-07-30 04:02:24 +02:00
|
|
|
uint8_t lig_id = buffer->next_serial () & 0x07;
|
2012-07-24 02:14:13 +02:00
|
|
|
if (unlikely (!lig_id))
|
2013-10-18 00:02:43 +02:00
|
|
|
lig_id = _hb_allocate_lig_id (buffer); /* in case of overflow */
|
2012-07-24 02:14:13 +02:00
|
|
|
return lig_id;
|
|
|
|
}
|
|
|
|
|
2013-10-18 00:21:59 +02:00
|
|
|
/* glyph_props: */
|
|
|
|
|
2014-04-28 23:29:39 +02:00
|
|
|
static inline void
|
2013-10-18 00:21:59 +02:00
|
|
|
_hb_glyph_info_set_glyph_props (hb_glyph_info_t *info, unsigned int props)
|
|
|
|
{
|
|
|
|
info->glyph_props() = props;
|
|
|
|
}
|
|
|
|
|
2014-04-28 23:29:39 +02:00
|
|
|
static inline unsigned int
|
2013-10-18 00:42:39 +02:00
|
|
|
_hb_glyph_info_get_glyph_props (const hb_glyph_info_t *info)
|
|
|
|
{
|
|
|
|
return info->glyph_props();
|
|
|
|
}
|
|
|
|
|
2014-04-28 23:29:39 +02:00
|
|
|
static inline bool
|
2013-10-18 00:42:39 +02:00
|
|
|
_hb_glyph_info_is_base_glyph (const hb_glyph_info_t *info)
|
|
|
|
{
|
|
|
|
return !!(info->glyph_props() & HB_OT_LAYOUT_GLYPH_PROPS_BASE_GLYPH);
|
|
|
|
}
|
|
|
|
|
2014-04-28 23:29:39 +02:00
|
|
|
static inline bool
|
2013-10-18 00:42:39 +02:00
|
|
|
_hb_glyph_info_is_ligature (const hb_glyph_info_t *info)
|
|
|
|
{
|
|
|
|
return !!(info->glyph_props() & HB_OT_LAYOUT_GLYPH_PROPS_LIGATURE);
|
|
|
|
}
|
|
|
|
|
2014-04-28 23:29:39 +02:00
|
|
|
static inline bool
|
2013-10-18 00:42:39 +02:00
|
|
|
_hb_glyph_info_is_mark (const hb_glyph_info_t *info)
|
|
|
|
{
|
|
|
|
return !!(info->glyph_props() & HB_OT_LAYOUT_GLYPH_PROPS_MARK);
|
|
|
|
}
|
|
|
|
|
2013-10-18 01:11:05 +02:00
|
|
|
static inline bool
|
|
|
|
_hb_glyph_info_substituted (const hb_glyph_info_t *info)
|
|
|
|
{
|
|
|
|
return !!(info->glyph_props() & HB_OT_LAYOUT_GLYPH_PROPS_SUBSTITUTED);
|
|
|
|
}
|
|
|
|
|
2013-10-18 01:09:08 +02:00
|
|
|
static inline bool
|
|
|
|
_hb_glyph_info_ligated (const hb_glyph_info_t *info)
|
|
|
|
{
|
|
|
|
return !!(info->glyph_props() & HB_OT_LAYOUT_GLYPH_PROPS_LIGATED);
|
[indic] Don't reorder reph/pref if ligature was expanded
Normally if you want to, say, conditionally prevent a 'pref', you
would use blocking contextual matching. Some designers instead
form the 'pref' form, then undo it in context. To detect that
we now also remember glyphs that went through MultipleSubst.
In the only place that this is used, Uniscribe seems to only care
about the "last" transformation between Ligature and Multiple
substitions. Ie. if you ligate, expand, and ligate again, it
moves the pref, but if you ligate and expand it doesn't. That's
why we clear the MULTIPLIED bit when setting LIGATED.
Micro-test added. Test: U+0D2F,0D4D,0D30 with font from:
[1]
https://code.google.com/a/google.com/p/noto-alpha/issues/detail?id=186#c29
2014-06-04 22:57:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
_hb_glyph_info_multiplied (const hb_glyph_info_t *info)
|
|
|
|
{
|
|
|
|
return !!(info->glyph_props() & HB_OT_LAYOUT_GLYPH_PROPS_MULTIPLIED);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline bool
|
|
|
|
_hb_glyph_info_ligated_and_didnt_multiply (const hb_glyph_info_t *info)
|
|
|
|
{
|
|
|
|
return _hb_glyph_info_ligated (info) && !_hb_glyph_info_multiplied (info);
|
2013-10-18 01:09:08 +02:00
|
|
|
}
|
|
|
|
|
2014-06-06 23:28:38 +02:00
|
|
|
static inline void
|
|
|
|
_hb_glyph_info_clear_ligated_and_multiplied (hb_glyph_info_t *info)
|
|
|
|
{
|
|
|
|
info->glyph_props() &= ~(HB_OT_LAYOUT_GLYPH_PROPS_LIGATED |
|
|
|
|
HB_OT_LAYOUT_GLYPH_PROPS_MULTIPLIED);
|
|
|
|
}
|
|
|
|
|
2015-07-21 15:15:35 +02:00
|
|
|
static inline void
|
2015-12-17 12:59:15 +01:00
|
|
|
_hb_glyph_info_clear_substituted (hb_glyph_info_t *info)
|
2015-07-21 15:15:35 +02:00
|
|
|
{
|
2015-12-17 12:59:15 +01:00
|
|
|
info->glyph_props() &= ~(HB_OT_LAYOUT_GLYPH_PROPS_SUBSTITUTED);
|
2015-07-21 15:15:35 +02:00
|
|
|
}
|
|
|
|
|
2014-06-06 23:28:38 +02:00
|
|
|
|
2013-10-18 00:42:39 +02:00
|
|
|
/* Allocation / deallocation. */
|
|
|
|
|
2014-04-28 23:29:39 +02:00
|
|
|
static inline void
|
2013-10-18 00:42:39 +02:00
|
|
|
_hb_buffer_allocate_unicode_vars (hb_buffer_t *buffer)
|
|
|
|
{
|
2015-11-03 02:36:51 +01:00
|
|
|
HB_BUFFER_ALLOCATE_VAR (buffer, unicode_props);
|
2013-10-18 00:42:39 +02:00
|
|
|
}
|
|
|
|
|
2014-04-28 23:29:39 +02:00
|
|
|
static inline void
|
2013-10-18 00:42:39 +02:00
|
|
|
_hb_buffer_deallocate_unicode_vars (hb_buffer_t *buffer)
|
|
|
|
{
|
2015-11-03 02:36:51 +01:00
|
|
|
HB_BUFFER_DEALLOCATE_VAR (buffer, unicode_props);
|
2013-10-18 00:42:39 +02:00
|
|
|
}
|
|
|
|
|
2014-08-02 23:18:46 +02:00
|
|
|
static inline void
|
|
|
|
_hb_buffer_assert_unicode_vars (hb_buffer_t *buffer)
|
|
|
|
{
|
2015-11-03 02:36:51 +01:00
|
|
|
HB_BUFFER_ASSERT_VAR (buffer, unicode_props);
|
2014-08-02 23:18:46 +02:00
|
|
|
}
|
|
|
|
|
2014-04-28 23:29:39 +02:00
|
|
|
static inline void
|
2013-10-18 00:42:39 +02:00
|
|
|
_hb_buffer_allocate_gsubgpos_vars (hb_buffer_t *buffer)
|
|
|
|
{
|
|
|
|
HB_BUFFER_ALLOCATE_VAR (buffer, glyph_props);
|
|
|
|
HB_BUFFER_ALLOCATE_VAR (buffer, lig_props);
|
|
|
|
HB_BUFFER_ALLOCATE_VAR (buffer, syllable);
|
|
|
|
}
|
|
|
|
|
2014-04-28 23:29:39 +02:00
|
|
|
static inline void
|
2013-10-18 00:42:39 +02:00
|
|
|
_hb_buffer_deallocate_gsubgpos_vars (hb_buffer_t *buffer)
|
|
|
|
{
|
|
|
|
HB_BUFFER_DEALLOCATE_VAR (buffer, syllable);
|
|
|
|
HB_BUFFER_DEALLOCATE_VAR (buffer, lig_props);
|
|
|
|
HB_BUFFER_DEALLOCATE_VAR (buffer, glyph_props);
|
|
|
|
}
|
2013-10-18 00:21:59 +02:00
|
|
|
|
2014-08-02 23:18:46 +02:00
|
|
|
static inline void
|
|
|
|
_hb_buffer_assert_gsubgpos_vars (hb_buffer_t *buffer)
|
|
|
|
{
|
|
|
|
HB_BUFFER_ASSERT_VAR (buffer, glyph_props);
|
|
|
|
HB_BUFFER_ASSERT_VAR (buffer, lig_props);
|
|
|
|
HB_BUFFER_ASSERT_VAR (buffer, syllable);
|
|
|
|
}
|
|
|
|
|
2013-10-18 00:42:39 +02:00
|
|
|
/* Make sure no one directly touches our props... */
|
|
|
|
#undef unicode_props0
|
|
|
|
#undef unicode_props1
|
|
|
|
#undef lig_props
|
|
|
|
#undef glyph_props
|
2012-07-24 02:14:13 +02:00
|
|
|
|
2010-06-09 12:32:56 +02:00
|
|
|
#endif /* HB_OT_LAYOUT_PRIVATE_HH */
|