src/hb-buffer.hh

   1 /*
   2  * Copyright © 1998-2004  David Turner and Werner Lemberg
   3  * Copyright © 2004,2007,2009,2010  Red Hat, Inc.
   4  * Copyright © 2011,2012  Google, Inc.
   5  *
   6  *  This is part of HarfBuzz, a text shaping library.
   7  *
   8  * Permission is hereby granted, without written agreement and without
   9  * license or royalty fees, to use, copy, modify, and distribute this
  10  * software and its documentation for any purpose, provided that the
  11  * above copyright notice and the following two paragraphs appear in
  12  * all copies of this software.
  13  *
  14  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
  15  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
  16  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
  17  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
  18  * DAMAGE.
  19  *
  20  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
  21  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  22  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  23  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
  24  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  25  *
  26  * Red Hat Author(s): Owen Taylor, Behdad Esfahbod
  27  * Google Author(s): Behdad Esfahbod
  28  */
  29
  30 #ifndef HB_BUFFER_HH
  31 #define HB_BUFFER_HH
  32
  33 #include "hb.hh"
  34 #include "hb-unicode.hh"
  35
  36
  37 #ifndef HB_BUFFER_MAX_LEN_FACTOR
  38 #define HB_BUFFER_MAX_LEN_FACTOR 32
  39 #endif
  40 #ifndef HB_BUFFER_MAX_LEN_MIN
  41 #define HB_BUFFER_MAX_LEN_MIN 8192
  42 #endif
  43 #ifndef HB_BUFFER_MAX_LEN_DEFAULT
  44 #define HB_BUFFER_MAX_LEN_DEFAULT 0x3FFFFFFF /* Shaping more than a billion chars? Let us know! */
  45 #endif
  46
  47 #ifndef HB_BUFFER_MAX_OPS_FACTOR
  48 #define HB_BUFFER_MAX_OPS_FACTOR 64
  49 #endif
  50 #ifndef HB_BUFFER_MAX_OPS_MIN
  51 #define HB_BUFFER_MAX_OPS_MIN 1024
  52 #endif
  53 #ifndef HB_BUFFER_MAX_OPS_DEFAULT
  54 #define HB_BUFFER_MAX_OPS_DEFAULT 0x1FFFFFFF /* Shaping more than a billion operations? Let us know! */
  55 #endif
  56
  57 static_assert ((sizeof (hb_glyph_info_t) == 20), "");
  58 static_assert ((sizeof (hb_glyph_info_t) == sizeof (hb_glyph_position_t)), "");
  59
  60 HB_MARK_AS_FLAG_T (hb_buffer_flags_t);
  61 HB_MARK_AS_FLAG_T (hb_buffer_serialize_flags_t);
  62 HB_MARK_AS_FLAG_T (hb_buffer_diff_flags_t);
  63
  64 enum hb_buffer_scratch_flags_t {
  65   HB_BUFFER_SCRATCH_FLAG_DEFAULT                        = 0x00000000u,
  66   HB_BUFFER_SCRATCH_FLAG_HAS_NON_ASCII                  = 0x00000001u,
  67   HB_BUFFER_SCRATCH_FLAG_HAS_DEFAULT_IGNORABLES         = 0x00000002u,
  68   HB_BUFFER_SCRATCH_FLAG_HAS_SPACE_FALLBACK             = 0x00000004u,
  69   HB_BUFFER_SCRATCH_FLAG_HAS_GPOS_ATTACHMENT            = 0x00000008u,
  70   HB_BUFFER_SCRATCH_FLAG_HAS_UNSAFE_TO_BREAK            = 0x00000010u,
  71   HB_BUFFER_SCRATCH_FLAG_HAS_CGJ                        = 0x00000020u,
  72
  73   /* Reserved for complex shapers' internal use. */
  74   HB_BUFFER_SCRATCH_FLAG_COMPLEX0                       = 0x01000000u,
  75   HB_BUFFER_SCRATCH_FLAG_COMPLEX1                       = 0x02000000u,
  76   HB_BUFFER_SCRATCH_FLAG_COMPLEX2                       = 0x04000000u,
  77   HB_BUFFER_SCRATCH_FLAG_COMPLEX3                       = 0x08000000u,
  78 };
  79 HB_MARK_AS_FLAG_T (hb_buffer_scratch_flags_t);
  80
  81
  82 /*
  83  * hb_buffer_t
  84  */
  85
  86 struct hb_buffer_t
  87 {
  88   hb_object_header_t header;
  89
  90   /* Information about how the text in the buffer should be treated */
  91   hb_unicode_funcs_t *unicode; /* Unicode functions */
  92   hb_buffer_flags_t flags; /* BOT / EOT / etc. */
  93   hb_buffer_cluster_level_t cluster_level;
  94   hb_codepoint_t replacement; /* U+FFFD or something else. */
  95   hb_codepoint_t invisible; /* 0 or something else. */
  96   hb_buffer_scratch_flags_t scratch_flags; /* Have space-fallback, etc. */
  97   unsigned int max_len; /* Maximum allowed len. */
  98   int max_ops; /* Maximum allowed operations. */
  99
 100   /* Buffer contents */
 101   hb_buffer_content_type_t content_type;
 102   hb_segment_properties_t props; /* Script, language, direction */
 103
 104   bool successful; /* Allocations successful */
 105   bool have_output; /* Whether we have an output buffer going on */
 106   bool have_positions; /* Whether we have positions */
 107
 108   unsigned int idx; /* Cursor into ->info and ->pos arrays */
 109   unsigned int len; /* Length of ->info and ->pos arrays */
 110   unsigned int out_len; /* Length of ->out array if have_output */
 111
 112   unsigned int allocated; /* Length of allocated arrays */
 113   hb_glyph_info_t     *info;
 114   hb_glyph_info_t     *out_info;
 115   hb_glyph_position_t *pos;
 116
 117   unsigned int serial;
 118
 119   /* Text before / after the main buffer contents.
 120    * Always in Unicode, and ordered outward.
 121    * Index 0 is for "pre-context", 1 for "post-context". */
 122   static constexpr unsigned CONTEXT_LENGTH = 5u;
 123   hb_codepoint_t context[2][CONTEXT_LENGTH];
 124   unsigned int context_len[2];
 125
 126   /* Debugging API */
 127 #ifndef HB_NO_BUFFER_MESSAGE
 128   hb_buffer_message_func_t message_func;
 129   void *message_data;
 130   hb_destroy_func_t message_destroy;
 131 #endif
 132
 133   /* Internal debugging. */
 134   /* The bits here reflect current allocations of the bytes in glyph_info_t's var1 and var2. */
 135 #ifndef HB_NDEBUG
 136   uint8_t allocated_var_bits;
 137 #endif
 138
 139
 140   /* Methods */
 141
 142   bool in_error () const { return !successful; }
 143
 144   void allocate_var (unsigned int start, unsigned int count)
 145   {
 146 #ifndef HB_NDEBUG
 147     unsigned int end = start + count;
 148     assert (end <= 8);
 149     unsigned int bits = (1u<<end) - (1u<<start);
 150     assert (0 == (allocated_var_bits & bits));
 151     allocated_var_bits |= bits;
 152 #endif
 153   }
 154   void deallocate_var (unsigned int start, unsigned int count)
 155   {
 156 #ifndef HB_NDEBUG
 157     unsigned int end = start + count;
 158     assert (end <= 8);
 159     unsigned int bits = (1u<<end) - (1u<<start);
 160     assert (bits == (allocated_var_bits & bits));
 161     allocated_var_bits &= ~bits;
 162 #endif
 163   }
 164   void assert_var (unsigned int start, unsigned int count)
 165   {
 166 #ifndef HB_NDEBUG
 167     unsigned int end = start + count;
 168     assert (end <= 8);
 169     unsigned int bits = (1u<<end) - (1u<<start);
 170     assert (bits == (allocated_var_bits & bits));
 171 #endif
 172   }
 173   void deallocate_var_all ()
 174   {
 175 #ifndef HB_NDEBUG
 176     allocated_var_bits = 0;
 177 #endif
 178   }
 179
 180   hb_glyph_info_t &cur (unsigned int i = 0) { return info[idx + i]; }
 181   hb_glyph_info_t cur (unsigned int i = 0) const { return info[idx + i]; }
 182
 183   hb_glyph_position_t &cur_pos (unsigned int i = 0) { return pos[idx + i]; }
 184   hb_glyph_position_t cur_pos (unsigned int i = 0) const { return pos[idx + i]; }
 185
 186   hb_glyph_info_t &prev ()      { return out_info[out_len ? out_len - 1 : 0]; }
 187   hb_glyph_info_t prev () const { return out_info[out_len ? out_len - 1 : 0]; }
 188
 189   bool has_separate_output () const { return info != out_info; }
 190
 191
 192   HB_INTERNAL void reset ();
 193   HB_INTERNAL void clear ();
 194
 195   unsigned int backtrack_len () const { return have_output? out_len : idx; }
 196   unsigned int lookahead_len () const { return len - idx; }
 197   unsigned int next_serial () { return serial++; }
 198
 199   HB_INTERNAL void add (hb_codepoint_t  codepoint,
 200                         unsigned int    cluster);
 201   HB_INTERNAL void add_info (const hb_glyph_info_t &glyph_info);
 202
 203   HB_INTERNAL void reverse_range (unsigned int start, unsigned int end);
 204   HB_INTERNAL void reverse ();
 205   HB_INTERNAL void reverse_clusters ();
 206   HB_INTERNAL void guess_segment_properties ();
 207
 208   HB_INTERNAL void swap_buffers ();
 209   HB_INTERNAL void remove_output ();
 210   HB_INTERNAL void clear_output ();
 211   HB_INTERNAL void clear_positions ();
 212
 213   HB_INTERNAL void replace_glyphs (unsigned int num_in,
 214                                    unsigned int num_out,
 215                                    const hb_codepoint_t *glyph_data);
 216
 217   void replace_glyph (hb_codepoint_t glyph_index)
 218   {
 219     if (unlikely (out_info != info || out_len != idx)) {
 220       if (unlikely (!make_room_for (1, 1))) return;
 221       out_info[out_len] = info[idx];
 222     }
 223     out_info[out_len].codepoint = glyph_index;
 224
 225     idx++;
 226     out_len++;
 227   }
 228   /* Makes a copy of the glyph at idx to output and replace glyph_index */
 229   hb_glyph_info_t & output_glyph (hb_codepoint_t glyph_index)
 230   {
 231     if (unlikely (!make_room_for (0, 1))) return Crap (hb_glyph_info_t);
 232
 233     if (unlikely (idx == len && !out_len))
 234       return Crap (hb_glyph_info_t);
 235
 236     out_info[out_len] = idx < len ? info[idx] : out_info[out_len - 1];
 237     out_info[out_len].codepoint = glyph_index;
 238
 239     out_len++;
 240
 241     return out_info[out_len - 1];
 242   }
 243   void output_info (const hb_glyph_info_t &glyph_info)
 244   {
 245     if (unlikely (!make_room_for (0, 1))) return;
 246
 247     out_info[out_len] = glyph_info;
 248
 249     out_len++;
 250   }
 251   /* Copies glyph at idx to output but doesn't advance idx */
 252   void copy_glyph ()
 253   {
 254     if (unlikely (!make_room_for (0, 1))) return;
 255
 256     out_info[out_len] = info[idx];
 257
 258     out_len++;
 259   }
 260   /* Copies glyph at idx to output and advance idx.
 261    * If there's no output, just advance idx. */
 262   void
 263   next_glyph ()
 264   {
 265     if (have_output)
 266     {
 267       if (out_info != info || out_len != idx)
 268       {
 269         if (unlikely (!make_room_for (1, 1))) return;
 270         out_info[out_len] = info[idx];
 271       }
 272       out_len++;
 273     }
 274
 275     idx++;
 276   }
 277   /* Copies n glyphs at idx to output and advance idx.
 278    * If there's no output, just advance idx. */
 279   void
 280   next_glyphs (unsigned int n)
 281   {
 282     if (have_output)
 283     {
 284       if (out_info != info || out_len != idx)
 285       {
 286         if (unlikely (!make_room_for (n, n))) return;
 287         memmove (out_info + out_len, info + idx, n * sizeof (out_info[0]));
 288       }
 289       out_len += n;
 290     }
 291
 292     idx += n;
 293   }
 294   /* Advance idx without copying to output. */
 295   void skip_glyph () { idx++; }
 296   void reset_masks (hb_mask_t mask)
 297   {
 298     for (unsigned int j = 0; j < len; j++)
 299       info[j].mask = mask;
 300   }
 301   void add_masks (hb_mask_t mask)
 302   {
 303     for (unsigned int j = 0; j < len; j++)
 304       info[j].mask |= mask;
 305   }
 306   HB_INTERNAL void set_masks (hb_mask_t value, hb_mask_t mask,
 307                               unsigned int cluster_start, unsigned int cluster_end);
 308
 309   void merge_clusters (unsigned int start, unsigned int end)
 310   {
 311     if (end - start < 2)
 312       return;
 313     merge_clusters_impl (start, end);
 314   }
 315   HB_INTERNAL void merge_clusters_impl (unsigned int start, unsigned int end);
 316   HB_INTERNAL void merge_out_clusters (unsigned int start, unsigned int end);
 317   /* Merge clusters for deleting current glyph, and skip it. */
 318   HB_INTERNAL void delete_glyph ();
 319
 320   void unsafe_to_break (unsigned int start,
 321                                unsigned int end)
 322   {
 323     if (end - start < 2)
 324       return;
 325     unsafe_to_break_impl (start, end);
 326   }
 327   HB_INTERNAL void unsafe_to_break_impl (unsigned int start, unsigned int end);
 328   HB_INTERNAL void unsafe_to_break_from_outbuffer (unsigned int start, unsigned int end);
 329
 330
 331   /* Internal methods */
 332   HB_INTERNAL bool move_to (unsigned int i); /* i is output-buffer index. */
 333
 334   HB_INTERNAL bool enlarge (unsigned int size);
 335
 336   bool ensure (unsigned int size)
 337   { return likely (!size || size < allocated) ? true : enlarge (size); }
 338
 339   bool ensure_inplace (unsigned int size)
 340   { return likely (!size || size < allocated); }
 341
 342   HB_INTERNAL bool make_room_for (unsigned int num_in, unsigned int num_out);
 343   HB_INTERNAL bool shift_forward (unsigned int count);
 344
 345   typedef long scratch_buffer_t;
 346   HB_INTERNAL scratch_buffer_t *get_scratch_buffer (unsigned int *size);
 347
 348   void clear_context (unsigned int side) { context_len[side] = 0; }
 349
 350   HB_INTERNAL void sort (unsigned int start, unsigned int end, int(*compar)(const hb_glyph_info_t *, const hb_glyph_info_t *));
 351
 352   bool messaging ()
 353   {
 354 #ifdef HB_NO_BUFFER_MESSAGE
 355     return false;
 356 #else
 357     return unlikely (message_func);
 358 #endif
 359   }
 360   bool message (hb_font_t *font, const char *fmt, ...) HB_PRINTF_FUNC(3, 4)
 361   {
 362 #ifdef HB_NO_BUFFER_MESSAGE
 363    return true;
 364 #else
 365     if (!messaging ())
 366       return true;
 367     va_list ap;
 368     va_start (ap, fmt);
 369     bool ret = message_impl (font, fmt, ap);
 370     va_end (ap);
 371     return ret;
 372 #endif
 373   }
 374   HB_INTERNAL bool message_impl (hb_font_t *font, const char *fmt, va_list ap) HB_PRINTF_FUNC(3, 0);
 375
 376   static void
 377   set_cluster (hb_glyph_info_t &inf, unsigned int cluster, unsigned int mask = 0)
 378   {
 379     if (inf.cluster != cluster)
 380     {
 381       if (mask & HB_GLYPH_FLAG_UNSAFE_TO_BREAK)
 382         inf.mask |= HB_GLYPH_FLAG_UNSAFE_TO_BREAK;
 383       else
 384         inf.mask &= ~HB_GLYPH_FLAG_UNSAFE_TO_BREAK;
 385     }
 386     inf.cluster = cluster;
 387   }
 388
 389   unsigned int
 390   _unsafe_to_break_find_min_cluster (const hb_glyph_info_t *infos,
 391                                      unsigned int start, unsigned int end,
 392                                      unsigned int cluster) const
 393   {
 394     for (unsigned int i = start; i < end; i++)
 395       cluster = hb_min (cluster, infos[i].cluster);
 396     return cluster;
 397   }
 398   void
 399   _unsafe_to_break_set_mask (hb_glyph_info_t *infos,
 400                              unsigned int start, unsigned int end,
 401                              unsigned int cluster)
 402   {
 403     for (unsigned int i = start; i < end; i++)
 404       if (cluster != infos[i].cluster)
 405       {
 406         scratch_flags |= HB_BUFFER_SCRATCH_FLAG_HAS_UNSAFE_TO_BREAK;
 407         infos[i].mask |= HB_GLYPH_FLAG_UNSAFE_TO_BREAK;
 408       }
 409   }
 410
 411   void unsafe_to_break_all () { unsafe_to_break_impl (0, len); }
 412   void safe_to_break_all ()
 413   {
 414     for (unsigned int i = 0; i < len; i++)
 415       info[i].mask &= ~HB_GLYPH_FLAG_UNSAFE_TO_BREAK;
 416   }
 417 };
 418 DECLARE_NULL_INSTANCE (hb_buffer_t);
 419
 420
 421 /* Loop over clusters. Duplicated in foreach_syllable(). */
 422 #define foreach_cluster(buffer, start, end) \
 423   for (unsigned int \
 424        _count = buffer->len, \
 425        start = 0, end = _count ? _next_cluster (buffer, 0) : 0; \
 426        start < _count; \
 427        start = end, end = _next_cluster (buffer, start))
 428
 429 static inline unsigned int
 430 _next_cluster (hb_buffer_t *buffer, unsigned int start)
 431 {
 432   hb_glyph_info_t *info = buffer->info;
 433   unsigned int count = buffer->len;
 434
 435   unsigned int cluster = info[start].cluster;
 436   while (++start < count && cluster == info[start].cluster)
 437     ;
 438
 439   return start;
 440 }
 441
 442
 443 #define HB_BUFFER_XALLOCATE_VAR(b, func, var) \
 444   b->func (offsetof (hb_glyph_info_t, var) - offsetof(hb_glyph_info_t, var1), \
 445            sizeof (b->info[0].var))
 446 #define HB_BUFFER_ALLOCATE_VAR(b, var)          HB_BUFFER_XALLOCATE_VAR (b, allocate_var,   var ())
 447 #define HB_BUFFER_DEALLOCATE_VAR(b, var)        HB_BUFFER_XALLOCATE_VAR (b, deallocate_var, var ())
 448 #define HB_BUFFER_ASSERT_VAR(b, var)            HB_BUFFER_XALLOCATE_VAR (b, assert_var,     var ())
 449
 450
 451 #endif /* HB_BUFFER_HH */