third_party/harfbuzz-ng/src/hb-shape.cc

   1 /*
   2  * Copyright © 2009  Red Hat, Inc.
   3  * Copyright © 2012  Google, Inc.
   4  *
   5  *  This is part of HarfBuzz, a text shaping library.
   6  *
   7  * Permission is hereby granted, without written agreement and without
   8  * license or royalty fees, to use, copy, modify, and distribute this
   9  * software and its documentation for any purpose, provided that the
  10  * above copyright notice and the following two paragraphs appear in
  11  * all copies of this software.
  12  *
  13  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
  14  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
  15  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
  16  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
  17  * DAMAGE.
  18  *
  19  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
  20  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  21  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
  22  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
  23  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  24  *
  25  * Red Hat Author(s): Behdad Esfahbod
  26  * Google Author(s): Behdad Esfahbod
  27  */
  28
  29 #include "hb-private.hh"
  30
  31 #include "hb-shaper-private.hh"
  32 #include "hb-shape-plan-private.hh"
  33 #include "hb-buffer-private.hh"
  34 #include "hb-font-private.hh"
  35
  36
  37 static void
  38 parse_space (const char **pp, const char *end)
  39 {
  40   char c;
  41   while (*pp < end && (c = **pp, ISSPACE (c)))
  42     (*pp)++;
  43 }
  44
  45 static hb_bool_t
  46 parse_char (const char **pp, const char *end, char c)
  47 {
  48   parse_space (pp, end);
  49
  50   if (*pp == end || **pp != c)
  51     return false;
  52
  53   (*pp)++;
  54   return true;
  55 }
  56
  57 static hb_bool_t
  58 parse_uint (const char **pp, const char *end, unsigned int *pv)
  59 {
  60   char buf[32];
  61   unsigned int len = MIN (ARRAY_LENGTH (buf) - 1, (unsigned int) (end - *pp));
  62   strncpy (buf, *pp, len);
  63   buf[len] = '\0';
  64
  65   char *p = buf;
  66   char *pend = p;
  67   unsigned int v;
  68
  69   /* Intentionally use strtol instead of strtoul, such that
  70    * -1 turns into "big number"... */
  71   errno = 0;
  72   v = strtol (p, &pend, 0);
  73   if (errno || p == pend)
  74     return false;
  75
  76   *pv = v;
  77   *pp += pend - p;
  78   return true;
  79 }
  80
  81 static hb_bool_t
  82 parse_feature_value_prefix (const char **pp, const char *end, hb_feature_t *feature)
  83 {
  84   if (parse_char (pp, end, '-'))
  85     feature->value = 0;
  86   else {
  87     parse_char (pp, end, '+');
  88     feature->value = 1;
  89   }
  90
  91   return true;
  92 }
  93
  94 static hb_bool_t
  95 parse_feature_tag (const char **pp, const char *end, hb_feature_t *feature)
  96 {
  97   const char *p = *pp;
  98   char c;
  99
 100   parse_space (pp, end);
 101
 102 #define ISALNUM(c) (('a' <= (c) && (c) <= 'z') || ('A' <= (c) && (c) <= 'Z') || ('0' <= (c) && (c) <= '9'))
 103   while (*pp < end && (c = **pp, ISALNUM(c)))
 104     (*pp)++;
 105 #undef ISALNUM
 106
 107   if (p == *pp)
 108     return false;
 109
 110   feature->tag = hb_tag_from_string (p, *pp - p);
 111   return true;
 112 }
 113
 114 static hb_bool_t
 115 parse_feature_indices (const char **pp, const char *end, hb_feature_t *feature)
 116 {
 117   parse_space (pp, end);
 118
 119   hb_bool_t has_start;
 120
 121   feature->start = 0;
 122   feature->end = (unsigned int) -1;
 123
 124   if (!parse_char (pp, end, '['))
 125     return true;
 126
 127   has_start = parse_uint (pp, end, &feature->start);
 128
 129   if (parse_char (pp, end, ':')) {
 130     parse_uint (pp, end, &feature->end);
 131   } else {
 132     if (has_start)
 133       feature->end = feature->start + 1;
 134   }
 135
 136   return parse_char (pp, end, ']');
 137 }
 138
 139 static hb_bool_t
 140 parse_feature_value_postfix (const char **pp, const char *end, hb_feature_t *feature)
 141 {
 142   return !parse_char (pp, end, '=') || parse_uint (pp, end, &feature->value);
 143 }
 144
 145
 146 static hb_bool_t
 147 parse_one_feature (const char **pp, const char *end, hb_feature_t *feature)
 148 {
 149   return parse_feature_value_prefix (pp, end, feature) &&
 150          parse_feature_tag (pp, end, feature) &&
 151          parse_feature_indices (pp, end, feature) &&
 152          parse_feature_value_postfix (pp, end, feature) &&
 153          *pp == end;
 154 }
 155
 156 hb_bool_t
 157 hb_feature_from_string (const char *str, int len,
 158                         hb_feature_t *feature)
 159 {
 160   if (len < 0)
 161     len = strlen (str);
 162
 163   return parse_one_feature (&str, str + len, feature);
 164 }
 165
 166 void
 167 hb_feature_to_string (hb_feature_t *feature,
 168                       char *buf, unsigned int size)
 169 {
 170   if (unlikely (!size)) return;
 171
 172   char s[128];
 173   unsigned int len = 0;
 174   if (feature->value == 0)
 175     s[len++] = '-';
 176   hb_tag_to_string (feature->tag, s + len);
 177   len += 4;
 178   while (len && s[len - 1] == ' ')
 179     len--;
 180   if (feature->start != 0 || feature->end != (unsigned int) -1)
 181   {
 182     s[len++] = '[';
 183     if (feature->start)
 184       len += snprintf (s + len, ARRAY_LENGTH (s) - len, "%d", feature->start);
 185     if (feature->end != feature->start + 1) {
 186       s[len++] = ':';
 187       if (feature->end != (unsigned int) -1)
 188         len += snprintf (s + len, ARRAY_LENGTH (s) - len, "%d", feature->end);
 189     }
 190     s[len++] = ']';
 191   }
 192   if (feature->value > 1)
 193   {
 194     s[len++] = '=';
 195     len += snprintf (s + len, ARRAY_LENGTH (s) - len, "%d", feature->value);
 196   }
 197   assert (len < ARRAY_LENGTH (s));
 198   len = MIN (len, size - 1);
 199   memcpy (buf, s, len);
 200   s[len] = '\0';
 201 }
 202
 203
 204 static const char **static_shaper_list;
 205
 206 static inline
 207 void free_static_shaper_list (void)
 208 {
 209   free (static_shaper_list);
 210 }
 211
 212 const char **
 213 hb_shape_list_shapers (void)
 214 {
 215 retry:
 216   const char **shaper_list = (const char **) hb_atomic_ptr_get (&static_shaper_list);
 217
 218   if (unlikely (!shaper_list))
 219   {
 220     /* Not found; allocate one. */
 221     shaper_list = (const char **) calloc (1 + HB_SHAPERS_COUNT, sizeof (const char *));
 222     if (unlikely (!shaper_list)) {
 223       static const char *nil_shaper_list[] = {NULL};
 224       return nil_shaper_list;
 225     }
 226
 227     const hb_shaper_pair_t *shapers = _hb_shapers_get ();
 228     unsigned int i;
 229     for (i = 0; i < HB_SHAPERS_COUNT; i++)
 230       shaper_list[i] = shapers[i].name;
 231     shaper_list[i] = NULL;
 232
 233     if (!hb_atomic_ptr_cmpexch (&static_shaper_list, NULL, shaper_list)) {
 234       free (shaper_list);
 235       goto retry;
 236     }
 237
 238 #ifdef HAVE_ATEXIT
 239     atexit (free_static_shaper_list); /* First person registers atexit() callback. */
 240 #endif
 241   }
 242
 243   return shaper_list;
 244 }
 245
 246
 247 hb_bool_t
 248 hb_shape_full (hb_font_t          *font,
 249                hb_buffer_t        *buffer,
 250                const hb_feature_t *features,
 251                unsigned int        num_features,
 252                const char * const *shaper_list)
 253 {
 254   if (unlikely (!buffer->len))
 255     return true;
 256
 257   assert (buffer->content_type == HB_BUFFER_CONTENT_TYPE_UNICODE);
 258
 259   hb_shape_plan_t *shape_plan = hb_shape_plan_create_cached (font->face, &buffer->props, features, num_features, shaper_list);
 260   hb_bool_t res = hb_shape_plan_execute (shape_plan, font, buffer, features, num_features);
 261   hb_shape_plan_destroy (shape_plan);
 262
 263   if (res)
 264     buffer->content_type = HB_BUFFER_CONTENT_TYPE_GLYPHS;
 265   return res;
 266 }
 267
 268 void
 269 hb_shape (hb_font_t           *font,
 270           hb_buffer_t         *buffer,
 271           const hb_feature_t  *features,
 272           unsigned int         num_features)
 273 {
 274   hb_shape_full (font, buffer, features, num_features, NULL);
 275 }