| /* |
| * Copyright © 2022 Behdad Esfahbod |
| * |
| * 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 |
| */ |
| |
| #include "hb.hh" |
| |
| #ifndef HB_NO_BUFFER_VERIFY |
| |
| #include "hb-buffer.hh" |
| |
| |
| #define BUFFER_VERIFY_ERROR "buffer verify error: " |
| static inline void |
| buffer_verify_error (hb_buffer_t *buffer, |
| hb_font_t *font, |
| const char *fmt, |
| ...) HB_PRINTF_FUNC(3, 4); |
| |
| static inline void |
| buffer_verify_error (hb_buffer_t *buffer, |
| hb_font_t *font, |
| const char *fmt, |
| ...) |
| { |
| va_list ap; |
| va_start (ap, fmt); |
| if (buffer->messaging ()) |
| { |
| buffer->message_impl (font, fmt, ap); |
| } |
| else |
| { |
| fprintf (stderr, "harfbuzz "); |
| vfprintf (stderr, fmt, ap); |
| fprintf (stderr, "\n"); |
| } |
| va_end (ap); |
| } |
| |
| static bool |
| buffer_verify_monotone (hb_buffer_t *buffer, |
| hb_font_t *font) |
| { |
| /* Check that clusters are monotone. */ |
| if (buffer->cluster_level == HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES || |
| buffer->cluster_level == HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS) |
| { |
| bool is_forward = HB_DIRECTION_IS_FORWARD (hb_buffer_get_direction (buffer)); |
| |
| unsigned int num_glyphs; |
| hb_glyph_info_t *info = hb_buffer_get_glyph_infos (buffer, &num_glyphs); |
| |
| for (unsigned int i = 1; i < num_glyphs; i++) |
| if (info[i-1].cluster != info[i].cluster && |
| (info[i-1].cluster < info[i].cluster) != is_forward) |
| { |
| buffer_verify_error (buffer, font, BUFFER_VERIFY_ERROR "clusters are not monotone."); |
| return false; |
| } |
| } |
| |
| return true; |
| } |
| |
| static bool |
| buffer_verify_unsafe_to_break (hb_buffer_t *buffer, |
| hb_buffer_t *text_buffer, |
| hb_font_t *font, |
| const hb_feature_t *features, |
| unsigned int num_features, |
| const char * const *shapers) |
| { |
| if (buffer->cluster_level != HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES && |
| buffer->cluster_level != HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS) |
| { |
| /* Cannot perform this check without monotone clusters. */ |
| return true; |
| } |
| |
| /* Check that breaking up shaping at safe-to-break is indeed safe. */ |
| |
| hb_buffer_t *fragment = hb_buffer_create_similar (buffer); |
| hb_buffer_set_flags (fragment, (hb_buffer_flags_t (hb_buffer_get_flags (fragment) & ~HB_BUFFER_FLAG_VERIFY))); |
| hb_buffer_t *reconstruction = hb_buffer_create_similar (buffer); |
| hb_buffer_set_flags (reconstruction, (hb_buffer_flags_t (hb_buffer_get_flags (reconstruction) & ~HB_BUFFER_FLAG_VERIFY))); |
| |
| unsigned int num_glyphs; |
| hb_glyph_info_t *info = hb_buffer_get_glyph_infos (buffer, &num_glyphs); |
| |
| unsigned int num_chars; |
| hb_glyph_info_t *text = hb_buffer_get_glyph_infos (text_buffer, &num_chars); |
| |
| /* Chop text and shape fragments. */ |
| bool forward = HB_DIRECTION_IS_FORWARD (hb_buffer_get_direction (buffer)); |
| unsigned int start = 0; |
| unsigned int text_start = forward ? 0 : num_chars; |
| unsigned int text_end = text_start; |
| for (unsigned int end = 1; end < num_glyphs + 1; end++) |
| { |
| if (end < num_glyphs && |
| (info[end].cluster == info[end-1].cluster || |
| info[end-(forward?0:1)].mask & HB_GLYPH_FLAG_UNSAFE_TO_BREAK)) |
| continue; |
| |
| /* Shape segment corresponding to glyphs start..end. */ |
| if (end == num_glyphs) |
| { |
| if (forward) |
| text_end = num_chars; |
| else |
| text_start = 0; |
| } |
| else |
| { |
| if (forward) |
| { |
| unsigned int cluster = info[end].cluster; |
| while (text_end < num_chars && text[text_end].cluster < cluster) |
| text_end++; |
| } |
| else |
| { |
| unsigned int cluster = info[end - 1].cluster; |
| while (text_start && text[text_start - 1].cluster >= cluster) |
| text_start--; |
| } |
| } |
| assert (text_start < text_end); |
| |
| if (0) |
| printf("start %d end %d text start %d end %d\n", start, end, text_start, text_end); |
| |
| hb_buffer_clear_contents (fragment); |
| |
| hb_buffer_flags_t flags = hb_buffer_get_flags (fragment); |
| if (0 < text_start) |
| flags = (hb_buffer_flags_t) (flags & ~HB_BUFFER_FLAG_BOT); |
| if (text_end < num_chars) |
| flags = (hb_buffer_flags_t) (flags & ~HB_BUFFER_FLAG_EOT); |
| hb_buffer_set_flags (fragment, flags); |
| |
| hb_buffer_append (fragment, text_buffer, text_start, text_end); |
| if (!hb_shape_full (font, fragment, features, num_features, shapers)) |
| { |
| buffer_verify_error (buffer, font, BUFFER_VERIFY_ERROR "shaping failed while shaping fragment."); |
| hb_buffer_destroy (reconstruction); |
| hb_buffer_destroy (fragment); |
| return false; |
| } |
| else if (!fragment->successful || fragment->shaping_failed) |
| { |
| hb_buffer_destroy (reconstruction); |
| hb_buffer_destroy (fragment); |
| return true; |
| } |
| hb_buffer_append (reconstruction, fragment, 0, -1); |
| |
| start = end; |
| if (forward) |
| text_start = text_end; |
| else |
| text_end = text_start; |
| } |
| |
| bool ret = true; |
| hb_buffer_diff_flags_t diff = hb_buffer_diff (reconstruction, buffer, (hb_codepoint_t) -1, 0); |
| if (diff) |
| { |
| buffer_verify_error (buffer, font, BUFFER_VERIFY_ERROR "unsafe-to-break test failed."); |
| ret = false; |
| |
| /* Return the reconstructed result instead so it can be inspected. */ |
| hb_buffer_set_length (buffer, 0); |
| hb_buffer_append (buffer, reconstruction, 0, -1); |
| } |
| |
| hb_buffer_destroy (reconstruction); |
| hb_buffer_destroy (fragment); |
| |
| return ret; |
| } |
| |
| static bool |
| buffer_verify_unsafe_to_concat (hb_buffer_t *buffer, |
| hb_buffer_t *text_buffer, |
| hb_font_t *font, |
| const hb_feature_t *features, |
| unsigned int num_features, |
| const char * const *shapers) |
| { |
| if (buffer->cluster_level != HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES && |
| buffer->cluster_level != HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS) |
| { |
| /* Cannot perform this check without monotone clusters. */ |
| return true; |
| } |
| |
| /* Check that shuffling up text before shaping at safe-to-concat points |
| * is indeed safe. */ |
| |
| /* This is what we do: |
| * |
| * 1. We shape text once. Then segment the text at all the safe-to-concat |
| * points; |
| * |
| * 2. Then we create two buffers, one containing all the even segments and |
| * one all the odd segments. |
| * |
| * 3. Because all these segments were safe-to-concat at both ends, we |
| * expect that concatenating them and shaping should NOT change the |
| * shaping results of each segment. As such, we expect that after |
| * shaping the two buffers, we still get cluster boundaries at the |
| * segment boundaries, and that those all are safe-to-concat points. |
| * Moreover, that there are NOT any safe-to-concat points within the |
| * segments. |
| * |
| * 4. Finally, we reconstruct the shaping results of the original text by |
| * simply interleaving the shaping results of the segments from the two |
| * buffers, and assert that the total shaping results is the same as |
| * the one from original buffer in step 1. |
| */ |
| |
| hb_buffer_t *fragments[2] {hb_buffer_create_similar (buffer), |
| hb_buffer_create_similar (buffer)}; |
| hb_buffer_set_flags (fragments[0], (hb_buffer_flags_t (hb_buffer_get_flags (fragments[0]) & ~HB_BUFFER_FLAG_VERIFY))); |
| hb_buffer_set_flags (fragments[1], (hb_buffer_flags_t (hb_buffer_get_flags (fragments[1]) & ~HB_BUFFER_FLAG_VERIFY))); |
| hb_buffer_t *reconstruction = hb_buffer_create_similar (buffer); |
| hb_buffer_set_flags (reconstruction, (hb_buffer_flags_t (hb_buffer_get_flags (reconstruction) & ~HB_BUFFER_FLAG_VERIFY))); |
| hb_segment_properties_t props; |
| hb_buffer_get_segment_properties (buffer, &props); |
| hb_buffer_set_segment_properties (fragments[0], &props); |
| hb_buffer_set_segment_properties (fragments[1], &props); |
| hb_buffer_set_segment_properties (reconstruction, &props); |
| |
| unsigned num_glyphs; |
| hb_glyph_info_t *info = hb_buffer_get_glyph_infos (buffer, &num_glyphs); |
| |
| unsigned num_chars; |
| hb_glyph_info_t *text = hb_buffer_get_glyph_infos (text_buffer, &num_chars); |
| |
| bool forward = HB_DIRECTION_IS_FORWARD (hb_buffer_get_direction (buffer)); |
| |
| if (!forward) |
| hb_buffer_reverse (buffer); |
| |
| /* |
| * Split text into segments and collect into to fragment streams. |
| */ |
| { |
| unsigned fragment_idx = 0; |
| unsigned start = 0; |
| unsigned text_start = 0; |
| unsigned text_end = 0; |
| for (unsigned end = 1; end < num_glyphs + 1; end++) |
| { |
| if (end < num_glyphs && |
| (info[end].cluster == info[end-1].cluster || |
| info[end].mask & HB_GLYPH_FLAG_UNSAFE_TO_CONCAT)) |
| continue; |
| |
| /* Accumulate segment corresponding to glyphs start..end. */ |
| if (end == num_glyphs) |
| text_end = num_chars; |
| else |
| { |
| unsigned cluster = info[end].cluster; |
| while (text_end < num_chars && text[text_end].cluster < cluster) |
| text_end++; |
| } |
| assert (text_start < text_end); |
| |
| if (0) |
| printf("start %d end %d text start %d end %d\n", start, end, text_start, text_end); |
| |
| #if 0 |
| hb_buffer_flags_t flags = hb_buffer_get_flags (fragment); |
| if (0 < text_start) |
| flags = (hb_buffer_flags_t) (flags & ~HB_BUFFER_FLAG_BOT); |
| if (text_end < num_chars) |
| flags = (hb_buffer_flags_t) (flags & ~HB_BUFFER_FLAG_EOT); |
| hb_buffer_set_flags (fragment, flags); |
| #endif |
| |
| hb_buffer_append (fragments[fragment_idx], text_buffer, text_start, text_end); |
| |
| start = end; |
| text_start = text_end; |
| fragment_idx = 1 - fragment_idx; |
| } |
| } |
| |
| bool ret = true; |
| hb_buffer_diff_flags_t diff; |
| |
| /* |
| * Shape the two fragment streams. |
| */ |
| if (!hb_shape_full (font, fragments[0], features, num_features, shapers)) |
| { |
| buffer_verify_error (buffer, font, BUFFER_VERIFY_ERROR "shaping failed while shaping fragment."); |
| ret = false; |
| goto out; |
| } |
| else if (!fragments[0]->successful || fragments[0]->shaping_failed) |
| { |
| ret = true; |
| goto out; |
| } |
| if (!hb_shape_full (font, fragments[1], features, num_features, shapers)) |
| { |
| buffer_verify_error (buffer, font, BUFFER_VERIFY_ERROR "shaping failed while shaping fragment."); |
| ret = false; |
| goto out; |
| } |
| else if (!fragments[1]->successful || fragments[1]->shaping_failed) |
| { |
| ret = true; |
| goto out; |
| } |
| |
| if (!forward) |
| { |
| hb_buffer_reverse (fragments[0]); |
| hb_buffer_reverse (fragments[1]); |
| } |
| |
| /* |
| * Reconstruct results. |
| */ |
| { |
| unsigned fragment_idx = 0; |
| unsigned fragment_start[2] {0, 0}; |
| unsigned fragment_num_glyphs[2]; |
| hb_glyph_info_t *fragment_info[2]; |
| for (unsigned i = 0; i < 2; i++) |
| fragment_info[i] = hb_buffer_get_glyph_infos (fragments[i], &fragment_num_glyphs[i]); |
| while (fragment_start[0] < fragment_num_glyphs[0] || |
| fragment_start[1] < fragment_num_glyphs[1]) |
| { |
| unsigned fragment_end = fragment_start[fragment_idx] + 1; |
| while (fragment_end < fragment_num_glyphs[fragment_idx] && |
| (fragment_info[fragment_idx][fragment_end].cluster == fragment_info[fragment_idx][fragment_end - 1].cluster || |
| fragment_info[fragment_idx][fragment_end].mask & HB_GLYPH_FLAG_UNSAFE_TO_CONCAT)) |
| fragment_end++; |
| |
| hb_buffer_append (reconstruction, fragments[fragment_idx], fragment_start[fragment_idx], fragment_end); |
| |
| fragment_start[fragment_idx] = fragment_end; |
| fragment_idx = 1 - fragment_idx; |
| } |
| } |
| |
| if (!forward) |
| { |
| hb_buffer_reverse (buffer); |
| hb_buffer_reverse (reconstruction); |
| } |
| |
| /* |
| * Diff results. |
| */ |
| diff = hb_buffer_diff (reconstruction, buffer, (hb_codepoint_t) -1, 0); |
| if (diff) |
| { |
| buffer_verify_error (buffer, font, BUFFER_VERIFY_ERROR "unsafe-to-concat test failed."); |
| ret = false; |
| |
| /* Return the reconstructed result instead so it can be inspected. */ |
| hb_buffer_set_length (buffer, 0); |
| hb_buffer_append (buffer, reconstruction, 0, -1); |
| } |
| |
| |
| out: |
| hb_buffer_destroy (reconstruction); |
| hb_buffer_destroy (fragments[0]); |
| hb_buffer_destroy (fragments[1]); |
| |
| return ret; |
| } |
| |
| bool |
| hb_buffer_t::verify (hb_buffer_t *text_buffer, |
| hb_font_t *font, |
| const hb_feature_t *features, |
| unsigned int num_features, |
| const char * const *shapers) |
| { |
| bool ret = true; |
| if (!buffer_verify_monotone (this, font)) |
| ret = false; |
| if (!buffer_verify_unsafe_to_break (this, text_buffer, font, features, num_features, shapers)) |
| ret = false; |
| if ((flags & HB_BUFFER_FLAG_PRODUCE_UNSAFE_TO_CONCAT) != 0 && |
| !buffer_verify_unsafe_to_concat (this, text_buffer, font, features, num_features, shapers)) |
| ret = false; |
| if (!ret) |
| { |
| #ifndef HB_NO_BUFFER_SERIALIZE |
| unsigned len = text_buffer->len; |
| hb_vector_t<char> bytes; |
| if (likely (bytes.resize (len * 10 + 16))) |
| { |
| hb_buffer_serialize_unicode (text_buffer, |
| 0, len, |
| bytes.arrayZ, bytes.length, |
| &len, |
| HB_BUFFER_SERIALIZE_FORMAT_TEXT, |
| HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS); |
| buffer_verify_error (this, font, BUFFER_VERIFY_ERROR "text was: %s.", bytes.arrayZ); |
| } |
| #endif |
| } |
| return ret; |
| } |
| |
| |
| #endif |