hb-buffer.c

   1 /*
   2 Port from c++ is protected by a GNU Lesser GPLv3
   3 Copyright © 2013 Sylvain BERTRAND <sylvain.bertrand@gmail.com>
   4                                   <sylware@legeek.net>
   5 */
   6 #include <string.h>
   7 #include <stdlib.h>
   8 #include <assert.h>
   9
  10 #include "hb.h"
  11 #include "hb-private.h"
  12 #include "hb-atomic-private.h"
  13 #include "hb-buffer-private.h"
  14 #include "hb-unicode-private.h"
  15 #include "hb-utf-private.h"
  16
  17 hb_bool_t hb_segment_properties_equal(const hb_segment_properties_t * a,
  18                                       const hb_segment_properties_t * b)
  19 {
  20         return a->direction == b->direction &&
  21             a->script == b->script &&
  22             a->language == b->language &&
  23             a->reserved1 == b->reserved1 && a->reserved2 == b->reserved2;
  24 }
  25
  26 unsigned hb_buffer_get_length(hb_buffer_t * buffer)
  27 {
  28         return buffer->len;
  29 }
  30
  31 hb_glyph_info_t *hb_buffer_get_glyph_infos(hb_buffer_t * buffer,
  32                                            unsigned *length)
  33 {
  34         if (length)
  35                 *length = buffer->len;
  36         return buffer->info;
  37 }
  38
  39 hb_glyph_position_t *hb_buffer_get_glyph_positions(hb_buffer_t * buffer,
  40                                                    unsigned *length)
  41 {
  42         if (!buffer->have_positions)
  43                 hb_buffer_clear_positions(buffer);
  44
  45         if (length)
  46                 *length = buffer->len;
  47         return buffer->pos;
  48 }
  49
  50 void hb_buffer_set_unicode_funcs(hb_buffer_t * buffer,
  51                                  hb_unicode_funcs_t * unicode_funcs)
  52 {
  53         if (hb_atomic_int32_get(&buffer->ref_cnt) == REF_CNT_INVALID_VAL)
  54                 return;
  55
  56         if (!unicode_funcs)
  57                 unicode_funcs = hb_unicode_funcs_get_default();
  58
  59         hb_unicode_funcs_reference(unicode_funcs);
  60         hb_unicode_funcs_destroy(buffer->unicode);
  61         buffer->unicode = unicode_funcs;
  62 }
  63
  64 void hb_buffer_reverse_range(hb_buffer_t * buffer, unsigned start, unsigned end)
  65 {
  66         unsigned i, j;
  67
  68         if (start == end - 1)
  69                 return;
  70
  71         for (i = start, j = end - 1; i < j; i++, j--) {
  72                 hb_glyph_info_t t;
  73
  74                 t = buffer->info[i];
  75                 buffer->info[i] = buffer->info[j];
  76                 buffer->info[j] = t;
  77         }
  78
  79         if (buffer->pos) {
  80                 for (i = start, j = end - 1; i < j; i++, j--) {
  81                         hb_glyph_position_t t;
  82
  83                         t = buffer->pos[i];
  84                         buffer->pos[i] = buffer->pos[j];
  85                         buffer->pos[j] = t;
  86                 }
  87         }
  88 }
  89
  90 void hb_buffer_reverse(hb_buffer_t * buffer)
  91 {
  92         if (!buffer->len)
  93                 return;
  94
  95         hb_buffer_reverse_range(buffer, 0, buffer->len);
  96 }
  97
  98 void hb_buffer_set_direction(hb_buffer_t * buffer, hb_direction_t direction)
  99 {
 100         if (hb_atomic_int32_get(&buffer->ref_cnt) == REF_CNT_INVALID_VAL)
 101                 return;
 102
 103         buffer->props.direction = direction;
 104 }
 105
 106 void hb_buffer_clear_positions(hb_buffer_t * buffer)
 107 {
 108         if (hb_atomic_int32_get(&buffer->ref_cnt) == REF_CNT_INVALID_VAL)
 109                 return;
 110
 111         buffer->have_output = FALSE;
 112         buffer->have_positions = TRUE;
 113
 114         buffer->out_len = 0;
 115         buffer->out_info = buffer->info;
 116
 117         memset(buffer->pos, 0, sizeof(buffer->pos[0]) * buffer->len);
 118 }
 119
 120 /*XXX:should go in lib "global init"*/
 121 static hb_buffer_t hb_buffer_nil = {
 122         REF_CNT_INVALID_VAL,    /*ref_cnt */
 123         &_hb_unicode_funcs_nil, /*unicode */
 124         HB_SEGMENT_PROPERTIES_DEFAULT,
 125         HB_BUFFER_FLAG_DEFAULT,
 126
 127         HB_BUFFER_CONTENT_TYPE_INVALID,
 128         FALSE,                  /*in_error */
 129         FALSE,                  /*have_output */
 130         FALSE                   /*have_positions */
 131             /*Zero is good enough for everything else. */
 132 };
 133
 134 hb_buffer_t *hb_buffer_get_empty(void)
 135 {
 136         return &hb_buffer_nil;
 137 }
 138
 139 void hb_buffer_clear(hb_buffer_t * buffer)
 140 {
 141         hb_segment_properties_t default_props;
 142
 143         if (hb_atomic_int32_get(&buffer->ref_cnt) == REF_CNT_INVALID_VAL)
 144                 return;
 145
 146         /*XXX:default_props = HB_SEGMENT_PROPERTIES_DEFAULT;*/
 147         HB_SEGMENT_PROPERTIES_DEFAULT_INIT(default_props);
 148
 149         buffer->props = default_props;
 150         buffer->flags = HB_BUFFER_FLAG_DEFAULT;
 151
 152         buffer->content_type = HB_BUFFER_CONTENT_TYPE_INVALID;
 153         buffer->in_error = FALSE;
 154         buffer->have_output = FALSE;
 155         buffer->have_positions = FALSE;
 156
 157         buffer->idx = 0;
 158         buffer->len = 0;
 159         buffer->out_len = 0;
 160         buffer->out_info = buffer->info;
 161
 162         buffer->serial = 0;
 163         memset(buffer->allocated_var_bytes, 0,
 164                sizeof(buffer->allocated_var_bytes));
 165         memset(buffer->allocated_var_owner, 0,
 166                sizeof(buffer->allocated_var_owner));
 167
 168         memset(buffer->context, 0, sizeof(buffer->context));
 169         memset(buffer->context_len, 0, sizeof(buffer->context_len));
 170 }
 171
 172 void hb_buffer_reset(hb_buffer_t * buffer)
 173 {
 174         if (hb_atomic_int32_get(&buffer->ref_cnt) == REF_CNT_INVALID_VAL)
 175                 return;
 176
 177         hb_unicode_funcs_destroy(buffer->unicode);
 178         buffer->unicode = hb_unicode_funcs_get_default();
 179
 180         hb_buffer_clear(buffer);
 181 }
 182
 183 void hb_buffer_destroy(hb_buffer_t * buffer)
 184 {
 185         if (!buffer)
 186                 return;
 187         if (hb_atomic_int32_get(&buffer->ref_cnt) == REF_CNT_INVALID_VAL)
 188                 return;
 189         hb_atomic_int32_add(&buffer->ref_cnt, -1);
 190         if (hb_atomic_int32_get(&buffer->ref_cnt) > 0)
 191                 return;
 192         hb_atomic_int32_set(&buffer->ref_cnt, REF_CNT_INVALID_VAL);
 193
 194         hb_unicode_funcs_destroy(buffer->unicode);
 195
 196         free(buffer->info);
 197         free(buffer->pos);
 198         free(buffer);
 199 }
 200
 201 hb_buffer_t *hb_buffer_create(void)
 202 {
 203         hb_buffer_t *buffer = calloc(1, sizeof(*buffer));
 204         if (!buffer)
 205                 return hb_buffer_get_empty();
 206
 207         hb_atomic_int32_set(&buffer->ref_cnt, 1);
 208         buffer->unicode = hb_unicode_funcs_get_empty();
 209
 210         hb_buffer_reset(buffer);
 211         return buffer;
 212 }
 213
 214 void hb_buffer_set_script(hb_buffer_t * buffer, hb_script_t script)
 215 {
 216         if (hb_atomic_int32_get(&buffer->ref_cnt) == REF_CNT_INVALID_VAL)
 217                 return;
 218
 219         buffer->props.script = script;
 220 }
 221
 222 /*
 223 Here is how the buffer works internally:
 224
 225 There are two info pointers: info and out_info.  They always have
 226 the same allocated size, but different lengths.
 227
 228 As an optimization, both info and out_info may point to the
 229 same piece of memory, which is owned by info.  This remains the
 230 case as long as out_len doesn't exceed i at any time.
 231 In that case, swap_buffers() is no-op and the glyph operations operate
 232 mostly in-place.
 233
 234 As soon as out_info gets longer than info, out_info is moved over
 235 to an alternate buffer (which we reuse the pos buffer for!), and its
 236 current contents (out_len entries) are copied to the new place.
 237 This should all remain transparent to the user.  swap_buffers() then
 238 switches info and out_info.
 239 */
 240
 241 static hb_bool_t enlarge(hb_buffer_t * buffer, unsigned int size)
 242 {
 243         unsigned new_allocated;
 244         hb_glyph_position_t *new_pos;
 245         hb_glyph_info_t *new_info;
 246         hb_bool_t separate_out;
 247
 248         if (buffer->in_error)
 249                 return FALSE;
 250
 251         new_allocated = buffer->allocated;
 252         new_pos = NULL;
 253         new_info = NULL;
 254         separate_out = buffer->out_info != buffer->info;
 255
 256         if (hb_unsigned_int_mul_overflows(size, sizeof(buffer->info[0])))
 257                 goto done;
 258
 259         while (size >= new_allocated)
 260                 new_allocated += (new_allocated >> 1) + 32;
 261
 262         /*ASSERT_STATIC (sizeof (info[0]) == sizeof (pos[0])); */
 263         if (hb_unsigned_int_mul_overflows
 264             (new_allocated, sizeof(buffer->info[0])))
 265                 goto done;
 266
 267         new_pos = (hb_glyph_position_t *) realloc(buffer->pos, new_allocated
 268                                                   * sizeof(buffer->pos[0]));
 269         new_info = (hb_glyph_info_t *) realloc(buffer->info, new_allocated
 270                                                * sizeof(buffer->info[0]));
 271
 272 done:
 273         if (!new_pos || !new_info)
 274                 buffer->in_error = TRUE;
 275
 276         if (new_pos)
 277                 buffer->pos = new_pos;
 278
 279         if (new_info)
 280                 buffer->info = new_info;
 281
 282         buffer->out_info = separate_out ? (hb_glyph_info_t *) buffer->pos
 283             : buffer->info;
 284         if (!buffer->in_error)
 285                 buffer->allocated = new_allocated;
 286         return !buffer->in_error;
 287 }
 288
 289 static hb_bool_t ensure(hb_buffer_t * buffer, unsigned int size)
 290 {
 291         return (size < buffer->allocated) ? TRUE : enlarge(buffer, size);
 292 }
 293
 294 static void clear_context(hb_buffer_t * buffer, unsigned int side)
 295 {
 296         buffer->context_len[side] = 0;
 297 }
 298
 299 static void add(hb_buffer_t * buffer, hb_codepoint_t codepoint,
 300                 unsigned int cluster)
 301 {
 302         hb_glyph_info_t *glyph;
 303
 304         if (!ensure(buffer, buffer->len + 1))
 305                 return;
 306
 307         glyph = &buffer->info[buffer->len];
 308
 309         memset(glyph, 0, sizeof(*glyph));
 310         glyph->codepoint = codepoint;
 311         glyph->mask = 1;
 312         glyph->cluster = cluster;
 313
 314         buffer->len++;
 315 }
 316
 317 struct utf {
 318         unsigned bytes_n;
 319         unsigned (*len) (void *text);
 320         void *(*ptr_offset) (void *text, unsigned offset);
 321         void *(*prev) (void *text, void *start, hb_codepoint_t * unicode);
 322         unsigned (*diff) (void *a, void *b);
 323         void *(*next) (void *text, void *end, hb_codepoint_t * unicode);
 324 };
 325
 326 /*XXX:should go in lib "global init"*/
 327 static struct utf utf8 = {
 328         sizeof(uint8_t),
 329         hb_utf_strlen_utf8,
 330         hb_utf_ptr_offset_utf8,
 331         hb_utf_prev_utf8,
 332         hb_utf_diff_utf8,
 333         hb_utf_next_utf8
 334 };
 335
 336 /*XXX:should go in lib "global init"*/
 337 static HB_UNUSED struct utf utf16 = {
 338         sizeof(uint16_t),
 339         hb_utf_strlen_utf16,
 340         hb_utf_ptr_offset_utf16,
 341         hb_utf_prev_utf16,
 342         hb_utf_diff_utf16,
 343         hb_utf_next_utf16
 344 };
 345
 346 /*XXX:should go in lib "global init"*/
 347 static HB_UNUSED struct utf utf32 = {
 348         sizeof(uint32_t),
 349         hb_utf_strlen_utf32,
 350         hb_utf_ptr_offset_utf32,
 351         hb_utf_prev_utf32,
 352         hb_utf_diff_utf32,
 353         hb_utf_next_utf32
 354 };
 355
 356 /*to unroll the original c++, could have used a macro
 357   ASSEMBLY:maybe worth to be unrolled to fine tuned assembly*/
 358 static void hb_buffer_add_utf(hb_buffer_t * buffer, struct utf *utf, void *text,
 359                               int text_length, unsigned item_offset,
 360                               int item_length)
 361 {
 362         void *next;
 363         void *end;
 364
 365         assert(buffer->content_type == HB_BUFFER_CONTENT_TYPE_UNICODE ||
 366                (!buffer->len
 367                 && buffer->content_type == HB_BUFFER_CONTENT_TYPE_INVALID));
 368
 369         if (hb_atomic_int32_get(&buffer->ref_cnt) == REF_CNT_INVALID_VAL)
 370                 return;
 371
 372         if (text_length == -1)
 373                 text_length = utf->len(text);
 374
 375         if (item_length == -1)
 376                 item_length = text_length - item_offset;
 377
 378         ensure(buffer, buffer->len + item_length * utf->bytes_n / 4);
 379
 380         /*If buffer is empty and pre-context provided, install it.
 381            This check is written this way, to make sure people can
 382            provide pre-context in one add_utf() call, then provide
 383            text in a follow-up call.  See:
 384
 385            https://bugzilla.mozilla.org/show_bug.cgi?id=801410#c13 */
 386         if (!buffer->len && item_offset > 0) {
 387                 void *prev;
 388                 void *start;
 389
 390                 /*Add pre-context */
 391                 clear_context(buffer, 0);
 392                 prev = utf->ptr_offset(text, item_offset);
 393                 start = text;
 394                 while (start < prev
 395                        && buffer->context_len[0] < HB_BUFFER_CONTEXT_LENGTH) {
 396                         hb_codepoint_t u;
 397                         prev = utf->prev(prev, start, &u);
 398                         buffer->context[0][buffer->context_len[0]++] = u;
 399                 }
 400         }
 401
 402         next = utf->ptr_offset(text, item_offset);
 403         end = utf->ptr_offset(next, item_length);
 404         while (next < end) {
 405                 hb_codepoint_t u;
 406                 void *old_next;
 407
 408                 old_next = next;
 409                 next = utf->next(next, end, &u);
 410                 add(buffer, u, utf->diff(old_next, text));
 411         }
 412
 413         /*Add post-context */
 414         clear_context(buffer, 1);
 415         end = utf->ptr_offset(text, text_length);
 416         while (next < end && buffer->context_len[1] < HB_BUFFER_CONTEXT_LENGTH) {
 417                 hb_codepoint_t u;
 418
 419                 next = utf->next(next, end, &u);
 420                 buffer->context[1][buffer->context_len[1]++] = u;
 421         }
 422
 423         buffer->content_type = HB_BUFFER_CONTENT_TYPE_UNICODE;
 424 }
 425
 426 void hb_buffer_add_utf8(hb_buffer_t * buffer, const char *text, int text_length,
 427                         unsigned int item_offset, int item_length)
 428 {
 429         hb_buffer_add_utf(buffer, &utf8, (void *)text, text_length, item_offset,
 430                           item_length);
 431 }
 432
 433 void hb_buffer_set_flags(hb_buffer_t * buffer, hb_buffer_flags_t flags)
 434 {
 435         if (hb_atomic_int32_get(&buffer->ref_cnt) == REF_CNT_INVALID_VAL)
 436                 return;
 437
 438         buffer->flags = flags;
 439 }
 440
 441 void hb_buffer_set_language(hb_buffer_t * buffer, hb_language_t language)
 442 {
 443         if (hb_atomic_int32_get(&buffer->ref_cnt) == REF_CNT_INVALID_VAL)
 444                 return;
 445
 446         buffer->props.language = language;
 447 }
 448
 449 hb_direction_t hb_buffer_get_direction(hb_buffer_t * buffer)
 450 {
 451         return buffer->props.direction;
 452 }
 453
 454 void hb_buffer_add(hb_buffer_t * buffer, hb_codepoint_t codepoint,
 455                    unsigned int cluster)
 456 {
 457         add(buffer, codepoint, cluster);
 458         clear_context(buffer, 1);
 459 }