338 lines
10 KiB
C
338 lines
10 KiB
C
/*
|
|
*******************************************************************************
|
|
*
|
|
* Copyright (C) 1999-2001, International Business Machines
|
|
* Corporation and others. All Rights Reserved.
|
|
*
|
|
*******************************************************************************
|
|
* file name: utf16.h
|
|
* encoding: US-ASCII
|
|
* tab size: 8 (not used)
|
|
* indentation:4
|
|
*
|
|
* created on: 1999sep09
|
|
* created by: Markus W. Scherer
|
|
*/
|
|
|
|
/**
|
|
* \file
|
|
* \brief C API: UTF-16 macros
|
|
*
|
|
* This file defines macros to deal with UTF-16 code units and code points.
|
|
* "Safe" macros check for length overruns and illegal sequences, and
|
|
* also for irregular sequences when the strict option is set.
|
|
* "Unsafe" macros are designed for maximum speed.
|
|
* utf16.h is included by utf.h after unicode/umachine.h
|
|
* and some common definitions.</p>
|
|
* <p><b>Usage:</b> ICU coding guidelines for if() statements should be followed when using these macros.
|
|
* Compound statements (curly braces {}) must be used for if-else-while...
|
|
* bodies and all macro statements should be terminated with semicolon.</p>
|
|
*/
|
|
|
|
#ifndef __UTF16_H__
|
|
#define __UTF16_H__
|
|
|
|
/* single-code point definitions -------------------------------------------- */
|
|
|
|
/* handle surrogate pairs */
|
|
#define UTF_IS_FIRST_SURROGATE(uchar) (((uchar)&0xfffffc00)==0xd800)
|
|
#define UTF_IS_SECOND_SURROGATE(uchar) (((uchar)&0xfffffc00)==0xdc00)
|
|
|
|
#define UTF_IS_SURROGATE_FIRST(c) (((c)&0x400)==0)
|
|
|
|
/** Get the UTF-32 value directly from the surrogate pseudo-characters */
|
|
#define UTF_SURROGATE_OFFSET ((0xd800<<10UL)+0xdc00-0x10000)
|
|
|
|
#define UTF16_GET_PAIR_VALUE(first, second) \
|
|
(((first)<<10UL)+(second)-UTF_SURROGATE_OFFSET)
|
|
|
|
/* get the first and second surrogates for a supplementary code point */
|
|
/**
|
|
* Takes a supplementary code point (0x10000..0x10ffff)
|
|
* and computes the first surrogate (0xd800..0xdbff)
|
|
* for UTF-16 encoding.
|
|
*/
|
|
#define UTF_FIRST_SURROGATE(supplementary) (UChar)(((supplementary)>>10)+0xd7c0)
|
|
|
|
/**
|
|
* Takes a supplementary code point (0x10000..0x10ffff)
|
|
* and computes the second surrogate (0xdc00..0xdfff)
|
|
* for UTF-16 encoding.
|
|
*/
|
|
#define UTF_SECOND_SURROGATE(supplementary) (UChar)(((supplementary)&0x3ff)|0xdc00)
|
|
|
|
/** alias for UTF_FIRST_SURROGATE */
|
|
#define UTF16_LEAD(supplementary) UTF_FIRST_SURROGATE(supplementary)
|
|
|
|
/** alias for UTF_SECOND_SURROGATE */
|
|
#define UTF16_TRAIL(supplementary) UTF_SECOND_SURROGATE(supplementary)
|
|
|
|
/* classes of code unit values */
|
|
#define UTF16_IS_SINGLE(uchar) !UTF_IS_SURROGATE(uchar)
|
|
#define UTF16_IS_LEAD(uchar) UTF_IS_FIRST_SURROGATE(uchar)
|
|
#define UTF16_IS_TRAIL(uchar) UTF_IS_SECOND_SURROGATE(uchar)
|
|
|
|
/* number of code units per code point */
|
|
#define UTF16_NEED_MULTIPLE_UCHAR(c) ((uint32_t)(c)>0xffff)
|
|
#define UTF16_CHAR_LENGTH(c) ((uint32_t)(c)<=0xffff ? 1 : 2)
|
|
#define UTF16_MAX_CHAR_LENGTH 2
|
|
|
|
/* average number of code units compared to UTF-16 */
|
|
#define UTF16_ARRAY_SIZE(size) (size)
|
|
|
|
/**
|
|
* Get a single code point from an offset that points to any
|
|
* of the code units that belong to that code point.
|
|
* Assume 0<=i<length.
|
|
*
|
|
* This could be used for iteration together with
|
|
* UTF16_CHAR_LENGTH() and UTF_IS_ERROR(),
|
|
* but the use of UTF16_NEXT_CHAR_[UN]SAFE() and
|
|
* UTF16_PREV_CHAR_[UN]SAFE() is more efficient for that.
|
|
*/
|
|
#define UTF16_GET_CHAR_UNSAFE(s, i, c) { \
|
|
(c)=(s)[i]; \
|
|
if(UTF_IS_SURROGATE(c)) { \
|
|
if(UTF_IS_SURROGATE_FIRST(c)) { \
|
|
(c)=UTF16_GET_PAIR_VALUE((c), (s)[(i)+1]); \
|
|
} else { \
|
|
(c)=UTF16_GET_PAIR_VALUE((s)[(i)-1], (c)); \
|
|
} \
|
|
} \
|
|
}
|
|
|
|
#define UTF16_GET_CHAR_SAFE(s, start, i, length, c, strict) { \
|
|
(c)=(s)[i]; \
|
|
if(UTF_IS_SURROGATE(c)) { \
|
|
uint16_t __c2; \
|
|
if(UTF_IS_SURROGATE_FIRST(c)) { \
|
|
if((i)+1<(length) && UTF_IS_SECOND_SURROGATE(__c2=(s)[(i)+1])) { \
|
|
(c)=UTF16_GET_PAIR_VALUE((c), __c2); \
|
|
/* strict: ((c)&0xfffe)==0xfffe is caught by UTF_IS_ERROR() and UTF_IS_UNICODE_CHAR() */ \
|
|
} else if(strict) {\
|
|
/* unmatched first surrogate */ \
|
|
(c)=UTF_ERROR_VALUE; \
|
|
} \
|
|
} else { \
|
|
if((i)-1>=(start) && UTF_IS_FIRST_SURROGATE(__c2=(s)[(i)-1])) { \
|
|
(c)=UTF16_GET_PAIR_VALUE(__c2, (c)); \
|
|
/* strict: ((c)&0xfffe)==0xfffe is caught by UTF_IS_ERROR() and UTF_IS_UNICODE_CHAR() */ \
|
|
} else if(strict) {\
|
|
/* unmatched second surrogate */ \
|
|
(c)=UTF_ERROR_VALUE; \
|
|
} \
|
|
} \
|
|
} else if((strict) && !UTF_IS_UNICODE_CHAR(c)) { \
|
|
(c)=UTF_ERROR_VALUE; \
|
|
} \
|
|
}
|
|
|
|
/* definitions with forward iteration --------------------------------------- */
|
|
|
|
/*
|
|
* all the macros that go forward assume that
|
|
* the initial offset is 0<=i<length;
|
|
* they update the offset
|
|
*/
|
|
|
|
/* fast versions, no error-checking */
|
|
|
|
/**
|
|
* Get a single code point from an offset that points to the first
|
|
* of the code units that belong to that code point.
|
|
* Assume 0<=i<length.
|
|
*/
|
|
#define UTF16_NEXT_CHAR_UNSAFE(s, i, c) { \
|
|
(c)=(s)[(i)++]; \
|
|
if(UTF_IS_FIRST_SURROGATE(c)) { \
|
|
(c)=UTF16_GET_PAIR_VALUE((c), (s)[(i)++]); \
|
|
} \
|
|
}
|
|
|
|
#define UTF16_APPEND_CHAR_UNSAFE(s, i, c) { \
|
|
if((uint32_t)(c)<=0xffff) { \
|
|
(s)[(i)++]=(uint16_t)(c); \
|
|
} else { \
|
|
(s)[(i)++]=(uint16_t)(((c)>>10)+0xd7c0); \
|
|
(s)[(i)++]=(uint16_t)(((c)&0x3ff)|0xdc00); \
|
|
} \
|
|
}
|
|
|
|
#define UTF16_FWD_1_UNSAFE(s, i) { \
|
|
if(UTF_IS_FIRST_SURROGATE((s)[(i)++])) { \
|
|
++(i); \
|
|
} \
|
|
}
|
|
|
|
#define UTF16_FWD_N_UNSAFE(s, i, n) { \
|
|
int32_t __N=(n); \
|
|
while(__N>0) { \
|
|
UTF16_FWD_1_UNSAFE(s, i); \
|
|
--__N; \
|
|
} \
|
|
}
|
|
|
|
/**
|
|
* Set a random-access offset and adjust it so that
|
|
* it points to the beginning of a Unicode character.
|
|
* The offset that is passed in points to
|
|
* any code unit of a code point
|
|
* and will point to the first code unit after
|
|
* the macro invocation.
|
|
* Never increments the offset.
|
|
*/
|
|
#define UTF16_SET_CHAR_START_UNSAFE(s, i) { \
|
|
if(UTF_IS_SECOND_SURROGATE((s)[i])) { \
|
|
--(i); \
|
|
} \
|
|
}
|
|
|
|
/* safe versions with error-checking and optional regularity-checking */
|
|
|
|
#define UTF16_NEXT_CHAR_SAFE(s, i, length, c, strict) { \
|
|
(c)=(s)[(i)++]; \
|
|
if(UTF_IS_FIRST_SURROGATE(c)) { \
|
|
uint16_t __c2; \
|
|
if((i)<(length) && UTF_IS_SECOND_SURROGATE(__c2=(s)[(i)])) { \
|
|
++(i); \
|
|
(c)=UTF16_GET_PAIR_VALUE((c), __c2); \
|
|
/* strict: ((c)&0xfffe)==0xfffe is caught by UTF_IS_ERROR() and UTF_IS_UNICODE_CHAR() */ \
|
|
} else if(strict) {\
|
|
/* unmatched first surrogate */ \
|
|
(c)=UTF_ERROR_VALUE; \
|
|
} \
|
|
} else if((strict) && !UTF_IS_UNICODE_CHAR(c)) { \
|
|
/* unmatched second surrogate or other non-character */ \
|
|
(c)=UTF_ERROR_VALUE; \
|
|
} \
|
|
}
|
|
|
|
#define UTF16_APPEND_CHAR_SAFE(s, i, length, c) { \
|
|
if((uint32_t)(c)<=0xffff) { \
|
|
(s)[(i)++]=(uint16_t)(c); \
|
|
} else if((uint32_t)(c)<=0x10ffff) { \
|
|
if((i)+1<(length)) { \
|
|
(s)[(i)++]=(uint16_t)(((c)>>10)+0xd7c0); \
|
|
(s)[(i)++]=(uint16_t)(((c)&0x3ff)|0xdc00); \
|
|
} else /* not enough space */ { \
|
|
(s)[(i)++]=UTF_ERROR_VALUE; \
|
|
} \
|
|
} else /* c>0x10ffff, write error value */ { \
|
|
(s)[(i)++]=UTF_ERROR_VALUE; \
|
|
} \
|
|
}
|
|
|
|
#define UTF16_FWD_1_SAFE(s, i, length) { \
|
|
if(UTF_IS_FIRST_SURROGATE((s)[(i)++]) && (i)<(length) && UTF_IS_SECOND_SURROGATE((s)[i])) { \
|
|
++(i); \
|
|
} \
|
|
}
|
|
|
|
#define UTF16_FWD_N_SAFE(s, i, length, n) { \
|
|
int32_t __N=(n); \
|
|
while(__N>0 && (i)<(length)) { \
|
|
UTF16_FWD_1_SAFE(s, i, length); \
|
|
--__N; \
|
|
} \
|
|
}
|
|
|
|
#define UTF16_SET_CHAR_START_SAFE(s, start, i) { \
|
|
if(UTF_IS_SECOND_SURROGATE((s)[i]) && (i)>(start) && UTF_IS_FIRST_SURROGATE((s)[(i)-1])) { \
|
|
--(i); \
|
|
} \
|
|
}
|
|
|
|
/* definitions with backward iteration -------------------------------------- */
|
|
|
|
/*
|
|
* all the macros that go backward assume that
|
|
* the valid buffer range starts at offset 0
|
|
* and that the initial offset is 0<i<=length;
|
|
* they update the offset
|
|
*/
|
|
|
|
/* fast versions, no error-checking */
|
|
|
|
/**
|
|
* Get a single code point from an offset that points behind the last
|
|
* of the code units that belong to that code point.
|
|
* Assume 0<=i<length.
|
|
*/
|
|
#define UTF16_PREV_CHAR_UNSAFE(s, i, c) { \
|
|
(c)=(s)[--(i)]; \
|
|
if(UTF_IS_SECOND_SURROGATE(c)) { \
|
|
(c)=UTF16_GET_PAIR_VALUE((s)[--(i)], (c)); \
|
|
} \
|
|
}
|
|
|
|
#define UTF16_BACK_1_UNSAFE(s, i) { \
|
|
if(UTF_IS_SECOND_SURROGATE((s)[--(i)])) { \
|
|
--(i); \
|
|
} \
|
|
}
|
|
|
|
#define UTF16_BACK_N_UNSAFE(s, i, n) { \
|
|
int32_t __N=(n); \
|
|
while(__N>0) { \
|
|
UTF16_BACK_1_UNSAFE(s, i); \
|
|
--__N; \
|
|
} \
|
|
}
|
|
|
|
/**
|
|
* Set a random-access offset and adjust it so that
|
|
* it points after the end of a Unicode character.
|
|
* The offset that is passed in points behind
|
|
* any code unit of a code point
|
|
* and will point behind the last code unit after
|
|
* the macro invocation.
|
|
* Never decrements the offset.
|
|
*/
|
|
#define UTF16_SET_CHAR_LIMIT_UNSAFE(s, i) { \
|
|
if(UTF_IS_FIRST_SURROGATE((s)[(i)-1])) { \
|
|
++(i); \
|
|
} \
|
|
}
|
|
|
|
/* safe versions with error-checking and optional regularity-checking */
|
|
|
|
#define UTF16_PREV_CHAR_SAFE(s, start, i, c, strict) { \
|
|
(c)=(s)[--(i)]; \
|
|
if(UTF_IS_SECOND_SURROGATE(c)) { \
|
|
uint16_t __c2; \
|
|
if((i)>(start) && UTF_IS_FIRST_SURROGATE(__c2=(s)[(i)-1])) { \
|
|
--(i); \
|
|
(c)=UTF16_GET_PAIR_VALUE(__c2, (c)); \
|
|
/* strict: ((c)&0xfffe)==0xfffe is caught by UTF_IS_ERROR() and UTF_IS_UNICODE_CHAR() */ \
|
|
} else if(strict) {\
|
|
/* unmatched second surrogate */ \
|
|
(c)=UTF_ERROR_VALUE; \
|
|
} \
|
|
} else if((strict) && !UTF_IS_UNICODE_CHAR(c)) { \
|
|
/* unmatched first surrogate or other non-character */ \
|
|
(c)=UTF_ERROR_VALUE; \
|
|
} \
|
|
}
|
|
|
|
#define UTF16_BACK_1_SAFE(s, start, i) { \
|
|
if(UTF_IS_SECOND_SURROGATE((s)[--(i)]) && (i)>(start) && UTF_IS_FIRST_SURROGATE((s)[(i)-1])) { \
|
|
--(i); \
|
|
} \
|
|
}
|
|
|
|
#define UTF16_BACK_N_SAFE(s, start, i, n) { \
|
|
int32_t __N=(n); \
|
|
while(__N>0 && (i)>(start)) { \
|
|
UTF16_BACK_1_SAFE(s, start, i); \
|
|
--__N; \
|
|
} \
|
|
}
|
|
|
|
#define UTF16_SET_CHAR_LIMIT_SAFE(s, start, i, length) { \
|
|
if((start)<(i) && (i)<(length) && UTF_IS_FIRST_SURROGATE((s)[(i)-1]) && UTF_IS_SECOND_SURROGATE((s)[i])) { \
|
|
++(i); \
|
|
} \
|
|
}
|
|
|
|
#endif
|