1 /* 2 * Copyright 2011,2012,2014 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 #ifndef HB_UTF_HH 28 #define HB_UTF_HH 29 30 #include "hb.hh" 31 32 #include "hb-open-type.hh" 33 34 35 struct hb_utf8_t 36 { 37 typedef uint8_t codepoint_t; 38 39 static const codepoint_t * 40 next (const codepoint_t *text, 41 const codepoint_t *end, 42 hb_codepoint_t *unicode, 43 hb_codepoint_t replacement) 44 { 45 /* Written to only accept well-formed sequences. 46 * Based on ideas from ICU's U8_NEXT. 47 * Generates one "replacement" for each ill-formed byte. */ 48 49 hb_codepoint_t c = *text++; 50 51 if (c > 0x7Fu) 52 { 53 if (hb_in_range<hb_codepoint_t> (c, 0xC2u, 0xDFu)) /* Two-byte */ 54 { 55 unsigned int t1; 56 if (likely (text < end && 57 (t1 = text[0] - 0x80u) <= 0x3Fu)) 58 { 59 c = ((c&0x1Fu)<<6) | t1; 60 text++; 61 } 62 else 63 goto error; 64 } 65 else if (hb_in_range<hb_codepoint_t> (c, 0xE0u, 0xEFu)) /* Three-byte */ 66 { 67 unsigned int t1, t2; 68 if (likely (1 < end - text && 69 (t1 = text[0] - 0x80u) <= 0x3Fu && 70 (t2 = text[1] - 0x80u) <= 0x3Fu)) 71 { 72 c = ((c&0xFu)<<12) | (t1<<6) | t2; 73 if (unlikely (c < 0x0800u || hb_in_range<hb_codepoint_t> (c, 0xD800u, 0xDFFFu))) 74 goto error; 75 text += 2; 76 } 77 else 78 goto error; 79 } 80 else if (hb_in_range<hb_codepoint_t> (c, 0xF0u, 0xF4u)) /* Four-byte */ 81 { 82 unsigned int t1, t2, t3; 83 if (likely (2 < end - text && 84 (t1 = text[0] - 0x80u) <= 0x3Fu && 85 (t2 = text[1] - 0x80u) <= 0x3Fu && 86 (t3 = text[2] - 0x80u) <= 0x3Fu)) 87 { 88 c = ((c&0x7u)<<18) | (t1<<12) | (t2<<6) | t3; 89 if (unlikely (!hb_in_range<hb_codepoint_t> (c, 0x10000u, 0x10FFFFu))) 90 goto error; 91 text += 3; 92 } 93 else 94 goto error; 95 } 96 else 97 goto error; 98 } 99 100 *unicode = c; 101 return text; 102 103 error: 104 *unicode = replacement; 105 return text; 106 } 107 108 static const codepoint_t * 109 prev (const codepoint_t *text, 110 const codepoint_t *start, 111 hb_codepoint_t *unicode, 112 hb_codepoint_t replacement) 113 { 114 const codepoint_t *end = text--; 115 while (start < text && (*text & 0xc0) == 0x80 && end - text < 4) 116 text--; 117 118 if (likely (next (text, end, unicode, replacement) == end)) 119 return text; 120 121 *unicode = replacement; 122 return end - 1; 123 } 124 125 static unsigned int 126 strlen (const codepoint_t *text) 127 { return ::strlen ((const char *) text); } 128 129 static unsigned int 130 encode_len (hb_codepoint_t unicode) 131 { 132 if (unicode < 0x0080u) return 1; 133 if (unicode < 0x0800u) return 2; 134 if (unicode < 0x10000u) return 3; 135 if (unicode < 0x110000u) return 4; 136 return 3; 137 } 138 139 static codepoint_t * 140 encode (codepoint_t *text, 141 const codepoint_t *end, 142 hb_codepoint_t unicode) 143 { 144 if (unlikely (unicode >= 0xD800u && (unicode <= 0xDFFFu || unicode > 0x10FFFFu))) 145 unicode = 0xFFFDu; 146 if (unicode < 0x0080u) 147 *text++ = unicode; 148 else if (unicode < 0x0800u) 149 { 150 if (end - text >= 2) 151 { 152 *text++ = 0xC0u + (0x1Fu & (unicode >> 6)); 153 *text++ = 0x80u + (0x3Fu & (unicode )); 154 } 155 } 156 else if (unicode < 0x10000u) 157 { 158 if (end - text >= 3) 159 { 160 *text++ = 0xE0u + (0x0Fu & (unicode >> 12)); 161 *text++ = 0x80u + (0x3Fu & (unicode >> 6)); 162 *text++ = 0x80u + (0x3Fu & (unicode )); 163 } 164 } 165 else 166 { 167 if (end - text >= 4) 168 { 169 *text++ = 0xF0u + (0x07u & (unicode >> 18)); 170 *text++ = 0x80u + (0x3Fu & (unicode >> 12)); 171 *text++ = 0x80u + (0x3Fu & (unicode >> 6)); 172 *text++ = 0x80u + (0x3Fu & (unicode )); 173 } 174 } 175 return text; 176 } 177 }; 178 179 180 template <typename TCodepoint> 181 struct hb_utf16_xe_t 182 { 183 static_assert (sizeof (TCodepoint) == 2, ""); 184 typedef TCodepoint codepoint_t; 185 186 static const codepoint_t * 187 next (const codepoint_t *text, 188 const codepoint_t *end, 189 hb_codepoint_t *unicode, 190 hb_codepoint_t replacement) 191 { 192 hb_codepoint_t c = *text++; 193 194 if (likely (!hb_in_range<hb_codepoint_t> (c, 0xD800u, 0xDFFFu))) 195 { 196 *unicode = c; 197 return text; 198 } 199 200 if (likely (c <= 0xDBFFu && text < end)) 201 { 202 /* High-surrogate in c */ 203 hb_codepoint_t l = *text; 204 if (likely (hb_in_range<hb_codepoint_t> (l, 0xDC00u, 0xDFFFu))) 205 { 206 /* Low-surrogate in l */ 207 *unicode = (c << 10) + l - ((0xD800u << 10) - 0x10000u + 0xDC00u); 208 text++; 209 return text; 210 } 211 } 212 213 /* Lonely / out-of-order surrogate. */ 214 *unicode = replacement; 215 return text; 216 } 217 218 static const codepoint_t * 219 prev (const codepoint_t *text, 220 const codepoint_t *start, 221 hb_codepoint_t *unicode, 222 hb_codepoint_t replacement) 223 { 224 hb_codepoint_t c = *--text; 225 226 if (likely (!hb_in_range<hb_codepoint_t> (c, 0xD800u, 0xDFFFu))) 227 { 228 *unicode = c; 229 return text; 230 } 231 232 if (likely (c >= 0xDC00u && start < text)) 233 { 234 /* Low-surrogate in c */ 235 hb_codepoint_t h = text[-1]; 236 if (likely (hb_in_range<hb_codepoint_t> (h, 0xD800u, 0xDBFFu))) 237 { 238 /* High-surrogate in h */ 239 *unicode = (h << 10) + c - ((0xD800u << 10) - 0x10000u + 0xDC00u); 240 text--; 241 return text; 242 } 243 } 244 245 /* Lonely / out-of-order surrogate. */ 246 *unicode = replacement; 247 return text; 248 } 249 250 251 static unsigned int 252 strlen (const codepoint_t *text) 253 { 254 unsigned int l = 0; 255 while (*text++) l++; 256 return l; 257 } 258 259 static unsigned int 260 encode_len (hb_codepoint_t unicode) 261 { 262 return unicode < 0x10000 ? 1 : 2; 263 } 264 265 static codepoint_t * 266 encode (codepoint_t *text, 267 const codepoint_t *end, 268 hb_codepoint_t unicode) 269 { 270 if (unlikely (unicode >= 0xD800u && (unicode <= 0xDFFFu || unicode > 0x10FFFFu))) 271 unicode = 0xFFFDu; 272 if (unicode < 0x10000u) 273 *text++ = unicode; 274 else if (end - text >= 2) 275 { 276 unicode -= 0x10000u; 277 *text++ = 0xD800u + (unicode >> 10); 278 *text++ = 0xDC00u + (unicode & 0x03FFu); 279 } 280 return text; 281 } 282 }; 283 284 typedef hb_utf16_xe_t<uint16_t> hb_utf16_t; 285 typedef hb_utf16_xe_t<OT::HBUINT16> hb_utf16_be_t; 286 287 288 template <typename TCodepoint, bool validate=true> 289 struct hb_utf32_xe_t 290 { 291 static_assert (sizeof (TCodepoint) == 4, ""); 292 typedef TCodepoint codepoint_t; 293 294 static const TCodepoint * 295 next (const TCodepoint *text, 296 const TCodepoint *end HB_UNUSED, 297 hb_codepoint_t *unicode, 298 hb_codepoint_t replacement) 299 { 300 hb_codepoint_t c = *unicode = *text++; 301 if (validate && unlikely (c >= 0xD800u && (c <= 0xDFFFu || c > 0x10FFFFu))) 302 *unicode = replacement; 303 return text; 304 } 305 306 static const TCodepoint * 307 prev (const TCodepoint *text, 308 const TCodepoint *start HB_UNUSED, 309 hb_codepoint_t *unicode, 310 hb_codepoint_t replacement) 311 { 312 hb_codepoint_t c = *unicode = *--text; 313 if (validate && unlikely (c >= 0xD800u && (c <= 0xDFFFu || c > 0x10FFFFu))) 314 *unicode = replacement; 315 return text; 316 } 317 318 static unsigned int 319 strlen (const TCodepoint *text) 320 { 321 unsigned int l = 0; 322 while (*text++) l++; 323 return l; 324 } 325 326 static unsigned int 327 encode_len (hb_codepoint_t unicode HB_UNUSED) 328 { 329 return 1; 330 } 331 332 static codepoint_t * 333 encode (codepoint_t *text, 334 const codepoint_t *end HB_UNUSED, 335 hb_codepoint_t unicode) 336 { 337 if (validate && unlikely (unicode >= 0xD800u && (unicode <= 0xDFFFu || unicode > 0x10FFFFu))) 338 unicode = 0xFFFDu; 339 *text++ = unicode; 340 return text; 341 } 342 }; 343 344 typedef hb_utf32_xe_t<uint32_t> hb_utf32_t; 345 typedef hb_utf32_xe_t<uint32_t, false> hb_utf32_novalidate_t; 346 347 348 struct hb_latin1_t 349 { 350 typedef uint8_t codepoint_t; 351 352 static const codepoint_t * 353 next (const codepoint_t *text, 354 const codepoint_t *end HB_UNUSED, 355 hb_codepoint_t *unicode, 356 hb_codepoint_t replacement HB_UNUSED) 357 { 358 *unicode = *text++; 359 return text; 360 } 361 362 static const codepoint_t * 363 prev (const codepoint_t *text, 364 const codepoint_t *start HB_UNUSED, 365 hb_codepoint_t *unicode, 366 hb_codepoint_t replacement HB_UNUSED) 367 { 368 *unicode = *--text; 369 return text; 370 } 371 372 static unsigned int 373 strlen (const codepoint_t *text) 374 { 375 unsigned int l = 0; 376 while (*text++) l++; 377 return l; 378 } 379 380 static unsigned int 381 encode_len (hb_codepoint_t unicode HB_UNUSED) 382 { 383 return 1; 384 } 385 386 static codepoint_t * 387 encode (codepoint_t *text, 388 const codepoint_t *end HB_UNUSED, 389 hb_codepoint_t unicode) 390 { 391 if (unlikely (unicode >= 0x0100u)) 392 unicode = '?'; 393 *text++ = unicode; 394 return text; 395 } 396 }; 397 398 399 struct hb_ascii_t 400 { 401 typedef uint8_t codepoint_t; 402 403 static const codepoint_t * 404 next (const codepoint_t *text, 405 const codepoint_t *end HB_UNUSED, 406 hb_codepoint_t *unicode, 407 hb_codepoint_t replacement HB_UNUSED) 408 { 409 *unicode = *text++; 410 if (*unicode >= 0x0080u) 411 *unicode = replacement; 412 return text; 413 } 414 415 static const codepoint_t * 416 prev (const codepoint_t *text, 417 const codepoint_t *start HB_UNUSED, 418 hb_codepoint_t *unicode, 419 hb_codepoint_t replacement) 420 { 421 *unicode = *--text; 422 if (*unicode >= 0x0080u) 423 *unicode = replacement; 424 return text; 425 } 426 427 static unsigned int 428 strlen (const codepoint_t *text) 429 { 430 unsigned int l = 0; 431 while (*text++) l++; 432 return l; 433 } 434 435 static unsigned int 436 encode_len (hb_codepoint_t unicode HB_UNUSED) 437 { 438 return 1; 439 } 440 441 static codepoint_t * 442 encode (codepoint_t *text, 443 const codepoint_t *end HB_UNUSED, 444 hb_codepoint_t unicode) 445 { 446 if (unlikely (unicode >= 0x0080u)) 447 unicode = '?'; 448 *text++ = unicode; 449 return text; 450 } 451 }; 452 453 #endif /* HB_UTF_HH */ 454
