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
parse_space(const char ** pp,const char * end)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
parse_char(const char ** pp,const char * end,char c)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
parse_uint(const char ** pp,const char * end,unsigned int * pv)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
parse_feature_value_prefix(const char ** pp,const char * end,hb_feature_t * feature)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
parse_feature_tag(const char ** pp,const char * end,hb_feature_t * feature)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
parse_feature_indices(const char ** pp,const char * end,hb_feature_t * feature)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
parse_feature_value_postfix(const char ** pp,const char * end,hb_feature_t * feature)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
parse_one_feature(const char ** pp,const char * end,hb_feature_t * feature)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
hb_feature_from_string(const char * str,int len,hb_feature_t * feature)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
hb_feature_to_string(hb_feature_t * feature,char * buf,unsigned int size)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
free_static_shaper_list(void)207 void free_static_shaper_list (void)
208 {
209 free (static_shaper_list);
210 }
211
212 const char **
hb_shape_list_shapers(void)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
hb_shape_full(hb_font_t * font,hb_buffer_t * buffer,const hb_feature_t * features,unsigned int num_features,const char * const * shaper_list)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
hb_shape(hb_font_t * font,hb_buffer_t * buffer,const hb_feature_t * features,unsigned int num_features)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 }
276