jdk-sandbox: comparison src/java.desktop/share/native/libfontmanager/harfbuzz/hb-ot-shape.cc

equal deleted inserted replaced

-:e2065f7505eb
+:51772bf1fb0c
 unsigned int                    num_user_features)
 {
 hb_ot_map_builder_t *map = &planner->map;
 map->add_global_bool_feature (HB_TAG('r','v','r','n'));
-map->add_gsub_pause (NULL);
+map->add_gsub_pause (nullptr);
 switch (props->direction) {
 case HB_DIRECTION_LTR:
 map->add_global_bool_feature (HB_TAG ('l','t','r','a'));
 map->add_global_bool_feature (HB_TAG ('l','t','r','m'));
 /*
 * shaper face data
 */
+HB_SHAPER_DATA_ENSURE_DEFINE(ot, face)
 hb_ot_shaper_face_data_t *
 _hb_ot_shaper_face_data_create (hb_face_t *face)
 {
 return _hb_ot_layout_create (face);
 }
 /*
 * shaper font data
 */
+HB_SHAPER_DATA_ENSURE_DEFINE(ot, font)
 struct hb_ot_shaper_font_data_t {};
 hb_ot_shaper_font_data_t *
 _hb_ot_shaper_font_data_create (hb_font_t *font HB_UNUSED)
 const int          *coords,
 unsigned int        num_coords)
 {
 hb_ot_shape_plan_t *plan = (hb_ot_shape_plan_t *) calloc (1, sizeof (hb_ot_shape_plan_t));
 if (unlikely (!plan))
-return NULL;
+return nullptr;
 hb_ot_shape_planner_t planner (shape_plan);
 planner.shaper = hb_ot_shape_complex_categorize (&planner);
 planner.compile (*plan, coords, num_coords);
 if (plan->shaper->data_create) {
 plan->data = plan->shaper->data_create (plan);
 if (unlikely (!plan->data))
-return NULL;
+return nullptr;
 }
 return plan;
 }
 }
 static void
 hb_form_clusters (hb_buffer_t *buffer)
 {
-if (!(buffer->scratch_flags & HB_BUFFER_SCRATCH_FLAG_HAS_NON_ASCII) ||
+if (!(buffer->scratch_flags & HB_BUFFER_SCRATCH_FLAG_HAS_NON_ASCII))
-buffer->cluster_level != HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES)
 return;
 /* Loop duplicated in hb_ensure_native_direction(), and in _hb-coretext.cc */
 unsigned int base = 0;
 unsigned int count = buffer->len;
 for (unsigned int i = 1; i < count; i++)
 {
 if (likely (!HB_UNICODE_GENERAL_CATEGORY_IS_MARK (_hb_glyph_info_get_general_category (&info[i])) &&
 !_hb_glyph_info_is_joiner (&info[i])))
 {
-buffer->merge_clusters (base, i);
+if (buffer->cluster_level == HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES)
+buffer->merge_clusters (base, i);
+else
+buffer->unsafe_to_break (base, i);
 base = i;
 }
 }
-buffer->merge_clusters (base, count);
+if (buffer->cluster_level == HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES)
+buffer->merge_clusters (base, count);
+else
+buffer->unsafe_to_break (base, count);
 }
 static void
 hb_ensure_native_direction (hb_buffer_t *buffer)
 {
 !c->plan->has_frac)
 return;
 hb_buffer_t *buffer = c->buffer;
-/* TODO look in pre/post context text also. */
+hb_mask_t pre_mask, post_mask;
+if (HB_DIRECTION_IS_FORWARD (buffer->props.direction))
+{
+pre_mask = c->plan->numr_mask | c->plan->frac_mask;
+post_mask = c->plan->frac_mask | c->plan->dnom_mask;
+}
+else
+{
+pre_mask = c->plan->frac_mask | c->plan->dnom_mask;
+post_mask = c->plan->numr_mask | c->plan->frac_mask;
+}
 unsigned int count = buffer->len;
 hb_glyph_info_t *info = buffer->info;
 for (unsigned int i = 0; i < count; i++)
 {
 if (info[i].codepoint == 0x2044u) /* FRACTION SLASH */
 while (end < count &&
 _hb_glyph_info_get_general_category (&info[end]) ==
 HB_UNICODE_GENERAL_CATEGORY_DECIMAL_NUMBER)
 end++;
+buffer->unsafe_to_break (start, end);
 for (unsigned int j = start; j < i; j++)
-info[j].mask |= c->plan->numr_mask | c->plan->frac_mask;
+info[j].mask |= pre_mask;
 info[i].mask |= c->plan->frac_mask;
 for (unsigned int j = i + 1; j < end; j++)
-info[j].mask |= c->plan->frac_mask | c->plan->dnom_mask;
+info[j].mask |= post_mask;
 i = end - 1;
 }
 }
 }
 if (j)
 {
 /* Merge cluster backward. */
 if (cluster < info[j - 1].cluster)
 {
+unsigned int mask = info[i].mask;
 unsigned int old_cluster = info[j - 1].cluster;
 for (unsigned k = j; k && info[k - 1].cluster == old_cluster; k--)
-info[k - 1].cluster = cluster;
+buffer->set_cluster (info[k - 1], cluster, mask);
 }
 continue;
 }
 if (i + 1 < count)
 static inline void
 hb_ot_substitute_default (hb_ot_shape_context_t *c)
 {
 hb_buffer_t *buffer = c->buffer;
-hb_ot_shape_initialize_masks (c);
 hb_ot_mirror_chars (c);
 HB_BUFFER_ALLOCATE_VAR (buffer, glyph_index);
 _hb_ot_shape_normalize (c->plan, buffer, c->font);
 }
 static inline void
 hb_ot_position_complex (hb_ot_shape_context_t *c)
 {
-hb_ot_layout_position_start (c->font, c->buffer);
 unsigned int count = c->buffer->len;
+hb_glyph_info_t *info = c->buffer->info;
+hb_glyph_position_t *pos = c->buffer->pos;
 /* If the font has no GPOS, AND, no fallback positioning will
 * happen, AND, direction is forward, then when zeroing mark
 * widths, we shift the mark with it, such that the mark
 * is positioned hanging over the previous glyph.  When
 */
 bool adjust_offsets_when_zeroing = c->fallback_positioning &&
 !c->plan->shaper->fallback_position &&
 HB_DIRECTION_IS_FORWARD (c->buffer->props.direction);
+/* We change glyph origin to what GPOS expects (horizontal), apply GPOS, change it back. */
+/* The nil glyph_h_origin() func returns 0, so no need to apply it. */
+if (c->font->has_glyph_h_origin_func ())
+for (unsigned int i = 0; i < count; i++)
+c->font->add_glyph_h_origin (info[i].codepoint,
+&pos[i].x_offset,
+&pos[i].y_offset);
+hb_ot_layout_position_start (c->font, c->buffer);
 switch (c->plan->shaper->zero_width_marks)
 {
 case HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_EARLY:
 zero_mark_widths_by_gdef (c->buffer, adjust_offsets_when_zeroing);
 break;
 case HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_LATE:
 break;
 }
 if (likely (!c->fallback_positioning))
-{
-hb_glyph_info_t *info = c->buffer->info;
-hb_glyph_position_t *pos = c->buffer->pos;
-/* Change glyph origin to what GPOS expects (horizontal), apply GPOS, change it back. */
-/* The nil glyph_h_origin() func returns 0, so no need to apply it. */
-if (c->font->has_glyph_h_origin_func ())
-for (unsigned int i = 0; i < count; i++)
-c->font->add_glyph_h_origin (info[i].codepoint,
-&pos[i].x_offset,
-&pos[i].y_offset);
 c->plan->position (c->font, c->buffer);
-/* The nil glyph_h_origin() func returns 0, so no need to apply it. */
-if (c->font->has_glyph_h_origin_func ())
-for (unsigned int i = 0; i < count; i++)
-c->font->subtract_glyph_h_origin (info[i].codepoint,
-&pos[i].x_offset,
-&pos[i].y_offset);
-}
 switch (c->plan->shaper->zero_width_marks)
 {
 case HB_OT_SHAPE_ZERO_WIDTH_MARKS_BY_GDEF_LATE:
 zero_mark_widths_by_gdef (c->buffer, adjust_offsets_when_zeroing);
 /* Finishing off GPOS has to follow a certain order. */
 hb_ot_layout_position_finish_advances (c->font, c->buffer);
 hb_ot_zero_width_default_ignorables (c);
 hb_ot_layout_position_finish_offsets (c->font, c->buffer);
+/* The nil glyph_h_origin() func returns 0, so no need to apply it. */
+if (c->font->has_glyph_h_origin_func ())
+for (unsigned int i = 0; i < count; i++)
+c->font->subtract_glyph_h_origin (info[i].codepoint,
+&pos[i].x_offset,
+&pos[i].y_offset);
 }
 static inline void
 hb_ot_position (hb_ot_shape_context_t *c)
 {
 _hb_ot_shape_fallback_kern (c->plan, c->font, c->buffer);
 _hb_buffer_deallocate_gsubgpos_vars (c->buffer);
 }
+static inline void
+hb_propagate_flags (hb_buffer_t *buffer)
+{
+/* Propagate cluster-level glyph flags to be the same on all cluster glyphs.
+* Simplifies using them. */
+if (!(buffer->scratch_flags & HB_BUFFER_SCRATCH_FLAG_HAS_UNSAFE_TO_BREAK))
+return;
+hb_glyph_info_t *info = buffer->info;
+foreach_cluster (buffer, start, end)
+{
+unsigned int mask = 0;
+for (unsigned int i = start; i < end; i++)
+if (info[i].mask & HB_GLYPH_FLAG_UNSAFE_TO_BREAK)
+{
+mask = HB_GLYPH_FLAG_UNSAFE_TO_BREAK;
+break;
+}
+if (mask)
+for (unsigned int i = start; i < end; i++)
+info[i].mask |= mask;
+}
+}
 /* Pull it all together! */
 static void
 hb_ot_shape_internal (hb_ot_shape_context_t *c)
 _hb_buffer_allocate_unicode_vars (c->buffer);
 c->buffer->clear_output ();
+hb_ot_shape_initialize_masks (c);
 hb_set_unicode_props (c->buffer);
 hb_insert_dotted_circle (c->buffer, c->font);
 hb_form_clusters (c->buffer);
 hb_ensure_native_direction (c->buffer);
 if (c->plan->shaper->preprocess_text)
 hb_ot_hide_default_ignorables (c);
 if (c->plan->shaper->postprocess_glyphs)
 c->plan->shaper->postprocess_glyphs (c->plan, c->buffer, c->font);
+hb_propagate_flags (c->buffer);
 _hb_buffer_deallocate_unicode_vars (c->buffer);
 c->buffer->props.direction = c->target_direction;
 unsigned int        num_features,
 hb_set_t           *glyphs)
 {
 hb_ot_shape_plan_t plan;
-const char *shapers[] = {"ot", NULL};
+const char *shapers[] = {"ot", nullptr};
 hb_shape_plan_t *shape_plan = hb_shape_plan_create_cached (font->face, &buffer->props,
 features, num_features, shapers);
 bool mirror = hb_script_get_horizontal_direction (buffer->props.script) == HB_DIRECTION_RTL;
 unsigned int count = buffer->len;
 hb_glyph_info_t *info = buffer->info;
 for (unsigned int i = 0; i < count; i++)
 add_char (font, buffer->unicode, mirror, info[i].codepoint, glyphs);
-hb_set_t lookups;
+hb_set_t *lookups = hb_set_create ();
-lookups.init ();
+hb_ot_shape_plan_collect_lookups (shape_plan, HB_OT_TAG_GSUB, lookups);
-hb_ot_shape_plan_collect_lookups (shape_plan, HB_OT_TAG_GSUB, &lookups);
 /* And find transitive closure. */
-hb_set_t copy;
+hb_set_t *copy = hb_set_create ();
-copy.init ();
 do {
-copy.set (glyphs);
+copy->set (glyphs);
-for (hb_codepoint_t lookup_index = -1; hb_set_next (&lookups, &lookup_index);)
+for (hb_codepoint_t lookup_index = -1; hb_set_next (lookups, &lookup_index);)
 hb_ot_layout_lookup_substitute_closure (font->face, lookup_index, glyphs);
-} while (!copy.is_equal (glyphs));
+} while (!copy->is_equal (glyphs));
+hb_set_destroy (copy);
+hb_set_destroy (lookups);
 hb_shape_plan_destroy (shape_plan);
 }

changeset 48274	51772bf1fb0c
parent 47216	71c04702a3d5
child 50352	25db2c8f3cf8