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 #define ISSPACE(c) ((c)==' '||(c)=='\f'||(c)=='\n'||(c)=='\r'||(c)=='\t'||(c)=='\v')
  42   while (*pp < end && (c = **pp, ISSPACE (c)))
  43     (*pp)++;
  44 #undef ISSPACE
  45 }
  46
  47 static hb_bool_t
  48 parse_char (const char **pp, const char *end, char c)
  49 {
  50   parse_space (pp, end);
  51
  52   if (*pp == end || **pp != c)
  53     return false;
  54
  55   (*pp)++;
  56   return true;
  57 }
  58
  59 static hb_bool_t
  60 parse_uint (const char **pp, const char *end, unsigned int *pv)
  61 {
  62   char buf[32];
  63   strncpy (buf, *pp, end - *pp);
  64   buf[ARRAY_LENGTH (buf) - 1] = '\0';
  65
  66   char *p = buf;
  67   char *pend = p;
  68   unsigned int v;
  69
  70   v = strtol (p, &pend, 0);
  71
  72   if (p == pend)
  73     return false;
  74
  75   *pv = v;
  76   *pp += pend - p;
  77   return true;
  78 }
  79
  80 static hb_bool_t
  81 parse_feature_value_prefix (const char **pp, const char *end, hb_feature_t *feature)
  82 {
  83   if (parse_char (pp, end, '-'))
  84     feature->value = 0;
  85   else {
  86     parse_char (pp, end, '+');
  87     feature->value = 1;
  88   }
  89
  90   return true;
  91 }
  92
  93 static hb_bool_t
  94 parse_feature_tag (const char **pp, const char *end, hb_feature_t *feature)
  95 {
  96   const char *p = *pp;
  97   char c;
  98
  99   parse_space (pp, end);
 100
 101 #define ISALNUM(c) (('a' <= (c) && (c) <= 'z') || ('A' <= (c) && (c) <= 'Z') || ('0' <= (c) && (c) <= '9'))
 102   while (*pp < end && (c = **pp, ISALNUM(c)))
 103     (*pp)++;
 104 #undef ISALNUM
 105
 106   if (p == *pp)
 107     return false;
 108
 109   feature->tag = hb_tag_from_string (p, *pp - p);
 110   return true;
 111 }
 112
 113 static hb_bool_t
 114 parse_feature_indices (const char **pp, const char *end, hb_feature_t *feature)
 115 {
 116   parse_space (pp, end);
 117
 118   hb_bool_t has_start;
 119
 120   feature->start = 0;
 121   feature->end = (unsigned int) -1;
 122
 123   if (!parse_char (pp, end, '['))
 124     return true;
 125
 126   has_start = parse_uint (pp, end, &feature->start);
 127
 128   if (parse_char (pp, end, ':')) {
 129     parse_uint (pp, end, &feature->end);
 130   } else {
 131     if (has_start)
 132       feature->end = feature->start + 1;
 133   }
 134
 135   return parse_char (pp, end, ']');
 136 }
 137
 138 static hb_bool_t
 139 parse_feature_value_postfix (const char **pp, const char *end, hb_feature_t *feature)
 140 {
 141   return !parse_char (pp, end, '=') || parse_uint (pp, end, &feature->value);
 142 }
 143
 144
 145 static hb_bool_t
 146 parse_one_feature (const char **pp, const char *end, hb_feature_t *feature)
 147 {
 148   return parse_feature_value_prefix (pp, end, feature) &&
 149          parse_feature_tag (pp, end, feature) &&
 150          parse_feature_indices (pp, end, feature) &&
 151          parse_feature_value_postfix (pp, end, feature) &&
 152          *pp == end;
 153 }
 154
 155 hb_bool_t
 156 hb_feature_from_string (const char *str, int len,
 157                         hb_feature_t *feature)
 158 {
 159   if (len < 0)
 160     len = strlen (str);
 161
 162   return parse_one_feature (&str, str + len, feature);
 163 }
 164
 165 void
 166 hb_feature_to_string (hb_feature_t *feature,
 167                       char *buf, unsigned int size)
 168 {
 169   if (unlikely (!size)) return;
 170
 171   char s[128];
 172   unsigned int len = 0;
 173   if (feature->value == 0)
 174     s[len++] = '-';
 175   hb_tag_to_string (feature->tag, s + len);
 176   len += 4;
 177   while (len && s[len - 1] == ' ')
 178     len--;
 179   if (feature->start != 0 || feature->start != (unsigned int) -1)
 180   {
 181     s[len++] = '[';
 182     if (feature->start)
 183       len += snprintf (s + len, ARRAY_LENGTH (s) - len, "%d", feature->start);
 184     if (feature->end != feature->start + 1) {
 185       s[len++] = ':';
 186       if (feature->end != (unsigned int) -1)
 187         len += snprintf (s + len, ARRAY_LENGTH (s) - len, "%d", feature->end);
 188     }
 189     s[len++] = ']';
 190   }
 191   if (feature->value > 1)
 192   {
 193     s[len++] = '=';
 194     len += snprintf (s + len, ARRAY_LENGTH (s) - len, "%d", feature->value);
 195   }
 196   assert (len < ARRAY_LENGTH (s));
 197   len = MIN (len, size - 1);
 198   memcpy (buf, s, len);
 199   s[len] = '\0';
 200 }
 201
 202
 203 static const char **static_shaper_list;
 204
 205 static
 206 void free_static_shaper_list (void)
 207 {
 208   free (static_shaper_list);
 209 }
 210
 211 const char **
 212 hb_shape_list_shapers (void)
 213 {
 214 retry:
 215   const char **shaper_list = (const char **) hb_atomic_ptr_get (&static_shaper_list);
 216
 217   if (unlikely (!shaper_list))
 218   {
 219     /* Not found; allocate one. */
 220     shaper_list = (const char **) calloc (1 + HB_SHAPERS_COUNT, sizeof (const char *));
 221     if (unlikely (!shaper_list)) {
 222       static const char *nil_shaper_list[] = {NULL};
 223       return nil_shaper_list;
 224     }
 225
 226     const hb_shaper_pair_t *shapers = _hb_shapers_get ();
 227     unsigned int i;
 228     for (i = 0; i < HB_SHAPERS_COUNT; i++)
 229       shaper_list[i] = shapers[i].name;
 230     shaper_list[i] = NULL;
 231
 232     if (!hb_atomic_ptr_cmpexch (&static_shaper_list, NULL, shaper_list)) {
 233       free (shaper_list);
 234       goto retry;
 235     }
 236
 237 #ifdef HAVE_ATEXIT
 238     atexit (free_static_shaper_list); /* First person registers atexit() callback. */
 239 #endif
 240   }
 241
 242   return shaper_list;
 243 }
 244
 245
 246 hb_bool_t
 247 hb_shape_full (hb_font_t          *font,
 248                hb_buffer_t        *buffer,
 249                const hb_feature_t *features,
 250                unsigned int        num_features,
 251                const char * const *shaper_list)
 252 {
 253   if (unlikely (!buffer->len))
 254     return true;
 255
 256   assert (buffer->content_type == HB_BUFFER_CONTENT_TYPE_UNICODE);
 257
 258   buffer->guess_properties ();
 259
 260   hb_shape_plan_t *shape_plan = hb_shape_plan_create_cached (font->face, &buffer->props, features, num_features, shaper_list);
 261   hb_bool_t res = hb_shape_plan_execute (shape_plan, font, buffer, features, num_features);
 262   hb_shape_plan_destroy (shape_plan);
 263
 264   if (res)
 265     buffer->content_type = HB_BUFFER_CONTENT_TYPE_GLYPHS;
 266   return res;
 267 }
 268
 269 void
 270 hb_shape (hb_font_t           *font,
 271           hb_buffer_t         *buffer,
 272           const hb_feature_t  *features,
 273           unsigned int         num_features)
 274 {
 275   hb_shape_full (font, buffer, features, num_features, NULL);
 276 }