Permalink
Switch branches/tags
Nothing to show
Find file
Fetching contributors…
Cannot retrieve contributors at this time
319 lines (273 sloc) 12.9 KB
/*
* Copyright (c) 2008-2009 Brent Fulgham <bfulgham@gmail.org>. All rights reserved.
*
* This source code is a modified version of the CoreFoundation sources released by Apple Inc. under
* the terms of the APSL version 2.0 (see below).
*
* For information about changes from the original Apple source release can be found by reviewing the
* source control system for the project at https://sourceforge.net/svn/?group_id=246198.
*
* The original license information is as follows:
*
* Copyright (c) 2008 Apple Inc. All rights reserved.
*
* @APPLE_LICENSE_HEADER_START@
*
* This file contains Original Code and/or Modifications of Original Code
* as defined in and that are subject to the Apple Public Source License
* Version 2.0 (the 'License'). You may not use this file except in
* compliance with the License. Please obtain a copy of the License at
* http://www.opensource.apple.com/apsl/ and read it before using this
* file.
*
* The 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, QUIET ENJOYMENT OR NON-INFRINGEMENT.
* Please see the License for the specific language governing rights and
* limitations under the License.
*
* @APPLE_LICENSE_HEADER_END@
*/
/* CFUnicodePrecomposition.c
Copyright 1999-2002, Apple, Inc. All rights reserved.
Responsibility: Aki Inoue
*/
#include <string.h>
#include <CoreFoundation/CFBase.h>
#include <CoreFoundation/CFCharacterSet.h>
#include "CFUniChar.h"
#include "CFUnicodePrecomposition.h"
#include "CFInternal.h"
#include "CFUniCharPriv.h"
// Canonical Precomposition
static UTF32Char *__CFUniCharPrecompSourceTable = NULL;
static uint32_t __CFUniCharPrecompositionTableLength = 0;
static uint16_t *__CFUniCharBMPPrecompDestinationTable = NULL;
static uint32_t *__CFUniCharNonBMPPrecompDestinationTable = NULL;
static const uint8_t *__CFUniCharNonBaseBitmapForBMP_P = NULL; // Adding _P so the symbol name is different from the one in CFUnicodeDecomposition.c
static const uint8_t *__CFUniCharCombiningClassForBMP = NULL;
static CFSpinLock_t __CFUniCharPrecompositionTableLock = CFSpinLockInit;
static void __CFUniCharLoadPrecompositionTable(void) {
__CFSpinLock(&__CFUniCharPrecompositionTableLock);
if (NULL == __CFUniCharPrecompSourceTable) {
const uint32_t *bytes = (const uint32_t *)CFUniCharGetMappingData(kCFUniCharCanonicalPrecompMapping);
uint32_t bmpMappingLength;
if (NULL == bytes) {
__CFSpinUnlock(&__CFUniCharPrecompositionTableLock);
return;
}
__CFUniCharPrecompositionTableLength = *(bytes++);
bmpMappingLength = *(bytes++);
__CFUniCharPrecompSourceTable = (UTF32Char *)bytes;
__CFUniCharBMPPrecompDestinationTable = (uint16_t *)((intptr_t)bytes + (__CFUniCharPrecompositionTableLength * sizeof(UTF32Char) * 2));
__CFUniCharNonBMPPrecompDestinationTable = (uint32_t *)(((intptr_t)__CFUniCharBMPPrecompDestinationTable) + bmpMappingLength);
__CFUniCharNonBaseBitmapForBMP_P = CFUniCharGetBitmapPtrForPlane(kCFUniCharNonBaseCharacterSet, 0);
__CFUniCharCombiningClassForBMP = (const uint8_t *)CFUniCharGetUnicodePropertyDataForPlane(kCFUniCharCombiningProperty, 0);
}
__CFSpinUnlock(&__CFUniCharPrecompositionTableLock);
}
// Adding _P so the symbol name is different from the one in CFUnicodeDecomposition.c
#define __CFUniCharIsNonBaseCharacter __CFUniCharIsNonBaseCharacter_P
CF_INLINE bool __CFUniCharIsNonBaseCharacter(UTF32Char character) {
return CFUniCharIsMemberOfBitmap(character, (character < 0x10000 ? __CFUniCharNonBaseBitmapForBMP_P : CFUniCharGetBitmapPtrForPlane(kCFUniCharNonBaseCharacterSet, ((character >> 16) & 0xFF))));
}
typedef struct {
UTF16Char _key;
UTF16Char _value;
} __CFUniCharPrecomposeBMPMappings;
static UTF16Char __CFUniCharGetMappedBMPValue(const __CFUniCharPrecomposeBMPMappings *theTable, uint32_t numElem, UTF16Char character) {
const __CFUniCharPrecomposeBMPMappings *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;
}
typedef struct {
UTF32Char _key;
uint32_t _value;
} __CFUniCharPrecomposeMappings;
static uint32_t __CFUniCharGetMappedValue_P(const __CFUniCharPrecomposeMappings *theTable, uint32_t numElem, UTF32Char character) {
const __CFUniCharPrecomposeMappings *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;
}
__private_extern__
UTF32Char CFUniCharPrecomposeCharacter(UTF32Char base, UTF32Char combining) {
uint32_t value;
if (NULL == __CFUniCharPrecompSourceTable) __CFUniCharLoadPrecompositionTable();
if (!(value = __CFUniCharGetMappedValue_P((const __CFUniCharPrecomposeMappings *)__CFUniCharPrecompSourceTable, __CFUniCharPrecompositionTableLength, combining))) return 0xFFFD;
// We don't have precomposition in non-BMP
if (value & kCFUniCharNonBmpFlag) {
value = __CFUniCharGetMappedValue_P((const __CFUniCharPrecomposeMappings *)((uint32_t *)__CFUniCharNonBMPPrecompDestinationTable + (value & 0xFFFF)), (value >> 16) & 0x7FFF, base);
} else {
value = __CFUniCharGetMappedBMPValue((const __CFUniCharPrecomposeBMPMappings *)((uint32_t *)__CFUniCharBMPPrecompDestinationTable + (value & 0xFFFF)), (value >> 16), base);
}
return (value ? value : 0xFFFD);
}
#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)
CF_INLINE void __CFUniCharMoveBufferFromEnd0(UTF16Char *convertedChars, CFIndex length, CFIndex delta) {
const UTF16Char *limit = convertedChars;
UTF16Char *dstP;
convertedChars += length;
dstP = convertedChars + delta;
while (convertedChars > limit) *(--dstP) = *(--convertedChars);
}
bool CFUniCharPrecompose(const UTF16Char *characters, CFIndex length, CFIndex *consumedLength, UTF16Char *precomposed, CFIndex maxLength, CFIndex *filledLength) {
UTF32Char currentChar = 0, lastChar = 0, precomposedChar = 0xFFFD;
CFIndex originalLength = length, usedLength = 0;
UTF16Char *currentBase = precomposed;
uint8_t currentClass, lastClass = 0;
bool currentBaseIsBMP = true;
bool isPrecomposed;
if (NULL == __CFUniCharPrecompSourceTable) __CFUniCharLoadPrecompositionTable();
while (length > 0) {
currentChar = *(characters++);
--length;
if (CFUniCharIsSurrogateHighCharacter(currentChar) && (length > 0) && CFUniCharIsSurrogateLowCharacter(*characters)) {
currentChar = CFUniCharGetLongCharacterForSurrogatePair(currentChar, *(characters++));
--length;
}
if (lastChar && __CFUniCharIsNonBaseCharacter(currentChar)) {
isPrecomposed = (precomposedChar == 0xFFFD ? false : true);
if (isPrecomposed) lastChar = precomposedChar;
currentClass = (currentChar > 0xFFFF ? CFUniCharGetUnicodeProperty(currentChar, kCFUniCharCombiningProperty) : CFUniCharGetCombiningPropertyForCharacter(currentChar, __CFUniCharCombiningClassForBMP));
if ((lastClass == 0) || (currentClass > lastClass)) {
if ((precomposedChar = CFUniCharPrecomposeCharacter(lastChar, currentChar)) == 0xFFFD) {
if (isPrecomposed) precomposedChar = lastChar;
lastClass = currentClass;
} else {
continue;
}
}
if (currentChar > 0xFFFF) { // Non-BMP
usedLength += 2;
if (usedLength > maxLength) break;
currentChar -= 0x10000;
*(precomposed++) = (UTF16Char)((currentChar >> 10) + 0xD800UL);
*(precomposed++) = (UTF16Char)((currentChar & 0x3FF) + 0xDC00UL);
} else {
++usedLength;
if (usedLength > maxLength) break;
*(precomposed++) = (UTF16Char)currentChar;
}
} else {
if ((currentChar >= HANGUL_LBASE) && (currentChar < (HANGUL_LBASE + 0xFF))) { // Hangul Jamo
int8_t lIndex = currentChar - HANGUL_LBASE;
if ((length > 0) && (0 <= lIndex) && (lIndex <= HANGUL_LCOUNT)) {
int16_t vIndex = *characters - HANGUL_VBASE;
if ((vIndex >= 0) && (vIndex <= HANGUL_VCOUNT)) {
int16_t tIndex = 0;
++characters; --length;
if (length > 0) {
tIndex = *characters - HANGUL_TBASE;
if ((tIndex < 0) || (tIndex > HANGUL_TCOUNT)) {
tIndex = 0;
} else {
++characters; --length;
}
}
currentChar = (lIndex * HANGUL_VCOUNT + vIndex) * HANGUL_TCOUNT + tIndex + HANGUL_SBASE;
}
}
}
if (precomposedChar != 0xFFFD) {
if (currentBaseIsBMP) { // Non-BMP
if (lastChar > 0xFFFF) { // Last char was Non-BMP
--usedLength;
memmove(currentBase + 1, currentBase + 2, (precomposed - (currentBase + 2)) * sizeof(UTF16Char));
}
*(currentBase) = (UTF16Char)precomposedChar;
} else {
if (lastChar < 0x10000) { // Last char was BMP
++usedLength;
if (usedLength > maxLength) break;
__CFUniCharMoveBufferFromEnd0(currentBase + 1, precomposed - (currentBase + 1), 1);
}
precomposedChar -= 0x10000;
*currentBase = (UTF16Char)((precomposedChar >> 10) + 0xD800UL);
*(currentBase + 1) = (UTF16Char)((precomposedChar & 0x3FF) + 0xDC00UL);
}
precomposedChar = 0xFFFD;
}
currentBase = precomposed;
lastChar = currentChar;
lastClass = 0;
if (currentChar > 0xFFFF) { // Non-BMP
usedLength += 2;
if (usedLength > maxLength) break;
currentChar -= 0x10000;
*(precomposed++) = (UTF16Char)((currentChar >> 10) + 0xD800UL);
*(precomposed++) = (UTF16Char)((currentChar & 0x3FF) + 0xDC00UL);
currentBaseIsBMP = false;
} else {
++usedLength;
if (usedLength > maxLength) break;
*(precomposed++) = (UTF16Char)currentChar;
currentBaseIsBMP = true;
}
}
}
if (precomposedChar != 0xFFFD) {
if (currentChar > 0xFFFF) { // Non-BMP
if (lastChar < 0x10000) { // Last char was BMP
++usedLength;
if (usedLength > maxLength) {
if (consumedLength) *consumedLength = originalLength - length;
if (filledLength) *filledLength = usedLength;
return false;
}
__CFUniCharMoveBufferFromEnd0(currentBase + 1, precomposed - (currentBase + 1), 1);
}
precomposedChar -= 0x10000;
*currentBase = (UTF16Char)((precomposedChar >> 10) + 0xD800UL);
*(currentBase + 1) = (UTF16Char)((precomposedChar & 0x3FF) + 0xDC00UL);
} else {
if (lastChar > 0xFFFF) { // Last char was Non-BMP
--usedLength;
memmove(currentBase + 1, currentBase + 2, (precomposed - (currentBase + 2)) * sizeof(UTF16Char));
}
*(currentBase) = (UTF16Char)precomposedChar;
}
}
if (consumedLength) *consumedLength = originalLength - length;
if (filledLength) *filledLength = usedLength;
return true;
}
#undef __CFUniCharIsNonBaseCharacter
#undef HANGUL_SBASE
#undef HANGUL_LBASE
#undef HANGUL_VBASE
#undef HANGUL_TBASE
#undef HANGUL_SCOUNT
#undef HANGUL_LCOUNT
#undef HANGUL_VCOUNT
#undef HANGUL_TCOUNT
#undef HANGUL_NCOUNT