third_party/harfbuzz-ng/src/hb-buffer-serialize.cc

   1 /*
   2  * Copyright © 2012,2013  Google, Inc.
   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-buffer-private.hh"
  28
  29
  30 static const char *serialize_formats[] = {
  31   "text",
  32   "json",
  33   NULL
  34 };
  35
  36 /**
  37  * hb_buffer_serialize_list_formats:
  38  *
  39  *
  40  *
  41  * Return value: (transfer none):
  42  *
  43  * Since: 1.0
  44  **/
  45 const char **
  46 hb_buffer_serialize_list_formats (void)
  47 {
  48   return serialize_formats;
  49 }
  50
  51 /**
  52  * hb_buffer_serialize_format_from_string:
  53  * @str:
  54  * @len:
  55  *
  56  *
  57  *
  58  * Return value:
  59  *
  60  * Since: 1.0
  61  **/
  62 hb_buffer_serialize_format_t
  63 hb_buffer_serialize_format_from_string (const char *str, int len)
  64 {
  65   /* Upper-case it. */
  66   return (hb_buffer_serialize_format_t) (hb_tag_from_string (str, len) & ~0x20202020);
  67 }
  68
  69 /**
  70  * hb_buffer_serialize_format_to_string:
  71  * @format:
  72  *
  73  *
  74  *
  75  * Return value:
  76  *
  77  * Since: 1.0
  78  **/
  79 const char *
  80 hb_buffer_serialize_format_to_string (hb_buffer_serialize_format_t format)
  81 {
  82   switch (format)
  83   {
  84     case HB_BUFFER_SERIALIZE_FORMAT_TEXT:       return serialize_formats[0];
  85     case HB_BUFFER_SERIALIZE_FORMAT_JSON:       return serialize_formats[1];
  86     default:
  87     case HB_BUFFER_SERIALIZE_FORMAT_INVALID:    return NULL;
  88   }
  89 }
  90
  91 static unsigned int
  92 _hb_buffer_serialize_glyphs_json (hb_buffer_t *buffer,
  93                                   unsigned int start,
  94                                   unsigned int end,
  95                                   char *buf,
  96                                   unsigned int buf_size,
  97                                   unsigned int *buf_consumed,
  98                                   hb_font_t *font,
  99                                   hb_buffer_serialize_flags_t flags)
 100 {
 101   hb_glyph_info_t *info = hb_buffer_get_glyph_infos (buffer, NULL);
 102   hb_glyph_position_t *pos = hb_buffer_get_glyph_positions (buffer, NULL);
 103
 104   *buf_consumed = 0;
 105   for (unsigned int i = start; i < end; i++)
 106   {
 107     char b[1024];
 108     char *p = b;
 109
 110     /* In the following code, we know b is large enough that no overflow can happen. */
 111
 112 #define APPEND(s) HB_STMT_START { strcpy (p, s); p += strlen (s); } HB_STMT_END
 113
 114     if (i)
 115       *p++ = ',';
 116
 117     *p++ = '{';
 118
 119     APPEND ("\"g\":");
 120     if (!(flags & HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES))
 121     {
 122       char g[128];
 123       hb_font_glyph_to_string (font, info[i].codepoint, g, sizeof (g));
 124       *p++ = '"';
 125       for (char *q = g; *q; q++) {
 126         if (*q == '"')
 127           *p++ = '\\';
 128         *p++ = *q;
 129       }
 130       *p++ = '"';
 131     }
 132     else
 133       p += MAX (0, snprintf (p, ARRAY_LENGTH (b) - (p - b), "%u", info[i].codepoint));
 134
 135     if (!(flags & HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS)) {
 136       p += MAX (0, snprintf (p, ARRAY_LENGTH (b) - (p - b), ",\"cl\":%u", info[i].cluster));
 137     }
 138
 139     if (!(flags & HB_BUFFER_SERIALIZE_FLAG_NO_POSITIONS))
 140     {
 141       p += snprintf (p, ARRAY_LENGTH (b) - (p - b), ",\"dx\":%d,\"dy\":%d",
 142                      pos[i].x_offset, pos[i].y_offset);
 143       p += snprintf (p, ARRAY_LENGTH (b) - (p - b), ",\"ax\":%d,\"ay\":%d",
 144                      pos[i].x_advance, pos[i].y_advance);
 145     }
 146
 147     *p++ = '}';
 148
 149     unsigned int l = p - b;
 150     if (buf_size > l)
 151     {
 152       memcpy (buf, b, l);
 153       buf += l;
 154       buf_size -= l;
 155       *buf_consumed += l;
 156       *buf = '\0';
 157     } else
 158       return i - start;
 159   }
 160
 161   return end - start;
 162 }
 163
 164 static unsigned int
 165 _hb_buffer_serialize_glyphs_text (hb_buffer_t *buffer,
 166                                   unsigned int start,
 167                                   unsigned int end,
 168                                   char *buf,
 169                                   unsigned int buf_size,
 170                                   unsigned int *buf_consumed,
 171                                   hb_font_t *font,
 172                                   hb_buffer_serialize_flags_t flags)
 173 {
 174   hb_glyph_info_t *info = hb_buffer_get_glyph_infos (buffer, NULL);
 175   hb_glyph_position_t *pos = hb_buffer_get_glyph_positions (buffer, NULL);
 176
 177   *buf_consumed = 0;
 178   for (unsigned int i = start; i < end; i++)
 179   {
 180     char b[1024];
 181     char *p = b;
 182
 183     /* In the following code, we know b is large enough that no overflow can happen. */
 184
 185     if (i)
 186       *p++ = '|';
 187
 188     if (!(flags & HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES))
 189     {
 190       hb_font_glyph_to_string (font, info[i].codepoint, p, 128);
 191       p += strlen (p);
 192     }
 193     else
 194       p += MAX (0, snprintf (p, ARRAY_LENGTH (b) - (p - b), "%u", info[i].codepoint));
 195
 196     if (!(flags & HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS)) {
 197       p += MAX (0, snprintf (p, ARRAY_LENGTH (b) - (p - b), "=%u", info[i].cluster));
 198     }
 199
 200     if (!(flags & HB_BUFFER_SERIALIZE_FLAG_NO_POSITIONS))
 201     {
 202       if (pos[i].x_offset || pos[i].y_offset)
 203         p += MAX (0, snprintf (p, ARRAY_LENGTH (b) - (p - b), "@%d,%d", pos[i].x_offset, pos[i].y_offset));
 204
 205       *p++ = '+';
 206       p += MAX (0, snprintf (p, ARRAY_LENGTH (b) - (p - b), "%d", pos[i].x_advance));
 207       if (pos->y_advance)
 208         p += MAX (0, snprintf (p, ARRAY_LENGTH (b) - (p - b), ",%d", pos[i].y_advance));
 209     }
 210
 211     unsigned int l = p - b;
 212     if (buf_size > l)
 213     {
 214       memcpy (buf, b, l);
 215       buf += l;
 216       buf_size -= l;
 217       *buf_consumed += l;
 218       *buf = '\0';
 219     } else
 220       return i - start;
 221   }
 222
 223   return end - start;
 224 }
 225
 226 /* Returns number of items, starting at start, that were serialized. */
 227 /**
 228  * hb_buffer_serialize_glyphs:
 229  * @buffer: a buffer.
 230  * @start:
 231  * @end:
 232  * @buf: (array length=buf_size):
 233  * @buf_size:
 234  * @buf_consumed: (out):
 235  * @font:
 236  * @format:
 237  * @flags:
 238  *
 239  *
 240  *
 241  * Return value:
 242  *
 243  * Since: 1.0
 244  **/
 245 unsigned int
 246 hb_buffer_serialize_glyphs (hb_buffer_t *buffer,
 247                             unsigned int start,
 248                             unsigned int end,
 249                             char *buf,
 250                             unsigned int buf_size,
 251                             unsigned int *buf_consumed, /* May be NULL */
 252                             hb_font_t *font, /* May be NULL */
 253                             hb_buffer_serialize_format_t format,
 254                             hb_buffer_serialize_flags_t flags)
 255 {
 256   assert (start <= end && end <= buffer->len);
 257
 258   unsigned int sconsumed;
 259   if (!buf_consumed)
 260     buf_consumed = &sconsumed;
 261   *buf_consumed = 0;
 262
 263   assert ((!buffer->len && buffer->content_type == HB_BUFFER_CONTENT_TYPE_INVALID) ||
 264           buffer->content_type == HB_BUFFER_CONTENT_TYPE_GLYPHS);
 265
 266   if (unlikely (start == end))
 267     return 0;
 268
 269   if (!font)
 270     font = hb_font_get_empty ();
 271
 272   switch (format)
 273   {
 274     case HB_BUFFER_SERIALIZE_FORMAT_TEXT:
 275       return _hb_buffer_serialize_glyphs_text (buffer, start, end,
 276                                                buf, buf_size, buf_consumed,
 277                                                font, flags);
 278
 279     case HB_BUFFER_SERIALIZE_FORMAT_JSON:
 280       return _hb_buffer_serialize_glyphs_json (buffer, start, end,
 281                                                buf, buf_size, buf_consumed,
 282                                                font, flags);
 283
 284     default:
 285     case HB_BUFFER_SERIALIZE_FORMAT_INVALID:
 286       return 0;
 287
 288   }
 289 }
 290
 291
 292 static hb_bool_t
 293 parse_uint (const char *pp, const char *end, uint32_t *pv)
 294 {
 295   char buf[32];
 296   unsigned int len = MIN (ARRAY_LENGTH (buf) - 1, (unsigned int) (end - pp));
 297   strncpy (buf, pp, len);
 298   buf[len] = '\0';
 299
 300   char *p = buf;
 301   char *pend = p;
 302   uint32_t v;
 303
 304   errno = 0;
 305   v = strtol (p, &pend, 10);
 306   if (errno || p == pend || pend - p != end - pp)
 307     return false;
 308
 309   *pv = v;
 310   return true;
 311 }
 312
 313 static hb_bool_t
 314 parse_int (const char *pp, const char *end, int32_t *pv)
 315 {
 316   char buf[32];
 317   unsigned int len = MIN (ARRAY_LENGTH (buf) - 1, (unsigned int) (end - pp));
 318   strncpy (buf, pp, len);
 319   buf[len] = '\0';
 320
 321   char *p = buf;
 322   char *pend = p;
 323   int32_t v;
 324
 325   errno = 0;
 326   v = strtol (p, &pend, 10);
 327   if (errno || p == pend || pend - p != end - pp)
 328     return false;
 329
 330   *pv = v;
 331   return true;
 332 }
 333
 334 #include "hb-buffer-deserialize-json.hh"
 335 #include "hb-buffer-deserialize-text.hh"
 336
 337 /**
 338  * hb_buffer_deserialize_glyphs:
 339  * @buffer: a buffer.
 340  * @buf: (array length=buf_len):
 341  * @buf_len:
 342  * @end_ptr: (out):
 343  * @font:
 344  * @format:
 345  *
 346  *
 347  *
 348  * Return value:
 349  *
 350  * Since: 1.0
 351  **/
 352 hb_bool_t
 353 hb_buffer_deserialize_glyphs (hb_buffer_t *buffer,
 354                               const char *buf,
 355                               int buf_len, /* -1 means nul-terminated */
 356                               const char **end_ptr, /* May be NULL */
 357                               hb_font_t *font, /* May be NULL */
 358                               hb_buffer_serialize_format_t format)
 359 {
 360   const char *end;
 361   if (!end_ptr)
 362     end_ptr = &end;
 363   *end_ptr = buf;
 364
 365   assert ((!buffer->len && buffer->content_type == HB_BUFFER_CONTENT_TYPE_INVALID) ||
 366           buffer->content_type == HB_BUFFER_CONTENT_TYPE_GLYPHS);
 367
 368   if (buf_len == -1)
 369     buf_len = strlen (buf);
 370
 371   if (!buf_len)
 372   {
 373     *end_ptr = buf;
 374     return false;
 375   }
 376
 377   hb_buffer_set_content_type (buffer, HB_BUFFER_CONTENT_TYPE_GLYPHS);
 378
 379   if (!font)
 380     font = hb_font_get_empty ();
 381
 382   switch (format)
 383   {
 384     case HB_BUFFER_SERIALIZE_FORMAT_TEXT:
 385       return _hb_buffer_deserialize_glyphs_text (buffer,
 386                                                  buf, buf_len, end_ptr,
 387                                                  font);
 388
 389     case HB_BUFFER_SERIALIZE_FORMAT_JSON:
 390       return _hb_buffer_deserialize_glyphs_json (buffer,
 391                                                  buf, buf_len, end_ptr,
 392                                                  font);
 393
 394     default:
 395     case HB_BUFFER_SERIALIZE_FORMAT_INVALID:
 396       return false;
 397
 398   }
 399 }