1// © 2016 and later: Unicode, Inc. and others. 2// License & terms of use: http://www.unicode.org/copyright.html 3/* 4******************************************************************************* 5* 6* Copyright (C) 1999-2015, International Business Machines 7* Corporation and others. All Rights Reserved. 8* 9******************************************************************************* 10* file name: utf8.h 11* encoding: UTF-8 12* tab size: 8 (not used) 13* indentation:4 14* 15* created on: 1999sep13 16* created by: Markus W. Scherer 17*/ 18 19/** 20 * \file 21 * \brief C API: 8-bit Unicode handling macros 22 * 23 * This file defines macros to deal with 8-bit Unicode (UTF-8) code units (bytes) and strings. 24 * 25 * For more information see utf.h and the ICU User Guide Strings chapter 26 * (http://userguide.icu-project.org/strings). 27 * 28 * <em>Usage:</em> 29 * ICU coding guidelines for if() statements should be followed when using these macros. 30 * Compound statements (curly braces {}) must be used for if-else-while... 31 * bodies and all macro statements should be terminated with semicolon. 32 */ 33 34#ifndef __UTF8_H__ 35#define __UTF8_H__ 36 37#include "unicode/umachine.h" 38#ifndef __UTF_H__ 39# include "unicode/utf.h" 40#endif 41 42/* internal definitions ----------------------------------------------------- */ 43 44/** 45 * Counts the trail bytes for a UTF-8 lead byte. 46 * Returns 0 for 0..0xc1 as well as for 0xf5..0xff. 47 * leadByte might be evaluated multiple times. 48 * 49 * This is internal since it is not meant to be called directly by external clients; 50 * however it is called by public macros in this file and thus must remain stable. 51 * 52 * @param leadByte The first byte of a UTF-8 sequence. Must be 0..0xff. 53 * @internal 54 */ 55#define U8_COUNT_TRAIL_BYTES(leadByte) \ 56 (U8_IS_LEAD(leadByte) ? \ 57 ((uint8_t)(leadByte)>=0xe0)+((uint8_t)(leadByte)>=0xf0)+1 : 0) 58 59/** 60 * Counts the trail bytes for a UTF-8 lead byte of a valid UTF-8 sequence. 61 * Returns 0 for 0..0xc1. Undefined for 0xf5..0xff. 62 * leadByte might be evaluated multiple times. 63 * 64 * This is internal since it is not meant to be called directly by external clients; 65 * however it is called by public macros in this file and thus must remain stable. 66 * 67 * @param leadByte The first byte of a UTF-8 sequence. Must be 0..0xff. 68 * @internal 69 */ 70#define U8_COUNT_TRAIL_BYTES_UNSAFE(leadByte) \ 71 (((uint8_t)(leadByte)>=0xc2)+((uint8_t)(leadByte)>=0xe0)+((uint8_t)(leadByte)>=0xf0)) 72 73/** 74 * Mask a UTF-8 lead byte, leave only the lower bits that form part of the code point value. 75 * 76 * This is internal since it is not meant to be called directly by external clients; 77 * however it is called by public macros in this file and thus must remain stable. 78 * @internal 79 */ 80#define U8_MASK_LEAD_BYTE(leadByte, countTrailBytes) ((leadByte)&=(1<<(6-(countTrailBytes)))-1) 81 82/** 83 * Internal bit vector for 3-byte UTF-8 validity check, for use in U8_IS_VALID_LEAD3_AND_T1. 84 * Each bit indicates whether one lead byte + first trail byte pair starts a valid sequence. 85 * Lead byte E0..EF bits 3..0 are used as byte index, 86 * first trail byte bits 7..5 are used as bit index into that byte. 87 * @see U8_IS_VALID_LEAD3_AND_T1 88 * @internal 89 */ 90#define U8_LEAD3_T1_BITS "\x20\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x30\x10\x30\x30" 91 92/** 93 * Internal 3-byte UTF-8 validity check. 94 * Non-zero if lead byte E0..EF and first trail byte 00..FF start a valid sequence. 95 * @internal 96 */ 97#define U8_IS_VALID_LEAD3_AND_T1(lead, t1) (U8_LEAD3_T1_BITS[(lead)&0xf]&(1<<((uint8_t)(t1)>>5))) 98 99/** 100 * Internal bit vector for 4-byte UTF-8 validity check, for use in U8_IS_VALID_LEAD4_AND_T1. 101 * Each bit indicates whether one lead byte + first trail byte pair starts a valid sequence. 102 * First trail byte bits 7..4 are used as byte index, 103 * lead byte F0..F4 bits 2..0 are used as bit index into that byte. 104 * @see U8_IS_VALID_LEAD4_AND_T1 105 * @internal 106 */ 107#define U8_LEAD4_T1_BITS "\x00\x00\x00\x00\x00\x00\x00\x00\x1E\x0F\x0F\x0F\x00\x00\x00\x00" 108 109/** 110 * Internal 4-byte UTF-8 validity check. 111 * Non-zero if lead byte F0..F4 and first trail byte 00..FF start a valid sequence. 112 * @internal 113 */ 114#define U8_IS_VALID_LEAD4_AND_T1(lead, t1) (U8_LEAD4_T1_BITS[(uint8_t)(t1)>>4]&(1<<((lead)&7))) 115 116/** 117 * Function for handling "next code point" with error-checking. 118 * 119 * This is internal since it is not meant to be called directly by external clients; 120 * however it is U_STABLE (not U_INTERNAL) since it is called by public macros in this 121 * file and thus must remain stable, and should not be hidden when other internal 122 * functions are hidden (otherwise public macros would fail to compile). 123 * @internal 124 */ 125U_STABLE UChar32 U_EXPORT2 126utf8_nextCharSafeBody(const uint8_t *s, int32_t *pi, int32_t length, UChar32 c, UBool strict); 127 128/** 129 * Function for handling "append code point" with error-checking. 130 * 131 * This is internal since it is not meant to be called directly by external clients; 132 * however it is U_STABLE (not U_INTERNAL) since it is called by public macros in this 133 * file and thus must remain stable, and should not be hidden when other internal 134 * functions are hidden (otherwise public macros would fail to compile). 135 * @internal 136 */ 137U_STABLE int32_t U_EXPORT2 138utf8_appendCharSafeBody(uint8_t *s, int32_t i, int32_t length, UChar32 c, UBool *pIsError); 139 140/** 141 * Function for handling "previous code point" with error-checking. 142 * 143 * This is internal since it is not meant to be called directly by external clients; 144 * however it is U_STABLE (not U_INTERNAL) since it is called by public macros in this 145 * file and thus must remain stable, and should not be hidden when other internal 146 * functions are hidden (otherwise public macros would fail to compile). 147 * @internal 148 */ 149U_STABLE UChar32 U_EXPORT2 150utf8_prevCharSafeBody(const uint8_t *s, int32_t start, int32_t *pi, UChar32 c, UBool strict); 151 152/** 153 * Function for handling "skip backward one code point" with error-checking. 154 * 155 * This is internal since it is not meant to be called directly by external clients; 156 * however it is U_STABLE (not U_INTERNAL) since it is called by public macros in this 157 * file and thus must remain stable, and should not be hidden when other internal 158 * functions are hidden (otherwise public macros would fail to compile). 159 * @internal 160 */ 161U_STABLE int32_t U_EXPORT2 162utf8_back1SafeBody(const uint8_t *s, int32_t start, int32_t i); 163 164/* single-code point definitions -------------------------------------------- */ 165 166/** 167 * Does this code unit (byte) encode a code point by itself (US-ASCII 0..0x7f)? 168 * @param c 8-bit code unit (byte) 169 * @return TRUE or FALSE 170 * @stable ICU 2.4 171 */ 172#define U8_IS_SINGLE(c) (((c)&0x80)==0) 173 174/** 175 * Is this code unit (byte) a UTF-8 lead byte? (0xC2..0xF4) 176 * @param c 8-bit code unit (byte) 177 * @return TRUE or FALSE 178 * @stable ICU 2.4 179 */ 180#define U8_IS_LEAD(c) ((uint8_t)((c)-0xc2)<=0x32) 181// 0x32=0xf4-0xc2 182 183/** 184 * Is this code unit (byte) a UTF-8 trail byte? (0x80..0xBF) 185 * @param c 8-bit code unit (byte) 186 * @return TRUE or FALSE 187 * @stable ICU 2.4 188 */ 189#define U8_IS_TRAIL(c) ((int8_t)(c)<-0x40) 190 191/** 192 * How many code units (bytes) are used for the UTF-8 encoding 193 * of this Unicode code point? 194 * @param c 32-bit code point 195 * @return 1..4, or 0 if c is a surrogate or not a Unicode code point 196 * @stable ICU 2.4 197 */ 198#define U8_LENGTH(c) \ 199 ((uint32_t)(c)<=0x7f ? 1 : \ 200 ((uint32_t)(c)<=0x7ff ? 2 : \ 201 ((uint32_t)(c)<=0xd7ff ? 3 : \ 202 ((uint32_t)(c)<=0xdfff || (uint32_t)(c)>0x10ffff ? 0 : \ 203 ((uint32_t)(c)<=0xffff ? 3 : 4)\ 204 ) \ 205 ) \ 206 ) \ 207 ) 208 209/** 210 * The maximum number of UTF-8 code units (bytes) per Unicode code point (U+0000..U+10ffff). 211 * @return 4 212 * @stable ICU 2.4 213 */ 214#define U8_MAX_LENGTH 4 215 216/** 217 * Get a code point from a string at a random-access offset, 218 * without changing the offset. 219 * The offset may point to either the lead byte or one of the trail bytes 220 * for a code point, in which case the macro will read all of the bytes 221 * for the code point. 222 * The result is undefined if the offset points to an illegal UTF-8 223 * byte sequence. 224 * Iteration through a string is more efficient with U8_NEXT_UNSAFE or U8_NEXT. 225 * 226 * @param s const uint8_t * string 227 * @param i string offset 228 * @param c output UChar32 variable 229 * @see U8_GET 230 * @stable ICU 2.4 231 */ 232#define U8_GET_UNSAFE(s, i, c) { \ 233 int32_t _u8_get_unsafe_index=(int32_t)(i); \ 234 U8_SET_CP_START_UNSAFE(s, _u8_get_unsafe_index); \ 235 U8_NEXT_UNSAFE(s, _u8_get_unsafe_index, c); \ 236} 237 238/** 239 * Get a code point from a string at a random-access offset, 240 * without changing the offset. 241 * The offset may point to either the lead byte or one of the trail bytes 242 * for a code point, in which case the macro will read all of the bytes 243 * for the code point. 244 * 245 * The length can be negative for a NUL-terminated string. 246 * 247 * If the offset points to an illegal UTF-8 byte sequence, then 248 * c is set to a negative value. 249 * Iteration through a string is more efficient with U8_NEXT_UNSAFE or U8_NEXT. 250 * 251 * @param s const uint8_t * string 252 * @param start int32_t starting string offset 253 * @param i int32_t string offset, must be start<=i<length 254 * @param length int32_t string length 255 * @param c output UChar32 variable, set to <0 in case of an error 256 * @see U8_GET_UNSAFE 257 * @stable ICU 2.4 258 */ 259#define U8_GET(s, start, i, length, c) { \ 260 int32_t _u8_get_index=(i); \ 261 U8_SET_CP_START(s, start, _u8_get_index); \ 262 U8_NEXT(s, _u8_get_index, length, c); \ 263} 264 265/** 266 * Get a code point from a string at a random-access offset, 267 * without changing the offset. 268 * The offset may point to either the lead byte or one of the trail bytes 269 * for a code point, in which case the macro will read all of the bytes 270 * for the code point. 271 * 272 * The length can be negative for a NUL-terminated string. 273 * 274 * If the offset points to an illegal UTF-8 byte sequence, then 275 * c is set to U+FFFD. 276 * Iteration through a string is more efficient with U8_NEXT_UNSAFE or U8_NEXT_OR_FFFD. 277 * 278 * This macro does not distinguish between a real U+FFFD in the text 279 * and U+FFFD returned for an ill-formed sequence. 280 * Use U8_GET() if that distinction is important. 281 * 282 * @param s const uint8_t * string 283 * @param start int32_t starting string offset 284 * @param i int32_t string offset, must be start<=i<length 285 * @param length int32_t string length 286 * @param c output UChar32 variable, set to U+FFFD in case of an error 287 * @see U8_GET 288 * @stable ICU 51 289 */ 290#define U8_GET_OR_FFFD(s, start, i, length, c) { \ 291 int32_t _u8_get_index=(i); \ 292 U8_SET_CP_START(s, start, _u8_get_index); \ 293 U8_NEXT_OR_FFFD(s, _u8_get_index, length, c); \ 294} 295 296/* definitions with forward iteration --------------------------------------- */ 297 298/** 299 * Get a code point from a string at a code point boundary offset, 300 * and advance the offset to the next code point boundary. 301 * (Post-incrementing forward iteration.) 302 * "Unsafe" macro, assumes well-formed UTF-8. 303 * 304 * The offset may point to the lead byte of a multi-byte sequence, 305 * in which case the macro will read the whole sequence. 306 * The result is undefined if the offset points to a trail byte 307 * or an illegal UTF-8 sequence. 308 * 309 * @param s const uint8_t * string 310 * @param i string offset 311 * @param c output UChar32 variable 312 * @see U8_NEXT 313 * @stable ICU 2.4 314 */ 315#define U8_NEXT_UNSAFE(s, i, c) { \ 316 (c)=(uint8_t)(s)[(i)++]; \ 317 if(!U8_IS_SINGLE(c)) { \ 318 if((c)<0xe0) { \ 319 (c)=(((c)&0x1f)<<6)|((s)[(i)++]&0x3f); \ 320 } else if((c)<0xf0) { \ 321 /* no need for (c&0xf) because the upper bits are truncated after <<12 in the cast to (UChar) */ \ 322 (c)=(UChar)(((c)<<12)|(((s)[i]&0x3f)<<6)|((s)[(i)+1]&0x3f)); \ 323 (i)+=2; \ 324 } else { \ 325 (c)=(((c)&7)<<18)|(((s)[i]&0x3f)<<12)|(((s)[(i)+1]&0x3f)<<6)|((s)[(i)+2]&0x3f); \ 326 (i)+=3; \ 327 } \ 328 } \ 329} 330 331/** 332 * Get a code point from a string at a code point boundary offset, 333 * and advance the offset to the next code point boundary. 334 * (Post-incrementing forward iteration.) 335 * "Safe" macro, checks for illegal sequences and for string boundaries. 336 * 337 * The length can be negative for a NUL-terminated string. 338 * 339 * The offset may point to the lead byte of a multi-byte sequence, 340 * in which case the macro will read the whole sequence. 341 * If the offset points to a trail byte or an illegal UTF-8 sequence, then 342 * c is set to a negative value. 343 * 344 * @param s const uint8_t * string 345 * @param i int32_t string offset, must be i<length 346 * @param length int32_t string length 347 * @param c output UChar32 variable, set to <0 in case of an error 348 * @see U8_NEXT_UNSAFE 349 * @stable ICU 2.4 350 */ 351#define U8_NEXT(s, i, length, c) { \ 352 (c)=(uint8_t)(s)[(i)++]; \ 353 if(!U8_IS_SINGLE(c)) { \ 354 uint8_t __t1, __t2; \ 355 if( /* handle U+0800..U+FFFF inline */ \ 356 (0xe0<=(c) && (c)<0xf0) && \ 357 (((i)+1)<(length) || (length)<0) && \ 358 U8_IS_VALID_LEAD3_AND_T1((c), __t1=(s)[i]) && \ 359 (__t2=(s)[(i)+1]-0x80)<=0x3f) { \ 360 (c)=(((c)&0xf)<<12)|((__t1&0x3f)<<6)|__t2; \ 361 (i)+=2; \ 362 } else if( /* handle U+0080..U+07FF inline */ \ 363 ((c)<0xe0 && (c)>=0xc2) && \ 364 ((i)!=(length)) && \ 365 (__t1=(s)[i]-0x80)<=0x3f) { \ 366 (c)=(((c)&0x1f)<<6)|__t1; \ 367 ++(i); \ 368 } else { \ 369 /* function call for "complicated" and error cases */ \ 370 (c)=utf8_nextCharSafeBody((const uint8_t *)s, &(i), (length), c, -1); \ 371 } \ 372 } \ 373} 374 375/** 376 * Get a code point from a string at a code point boundary offset, 377 * and advance the offset to the next code point boundary. 378 * (Post-incrementing forward iteration.) 379 * "Safe" macro, checks for illegal sequences and for string boundaries. 380 * 381 * The length can be negative for a NUL-terminated string. 382 * 383 * The offset may point to the lead byte of a multi-byte sequence, 384 * in which case the macro will read the whole sequence. 385 * If the offset points to a trail byte or an illegal UTF-8 sequence, then 386 * c is set to U+FFFD. 387 * 388 * This macro does not distinguish between a real U+FFFD in the text 389 * and U+FFFD returned for an ill-formed sequence. 390 * Use U8_NEXT() if that distinction is important. 391 * 392 * @param s const uint8_t * string 393 * @param i int32_t string offset, must be i<length 394 * @param length int32_t string length 395 * @param c output UChar32 variable, set to U+FFFD in case of an error 396 * @see U8_NEXT 397 * @stable ICU 51 398 */ 399#define U8_NEXT_OR_FFFD(s, i, length, c) { \ 400 (c)=(uint8_t)(s)[(i)++]; \ 401 if(!U8_IS_SINGLE(c)) { \ 402 uint8_t __t1, __t2; \ 403 if( /* handle U+0800..U+FFFF inline */ \ 404 (0xe0<=(c) && (c)<0xf0) && \ 405 (((i)+1)<(length) || (length)<0) && \ 406 U8_IS_VALID_LEAD3_AND_T1((c), __t1=(s)[i]) && \ 407 (__t2=(s)[(i)+1]-0x80)<=0x3f) { \ 408 (c)=(((c)&0xf)<<12)|((__t1&0x3f)<<6)|__t2; \ 409 (i)+=2; \ 410 } else if( /* handle U+0080..U+07FF inline */ \ 411 ((c)<0xe0 && (c)>=0xc2) && \ 412 ((i)!=(length)) && \ 413 (__t1=(s)[i]-0x80)<=0x3f) { \ 414 (c)=(((c)&0x1f)<<6)|__t1; \ 415 ++(i); \ 416 } else { \ 417 /* function call for "complicated" and error cases */ \ 418 (c)=utf8_nextCharSafeBody((const uint8_t *)s, &(i), (length), c, -3); \ 419 } \ 420 } \ 421} 422 423/** 424 * Append a code point to a string, overwriting 1 to 4 bytes. 425 * The offset points to the current end of the string contents 426 * and is advanced (post-increment). 427 * "Unsafe" macro, assumes a valid code point and sufficient space in the string. 428 * Otherwise, the result is undefined. 429 * 430 * @param s const uint8_t * string buffer 431 * @param i string offset 432 * @param c code point to append 433 * @see U8_APPEND 434 * @stable ICU 2.4 435 */ 436#define U8_APPEND_UNSAFE(s, i, c) { \ 437 if((uint32_t)(c)<=0x7f) { \ 438 (s)[(i)++]=(uint8_t)(c); \ 439 } else { \ 440 if((uint32_t)(c)<=0x7ff) { \ 441 (s)[(i)++]=(uint8_t)(((c)>>6)|0xc0); \ 442 } else { \ 443 if((uint32_t)(c)<=0xffff) { \ 444 (s)[(i)++]=(uint8_t)(((c)>>12)|0xe0); \ 445 } else { \ 446 (s)[(i)++]=(uint8_t)(((c)>>18)|0xf0); \ 447 (s)[(i)++]=(uint8_t)((((c)>>12)&0x3f)|0x80); \ 448 } \ 449 (s)[(i)++]=(uint8_t)((((c)>>6)&0x3f)|0x80); \ 450 } \ 451 (s)[(i)++]=(uint8_t)(((c)&0x3f)|0x80); \ 452 } \ 453} 454 455/** 456 * Append a code point to a string, overwriting 1 to 4 bytes. 457 * The offset points to the current end of the string contents 458 * and is advanced (post-increment). 459 * "Safe" macro, checks for a valid code point. 460 * If a non-ASCII code point is written, checks for sufficient space in the string. 461 * If the code point is not valid or trail bytes do not fit, 462 * then isError is set to TRUE. 463 * 464 * @param s const uint8_t * string buffer 465 * @param i int32_t string offset, must be i<capacity 466 * @param capacity int32_t size of the string buffer 467 * @param c UChar32 code point to append 468 * @param isError output UBool set to TRUE if an error occurs, otherwise not modified 469 * @see U8_APPEND_UNSAFE 470 * @stable ICU 2.4 471 */ 472#define U8_APPEND(s, i, capacity, c, isError) { \ 473 if((uint32_t)(c)<=0x7f) { \ 474 (s)[(i)++]=(uint8_t)(c); \ 475 } else if((uint32_t)(c)<=0x7ff && (i)+1<(capacity)) { \ 476 (s)[(i)++]=(uint8_t)(((c)>>6)|0xc0); \ 477 (s)[(i)++]=(uint8_t)(((c)&0x3f)|0x80); \ 478 } else if((uint32_t)(c)<=0xd7ff && (i)+2<(capacity)) { \ 479 (s)[(i)++]=(uint8_t)(((c)>>12)|0xe0); \ 480 (s)[(i)++]=(uint8_t)((((c)>>6)&0x3f)|0x80); \ 481 (s)[(i)++]=(uint8_t)(((c)&0x3f)|0x80); \ 482 } else { \ 483 (i)=utf8_appendCharSafeBody(s, (i), (capacity), c, &(isError)); \ 484 } \ 485} 486 487/** 488 * Advance the string offset from one code point boundary to the next. 489 * (Post-incrementing iteration.) 490 * "Unsafe" macro, assumes well-formed UTF-8. 491 * 492 * @param s const uint8_t * string 493 * @param i string offset 494 * @see U8_FWD_1 495 * @stable ICU 2.4 496 */ 497#define U8_FWD_1_UNSAFE(s, i) { \ 498 (i)+=1+U8_COUNT_TRAIL_BYTES_UNSAFE((s)[i]); \ 499} 500 501/** 502 * Advance the string offset from one code point boundary to the next. 503 * (Post-incrementing iteration.) 504 * "Safe" macro, checks for illegal sequences and for string boundaries. 505 * 506 * The length can be negative for a NUL-terminated string. 507 * 508 * @param s const uint8_t * string 509 * @param i int32_t string offset, must be i<length 510 * @param length int32_t string length 511 * @see U8_FWD_1_UNSAFE 512 * @stable ICU 2.4 513 */ 514#define U8_FWD_1(s, i, length) { \ 515 uint8_t __b=(s)[(i)++]; \ 516 if(U8_IS_LEAD(__b) && (i)!=(length)) { \ 517 uint8_t __t1=(s)[i]; \ 518 if((0xe0<=__b && __b<0xf0)) { \ 519 if(U8_IS_VALID_LEAD3_AND_T1(__b, __t1) && \ 520 ++(i)!=(length) && U8_IS_TRAIL((s)[i])) { \ 521 ++(i); \ 522 } \ 523 } else if(__b<0xe0) { \ 524 if(U8_IS_TRAIL(__t1)) { \ 525 ++(i); \ 526 } \ 527 } else /* c>=0xf0 */ { \ 528 if(U8_IS_VALID_LEAD4_AND_T1(__b, __t1) && \ 529 ++(i)!=(length) && U8_IS_TRAIL((s)[i]) && \ 530 ++(i)!=(length) && U8_IS_TRAIL((s)[i])) { \ 531 ++(i); \ 532 } \ 533 } \ 534 } \ 535} 536 537/** 538 * Advance the string offset from one code point boundary to the n-th next one, 539 * i.e., move forward by n code points. 540 * (Post-incrementing iteration.) 541 * "Unsafe" macro, assumes well-formed UTF-8. 542 * 543 * @param s const uint8_t * string 544 * @param i string offset 545 * @param n number of code points to skip 546 * @see U8_FWD_N 547 * @stable ICU 2.4 548 */ 549#define U8_FWD_N_UNSAFE(s, i, n) { \ 550 int32_t __N=(n); \ 551 while(__N>0) { \ 552 U8_FWD_1_UNSAFE(s, i); \ 553 --__N; \ 554 } \ 555} 556 557/** 558 * Advance the string offset from one code point boundary to the n-th next one, 559 * i.e., move forward by n code points. 560 * (Post-incrementing iteration.) 561 * "Safe" macro, checks for illegal sequences and for string boundaries. 562 * 563 * The length can be negative for a NUL-terminated string. 564 * 565 * @param s const uint8_t * string 566 * @param i int32_t string offset, must be i<length 567 * @param length int32_t string length 568 * @param n number of code points to skip 569 * @see U8_FWD_N_UNSAFE 570 * @stable ICU 2.4 571 */ 572#define U8_FWD_N(s, i, length, n) { \ 573 int32_t __N=(n); \ 574 while(__N>0 && ((i)<(length) || ((length)<0 && (s)[i]!=0))) { \ 575 U8_FWD_1(s, i, length); \ 576 --__N; \ 577 } \ 578} 579 580/** 581 * Adjust a random-access offset to a code point boundary 582 * at the start of a code point. 583 * If the offset points to a UTF-8 trail byte, 584 * then the offset is moved backward to the corresponding lead byte. 585 * Otherwise, it is not modified. 586 * "Unsafe" macro, assumes well-formed UTF-8. 587 * 588 * @param s const uint8_t * string 589 * @param i string offset 590 * @see U8_SET_CP_START 591 * @stable ICU 2.4 592 */ 593#define U8_SET_CP_START_UNSAFE(s, i) { \ 594 while(U8_IS_TRAIL((s)[i])) { --(i); } \ 595} 596 597/** 598 * Adjust a random-access offset to a code point boundary 599 * at the start of a code point. 600 * If the offset points to a UTF-8 trail byte, 601 * then the offset is moved backward to the corresponding lead byte. 602 * Otherwise, it is not modified. 603 * "Safe" macro, checks for illegal sequences and for string boundaries. 604 * 605 * @param s const uint8_t * string 606 * @param start int32_t starting string offset (usually 0) 607 * @param i int32_t string offset, must be start<=i 608 * @see U8_SET_CP_START_UNSAFE 609 * @stable ICU 2.4 610 */ 611#define U8_SET_CP_START(s, start, i) { \ 612 if(U8_IS_TRAIL((s)[(i)])) { \ 613 (i)=utf8_back1SafeBody(s, start, (i)); \ 614 } \ 615} 616 617/* definitions with backward iteration -------------------------------------- */ 618 619/** 620 * Move the string offset from one code point boundary to the previous one 621 * and get the code point between them. 622 * (Pre-decrementing backward iteration.) 623 * "Unsafe" macro, assumes well-formed UTF-8. 624 * 625 * The input offset may be the same as the string length. 626 * If the offset is behind a multi-byte sequence, then the macro will read 627 * the whole sequence. 628 * If the offset is behind a lead byte, then that itself 629 * will be returned as the code point. 630 * The result is undefined if the offset is behind an illegal UTF-8 sequence. 631 * 632 * @param s const uint8_t * string 633 * @param i string offset 634 * @param c output UChar32 variable 635 * @see U8_PREV 636 * @stable ICU 2.4 637 */ 638#define U8_PREV_UNSAFE(s, i, c) { \ 639 (c)=(uint8_t)(s)[--(i)]; \ 640 if(U8_IS_TRAIL(c)) { \ 641 uint8_t __b, __count=1, __shift=6; \ 642\ 643 /* c is a trail byte */ \ 644 (c)&=0x3f; \ 645 for(;;) { \ 646 __b=(s)[--(i)]; \ 647 if(__b>=0xc0) { \ 648 U8_MASK_LEAD_BYTE(__b, __count); \ 649 (c)|=(UChar32)__b<<__shift; \ 650 break; \ 651 } else { \ 652 (c)|=(UChar32)(__b&0x3f)<<__shift; \ 653 ++__count; \ 654 __shift+=6; \ 655 } \ 656 } \ 657 } \ 658} 659 660/** 661 * Move the string offset from one code point boundary to the previous one 662 * and get the code point between them. 663 * (Pre-decrementing backward iteration.) 664 * "Safe" macro, checks for illegal sequences and for string boundaries. 665 * 666 * The input offset may be the same as the string length. 667 * If the offset is behind a multi-byte sequence, then the macro will read 668 * the whole sequence. 669 * If the offset is behind a lead byte, then that itself 670 * will be returned as the code point. 671 * If the offset is behind an illegal UTF-8 sequence, then c is set to a negative value. 672 * 673 * @param s const uint8_t * string 674 * @param start int32_t starting string offset (usually 0) 675 * @param i int32_t string offset, must be start<i 676 * @param c output UChar32 variable, set to <0 in case of an error 677 * @see U8_PREV_UNSAFE 678 * @stable ICU 2.4 679 */ 680#define U8_PREV(s, start, i, c) { \ 681 (c)=(uint8_t)(s)[--(i)]; \ 682 if(!U8_IS_SINGLE(c)) { \ 683 (c)=utf8_prevCharSafeBody((const uint8_t *)s, start, &(i), c, -1); \ 684 } \ 685} 686 687/** 688 * Move the string offset from one code point boundary to the previous one 689 * and get the code point between them. 690 * (Pre-decrementing backward iteration.) 691 * "Safe" macro, checks for illegal sequences and for string boundaries. 692 * 693 * The input offset may be the same as the string length. 694 * If the offset is behind a multi-byte sequence, then the macro will read 695 * the whole sequence. 696 * If the offset is behind a lead byte, then that itself 697 * will be returned as the code point. 698 * If the offset is behind an illegal UTF-8 sequence, then c is set to U+FFFD. 699 * 700 * This macro does not distinguish between a real U+FFFD in the text 701 * and U+FFFD returned for an ill-formed sequence. 702 * Use U8_PREV() if that distinction is important. 703 * 704 * @param s const uint8_t * string 705 * @param start int32_t starting string offset (usually 0) 706 * @param i int32_t string offset, must be start<i 707 * @param c output UChar32 variable, set to U+FFFD in case of an error 708 * @see U8_PREV 709 * @stable ICU 51 710 */ 711#define U8_PREV_OR_FFFD(s, start, i, c) { \ 712 (c)=(uint8_t)(s)[--(i)]; \ 713 if(!U8_IS_SINGLE(c)) { \ 714 (c)=utf8_prevCharSafeBody((const uint8_t *)s, start, &(i), c, -3); \ 715 } \ 716} 717 718/** 719 * Move the string offset from one code point boundary to the previous one. 720 * (Pre-decrementing backward iteration.) 721 * The input offset may be the same as the string length. 722 * "Unsafe" macro, assumes well-formed UTF-8. 723 * 724 * @param s const uint8_t * string 725 * @param i string offset 726 * @see U8_BACK_1 727 * @stable ICU 2.4 728 */ 729#define U8_BACK_1_UNSAFE(s, i) { \ 730 while(U8_IS_TRAIL((s)[--(i)])) {} \ 731} 732 733/** 734 * Move the string offset from one code point boundary to the previous one. 735 * (Pre-decrementing backward iteration.) 736 * The input offset may be the same as the string length. 737 * "Safe" macro, checks for illegal sequences and for string boundaries. 738 * 739 * @param s const uint8_t * string 740 * @param start int32_t starting string offset (usually 0) 741 * @param i int32_t string offset, must be start<i 742 * @see U8_BACK_1_UNSAFE 743 * @stable ICU 2.4 744 */ 745#define U8_BACK_1(s, start, i) { \ 746 if(U8_IS_TRAIL((s)[--(i)])) { \ 747 (i)=utf8_back1SafeBody(s, start, (i)); \ 748 } \ 749} 750 751/** 752 * Move the string offset from one code point boundary to the n-th one before it, 753 * i.e., move backward by n code points. 754 * (Pre-decrementing backward iteration.) 755 * The input offset may be the same as the string length. 756 * "Unsafe" macro, assumes well-formed UTF-8. 757 * 758 * @param s const uint8_t * string 759 * @param i string offset 760 * @param n number of code points to skip 761 * @see U8_BACK_N 762 * @stable ICU 2.4 763 */ 764#define U8_BACK_N_UNSAFE(s, i, n) { \ 765 int32_t __N=(n); \ 766 while(__N>0) { \ 767 U8_BACK_1_UNSAFE(s, i); \ 768 --__N; \ 769 } \ 770} 771 772/** 773 * Move the string offset from one code point boundary to the n-th one before it, 774 * i.e., move backward by n code points. 775 * (Pre-decrementing backward iteration.) 776 * The input offset may be the same as the string length. 777 * "Safe" macro, checks for illegal sequences and for string boundaries. 778 * 779 * @param s const uint8_t * string 780 * @param start int32_t index of the start of the string 781 * @param i int32_t string offset, must be start<i 782 * @param n number of code points to skip 783 * @see U8_BACK_N_UNSAFE 784 * @stable ICU 2.4 785 */ 786#define U8_BACK_N(s, start, i, n) { \ 787 int32_t __N=(n); \ 788 while(__N>0 && (i)>(start)) { \ 789 U8_BACK_1(s, start, i); \ 790 --__N; \ 791 } \ 792} 793 794/** 795 * Adjust a random-access offset to a code point boundary after a code point. 796 * If the offset is behind a partial multi-byte sequence, 797 * then the offset is incremented to behind the whole sequence. 798 * Otherwise, it is not modified. 799 * The input offset may be the same as the string length. 800 * "Unsafe" macro, assumes well-formed UTF-8. 801 * 802 * @param s const uint8_t * string 803 * @param i string offset 804 * @see U8_SET_CP_LIMIT 805 * @stable ICU 2.4 806 */ 807#define U8_SET_CP_LIMIT_UNSAFE(s, i) { \ 808 U8_BACK_1_UNSAFE(s, i); \ 809 U8_FWD_1_UNSAFE(s, i); \ 810} 811 812/** 813 * Adjust a random-access offset to a code point boundary after a code point. 814 * If the offset is behind a partial multi-byte sequence, 815 * then the offset is incremented to behind the whole sequence. 816 * Otherwise, it is not modified. 817 * The input offset may be the same as the string length. 818 * "Safe" macro, checks for illegal sequences and for string boundaries. 819 * 820 * The length can be negative for a NUL-terminated string. 821 * 822 * @param s const uint8_t * string 823 * @param start int32_t starting string offset (usually 0) 824 * @param i int32_t string offset, must be start<=i<=length 825 * @param length int32_t string length 826 * @see U8_SET_CP_LIMIT_UNSAFE 827 * @stable ICU 2.4 828 */ 829#define U8_SET_CP_LIMIT(s, start, i, length) { \ 830 if((start)<(i) && ((i)<(length) || (length)<0)) { \ 831 U8_BACK_1(s, start, i); \ 832 U8_FWD_1(s, i, length); \ 833 } \ 834} 835 836#endif 837