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