[apple/xnu.git] / bsd / vfs / vfs_utfconv.c

/*
 * Copyright (c) 2000-2002 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * The contents of this file constitute Original Code as defined in and
 * are subject to the Apple Public Source License Version 1.1 (the
 * "License").  You may not use this file except in compliance with the
 * License.  Please obtain a copy of the License at
 * http://www.apple.com/publicsource and read it before using this file.
 * 
 * This Original Code and all software distributed under the License are
 * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT.  Please see the
 * License for the specific language governing rights and limitations
 * under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
 
 /*
 	Includes Unicode 3.2 decomposition code derived from Core Foundation
 */

#include <sys/param.h>
#include <sys/utfconv.h>
#include <sys/errno.h>
#include <architecture/byte_order.h>

/*
 * UTF-8 (Unicode Transformation Format)
 *
 * UTF-8 is the Unicode Transformation Format that serializes a Unicode
 * character as a sequence of one to four bytes. Only the shortest form
 * required to represent the significant Unicode bits is legal.
 * 
 * UTF-8 Multibyte Codes
 *
 * Bytes   Bits   Unicode Min  Unicode Max   UTF-8 Byte Sequence (binary)
 * -----------------------------------------------------------------------------
 *   1       7       0x0000        0x007F    0xxxxxxx
 *   2      11       0x0080        0x07FF    110xxxxx 10xxxxxx
 *   3      16       0x0800        0xFFFF    1110xxxx 10xxxxxx 10xxxxxx
 *   4      21      0x10000      0x10FFFF    11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
 * -----------------------------------------------------------------------------
 */


#define UNICODE_TO_UTF8_LEN(c)  \
	((c) < 0x0080 ? 1 : ((c) < 0x0800 ? 2 : (((c) & 0xf800) == 0xd800 ? 2 : 3)))

#define UCS_ALT_NULL	0x2400

/* Surrogate Pair Constants */
#define SP_HALF_SHIFT	10
#define SP_HALF_BASE	0x0010000UL
#define SP_HALF_MASK	0x3FFUL

#define SP_HIGH_FIRST	0xD800UL
#define SP_HIGH_LAST	0xDBFFUL
#define SP_LOW_FIRST	0xDC00UL
#define SP_LOW_LAST	0xDFFFUL


#include "vfs_utfconvdata.h"


/*
 * Test for a combining character.
 *
 * Similar to __CFUniCharIsNonBaseCharacter except that
 * unicode_combinable also includes Hangul Jamo characters.
 */
static inline int
unicode_combinable(u_int16_t character)
{
	const u_int8_t *bitmap = __CFUniCharCombiningBitmap;
	u_int8_t value;

	if (character < 0x0300)
		return (0);

	value = bitmap[(character >> 8) & 0xFF];

	if (value == 0xFF) {
		return (1);
	} else if (value) {
		bitmap = bitmap + ((value - 1) * 32) + 256;
		return (bitmap[(character & 0xFF) / 8] & (1 << (character % 8)) ? 1 : 0);
	}
	return (0);
}

/*
 * Test for a precomposed character.
 *
 * Similar to __CFUniCharIsDecomposableCharacter.
 */
static inline int
unicode_decomposeable(u_int16_t character) {
	const u_int8_t *bitmap = __CFUniCharDecomposableBitmap;
	u_int8_t value;
	
	if (character < 0x00C0)
		return (0);

	value = bitmap[(character >> 8) & 0xFF];

	if (value == 0xFF) {
		return (1);
	} else if (value) {
		bitmap = bitmap + ((value - 1) * 32) + 256;
		return (bitmap[(character & 0xFF) / 8] & (1 << (character % 8)) ? 1 : 0);
	}
    	return (0);
}

static int unicode_decompose(u_int16_t character, u_int16_t *convertedChars);

static u_int16_t unicode_combine(u_int16_t base, u_int16_t combining);


char utf_extrabytes[32] = {
	 0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
	-1, -1, -1, -1, -1, -1, -1, -1,  1,  1,  1,  1,  2,  2,  3, -1
};


/*
 * utf8_encodelen - Calculates the UTF-8 encoding length for a Unicode filename
 *
 * NOTES:
 *    If '/' chars are allowed on disk then an alternate
 *    (replacement) char must be provided in altslash.
 *
 * input flags:
 *    UTF_REVERSE_ENDIAN: Unicode byteorder is opposite current runtime
 */
size_t
utf8_encodelen(const u_int16_t * ucsp, size_t ucslen, u_int16_t altslash,
               int flags)
{
	u_int16_t ucs_ch;
	int charcnt;
	int swapbytes = (flags & UTF_REVERSE_ENDIAN);
	size_t len;
	
	charcnt = ucslen / 2;
	len = 0;

	while (charcnt-- > 0) {
		ucs_ch = *ucsp++;

		if (swapbytes)
			ucs_ch = NXSwapShort(ucs_ch);
		if (ucs_ch == '/')
			ucs_ch = altslash ? altslash : '_';
		else if (ucs_ch == '\0')
			ucs_ch = UCS_ALT_NULL;
		
		len += UNICODE_TO_UTF8_LEN(ucs_ch);
	}

	return (len);
}


/*
 * utf8_encodestr - Encodes a Unicode string to UTF-8
 *
 * NOTES:
 *    The resulting UTF-8 string is NULL terminated.
 *
 *    If '/' chars are allowed on disk then an alternate
 *    (replacement) char must be provided in altslash.
 *
 * input flags:
 *    UTF_REVERSE_ENDIAN: Unicode byteorder is opposite current runtime
 *    UTF_NO_NULL_TERM:  don't add NULL termination to UTF-8 output
 *
 * result:
 *    ENAMETOOLONG: Name didn't fit; only buflen bytes were encoded
 *    EINVAL: Illegal char found; char was replaced by an '_'.
 */
int
utf8_encodestr(const u_int16_t * ucsp, size_t ucslen, u_int8_t * utf8p,
               size_t * utf8len, size_t buflen, u_int16_t altslash, int flags)
{
	u_int8_t * bufstart;
	u_int8_t * bufend;
	u_int16_t ucs_ch;
	u_int16_t * chp = NULL;
	u_int16_t sequence[8];
	int extra = 0;
	int charcnt;
	int swapbytes = (flags & UTF_REVERSE_ENDIAN);
	int nullterm  = ((flags & UTF_NO_NULL_TERM) == 0);
	int decompose = (flags & UTF_DECOMPOSED);
	int result = 0;
	
	bufstart = utf8p;
	bufend = bufstart + buflen;
	if (nullterm)
		--bufend;
	charcnt = ucslen / 2;

	while (charcnt-- > 0) {
		if (extra > 0) {
			--extra;
			ucs_ch = *chp++;
		} else {
			ucs_ch = swapbytes ? NXSwapShort(*ucsp++) : *ucsp++;

			if (decompose && unicode_decomposeable(ucs_ch)) {
				extra = unicode_decompose(ucs_ch, sequence) - 1;
				charcnt += extra;
				ucs_ch = sequence[0];
				chp = &sequence[1];
			}
		}

		/* Slash and NULL are not permitted */
		if (ucs_ch == '/') {
			if (altslash)
				ucs_ch = altslash;
			else {
				ucs_ch = '_';
				result = EINVAL;
			}
		} else if (ucs_ch == '\0') {
			ucs_ch = UCS_ALT_NULL;
		}

		if (ucs_ch < 0x0080) {
			if (utf8p >= bufend) {
				result = ENAMETOOLONG;
				break;
			}			
			*utf8p++ = ucs_ch;

		} else if (ucs_ch < 0x800) {
			if ((utf8p + 1) >= bufend) {
				result = ENAMETOOLONG;
				break;
			}
			*utf8p++ = 0xc0 | (ucs_ch >> 6);
			*utf8p++ = 0x80 | (0x3f & ucs_ch);

		} else {
			/* Combine valid surrogate pairs */
			if (ucs_ch >= SP_HIGH_FIRST && ucs_ch <= SP_HIGH_LAST
				&& charcnt > 0) {
				u_int16_t ch2;
				u_int32_t pair;

				ch2 = swapbytes ? NXSwapShort(*ucsp) : *ucsp;
				if (ch2 >= SP_LOW_FIRST && ch2 <= SP_LOW_LAST) {
					pair = ((ucs_ch - SP_HIGH_FIRST) << SP_HALF_SHIFT)
						+ (ch2 - SP_LOW_FIRST) + SP_HALF_BASE;
					if ((utf8p + 3) >= bufend) {
						result = ENAMETOOLONG;
						break;
					}
					--charcnt;
					++ucsp;				
					*utf8p++ = 0xf0 | (pair >> 18);
					*utf8p++ = 0x80 | (0x3f & (pair >> 12));
					*utf8p++ = 0x80 | (0x3f & (pair >> 6));
					*utf8p++ = 0x80 | (0x3f & pair);
					continue;
				}
			}
			if ((utf8p + 2) >= bufend) {
				result = ENAMETOOLONG;
				break;
			}
			*utf8p++ = 0xe0 | (ucs_ch >> 12);
			*utf8p++ = 0x80 | (0x3f & (ucs_ch >> 6));
			*utf8p++ = 0x80 | (0x3f & ucs_ch);
		}	
	}
	
	*utf8len = utf8p - bufstart;
	if (nullterm)
		*utf8p++ = '\0';

	return (result);
}


/*
 * utf8_decodestr - Decodes a UTF-8 string back to Unicode
 *
 * NOTES:
 *    The input UTF-8 string does not need to be null terminated
 *    if utf8len is set.
 *
 *    If '/' chars are allowed on disk then an alternate
 *    (replacement) char must be provided in altslash.
 *
 * input flags:
 *    UTF_REV_ENDIAN:   Unicode byteorder is oposite current runtime
 *    UTF_DECOMPOSED:   Unicode output string must be fully decompsed
 *
 * result:
 *    ENAMETOOLONG: Name didn't fit; only ucslen chars were decoded.
 *    EINVAL: Illegal UTF-8 sequence found.
 */
int
utf8_decodestr(const u_int8_t* utf8p, size_t utf8len, u_int16_t* ucsp,
               size_t *ucslen, size_t buflen, u_int16_t altslash, int flags)
{
	u_int16_t* bufstart;
	u_int16_t* bufend;
	unsigned int ucs_ch;
	unsigned int byte;
	int result = 0;
	int decompose, precompose, swapbytes;

	decompose =  (flags & UTF_DECOMPOSED);
	precompose = (flags & UTF_PRECOMPOSED);
	swapbytes =  (flags & UTF_REVERSE_ENDIAN);

	bufstart = ucsp;
	bufend = (u_int16_t *)((u_int8_t *)ucsp + buflen);

	while (utf8len-- > 0 && (byte = *utf8p++) != '\0') {
		if (ucsp >= bufend)
			goto toolong;

		/* check for ascii */
		if (byte < 0x80) {
			ucs_ch = byte;                 /* 1st byte */
		} else {
			u_int32_t ch;
			int extrabytes = utf_extrabytes[byte >> 3];

			if (utf8len < extrabytes)
				goto invalid;
			utf8len -= extrabytes;

			switch (extrabytes) {
			case 1:
				ch = byte; ch <<= 6;   /* 1st byte */
				byte = *utf8p++;       /* 2nd byte */
				if ((byte >> 6) != 2)
					goto invalid;
				ch += byte;
				ch -= 0x00003080UL;
				if (ch < 0x0080)
					goto invalid;
				ucs_ch = ch;
			        break;
			case 2:
				ch = byte; ch <<= 6;   /* 1st byte */
				byte = *utf8p++;       /* 2nd byte */
				if ((byte >> 6) != 2)
					goto invalid;
				ch += byte; ch <<= 6;
				byte = *utf8p++;       /* 3rd byte */
				if ((byte >> 6) != 2)
					goto invalid;
				ch += byte;
				ch -= 0x000E2080UL;
				if (ch < 0x0800)
					goto invalid;
				if (ch >= 0xD800) {
					if (ch <= 0xDFFF)
						goto invalid;
					if (ch == 0xFFFE || ch == 0xFFFF)
						goto invalid;
				}
				ucs_ch = ch;
				break;
			case 3:
				ch = byte; ch <<= 6;   /* 1st byte */
				byte = *utf8p++;       /* 2nd byte */
				if ((byte >> 6) != 2)
					goto invalid;
				ch += byte; ch <<= 6;
				byte = *utf8p++;       /* 3rd byte */
				if ((byte >> 6) != 2)
					goto invalid;
				ch += byte; ch <<= 6;
				byte = *utf8p++;       /* 4th byte */
				if ((byte >> 6) != 2)
					goto invalid;
			        ch += byte;
				ch -= 0x03C82080UL + SP_HALF_BASE;
				ucs_ch = (ch >> SP_HALF_SHIFT) + SP_HIGH_FIRST;
				if (ucs_ch < SP_HIGH_FIRST || ucs_ch > SP_HIGH_LAST)
					goto invalid;
				*ucsp++ = swapbytes ? NXSwapShort(ucs_ch) : ucs_ch;
				if (ucsp >= bufend)
					goto toolong;
				ucs_ch = (ch & SP_HALF_MASK) + SP_LOW_FIRST;
				if (ucs_ch < SP_LOW_FIRST || ucs_ch > SP_LOW_LAST)
					goto invalid;
				*ucsp++ = swapbytes ? NXSwapShort(ucs_ch) : ucs_ch;
			        continue;
			default:
				goto invalid;
			}
			if (decompose) {
				if (unicode_decomposeable(ucs_ch)) {
					u_int16_t sequence[8];
					int count, i;

					count = unicode_decompose(ucs_ch, sequence);

					for (i = 0; i < count; ++i) {
						ucs_ch = sequence[i];
						*ucsp++ = swapbytes ? NXSwapShort(ucs_ch) : ucs_ch;
						if (ucsp >= bufend)
							goto toolong;
					}
					continue;			
				}
			} else if (precompose && (ucsp != bufstart)) {
				u_int16_t composite, base;

				if (unicode_combinable(ucs_ch)) {
					base = swapbytes ? NXSwapShort(*(ucsp - 1)) : *(ucsp - 1);
					composite = unicode_combine(base, ucs_ch);
					if (composite) {
						--ucsp;
						ucs_ch = composite;
					}
				}
			}
			if (ucs_ch == UCS_ALT_NULL)
				ucs_ch = '\0';
		}
		if (ucs_ch == altslash)
			ucs_ch = '/';

		*ucsp++ = swapbytes ? NXSwapShort(ucs_ch) : ucs_ch;
	}

exit:
	*ucslen = (u_int8_t*)ucsp - (u_int8_t*)bufstart;

	return (result);

invalid:
	result = EINVAL;
	goto exit;

toolong:
	result = ENAMETOOLONG;
	goto exit;
}


 /*
  * Unicode 3.2 decomposition code (derived from Core Foundation)
  */

typedef struct {
	u_int32_t _key;
	u_int32_t _value;
} unicode_mappings32;

static inline u_int32_t
getmappedvalue32(const unicode_mappings32 *theTable, u_int32_t numElem,
		u_int16_t character)
{
	const unicode_mappings32 *p, *q, *divider;

	if ((character < theTable[0]._key) || (character > theTable[numElem-1]._key))
		return (0);

	p = theTable;
	q = p + (numElem-1);
	while (p <= q) {
		divider = p + ((q - p) >> 1);	/* divide by 2 */
		if (character < divider->_key) { q = divider - 1; }
		else if (character > divider->_key) { p = divider + 1; }
		else { return (divider->_value); }
	}
	return (0);
}

#define RECURSIVE_DECOMPOSITION	(1 << 15)
#define EXTRACT_COUNT(value)	(((value) >> 12) & 0x0007)

typedef struct {
	u_int16_t _key;
	u_int16_t _value;
} unicode_mappings16;

static inline u_int16_t
getmappedvalue16(const unicode_mappings16 *theTable, u_int32_t numElem,
		u_int16_t character)
{
	const unicode_mappings16 *p, *q, *divider;

	if ((character < theTable[0]._key) || (character > theTable[numElem-1]._key))
		return (0);

	p = theTable;
	q = p + (numElem-1);
	while (p <= q) {
		divider = p + ((q - p) >> 1);	/* divide by 2 */
		if (character < divider->_key)
			q = divider - 1;
		else if (character > divider->_key)
			p = divider + 1;
		else
			return (divider->_value);
	}
	return (0);
}


static u_int32_t
unicode_recursive_decompose(u_int16_t character, u_int16_t *convertedChars)
{
	u_int16_t value;
	u_int32_t length;
	u_int16_t firstChar;
	u_int16_t theChar;
	const u_int16_t *bmpMappings;
	u_int32_t usedLength;

	value = getmappedvalue16(
		(const unicode_mappings16 *)__CFUniCharDecompositionTable,
		__UniCharDecompositionTableLength, character);
	length = EXTRACT_COUNT(value);
	firstChar = value & 0x0FFF;
	theChar = firstChar;
	bmpMappings = (length == 1 ? &theChar : __CFUniCharMultipleDecompositionTable + firstChar);
	usedLength = 0;

	if (value & RECURSIVE_DECOMPOSITION) {
	    usedLength = unicode_recursive_decompose((u_int16_t)*bmpMappings, convertedChars);
	
	    --length;	/* Decrement for the first char */
	    if (!usedLength)
	    	return 0;
	    ++bmpMappings;
	    convertedChars += usedLength;
	}
	
	usedLength += length;
	
	while (length--)
		*(convertedChars++) = *(bmpMappings++);
	
	return (usedLength);
}
    
#define HANGUL_SBASE 0xAC00
#define HANGUL_LBASE 0x1100
#define HANGUL_VBASE 0x1161
#define HANGUL_TBASE 0x11A7

#define HANGUL_SCOUNT 11172
#define HANGUL_LCOUNT 19
#define HANGUL_VCOUNT 21
#define HANGUL_TCOUNT 28
#define HANGUL_NCOUNT (HANGUL_VCOUNT * HANGUL_TCOUNT)

/*
 * unicode_decompose - decompose a composed Unicode char
 *
 * Composed Unicode characters are forbidden on
 * HFS Plus volumes. ucs_decompose will convert a
 * composed character into its correct decomposed
 * sequence.
 *
 * Similar to CFUniCharDecomposeCharacter
 */
static int
unicode_decompose(u_int16_t character, u_int16_t *convertedChars)
{
	if ((character >= HANGUL_SBASE) &&
	    (character <= (HANGUL_SBASE + HANGUL_SCOUNT))) {
		u_int32_t length;

		character -= HANGUL_SBASE;
		length = (character % HANGUL_TCOUNT ? 3 : 2);

		*(convertedChars++) =
			character / HANGUL_NCOUNT + HANGUL_LBASE;
		*(convertedChars++) =
			(character % HANGUL_NCOUNT) / HANGUL_TCOUNT + HANGUL_VBASE;
		if (length > 2)
			*convertedChars = (character % HANGUL_TCOUNT) + HANGUL_TBASE;
		return (length);
	} else {
		return (unicode_recursive_decompose(character, convertedChars));
	}
}

/*
 * unicode_combine - generate a precomposed Unicode char
 *
 * Precomposed Unicode characters are required for some volume
 * formats and network protocols.  unicode_combine will combine
 * a decomposed character sequence into a single precomposed
 * (composite) character.
 *
 * Similar toCFUniCharPrecomposeCharacter but unicode_combine
 * also handles Hangul Jamo characters.
 */
static u_int16_t
unicode_combine(u_int16_t base, u_int16_t combining)
{
	u_int32_t value;

	/* Check HANGUL */
	if ((combining >= HANGUL_VBASE) && (combining < (HANGUL_TBASE + HANGUL_TCOUNT))) {
		/* 2 char Hangul sequences */
		if ((combining < (HANGUL_VBASE + HANGUL_VCOUNT)) &&
		    (base >= HANGUL_LBASE && base < (HANGUL_LBASE + HANGUL_LCOUNT))) {
		    return (HANGUL_SBASE +
		            ((base - HANGUL_LBASE)*(HANGUL_VCOUNT*HANGUL_TCOUNT)) +
		            ((combining  - HANGUL_VBASE)*HANGUL_TCOUNT));
		}
	
		/* 3 char Hangul sequences */
		if ((combining > HANGUL_TBASE) &&
		    (base >= HANGUL_SBASE && base < (HANGUL_SBASE + HANGUL_SCOUNT))) {
			if ((base - HANGUL_SBASE) % HANGUL_TCOUNT)
				return (0);
			else
				return (base + (combining - HANGUL_TBASE));
		}
	}

	value = getmappedvalue32(
		(const unicode_mappings32 *)__CFUniCharPrecompSourceTable,
		__CFUniCharPrecompositionTableLength, combining);

	if (value) {
		value = getmappedvalue16(
			(const unicode_mappings16 *)
			((u_int32_t *)__CFUniCharBMPPrecompDestinationTable + (value & 0xFFFF)),
			(value >> 16), base);
	}
	return (value);
}
Commit	Line	Data
1c79356b	1	/*
9bccf70c	2	* Copyright (c) 2000-2002 Apple Computer, Inc. All rights reserved.
1c79356b A	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
e5568f75 A	6	* The contents of this file constitute Original Code as defined in and
	7	* are subject to the Apple Public Source License Version 1.1 (the
	8	* "License"). You may not use this file except in compliance with the
	9	* License. Please obtain a copy of the License at
	10	* http://www.apple.com/publicsource and read it before using this file.
1c79356b	11	*
e5568f75 A	12	* This Original Code and all software distributed under the License are
e5568f75 A	13	* distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
1c79356b A	14	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
1c79356b A	15	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
e5568f75 A	16	* FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
	17	* License for the specific language governing rights and limitations
	18	* under the License.
1c79356b A	19	*
	20	* @APPLE_LICENSE_HEADER_END@
	21	*/
9bccf70c A	22
	23	/*
	24	Includes Unicode 3.2 decomposition code derived from Core Foundation
	25	*/
	26
1c79356b A	27	#include <sys/param.h>
	28	#include <sys/utfconv.h>
	29	#include <sys/errno.h>
	30	#include <architecture/byte_order.h>
	31
1c79356b	32	/*
765c9de3	33	* UTF-8 (Unicode Transformation Format)
1c79356b	34	*
765c9de3 A	35	* UTF-8 is the Unicode Transformation Format that serializes a Unicode
	36	* character as a sequence of one to four bytes. Only the shortest form
	37	* required to represent the significant Unicode bits is legal.
1c79356b A	38	*
	39	* UTF-8 Multibyte Codes
	40	*
765c9de3 A	41	* Bytes Bits Unicode Min Unicode Max UTF-8 Byte Sequence (binary)
	42	* -----------------------------------------------------------------------------
	43	* 1 7 0x0000 0x007F 0xxxxxxx
	44	* 2 11 0x0080 0x07FF 110xxxxx 10xxxxxx
	45	* 3 16 0x0800 0xFFFF 1110xxxx 10xxxxxx 10xxxxxx
	46	* 4 21 0x10000 0x10FFFF 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
	47	* -----------------------------------------------------------------------------
1c79356b A	48	*/
	49
	50
765c9de3 A	51	#define UNICODE_TO_UTF8_LEN(c) \
765c9de3 A	52	((c) < 0x0080 ? 1 : ((c) < 0x0800 ? 2 : (((c) & 0xf800) == 0xd800 ? 2 : 3)))
0b4e3aa0 A	53
0b4e3aa0 A	54	#define UCS_ALT_NULL 0x2400
1c79356b	55
765c9de3 A	56	/* Surrogate Pair Constants */
	57	#define SP_HALF_SHIFT 10
	58	#define SP_HALF_BASE 0x0010000UL
	59	#define SP_HALF_MASK 0x3FFUL
	60
	61	#define SP_HIGH_FIRST 0xD800UL
	62	#define SP_HIGH_LAST 0xDBFFUL
	63	#define SP_LOW_FIRST 0xDC00UL
9bccf70c A	64	#define SP_LOW_LAST 0xDFFFUL
9bccf70c A	65
1c79356b	66
9bccf70c	67	#include "vfs_utfconvdata.h"
765c9de3	68
1c79356b	69
9bccf70c A	70	/*
	71	* Test for a combining character.
	72	*
	73	* Similar to __CFUniCharIsNonBaseCharacter except that
	74	* unicode_combinable also includes Hangul Jamo characters.
	75	*/
	76	static inline int
	77	unicode_combinable(u_int16_t character)
	78	{
	79	const u_int8_t *bitmap = __CFUniCharCombiningBitmap;
	80	u_int8_t value;
	81
	82	if (character < 0x0300)
	83	return (0);
	84
	85	value = bitmap[(character >> 8) & 0xFF];
	86
	87	if (value == 0xFF) {
	88	return (1);
	89	} else if (value) {
	90	bitmap = bitmap + ((value - 1) * 32) + 256;
	91	return (bitmap[(character & 0xFF) / 8] & (1 << (character % 8)) ? 1 : 0);
	92	}
	93	return (0);
	94	}
	95
	96	/*
	97	* Test for a precomposed character.
	98	*
	99	* Similar to __CFUniCharIsDecomposableCharacter.
	100	*/
	101	static inline int
	102	unicode_decomposeable(u_int16_t character) {
	103	const u_int8_t *bitmap = __CFUniCharDecomposableBitmap;
	104	u_int8_t value;
	105
	106	if (character < 0x00C0)
	107	return (0);
	108
	109	value = bitmap[(character >> 8) & 0xFF];
	110
	111	if (value == 0xFF) {
	112	return (1);
	113	} else if (value) {
	114	bitmap = bitmap + ((value - 1) * 32) + 256;
	115	return (bitmap[(character & 0xFF) / 8] & (1 << (character % 8)) ? 1 : 0);
	116	}
	117	return (0);
	118	}
	119
	120	static int unicode_decompose(u_int16_t character, u_int16_t *convertedChars);
	121
	122	static u_int16_t unicode_combine(u_int16_t base, u_int16_t combining);
0b4e3aa0	123
1c79356b	124
765c9de3 A	125	char utf_extrabytes[32] = {
	126	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	127	-1, -1, -1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 2, 2, 3, -1
	128	};
	129
	130
1c79356b	131	/*
765c9de3	132	* utf8_encodelen - Calculates the UTF-8 encoding length for a Unicode filename
1c79356b A	133	*
	134	* NOTES:
	135	* If '/' chars are allowed on disk then an alternate
	136	* (replacement) char must be provided in altslash.
	137	*
	138	* input flags:
765c9de3	139	* UTF_REVERSE_ENDIAN: Unicode byteorder is opposite current runtime
1c79356b A	140	*/
1c79356b A	141	size_t
765c9de3 A	142	utf8_encodelen(const u_int16_t * ucsp, size_t ucslen, u_int16_t altslash,
765c9de3 A	143	int flags)
1c79356b A	144	{
	145	u_int16_t ucs_ch;
	146	int charcnt;
	147	int swapbytes = (flags & UTF_REVERSE_ENDIAN);
	148	size_t len;
	149
	150	charcnt = ucslen / 2;
	151	len = 0;
	152
	153	while (charcnt-- > 0) {
	154	ucs_ch = *ucsp++;
	155
	156	if (swapbytes)
	157	ucs_ch = NXSwapShort(ucs_ch);
0b4e3aa0 A	158	if (ucs_ch == '/')
	159	ucs_ch = altslash ? altslash : '_';
	160	else if (ucs_ch == '\0')
	161	ucs_ch = UCS_ALT_NULL;
1c79356b	162
765c9de3	163	len += UNICODE_TO_UTF8_LEN(ucs_ch);
1c79356b A	164	}
	165
	166	return (len);
	167	}
	168
	169
	170	/*
765c9de3	171	* utf8_encodestr - Encodes a Unicode string to UTF-8
1c79356b A	172	*
1c79356b A	173	* NOTES:
0b4e3aa0	174	* The resulting UTF-8 string is NULL terminated.
1c79356b A	175	*
	176	* If '/' chars are allowed on disk then an alternate
	177	* (replacement) char must be provided in altslash.
	178	*
	179	* input flags:
765c9de3	180	* UTF_REVERSE_ENDIAN: Unicode byteorder is opposite current runtime
1c79356b	181	* UTF_NO_NULL_TERM: don't add NULL termination to UTF-8 output
0b4e3aa0 A	182	*
	183	* result:
	184	* ENAMETOOLONG: Name didn't fit; only buflen bytes were encoded
	185	* EINVAL: Illegal char found; char was replaced by an '_'.
1c79356b	186	*/
765c9de3 A	187	int
	188	utf8_encodestr(const u_int16_t * ucsp, size_t ucslen, u_int8_t * utf8p,
	189	size_t * utf8len, size_t buflen, u_int16_t altslash, int flags)
1c79356b A	190	{
	191	u_int8_t * bufstart;
	192	u_int8_t * bufend;
	193	u_int16_t ucs_ch;
9bccf70c A	194	u_int16_t * chp = NULL;
	195	u_int16_t sequence[8];
	196	int extra = 0;
1c79356b A	197	int charcnt;
1c79356b A	198	int swapbytes = (flags & UTF_REVERSE_ENDIAN);
0b4e3aa0 A	199	int nullterm = ((flags & UTF_NO_NULL_TERM) == 0);
0b4e3aa0 A	200	int decompose = (flags & UTF_DECOMPOSED);
1c79356b A	201	int result = 0;
	202
	203	bufstart = utf8p;
	204	bufend = bufstart + buflen;
	205	if (nullterm)
	206	--bufend;
	207	charcnt = ucslen / 2;
	208
	209	while (charcnt-- > 0) {
9bccf70c A	210	if (extra > 0) {
	211	--extra;
	212	ucs_ch = *chp++;
0b4e3aa0 A	213	} else {
0b4e3aa0 A	214	ucs_ch = swapbytes ? NXSwapShort(ucsp++) : ucsp++;
9bccf70c A	215
	216	if (decompose && unicode_decomposeable(ucs_ch)) {
	217	extra = unicode_decompose(ucs_ch, sequence) - 1;
	218	charcnt += extra;
	219	ucs_ch = sequence[0];
	220	chp = &sequence[1];
	221	}
0b4e3aa0	222	}
1c79356b	223
0b4e3aa0 A	224	/* Slash and NULL are not permitted */
	225	if (ucs_ch == '/') {
	226	if (altslash)
	227	ucs_ch = altslash;
	228	else {
	229	ucs_ch = '_';
	230	result = EINVAL;
	231	}
	232	} else if (ucs_ch == '\0') {
	233	ucs_ch = UCS_ALT_NULL;
	234	}
1c79356b	235
0b4e3aa0	236	if (ucs_ch < 0x0080) {
1c79356b A	237	if (utf8p >= bufend) {
	238	result = ENAMETOOLONG;
	239	break;
765c9de3	240	}
1c79356b A	241	*utf8p++ = ucs_ch;
	242
	243	} else if (ucs_ch < 0x800) {
	244	if ((utf8p + 1) >= bufend) {
	245	result = ENAMETOOLONG;
	246	break;
	247	}
765c9de3 A	248	*utf8p++ = 0xc0 \| (ucs_ch >> 6);
765c9de3 A	249	*utf8p++ = 0x80 \| (0x3f & ucs_ch);
1c79356b A	250
1c79356b A	251	} else {
765c9de3 A	252	/* Combine valid surrogate pairs */
	253	if (ucs_ch >= SP_HIGH_FIRST && ucs_ch <= SP_HIGH_LAST
	254	&& charcnt > 0) {
	255	u_int16_t ch2;
	256	u_int32_t pair;
	257
	258	ch2 = swapbytes ? NXSwapShort(ucsp) : ucsp;
	259	if (ch2 >= SP_LOW_FIRST && ch2 <= SP_LOW_LAST) {
	260	pair = ((ucs_ch - SP_HIGH_FIRST) << SP_HALF_SHIFT)
	261	+ (ch2 - SP_LOW_FIRST) + SP_HALF_BASE;
	262	if ((utf8p + 3) >= bufend) {
	263	result = ENAMETOOLONG;
	264	break;
	265	}
	266	--charcnt;
	267	++ucsp;
	268	*utf8p++ = 0xf0 \| (pair >> 18);
	269	*utf8p++ = 0x80 \| (0x3f & (pair >> 12));
	270	*utf8p++ = 0x80 \| (0x3f & (pair >> 6));
	271	*utf8p++ = 0x80 \| (0x3f & pair);
	272	continue;
	273	}
	274	}
1c79356b A	275	if ((utf8p + 2) >= bufend) {
	276	result = ENAMETOOLONG;
	277	break;
	278	}
765c9de3 A	279	*utf8p++ = 0xe0 \| (ucs_ch >> 12);
	280	*utf8p++ = 0x80 \| (0x3f & (ucs_ch >> 6));
	281	*utf8p++ = 0x80 \| (0x3f & ucs_ch);
1c79356b A	282	}
	283	}
	284
	285	*utf8len = utf8p - bufstart;
	286	if (nullterm)
	287	*utf8p++ = '\0';
	288
	289	return (result);
	290	}
	291
	292
	293	/*
765c9de3	294	* utf8_decodestr - Decodes a UTF-8 string back to Unicode
1c79356b A	295	*
	296	* NOTES:
	297	* The input UTF-8 string does not need to be null terminated
	298	* if utf8len is set.
	299	*
	300	* If '/' chars are allowed on disk then an alternate
	301	* (replacement) char must be provided in altslash.
	302	*
	303	* input flags:
765c9de3 A	304	* UTF_REV_ENDIAN: Unicode byteorder is oposite current runtime
765c9de3 A	305	* UTF_DECOMPOSED: Unicode output string must be fully decompsed
0b4e3aa0 A	306	*
	307	* result:
	308	* ENAMETOOLONG: Name didn't fit; only ucslen chars were decoded.
	309	* EINVAL: Illegal UTF-8 sequence found.
1c79356b A	310	*/
1c79356b A	311	int
765c9de3 A	312	utf8_decodestr(const u_int8_t* utf8p, size_t utf8len, u_int16_t* ucsp,
765c9de3 A	313	size_t *ucslen, size_t buflen, u_int16_t altslash, int flags)
1c79356b A	314	{
	315	u_int16_t* bufstart;
	316	u_int16_t* bufend;
55e303ae A	317	unsigned int ucs_ch;
55e303ae A	318	unsigned int byte;
1c79356b	319	int result = 0;
0b4e3aa0	320	int decompose, precompose, swapbytes;
1c79356b	321
0b4e3aa0 A	322	decompose = (flags & UTF_DECOMPOSED);
	323	precompose = (flags & UTF_PRECOMPOSED);
	324	swapbytes = (flags & UTF_REVERSE_ENDIAN);
1c79356b A	325
	326	bufstart = ucsp;
	327	bufend = (u_int16_t )((u_int8_t )ucsp + buflen);
	328
	329	while (utf8len-- > 0 && (byte = *utf8p++) != '\0') {
765c9de3 A	330	if (ucsp >= bufend)
765c9de3 A	331	goto toolong;
1c79356b A	332
	333	/* check for ascii */
	334	if (byte < 0x80) {
55e303ae	335	ucs_ch = byte; /* 1st byte */
1c79356b	336	} else {
765c9de3 A	337	u_int32_t ch;
	338	int extrabytes = utf_extrabytes[byte >> 3];
	339
	340	if (utf8len < extrabytes)
	341	goto invalid;
	342	utf8len -= extrabytes;
	343
	344	switch (extrabytes) {
55e303ae A	345	case 1:
	346	ch = byte; ch <<= 6; /* 1st byte */
	347	byte = utf8p++; / 2nd byte */
	348	if ((byte >> 6) != 2)
	349	goto invalid;
	350	ch += byte;
	351	ch -= 0x00003080UL;
	352	if (ch < 0x0080)
	353	goto invalid;
	354	ucs_ch = ch;
765c9de3	355	break;
55e303ae A	356	case 2:
	357	ch = byte; ch <<= 6; /* 1st byte */
	358	byte = utf8p++; / 2nd byte */
	359	if ((byte >> 6) != 2)
	360	goto invalid;
	361	ch += byte; ch <<= 6;
	362	byte = utf8p++; / 3rd byte */
	363	if ((byte >> 6) != 2)
	364	goto invalid;
	365	ch += byte;
	366	ch -= 0x000E2080UL;
	367	if (ch < 0x0800)
	368	goto invalid;
	369	if (ch >= 0xD800) {
	370	if (ch <= 0xDFFF)
765c9de3	371	goto invalid;
55e303ae A	372	if (ch == 0xFFFE \|\| ch == 0xFFFF)
	373	goto invalid;
	374	}
	375	ucs_ch = ch;
	376	break;
	377	case 3:
	378	ch = byte; ch <<= 6; /* 1st byte */
	379	byte = utf8p++; / 2nd byte */
	380	if ((byte >> 6) != 2)
	381	goto invalid;
	382	ch += byte; ch <<= 6;
	383	byte = utf8p++; / 3rd byte */
	384	if ((byte >> 6) != 2)
	385	goto invalid;
	386	ch += byte; ch <<= 6;
	387	byte = utf8p++; / 4th byte */
	388	if ((byte >> 6) != 2)
	389	goto invalid;
	390	ch += byte;
	391	ch -= 0x03C82080UL + SP_HALF_BASE;
	392	ucs_ch = (ch >> SP_HALF_SHIFT) + SP_HIGH_FIRST;
	393	if (ucs_ch < SP_HIGH_FIRST \|\| ucs_ch > SP_HIGH_LAST)
	394	goto invalid;
	395	*ucsp++ = swapbytes ? NXSwapShort(ucs_ch) : ucs_ch;
	396	if (ucsp >= bufend)
	397	goto toolong;
	398	ucs_ch = (ch & SP_HALF_MASK) + SP_LOW_FIRST;
	399	if (ucs_ch < SP_LOW_FIRST \|\| ucs_ch > SP_LOW_LAST)
	400	goto invalid;
	401	*ucsp++ = swapbytes ? NXSwapShort(ucs_ch) : ucs_ch;
765c9de3	402	continue;
1c79356b	403	default:
55e303ae	404	goto invalid;
1c79356b	405	}
1c79356b	406	if (decompose) {
9bccf70c A	407	if (unicode_decomposeable(ucs_ch)) {
	408	u_int16_t sequence[8];
	409	int count, i;
1c79356b	410
9bccf70c	411	count = unicode_decompose(ucs_ch, sequence);
1c79356b	412
9bccf70c A	413	for (i = 0; i < count; ++i) {
9bccf70c A	414	ucs_ch = sequence[i];
0b4e3aa0	415	*ucsp++ = swapbytes ? NXSwapShort(ucs_ch) : ucs_ch;
765c9de3 A	416	if (ucsp >= bufend)
765c9de3 A	417	goto toolong;
0b4e3aa0	418	}
9bccf70c	419	continue;
0b4e3aa0 A	420	}
	421	} else if (precompose && (ucsp != bufstart)) {
	422	u_int16_t composite, base;
	423
9bccf70c A	424	if (unicode_combinable(ucs_ch)) {
	425	base = swapbytes ? NXSwapShort((ucsp - 1)) : (ucsp - 1);
	426	composite = unicode_combine(base, ucs_ch);
	427	if (composite) {
	428	--ucsp;
	429	ucs_ch = composite;
	430	}
1c79356b A	431	}
1c79356b A	432	}
0b4e3aa0 A	433	if (ucs_ch == UCS_ALT_NULL)
0b4e3aa0 A	434	ucs_ch = '\0';
1c79356b	435	}
1c79356b A	436	if (ucs_ch == altslash)
1c79356b A	437	ucs_ch = '/';
1c79356b	438
765c9de3	439	*ucsp++ = swapbytes ? NXSwapShort(ucs_ch) : ucs_ch;
1c79356b	440	}
765c9de3 A	441
765c9de3 A	442	exit:
1c79356b A	443	ucslen = (u_int8_t)ucsp - (u_int8_t*)bufstart;
	444
	445	return (result);
765c9de3 A	446
	447	invalid:
	448	result = EINVAL;
	449	goto exit;
	450
	451	toolong:
	452	result = ENAMETOOLONG;
	453	goto exit;
1c79356b A	454	}
	455
	456
9bccf70c A	457	/*
	458	* Unicode 3.2 decomposition code (derived from Core Foundation)
	459	*/
1c79356b	460
9bccf70c A	461	typedef struct {
	462	u_int32_t _key;
	463	u_int32_t _value;
	464	} unicode_mappings32;
0b4e3aa0	465
9bccf70c A	466	static inline u_int32_t
	467	getmappedvalue32(const unicode_mappings32 *theTable, u_int32_t numElem,
	468	u_int16_t character)
	469	{
	470	const unicode_mappings32 p, q, *divider;
1c79356b	471
9bccf70c A	472	if ((character < theTable[0]._key) \|\| (character > theTable[numElem-1]._key))
9bccf70c A	473	return (0);
1c79356b	474
9bccf70c A	475	p = theTable;
	476	q = p + (numElem-1);
	477	while (p <= q) {
	478	divider = p + ((q - p) >> 1); /* divide by 2 */
	479	if (character < divider->_key) { q = divider - 1; }
	480	else if (character > divider->_key) { p = divider + 1; }
	481	else { return (divider->_value); }
	482	}
	483	return (0);
	484	}
1c79356b	485
9bccf70c A	486	#define RECURSIVE_DECOMPOSITION (1 << 15)
9bccf70c A	487	#define EXTRACT_COUNT(value) (((value) >> 12) & 0x0007)
1c79356b	488
9bccf70c A	489	typedef struct {
	490	u_int16_t _key;
	491	u_int16_t _value;
	492	} unicode_mappings16;
1c79356b	493
9bccf70c A	494	static inline u_int16_t
	495	getmappedvalue16(const unicode_mappings16 *theTable, u_int32_t numElem,
	496	u_int16_t character)
	497	{
	498	const unicode_mappings16 p, q, *divider;
1c79356b	499
9bccf70c A	500	if ((character < theTable[0]._key) \|\| (character > theTable[numElem-1]._key))
9bccf70c A	501	return (0);
1c79356b	502
9bccf70c A	503	p = theTable;
	504	q = p + (numElem-1);
	505	while (p <= q) {
	506	divider = p + ((q - p) >> 1); /* divide by 2 */
	507	if (character < divider->_key)
	508	q = divider - 1;
	509	else if (character > divider->_key)
	510	p = divider + 1;
	511	else
	512	return (divider->_value);
	513	}
	514	return (0);
	515	}
	516
	517
	518	static u_int32_t
	519	unicode_recursive_decompose(u_int16_t character, u_int16_t *convertedChars)
	520	{
	521	u_int16_t value;
	522	u_int32_t length;
	523	u_int16_t firstChar;
	524	u_int16_t theChar;
	525	const u_int16_t *bmpMappings;
	526	u_int32_t usedLength;
	527
	528	value = getmappedvalue16(
	529	(const unicode_mappings16 *)__CFUniCharDecompositionTable,
	530	__UniCharDecompositionTableLength, character);
	531	length = EXTRACT_COUNT(value);
	532	firstChar = value & 0x0FFF;
	533	theChar = firstChar;
	534	bmpMappings = (length == 1 ? &theChar : __CFUniCharMultipleDecompositionTable + firstChar);
	535	usedLength = 0;
	536
	537	if (value & RECURSIVE_DECOMPOSITION) {
	538	usedLength = unicode_recursive_decompose((u_int16_t)*bmpMappings, convertedChars);
	539
	540	--length; /* Decrement for the first char */
	541	if (!usedLength)
	542	return 0;
	543	++bmpMappings;
	544	convertedChars += usedLength;
	545	}
0b4e3aa0	546
9bccf70c	547	usedLength += length;
0b4e3aa0	548
9bccf70c A	549	while (length--)
9bccf70c A	550	(convertedChars++) = (bmpMappings++);
0b4e3aa0	551
9bccf70c A	552	return (usedLength);
	553	}
	554
	555	#define HANGUL_SBASE 0xAC00
	556	#define HANGUL_LBASE 0x1100
	557	#define HANGUL_VBASE 0x1161
	558	#define HANGUL_TBASE 0x11A7
	559
	560	#define HANGUL_SCOUNT 11172
	561	#define HANGUL_LCOUNT 19
	562	#define HANGUL_VCOUNT 21
	563	#define HANGUL_TCOUNT 28
	564	#define HANGUL_NCOUNT (HANGUL_VCOUNT * HANGUL_TCOUNT)
1c79356b A	565
1c79356b A	566	/*
9bccf70c	567	* unicode_decompose - decompose a composed Unicode char
1c79356b A	568	*
	569	* Composed Unicode characters are forbidden on
	570	* HFS Plus volumes. ucs_decompose will convert a
	571	* composed character into its correct decomposed
	572	* sequence.
	573	*
9bccf70c	574	* Similar to CFUniCharDecomposeCharacter
1c79356b	575	*/
9bccf70c A	576	static int
9bccf70c A	577	unicode_decompose(u_int16_t character, u_int16_t *convertedChars)
1c79356b	578	{
9bccf70c A	579	if ((character >= HANGUL_SBASE) &&
	580	(character <= (HANGUL_SBASE + HANGUL_SCOUNT))) {
	581	u_int32_t length;
	582
	583	character -= HANGUL_SBASE;
	584	length = (character % HANGUL_TCOUNT ? 3 : 2);
	585
	586	*(convertedChars++) =
	587	character / HANGUL_NCOUNT + HANGUL_LBASE;
	588	*(convertedChars++) =
	589	(character % HANGUL_NCOUNT) / HANGUL_TCOUNT + HANGUL_VBASE;
	590	if (length > 2)
	591	*convertedChars = (character % HANGUL_TCOUNT) + HANGUL_TBASE;
	592	return (length);
1c79356b	593	} else {
9bccf70c	594	return (unicode_recursive_decompose(character, convertedChars));
1c79356b	595	}
1c79356b A	596	}
1c79356b A	597
0b4e3aa0	598	/*
9bccf70c	599	* unicode_combine - generate a precomposed Unicode char
0b4e3aa0 A	600	*
0b4e3aa0 A	601	* Precomposed Unicode characters are required for some volume
9bccf70c A	602	* formats and network protocols. unicode_combine will combine
9bccf70c A	603	* a decomposed character sequence into a single precomposed
0b4e3aa0 A	604	* (composite) character.
0b4e3aa0 A	605	*
9bccf70c A	606	* Similar toCFUniCharPrecomposeCharacter but unicode_combine
9bccf70c A	607	* also handles Hangul Jamo characters.
0b4e3aa0 A	608	*/
0b4e3aa0 A	609	static u_int16_t
9bccf70c	610	unicode_combine(u_int16_t base, u_int16_t combining)
0b4e3aa0	611	{
9bccf70c A	612	u_int32_t value;
	613
	614	/* Check HANGUL */
	615	if ((combining >= HANGUL_VBASE) && (combining < (HANGUL_TBASE + HANGUL_TCOUNT))) {
	616	/* 2 char Hangul sequences */
	617	if ((combining < (HANGUL_VBASE + HANGUL_VCOUNT)) &&
	618	(base >= HANGUL_LBASE && base < (HANGUL_LBASE + HANGUL_LCOUNT))) {
	619	return (HANGUL_SBASE +
	620	((base - HANGUL_LBASE)(HANGUL_VCOUNTHANGUL_TCOUNT)) +
	621	((combining - HANGUL_VBASE)*HANGUL_TCOUNT));
0b4e3aa0	622	}
9bccf70c A	623
	624	/* 3 char Hangul sequences */
	625	if ((combining > HANGUL_TBASE) &&
	626	(base >= HANGUL_SBASE && base < (HANGUL_SBASE + HANGUL_SCOUNT))) {
	627	if ((base - HANGUL_SBASE) % HANGUL_TCOUNT)
	628	return (0);
	629	else
	630	return (base + (combining - HANGUL_TBASE));
0b4e3aa0	631	}
0b4e3aa0 A	632	}
0b4e3aa0 A	633
9bccf70c A	634	value = getmappedvalue32(
	635	(const unicode_mappings32 *)__CFUniCharPrecompSourceTable,
	636	__CFUniCharPrecompositionTableLength, combining);
0b4e3aa0	637
9bccf70c A	638	if (value) {
	639	value = getmappedvalue16(
	640	(const unicode_mappings16 *)
	641	((u_int32_t *)__CFUniCharBMPPrecompDestinationTable + (value & 0xFFFF)),
	642	(value >> 16), base);
0b4e3aa0	643	}
9bccf70c	644	return (value);
0b4e3aa0 A	645	}
0b4e3aa0 A	646