2011-06-02 21:43:12 +00:00
|
|
|
|
/*
|
2012-05-24 19:00:01 +00:00
|
|
|
|
* Copyright © 2011,2012 Google, Inc.
|
2011-06-02 21:43:12 +00:00
|
|
|
|
*
|
|
|
|
|
* This is part of HarfBuzz, a text shaping library.
|
|
|
|
|
*
|
|
|
|
|
* Permission is hereby granted, without written agreement and without
|
|
|
|
|
* license or royalty fees, to use, copy, modify, and distribute this
|
|
|
|
|
* software and its documentation for any purpose, provided that the
|
|
|
|
|
* above copyright notice and the following two paragraphs appear in
|
|
|
|
|
* all copies of this software.
|
|
|
|
|
*
|
|
|
|
|
* IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
|
|
|
|
|
* DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
|
|
|
|
|
* ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
|
|
|
|
|
* IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
|
|
|
|
|
* DAMAGE.
|
|
|
|
|
*
|
|
|
|
|
* THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
|
|
|
|
|
* BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
|
|
|
|
|
* FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
|
|
|
|
|
* ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
|
|
|
|
|
* PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
|
|
|
|
|
*
|
|
|
|
|
* Google Author(s): Behdad Esfahbod
|
|
|
|
|
*/
|
|
|
|
|
|
2018-08-26 05:36:36 +00:00
|
|
|
|
#include "hb-ot-shape-complex-indic.hh"
|
|
|
|
|
#include "hb-ot-layout.hh"
|
2011-07-30 23:04:02 +00:00
|
|
|
|
|
2013-02-12 17:14:10 +00:00
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Indic shaper.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
2012-08-02 18:21:40 +00:00
|
|
|
|
/*
|
|
|
|
|
* Indic configurations. Note that we do not want to keep every single script-specific
|
|
|
|
|
* behavior in these tables necessarily. This should mainly be used for per-script
|
|
|
|
|
* properties that are cheaper keeping here, than in the code. Ie. if, say, one and
|
|
|
|
|
* only one script has an exception, that one script can be if'ed directly in the code,
|
|
|
|
|
* instead of adding a new flag in these structs.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
enum base_position_t {
|
2013-10-17 14:49:06 +00:00
|
|
|
|
BASE_POS_LAST_SINHALA,
|
2012-08-02 18:21:40 +00:00
|
|
|
|
BASE_POS_LAST
|
|
|
|
|
};
|
|
|
|
|
enum reph_position_t {
|
|
|
|
|
REPH_POS_AFTER_MAIN = POS_AFTER_MAIN,
|
|
|
|
|
REPH_POS_BEFORE_SUB = POS_BEFORE_SUB,
|
|
|
|
|
REPH_POS_AFTER_SUB = POS_AFTER_SUB,
|
|
|
|
|
REPH_POS_BEFORE_POST = POS_BEFORE_POST,
|
2018-01-05 15:08:28 +00:00
|
|
|
|
REPH_POS_AFTER_POST = POS_AFTER_POST
|
2012-08-02 18:21:40 +00:00
|
|
|
|
};
|
|
|
|
|
enum reph_mode_t {
|
|
|
|
|
REPH_MODE_IMPLICIT, /* Reph formed out of initial Ra,H sequence. */
|
|
|
|
|
REPH_MODE_EXPLICIT, /* Reph formed out of initial Ra,H,ZWJ sequence. */
|
|
|
|
|
REPH_MODE_LOG_REPHA /* Encoded Repha character, needs reordering. */
|
|
|
|
|
};
|
2013-10-15 10:15:49 +00:00
|
|
|
|
enum blwf_mode_t {
|
|
|
|
|
BLWF_MODE_PRE_AND_POST, /* Below-forms feature applied to pre-base and post-base. */
|
|
|
|
|
BLWF_MODE_POST_ONLY /* Below-forms feature applied to post-base only. */
|
|
|
|
|
};
|
2012-08-02 18:21:40 +00:00
|
|
|
|
struct indic_config_t
|
|
|
|
|
{
|
|
|
|
|
hb_script_t script;
|
|
|
|
|
bool has_old_spec;
|
|
|
|
|
hb_codepoint_t virama;
|
|
|
|
|
base_position_t base_pos;
|
|
|
|
|
reph_position_t reph_pos;
|
|
|
|
|
reph_mode_t reph_mode;
|
2013-10-15 10:15:49 +00:00
|
|
|
|
blwf_mode_t blwf_mode;
|
2012-08-02 18:21:40 +00:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const indic_config_t indic_configs[] =
|
|
|
|
|
{
|
|
|
|
|
/* Default. Should be first. */
|
2016-05-06 15:05:07 +00:00
|
|
|
|
{HB_SCRIPT_INVALID, false, 0,BASE_POS_LAST, REPH_POS_BEFORE_POST,REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST},
|
|
|
|
|
{HB_SCRIPT_DEVANAGARI,true, 0x094Du,BASE_POS_LAST, REPH_POS_BEFORE_POST,REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST},
|
|
|
|
|
{HB_SCRIPT_BENGALI, true, 0x09CDu,BASE_POS_LAST, REPH_POS_AFTER_SUB, REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST},
|
|
|
|
|
{HB_SCRIPT_GURMUKHI, true, 0x0A4Du,BASE_POS_LAST, REPH_POS_BEFORE_SUB, REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST},
|
|
|
|
|
{HB_SCRIPT_GUJARATI, true, 0x0ACDu,BASE_POS_LAST, REPH_POS_BEFORE_POST,REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST},
|
|
|
|
|
{HB_SCRIPT_ORIYA, true, 0x0B4Du,BASE_POS_LAST, REPH_POS_AFTER_MAIN, REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST},
|
|
|
|
|
{HB_SCRIPT_TAMIL, true, 0x0BCDu,BASE_POS_LAST, REPH_POS_AFTER_POST, REPH_MODE_IMPLICIT, BLWF_MODE_PRE_AND_POST},
|
|
|
|
|
{HB_SCRIPT_TELUGU, true, 0x0C4Du,BASE_POS_LAST, REPH_POS_AFTER_POST, REPH_MODE_EXPLICIT, BLWF_MODE_POST_ONLY},
|
|
|
|
|
{HB_SCRIPT_KANNADA, true, 0x0CCDu,BASE_POS_LAST, REPH_POS_AFTER_POST, REPH_MODE_IMPLICIT, BLWF_MODE_POST_ONLY},
|
|
|
|
|
{HB_SCRIPT_MALAYALAM, true, 0x0D4Du,BASE_POS_LAST, REPH_POS_AFTER_MAIN, REPH_MODE_LOG_REPHA,BLWF_MODE_PRE_AND_POST},
|
2014-07-11 18:54:42 +00:00
|
|
|
|
{HB_SCRIPT_SINHALA, false,0x0DCAu,BASE_POS_LAST_SINHALA,
|
2018-06-04 22:40:43 +00:00
|
|
|
|
REPH_POS_AFTER_POST, REPH_MODE_EXPLICIT, BLWF_MODE_PRE_AND_POST},
|
2012-08-02 18:21:40 +00:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Indic shaper.
|
|
|
|
|
*/
|
2012-07-19 16:32:16 +00:00
|
|
|
|
|
2018-09-24 21:55:03 +00:00
|
|
|
|
static const hb_ot_map_feature_t
|
2012-08-02 16:21:44 +00:00
|
|
|
|
indic_features[] =
|
2011-06-02 21:43:12 +00:00
|
|
|
|
{
|
2012-08-02 16:21:44 +00:00
|
|
|
|
/*
|
|
|
|
|
* Basic features.
|
|
|
|
|
* These features are applied in order, one at a time, after initial_reordering.
|
|
|
|
|
*/
|
2018-09-30 09:43:22 +00:00
|
|
|
|
{HB_TAG('n','u','k','t'), F_GLOBAL_MANUAL_JOINERS},
|
|
|
|
|
{HB_TAG('a','k','h','n'), F_GLOBAL_MANUAL_JOINERS},
|
|
|
|
|
{HB_TAG('r','p','h','f'), F_MANUAL_JOINERS},
|
|
|
|
|
{HB_TAG('r','k','r','f'), F_GLOBAL_MANUAL_JOINERS},
|
|
|
|
|
{HB_TAG('p','r','e','f'), F_MANUAL_JOINERS},
|
|
|
|
|
{HB_TAG('b','l','w','f'), F_MANUAL_JOINERS},
|
|
|
|
|
{HB_TAG('a','b','v','f'), F_MANUAL_JOINERS},
|
|
|
|
|
{HB_TAG('h','a','l','f'), F_MANUAL_JOINERS},
|
|
|
|
|
{HB_TAG('p','s','t','f'), F_MANUAL_JOINERS},
|
|
|
|
|
{HB_TAG('v','a','t','u'), F_GLOBAL_MANUAL_JOINERS},
|
|
|
|
|
{HB_TAG('c','j','c','t'), F_GLOBAL_MANUAL_JOINERS},
|
2012-08-02 16:21:44 +00:00
|
|
|
|
/*
|
|
|
|
|
* Other features.
|
|
|
|
|
* These features are applied all at once, after final_reordering.
|
2013-10-15 14:37:53 +00:00
|
|
|
|
* Default Bengali font in Windows for example has intermixed
|
|
|
|
|
* lookups for init,pres,abvs,blws features.
|
2012-08-02 16:21:44 +00:00
|
|
|
|
*/
|
2018-09-30 09:43:22 +00:00
|
|
|
|
{HB_TAG('i','n','i','t'), F_MANUAL_JOINERS},
|
|
|
|
|
{HB_TAG('p','r','e','s'), F_GLOBAL_MANUAL_JOINERS},
|
|
|
|
|
{HB_TAG('a','b','v','s'), F_GLOBAL_MANUAL_JOINERS},
|
|
|
|
|
{HB_TAG('b','l','w','s'), F_GLOBAL_MANUAL_JOINERS},
|
|
|
|
|
{HB_TAG('p','s','t','s'), F_GLOBAL_MANUAL_JOINERS},
|
|
|
|
|
{HB_TAG('h','a','l','n'), F_GLOBAL_MANUAL_JOINERS},
|
2018-09-24 02:33:38 +00:00
|
|
|
|
/*
|
|
|
|
|
* Positioning features.
|
|
|
|
|
* We don't care about the types.
|
|
|
|
|
*/
|
2013-02-14 16:25:10 +00:00
|
|
|
|
{HB_TAG('d','i','s','t'), F_GLOBAL},
|
|
|
|
|
{HB_TAG('a','b','v','m'), F_GLOBAL},
|
|
|
|
|
{HB_TAG('b','l','w','m'), F_GLOBAL},
|
2011-06-24 23:05:34 +00:00
|
|
|
|
};
|
|
|
|
|
|
2012-08-02 16:21:44 +00:00
|
|
|
|
/*
|
|
|
|
|
* Must be in the same order as the indic_features array.
|
|
|
|
|
*/
|
2011-06-24 23:05:34 +00:00
|
|
|
|
enum {
|
|
|
|
|
_NUKT,
|
2012-07-20 00:24:14 +00:00
|
|
|
|
_AKHN,
|
2011-06-24 23:05:34 +00:00
|
|
|
|
RPHF,
|
2012-05-09 09:38:31 +00:00
|
|
|
|
_RKRF,
|
2011-06-24 23:05:34 +00:00
|
|
|
|
PREF,
|
2012-08-06 04:16:26 +00:00
|
|
|
|
BLWF,
|
2012-07-16 16:05:35 +00:00
|
|
|
|
ABVF,
|
2013-10-15 14:37:53 +00:00
|
|
|
|
HALF,
|
2011-06-24 23:05:34 +00:00
|
|
|
|
PSTF,
|
2012-08-02 16:21:44 +00:00
|
|
|
|
_VATU,
|
2013-02-12 23:01:21 +00:00
|
|
|
|
_CJCT,
|
2012-08-02 16:21:44 +00:00
|
|
|
|
|
|
|
|
|
INIT,
|
|
|
|
|
_PRES,
|
|
|
|
|
_ABVS,
|
|
|
|
|
_BLWS,
|
|
|
|
|
_PSTS,
|
|
|
|
|
_HALN,
|
2018-09-24 02:33:38 +00:00
|
|
|
|
|
2012-08-02 16:21:44 +00:00
|
|
|
|
_DIST,
|
|
|
|
|
_ABVM,
|
|
|
|
|
_BLWM,
|
|
|
|
|
|
|
|
|
|
INDIC_NUM_FEATURES,
|
2018-09-24 02:33:38 +00:00
|
|
|
|
INDIC_BASIC_FEATURES = INIT, /* Don't forget to update this! */
|
2011-06-02 21:43:12 +00:00
|
|
|
|
};
|
|
|
|
|
|
2012-09-07 18:55:07 +00:00
|
|
|
|
static void
|
|
|
|
|
setup_syllables (const hb_ot_shape_plan_t *plan,
|
|
|
|
|
hb_font_t *font,
|
|
|
|
|
hb_buffer_t *buffer);
|
2011-07-29 20:37:02 +00:00
|
|
|
|
static void
|
2012-08-02 14:07:58 +00:00
|
|
|
|
initial_reordering (const hb_ot_shape_plan_t *plan,
|
2012-08-02 12:36:40 +00:00
|
|
|
|
hb_font_t *font,
|
2012-08-02 13:44:18 +00:00
|
|
|
|
hb_buffer_t *buffer);
|
2011-07-08 04:22:40 +00:00
|
|
|
|
static void
|
2012-08-02 14:07:58 +00:00
|
|
|
|
final_reordering (const hb_ot_shape_plan_t *plan,
|
2012-08-02 12:36:40 +00:00
|
|
|
|
hb_font_t *font,
|
2012-08-02 13:44:18 +00:00
|
|
|
|
hb_buffer_t *buffer);
|
[indic] Don't apply presentation features across syllables
More like Uniscribe... We still allow user-defined features to
work across syllables, but not pres,blws,abs,psts,etc.
This "regressed" Sinhala numbers by 11. These are cases were
there's Consonant followed by Ra,Halant,ZWJ at the of text.
The Ra,Halant,ZWJ ends up forming reph, which is wrong...
But before we were also ligating that reph with the previous
consonant. That's even more wrong. That's also what Uniscribe
does.
Current numbers:
BENGALI: 353732 out of 354188 tests passed. 456 failed (0.128745%)
DEVANAGARI: 707307 out of 707394 tests passed. 87 failed (0.0122987%)
GUJARATI: 366349 out of 366457 tests passed. 108 failed (0.0294714%)
GURMUKHI: 60732 out of 60747 tests passed. 15 failed (0.0246926%)
KANNADA: 951030 out of 951913 tests passed. 883 failed (0.0927606%)
KHMER: 299070 out of 299124 tests passed. 54 failed (0.0180527%)
MALAYALAM: 1048140 out of 1048334 tests passed. 194 failed (0.0185056%)
ORIYA: 42320 out of 42329 tests passed. 9 failed (0.021262%)
SINHALA: 271655 out of 271847 tests passed. 192 failed (0.070628%)
TAMIL: 1091753 out of 1091754 tests passed. 1 failed (9.15957e-05%)
TELUGU: 970555 out of 970573 tests passed. 18 failed (0.00185457%)
2013-10-15 11:47:27 +00:00
|
|
|
|
static void
|
|
|
|
|
clear_syllables (const hb_ot_shape_plan_t *plan,
|
|
|
|
|
hb_font_t *font,
|
|
|
|
|
hb_buffer_t *buffer);
|
2011-06-02 21:43:12 +00:00
|
|
|
|
|
2012-07-31 01:08:51 +00:00
|
|
|
|
static void
|
2012-08-02 13:38:28 +00:00
|
|
|
|
collect_features_indic (hb_ot_shape_planner_t *plan)
|
2011-06-02 21:43:12 +00:00
|
|
|
|
{
|
2012-08-02 13:38:28 +00:00
|
|
|
|
hb_ot_map_builder_t *map = &plan->map;
|
|
|
|
|
|
2012-09-07 18:55:07 +00:00
|
|
|
|
/* Do this before any lookups have been applied. */
|
|
|
|
|
map->add_gsub_pause (setup_syllables);
|
|
|
|
|
|
2018-09-24 22:01:53 +00:00
|
|
|
|
map->enable_feature (HB_TAG('l','o','c','l'));
|
2011-07-20 20:42:10 +00:00
|
|
|
|
/* The Indic specs do not require ccmp, but we apply it here since if
|
|
|
|
|
* there is a use of it, it's typically at the beginning. */
|
2018-09-24 22:01:53 +00:00
|
|
|
|
map->enable_feature (HB_TAG('c','c','m','p'));
|
2011-07-08 04:22:40 +00:00
|
|
|
|
|
|
|
|
|
|
2012-08-02 16:21:44 +00:00
|
|
|
|
unsigned int i = 0;
|
|
|
|
|
map->add_gsub_pause (initial_reordering);
|
2018-09-24 02:33:38 +00:00
|
|
|
|
|
2012-08-02 16:21:44 +00:00
|
|
|
|
for (; i < INDIC_BASIC_FEATURES; i++) {
|
2018-09-24 21:55:03 +00:00
|
|
|
|
map->add_feature (indic_features[i]);
|
2017-10-15 10:11:08 +00:00
|
|
|
|
map->add_gsub_pause (nullptr);
|
2012-05-09 09:07:18 +00:00
|
|
|
|
}
|
2018-09-24 02:33:38 +00:00
|
|
|
|
|
2012-08-02 13:44:18 +00:00
|
|
|
|
map->add_gsub_pause (final_reordering);
|
2018-09-24 02:33:38 +00:00
|
|
|
|
|
|
|
|
|
for (; i < INDIC_NUM_FEATURES; i++)
|
2018-09-24 21:55:03 +00:00
|
|
|
|
map->add_feature (indic_features[i]);
|
2013-10-17 11:05:05 +00:00
|
|
|
|
|
2018-09-24 22:01:53 +00:00
|
|
|
|
map->enable_feature (HB_TAG('c','a','l','t'));
|
|
|
|
|
map->enable_feature (HB_TAG('c','l','i','g'));
|
2013-10-17 11:05:05 +00:00
|
|
|
|
|
[indic] Don't apply presentation features across syllables
More like Uniscribe... We still allow user-defined features to
work across syllables, but not pres,blws,abs,psts,etc.
This "regressed" Sinhala numbers by 11. These are cases were
there's Consonant followed by Ra,Halant,ZWJ at the of text.
The Ra,Halant,ZWJ ends up forming reph, which is wrong...
But before we were also ligating that reph with the previous
consonant. That's even more wrong. That's also what Uniscribe
does.
Current numbers:
BENGALI: 353732 out of 354188 tests passed. 456 failed (0.128745%)
DEVANAGARI: 707307 out of 707394 tests passed. 87 failed (0.0122987%)
GUJARATI: 366349 out of 366457 tests passed. 108 failed (0.0294714%)
GURMUKHI: 60732 out of 60747 tests passed. 15 failed (0.0246926%)
KANNADA: 951030 out of 951913 tests passed. 883 failed (0.0927606%)
KHMER: 299070 out of 299124 tests passed. 54 failed (0.0180527%)
MALAYALAM: 1048140 out of 1048334 tests passed. 194 failed (0.0185056%)
ORIYA: 42320 out of 42329 tests passed. 9 failed (0.021262%)
SINHALA: 271655 out of 271847 tests passed. 192 failed (0.070628%)
TAMIL: 1091753 out of 1091754 tests passed. 1 failed (9.15957e-05%)
TELUGU: 970555 out of 970573 tests passed. 18 failed (0.00185457%)
2013-10-15 11:47:27 +00:00
|
|
|
|
map->add_gsub_pause (clear_syllables);
|
2011-06-02 21:43:12 +00:00
|
|
|
|
}
|
|
|
|
|
|
2012-07-31 01:08:51 +00:00
|
|
|
|
static void
|
2012-08-02 13:38:28 +00:00
|
|
|
|
override_features_indic (hb_ot_shape_planner_t *plan)
|
2012-07-17 00:26:57 +00:00
|
|
|
|
{
|
2018-09-24 21:55:03 +00:00
|
|
|
|
plan->map.disable_feature (HB_TAG('l','i','g','a'));
|
2012-07-17 00:26:57 +00:00
|
|
|
|
}
|
|
|
|
|
|
2011-06-17 22:35:46 +00:00
|
|
|
|
|
2012-08-02 16:21:44 +00:00
|
|
|
|
struct would_substitute_feature_t
|
2012-08-02 14:46:34 +00:00
|
|
|
|
{
|
2013-10-17 16:04:23 +00:00
|
|
|
|
inline void init (const hb_ot_map_t *map, hb_tag_t feature_tag, bool zero_context_)
|
2012-08-02 14:46:34 +00:00
|
|
|
|
{
|
2013-10-17 16:04:23 +00:00
|
|
|
|
zero_context = zero_context_;
|
2012-08-02 14:46:34 +00:00
|
|
|
|
map->get_stage_lookups (0/*GSUB*/,
|
|
|
|
|
map->get_feature_stage (0/*GSUB*/, feature_tag),
|
|
|
|
|
&lookups, &count);
|
|
|
|
|
}
|
|
|
|
|
|
2013-03-06 01:08:59 +00:00
|
|
|
|
inline bool would_substitute (const hb_codepoint_t *glyphs,
|
|
|
|
|
unsigned int glyphs_count,
|
|
|
|
|
hb_face_t *face) const
|
2012-08-02 14:46:34 +00:00
|
|
|
|
{
|
|
|
|
|
for (unsigned int i = 0; i < count; i++)
|
2012-11-15 22:57:31 +00:00
|
|
|
|
if (hb_ot_layout_lookup_would_substitute_fast (face, lookups[i].index, glyphs, glyphs_count, zero_context))
|
2012-08-02 14:46:34 +00:00
|
|
|
|
return true;
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
const hb_ot_map_t::lookup_map_t *lookups;
|
|
|
|
|
unsigned int count;
|
2013-10-17 16:04:23 +00:00
|
|
|
|
bool zero_context;
|
2012-08-02 14:46:34 +00:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct indic_shape_plan_t
|
|
|
|
|
{
|
2012-08-02 16:21:44 +00:00
|
|
|
|
ASSERT_POD ();
|
2012-08-02 15:03:39 +00:00
|
|
|
|
|
2018-08-01 04:05:51 +00:00
|
|
|
|
inline bool load_virama_glyph (hb_font_t *font, hb_codepoint_t *pglyph) const
|
2012-08-02 15:03:39 +00:00
|
|
|
|
{
|
2018-08-01 04:05:51 +00:00
|
|
|
|
hb_codepoint_t glyph = virama_glyph.get_relaxed ();
|
|
|
|
|
if (unlikely (glyph == (hb_codepoint_t) -1))
|
2012-08-02 15:03:39 +00:00
|
|
|
|
{
|
2016-02-24 10:05:23 +00:00
|
|
|
|
if (!config->virama || !font->get_nominal_glyph (config->virama, &glyph))
|
2012-08-02 15:03:39 +00:00
|
|
|
|
glyph = 0;
|
|
|
|
|
/* Technically speaking, the spec says we should apply 'locl' to virama too.
|
|
|
|
|
* Maybe one day... */
|
|
|
|
|
|
2016-02-24 10:05:23 +00:00
|
|
|
|
/* Our get_nominal_glyph() function needs a font, so we can't get the virama glyph
|
2018-08-01 04:05:51 +00:00
|
|
|
|
* during shape planning... Instead, overwrite it here. */
|
|
|
|
|
virama_glyph.set_relaxed ((int) glyph);
|
2012-08-02 15:03:39 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
*pglyph = glyph;
|
|
|
|
|
return glyph != 0;
|
|
|
|
|
}
|
2012-08-02 16:21:44 +00:00
|
|
|
|
|
2012-08-02 18:21:40 +00:00
|
|
|
|
const indic_config_t *config;
|
2012-08-02 16:21:44 +00:00
|
|
|
|
|
|
|
|
|
bool is_old_spec;
|
2018-09-10 20:51:26 +00:00
|
|
|
|
bool uniscribe_bug_compatible;
|
2018-08-01 04:05:51 +00:00
|
|
|
|
mutable hb_atomic_int_t virama_glyph;
|
2012-08-02 16:21:44 +00:00
|
|
|
|
|
2012-11-12 22:02:02 +00:00
|
|
|
|
would_substitute_feature_t rphf;
|
2012-08-02 16:21:44 +00:00
|
|
|
|
would_substitute_feature_t pref;
|
|
|
|
|
would_substitute_feature_t blwf;
|
|
|
|
|
would_substitute_feature_t pstf;
|
|
|
|
|
|
|
|
|
|
hb_mask_t mask_array[INDIC_NUM_FEATURES];
|
2012-08-02 14:46:34 +00:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static void *
|
|
|
|
|
data_create_indic (const hb_ot_shape_plan_t *plan)
|
|
|
|
|
{
|
2012-08-02 16:21:44 +00:00
|
|
|
|
indic_shape_plan_t *indic_plan = (indic_shape_plan_t *) calloc (1, sizeof (indic_shape_plan_t));
|
|
|
|
|
if (unlikely (!indic_plan))
|
2017-10-15 10:11:08 +00:00
|
|
|
|
return nullptr;
|
2012-08-02 14:46:34 +00:00
|
|
|
|
|
2012-08-02 18:21:40 +00:00
|
|
|
|
indic_plan->config = &indic_configs[0];
|
|
|
|
|
for (unsigned int i = 1; i < ARRAY_LENGTH (indic_configs); i++)
|
|
|
|
|
if (plan->props.script == indic_configs[i].script) {
|
|
|
|
|
indic_plan->config = &indic_configs[i];
|
|
|
|
|
break;
|
2012-08-02 16:21:44 +00:00
|
|
|
|
}
|
2012-08-02 18:21:40 +00:00
|
|
|
|
|
2014-07-11 18:54:42 +00:00
|
|
|
|
indic_plan->is_old_spec = indic_plan->config->has_old_spec && ((plan->map.chosen_script[0] & 0x000000FFu) != '2');
|
2018-09-10 20:51:26 +00:00
|
|
|
|
indic_plan->uniscribe_bug_compatible = hb_options ().uniscribe_bug_compatible;
|
2018-08-01 04:05:51 +00:00
|
|
|
|
indic_plan->virama_glyph.set_relaxed (-1);
|
2012-08-02 16:21:44 +00:00
|
|
|
|
|
2013-10-17 16:04:23 +00:00
|
|
|
|
/* Use zero-context would_substitute() matching for new-spec of the main
|
2015-12-17 17:31:17 +00:00
|
|
|
|
* Indic scripts, and scripts with one spec only, but not for old-specs.
|
|
|
|
|
* The new-spec for all dual-spec scripts says zero-context matching happens.
|
|
|
|
|
*
|
|
|
|
|
* However, testing with Malayalam shows that old and new spec both allow
|
|
|
|
|
* context. Testing with Bengali new-spec however shows that it doesn't.
|
|
|
|
|
* So, the heuristic here is the way it is. It should *only* be changed,
|
|
|
|
|
* as we discover more cases of what Windows does. DON'T TOUCH OTHERWISE.
|
|
|
|
|
*/
|
|
|
|
|
bool zero_context = !indic_plan->is_old_spec && plan->props.script != HB_SCRIPT_MALAYALAM;
|
2013-10-17 16:04:23 +00:00
|
|
|
|
indic_plan->rphf.init (&plan->map, HB_TAG('r','p','h','f'), zero_context);
|
|
|
|
|
indic_plan->pref.init (&plan->map, HB_TAG('p','r','e','f'), zero_context);
|
|
|
|
|
indic_plan->blwf.init (&plan->map, HB_TAG('b','l','w','f'), zero_context);
|
|
|
|
|
indic_plan->pstf.init (&plan->map, HB_TAG('p','s','t','f'), zero_context);
|
2012-08-02 16:21:44 +00:00
|
|
|
|
|
|
|
|
|
for (unsigned int i = 0; i < ARRAY_LENGTH (indic_plan->mask_array); i++)
|
2013-02-14 16:25:10 +00:00
|
|
|
|
indic_plan->mask_array[i] = (indic_features[i].flags & F_GLOBAL) ?
|
|
|
|
|
0 : plan->map.get_1_mask (indic_features[i].tag);
|
2012-08-02 14:46:34 +00:00
|
|
|
|
|
2012-08-02 16:21:44 +00:00
|
|
|
|
return indic_plan;
|
2012-08-02 14:46:34 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
data_destroy_indic (void *data)
|
|
|
|
|
{
|
|
|
|
|
free (data);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static indic_position_t
|
|
|
|
|
consonant_position_from_face (const indic_shape_plan_t *indic_plan,
|
2013-10-17 16:30:06 +00:00
|
|
|
|
const hb_codepoint_t consonant,
|
|
|
|
|
const hb_codepoint_t virama,
|
2013-03-06 01:08:59 +00:00
|
|
|
|
hb_face_t *face)
|
2012-08-02 14:46:34 +00:00
|
|
|
|
{
|
2013-03-06 01:08:59 +00:00
|
|
|
|
/* For old-spec, the order of glyphs is Consonant,Virama,
|
|
|
|
|
* whereas for new-spec, it's Virama,Consonant. However,
|
|
|
|
|
* some broken fonts (like Free Sans) simply copied lookups
|
|
|
|
|
* from old-spec to new-spec without modification.
|
|
|
|
|
* And oddly enough, Uniscribe seems to respect those lookups.
|
|
|
|
|
* Eg. in the sequence U+0924,U+094D,U+0930, Uniscribe finds
|
|
|
|
|
* base at 0. The font however, only has lookups matching
|
|
|
|
|
* 930,94D in 'blwf', not the expected 94D,930 (with new-spec
|
|
|
|
|
* table). As such, we simply match both sequences. Seems
|
|
|
|
|
* to work. */
|
2013-10-17 16:30:06 +00:00
|
|
|
|
hb_codepoint_t glyphs[3] = {virama, consonant, virama};
|
2013-10-17 16:04:23 +00:00
|
|
|
|
if (indic_plan->blwf.would_substitute (glyphs , 2, face) ||
|
2013-10-17 16:30:06 +00:00
|
|
|
|
indic_plan->blwf.would_substitute (glyphs+1, 2, face))
|
2013-03-06 01:08:59 +00:00
|
|
|
|
return POS_BELOW_C;
|
2013-10-17 16:04:23 +00:00
|
|
|
|
if (indic_plan->pstf.would_substitute (glyphs , 2, face) ||
|
2013-10-17 16:30:06 +00:00
|
|
|
|
indic_plan->pstf.would_substitute (glyphs+1, 2, face))
|
2013-03-06 01:08:59 +00:00
|
|
|
|
return POS_POST_C;
|
2016-05-06 15:05:07 +00:00
|
|
|
|
if (indic_plan->pref.would_substitute (glyphs , 2, face) ||
|
|
|
|
|
indic_plan->pref.would_substitute (glyphs+1, 2, face))
|
2013-10-17 10:24:55 +00:00
|
|
|
|
return POS_POST_C;
|
2012-08-02 14:46:34 +00:00
|
|
|
|
return POS_BASE_C;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-09-07 18:55:07 +00:00
|
|
|
|
enum syllable_type_t {
|
|
|
|
|
consonant_syllable,
|
|
|
|
|
vowel_syllable,
|
|
|
|
|
standalone_cluster,
|
2014-05-23 19:33:13 +00:00
|
|
|
|
symbol_cluster,
|
2012-09-07 18:55:07 +00:00
|
|
|
|
broken_cluster,
|
|
|
|
|
non_indic_cluster,
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#include "hb-ot-shape-complex-indic-machine.hh"
|
|
|
|
|
|
|
|
|
|
|
2012-08-02 12:42:11 +00:00
|
|
|
|
static void
|
2012-08-02 13:38:28 +00:00
|
|
|
|
setup_masks_indic (const hb_ot_shape_plan_t *plan HB_UNUSED,
|
|
|
|
|
hb_buffer_t *buffer,
|
|
|
|
|
hb_font_t *font HB_UNUSED)
|
2012-08-02 12:42:11 +00:00
|
|
|
|
{
|
|
|
|
|
HB_BUFFER_ALLOCATE_VAR (buffer, indic_category);
|
|
|
|
|
HB_BUFFER_ALLOCATE_VAR (buffer, indic_position);
|
|
|
|
|
|
|
|
|
|
/* We cannot setup masks here. We save information about characters
|
|
|
|
|
* and setup masks later on in a pause-callback. */
|
|
|
|
|
|
|
|
|
|
unsigned int count = buffer->len;
|
2014-07-17 18:22:11 +00:00
|
|
|
|
hb_glyph_info_t *info = buffer->info;
|
2012-08-02 12:42:11 +00:00
|
|
|
|
for (unsigned int i = 0; i < count; i++)
|
2014-07-17 18:22:11 +00:00
|
|
|
|
set_indic_properties (info[i]);
|
2012-08-02 12:42:11 +00:00
|
|
|
|
}
|
|
|
|
|
|
2012-09-07 18:55:07 +00:00
|
|
|
|
static void
|
|
|
|
|
setup_syllables (const hb_ot_shape_plan_t *plan HB_UNUSED,
|
|
|
|
|
hb_font_t *font HB_UNUSED,
|
|
|
|
|
hb_buffer_t *buffer)
|
|
|
|
|
{
|
|
|
|
|
find_syllables (buffer);
|
2017-08-11 01:45:33 +00:00
|
|
|
|
foreach_syllable (buffer, start, end)
|
|
|
|
|
buffer->unsafe_to_break (start, end);
|
2012-09-07 18:55:07 +00:00
|
|
|
|
}
|
|
|
|
|
|
2012-08-02 12:42:11 +00:00
|
|
|
|
static int
|
|
|
|
|
compare_indic_order (const hb_glyph_info_t *pa, const hb_glyph_info_t *pb)
|
|
|
|
|
{
|
|
|
|
|
int a = pa->indic_position();
|
|
|
|
|
int b = pb->indic_position();
|
|
|
|
|
|
|
|
|
|
return a < b ? -1 : a == b ? 0 : +1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2012-08-02 11:53:18 +00:00
|
|
|
|
static void
|
2012-08-02 14:07:58 +00:00
|
|
|
|
update_consonant_positions (const hb_ot_shape_plan_t *plan,
|
2012-08-02 16:21:44 +00:00
|
|
|
|
hb_font_t *font,
|
|
|
|
|
hb_buffer_t *buffer)
|
2012-08-02 11:53:18 +00:00
|
|
|
|
{
|
2012-08-02 14:46:34 +00:00
|
|
|
|
const indic_shape_plan_t *indic_plan = (const indic_shape_plan_t *) plan->data;
|
2012-08-02 11:53:18 +00:00
|
|
|
|
|
2013-10-17 15:04:47 +00:00
|
|
|
|
if (indic_plan->config->base_pos != BASE_POS_LAST)
|
|
|
|
|
return;
|
|
|
|
|
|
2013-10-17 16:30:06 +00:00
|
|
|
|
hb_codepoint_t virama;
|
2018-08-01 04:05:51 +00:00
|
|
|
|
if (indic_plan->load_virama_glyph (font, &virama))
|
2012-08-02 11:53:18 +00:00
|
|
|
|
{
|
|
|
|
|
hb_face_t *face = font->face;
|
|
|
|
|
unsigned int count = buffer->len;
|
2014-07-17 18:22:11 +00:00
|
|
|
|
hb_glyph_info_t *info = buffer->info;
|
2012-08-02 11:53:18 +00:00
|
|
|
|
for (unsigned int i = 0; i < count; i++)
|
2014-07-17 18:22:11 +00:00
|
|
|
|
if (info[i].indic_position() == POS_BASE_C)
|
|
|
|
|
{
|
|
|
|
|
hb_codepoint_t consonant = info[i].codepoint;
|
|
|
|
|
info[i].indic_position() = consonant_position_from_face (indic_plan, consonant, virama, face);
|
2012-08-02 11:53:18 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2011-06-17 22:35:46 +00:00
|
|
|
|
|
2012-05-11 16:58:57 +00:00
|
|
|
|
/* Rules from:
|
2018-04-12 09:10:45 +00:00
|
|
|
|
* https://docs.microsqoft.com/en-us/typography/script-development/devanagari */
|
2012-05-11 16:58:57 +00:00
|
|
|
|
|
2011-07-29 20:37:02 +00:00
|
|
|
|
static void
|
2012-11-12 22:02:02 +00:00
|
|
|
|
initial_reordering_consonant_syllable (const hb_ot_shape_plan_t *plan,
|
|
|
|
|
hb_face_t *face,
|
|
|
|
|
hb_buffer_t *buffer,
|
2012-05-09 15:56:03 +00:00
|
|
|
|
unsigned int start, unsigned int end)
|
2011-07-29 20:37:02 +00:00
|
|
|
|
{
|
2012-08-02 15:03:39 +00:00
|
|
|
|
const indic_shape_plan_t *indic_plan = (const indic_shape_plan_t *) plan->data;
|
2011-07-30 23:15:53 +00:00
|
|
|
|
hb_glyph_info_t *info = buffer->info;
|
2011-07-29 20:37:02 +00:00
|
|
|
|
|
2017-11-20 19:49:22 +00:00
|
|
|
|
/* https://github.com/harfbuzz/harfbuzz/issues/435#issuecomment-335560167
|
2017-11-03 13:05:00 +00:00
|
|
|
|
* // For compatibility with legacy usage in Kannada,
|
2017-10-12 12:07:37 +00:00
|
|
|
|
* // Ra+h+ZWJ must behave like Ra+ZWJ+h...
|
|
|
|
|
*/
|
|
|
|
|
if (buffer->props.script == HB_SCRIPT_KANNADA &&
|
|
|
|
|
start + 3 <= end &&
|
|
|
|
|
is_one_of (info[start ], FLAG (OT_Ra)) &&
|
|
|
|
|
is_one_of (info[start+1], FLAG (OT_H)) &&
|
|
|
|
|
is_one_of (info[start+2], FLAG (OT_ZWJ)))
|
|
|
|
|
{
|
|
|
|
|
buffer->merge_clusters (start+1, start+3);
|
|
|
|
|
hb_glyph_info_t tmp = info[start+1];
|
|
|
|
|
info[start+1] = info[start+2];
|
|
|
|
|
info[start+2] = tmp;
|
|
|
|
|
}
|
2012-05-13 14:48:03 +00:00
|
|
|
|
|
2011-07-29 20:37:02 +00:00
|
|
|
|
/* 1. Find base consonant:
|
|
|
|
|
*
|
|
|
|
|
* The shaping engine finds the base consonant of the syllable, using the
|
|
|
|
|
* following algorithm: starting from the end of the syllable, move backwards
|
|
|
|
|
* until a consonant is found that does not have a below-base or post-base
|
|
|
|
|
* form (post-base forms have to follow below-base forms), or that is not a
|
2017-12-05 17:43:09 +00:00
|
|
|
|
* pre-base-reordering Ra, or arrive at the first consonant. The consonant
|
2011-07-29 20:37:02 +00:00
|
|
|
|
* stopped at will be the base.
|
|
|
|
|
*
|
|
|
|
|
* o If the syllable starts with Ra + Halant (in a script that has Reph)
|
|
|
|
|
* and has more than one consonant, Ra is excluded from candidates for
|
|
|
|
|
* base consonants.
|
|
|
|
|
*/
|
|
|
|
|
|
2011-07-31 21:51:50 +00:00
|
|
|
|
unsigned int base = end;
|
2012-05-09 09:43:43 +00:00
|
|
|
|
bool has_reph = false;
|
2011-07-29 20:37:02 +00:00
|
|
|
|
|
2012-05-09 09:43:43 +00:00
|
|
|
|
{
|
2012-05-13 14:48:03 +00:00
|
|
|
|
/* -> If the syllable starts with Ra + Halant (in a script that has Reph)
|
|
|
|
|
* and has more than one consonant, Ra is excluded from candidates for
|
|
|
|
|
* base consonants. */
|
|
|
|
|
unsigned int limit = start;
|
2018-01-05 15:08:28 +00:00
|
|
|
|
if (indic_plan->mask_array[RPHF] &&
|
2012-05-13 14:48:03 +00:00
|
|
|
|
start + 3 <= end &&
|
2012-12-21 20:48:32 +00:00
|
|
|
|
(
|
2012-08-02 18:21:40 +00:00
|
|
|
|
(indic_plan->config->reph_mode == REPH_MODE_IMPLICIT && !is_joiner (info[start + 2])) ||
|
|
|
|
|
(indic_plan->config->reph_mode == REPH_MODE_EXPLICIT && info[start + 2].indic_category() == OT_ZWJ)
|
2012-07-18 21:22:14 +00:00
|
|
|
|
))
|
2012-05-13 14:48:03 +00:00
|
|
|
|
{
|
2012-11-12 22:02:02 +00:00
|
|
|
|
/* See if it matches the 'rphf' feature. */
|
2014-05-15 20:04:02 +00:00
|
|
|
|
hb_codepoint_t glyphs[3] = {info[start].codepoint,
|
|
|
|
|
info[start + 1].codepoint,
|
|
|
|
|
indic_plan->config->reph_mode == REPH_MODE_EXPLICIT ?
|
|
|
|
|
info[start + 2].codepoint : 0};
|
|
|
|
|
if (indic_plan->rphf.would_substitute (glyphs, 2, face) ||
|
|
|
|
|
(indic_plan->config->reph_mode == REPH_MODE_EXPLICIT &&
|
|
|
|
|
indic_plan->rphf.would_substitute (glyphs, 3, face)))
|
2012-11-12 22:02:02 +00:00
|
|
|
|
{
|
|
|
|
|
limit += 2;
|
|
|
|
|
while (limit < end && is_joiner (info[limit]))
|
|
|
|
|
limit++;
|
|
|
|
|
base = start;
|
|
|
|
|
has_reph = true;
|
|
|
|
|
}
|
2012-12-21 20:48:32 +00:00
|
|
|
|
} else if (indic_plan->config->reph_mode == REPH_MODE_LOG_REPHA && info[start].indic_category() == OT_Repha)
|
|
|
|
|
{
|
|
|
|
|
limit += 1;
|
|
|
|
|
while (limit < end && is_joiner (info[limit]))
|
|
|
|
|
limit++;
|
|
|
|
|
base = start;
|
|
|
|
|
has_reph = true;
|
|
|
|
|
}
|
2012-05-09 09:43:43 +00:00
|
|
|
|
|
2012-08-26 18:30:18 +00:00
|
|
|
|
switch (indic_plan->config->base_pos)
|
2012-07-17 18:23:28 +00:00
|
|
|
|
{
|
2012-08-02 18:21:40 +00:00
|
|
|
|
case BASE_POS_LAST:
|
|
|
|
|
{
|
|
|
|
|
/* -> starting from the end of the syllable, move backwards */
|
|
|
|
|
unsigned int i = end;
|
|
|
|
|
bool seen_below = false;
|
|
|
|
|
do {
|
|
|
|
|
i--;
|
|
|
|
|
/* -> until a consonant is found */
|
|
|
|
|
if (is_consonant (info[i]))
|
2012-07-17 18:23:28 +00:00
|
|
|
|
{
|
2012-08-02 18:21:40 +00:00
|
|
|
|
/* -> that does not have a below-base or post-base form
|
|
|
|
|
* (post-base forms have to follow below-base forms), */
|
|
|
|
|
if (info[i].indic_position() != POS_BELOW_C &&
|
|
|
|
|
(info[i].indic_position() != POS_POST_C || seen_below))
|
|
|
|
|
{
|
|
|
|
|
base = i;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (info[i].indic_position() == POS_BELOW_C)
|
|
|
|
|
seen_below = true;
|
|
|
|
|
|
2017-12-05 17:43:09 +00:00
|
|
|
|
/* -> or that is not a pre-base-reordering Ra,
|
2012-08-02 18:21:40 +00:00
|
|
|
|
*
|
|
|
|
|
* IMPLEMENTATION NOTES:
|
|
|
|
|
*
|
2017-12-05 17:43:09 +00:00
|
|
|
|
* Our pre-base-reordering Ra's are marked POS_POST_C, so will be skipped
|
2012-08-02 18:21:40 +00:00
|
|
|
|
* by the logic above already.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
/* -> or arrive at the first consonant. The consonant stopped at will
|
|
|
|
|
* be the base. */
|
2012-07-17 18:23:28 +00:00
|
|
|
|
base = i;
|
|
|
|
|
}
|
2012-08-02 18:21:40 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* A ZWJ after a Halant stops the base search, and requests an explicit
|
|
|
|
|
* half form.
|
|
|
|
|
* A ZWJ before a Halant, requests a subjoined form instead, and hence
|
|
|
|
|
* search continues. This is particularly important for Bengali
|
2012-11-12 22:27:33 +00:00
|
|
|
|
* sequence Ra,H,Ya that should form Ya-Phalaa by subjoining Ya. */
|
2012-08-02 18:21:40 +00:00
|
|
|
|
if (start < i &&
|
|
|
|
|
info[i].indic_category() == OT_ZWJ &&
|
|
|
|
|
info[i - 1].indic_category() == OT_H)
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
} while (i > limit);
|
|
|
|
|
}
|
|
|
|
|
break;
|
2012-07-17 18:23:28 +00:00
|
|
|
|
|
2013-10-17 14:49:06 +00:00
|
|
|
|
case BASE_POS_LAST_SINHALA:
|
2012-08-02 18:21:40 +00:00
|
|
|
|
{
|
2013-10-17 15:04:47 +00:00
|
|
|
|
/* Sinhala base positioning is slightly different from main Indic, in that:
|
2014-04-25 18:48:10 +00:00
|
|
|
|
* 1. Its ZWJ behavior is different,
|
2013-10-17 15:04:47 +00:00
|
|
|
|
* 2. We don't need to look into the font for consonant positions.
|
|
|
|
|
*/
|
2012-07-17 18:23:28 +00:00
|
|
|
|
|
2012-08-02 18:21:40 +00:00
|
|
|
|
if (!has_reph)
|
|
|
|
|
base = limit;
|
2012-07-24 03:51:29 +00:00
|
|
|
|
|
2012-08-02 18:21:40 +00:00
|
|
|
|
/* Find the last base consonant that is not blocked by ZWJ. If there is
|
|
|
|
|
* a ZWJ right before a base consonant, that would request a subjoined form. */
|
|
|
|
|
for (unsigned int i = limit; i < end; i++)
|
2013-10-17 15:04:47 +00:00
|
|
|
|
if (is_consonant (info[i]))
|
2012-08-02 18:21:40 +00:00
|
|
|
|
{
|
|
|
|
|
if (limit < i && info[i - 1].indic_category() == OT_ZWJ)
|
|
|
|
|
break;
|
|
|
|
|
else
|
|
|
|
|
base = i;
|
|
|
|
|
}
|
2012-07-24 03:51:29 +00:00
|
|
|
|
|
2012-08-02 18:21:40 +00:00
|
|
|
|
/* Mark all subsequent consonants as below. */
|
|
|
|
|
for (unsigned int i = base + 1; i < end; i++)
|
2013-10-17 15:04:47 +00:00
|
|
|
|
if (is_consonant (info[i]))
|
2012-08-02 18:21:40 +00:00
|
|
|
|
info[i].indic_position() = POS_BELOW_C;
|
|
|
|
|
}
|
|
|
|
|
break;
|
2012-07-17 18:23:28 +00:00
|
|
|
|
}
|
2011-07-29 20:37:02 +00:00
|
|
|
|
|
2012-05-13 14:48:03 +00:00
|
|
|
|
/* -> If the syllable starts with Ra + Halant (in a script that has Reph)
|
|
|
|
|
* and has more than one consonant, Ra is excluded from candidates for
|
2012-07-24 04:26:43 +00:00
|
|
|
|
* base consonants.
|
|
|
|
|
*
|
|
|
|
|
* Only do this for unforced Reph. (ie. not for Ra,H,ZWJ. */
|
2013-02-11 11:58:27 +00:00
|
|
|
|
if (has_reph && base == start && limit - base <= 2) {
|
2012-05-13 14:48:03 +00:00
|
|
|
|
/* Have no other consonant, so Reph is not formed and Ra becomes base. */
|
|
|
|
|
has_reph = false;
|
|
|
|
|
}
|
2012-05-13 14:46:08 +00:00
|
|
|
|
}
|
2012-07-24 04:26:43 +00:00
|
|
|
|
|
2012-05-10 09:37:42 +00:00
|
|
|
|
|
2011-07-29 20:37:02 +00:00
|
|
|
|
/* 2. Decompose and reorder Matras:
|
|
|
|
|
*
|
2017-10-12 11:48:48 +00:00
|
|
|
|
* Each matra and any syllable modifier sign in the syllable are moved to the
|
|
|
|
|
* appropriate position relative to the consonant(s) in the syllable. The
|
2011-07-29 20:37:02 +00:00
|
|
|
|
* shaping engine decomposes two- or three-part matras into their constituent
|
|
|
|
|
* parts before any repositioning. Matra characters are classified by which
|
|
|
|
|
* consonant in a conjunct they have affinity for and are reordered to the
|
|
|
|
|
* following positions:
|
|
|
|
|
*
|
|
|
|
|
* o Before first half form in the syllable
|
|
|
|
|
* o After subjoined consonants
|
|
|
|
|
* o After post-form consonant
|
|
|
|
|
* o After main consonant (for above marks)
|
|
|
|
|
*
|
|
|
|
|
* IMPLEMENTATION NOTES:
|
|
|
|
|
*
|
|
|
|
|
* The normalize() routine has already decomposed matras for us, so we don't
|
|
|
|
|
* need to worry about that.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* 3. Reorder marks to canonical order:
|
|
|
|
|
*
|
|
|
|
|
* Adjacent nukta and halant or nukta and vedic sign are always repositioned
|
|
|
|
|
* if necessary, so that the nukta is first.
|
|
|
|
|
*
|
|
|
|
|
* IMPLEMENTATION NOTES:
|
|
|
|
|
*
|
|
|
|
|
* We don't need to do this: the normalize() routine already did this for us.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
2011-07-30 18:44:30 +00:00
|
|
|
|
/* Reorder characters */
|
|
|
|
|
|
2012-05-11 14:23:38 +00:00
|
|
|
|
for (unsigned int i = start; i < base; i++)
|
2012-07-20 14:18:23 +00:00
|
|
|
|
info[i].indic_position() = MIN (POS_PRE_C, (indic_position_t) info[i].indic_position());
|
2012-07-17 16:50:13 +00:00
|
|
|
|
|
2012-07-18 19:41:53 +00:00
|
|
|
|
if (base < end)
|
|
|
|
|
info[base].indic_position() = POS_BASE_C;
|
2011-07-30 18:44:30 +00:00
|
|
|
|
|
2018-01-05 15:33:11 +00:00
|
|
|
|
/* Mark final consonants. A final consonant is one appearing after a matra.
|
|
|
|
|
* Happens in Sinhala. */
|
2012-07-17 16:50:13 +00:00
|
|
|
|
for (unsigned int i = base + 1; i < end; i++)
|
|
|
|
|
if (info[i].indic_category() == OT_M) {
|
|
|
|
|
for (unsigned int j = i + 1; j < end; j++)
|
2018-01-05 15:33:11 +00:00
|
|
|
|
if (is_consonant (info[j])) {
|
|
|
|
|
info[j].indic_position() = POS_FINAL_C;
|
|
|
|
|
break;
|
|
|
|
|
}
|
2012-07-17 16:50:13 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-31 00:14:44 +00:00
|
|
|
|
/* Handle beginning Ra */
|
2012-05-13 14:46:08 +00:00
|
|
|
|
if (has_reph)
|
2012-05-10 11:45:52 +00:00
|
|
|
|
info[start].indic_position() = POS_RA_TO_BECOME_REPH;
|
2011-07-31 00:14:44 +00:00
|
|
|
|
|
2011-07-31 01:08:10 +00:00
|
|
|
|
/* For old-style Indic script tags, move the first post-base Halant after
|
2014-07-23 20:48:51 +00:00
|
|
|
|
* last consonant.
|
|
|
|
|
*
|
|
|
|
|
* Reports suggest that in some scripts Uniscribe does this only if there
|
2018-07-31 22:19:32 +00:00
|
|
|
|
* is *not* a Halant after last consonant already. We know that is the
|
|
|
|
|
* case for Kannada, while it reorders unconditionally in other scripts,
|
|
|
|
|
* eg. Malayalam, Bengali, and Devanagari. We don't currently know about
|
2018-07-31 22:27:29 +00:00
|
|
|
|
* other scripts, so we blacklist Kannada.
|
2014-07-23 20:48:51 +00:00
|
|
|
|
*
|
|
|
|
|
* Kannada test case:
|
|
|
|
|
* U+0C9A,U+0CCD,U+0C9A,U+0CCD
|
|
|
|
|
* With some versions of Lohit Kannada.
|
|
|
|
|
* https://bugs.freedesktop.org/show_bug.cgi?id=59118
|
|
|
|
|
*
|
|
|
|
|
* Malayalam test case:
|
|
|
|
|
* U+0D38,U+0D4D,U+0D31,U+0D4D,U+0D31,U+0D4D
|
|
|
|
|
* With lohit-ttf-20121122/Lohit-Malayalam.ttf
|
2018-06-30 07:58:03 +00:00
|
|
|
|
*
|
2018-07-31 22:19:32 +00:00
|
|
|
|
* Bengali test case:
|
2018-06-30 07:58:03 +00:00
|
|
|
|
* U+0998,U+09CD,U+09AF,U+09CD
|
|
|
|
|
* With Windows XP vrinda.ttf
|
|
|
|
|
* https://github.com/harfbuzz/harfbuzz/issues/1073
|
2018-07-31 22:19:32 +00:00
|
|
|
|
*
|
|
|
|
|
* Devanagari test case:
|
|
|
|
|
* U+091F,U+094D,U+0930,U+094D
|
|
|
|
|
* With chandas.ttf
|
|
|
|
|
* https://github.com/harfbuzz/harfbuzz/issues/1071
|
2014-07-23 20:48:51 +00:00
|
|
|
|
*/
|
|
|
|
|
if (indic_plan->is_old_spec)
|
|
|
|
|
{
|
2018-07-31 22:27:29 +00:00
|
|
|
|
bool disallow_double_halants = buffer->props.script == HB_SCRIPT_KANNADA;
|
2012-05-11 14:23:38 +00:00
|
|
|
|
for (unsigned int i = base + 1; i < end; i++)
|
2014-07-23 20:48:51 +00:00
|
|
|
|
if (info[i].indic_category() == OT_H)
|
|
|
|
|
{
|
2011-07-31 01:08:10 +00:00
|
|
|
|
unsigned int j;
|
|
|
|
|
for (j = end - 1; j > i; j--)
|
2014-07-23 20:48:51 +00:00
|
|
|
|
if (is_consonant (info[j]) ||
|
|
|
|
|
(disallow_double_halants && info[j].indic_category() == OT_H))
|
2011-07-31 01:08:10 +00:00
|
|
|
|
break;
|
2013-01-09 00:09:46 +00:00
|
|
|
|
if (info[j].indic_category() != OT_H && j > i) {
|
2011-07-31 01:08:10 +00:00
|
|
|
|
/* Move Halant to after last consonant. */
|
|
|
|
|
hb_glyph_info_t t = info[i];
|
|
|
|
|
memmove (&info[i], &info[i + 1], (j - i) * sizeof (info[0]));
|
|
|
|
|
info[j] = t;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-07-20 19:10:02 +00:00
|
|
|
|
/* Attach misc marks to previous char to move with them. */
|
2012-05-11 14:43:12 +00:00
|
|
|
|
{
|
2012-07-20 19:10:02 +00:00
|
|
|
|
indic_position_t last_pos = POS_START;
|
|
|
|
|
for (unsigned int i = start; i < end; i++)
|
|
|
|
|
{
|
2018-01-05 15:33:11 +00:00
|
|
|
|
if ((FLAG_UNSAFE (info[i].indic_category()) & (JOINER_FLAGS | FLAG (OT_N) | FLAG (OT_RS) | MEDIAL_FLAGS | FLAG (OT_H))))
|
2012-07-20 19:10:02 +00:00
|
|
|
|
{
|
|
|
|
|
info[i].indic_position() = last_pos;
|
2012-11-14 19:37:04 +00:00
|
|
|
|
if (unlikely (info[i].indic_category() == OT_H &&
|
2012-07-20 19:10:02 +00:00
|
|
|
|
info[i].indic_position() == POS_PRE_M))
|
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
* Uniscribe doesn't move the Halant with Left Matra.
|
|
|
|
|
* TEST: U+092B,U+093F,U+094DE
|
2012-11-14 19:37:04 +00:00
|
|
|
|
* We follow. This is important for the Sinhala
|
|
|
|
|
* U+0DDA split matra since it decomposes to U+0DD9,U+0DCA
|
|
|
|
|
* where U+0DD9 is a left matra and U+0DCA is the virama.
|
|
|
|
|
* We don't want to move the virama with the left matra.
|
|
|
|
|
* TEST: U+0D9A,U+0DDA
|
2012-07-20 19:10:02 +00:00
|
|
|
|
*/
|
2012-05-11 14:43:12 +00:00
|
|
|
|
for (unsigned int j = i; j > start; j--)
|
2012-05-11 19:42:27 +00:00
|
|
|
|
if (info[j - 1].indic_position() != POS_PRE_M) {
|
2012-05-11 14:43:12 +00:00
|
|
|
|
info[i].indic_position() = info[j - 1].indic_position();
|
|
|
|
|
break;
|
|
|
|
|
}
|
2012-07-20 19:10:02 +00:00
|
|
|
|
}
|
|
|
|
|
} else if (info[i].indic_position() != POS_SMVD) {
|
|
|
|
|
last_pos = (indic_position_t) info[i].indic_position();
|
2012-05-11 14:43:12 +00:00
|
|
|
|
}
|
2012-07-20 19:10:02 +00:00
|
|
|
|
}
|
2012-05-11 14:43:12 +00:00
|
|
|
|
}
|
2013-10-18 16:07:11 +00:00
|
|
|
|
/* For post-base consonants let them own anything before them
|
|
|
|
|
* since the last consonant or matra. */
|
2012-07-17 15:16:19 +00:00
|
|
|
|
{
|
2013-10-18 16:07:11 +00:00
|
|
|
|
unsigned int last = base;
|
2012-07-17 15:16:19 +00:00
|
|
|
|
for (unsigned int i = base + 1; i < end; i++)
|
2013-10-18 16:07:11 +00:00
|
|
|
|
if (is_consonant (info[i]))
|
|
|
|
|
{
|
|
|
|
|
for (unsigned int j = last + 1; j < i; j++)
|
|
|
|
|
if (info[j].indic_position() < POS_SMVD)
|
2012-07-20 19:10:02 +00:00
|
|
|
|
info[j].indic_position() = info[i].indic_position();
|
2013-10-18 16:07:11 +00:00
|
|
|
|
last = i;
|
|
|
|
|
} else if (info[i].indic_category() == OT_M)
|
|
|
|
|
last = i;
|
2012-07-17 15:16:19 +00:00
|
|
|
|
}
|
2011-07-30 18:44:30 +00:00
|
|
|
|
|
2013-10-16 10:32:12 +00:00
|
|
|
|
|
2012-05-10 09:31:20 +00:00
|
|
|
|
{
|
2013-10-16 10:32:12 +00:00
|
|
|
|
/* Use syllable() for sort accounting temporarily. */
|
|
|
|
|
unsigned int syllable = info[start].syllable();
|
|
|
|
|
for (unsigned int i = start; i < end; i++)
|
|
|
|
|
info[i].syllable() = i - start;
|
|
|
|
|
|
2012-05-10 09:31:20 +00:00
|
|
|
|
/* Sit tight, rock 'n roll! */
|
2015-09-01 14:07:52 +00:00
|
|
|
|
hb_stable_sort (info + start, end - start, compare_indic_order);
|
2012-05-10 09:31:20 +00:00
|
|
|
|
/* Find base again */
|
|
|
|
|
base = end;
|
2012-05-11 14:23:38 +00:00
|
|
|
|
for (unsigned int i = start; i < end; i++)
|
2013-10-16 10:32:12 +00:00
|
|
|
|
if (info[i].indic_position() == POS_BASE_C)
|
|
|
|
|
{
|
|
|
|
|
base = i;
|
2012-05-10 09:31:20 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
2013-10-16 10:32:12 +00:00
|
|
|
|
/* Things are out-of-control for post base positions, they may shuffle
|
|
|
|
|
* around like crazy. In old-spec mode, we move halants around, so in
|
|
|
|
|
* that case merge all clusters after base. Otherwise, check the sort
|
|
|
|
|
* order and merge as needed.
|
2015-09-01 15:26:35 +00:00
|
|
|
|
* For pre-base stuff, we handle cluster issues in final reordering.
|
|
|
|
|
*
|
|
|
|
|
* We could use buffer->sort() for this, if there was no special
|
|
|
|
|
* reordering of pre-base stuff happening later...
|
|
|
|
|
*/
|
2013-10-16 10:32:12 +00:00
|
|
|
|
if (indic_plan->is_old_spec || end - base > 127)
|
|
|
|
|
buffer->merge_clusters (base, end);
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* Note! syllable() is a one-byte field. */
|
|
|
|
|
for (unsigned int i = base; i < end; i++)
|
|
|
|
|
if (info[i].syllable() != 255)
|
|
|
|
|
{
|
|
|
|
|
unsigned int max = i;
|
|
|
|
|
unsigned int j = start + info[i].syllable();
|
|
|
|
|
while (j != i)
|
|
|
|
|
{
|
|
|
|
|
max = MAX (max, j);
|
|
|
|
|
unsigned int next = start + info[j].syllable();
|
|
|
|
|
info[j].syllable() = 255; /* So we don't process j later again. */
|
|
|
|
|
j = next;
|
|
|
|
|
}
|
|
|
|
|
if (i != max)
|
|
|
|
|
buffer->merge_clusters (i, max + 1);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Put syllable back in. */
|
|
|
|
|
for (unsigned int i = start; i < end; i++)
|
|
|
|
|
info[i].syllable() = syllable;
|
2012-05-10 09:31:20 +00:00
|
|
|
|
}
|
2011-07-30 18:44:30 +00:00
|
|
|
|
|
2011-07-29 20:37:02 +00:00
|
|
|
|
/* Setup masks now */
|
|
|
|
|
|
2011-07-31 20:00:35 +00:00
|
|
|
|
{
|
|
|
|
|
hb_mask_t mask;
|
|
|
|
|
|
2012-05-10 11:45:52 +00:00
|
|
|
|
/* Reph */
|
2012-05-11 13:34:13 +00:00
|
|
|
|
for (unsigned int i = start; i < end && info[i].indic_position() == POS_RA_TO_BECOME_REPH; i++)
|
2012-08-02 16:21:44 +00:00
|
|
|
|
info[i].mask |= indic_plan->mask_array[RPHF];
|
2012-05-10 11:45:52 +00:00
|
|
|
|
|
2011-07-31 20:00:35 +00:00
|
|
|
|
/* Pre-base */
|
2012-08-02 16:21:44 +00:00
|
|
|
|
mask = indic_plan->mask_array[HALF];
|
2013-10-17 10:20:24 +00:00
|
|
|
|
if (!indic_plan->is_old_spec &&
|
|
|
|
|
indic_plan->config->blwf_mode == BLWF_MODE_PRE_AND_POST)
|
2013-10-15 10:15:49 +00:00
|
|
|
|
mask |= indic_plan->mask_array[BLWF];
|
2012-05-11 14:23:38 +00:00
|
|
|
|
for (unsigned int i = start; i < base; i++)
|
2011-07-31 20:00:35 +00:00
|
|
|
|
info[i].mask |= mask;
|
|
|
|
|
/* Base */
|
2012-07-20 14:47:46 +00:00
|
|
|
|
mask = 0;
|
2012-07-18 19:41:53 +00:00
|
|
|
|
if (base < end)
|
|
|
|
|
info[base].mask |= mask;
|
2011-07-31 20:00:35 +00:00
|
|
|
|
/* Post-base */
|
2012-08-02 16:21:44 +00:00
|
|
|
|
mask = indic_plan->mask_array[BLWF] | indic_plan->mask_array[ABVF] | indic_plan->mask_array[PSTF];
|
2012-05-11 14:23:38 +00:00
|
|
|
|
for (unsigned int i = base + 1; i < end; i++)
|
2011-07-31 20:00:35 +00:00
|
|
|
|
info[i].mask |= mask;
|
|
|
|
|
}
|
2011-07-31 17:46:44 +00:00
|
|
|
|
|
2013-02-12 23:17:39 +00:00
|
|
|
|
if (indic_plan->is_old_spec &&
|
|
|
|
|
buffer->props.script == HB_SCRIPT_DEVANAGARI)
|
|
|
|
|
{
|
|
|
|
|
/* Old-spec eye-lash Ra needs special handling. From the
|
|
|
|
|
* spec:
|
|
|
|
|
*
|
|
|
|
|
* "The feature 'below-base form' is applied to consonants
|
|
|
|
|
* having below-base forms and following the base consonant.
|
|
|
|
|
* The exception is vattu, which may appear below half forms
|
|
|
|
|
* as well as below the base glyph. The feature 'below-base
|
|
|
|
|
* form' will be applied to all such occurrences of Ra as well."
|
|
|
|
|
*
|
|
|
|
|
* Test case: U+0924,U+094D,U+0930,U+094d,U+0915
|
|
|
|
|
* with Sanskrit 2003 font.
|
|
|
|
|
*
|
|
|
|
|
* However, note that Ra,Halant,ZWJ is the correct way to
|
|
|
|
|
* request eyelash form of Ra, so we wouldbn't inhibit it
|
|
|
|
|
* in that sequence.
|
|
|
|
|
*
|
|
|
|
|
* Test case: U+0924,U+094D,U+0930,U+094d,U+200D,U+0915
|
|
|
|
|
*/
|
|
|
|
|
for (unsigned int i = start; i + 1 < base; i++)
|
|
|
|
|
if (info[i ].indic_category() == OT_Ra &&
|
|
|
|
|
info[i+1].indic_category() == OT_H &&
|
|
|
|
|
(i + 2 == base ||
|
|
|
|
|
info[i+2].indic_category() != OT_ZWJ))
|
|
|
|
|
{
|
|
|
|
|
info[i ].mask |= indic_plan->mask_array[BLWF];
|
|
|
|
|
info[i+1].mask |= indic_plan->mask_array[BLWF];
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-05-06 15:05:07 +00:00
|
|
|
|
unsigned int pref_len = 2;
|
2013-10-17 17:07:53 +00:00
|
|
|
|
if (indic_plan->mask_array[PREF] && base + pref_len < end)
|
2012-07-16 19:20:15 +00:00
|
|
|
|
{
|
2017-12-05 17:43:09 +00:00
|
|
|
|
/* Find a Halant,Ra sequence and mark it for pre-base-reordering processing. */
|
2013-10-17 17:07:53 +00:00
|
|
|
|
for (unsigned int i = base + 1; i + pref_len - 1 < end; i++) {
|
|
|
|
|
hb_codepoint_t glyphs[2];
|
|
|
|
|
for (unsigned int j = 0; j < pref_len; j++)
|
|
|
|
|
glyphs[j] = info[i + j].codepoint;
|
|
|
|
|
if (indic_plan->pref.would_substitute (glyphs, pref_len, face))
|
2012-07-16 21:04:46 +00:00
|
|
|
|
{
|
2013-10-17 17:07:53 +00:00
|
|
|
|
for (unsigned int j = 0; j < pref_len; j++)
|
|
|
|
|
info[i++].mask |= indic_plan->mask_array[PREF];
|
2012-07-16 21:04:46 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
2012-11-12 22:09:40 +00:00
|
|
|
|
}
|
2012-07-16 19:20:15 +00:00
|
|
|
|
}
|
|
|
|
|
|
2011-07-31 17:46:44 +00:00
|
|
|
|
/* Apply ZWJ/ZWNJ effects */
|
2012-05-11 14:23:38 +00:00
|
|
|
|
for (unsigned int i = start + 1; i < end; i++)
|
2011-07-31 17:46:44 +00:00
|
|
|
|
if (is_joiner (info[i])) {
|
|
|
|
|
bool non_joiner = info[i].indic_category() == OT_ZWNJ;
|
2011-07-31 19:57:00 +00:00
|
|
|
|
unsigned int j = i;
|
2011-07-31 17:46:44 +00:00
|
|
|
|
|
|
|
|
|
do {
|
|
|
|
|
j--;
|
2011-07-31 19:57:00 +00:00
|
|
|
|
|
[Indic-like] Disable automatic joiner handling for basic shaping features
Not for Arabic, but for Indic-like scripts. ZWJ/ZWNJ have special
meanings in those scripts, so let font lookups take full control.
This undoes the regression caused by automatic-joiners handling
introduced two commits ago.
We only disable automatic joiner handling for the "basic shaping
features" of Indic, Myanmar, and SEAsian shapers. The "presentation
forms" and other features are still applied with automatic-joiner
handling.
This change also changes the test suite failure statistics, such that
a few scripts show more "failures". The most affected is Kannada.
However, upon inspection, we believe that in most, if not all, of the
new failures, we are producing results superior to Uniscribe. Hard to
count those!
Here's an example of what is fixed by the recent joiner-handling
changes:
https://bugs.freedesktop.org/show_bug.cgi?id=58714
New numbers, for future reference:
BENGALI: 353892 out of 354188 tests passed. 296 failed (0.0835714%)
DEVANAGARI: 707336 out of 707394 tests passed. 58 failed (0.00819911%)
GUJARATI: 366262 out of 366457 tests passed. 195 failed (0.0532122%)
GURMUKHI: 60706 out of 60747 tests passed. 41 failed (0.067493%)
KANNADA: 950680 out of 951913 tests passed. 1233 failed (0.129529%)
KHMER: 299074 out of 299124 tests passed. 50 failed (0.0167155%)
LAO: 53611 out of 53644 tests passed. 33 failed (0.0615167%)
MALAYALAM: 1047983 out of 1048334 tests passed. 351 failed (0.0334817%)
ORIYA: 42320 out of 42329 tests passed. 9 failed (0.021262%)
SINHALA: 271539 out of 271847 tests passed. 308 failed (0.113299%)
TAMIL: 1091753 out of 1091754 tests passed. 1 failed (9.15957e-05%)
TELUGU: 970555 out of 970573 tests passed. 18 failed (0.00185457%)
TIBETAN: 208469 out of 208469 tests passed. 0 failed (0%)
2013-02-14 15:40:12 +00:00
|
|
|
|
/* ZWJ/ZWNJ should disable CJCT. They do that by simply
|
|
|
|
|
* being there, since we don't skip them for the CJCT
|
[Indic] Futher adjust ZWJ handling in Indic-like shapers
After the Ngapi hackfest work, we were assuming that fonts
won't use presentation features to choose specific forms
(eg. conjuncts). As such, we were using auto-joiner behavior
for such features. It proved to be troublesome as many fonts
used presentation forms ('pres') for example to form conjuncts,
which need to be disabled when a ZWJ is inserted.
Two examples:
U+0D2F,U+200D,U+0D4D,U+0D2F with kartika.ttf
U+0995,U+09CD,U+200D,U+09B7 with vrinda.ttf
What we do now is to never do magic to ZWJ during GSUB's main input
match for Indic-style shapers. Note that backtrack/lookahead are still
matched liberally, as is GPOS. This seems to be an acceptable
compromise.
As to the bug that initially started this work, that one needs to
be fixed differently:
Bug 58714 - Kannada u+0cb0 u+200d u+0ccd u+0c95 u+0cbe does not
provide same results as Windows8
https://bugs.freedesktop.org/show_bug.cgi?id=58714
New numbers:
BENGALI: 353689 out of 354188 tests passed. 499 failed (0.140886%)
DEVANAGARI: 707305 out of 707394 tests passed. 89 failed (0.0125814%)
GUJARATI: 366349 out of 366457 tests passed. 108 failed (0.0294714%)
GURMUKHI: 60706 out of 60747 tests passed. 41 failed (0.067493%)
KANNADA: 951030 out of 951913 tests passed. 883 failed (0.0927606%)
KHMER: 299070 out of 299124 tests passed. 54 failed (0.0180527%)
LAO: 53611 out of 53644 tests passed. 33 failed (0.0615167%)
MALAYALAM: 1048102 out of 1048334 tests passed. 232 failed (0.0221304%)
ORIYA: 42320 out of 42329 tests passed. 9 failed (0.021262%)
SINHALA: 271666 out of 271847 tests passed. 181 failed (0.0665816%)
TAMIL: 1091753 out of 1091754 tests passed. 1 failed (9.15957e-05%)
TELUGU: 970555 out of 970573 tests passed. 18 failed (0.00185457%)
TIBETAN: 208469 out of 208469 tests passed. 0 failed (0%)
2013-03-19 09:53:26 +00:00
|
|
|
|
* feature (ie. F_MANUAL_ZWJ) */
|
2012-07-20 14:47:46 +00:00
|
|
|
|
|
|
|
|
|
/* A ZWNJ disables HALF. */
|
2011-07-31 19:57:00 +00:00
|
|
|
|
if (non_joiner)
|
2012-08-02 16:21:44 +00:00
|
|
|
|
info[j].mask &= ~indic_plan->mask_array[HALF];
|
2011-07-31 19:57:00 +00:00
|
|
|
|
|
2011-07-31 17:46:44 +00:00
|
|
|
|
} while (j > start && !is_consonant (info[j]));
|
|
|
|
|
}
|
2011-07-29 20:37:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
2012-08-02 14:07:58 +00:00
|
|
|
|
initial_reordering_standalone_cluster (const hb_ot_shape_plan_t *plan,
|
2012-11-12 22:02:02 +00:00
|
|
|
|
hb_face_t *face,
|
2012-05-13 14:13:44 +00:00
|
|
|
|
hb_buffer_t *buffer,
|
2012-05-09 15:56:03 +00:00
|
|
|
|
unsigned int start, unsigned int end)
|
2011-07-29 20:37:02 +00:00
|
|
|
|
{
|
2018-09-10 20:51:26 +00:00
|
|
|
|
const indic_shape_plan_t *indic_plan = (const indic_shape_plan_t *) plan->data;
|
|
|
|
|
|
2014-05-27 21:53:37 +00:00
|
|
|
|
/* We treat placeholder/dotted-circle as if they are consonants, so we
|
|
|
|
|
* should just chain. Only if not in compatibility mode that is... */
|
2012-05-11 18:02:14 +00:00
|
|
|
|
|
2018-09-10 20:51:26 +00:00
|
|
|
|
if (indic_plan->uniscribe_bug_compatible)
|
2012-05-11 18:02:14 +00:00
|
|
|
|
{
|
|
|
|
|
/* For dotted-circle, this is what Uniscribe does:
|
|
|
|
|
* If dotted-circle is the last glyph, it just does nothing.
|
|
|
|
|
* Ie. It doesn't form Reph. */
|
|
|
|
|
if (buffer->info[end - 1].indic_category() == OT_DOTTEDCIRCLE)
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2012-11-12 22:02:02 +00:00
|
|
|
|
initial_reordering_consonant_syllable (plan, face, buffer, start, end);
|
2011-07-29 20:37:02 +00:00
|
|
|
|
}
|
|
|
|
|
|
2012-08-31 20:49:34 +00:00
|
|
|
|
static void
|
|
|
|
|
initial_reordering_syllable (const hb_ot_shape_plan_t *plan,
|
2012-11-12 22:02:02 +00:00
|
|
|
|
hb_face_t *face,
|
2012-08-31 20:49:34 +00:00
|
|
|
|
hb_buffer_t *buffer,
|
|
|
|
|
unsigned int start, unsigned int end)
|
|
|
|
|
{
|
|
|
|
|
syllable_type_t syllable_type = (syllable_type_t) (buffer->info[start].syllable() & 0x0F);
|
2015-07-22 11:02:09 +00:00
|
|
|
|
switch (syllable_type)
|
|
|
|
|
{
|
|
|
|
|
case vowel_syllable: /* We made the vowels look like consonants. So let's call the consonant logic! */
|
|
|
|
|
case consonant_syllable:
|
|
|
|
|
initial_reordering_consonant_syllable (plan, face, buffer, start, end);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case broken_cluster: /* We already inserted dotted-circles, so just call the standalone_cluster. */
|
|
|
|
|
case standalone_cluster:
|
|
|
|
|
initial_reordering_standalone_cluster (plan, face, buffer, start, end);
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
case symbol_cluster:
|
|
|
|
|
case non_indic_cluster:
|
|
|
|
|
break;
|
2012-08-31 20:49:34 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2012-09-07 18:55:07 +00:00
|
|
|
|
static inline void
|
2012-12-05 23:46:04 +00:00
|
|
|
|
insert_dotted_circles (const hb_ot_shape_plan_t *plan HB_UNUSED,
|
2012-08-31 22:12:01 +00:00
|
|
|
|
hb_font_t *font,
|
|
|
|
|
hb_buffer_t *buffer)
|
|
|
|
|
{
|
2012-09-07 18:55:07 +00:00
|
|
|
|
/* Note: This loop is extra overhead, but should not be measurable. */
|
|
|
|
|
bool has_broken_syllables = false;
|
|
|
|
|
unsigned int count = buffer->len;
|
2014-07-17 18:22:11 +00:00
|
|
|
|
hb_glyph_info_t *info = buffer->info;
|
2012-09-07 18:55:07 +00:00
|
|
|
|
for (unsigned int i = 0; i < count; i++)
|
2014-07-17 18:22:11 +00:00
|
|
|
|
if ((info[i].syllable() & 0x0F) == broken_cluster)
|
|
|
|
|
{
|
2012-09-07 18:55:07 +00:00
|
|
|
|
has_broken_syllables = true;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
if (likely (!has_broken_syllables))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
|
2012-08-31 22:12:01 +00:00
|
|
|
|
hb_codepoint_t dottedcircle_glyph;
|
2016-02-24 10:05:23 +00:00
|
|
|
|
if (!font->get_nominal_glyph (0x25CCu, &dottedcircle_glyph))
|
2012-08-31 22:12:01 +00:00
|
|
|
|
return;
|
|
|
|
|
|
2012-11-15 18:36:43 +00:00
|
|
|
|
hb_glyph_info_t dottedcircle = {0};
|
2014-07-11 18:54:42 +00:00
|
|
|
|
dottedcircle.codepoint = 0x25CCu;
|
2012-08-31 22:12:01 +00:00
|
|
|
|
set_indic_properties (dottedcircle);
|
|
|
|
|
dottedcircle.codepoint = dottedcircle_glyph;
|
|
|
|
|
|
|
|
|
|
buffer->clear_output ();
|
|
|
|
|
|
|
|
|
|
buffer->idx = 0;
|
|
|
|
|
unsigned int last_syllable = 0;
|
2018-06-01 03:03:00 +00:00
|
|
|
|
while (buffer->idx < buffer->len && buffer->successful)
|
2012-08-31 22:12:01 +00:00
|
|
|
|
{
|
|
|
|
|
unsigned int syllable = buffer->cur().syllable();
|
|
|
|
|
syllable_type_t syllable_type = (syllable_type_t) (syllable & 0x0F);
|
|
|
|
|
if (unlikely (last_syllable != syllable && syllable_type == broken_cluster))
|
|
|
|
|
{
|
2012-12-22 00:41:04 +00:00
|
|
|
|
last_syllable = syllable;
|
|
|
|
|
|
2015-10-21 13:16:49 +00:00
|
|
|
|
hb_glyph_info_t ginfo = dottedcircle;
|
|
|
|
|
ginfo.cluster = buffer->cur().cluster;
|
|
|
|
|
ginfo.mask = buffer->cur().mask;
|
|
|
|
|
ginfo.syllable() = buffer->cur().syllable();
|
2014-07-26 22:44:15 +00:00
|
|
|
|
/* TODO Set glyph_props? */
|
2012-12-22 00:41:04 +00:00
|
|
|
|
|
|
|
|
|
/* Insert dottedcircle after possible Repha. */
|
2018-06-01 03:03:00 +00:00
|
|
|
|
while (buffer->idx < buffer->len && buffer->successful &&
|
2012-12-22 00:41:04 +00:00
|
|
|
|
last_syllable == buffer->cur().syllable() &&
|
|
|
|
|
buffer->cur().indic_category() == OT_Repha)
|
|
|
|
|
buffer->next_glyph ();
|
|
|
|
|
|
2015-10-21 13:16:49 +00:00
|
|
|
|
buffer->output_info (ginfo);
|
2012-08-31 22:12:01 +00:00
|
|
|
|
}
|
2012-12-22 00:41:04 +00:00
|
|
|
|
else
|
|
|
|
|
buffer->next_glyph ();
|
2012-08-31 22:12:01 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
buffer->swap_buffers ();
|
|
|
|
|
}
|
|
|
|
|
|
2011-07-29 20:37:02 +00:00
|
|
|
|
static void
|
2012-08-02 14:07:58 +00:00
|
|
|
|
initial_reordering (const hb_ot_shape_plan_t *plan,
|
2012-08-02 12:42:11 +00:00
|
|
|
|
hb_font_t *font,
|
2012-08-02 13:44:18 +00:00
|
|
|
|
hb_buffer_t *buffer)
|
2011-07-29 20:37:02 +00:00
|
|
|
|
{
|
2012-08-02 16:21:44 +00:00
|
|
|
|
update_consonant_positions (plan, font, buffer);
|
2012-09-07 18:55:07 +00:00
|
|
|
|
insert_dotted_circles (plan, font, buffer);
|
2012-08-31 20:49:34 +00:00
|
|
|
|
|
2015-07-22 11:02:09 +00:00
|
|
|
|
foreach_syllable (buffer, start, end)
|
|
|
|
|
initial_reordering_syllable (plan, font->face, buffer, start, end);
|
2011-06-02 21:43:12 +00:00
|
|
|
|
}
|
|
|
|
|
|
2011-07-29 20:37:02 +00:00
|
|
|
|
static void
|
2012-08-02 16:21:44 +00:00
|
|
|
|
final_reordering_syllable (const hb_ot_shape_plan_t *plan,
|
|
|
|
|
hb_buffer_t *buffer,
|
2012-05-09 15:56:03 +00:00
|
|
|
|
unsigned int start, unsigned int end)
|
2011-07-29 20:37:02 +00:00
|
|
|
|
{
|
2012-08-02 16:21:44 +00:00
|
|
|
|
const indic_shape_plan_t *indic_plan = (const indic_shape_plan_t *) plan->data;
|
2012-05-10 10:53:53 +00:00
|
|
|
|
hb_glyph_info_t *info = buffer->info;
|
|
|
|
|
|
2014-06-06 21:28:38 +00:00
|
|
|
|
|
|
|
|
|
/* This function relies heavily on halant glyphs. Lots of ligation
|
2017-10-12 11:48:48 +00:00
|
|
|
|
* and possibly multiple substitutions happened prior to this
|
2014-06-06 21:28:38 +00:00
|
|
|
|
* phase, and that might have messed up our properties. Recover
|
|
|
|
|
* from a particular case of that where we're fairly sure that a
|
|
|
|
|
* class of OT_H is desired but has been lost. */
|
2018-08-01 04:05:51 +00:00
|
|
|
|
/* We don't call load_virama_glyph(), since we know it's already
|
|
|
|
|
* loaded. */
|
|
|
|
|
hb_codepoint_t virama_glyph = indic_plan->virama_glyph.get_relaxed ();
|
|
|
|
|
if (virama_glyph)
|
2014-06-06 21:28:38 +00:00
|
|
|
|
{
|
|
|
|
|
for (unsigned int i = start; i < end; i++)
|
|
|
|
|
if (info[i].codepoint == virama_glyph &&
|
|
|
|
|
_hb_glyph_info_ligated (&info[i]) &&
|
|
|
|
|
_hb_glyph_info_multiplied (&info[i]))
|
|
|
|
|
{
|
2018-01-05 15:33:11 +00:00
|
|
|
|
/* This will make sure that this glyph passes is_halant() test. */
|
2014-06-06 21:28:38 +00:00
|
|
|
|
info[i].indic_category() = OT_H;
|
|
|
|
|
_hb_glyph_info_clear_ligated_and_multiplied (&info[i]);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2011-07-31 19:18:57 +00:00
|
|
|
|
/* 4. Final reordering:
|
|
|
|
|
*
|
|
|
|
|
* After the localized forms and basic shaping forms GSUB features have been
|
|
|
|
|
* applied (see below), the shaping engine performs some final glyph
|
|
|
|
|
* reordering before applying all the remaining font features to the entire
|
2017-10-12 11:48:48 +00:00
|
|
|
|
* syllable.
|
2012-05-10 10:53:53 +00:00
|
|
|
|
*/
|
|
|
|
|
|
2014-06-06 21:55:02 +00:00
|
|
|
|
bool try_pref = !!indic_plan->mask_array[PREF];
|
|
|
|
|
|
2012-05-10 10:53:53 +00:00
|
|
|
|
/* Find base again */
|
2012-07-20 19:47:24 +00:00
|
|
|
|
unsigned int base;
|
|
|
|
|
for (base = start; base < end; base++)
|
2014-06-06 21:55:02 +00:00
|
|
|
|
if (info[base].indic_position() >= POS_BASE_C)
|
|
|
|
|
{
|
2016-05-06 15:05:07 +00:00
|
|
|
|
if (try_pref && base + 1 < end)
|
2014-06-06 21:55:02 +00:00
|
|
|
|
{
|
|
|
|
|
for (unsigned int i = base + 1; i < end; i++)
|
|
|
|
|
if ((info[i].mask & indic_plan->mask_array[PREF]) != 0)
|
|
|
|
|
{
|
|
|
|
|
if (!(_hb_glyph_info_substituted (&info[i]) &&
|
|
|
|
|
_hb_glyph_info_ligated_and_didnt_multiply (&info[i])))
|
|
|
|
|
{
|
|
|
|
|
/* Ok, this was a 'pref' candidate but didn't form any.
|
|
|
|
|
* Base is around here... */
|
|
|
|
|
base = i;
|
2018-01-05 15:33:11 +00:00
|
|
|
|
while (base < end && is_halant (info[base]))
|
2014-06-06 21:55:02 +00:00
|
|
|
|
base++;
|
|
|
|
|
info[base].indic_position() = POS_BASE_C;
|
|
|
|
|
|
|
|
|
|
try_pref = false;
|
|
|
|
|
}
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
2015-12-18 13:47:16 +00:00
|
|
|
|
/* For Malayalam, skip over unformed below- (but NOT post-) forms. */
|
|
|
|
|
if (buffer->props.script == HB_SCRIPT_MALAYALAM)
|
|
|
|
|
{
|
|
|
|
|
for (unsigned int i = base + 1; i < end; i++)
|
|
|
|
|
{
|
|
|
|
|
while (i < end && is_joiner (info[i]))
|
|
|
|
|
i++;
|
2018-01-05 15:33:11 +00:00
|
|
|
|
if (i == end || !is_halant (info[i]))
|
2015-12-18 13:47:16 +00:00
|
|
|
|
break;
|
|
|
|
|
i++; /* Skip halant. */
|
|
|
|
|
while (i < end && is_joiner (info[i]))
|
|
|
|
|
i++;
|
|
|
|
|
if (i < end && is_consonant (info[i]) && info[i].indic_position() == POS_BELOW_C)
|
|
|
|
|
{
|
|
|
|
|
base = i;
|
|
|
|
|
info[base].indic_position() = POS_BASE_C;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2014-06-06 21:55:02 +00:00
|
|
|
|
|
2012-07-20 19:47:24 +00:00
|
|
|
|
if (start < base && info[base].indic_position() > POS_BASE_C)
|
|
|
|
|
base--;
|
|
|
|
|
break;
|
|
|
|
|
}
|
2013-02-13 14:26:55 +00:00
|
|
|
|
if (base == end && start < base &&
|
2014-06-06 21:19:35 +00:00
|
|
|
|
is_one_of (info[base - 1], FLAG (OT_ZWJ)))
|
2013-02-13 14:26:55 +00:00
|
|
|
|
base--;
|
2014-07-16 16:30:39 +00:00
|
|
|
|
if (base < end)
|
|
|
|
|
while (start < base &&
|
2018-01-05 15:33:11 +00:00
|
|
|
|
is_one_of (info[base], (FLAG (OT_N) | FLAG (OT_H))))
|
2014-07-16 16:30:39 +00:00
|
|
|
|
base--;
|
2012-05-10 10:53:53 +00:00
|
|
|
|
|
2012-05-10 11:09:08 +00:00
|
|
|
|
|
2012-05-10 10:53:53 +00:00
|
|
|
|
/* o Reorder matras:
|
2011-07-31 19:18:57 +00:00
|
|
|
|
*
|
|
|
|
|
* If a pre-base matra character had been reordered before applying basic
|
|
|
|
|
* features, the glyph can be moved closer to the main consonant based on
|
|
|
|
|
* whether half-forms had been formed. Actual position for the matra is
|
|
|
|
|
* defined as “after last standalone halant glyph, after initial matra
|
|
|
|
|
* position and before the main consonant”. If ZWJ or ZWNJ follow this
|
|
|
|
|
* halant, position is moved after it.
|
[indic] Adjust left-matra repositioning and Halant,ZWJ sequence
From the new code (first paragraph is from the OT Devanagari spec.):
/* o Reorder matras:
*
* If a pre-base matra character had been reordered before applying basic
* features, the glyph can be moved closer to the main consonant based on
* whether half-forms had been formed. Actual position for the matra is
* defined as “after last standalone halant glyph, after initial matra
* position and before the main consonant”. If ZWJ or ZWNJ follow this
* halant, position is moved after it.
*
* IMPLEMENTATION NOTES:
*
* It looks like the last sentence is wrong. Testing, with Windows 7 Uniscribe
* and Devanagari shows that the behavior is best described as:
*
* "If ZWJ follows this halant, matra is NOT repositioned after this halant.
* If ZWNJ follows this halant, position is moved after it."
*
* Test case, with Adobe Devanagari or Nirmala UI:
*
* U+091F,U+094D,U+200C,U+092F,U+093F
* (Matra moves to the middle, after ZWNJ.)
*
* U+091F,U+094D,U+200D,U+092F,U+093F
* (Matra does NOT move, stays to the left.)
Fixes https://github.com/harfbuzz/harfbuzz/issues/1070
Test case added with Adobe Devanagari.
2018-07-03 09:59:25 +00:00
|
|
|
|
*
|
|
|
|
|
* IMPLEMENTATION NOTES:
|
|
|
|
|
*
|
|
|
|
|
* It looks like the last sentence is wrong. Testing, with Windows 7 Uniscribe
|
|
|
|
|
* and Devanagari shows that the behavior is best described as:
|
|
|
|
|
*
|
|
|
|
|
* "If ZWJ follows this halant, matra is NOT repositioned after this halant.
|
|
|
|
|
* If ZWNJ follows this halant, position is moved after it."
|
|
|
|
|
*
|
|
|
|
|
* Test case, with Adobe Devanagari or Nirmala UI:
|
|
|
|
|
*
|
|
|
|
|
* U+091F,U+094D,U+200C,U+092F,U+093F
|
|
|
|
|
* (Matra moves to the middle, after ZWNJ.)
|
|
|
|
|
*
|
|
|
|
|
* U+091F,U+094D,U+200D,U+092F,U+093F
|
|
|
|
|
* (Matra does NOT move, stays to the left.)
|
|
|
|
|
*
|
|
|
|
|
* https://github.com/harfbuzz/harfbuzz/issues/1070
|
2012-05-10 10:53:53 +00:00
|
|
|
|
*/
|
|
|
|
|
|
2012-07-24 07:36:47 +00:00
|
|
|
|
if (start + 1 < end && start < base) /* Otherwise there can't be any pre-base matra characters. */
|
2012-05-11 19:36:32 +00:00
|
|
|
|
{
|
2012-07-24 07:36:47 +00:00
|
|
|
|
/* If we lost track of base, alas, position before last thingy. */
|
|
|
|
|
unsigned int new_pos = base == end ? base - 2 : base - 1;
|
|
|
|
|
|
2012-09-05 19:11:14 +00:00
|
|
|
|
/* Malayalam / Tamil do not have "half" forms or explicit virama forms.
|
|
|
|
|
* The glyphs formed by 'half' are Chillus or ligated explicit viramas.
|
|
|
|
|
* We want to position matra after them.
|
2012-07-24 07:36:47 +00:00
|
|
|
|
*/
|
2012-09-05 19:11:14 +00:00
|
|
|
|
if (buffer->props.script != HB_SCRIPT_MALAYALAM && buffer->props.script != HB_SCRIPT_TAMIL)
|
2012-07-23 04:11:26 +00:00
|
|
|
|
{
|
[indic] Adjust left-matra repositioning and Halant,ZWJ sequence
From the new code (first paragraph is from the OT Devanagari spec.):
/* o Reorder matras:
*
* If a pre-base matra character had been reordered before applying basic
* features, the glyph can be moved closer to the main consonant based on
* whether half-forms had been formed. Actual position for the matra is
* defined as “after last standalone halant glyph, after initial matra
* position and before the main consonant”. If ZWJ or ZWNJ follow this
* halant, position is moved after it.
*
* IMPLEMENTATION NOTES:
*
* It looks like the last sentence is wrong. Testing, with Windows 7 Uniscribe
* and Devanagari shows that the behavior is best described as:
*
* "If ZWJ follows this halant, matra is NOT repositioned after this halant.
* If ZWNJ follows this halant, position is moved after it."
*
* Test case, with Adobe Devanagari or Nirmala UI:
*
* U+091F,U+094D,U+200C,U+092F,U+093F
* (Matra moves to the middle, after ZWNJ.)
*
* U+091F,U+094D,U+200D,U+092F,U+093F
* (Matra does NOT move, stays to the left.)
Fixes https://github.com/harfbuzz/harfbuzz/issues/1070
Test case added with Adobe Devanagari.
2018-07-03 09:59:25 +00:00
|
|
|
|
search:
|
2012-07-24 07:36:47 +00:00
|
|
|
|
while (new_pos > start &&
|
2018-01-05 15:33:11 +00:00
|
|
|
|
!(is_one_of (info[new_pos], (FLAG (OT_M) | FLAG (OT_H)))))
|
2012-07-24 07:36:47 +00:00
|
|
|
|
new_pos--;
|
|
|
|
|
|
|
|
|
|
/* If we found no Halant we are done.
|
|
|
|
|
* Otherwise only proceed if the Halant does
|
|
|
|
|
* not belong to the Matra itself! */
|
2018-01-05 15:33:11 +00:00
|
|
|
|
if (is_halant (info[new_pos]) &&
|
2012-07-24 07:36:47 +00:00
|
|
|
|
info[new_pos].indic_position() != POS_PRE_M)
|
|
|
|
|
{
|
[indic] Adjust left-matra repositioning and Halant,ZWJ sequence
From the new code (first paragraph is from the OT Devanagari spec.):
/* o Reorder matras:
*
* If a pre-base matra character had been reordered before applying basic
* features, the glyph can be moved closer to the main consonant based on
* whether half-forms had been formed. Actual position for the matra is
* defined as “after last standalone halant glyph, after initial matra
* position and before the main consonant”. If ZWJ or ZWNJ follow this
* halant, position is moved after it.
*
* IMPLEMENTATION NOTES:
*
* It looks like the last sentence is wrong. Testing, with Windows 7 Uniscribe
* and Devanagari shows that the behavior is best described as:
*
* "If ZWJ follows this halant, matra is NOT repositioned after this halant.
* If ZWNJ follows this halant, position is moved after it."
*
* Test case, with Adobe Devanagari or Nirmala UI:
*
* U+091F,U+094D,U+200C,U+092F,U+093F
* (Matra moves to the middle, after ZWNJ.)
*
* U+091F,U+094D,U+200D,U+092F,U+093F
* (Matra does NOT move, stays to the left.)
Fixes https://github.com/harfbuzz/harfbuzz/issues/1070
Test case added with Adobe Devanagari.
2018-07-03 09:59:25 +00:00
|
|
|
|
#if 0 // See comment above
|
2012-07-24 07:36:47 +00:00
|
|
|
|
/* -> If ZWJ or ZWNJ follow this halant, position is moved after it. */
|
|
|
|
|
if (new_pos + 1 < end && is_joiner (info[new_pos + 1]))
|
|
|
|
|
new_pos++;
|
[indic] Adjust left-matra repositioning and Halant,ZWJ sequence
From the new code (first paragraph is from the OT Devanagari spec.):
/* o Reorder matras:
*
* If a pre-base matra character had been reordered before applying basic
* features, the glyph can be moved closer to the main consonant based on
* whether half-forms had been formed. Actual position for the matra is
* defined as “after last standalone halant glyph, after initial matra
* position and before the main consonant”. If ZWJ or ZWNJ follow this
* halant, position is moved after it.
*
* IMPLEMENTATION NOTES:
*
* It looks like the last sentence is wrong. Testing, with Windows 7 Uniscribe
* and Devanagari shows that the behavior is best described as:
*
* "If ZWJ follows this halant, matra is NOT repositioned after this halant.
* If ZWNJ follows this halant, position is moved after it."
*
* Test case, with Adobe Devanagari or Nirmala UI:
*
* U+091F,U+094D,U+200C,U+092F,U+093F
* (Matra moves to the middle, after ZWNJ.)
*
* U+091F,U+094D,U+200D,U+092F,U+093F
* (Matra does NOT move, stays to the left.)
Fixes https://github.com/harfbuzz/harfbuzz/issues/1070
Test case added with Adobe Devanagari.
2018-07-03 09:59:25 +00:00
|
|
|
|
#endif
|
|
|
|
|
if (new_pos + 1 < end)
|
|
|
|
|
{
|
|
|
|
|
/* -> If ZWJ follows this halant, matra is NOT repositioned after this halant. */
|
|
|
|
|
if (info[new_pos + 1].indic_category() == OT_ZWJ)
|
|
|
|
|
{
|
|
|
|
|
/* Keep searching. */
|
|
|
|
|
if (new_pos > start)
|
|
|
|
|
{
|
|
|
|
|
new_pos--;
|
|
|
|
|
goto search;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
/* -> If ZWNJ follows this halant, position is moved after it. */
|
|
|
|
|
if (info[new_pos + 1].indic_category() == OT_ZWNJ)
|
|
|
|
|
new_pos++;
|
|
|
|
|
}
|
2012-07-24 07:36:47 +00:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
new_pos = start; /* No move. */
|
|
|
|
|
}
|
2012-05-11 19:36:32 +00:00
|
|
|
|
|
2012-09-05 19:11:14 +00:00
|
|
|
|
if (start < new_pos && info[new_pos].indic_position () != POS_PRE_M)
|
2012-07-24 07:36:47 +00:00
|
|
|
|
{
|
2012-05-11 19:36:32 +00:00
|
|
|
|
/* Now go see if there's actually any matras... */
|
2012-07-16 19:26:56 +00:00
|
|
|
|
for (unsigned int i = new_pos; i > start; i--)
|
2012-05-11 19:42:27 +00:00
|
|
|
|
if (info[i - 1].indic_position () == POS_PRE_M)
|
2012-05-11 19:36:32 +00:00
|
|
|
|
{
|
2012-07-16 19:40:33 +00:00
|
|
|
|
unsigned int old_pos = i - 1;
|
2015-09-01 15:26:35 +00:00
|
|
|
|
if (old_pos < base && base <= new_pos) /* Shouldn't actually happen. */
|
|
|
|
|
base--;
|
|
|
|
|
|
2012-07-16 19:40:33 +00:00
|
|
|
|
hb_glyph_info_t tmp = info[old_pos];
|
|
|
|
|
memmove (&info[old_pos], &info[old_pos + 1], (new_pos - old_pos) * sizeof (info[0]));
|
|
|
|
|
info[new_pos] = tmp;
|
2015-09-01 15:26:35 +00:00
|
|
|
|
|
|
|
|
|
/* Note: this merge_clusters() is intentionally *after* the reordering.
|
|
|
|
|
* Indic matra reordering is special and tricky... */
|
2013-10-16 09:34:07 +00:00
|
|
|
|
buffer->merge_clusters (new_pos, MIN (end, base + 1));
|
2015-09-01 15:26:35 +00:00
|
|
|
|
|
2012-07-16 19:26:56 +00:00
|
|
|
|
new_pos--;
|
2012-05-11 19:36:32 +00:00
|
|
|
|
}
|
2012-07-23 03:55:19 +00:00
|
|
|
|
} else {
|
2012-07-23 04:11:26 +00:00
|
|
|
|
for (unsigned int i = start; i < base; i++)
|
2012-07-23 03:55:19 +00:00
|
|
|
|
if (info[i].indic_position () == POS_PRE_M) {
|
2012-07-23 12:22:55 +00:00
|
|
|
|
buffer->merge_clusters (i, MIN (end, base + 1));
|
2012-07-23 03:55:19 +00:00
|
|
|
|
break;
|
|
|
|
|
}
|
2012-05-11 19:36:32 +00:00
|
|
|
|
}
|
2012-05-10 10:53:53 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* o Reorder reph:
|
2011-07-31 19:18:57 +00:00
|
|
|
|
*
|
|
|
|
|
* Reph’s original position is always at the beginning of the syllable,
|
|
|
|
|
* (i.e. it is not reordered at the character reordering stage). However,
|
|
|
|
|
* it will be reordered according to the basic-forms shaping results.
|
|
|
|
|
* Possible positions for reph, depending on the script, are; after main,
|
|
|
|
|
* before post-base consonant forms, and after post-base consonant forms.
|
2012-05-10 11:45:52 +00:00
|
|
|
|
*/
|
|
|
|
|
|
2013-10-15 16:08:05 +00:00
|
|
|
|
/* Two cases:
|
|
|
|
|
*
|
|
|
|
|
* - If repha is encoded as a sequence of characters (Ra,H or Ra,H,ZWJ), then
|
|
|
|
|
* we should only move it if the sequence ligated to the repha form.
|
|
|
|
|
*
|
|
|
|
|
* - If repha is encoded separately and in the logical position, we should only
|
|
|
|
|
* move it if it did NOT ligate. If it ligated, it's probably the font trying
|
|
|
|
|
* to make it work without the reordering.
|
|
|
|
|
*/
|
2013-10-15 16:13:07 +00:00
|
|
|
|
if (start + 1 < end &&
|
|
|
|
|
info[start].indic_position() == POS_RA_TO_BECOME_REPH &&
|
2013-10-17 22:02:43 +00:00
|
|
|
|
((info[start].indic_category() == OT_Repha) ^
|
[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 20:57:42 +00:00
|
|
|
|
_hb_glyph_info_ligated_and_didnt_multiply (&info[start])))
|
2012-05-10 11:45:52 +00:00
|
|
|
|
{
|
2012-08-02 18:21:40 +00:00
|
|
|
|
unsigned int new_reph_pos;
|
|
|
|
|
reph_position_t reph_pos = indic_plan->config->reph_pos;
|
|
|
|
|
|
2012-05-10 11:45:52 +00:00
|
|
|
|
/* 1. If reph should be positioned after post-base consonant forms,
|
|
|
|
|
* proceed to step 5.
|
2012-05-10 19:44:50 +00:00
|
|
|
|
*/
|
2012-08-02 18:21:40 +00:00
|
|
|
|
if (reph_pos == REPH_POS_AFTER_POST)
|
2012-05-10 19:44:50 +00:00
|
|
|
|
{
|
2012-05-11 19:36:32 +00:00
|
|
|
|
goto reph_step_5;
|
2012-05-10 19:44:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* 2. If the reph repositioning class is not after post-base: target
|
2012-05-10 11:45:52 +00:00
|
|
|
|
* position is after the first explicit halant glyph between the
|
|
|
|
|
* first post-reph consonant and last main consonant. If ZWJ or ZWNJ
|
|
|
|
|
* are following this halant, position is moved after it. If such
|
|
|
|
|
* position is found, this is the target position. Otherwise,
|
|
|
|
|
* proceed to the next step.
|
|
|
|
|
*
|
|
|
|
|
* Note: in old-implementation fonts, where classifications were
|
|
|
|
|
* fixed in shaping engine, there was no case where reph position
|
|
|
|
|
* will be found on this step.
|
2012-05-10 19:44:50 +00:00
|
|
|
|
*/
|
|
|
|
|
{
|
|
|
|
|
new_reph_pos = start + 1;
|
2018-01-05 15:33:11 +00:00
|
|
|
|
while (new_reph_pos < base && !is_halant (info[new_reph_pos]))
|
2012-05-10 19:44:50 +00:00
|
|
|
|
new_reph_pos++;
|
|
|
|
|
|
2018-01-05 15:33:11 +00:00
|
|
|
|
if (new_reph_pos < base && is_halant (info[new_reph_pos]))
|
2013-02-13 14:38:40 +00:00
|
|
|
|
{
|
2012-05-10 19:44:50 +00:00
|
|
|
|
/* ->If ZWJ or ZWNJ are following this halant, position is moved after it. */
|
|
|
|
|
if (new_reph_pos + 1 < base && is_joiner (info[new_reph_pos + 1]))
|
|
|
|
|
new_reph_pos++;
|
|
|
|
|
goto reph_move;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* 3. If reph should be repositioned after the main consonant: find the
|
2012-05-10 11:45:52 +00:00
|
|
|
|
* first consonant not ligated with main, or find the first
|
2017-12-05 17:43:09 +00:00
|
|
|
|
* consonant that is not a potential pre-base-reordering Ra.
|
2012-05-10 19:44:50 +00:00
|
|
|
|
*/
|
2012-08-02 18:21:40 +00:00
|
|
|
|
if (reph_pos == REPH_POS_AFTER_MAIN)
|
2012-05-10 19:44:50 +00:00
|
|
|
|
{
|
2012-07-16 19:21:12 +00:00
|
|
|
|
new_reph_pos = base;
|
2012-07-20 20:17:28 +00:00
|
|
|
|
while (new_reph_pos + 1 < end && info[new_reph_pos + 1].indic_position() <= POS_AFTER_MAIN)
|
2012-07-16 19:21:12 +00:00
|
|
|
|
new_reph_pos++;
|
|
|
|
|
if (new_reph_pos < end)
|
|
|
|
|
goto reph_move;
|
2012-05-10 19:44:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* 4. If reph should be positioned before post-base consonant, find
|
2012-05-10 11:45:52 +00:00
|
|
|
|
* first post-base classified consonant not ligated with main. If no
|
|
|
|
|
* consonant is found, the target position should be before the
|
|
|
|
|
* first matra, syllable modifier sign or vedic sign.
|
2012-05-10 19:44:50 +00:00
|
|
|
|
*/
|
2012-05-11 19:36:32 +00:00
|
|
|
|
/* This is our take on what step 4 is trying to say (and failing, BADLY). */
|
2012-08-02 18:21:40 +00:00
|
|
|
|
if (reph_pos == REPH_POS_AFTER_SUB)
|
2012-05-10 19:44:50 +00:00
|
|
|
|
{
|
2012-05-11 19:36:32 +00:00
|
|
|
|
new_reph_pos = base;
|
2017-02-25 21:30:38 +00:00
|
|
|
|
while (new_reph_pos + 1 < end &&
|
2017-10-19 18:39:52 +00:00
|
|
|
|
!( FLAG_UNSAFE (info[new_reph_pos + 1].indic_position()) & (FLAG (POS_POST_C) | FLAG (POS_AFTER_POST) | FLAG (POS_SMVD))))
|
2012-05-11 19:36:32 +00:00
|
|
|
|
new_reph_pos++;
|
|
|
|
|
if (new_reph_pos < end)
|
|
|
|
|
goto reph_move;
|
2012-05-10 19:44:50 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* 5. If no consonant is found in steps 3 or 4, move reph to a position
|
2012-05-10 11:45:52 +00:00
|
|
|
|
* immediately before the first post-base matra, syllable modifier
|
|
|
|
|
* sign or vedic sign that has a reordering class after the intended
|
|
|
|
|
* reph position. For example, if the reordering position for reph
|
|
|
|
|
* is post-main, it will skip above-base matras that also have a
|
|
|
|
|
* post-main position.
|
|
|
|
|
*/
|
2012-05-10 19:44:50 +00:00
|
|
|
|
reph_step_5:
|
|
|
|
|
{
|
2012-07-20 15:25:41 +00:00
|
|
|
|
/* Copied from step 2. */
|
|
|
|
|
new_reph_pos = start + 1;
|
2018-01-05 15:33:11 +00:00
|
|
|
|
while (new_reph_pos < base && !is_halant (info[new_reph_pos]))
|
2012-07-20 15:25:41 +00:00
|
|
|
|
new_reph_pos++;
|
|
|
|
|
|
2018-01-05 15:33:11 +00:00
|
|
|
|
if (new_reph_pos < base && is_halant (info[new_reph_pos]))
|
2013-02-13 14:38:40 +00:00
|
|
|
|
{
|
2012-07-20 15:25:41 +00:00
|
|
|
|
/* ->If ZWJ or ZWNJ are following this halant, position is moved after it. */
|
|
|
|
|
if (new_reph_pos + 1 < base && is_joiner (info[new_reph_pos + 1]))
|
|
|
|
|
new_reph_pos++;
|
|
|
|
|
goto reph_move;
|
|
|
|
|
}
|
2012-05-10 19:44:50 +00:00
|
|
|
|
}
|
2012-05-10 11:45:52 +00:00
|
|
|
|
|
2012-05-10 19:44:50 +00:00
|
|
|
|
/* 6. Otherwise, reorder reph to the end of the syllable.
|
|
|
|
|
*/
|
|
|
|
|
{
|
|
|
|
|
new_reph_pos = end - 1;
|
|
|
|
|
while (new_reph_pos > start && info[new_reph_pos].indic_position() == POS_SMVD)
|
|
|
|
|
new_reph_pos--;
|
|
|
|
|
|
2012-05-11 14:54:40 +00:00
|
|
|
|
/*
|
|
|
|
|
* If the Reph is to be ending up after a Matra,Halant sequence,
|
|
|
|
|
* position it before that Halant so it can interact with the Matra.
|
|
|
|
|
* However, if it's a plain Consonant,Halant we shouldn't do that.
|
|
|
|
|
* Uniscribe doesn't do this.
|
|
|
|
|
* TEST: U+0930,U+094D,U+0915,U+094B,U+094D
|
|
|
|
|
*/
|
2018-09-10 20:51:26 +00:00
|
|
|
|
if (!indic_plan->uniscribe_bug_compatible &&
|
2018-01-05 15:33:11 +00:00
|
|
|
|
unlikely (is_halant (info[new_reph_pos]))) {
|
2012-05-10 19:44:50 +00:00
|
|
|
|
for (unsigned int i = base + 1; i < new_reph_pos; i++)
|
|
|
|
|
if (info[i].indic_category() == OT_M) {
|
|
|
|
|
/* Ok, got it. */
|
|
|
|
|
new_reph_pos--;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
goto reph_move;
|
2012-05-10 13:41:04 +00:00
|
|
|
|
}
|
|
|
|
|
|
2012-05-10 19:44:50 +00:00
|
|
|
|
reph_move:
|
|
|
|
|
{
|
|
|
|
|
/* Move */
|
2015-09-01 15:26:35 +00:00
|
|
|
|
buffer->merge_clusters (start, new_reph_pos + 1);
|
2012-05-10 19:44:50 +00:00
|
|
|
|
hb_glyph_info_t reph = info[start];
|
|
|
|
|
memmove (&info[start], &info[start + 1], (new_reph_pos - start) * sizeof (info[0]));
|
|
|
|
|
info[new_reph_pos] = reph;
|
2015-09-01 15:26:35 +00:00
|
|
|
|
|
2013-02-13 12:32:46 +00:00
|
|
|
|
if (start < base && base <= new_reph_pos)
|
|
|
|
|
base--;
|
2012-05-10 19:44:50 +00:00
|
|
|
|
}
|
2012-05-10 11:45:52 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2017-12-05 17:43:09 +00:00
|
|
|
|
/* o Reorder pre-base-reordering consonants:
|
2011-07-31 19:18:57 +00:00
|
|
|
|
*
|
2017-12-05 17:43:09 +00:00
|
|
|
|
* If a pre-base-reordering consonant is found, reorder it according to
|
2011-07-31 19:18:57 +00:00
|
|
|
|
* the following rules:
|
|
|
|
|
*/
|
|
|
|
|
|
2017-12-05 17:43:09 +00:00
|
|
|
|
if (try_pref && base + 1 < end) /* Otherwise there can't be any pre-base-reordering Ra. */
|
2012-07-16 19:30:05 +00:00
|
|
|
|
{
|
2012-07-16 21:04:46 +00:00
|
|
|
|
for (unsigned int i = base + 1; i < end; i++)
|
2012-08-02 16:21:44 +00:00
|
|
|
|
if ((info[i].mask & indic_plan->mask_array[PREF]) != 0)
|
2012-07-16 19:49:08 +00:00
|
|
|
|
{
|
2012-07-16 21:04:46 +00:00
|
|
|
|
/* 1. Only reorder a glyph produced by substitution during application
|
|
|
|
|
* of the <pref> feature. (Note that a font may shape a Ra consonant with
|
|
|
|
|
* the feature generally but block it in certain contexts.)
|
|
|
|
|
*/
|
2013-10-18 00:14:53 +00:00
|
|
|
|
/* Note: We just check that something got substituted. We don't check that
|
2013-10-27 22:24:50 +00:00
|
|
|
|
* the <pref> feature actually did it...
|
|
|
|
|
*
|
2016-05-06 15:05:07 +00:00
|
|
|
|
* Reorder pref only if it ligated. */
|
|
|
|
|
if (_hb_glyph_info_ligated_and_didnt_multiply (&info[i]))
|
2012-07-16 21:04:46 +00:00
|
|
|
|
{
|
|
|
|
|
/*
|
|
|
|
|
* 2. Try to find a target position the same way as for pre-base matra.
|
|
|
|
|
* If it is found, reorder pre-base consonant glyph.
|
|
|
|
|
*
|
|
|
|
|
* 3. If position is not found, reorder immediately before main
|
|
|
|
|
* consonant.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
unsigned int new_pos = base;
|
2012-10-29 23:27:02 +00:00
|
|
|
|
/* Malayalam / Tamil do not have "half" forms or explicit virama forms.
|
|
|
|
|
* The glyphs formed by 'half' are Chillus or ligated explicit viramas.
|
|
|
|
|
* We want to position matra after them.
|
|
|
|
|
*/
|
|
|
|
|
if (buffer->props.script != HB_SCRIPT_MALAYALAM && buffer->props.script != HB_SCRIPT_TAMIL)
|
2012-07-24 06:10:20 +00:00
|
|
|
|
{
|
2012-10-29 23:27:02 +00:00
|
|
|
|
while (new_pos > start &&
|
2018-01-05 15:33:11 +00:00
|
|
|
|
!(is_one_of (info[new_pos - 1], FLAG(OT_M) | FLAG (OT_H))))
|
2012-10-29 23:27:02 +00:00
|
|
|
|
new_pos--;
|
2012-07-24 06:10:20 +00:00
|
|
|
|
}
|
|
|
|
|
|
2018-01-05 15:33:11 +00:00
|
|
|
|
if (new_pos > start && is_halant (info[new_pos - 1]))
|
2013-02-13 14:38:40 +00:00
|
|
|
|
{
|
2012-07-16 21:04:46 +00:00
|
|
|
|
/* -> If ZWJ or ZWNJ follow this halant, position is moved after it. */
|
|
|
|
|
if (new_pos < end && is_joiner (info[new_pos]))
|
|
|
|
|
new_pos++;
|
2013-02-13 14:38:40 +00:00
|
|
|
|
}
|
2012-07-16 21:04:46 +00:00
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
unsigned int old_pos = i;
|
2015-09-01 15:26:35 +00:00
|
|
|
|
|
2012-07-23 04:11:26 +00:00
|
|
|
|
buffer->merge_clusters (new_pos, old_pos + 1);
|
2012-07-16 21:04:46 +00:00
|
|
|
|
hb_glyph_info_t tmp = info[old_pos];
|
|
|
|
|
memmove (&info[new_pos + 1], &info[new_pos], (old_pos - new_pos) * sizeof (info[0]));
|
|
|
|
|
info[new_pos] = tmp;
|
2015-09-01 15:26:35 +00:00
|
|
|
|
|
2013-02-13 12:32:46 +00:00
|
|
|
|
if (new_pos <= base && base < old_pos)
|
|
|
|
|
base++;
|
2012-07-16 21:04:46 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
break;
|
2012-07-16 19:49:08 +00:00
|
|
|
|
}
|
2012-07-16 19:30:05 +00:00
|
|
|
|
}
|
2012-05-11 18:50:53 +00:00
|
|
|
|
|
|
|
|
|
|
2012-05-11 18:59:26 +00:00
|
|
|
|
/* Apply 'init' to the Left Matra if it's a word start. */
|
2017-11-08 18:15:27 +00:00
|
|
|
|
if (info[start].indic_position () == POS_PRE_M)
|
|
|
|
|
{
|
|
|
|
|
if (!start ||
|
|
|
|
|
!(FLAG_UNSAFE (_hb_glyph_info_get_general_category (&info[start - 1])) &
|
|
|
|
|
FLAG_RANGE (HB_UNICODE_GENERAL_CATEGORY_FORMAT, HB_UNICODE_GENERAL_CATEGORY_NON_SPACING_MARK)))
|
|
|
|
|
info[start].mask |= indic_plan->mask_array[INIT];
|
|
|
|
|
else
|
|
|
|
|
buffer->unsafe_to_break (start - 1, start + 1);
|
|
|
|
|
}
|
2012-05-11 18:59:26 +00:00
|
|
|
|
|
2012-05-11 18:50:53 +00:00
|
|
|
|
|
2012-07-20 15:42:24 +00:00
|
|
|
|
/*
|
|
|
|
|
* Finish off the clusters and go home!
|
|
|
|
|
*/
|
2018-09-10 20:51:26 +00:00
|
|
|
|
if (indic_plan->uniscribe_bug_compatible)
|
2012-05-11 14:43:12 +00:00
|
|
|
|
{
|
2013-10-17 14:27:38 +00:00
|
|
|
|
switch ((hb_tag_t) plan->props.script)
|
|
|
|
|
{
|
|
|
|
|
case HB_SCRIPT_TAMIL:
|
|
|
|
|
case HB_SCRIPT_SINHALA:
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
default:
|
2017-10-12 11:48:48 +00:00
|
|
|
|
/* Uniscribe merges the entire syllable into a single cluster... Except for Tamil & Sinhala.
|
|
|
|
|
* This means, half forms are submerged into the main consonant's cluster.
|
2013-10-17 14:27:38 +00:00
|
|
|
|
* This is unnecessary, and makes cursor positioning harder, but that's what
|
|
|
|
|
* Uniscribe does. */
|
|
|
|
|
buffer->merge_clusters (start, end);
|
|
|
|
|
break;
|
|
|
|
|
}
|
2012-05-10 16:34:34 +00:00
|
|
|
|
}
|
2012-05-09 15:56:03 +00:00
|
|
|
|
}
|
2011-07-31 19:18:57 +00:00
|
|
|
|
|
|
|
|
|
|
2012-05-09 15:56:03 +00:00
|
|
|
|
static void
|
2012-08-02 14:07:58 +00:00
|
|
|
|
final_reordering (const hb_ot_shape_plan_t *plan,
|
2012-12-05 23:46:04 +00:00
|
|
|
|
hb_font_t *font HB_UNUSED,
|
2012-08-02 13:44:18 +00:00
|
|
|
|
hb_buffer_t *buffer)
|
2012-05-09 15:56:03 +00:00
|
|
|
|
{
|
|
|
|
|
unsigned int count = buffer->len;
|
2012-08-31 20:49:34 +00:00
|
|
|
|
if (unlikely (!count)) return;
|
2012-05-09 15:56:03 +00:00
|
|
|
|
|
2015-07-22 11:02:09 +00:00
|
|
|
|
foreach_syllable (buffer, start, end)
|
|
|
|
|
final_reordering_syllable (plan, buffer, start, end);
|
2011-07-31 19:18:57 +00:00
|
|
|
|
|
2011-07-29 20:37:02 +00:00
|
|
|
|
HB_BUFFER_DEALLOCATE_VAR (buffer, indic_category);
|
|
|
|
|
HB_BUFFER_DEALLOCATE_VAR (buffer, indic_position);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
[indic] Don't apply presentation features across syllables
More like Uniscribe... We still allow user-defined features to
work across syllables, but not pres,blws,abs,psts,etc.
This "regressed" Sinhala numbers by 11. These are cases were
there's Consonant followed by Ra,Halant,ZWJ at the of text.
The Ra,Halant,ZWJ ends up forming reph, which is wrong...
But before we were also ligating that reph with the previous
consonant. That's even more wrong. That's also what Uniscribe
does.
Current numbers:
BENGALI: 353732 out of 354188 tests passed. 456 failed (0.128745%)
DEVANAGARI: 707307 out of 707394 tests passed. 87 failed (0.0122987%)
GUJARATI: 366349 out of 366457 tests passed. 108 failed (0.0294714%)
GURMUKHI: 60732 out of 60747 tests passed. 15 failed (0.0246926%)
KANNADA: 951030 out of 951913 tests passed. 883 failed (0.0927606%)
KHMER: 299070 out of 299124 tests passed. 54 failed (0.0180527%)
MALAYALAM: 1048140 out of 1048334 tests passed. 194 failed (0.0185056%)
ORIYA: 42320 out of 42329 tests passed. 9 failed (0.021262%)
SINHALA: 271655 out of 271847 tests passed. 192 failed (0.070628%)
TAMIL: 1091753 out of 1091754 tests passed. 1 failed (9.15957e-05%)
TELUGU: 970555 out of 970573 tests passed. 18 failed (0.00185457%)
2013-10-15 11:47:27 +00:00
|
|
|
|
static void
|
|
|
|
|
clear_syllables (const hb_ot_shape_plan_t *plan HB_UNUSED,
|
|
|
|
|
hb_font_t *font HB_UNUSED,
|
|
|
|
|
hb_buffer_t *buffer)
|
|
|
|
|
{
|
|
|
|
|
hb_glyph_info_t *info = buffer->info;
|
|
|
|
|
unsigned int count = buffer->len;
|
|
|
|
|
for (unsigned int i = 0; i < count; i++)
|
|
|
|
|
info[i].syllable() = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-11-16 20:39:23 +00:00
|
|
|
|
static bool
|
|
|
|
|
decompose_indic (const hb_ot_shape_normalize_context_t *c,
|
2012-11-13 20:35:35 +00:00
|
|
|
|
hb_codepoint_t ab,
|
|
|
|
|
hb_codepoint_t *a,
|
|
|
|
|
hb_codepoint_t *b)
|
|
|
|
|
{
|
|
|
|
|
switch (ab)
|
|
|
|
|
{
|
|
|
|
|
/* Don't decompose these. */
|
2016-12-26 18:10:31 +00:00
|
|
|
|
case 0x0931u : return false; /* DEVANAGARI LETTER RRA */
|
2018-04-13 08:13:29 +00:00
|
|
|
|
// https://github.com/harfbuzz/harfbuzz/issues/779
|
|
|
|
|
case 0x09DCu : return false; /* BENGALI LETTER RRA */
|
|
|
|
|
case 0x09DDu : return false; /* BENGALI LETTER RHA */
|
2016-12-26 18:10:31 +00:00
|
|
|
|
case 0x0B94u : return false; /* TAMIL LETTER AU */
|
2012-11-13 20:35:35 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
* Decompose split matras that don't have Unicode decompositions.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#if 0
|
2016-12-26 18:10:31 +00:00
|
|
|
|
/* Gujarati */
|
2012-11-13 20:35:35 +00:00
|
|
|
|
/* This one has no decomposition in Unicode, but needs no decomposition either. */
|
2014-07-11 18:54:42 +00:00
|
|
|
|
/* case 0x0AC9u : return false; */
|
2016-12-26 18:10:31 +00:00
|
|
|
|
|
|
|
|
|
/* Oriya */
|
2014-07-11 18:54:42 +00:00
|
|
|
|
case 0x0B57u : *a = no decomp, -> RIGHT; return true;
|
2012-11-13 20:35:35 +00:00
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
|
2017-06-19 10:17:09 +00:00
|
|
|
|
if ((ab == 0x0DDAu || hb_in_range<hb_codepoint_t> (ab, 0x0DDCu, 0x0DDEu)))
|
2012-11-13 20:35:35 +00:00
|
|
|
|
{
|
2012-11-16 21:12:35 +00:00
|
|
|
|
/*
|
|
|
|
|
* Sinhala split matras... Let the fun begin.
|
|
|
|
|
*
|
|
|
|
|
* These four characters have Unicode decompositions. However, Uniscribe
|
|
|
|
|
* decomposes them "Khmer-style", that is, it uses the character itself to
|
|
|
|
|
* get the second half. The first half of all four decompositions is always
|
|
|
|
|
* U+0DD9.
|
|
|
|
|
*
|
|
|
|
|
* Now, there are buggy fonts, namely, the widely used lklug.ttf, that are
|
|
|
|
|
* broken with Uniscribe. But we need to support them. As such, we only
|
|
|
|
|
* do the Uniscribe-style decomposition if the character is transformed into
|
|
|
|
|
* its "sec.half" form by the 'pstf' feature. Otherwise, we fall back to
|
|
|
|
|
* Unicode decomposition.
|
|
|
|
|
*
|
|
|
|
|
* Note that we can't unconditionally use Unicode decomposition. That would
|
|
|
|
|
* break some other fonts, that are designed to work with Uniscribe, and
|
|
|
|
|
* don't have positioning features for the Unicode-style decomposition.
|
|
|
|
|
*
|
|
|
|
|
* Argh...
|
2012-12-06 00:20:31 +00:00
|
|
|
|
*
|
|
|
|
|
* The Uniscribe behavior is now documented in the newly published Sinhala
|
|
|
|
|
* spec in 2012:
|
|
|
|
|
*
|
2018-04-12 09:10:45 +00:00
|
|
|
|
* https://docs.microsoft.com/en-us/typography/script-development/sinhala#shaping
|
2012-11-16 21:12:35 +00:00
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
const indic_shape_plan_t *indic_plan = (const indic_shape_plan_t *) c->plan->data;
|
|
|
|
|
|
|
|
|
|
hb_codepoint_t glyph;
|
|
|
|
|
|
2013-02-12 20:26:45 +00:00
|
|
|
|
if (hb_options ().uniscribe_bug_compatible ||
|
2016-02-24 10:05:23 +00:00
|
|
|
|
(c->font->get_nominal_glyph (ab, &glyph) &&
|
2013-10-17 16:04:23 +00:00
|
|
|
|
indic_plan->pstf.would_substitute (&glyph, 1, c->font->face)))
|
2012-11-16 21:12:35 +00:00
|
|
|
|
{
|
|
|
|
|
/* Ok, safe to use Uniscribe-style decomposition. */
|
2014-07-11 18:54:42 +00:00
|
|
|
|
*a = 0x0DD9u;
|
2012-11-16 21:12:35 +00:00
|
|
|
|
*b = ab;
|
|
|
|
|
return true;
|
|
|
|
|
}
|
2012-11-13 20:35:35 +00:00
|
|
|
|
}
|
|
|
|
|
|
2015-11-27 00:22:22 +00:00
|
|
|
|
return (bool) c->unicode->decompose (ab, a, b);
|
2012-11-13 20:35:35 +00:00
|
|
|
|
}
|
|
|
|
|
|
2012-11-16 20:39:23 +00:00
|
|
|
|
static bool
|
|
|
|
|
compose_indic (const hb_ot_shape_normalize_context_t *c,
|
2012-11-13 20:35:35 +00:00
|
|
|
|
hb_codepoint_t a,
|
|
|
|
|
hb_codepoint_t b,
|
|
|
|
|
hb_codepoint_t *ab)
|
|
|
|
|
{
|
|
|
|
|
/* Avoid recomposing split matras. */
|
2012-11-16 20:39:23 +00:00
|
|
|
|
if (HB_UNICODE_GENERAL_CATEGORY_IS_MARK (c->unicode->general_category (a)))
|
2012-11-13 20:35:35 +00:00
|
|
|
|
return false;
|
|
|
|
|
|
|
|
|
|
/* Composition-exclusion exceptions that we want to recompose. */
|
2014-07-11 18:54:42 +00:00
|
|
|
|
if (a == 0x09AFu && b == 0x09BCu) { *ab = 0x09DFu; return true; }
|
2012-11-13 20:35:35 +00:00
|
|
|
|
|
2015-11-27 00:22:22 +00:00
|
|
|
|
return (bool) c->unicode->compose (a, b, ab);
|
2012-11-13 20:35:35 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2012-07-31 01:08:51 +00:00
|
|
|
|
const hb_ot_complex_shaper_t _hb_ot_complex_shaper_indic =
|
|
|
|
|
{
|
|
|
|
|
collect_features_indic,
|
|
|
|
|
override_features_indic,
|
2012-08-02 14:46:34 +00:00
|
|
|
|
data_create_indic,
|
|
|
|
|
data_destroy_indic,
|
2017-10-15 10:11:08 +00:00
|
|
|
|
nullptr, /* preprocess_text */
|
|
|
|
|
nullptr, /* postprocess_glyphs */
|
2013-12-31 08:04:35 +00:00
|
|
|
|
HB_OT_SHAPE_NORMALIZATION_MODE_COMPOSED_DIACRITICS_NO_SHORT_CIRCUIT,
|
2012-11-13 20:35:35 +00:00
|
|
|
|
decompose_indic,
|
|
|
|
|
compose_indic,
|
2012-07-31 01:08:51 +00:00
|
|
|
|
setup_masks_indic,
|
2017-10-15 10:11:08 +00:00
|
|
|
|
nullptr, /* disable_otl */
|
|
|
|
|
nullptr, /* reorder_marks */
|
2013-10-27 23:20:59 +00:00
|
|
|
|
HB_OT_SHAPE_ZERO_WIDTH_MARKS_NONE,
|
2012-11-14 21:48:26 +00:00
|
|
|
|
false, /* fallback_position */
|
2012-07-31 01:08:51 +00:00
|
|
|
|
};
|