diff options
Diffstat (limited to 'src/3rdparty/harfbuzz-ng/src/hb-ot-shape-normalize.cc')
-rw-r--r-- | src/3rdparty/harfbuzz-ng/src/hb-ot-shape-normalize.cc | 77 |
1 files changed, 56 insertions, 21 deletions
diff --git a/src/3rdparty/harfbuzz-ng/src/hb-ot-shape-normalize.cc b/src/3rdparty/harfbuzz-ng/src/hb-ot-shape-normalize.cc index 0a4d40499f..107617e81c 100644 --- a/src/3rdparty/harfbuzz-ng/src/hb-ot-shape-normalize.cc +++ b/src/3rdparty/harfbuzz-ng/src/hb-ot-shape-normalize.cc @@ -76,7 +76,7 @@ decompose_unicode (const hb_ot_shape_normalize_context_t *c, hb_codepoint_t *a, hb_codepoint_t *b) { - return c->unicode->decompose (ab, a, b); + return (bool) c->unicode->decompose (ab, a, b); } static bool @@ -85,21 +85,21 @@ compose_unicode (const hb_ot_shape_normalize_context_t *c, hb_codepoint_t b, hb_codepoint_t *ab) { - return c->unicode->compose (a, b, ab); + return (bool) c->unicode->compose (a, b, ab); } static inline void set_glyph (hb_glyph_info_t &info, hb_font_t *font) { - font->get_glyph (info.codepoint, 0, &info.glyph_index()); + font->get_nominal_glyph (info.codepoint, &info.glyph_index()); } static inline void output_char (hb_buffer_t *buffer, hb_codepoint_t unichar, hb_codepoint_t glyph) { buffer->cur().glyph_index() = glyph; - buffer->output_glyph (unichar); - _hb_glyph_info_set_unicode_props (&buffer->prev(), buffer->unicode); + buffer->output_glyph (unichar); /* This is very confusing indeed. */ + _hb_glyph_info_set_unicode_props (&buffer->prev(), buffer); } static inline void @@ -124,10 +124,10 @@ decompose (const hb_ot_shape_normalize_context_t *c, bool shortest, hb_codepoint hb_font_t * const font = c->font; if (!c->decompose (c, ab, &a, &b) || - (b && !font->get_glyph (b, 0, &b_glyph))) + (b && !font->get_nominal_glyph (b, &b_glyph))) return 0; - bool has_a = font->get_glyph (a, 0, &a_glyph); + bool has_a = (bool) font->get_nominal_glyph (a, &a_glyph); if (shortest && has_a) { /* Output a and b */ output_char (buffer, a, a_glyph); @@ -166,15 +166,50 @@ decompose_current_character (const hb_ot_shape_normalize_context_t *c, bool shor hb_codepoint_t u = buffer->cur().codepoint; hb_codepoint_t glyph; - /* Kind of a cute waterfall here... */ - if (shortest && c->font->get_glyph (u, 0, &glyph)) + if (shortest && c->font->get_nominal_glyph (u, &glyph)) + { next_char (buffer, glyph); - else if (decompose (c, shortest, u)) + return; + } + + if (decompose (c, shortest, u)) + { skip_char (buffer); - else if (!shortest && c->font->get_glyph (u, 0, &glyph)) + return; + } + + if (!shortest && c->font->get_nominal_glyph (u, &glyph)) + { next_char (buffer, glyph); - else - next_char (buffer, glyph); /* glyph is initialized in earlier branches. */ + return; + } + + if (_hb_glyph_info_is_unicode_space (&buffer->cur())) + { + hb_codepoint_t space_glyph; + hb_unicode_funcs_t::space_t space_type = buffer->unicode->space_fallback_type (u); + if (space_type != hb_unicode_funcs_t::NOT_SPACE && c->font->get_nominal_glyph (0x0020u, &space_glyph)) + { + _hb_glyph_info_set_unicode_space_fallback_type (&buffer->cur(), space_type); + next_char (buffer, space_glyph); + buffer->scratch_flags |= HB_BUFFER_SCRATCH_FLAG_HAS_SPACE_FALLBACK; + return; + } + } + + if (u == 0x2011u) + { + /* U+2011 is the only sensible character that is a no-break version of another character + * and not a space. The space ones are handled already. Handle this lone one. */ + hb_codepoint_t other_glyph; + if (c->font->get_nominal_glyph (0x2010u, &other_glyph)) + { + next_char (buffer, other_glyph); + return; + } + } + + next_char (buffer, glyph); /* glyph is initialized in earlier branches. */ } static inline void @@ -183,10 +218,10 @@ handle_variation_selector_cluster (const hb_ot_shape_normalize_context_t *c, uns /* TODO Currently if there's a variation-selector we give-up, it's just too hard. */ hb_buffer_t * const buffer = c->buffer; hb_font_t * const font = c->font; - for (; buffer->idx < end - 1;) { + for (; buffer->idx < end - 1 && !buffer->in_error;) { if (unlikely (buffer->unicode->is_variation_selector (buffer->cur(+1).codepoint))) { /* The next two lines are some ugly lines... But work. */ - if (font->get_glyph (buffer->cur().codepoint, buffer->cur(+1).codepoint, &buffer->cur().glyph_index())) + if (font->get_variation_glyph (buffer->cur().codepoint, buffer->cur(+1).codepoint, &buffer->cur().glyph_index())) { buffer->replace_glyphs (2, 1, &buffer->cur().codepoint); } @@ -219,13 +254,13 @@ static inline void decompose_multi_char_cluster (const hb_ot_shape_normalize_context_t *c, unsigned int end, bool short_circuit) { hb_buffer_t * const buffer = c->buffer; - for (unsigned int i = buffer->idx; i < end; i++) + for (unsigned int i = buffer->idx; i < end && !buffer->in_error; i++) if (unlikely (buffer->unicode->is_variation_selector (buffer->info[i].codepoint))) { handle_variation_selector_cluster (c, end, short_circuit); return; } - while (buffer->idx < end) + while (buffer->idx < end && !buffer->in_error) decompose_current_character (c, short_circuit); } @@ -285,7 +320,7 @@ _hb_ot_shape_normalize (const hb_ot_shape_plan_t *plan, buffer->clear_output (); count = buffer->len; - for (buffer->idx = 0; buffer->idx < count;) + for (buffer->idx = 0; buffer->idx < count && !buffer->in_error;) { unsigned int end; for (end = buffer->idx + 1; end < count; end++) @@ -335,7 +370,7 @@ _hb_ot_shape_normalize (const hb_ot_shape_plan_t *plan, count = buffer->len; unsigned int starter = 0; buffer->next_glyph (); - while (buffer->idx < count) + while (buffer->idx < count && !buffer->in_error) { hb_codepoint_t composed, glyph; if (/* We don't try to compose a non-mark character with it's preceding starter. @@ -353,7 +388,7 @@ _hb_ot_shape_normalize (const hb_ot_shape_plan_t *plan, buffer->cur().codepoint, &composed) && /* And the font has glyph for the composite. */ - font->get_glyph (composed, 0, &glyph)) + font->get_nominal_glyph (composed, &glyph)) { /* Composes. */ buffer->next_glyph (); /* Copy to out-buffer. */ @@ -364,7 +399,7 @@ _hb_ot_shape_normalize (const hb_ot_shape_plan_t *plan, /* Modify starter and carry on. */ buffer->out_info[starter].codepoint = composed; buffer->out_info[starter].glyph_index() = glyph; - _hb_glyph_info_set_unicode_props (&buffer->out_info[starter], buffer->unicode); + _hb_glyph_info_set_unicode_props (&buffer->out_info[starter], buffer); continue; } |