src/hb-buffer-verify.cc

   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
  34 #define BUFFER_VERIFY_ERROR "buffer verify error: "
  35 static inline void
  36 buffer_verify_error (hb_buffer_t *buffer,
  37                      hb_font_t *font,
  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                      ...)
  46 {
  47   va_list ap;
  48   va_start (ap, fmt);
  49   if (buffer->messaging ())
  50   {
  51     buffer->message_impl (font, fmt, ap);
  52   }
  53   else
  54   {
  55     fprintf (stderr, "harfbuzz ");
  56     vfprintf (stderr, fmt, ap);
  57     fprintf (stderr, "\n");
  58   }
  59   va_end (ap);
  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       {
  79         buffer_verify_error (buffer, font, BUFFER_VERIFY_ERROR "clusters are not monotone.");
  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);
 105   hb_buffer_set_flags (fragment, hb_buffer_get_flags (fragment) & ~HB_BUFFER_FLAG_VERIFY);
 106   hb_buffer_t *reconstruction = hb_buffer_create_similar (buffer);
 107   hb_buffer_set_flags (reconstruction, hb_buffer_get_flags (reconstruction) & ~HB_BUFFER_FLAG_VERIFY);
 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)
 153       printf("start %d end %d text start %d end %d\n", start, end, text_start, text_end);
 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);
 165     if (!hb_shape_full (font, fragment, features, num_features, shapers))
 166     {
 167       buffer_verify_error (buffer, font, BUFFER_VERIFY_ERROR "shaping failed while shaping fragment.");
 168       hb_buffer_destroy (reconstruction);
 169       hb_buffer_destroy (fragment);
 170       return false;
 171     }
 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;
 182   hb_buffer_diff_flags_t diff = hb_buffer_diff (reconstruction, buffer, (hb_codepoint_t) -1, 0);
 183   if (diff)
 184   {
 185     buffer_verify_error (buffer, font, BUFFER_VERIFY_ERROR "unsafe-to-break test failed.");
 186     ret = false;
 187
 188     /* Return the reconstructed result instead so it can be inspected. */
 189     hb_buffer_set_length (buffer, 0);
 190     hb_buffer_append (buffer, reconstruction, 0, -1);
 191   }
 192
 193   hb_buffer_destroy (reconstruction);
 194   hb_buffer_destroy (fragment);
 195
 196   return ret;
 197 }
 198
 199 static bool
 200 buffer_verify_unsafe_to_concat (hb_buffer_t        *buffer,
 201                                 hb_buffer_t        *text_buffer,
 202                                 hb_font_t          *font,
 203                                 const hb_feature_t *features,
 204                                 unsigned int        num_features,
 205                                 const char * const *shapers)
 206 {
 207   if (buffer->cluster_level != HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES &&
 208       buffer->cluster_level != HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS)
 209   {
 210     /* Cannot perform this check without monotone clusters. */
 211     return true;
 212   }
 213
 214   /* Check that shuffling up text before shaping at safe-to-concat points
 215    * is indeed safe. */
 216
 217   /* This is what we do:
 218    *
 219    * 1. We shape text once. Then segment the text at all the safe-to-concat
 220    *    points;
 221    *
 222    * 2. Then we create two buffers, one containing all the even segments and
 223    *    one all the odd segments.
 224    *
 225    * 3. Because all these segments were safe-to-concat at both ends, we
 226    *    expect that concatenating them and shaping should NOT change the
 227    *    shaping results of each segment.  As such, we expect that after
 228    *    shaping the two buffers, we still get cluster boundaries at the
 229    *    segment boundaries, and that those all are safe-to-concat points.
 230    *    Moreover, that there are NOT any safe-to-concat points within the
 231    *    segments.
 232    *
 233    * 4. Finally, we reconstruct the shaping results of the original text by
 234    *    simply interleaving the shaping results of the segments from the two
 235    *    buffers, and assert that the total shaping results is the same as
 236    *    the one from original buffer in step 1.
 237    */
 238
 239   hb_buffer_t *fragments[2] {hb_buffer_create_similar (buffer),
 240                              hb_buffer_create_similar (buffer)};
 241   hb_buffer_set_flags (fragments[0], hb_buffer_get_flags (fragments[0]) & ~HB_BUFFER_FLAG_VERIFY);
 242   hb_buffer_set_flags (fragments[1], hb_buffer_get_flags (fragments[1]) & ~HB_BUFFER_FLAG_VERIFY);
 243   hb_buffer_t *reconstruction = hb_buffer_create_similar (buffer);
 244   hb_buffer_set_flags (reconstruction, hb_buffer_get_flags (reconstruction) & ~HB_BUFFER_FLAG_VERIFY);
 245   hb_segment_properties_t props;
 246   hb_buffer_get_segment_properties (buffer, &props);
 247   hb_buffer_set_segment_properties (fragments[0], &props);
 248   hb_buffer_set_segment_properties (fragments[1], &props);
 249   hb_buffer_set_segment_properties (reconstruction, &props);
 250
 251   unsigned num_glyphs;
 252   hb_glyph_info_t *info = hb_buffer_get_glyph_infos (buffer, &num_glyphs);
 253
 254   unsigned num_chars;
 255   hb_glyph_info_t *text = hb_buffer_get_glyph_infos (text_buffer, &num_chars);
 256
 257   bool forward = HB_DIRECTION_IS_FORWARD (hb_buffer_get_direction (buffer));
 258
 259   if (!forward)
 260     hb_buffer_reverse (buffer);
 261
 262   /*
 263    * Split text into segments and collect into to fragment streams.
 264    */
 265   {
 266     unsigned fragment_idx = 0;
 267     unsigned start = 0;
 268     unsigned text_start = 0;
 269     unsigned text_end = 0;
 270     for (unsigned end = 1; end < num_glyphs + 1; end++)
 271     {
 272       if (end < num_glyphs &&
 273           (info[end].cluster == info[end-1].cluster ||
 274            info[end].mask & HB_GLYPH_FLAG_UNSAFE_TO_CONCAT))
 275           continue;
 276
 277       /* Accumulate segment corresponding to glyphs start..end. */
 278       if (end == num_glyphs)
 279         text_end = num_chars;
 280       else
 281       {
 282         unsigned cluster = info[end].cluster;
 283         while (text_end < num_chars && text[text_end].cluster < cluster)
 284           text_end++;
 285       }
 286       assert (text_start < text_end);
 287
 288       if (0)
 289         printf("start %d end %d text start %d end %d\n", start, end, text_start, text_end);
 290
 291 #if 0
 292       hb_buffer_flags_t flags = hb_buffer_get_flags (fragment);
 293       if (0 < text_start)
 294         flags = (hb_buffer_flags_t) (flags & ~HB_BUFFER_FLAG_BOT);
 295       if (text_end < num_chars)
 296         flags = (hb_buffer_flags_t) (flags & ~HB_BUFFER_FLAG_EOT);
 297       hb_buffer_set_flags (fragment, flags);
 298 #endif
 299
 300       hb_buffer_append (fragments[fragment_idx], text_buffer, text_start, text_end);
 301
 302       start = end;
 303       text_start = text_end;
 304       fragment_idx = 1 - fragment_idx;
 305     }
 306   }
 307
 308   bool ret = true;
 309   hb_buffer_diff_flags_t diff;
 310
 311   /*
 312    * Shape the two fragment streams.
 313    */
 314   if (!hb_shape_full (font, fragments[0], features, num_features, shapers))
 315   {
 316     buffer_verify_error (buffer, font, BUFFER_VERIFY_ERROR "shaping failed while shaping fragment.");
 317     ret = false;
 318     goto out;
 319   }
 320   if (!hb_shape_full (font, fragments[1], features, num_features, shapers))
 321   {
 322     buffer_verify_error (buffer, font, BUFFER_VERIFY_ERROR "shaping failed while shaping fragment.");
 323     ret = false;
 324     goto out;
 325   }
 326
 327   if (!forward)
 328   {
 329     hb_buffer_reverse (fragments[0]);
 330     hb_buffer_reverse (fragments[1]);
 331   }
 332
 333   /*
 334    * Reconstruct results.
 335    */
 336   {
 337     unsigned fragment_idx = 0;
 338     unsigned fragment_start[2] {0, 0};
 339     unsigned fragment_num_glyphs[2];
 340     hb_glyph_info_t *fragment_info[2];
 341     for (unsigned i = 0; i < 2; i++)
 342       fragment_info[i] = hb_buffer_get_glyph_infos (fragments[i], &fragment_num_glyphs[i]);
 343     while (fragment_start[0] < fragment_num_glyphs[0] ||
 344            fragment_start[1] < fragment_num_glyphs[1])
 345     {
 346       unsigned fragment_end = fragment_start[fragment_idx] + 1;
 347       while (fragment_end < fragment_num_glyphs[fragment_idx] &&
 348              (fragment_info[fragment_idx][fragment_end].cluster == fragment_info[fragment_idx][fragment_end - 1].cluster ||
 349               fragment_info[fragment_idx][fragment_end].mask & HB_GLYPH_FLAG_UNSAFE_TO_CONCAT))
 350         fragment_end++;
 351
 352       hb_buffer_append (reconstruction, fragments[fragment_idx], fragment_start[fragment_idx], fragment_end);
 353
 354       fragment_start[fragment_idx] = fragment_end;
 355       fragment_idx = 1 - fragment_idx;
 356     }
 357   }
 358
 359   if (!forward)
 360   {
 361     hb_buffer_reverse (buffer);
 362     hb_buffer_reverse (reconstruction);
 363   }
 364
 365   /*
 366    * Diff results.
 367    */
 368   diff = hb_buffer_diff (reconstruction, buffer, (hb_codepoint_t) -1, 0);
 369   if (diff)
 370   {
 371     buffer_verify_error (buffer, font, BUFFER_VERIFY_ERROR "unsafe-to-concat test failed.");
 372     ret = false;
 373
 374     /* Return the reconstructed result instead so it can be inspected. */
 375     hb_buffer_set_length (buffer, 0);
 376     hb_buffer_append (buffer, reconstruction, 0, -1);
 377   }
 378
 379
 380 out:
 381   hb_buffer_destroy (reconstruction);
 382   hb_buffer_destroy (fragments[0]);
 383   hb_buffer_destroy (fragments[1]);
 384
 385   return ret;
 386 }
 387
 388 bool
 389 hb_buffer_t::verify (hb_buffer_t        *text_buffer,
 390                      hb_font_t          *font,
 391                      const hb_feature_t *features,
 392                      unsigned int        num_features,
 393                      const char * const *shapers)
 394 {
 395   bool ret = true;
 396   if (!buffer_verify_monotone (this, font))
 397     ret = false;
 398   if (!buffer_verify_unsafe_to_break (this, text_buffer, font, features, num_features, shapers))
 399     ret = false;
 400   if (!buffer_verify_unsafe_to_concat (this, text_buffer, font, features, num_features, shapers))
 401     ret = false;
 402   if (!ret)
 403   {
 404     unsigned len = text_buffer->len;
 405     hb_vector_t<char> bytes;
 406     if (likely (bytes.resize (len * 10 + 16)))
 407     {
 408       hb_buffer_serialize_unicode (text_buffer,
 409                                    0, len,
 410                                    bytes.arrayZ, bytes.length,
 411                                    &len,
 412                                    HB_BUFFER_SERIALIZE_FORMAT_TEXT,
 413                                    HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS);
 414       buffer_verify_error (this, font, BUFFER_VERIFY_ERROR "text was: %s.", bytes.arrayZ);
 415     }
 416   }
 417   return ret;
 418 }
 419
 420
 421 #endif