Behdad Esfahbod | 6182383 | 2022-01-28 13:45:25 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright © 2022 Behdad Esfahbod |
| 3 | * |
| 4 | * This is part of HarfBuzz, a text shaping library. |
| 5 | * |
| 6 | * Permission is hereby granted, without written agreement and without |
| 7 | * license or royalty fees, to use, copy, modify, and distribute this |
| 8 | * software and its documentation for any purpose, provided that the |
| 9 | * above copyright notice and the following two paragraphs appear in |
| 10 | * all copies of this software. |
| 11 | * |
| 12 | * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR |
| 13 | * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES |
| 14 | * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN |
| 15 | * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH |
| 16 | * DAMAGE. |
| 17 | * |
| 18 | * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, |
| 19 | * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND |
| 20 | * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS |
| 21 | * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO |
| 22 | * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS. |
| 23 | * |
| 24 | * Google Author(s): Behdad Esfahbod |
| 25 | */ |
| 26 | |
| 27 | #include "hb.hh" |
| 28 | |
| 29 | #ifndef HB_NO_BUFFER_VERIFY |
| 30 | |
| 31 | #include "hb-buffer.hh" |
| 32 | |
| 33 | |
Behdad Esfahbod | e986c12 | 2022-01-29 09:08:48 -0700 | [diff] [blame] | 34 | #define BUFFER_VERIFY_ERROR "buffer verify error: " |
Behdad Esfahbod | 6182383 | 2022-01-28 13:45:25 -0700 | [diff] [blame] | 35 | static inline void |
| 36 | buffer_verify_error (hb_buffer_t *buffer, |
| 37 | hb_font_t *font, |
Behdad Esfahbod | e986c12 | 2022-01-29 09:08:48 -0700 | [diff] [blame] | 38 | const char *fmt, |
| 39 | ...) HB_PRINTF_FUNC(3, 4); |
| 40 | |
| 41 | static inline void |
| 42 | buffer_verify_error (hb_buffer_t *buffer, |
| 43 | hb_font_t *font, |
| 44 | const char *fmt, |
| 45 | ...) |
Behdad Esfahbod | 6182383 | 2022-01-28 13:45:25 -0700 | [diff] [blame] | 46 | { |
Behdad Esfahbod | e986c12 | 2022-01-29 09:08:48 -0700 | [diff] [blame] | 47 | va_list ap; |
| 48 | va_start (ap, fmt); |
Behdad Esfahbod | 6182383 | 2022-01-28 13:45:25 -0700 | [diff] [blame] | 49 | if (buffer->messaging ()) |
Behdad Esfahbod | e986c12 | 2022-01-29 09:08:48 -0700 | [diff] [blame] | 50 | { |
| 51 | buffer->message_impl (font, fmt, ap); |
| 52 | } |
Behdad Esfahbod | 6182383 | 2022-01-28 13:45:25 -0700 | [diff] [blame] | 53 | else |
Behdad Esfahbod | e986c12 | 2022-01-29 09:08:48 -0700 | [diff] [blame] | 54 | { |
| 55 | fprintf (stderr, "harfbuzz "); |
| 56 | vfprintf (stderr, fmt, ap); |
| 57 | fprintf (stderr, "\n"); |
| 58 | } |
| 59 | va_end (ap); |
Behdad Esfahbod | 6182383 | 2022-01-28 13:45:25 -0700 | [diff] [blame] | 60 | } |
| 61 | |
| 62 | static bool |
| 63 | buffer_verify_monotone (hb_buffer_t *buffer, |
| 64 | hb_font_t *font) |
| 65 | { |
| 66 | /* Check that clusters are monotone. */ |
| 67 | if (buffer->cluster_level == HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES || |
| 68 | buffer->cluster_level == HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS) |
| 69 | { |
| 70 | bool is_forward = HB_DIRECTION_IS_FORWARD (hb_buffer_get_direction (buffer)); |
| 71 | |
| 72 | unsigned int num_glyphs; |
| 73 | hb_glyph_info_t *info = hb_buffer_get_glyph_infos (buffer, &num_glyphs); |
| 74 | |
| 75 | for (unsigned int i = 1; i < num_glyphs; i++) |
| 76 | if (info[i-1].cluster != info[i].cluster && |
| 77 | (info[i-1].cluster < info[i].cluster) != is_forward) |
| 78 | { |
Behdad Esfahbod | e986c12 | 2022-01-29 09:08:48 -0700 | [diff] [blame] | 79 | buffer_verify_error (buffer, font, BUFFER_VERIFY_ERROR "clusters are not monotone."); |
Behdad Esfahbod | 6182383 | 2022-01-28 13:45:25 -0700 | [diff] [blame] | 80 | return false; |
| 81 | } |
| 82 | } |
| 83 | |
| 84 | return true; |
| 85 | } |
| 86 | |
| 87 | static bool |
| 88 | buffer_verify_unsafe_to_break (hb_buffer_t *buffer, |
| 89 | hb_buffer_t *text_buffer, |
| 90 | hb_font_t *font, |
| 91 | const hb_feature_t *features, |
| 92 | unsigned int num_features, |
| 93 | const char * const *shapers) |
| 94 | { |
| 95 | if (buffer->cluster_level != HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES && |
| 96 | buffer->cluster_level != HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS) |
| 97 | { |
| 98 | /* Cannot perform this check without monotone clusters. */ |
| 99 | return true; |
| 100 | } |
| 101 | |
| 102 | /* Check that breaking up shaping at safe-to-break is indeed safe. */ |
| 103 | |
| 104 | hb_buffer_t *fragment = hb_buffer_create_similar (buffer); |
Behdad Esfahbod | 45a2252 | 2022-05-31 06:23:47 -0600 | [diff] [blame] | 105 | hb_buffer_set_flags (fragment, (hb_buffer_flags_t (hb_buffer_get_flags (fragment) & ~HB_BUFFER_FLAG_VERIFY))); |
Behdad Esfahbod | 6182383 | 2022-01-28 13:45:25 -0700 | [diff] [blame] | 106 | hb_buffer_t *reconstruction = hb_buffer_create_similar (buffer); |
Behdad Esfahbod | 45a2252 | 2022-05-31 06:23:47 -0600 | [diff] [blame] | 107 | hb_buffer_set_flags (reconstruction, (hb_buffer_flags_t (hb_buffer_get_flags (reconstruction) & ~HB_BUFFER_FLAG_VERIFY))); |
Behdad Esfahbod | 6182383 | 2022-01-28 13:45:25 -0700 | [diff] [blame] | 108 | |
| 109 | unsigned int num_glyphs; |
| 110 | hb_glyph_info_t *info = hb_buffer_get_glyph_infos (buffer, &num_glyphs); |
| 111 | |
| 112 | unsigned int num_chars; |
| 113 | hb_glyph_info_t *text = hb_buffer_get_glyph_infos (text_buffer, &num_chars); |
| 114 | |
| 115 | /* Chop text and shape fragments. */ |
| 116 | bool forward = HB_DIRECTION_IS_FORWARD (hb_buffer_get_direction (buffer)); |
| 117 | unsigned int start = 0; |
| 118 | unsigned int text_start = forward ? 0 : num_chars; |
| 119 | unsigned int text_end = text_start; |
| 120 | for (unsigned int end = 1; end < num_glyphs + 1; end++) |
| 121 | { |
| 122 | if (end < num_glyphs && |
| 123 | (info[end].cluster == info[end-1].cluster || |
| 124 | info[end-(forward?0:1)].mask & HB_GLYPH_FLAG_UNSAFE_TO_BREAK)) |
| 125 | continue; |
| 126 | |
| 127 | /* Shape segment corresponding to glyphs start..end. */ |
| 128 | if (end == num_glyphs) |
| 129 | { |
| 130 | if (forward) |
| 131 | text_end = num_chars; |
| 132 | else |
| 133 | text_start = 0; |
| 134 | } |
| 135 | else |
| 136 | { |
| 137 | if (forward) |
| 138 | { |
| 139 | unsigned int cluster = info[end].cluster; |
| 140 | while (text_end < num_chars && text[text_end].cluster < cluster) |
| 141 | text_end++; |
| 142 | } |
| 143 | else |
| 144 | { |
| 145 | unsigned int cluster = info[end - 1].cluster; |
| 146 | while (text_start && text[text_start - 1].cluster >= cluster) |
| 147 | text_start--; |
| 148 | } |
| 149 | } |
| 150 | assert (text_start < text_end); |
| 151 | |
| 152 | if (0) |
Behdad Esfahbod | ed023f6 | 2023-01-12 17:04:24 -0700 | [diff] [blame] | 153 | printf("start %u end %u text start %u end %u\n", start, end, text_start, text_end); |
Behdad Esfahbod | 6182383 | 2022-01-28 13:45:25 -0700 | [diff] [blame] | 154 | |
| 155 | hb_buffer_clear_contents (fragment); |
| 156 | |
| 157 | hb_buffer_flags_t flags = hb_buffer_get_flags (fragment); |
| 158 | if (0 < text_start) |
| 159 | flags = (hb_buffer_flags_t) (flags & ~HB_BUFFER_FLAG_BOT); |
| 160 | if (text_end < num_chars) |
| 161 | flags = (hb_buffer_flags_t) (flags & ~HB_BUFFER_FLAG_EOT); |
| 162 | hb_buffer_set_flags (fragment, flags); |
| 163 | |
| 164 | hb_buffer_append (fragment, text_buffer, text_start, text_end); |
Behdad Esfahbod | c85ca75 | 2023-06-08 15:57:49 -0600 | [diff] [blame] | 165 | if (!hb_shape_full (font, fragment, features, num_features, shapers) || |
| 166 | fragment->successful || fragment->shaping_failed) |
Behdad Esfahbod | 0384f80 | 2022-05-31 08:23:48 -0600 | [diff] [blame] | 167 | { |
| 168 | hb_buffer_destroy (reconstruction); |
| 169 | hb_buffer_destroy (fragment); |
| 170 | return true; |
| 171 | } |
Behdad Esfahbod | 6182383 | 2022-01-28 13:45:25 -0700 | [diff] [blame] | 172 | hb_buffer_append (reconstruction, fragment, 0, -1); |
| 173 | |
| 174 | start = end; |
| 175 | if (forward) |
| 176 | text_start = text_end; |
| 177 | else |
| 178 | text_end = text_start; |
| 179 | } |
| 180 | |
| 181 | bool ret = true; |
Behdad Esfahbod | cb51607 | 2023-06-08 15:50:53 -0600 | [diff] [blame] | 182 | if (likely (reconstruction->successful)) |
Behdad Esfahbod | 6182383 | 2022-01-28 13:45:25 -0700 | [diff] [blame] | 183 | { |
Behdad Esfahbod | cb51607 | 2023-06-08 15:50:53 -0600 | [diff] [blame] | 184 | hb_buffer_diff_flags_t diff = hb_buffer_diff (reconstruction, buffer, (hb_codepoint_t) -1, 0); |
| 185 | if (diff & ~HB_BUFFER_DIFF_FLAG_GLYPH_FLAGS_MISMATCH) |
| 186 | { |
| 187 | buffer_verify_error (buffer, font, BUFFER_VERIFY_ERROR "unsafe-to-break test failed."); |
| 188 | ret = false; |
Behdad Esfahbod | 6182383 | 2022-01-28 13:45:25 -0700 | [diff] [blame] | 189 | |
Behdad Esfahbod | cb51607 | 2023-06-08 15:50:53 -0600 | [diff] [blame] | 190 | /* Return the reconstructed result instead so it can be inspected. */ |
| 191 | hb_buffer_set_length (buffer, 0); |
| 192 | hb_buffer_append (buffer, reconstruction, 0, -1); |
| 193 | } |
Behdad Esfahbod | 6182383 | 2022-01-28 13:45:25 -0700 | [diff] [blame] | 194 | } |
| 195 | |
| 196 | hb_buffer_destroy (reconstruction); |
| 197 | hb_buffer_destroy (fragment); |
| 198 | |
| 199 | return ret; |
| 200 | } |
| 201 | |
| 202 | static bool |
| 203 | buffer_verify_unsafe_to_concat (hb_buffer_t *buffer, |
| 204 | hb_buffer_t *text_buffer, |
| 205 | hb_font_t *font, |
| 206 | const hb_feature_t *features, |
| 207 | unsigned int num_features, |
| 208 | const char * const *shapers) |
| 209 | { |
| 210 | if (buffer->cluster_level != HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES && |
| 211 | buffer->cluster_level != HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS) |
| 212 | { |
| 213 | /* Cannot perform this check without monotone clusters. */ |
| 214 | return true; |
| 215 | } |
| 216 | |
| 217 | /* Check that shuffling up text before shaping at safe-to-concat points |
| 218 | * is indeed safe. */ |
| 219 | |
| 220 | /* This is what we do: |
| 221 | * |
| 222 | * 1. We shape text once. Then segment the text at all the safe-to-concat |
| 223 | * points; |
| 224 | * |
| 225 | * 2. Then we create two buffers, one containing all the even segments and |
| 226 | * one all the odd segments. |
| 227 | * |
| 228 | * 3. Because all these segments were safe-to-concat at both ends, we |
| 229 | * expect that concatenating them and shaping should NOT change the |
| 230 | * shaping results of each segment. As such, we expect that after |
| 231 | * shaping the two buffers, we still get cluster boundaries at the |
| 232 | * segment boundaries, and that those all are safe-to-concat points. |
| 233 | * Moreover, that there are NOT any safe-to-concat points within the |
| 234 | * segments. |
| 235 | * |
| 236 | * 4. Finally, we reconstruct the shaping results of the original text by |
| 237 | * simply interleaving the shaping results of the segments from the two |
| 238 | * buffers, and assert that the total shaping results is the same as |
| 239 | * the one from original buffer in step 1. |
| 240 | */ |
| 241 | |
| 242 | hb_buffer_t *fragments[2] {hb_buffer_create_similar (buffer), |
| 243 | hb_buffer_create_similar (buffer)}; |
Behdad Esfahbod | 45a2252 | 2022-05-31 06:23:47 -0600 | [diff] [blame] | 244 | hb_buffer_set_flags (fragments[0], (hb_buffer_flags_t (hb_buffer_get_flags (fragments[0]) & ~HB_BUFFER_FLAG_VERIFY))); |
| 245 | hb_buffer_set_flags (fragments[1], (hb_buffer_flags_t (hb_buffer_get_flags (fragments[1]) & ~HB_BUFFER_FLAG_VERIFY))); |
Behdad Esfahbod | 6182383 | 2022-01-28 13:45:25 -0700 | [diff] [blame] | 246 | hb_buffer_t *reconstruction = hb_buffer_create_similar (buffer); |
Behdad Esfahbod | 45a2252 | 2022-05-31 06:23:47 -0600 | [diff] [blame] | 247 | hb_buffer_set_flags (reconstruction, (hb_buffer_flags_t (hb_buffer_get_flags (reconstruction) & ~HB_BUFFER_FLAG_VERIFY))); |
Behdad Esfahbod | 6182383 | 2022-01-28 13:45:25 -0700 | [diff] [blame] | 248 | hb_segment_properties_t props; |
| 249 | hb_buffer_get_segment_properties (buffer, &props); |
| 250 | hb_buffer_set_segment_properties (fragments[0], &props); |
| 251 | hb_buffer_set_segment_properties (fragments[1], &props); |
| 252 | hb_buffer_set_segment_properties (reconstruction, &props); |
| 253 | |
| 254 | unsigned num_glyphs; |
| 255 | hb_glyph_info_t *info = hb_buffer_get_glyph_infos (buffer, &num_glyphs); |
| 256 | |
| 257 | unsigned num_chars; |
| 258 | hb_glyph_info_t *text = hb_buffer_get_glyph_infos (text_buffer, &num_chars); |
| 259 | |
| 260 | bool forward = HB_DIRECTION_IS_FORWARD (hb_buffer_get_direction (buffer)); |
| 261 | |
| 262 | if (!forward) |
| 263 | hb_buffer_reverse (buffer); |
| 264 | |
| 265 | /* |
| 266 | * Split text into segments and collect into to fragment streams. |
| 267 | */ |
| 268 | { |
| 269 | unsigned fragment_idx = 0; |
| 270 | unsigned start = 0; |
| 271 | unsigned text_start = 0; |
| 272 | unsigned text_end = 0; |
| 273 | for (unsigned end = 1; end < num_glyphs + 1; end++) |
| 274 | { |
| 275 | if (end < num_glyphs && |
| 276 | (info[end].cluster == info[end-1].cluster || |
| 277 | info[end].mask & HB_GLYPH_FLAG_UNSAFE_TO_CONCAT)) |
| 278 | continue; |
| 279 | |
| 280 | /* Accumulate segment corresponding to glyphs start..end. */ |
| 281 | if (end == num_glyphs) |
| 282 | text_end = num_chars; |
| 283 | else |
| 284 | { |
| 285 | unsigned cluster = info[end].cluster; |
| 286 | while (text_end < num_chars && text[text_end].cluster < cluster) |
| 287 | text_end++; |
| 288 | } |
| 289 | assert (text_start < text_end); |
| 290 | |
| 291 | if (0) |
Behdad Esfahbod | ed023f6 | 2023-01-12 17:04:24 -0700 | [diff] [blame] | 292 | printf("start %u end %u text start %u end %u\n", start, end, text_start, text_end); |
Behdad Esfahbod | 6182383 | 2022-01-28 13:45:25 -0700 | [diff] [blame] | 293 | |
| 294 | #if 0 |
| 295 | hb_buffer_flags_t flags = hb_buffer_get_flags (fragment); |
| 296 | if (0 < text_start) |
| 297 | flags = (hb_buffer_flags_t) (flags & ~HB_BUFFER_FLAG_BOT); |
| 298 | if (text_end < num_chars) |
| 299 | flags = (hb_buffer_flags_t) (flags & ~HB_BUFFER_FLAG_EOT); |
| 300 | hb_buffer_set_flags (fragment, flags); |
| 301 | #endif |
| 302 | |
| 303 | hb_buffer_append (fragments[fragment_idx], text_buffer, text_start, text_end); |
| 304 | |
| 305 | start = end; |
| 306 | text_start = text_end; |
| 307 | fragment_idx = 1 - fragment_idx; |
| 308 | } |
| 309 | } |
| 310 | |
| 311 | bool ret = true; |
| 312 | hb_buffer_diff_flags_t diff; |
Behdad Esfahbod | 6182383 | 2022-01-28 13:45:25 -0700 | [diff] [blame] | 313 | /* |
| 314 | * Shape the two fragment streams. |
| 315 | */ |
Behdad Esfahbod | c85ca75 | 2023-06-08 15:57:49 -0600 | [diff] [blame] | 316 | if (!hb_shape_full (font, fragments[0], features, num_features, shapers) || |
| 317 | !fragments[0]->successful || fragments[0]->shaping_failed) |
Behdad Esfahbod | 0384f80 | 2022-05-31 08:23:48 -0600 | [diff] [blame] | 318 | goto out; |
Behdad Esfahbod | e527c17 | 2023-06-08 15:56:12 -0600 | [diff] [blame] | 319 | |
Behdad Esfahbod | c85ca75 | 2023-06-08 15:57:49 -0600 | [diff] [blame] | 320 | if (!hb_shape_full (font, fragments[1], features, num_features, shapers) || |
| 321 | !fragments[1]->successful || fragments[1]->shaping_failed) |
Behdad Esfahbod | 0384f80 | 2022-05-31 08:23:48 -0600 | [diff] [blame] | 322 | goto out; |
Behdad Esfahbod | 6182383 | 2022-01-28 13:45:25 -0700 | [diff] [blame] | 323 | |
| 324 | if (!forward) |
| 325 | { |
| 326 | hb_buffer_reverse (fragments[0]); |
| 327 | hb_buffer_reverse (fragments[1]); |
| 328 | } |
| 329 | |
| 330 | /* |
| 331 | * Reconstruct results. |
| 332 | */ |
| 333 | { |
| 334 | unsigned fragment_idx = 0; |
| 335 | unsigned fragment_start[2] {0, 0}; |
| 336 | unsigned fragment_num_glyphs[2]; |
| 337 | hb_glyph_info_t *fragment_info[2]; |
| 338 | for (unsigned i = 0; i < 2; i++) |
| 339 | fragment_info[i] = hb_buffer_get_glyph_infos (fragments[i], &fragment_num_glyphs[i]); |
| 340 | while (fragment_start[0] < fragment_num_glyphs[0] || |
| 341 | fragment_start[1] < fragment_num_glyphs[1]) |
| 342 | { |
| 343 | unsigned fragment_end = fragment_start[fragment_idx] + 1; |
| 344 | while (fragment_end < fragment_num_glyphs[fragment_idx] && |
| 345 | (fragment_info[fragment_idx][fragment_end].cluster == fragment_info[fragment_idx][fragment_end - 1].cluster || |
| 346 | fragment_info[fragment_idx][fragment_end].mask & HB_GLYPH_FLAG_UNSAFE_TO_CONCAT)) |
| 347 | fragment_end++; |
| 348 | |
| 349 | hb_buffer_append (reconstruction, fragments[fragment_idx], fragment_start[fragment_idx], fragment_end); |
| 350 | |
| 351 | fragment_start[fragment_idx] = fragment_end; |
| 352 | fragment_idx = 1 - fragment_idx; |
| 353 | } |
| 354 | } |
| 355 | |
| 356 | if (!forward) |
| 357 | { |
| 358 | hb_buffer_reverse (buffer); |
| 359 | hb_buffer_reverse (reconstruction); |
| 360 | } |
| 361 | |
Behdad Esfahbod | cb51607 | 2023-06-08 15:50:53 -0600 | [diff] [blame] | 362 | if (likely (reconstruction->successful)) |
Behdad Esfahbod | 6182383 | 2022-01-28 13:45:25 -0700 | [diff] [blame] | 363 | { |
Behdad Esfahbod | cb51607 | 2023-06-08 15:50:53 -0600 | [diff] [blame] | 364 | /* |
| 365 | * Diff results. |
| 366 | */ |
| 367 | diff = hb_buffer_diff (reconstruction, buffer, (hb_codepoint_t) -1, 0); |
| 368 | if (diff & ~HB_BUFFER_DIFF_FLAG_GLYPH_FLAGS_MISMATCH) |
| 369 | { |
| 370 | buffer_verify_error (buffer, font, BUFFER_VERIFY_ERROR "unsafe-to-concat test failed."); |
| 371 | ret = false; |
Behdad Esfahbod | 6182383 | 2022-01-28 13:45:25 -0700 | [diff] [blame] | 372 | |
Behdad Esfahbod | cb51607 | 2023-06-08 15:50:53 -0600 | [diff] [blame] | 373 | /* Return the reconstructed result instead so it can be inspected. */ |
| 374 | hb_buffer_set_length (buffer, 0); |
| 375 | hb_buffer_append (buffer, reconstruction, 0, -1); |
| 376 | } |
Behdad Esfahbod | 6182383 | 2022-01-28 13:45:25 -0700 | [diff] [blame] | 377 | } |
| 378 | |
Behdad Esfahbod | 6182383 | 2022-01-28 13:45:25 -0700 | [diff] [blame] | 379 | out: |
| 380 | hb_buffer_destroy (reconstruction); |
| 381 | hb_buffer_destroy (fragments[0]); |
| 382 | hb_buffer_destroy (fragments[1]); |
| 383 | |
| 384 | return ret; |
| 385 | } |
| 386 | |
| 387 | bool |
| 388 | hb_buffer_t::verify (hb_buffer_t *text_buffer, |
| 389 | hb_font_t *font, |
| 390 | const hb_feature_t *features, |
| 391 | unsigned int num_features, |
| 392 | const char * const *shapers) |
| 393 | { |
| 394 | bool ret = true; |
| 395 | if (!buffer_verify_monotone (this, font)) |
| 396 | ret = false; |
| 397 | if (!buffer_verify_unsafe_to_break (this, text_buffer, font, features, num_features, shapers)) |
| 398 | ret = false; |
Behdad Esfahbod | 56f11ec | 2022-02-18 14:08:43 -0600 | [diff] [blame] | 399 | if ((flags & HB_BUFFER_FLAG_PRODUCE_UNSAFE_TO_CONCAT) != 0 && |
| 400 | !buffer_verify_unsafe_to_concat (this, text_buffer, font, features, num_features, shapers)) |
Behdad Esfahbod | 6182383 | 2022-01-28 13:45:25 -0700 | [diff] [blame] | 401 | ret = false; |
Behdad Esfahbod | e986c12 | 2022-01-29 09:08:48 -0700 | [diff] [blame] | 402 | if (!ret) |
| 403 | { |
Behdad Esfahbod | cb961ea | 2022-06-05 00:44:07 -0600 | [diff] [blame] | 404 | #ifndef HB_NO_BUFFER_SERIALIZE |
Behdad Esfahbod | e986c12 | 2022-01-29 09:08:48 -0700 | [diff] [blame] | 405 | unsigned len = text_buffer->len; |
| 406 | hb_vector_t<char> bytes; |
| 407 | if (likely (bytes.resize (len * 10 + 16))) |
| 408 | { |
| 409 | hb_buffer_serialize_unicode (text_buffer, |
| 410 | 0, len, |
| 411 | bytes.arrayZ, bytes.length, |
| 412 | &len, |
| 413 | HB_BUFFER_SERIALIZE_FORMAT_TEXT, |
| 414 | HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS); |
| 415 | buffer_verify_error (this, font, BUFFER_VERIFY_ERROR "text was: %s.", bytes.arrayZ); |
| 416 | } |
Behdad Esfahbod | cb961ea | 2022-06-05 00:44:07 -0600 | [diff] [blame] | 417 | #endif |
Behdad Esfahbod | e986c12 | 2022-01-29 09:08:48 -0700 | [diff] [blame] | 418 | } |
Behdad Esfahbod | 6182383 | 2022-01-28 13:45:25 -0700 | [diff] [blame] | 419 | return ret; |
| 420 | } |
| 421 | |
| 422 | |
| 423 | #endif |