Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
branch: master
Fetching contributors…

Cannot retrieve contributors at this time

1278 lines (1076 sloc) 50.943 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@
*/
/* CFUniChar.c
Copyright 2001-2002, Apple, Inc. All rights reserved.
Responsibility: Aki Inoue
*/
#include <CoreFoundation/CFByteOrder.h>
#include "CFInternal.h"
#include "CFBundle_Internal.h"
#include "CFUniChar.h"
#include "CFStringEncodingConverterExt.h"
#include "CFUnicodeDecomposition.h"
#include "CFUniCharPriv.h"
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_LINUX || DEPLOYMENT_TARGET_FREEBSD
#include <fcntl.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <sys/mman.h>
#include <unistd.h>
#include <stdlib.h>
#elif DEPLOYMENT_TARGET_WINDOWS
#include <windows.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <io.h>
#include <stdlib.h>
extern size_t strlcpy(char *dst, const char *src, size_t siz);
extern size_t strlcat(char *dst, const char *src, size_t siz);
#endif
#if DEPLOYMENT_TARGET_MACOSX
#include <mach/mach.h>
#endif
#if DEPLOYMENT_TARGET_MACOSX
#define __kCFCharacterSetDir "/System/Library/CoreServices"
#elif DEPLOYMENT_TARGET_LINUX || DEPLOYMENT_TARGET_FREEBSD
#define __kCFCharacterSetDir "/usr/local/share/CoreFoundation"
#elif DEPLOYMENT_TARGET_WINDOWS
#define __kCFCharacterSetDir "\\Windows\\CoreFoundation"
#define MAXPATHLEN MAX_PATH
#endif
#if DEPLOYMENT_TARGET_MACOSX
#define USE_MACHO_SEGMENT 1
#endif //__MACH__
enum {
kCFUniCharLastExternalSet = kCFUniCharNewlineCharacterSet,
kCFUniCharFirstInternalSet = kCFUniCharCompatibilityDecomposableCharacterSet,
kCFUniCharLastInternalSet = kCFUniCharGraphemeExtendCharacterSet,
kCFUniCharFirstBitmapSet = kCFUniCharDecimalDigitCharacterSet
};
CF_INLINE uint32_t __CFUniCharMapExternalSetToInternalIndex(uint32_t cset) { return ((kCFUniCharFirstInternalSet <= cset) ? ((cset - kCFUniCharFirstInternalSet) + kCFUniCharLastExternalSet) : cset) - kCFUniCharFirstBitmapSet; }
CF_INLINE uint32_t __CFUniCharMapCompatibilitySetID(uint32_t cset) { return ((cset == kCFUniCharControlCharacterSet) ? kCFUniCharControlAndFormatterCharacterSet : (((cset > kCFUniCharLastExternalSet) && (cset < kCFUniCharFirstInternalSet)) ? ((cset - kCFUniCharLastExternalSet) + kCFUniCharFirstInternalSet) : cset)); }
#if (DEPLOYMENT_TARGET_MACOSX) && USE_MACHO_SEGMENT
#include <mach-o/getsect.h>
#include <mach-o/dyld.h>
#include <mach-o/ldsyms.h>
static const void *__CFGetSectDataPtr(const char *segname, const char *sectname, uint64_t *sizep) {
uint32_t idx, cnt = _dyld_image_count();
for (idx = 0; idx < cnt; idx++) {
void *mh = (void *)_dyld_get_image_header(idx);
if (mh != &_mh_dylib_header) continue;
#if __LP64__
const struct section_64 *sect = getsectbynamefromheader_64((struct mach_header_64 *)mh, segname, sectname);
#else
const struct section *sect = getsectbynamefromheader((struct mach_header *)mh, segname, sectname);
#endif
if (!sect) break;
if (sizep) *sizep = (uint64_t)sect->size;
return (char *)sect->addr + _dyld_get_image_vmaddr_slide(idx);
}
if (sizep) *sizep = 0ULL;
return NULL;
}
#endif
#if !USE_MACHO_SEGMENT
#if DEPLOYMENT_TARGET_WINDOWS
extern const char* _CFDLLPath(void);
#endif
// Memory map the file
CF_INLINE void __CFUniCharCharacterSetPath(char *cpath) {
#if DEPLOYMENT_TARGET_MACOSX
strlcpy(cpath, __kCFCharacterSetDir, MAXPATHLEN);
#elif DEPLOYMENT_TARGET_WINDOWS
strlcpy(cpath, _CFDLLPath(), MAXPATHLEN);
#else
strlcpy(cpath, __kCFCharacterSetDir, MAXPATHLEN);
#endif
#if DEPLOYMENT_TARGET_WINDOWS || 0
#if 0
strncat(cpath, "\\Resources\\", MAXPATHLEN - strlen(cpath));
#else
strncat(cpath, "\\CoreFoundation.resources\\CharacterSets\\", MAXPATHLEN - strlen(cpath));
#endif
#else
strlcat(cpath, "/CharacterSets/", MAXPATHLEN);
#endif
}
#if DEPLOYMENT_TARGET_WINDOWS
#define MAX_BITMAP_STATE 512
//
// If a string is placed into this array, then it has been previously
// determined that the bitmap-file cannot be found. Thus, we make
// the assumption it won't be there in future calls and we avoid
// hitting the disk un-necessarily. This assumption isn't 100%
// correct, as bitmap-files can be added. We would have to re-start
// the application in order to pick-up the new bitmap info.
//
// We should probably re-visit this.
//
static char *mappedBitmapState[MAX_BITMAP_STATE];
static int __nNumStateEntries = -1;
CRITICAL_SECTION __bitmapStateLock = {0};
bool __GetBitmapStateForName(char *bitmapName) {
if (NULL == __bitmapStateLock.DebugInfo)
InitializeCriticalSection(&__bitmapStateLock);
EnterCriticalSection(&__bitmapStateLock);
if (__nNumStateEntries >= 0) {
for (int i = 0; i < __nNumStateEntries; i++) {
if (strcmp(mappedBitmapState[i], bitmapName) == 0) {
LeaveCriticalSection(&__bitmapStateLock);
return true;
}
}
}
LeaveCriticalSection(&__bitmapStateLock);
return false;
}
void __AddBitmapStateForName(char *bitmapName) {
if (NULL == __bitmapStateLock.DebugInfo)
InitializeCriticalSection(&__bitmapStateLock);
EnterCriticalSection(&__bitmapStateLock);
__nNumStateEntries++;
mappedBitmapState[__nNumStateEntries] = (char *)malloc((strlen(bitmapName)+1) * sizeof(char));
strcpy(mappedBitmapState[__nNumStateEntries], bitmapName);
LeaveCriticalSection(&__bitmapStateLock);
}
#endif // DEPLOYMENT_TARGET_WINDOWS
static bool __CFUniCharLoadBytesFromFile(const char *fileName, const void **bytes) {
#if DEPLOYMENT_TARGET_WINDOWS || 0
HANDLE bitmapFileHandle = NULL;
HANDLE mappingHandle = NULL;
if (__GetBitmapStateForName((char *)fileName)) {
// The fileName has been tried in the past, so just return false
// and move on.
*bytes = NULL;
return false;
}
mappingHandle = OpenFileMappingA(FILE_MAP_READ, TRUE, fileName);
if (NULL == mappingHandle) {
if ((bitmapFileHandle = CreateFileA(fileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL)) == INVALID_HANDLE_VALUE) {
// We tried to get the bitmap file for mapping, but it's not there. Add to list of non-existant bitmap-files so
// we don't have to try this again in the future.
__AddBitmapStateForName((char *)fileName);
return false;
}
mappingHandle = CreateFileMappingA(bitmapFileHandle, NULL, PAGE_READONLY, 0, 0, NULL);
CloseHandle(bitmapFileHandle);
if (!mappingHandle) return false;
*bytes = MapViewOfFileEx(mappingHandle, FILE_MAP_READ, 0, 0, 0, 0);
CloseHandle(mappingHandle);
} else {
*bytes = MapViewOfFileEx(mappingHandle, FILE_MAP_READ, 0, 0, 0, 0);
CloseHandle(mappingHandle);
}
return (*bytes ? true : false);
#else
struct stat statBuf;
int fd = -1;
int no_hang_fd = open("/dev/autofs_nowait", 0);
if ((fd = open(fileName, O_RDONLY, 0)) < 0) {
close(no_hang_fd);
return false;
}
if (fstat(fd, &statBuf) < 0 || (*bytes = mmap(0, statBuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0)) == (void *)-1) {
close(fd);
return false;
}
close(fd);
close(no_hang_fd);
return true;
#endif
}
#endif // USE_MACHO_SEGMENT
static bool __CFUniCharLoadFile(const char *bitmapName, const void **bytes) {
#if USE_MACHO_SEGMENT
*bytes = __CFGetSectDataPtr("__UNICODE", bitmapName, NULL);
return *bytes ? true : false;
#else
char cpath[MAXPATHLEN];
__CFUniCharCharacterSetPath(cpath);
strlcat(cpath, bitmapName, MAXPATHLEN);
return __CFUniCharLoadBytesFromFile(cpath, bytes);
#endif
}
// Bitmap functions
CF_INLINE bool isControl(UTF32Char theChar, uint16_t charset, const void *data) { // ISO Control
return (((theChar <= 0x001F) || (theChar >= 0x007F && theChar <= 0x009F)) ? true : false);
}
CF_INLINE bool isWhitespace(UTF32Char theChar, uint16_t charset, const void *data) { // Space
return (((theChar == 0x0020) || (theChar == 0x0009) || (theChar == 0x00A0) || (theChar == 0x1680) || (theChar >= 0x2000 && theChar <= 0x200B) || (theChar == 0x202F) || (theChar == 0x205F) || (theChar == 0x3000)) ? true : false);
}
CF_INLINE bool isNewline(UTF32Char theChar, uint16_t charset, const void *data) { // White space
return (((theChar >= 0x000A && theChar <= 0x000D) || (theChar == 0x0085) || (theChar == 0x2028) || (theChar == 0x2029)) ? true : false);
}
CF_INLINE bool isWhitespaceAndNewline(UTF32Char theChar, uint16_t charset, const void *data) { // White space
return ((isWhitespace(theChar, charset, data) || isNewline(theChar, charset, data)) ? true : false);
}
typedef struct {
uint32_t _numPlanes;
const uint8_t **_planes;
} __CFUniCharBitmapData;
static char __CFUniCharUnicodeVersionString[8] = {0, 0, 0, 0, 0, 0, 0, 0};
static uint32_t __CFUniCharNumberOfBitmaps = 0;
static __CFUniCharBitmapData *__CFUniCharBitmapDataArray = NULL;
static CFSpinLock_t __CFUniCharBitmapLock = CFSpinLockInit;
#if !defined(CF_UNICHAR_BITMAP_FILE)
#if USE_MACHO_SEGMENT
#define CF_UNICHAR_BITMAP_FILE "__csbitmaps"
#else
#define CF_UNICHAR_BITMAP_FILE "CFCharacterSetBitmaps.bitmap"
#endif
#endif
static bool __CFUniCharLoadBitmapData(void) {
__CFUniCharBitmapData *array;
uint32_t headerSize;
uint32_t bitmapSize;
int numPlanes;
uint8_t currentPlane;
const void *bytes;
const void *bitmapBase;
const void *bitmap;
int idx, bitmapIndex;
__CFSpinLock(&__CFUniCharBitmapLock);
if (__CFUniCharBitmapDataArray || !__CFUniCharLoadFile(CF_UNICHAR_BITMAP_FILE, &bytes)) {
__CFSpinUnlock(&__CFUniCharBitmapLock);
return false;
}
for (idx = 0;idx < 4 && ((const uint8_t *)bytes)[idx];idx++) {
__CFUniCharUnicodeVersionString[idx * 2] = ((const uint8_t *)bytes)[idx];
__CFUniCharUnicodeVersionString[idx * 2 + 1] = '.';
}
__CFUniCharUnicodeVersionString[(idx < 4 ? idx * 2 - 1 : 7)] = '\0';
headerSize = CFSwapInt32BigToHost(*((uint32_t *)((char *)bytes + 4)));
bitmapBase = (uint8_t *)bytes + headerSize;
bytes = (uint8_t *)bytes + (sizeof(uint32_t) * 2);
headerSize -= (sizeof(uint32_t) * 2);
__CFUniCharNumberOfBitmaps = headerSize / (sizeof(uint32_t) * 2);
array = (__CFUniCharBitmapData *)CFAllocatorAllocate(kCFAllocatorSystemDefault, sizeof(__CFUniCharBitmapData) * __CFUniCharNumberOfBitmaps, 0);
for (idx = 0;idx < (int)__CFUniCharNumberOfBitmaps;idx++) {
bitmap = (uint8_t *)bitmapBase + CFSwapInt32BigToHost(*((uint32_t *)bytes)); bytes = (uint8_t *)bytes + sizeof(uint32_t);
bitmapSize = CFSwapInt32BigToHost(*((uint32_t *)bytes)); bytes = (uint8_t *)bytes + sizeof(uint32_t);
numPlanes = bitmapSize / (8 * 1024);
numPlanes = *(const uint8_t *)((char *)bitmap + (((numPlanes - 1) * ((8 * 1024) + 1)) - 1)) + 1;
array[idx]._planes = (const uint8_t **)CFAllocatorAllocate(kCFAllocatorSystemDefault, sizeof(const void *) * numPlanes, 0);
array[idx]._numPlanes = numPlanes;
currentPlane = 0;
for (bitmapIndex = 0;bitmapIndex < numPlanes;bitmapIndex++) {
if (bitmapIndex == currentPlane) {
array[idx]._planes[bitmapIndex] = (const uint8_t *)bitmap;
bitmap = (uint8_t *)bitmap + (8 * 1024);
#if defined (__cplusplus)
currentPlane = *(((const uint8_t*&)bitmap)++);
#else
currentPlane = *((const uint8_t *)bitmap++);
#endif //C++
} else {
array[idx]._planes[bitmapIndex] = NULL;
}
}
}
__CFUniCharBitmapDataArray = array;
__CFSpinUnlock(&__CFUniCharBitmapLock);
return true;
}
__private_extern__ const char *__CFUniCharGetUnicodeVersionString(void) {
if (NULL == __CFUniCharBitmapDataArray) __CFUniCharLoadBitmapData();
return __CFUniCharUnicodeVersionString;
}
bool CFUniCharIsMemberOf(UTF32Char theChar, uint32_t charset) {
charset = __CFUniCharMapCompatibilitySetID(charset);
switch (charset) {
case kCFUniCharWhitespaceCharacterSet:
return isWhitespace(theChar, charset, NULL);
case kCFUniCharWhitespaceAndNewlineCharacterSet:
return isWhitespaceAndNewline(theChar, charset, NULL);
case kCFUniCharNewlineCharacterSet:
return isNewline(theChar, charset, NULL);
default: {
uint32_t tableIndex = __CFUniCharMapExternalSetToInternalIndex(charset);
if (NULL == __CFUniCharBitmapDataArray) __CFUniCharLoadBitmapData();
if (tableIndex < __CFUniCharNumberOfBitmaps) {
__CFUniCharBitmapData *data = __CFUniCharBitmapDataArray + tableIndex;
uint8_t planeNo = (theChar >> 16) & 0xFF;
// The bitmap data for kCFUniCharIllegalCharacterSet is actually LEGAL set less Plane 14 ~ 16
if (charset == kCFUniCharIllegalCharacterSet) {
if (planeNo == 0x0E) { // Plane 14
theChar &= 0xFF;
return (((theChar == 0x01) || ((theChar > 0x1F) && (theChar < 0x80))) ? false : true);
} else if (planeNo == 0x0F || planeNo == 0x10) { // Plane 15 & 16
return ((theChar & 0xFF) > 0xFFFD ? true : false);
} else {
return (planeNo < data->_numPlanes && data->_planes[planeNo] ? !CFUniCharIsMemberOfBitmap(theChar, data->_planes[planeNo]) : true);
}
} else if (charset == kCFUniCharControlAndFormatterCharacterSet) {
if (planeNo == 0x0E) { // Plane 14
theChar &= 0xFF;
return (((theChar == 0x01) || ((theChar > 0x1F) && (theChar < 0x80))) ? true : false);
} else {
return (planeNo < data->_numPlanes && data->_planes[planeNo] ? CFUniCharIsMemberOfBitmap(theChar, data->_planes[planeNo]) : false);
}
} else {
return (planeNo < data->_numPlanes && data->_planes[planeNo] ? CFUniCharIsMemberOfBitmap(theChar, data->_planes[planeNo]) : false);
}
}
return false;
}
}
}
const uint8_t *CFUniCharGetBitmapPtrForPlane(uint32_t charset, uint32_t plane) {
if (NULL == __CFUniCharBitmapDataArray) __CFUniCharLoadBitmapData();
charset = __CFUniCharMapCompatibilitySetID(charset);
if ((charset > kCFUniCharWhitespaceAndNewlineCharacterSet) && (charset != kCFUniCharIllegalCharacterSet) && (charset != kCFUniCharNewlineCharacterSet)) {
uint32_t tableIndex = __CFUniCharMapExternalSetToInternalIndex(charset);
if (tableIndex < __CFUniCharNumberOfBitmaps) {
__CFUniCharBitmapData *data = __CFUniCharBitmapDataArray + tableIndex;
return (plane < data->_numPlanes ? data->_planes[plane] : NULL);
}
}
return NULL;
}
__private_extern__ uint8_t CFUniCharGetBitmapForPlane(uint32_t charset, uint32_t plane, void *bitmap, bool isInverted) {
const uint8_t *src = CFUniCharGetBitmapPtrForPlane(charset, plane);
int numBytes = (8 * 1024);
if (src) {
if (isInverted) {
#if defined (__cplusplus)
while (numBytes-- > 0) *(((uint8_t *&)bitmap)++) = ~(*(src++));
#else
while (numBytes-- > 0) *((uint8_t *)bitmap++) = ~(*(src++));
#endif //C++
} else {
#if defined (__cplusplus)
while (numBytes-- > 0) *(((uint8_t *&)bitmap)++) = *(src++);
#else
while (numBytes-- > 0) *((uint8_t *)bitmap++) = *(src++);
#endif //C++
}
return kCFUniCharBitmapFilled;
} else if (charset == kCFUniCharIllegalCharacterSet) {
__CFUniCharBitmapData *data = __CFUniCharBitmapDataArray + __CFUniCharMapExternalSetToInternalIndex(__CFUniCharMapCompatibilitySetID(charset));
if (plane < data->_numPlanes && (src = data->_planes[plane])) {
if (isInverted) {
#if defined (__cplusplus)
while (numBytes-- > 0) *(((uint8_t *&)bitmap)++) = *(src++);
#else
while (numBytes-- > 0) *((uint8_t *)bitmap++) = *(src++);
#endif //C++
} else {
#if defined (__cplusplus)
while (numBytes-- > 0) *(((uint8_t *&)bitmap)++) = ~(*(src++));
#else
while (numBytes-- > 0) *((uint8_t *)bitmap++) = ~(*(src++));
#endif //C++
}
return kCFUniCharBitmapFilled;
} else if (plane == 0x0E) { // Plane 14
int idx;
uint8_t asciiRange = (isInverted ? (uint8_t)0xFF : (uint8_t)0);
uint8_t otherRange = (isInverted ? (uint8_t)0 : (uint8_t)0xFF);
#if defined (__cplusplus)
*(((uint8_t *&)bitmap)++) = 0x02; // UE0001 LANGUAGE TAG
#else
*((uint8_t *)bitmap++) = 0x02; // UE0001 LANGUAGE TAG
#endif //C++
for (idx = 1;idx < numBytes;idx++) {
#if defined (__cplusplus)
*(((uint8_t *&)bitmap)++) = ((idx >= (0x20 / 8) && (idx < (0x80 / 8))) ? asciiRange : otherRange);
#else
*((uint8_t *)bitmap++) = ((idx >= (0x20 / 8) && (idx < (0x80 / 8))) ? asciiRange : otherRange);
#endif //C++
}
return kCFUniCharBitmapFilled;
} else if (plane == 0x0F || plane == 0x10) { // Plane 15 & 16
uint32_t value = (isInverted ? ~0 : 0);
numBytes /= 4; // for 32bit
while (numBytes-- > 0) {
*((uint32_t *)bitmap) = value;
#if defined (__cplusplus)
bitmap = (uint8_t *)bitmap + sizeof(uint32_t);
#else
bitmap += sizeof(uint32_t);
#endif //C++
}
*(((uint8_t *)bitmap) - 5) = (isInverted ? 0x3F : 0xC0); // 0xFFFE & 0xFFFF
return kCFUniCharBitmapFilled;
}
return (isInverted ? kCFUniCharBitmapEmpty : kCFUniCharBitmapAll);
} else if ((charset < kCFUniCharDecimalDigitCharacterSet) || (charset == kCFUniCharNewlineCharacterSet)) {
if (plane) return (isInverted ? kCFUniCharBitmapAll : kCFUniCharBitmapEmpty);
uint8_t *bitmapBase = (uint8_t *)bitmap;
CFIndex idx;
uint8_t nonFillValue = (isInverted ? (uint8_t)0xFF : (uint8_t)0);
#if defined (__cplusplus)
while (numBytes-- > 0) *(((uint8_t *&)bitmap)++) = nonFillValue;
#else
while (numBytes-- > 0) *((uint8_t *)bitmap++) = nonFillValue;
#endif //C++
if ((charset == kCFUniCharWhitespaceAndNewlineCharacterSet) || (charset == kCFUniCharNewlineCharacterSet)) {
const UniChar newlines[] = {0x000A, 0x000B, 0x000C, 0x000D, 0x0085, 0x2028, 0x2029};
for (idx = 0;idx < (int)(sizeof(newlines) / sizeof(*newlines)); idx++) {
if (isInverted) {
CFUniCharRemoveCharacterFromBitmap(newlines[idx], bitmapBase);
} else {
CFUniCharAddCharacterToBitmap(newlines[idx], bitmapBase);
}
}
if (charset == kCFUniCharNewlineCharacterSet) return kCFUniCharBitmapFilled;
}
if (isInverted) {
CFUniCharRemoveCharacterFromBitmap(0x0009, bitmapBase);
CFUniCharRemoveCharacterFromBitmap(0x0020, bitmapBase);
CFUniCharRemoveCharacterFromBitmap(0x00A0, bitmapBase);
CFUniCharRemoveCharacterFromBitmap(0x1680, bitmapBase);
CFUniCharRemoveCharacterFromBitmap(0x202F, bitmapBase);
CFUniCharRemoveCharacterFromBitmap(0x205F, bitmapBase);
CFUniCharRemoveCharacterFromBitmap(0x3000, bitmapBase);
} else {
CFUniCharAddCharacterToBitmap(0x0009, bitmapBase);
CFUniCharAddCharacterToBitmap(0x0020, bitmapBase);
CFUniCharAddCharacterToBitmap(0x00A0, bitmapBase);
CFUniCharAddCharacterToBitmap(0x1680, bitmapBase);
CFUniCharAddCharacterToBitmap(0x202F, bitmapBase);
CFUniCharAddCharacterToBitmap(0x205F, bitmapBase);
CFUniCharAddCharacterToBitmap(0x3000, bitmapBase);
}
for (idx = 0x2000;idx <= 0x200B;idx++) {
if (isInverted) {
CFUniCharRemoveCharacterFromBitmap(idx, bitmapBase);
} else {
CFUniCharAddCharacterToBitmap(idx, bitmapBase);
}
}
return kCFUniCharBitmapFilled;
}
return (isInverted ? kCFUniCharBitmapAll : kCFUniCharBitmapEmpty);
}
__private_extern__ uint32_t CFUniCharGetNumberOfPlanes(uint32_t charset) {
if ((charset == kCFUniCharControlCharacterSet) || (charset == kCFUniCharControlAndFormatterCharacterSet)) {
return 15; // 0 to 14
} else if (charset < kCFUniCharDecimalDigitCharacterSet) {
return 1;
} else if (charset == kCFUniCharIllegalCharacterSet) {
return 17;
} else {
uint32_t numPlanes;
if (NULL == __CFUniCharBitmapDataArray) __CFUniCharLoadBitmapData();
numPlanes = __CFUniCharBitmapDataArray[__CFUniCharMapExternalSetToInternalIndex(__CFUniCharMapCompatibilitySetID(charset))]._numPlanes;
return numPlanes;
}
}
// Mapping data loading
static const void **__CFUniCharMappingTables = NULL;
static CFSpinLock_t __CFUniCharMappingTableLock = CFSpinLockInit;
#if __CF_BIG_ENDIAN__
#if USE_MACHO_SEGMENT
#define MAPPING_TABLE_FILE "__data"
#else
#define MAPPING_TABLE_FILE "CFUnicodeData-B.mapping"
#endif
#else
#if USE_MACHO_SEGMENT
#define MAPPING_TABLE_FILE "__data"
#else
#define MAPPING_TABLE_FILE "CFUnicodeData-L.mapping"
#endif
#endif
__private_extern__ const void *CFUniCharGetMappingData(uint32_t type) {
__CFSpinLock(&__CFUniCharMappingTableLock);
if (NULL == __CFUniCharMappingTables) {
const void *bytes;
const void *bodyBase;
int headerSize;
int idx, count;
if (!__CFUniCharLoadFile(MAPPING_TABLE_FILE, &bytes)) {
__CFSpinUnlock(&__CFUniCharMappingTableLock);
return NULL;
}
#if defined (__cplusplus)
bytes = (uint8_t *)bytes + 4; // Skip Unicode version
headerSize = *((uint8_t *)bytes); bytes = (uint8_t *)bytes + sizeof(uint32_t);
#else
bytes += 4; // Skip Unicode version
headerSize = *((uint32_t *)bytes); bytes += sizeof(uint32_t);
#endif //C++
headerSize -= (sizeof(uint32_t) * 2);
bodyBase = (char *)bytes + headerSize;
count = headerSize / sizeof(uint32_t);
__CFUniCharMappingTables = (const void **)CFAllocatorAllocate(kCFAllocatorSystemDefault, sizeof(const void *) * count, 0);
for (idx = 0;idx < count;idx++) {
#if defined (__cplusplus)
__CFUniCharMappingTables[idx] = (char *)bodyBase + *((uint32_t *)bytes); bytes = (uint8_t *)bytes + sizeof(uint32_t);
#else
__CFUniCharMappingTables[idx] = (char *)bodyBase + *((uint32_t *)bytes); bytes += sizeof(uint32_t);
#endif //C++
}
}
__CFSpinUnlock(&__CFUniCharMappingTableLock);
return __CFUniCharMappingTables[type];
}
// Case mapping functions
#define DO_SPECIAL_CASE_MAPPING 1
static uint32_t *__CFUniCharCaseMappingTableCounts = NULL;
static uint32_t **__CFUniCharCaseMappingTable = NULL;
static const uint32_t **__CFUniCharCaseMappingExtraTable = NULL;
typedef struct {
uint32_t _key;
uint32_t _value;
} __CFUniCharCaseMappings;
/* Binary searches CFStringEncodingUnicodeTo8BitCharMap */
static uint32_t __CFUniCharGetMappedCase(const __CFUniCharCaseMappings *theTable, uint32_t numElem, UTF32Char character) {
const __CFUniCharCaseMappings *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 NUM_CASE_MAP_DATA (kCFUniCharCaseFold + 1)
static bool __CFUniCharLoadCaseMappingTable(void) {
uint32_t *countArray;
int idx;
if (NULL == __CFUniCharMappingTables) (void)CFUniCharGetMappingData(kCFUniCharToLowercase);
if (NULL == __CFUniCharMappingTables) return false;
__CFSpinLock(&__CFUniCharMappingTableLock);
if (__CFUniCharCaseMappingTableCounts) {
__CFSpinUnlock(&__CFUniCharMappingTableLock);
return true;
}
countArray = (uint32_t *)CFAllocatorAllocate(kCFAllocatorSystemDefault, sizeof(uint32_t) * NUM_CASE_MAP_DATA + sizeof(uint32_t *) * NUM_CASE_MAP_DATA * 2, 0);
__CFUniCharCaseMappingTable = (uint32_t **)((char *)countArray + sizeof(uint32_t) * NUM_CASE_MAP_DATA);
__CFUniCharCaseMappingExtraTable = (const uint32_t **)__CFUniCharCaseMappingTable + NUM_CASE_MAP_DATA;
for (idx = 0;idx < NUM_CASE_MAP_DATA;idx++) {
countArray[idx] = *((uint32_t *)__CFUniCharMappingTables[idx]) / (sizeof(uint32_t) * 2);
__CFUniCharCaseMappingTable[idx] = ((uint32_t *)__CFUniCharMappingTables[idx]) + 1;
__CFUniCharCaseMappingExtraTable[idx] = (const uint32_t *)((char *)__CFUniCharCaseMappingTable[idx] + *((uint32_t *)__CFUniCharMappingTables[idx]));
}
__CFUniCharCaseMappingTableCounts = countArray;
__CFSpinUnlock(&__CFUniCharMappingTableLock);
return true;
}
#if __CF_BIG_ENDIAN__
#define TURKISH_LANG_CODE (0x7472) // tr
#define LITHUANIAN_LANG_CODE (0x6C74) // lt
#define AZERI_LANG_CODE (0x617A) // az
#else
#define TURKISH_LANG_CODE (0x7274) // tr
#define LITHUANIAN_LANG_CODE (0x746C) // lt
#define AZERI_LANG_CODE (0x7A61) // az
#endif
CFIndex CFUniCharMapCaseTo(UTF32Char theChar, UTF16Char *convertedChar, CFIndex maxLength, uint32_t ctype, uint32_t flags, const uint8_t *langCode) {
__CFUniCharBitmapData *data;
uint8_t planeNo = (theChar >> 16) & 0xFF;
caseFoldRetry:
#if DO_SPECIAL_CASE_MAPPING
if (flags & kCFUniCharCaseMapFinalSigma) {
if (theChar == 0x03A3) { // Final sigma
*convertedChar = (ctype == kCFUniCharToLowercase ? 0x03C2 : 0x03A3);
return 1;
}
}
if (langCode) {
switch (*(uint16_t *)langCode) {
case LITHUANIAN_LANG_CODE:
if (theChar == 0x0307 && (flags & kCFUniCharCaseMapAfter_i)) {
return 0;
} else if (ctype == kCFUniCharToLowercase) {
if (flags & kCFUniCharCaseMapMoreAbove) {
switch (theChar) {
case 0x0049: // LATIN CAPITAL LETTER I
*(convertedChar++) = 0x0069;
*(convertedChar++) = 0x0307;
return 2;
case 0x004A: // LATIN CAPITAL LETTER J
*(convertedChar++) = 0x006A;
*(convertedChar++) = 0x0307;
return 2;
case 0x012E: // LATIN CAPITAL LETTER I WITH OGONEK
*(convertedChar++) = 0x012F;
*(convertedChar++) = 0x0307;
return 2;
default: break;
}
}
switch (theChar) {
case 0x00CC: // LATIN CAPITAL LETTER I WITH GRAVE
*(convertedChar++) = 0x0069;
*(convertedChar++) = 0x0307;
*(convertedChar++) = 0x0300;
return 3;
case 0x00CD: // LATIN CAPITAL LETTER I WITH ACUTE
*(convertedChar++) = 0x0069;
*(convertedChar++) = 0x0307;
*(convertedChar++) = 0x0301;
return 3;
case 0x0128: // LATIN CAPITAL LETTER I WITH TILDE
*(convertedChar++) = 0x0069;
*(convertedChar++) = 0x0307;
*(convertedChar++) = 0x0303;
return 3;
default: break;
}
}
break;
case TURKISH_LANG_CODE:
case AZERI_LANG_CODE:
if ((theChar == 0x0049) || (theChar == 0x0131)) { // LATIN CAPITAL LETTER I & LATIN SMALL LETTER DOTLESS I
*convertedChar = (((ctype == kCFUniCharToLowercase) || (ctype == kCFUniCharCaseFold)) ? ((kCFUniCharCaseMapMoreAbove & flags) ? 0x0069 : 0x0131) : 0x0049);
return 1;
} else if ((theChar == 0x0069) || (theChar == 0x0130)) { // LATIN SMALL LETTER I & LATIN CAPITAL LETTER I WITH DOT ABOVE
*convertedChar = (((ctype == kCFUniCharToLowercase) || (ctype == kCFUniCharCaseFold)) ? 0x0069 : 0x0130);
return 1;
} else if (theChar == 0x0307 && (kCFUniCharCaseMapAfter_i & flags)) { // COMBINING DOT ABOVE AFTER_i
if (ctype == kCFUniCharToLowercase) {
return 0;
} else {
*convertedChar = 0x0307;
return 1;
}
}
break;
default: break;
}
}
#endif /* DO_SPECIAL_CASE_MAPPING */
if (NULL == __CFUniCharBitmapDataArray) __CFUniCharLoadBitmapData();
data = __CFUniCharBitmapDataArray + __CFUniCharMapExternalSetToInternalIndex(__CFUniCharMapCompatibilitySetID(ctype + kCFUniCharHasNonSelfLowercaseCharacterSet));
if (planeNo < data->_numPlanes && data->_planes[planeNo] && CFUniCharIsMemberOfBitmap(theChar, data->_planes[planeNo]) && (__CFUniCharCaseMappingTableCounts || __CFUniCharLoadCaseMappingTable())) {
uint32_t value = __CFUniCharGetMappedCase((const __CFUniCharCaseMappings *)__CFUniCharCaseMappingTable[ctype], __CFUniCharCaseMappingTableCounts[ctype], theChar);
if (!value && ctype == kCFUniCharToTitlecase) {
value = __CFUniCharGetMappedCase((const __CFUniCharCaseMappings *)__CFUniCharCaseMappingTable[kCFUniCharToUppercase], __CFUniCharCaseMappingTableCounts[kCFUniCharToUppercase], theChar);
if (value) ctype = kCFUniCharToUppercase;
}
if (value) {
CFIndex count = CFUniCharConvertFlagToCount(value);
if (count == 1) {
if (value & kCFUniCharNonBmpFlag) {
if (maxLength > 1) {
value = (value & 0xFFFFFF) - 0x10000;
*(convertedChar++) = (UTF16Char)(value >> 10) + 0xD800UL;
*(convertedChar++) = (UTF16Char)(value & 0x3FF) + 0xDC00UL;
return 2;
}
} else {
*convertedChar = (UTF16Char)value;
return 1;
}
} else if (count < maxLength) {
const uint32_t *extraMapping = __CFUniCharCaseMappingExtraTable[ctype] + (value & 0xFFFFFF);
if (value & kCFUniCharNonBmpFlag) {
CFIndex copiedLen = 0;
while (count-- > 0) {
value = *(extraMapping++);
if (value > 0xFFFF) {
if (copiedLen + 2 >= maxLength) break;
value = (value & 0xFFFFFF) - 0x10000;
convertedChar[copiedLen++] = (UTF16Char)(value >> 10) + 0xD800UL;
convertedChar[copiedLen++] = (UTF16Char)(value & 0x3FF) + 0xDC00UL;
} else {
if (copiedLen + 1 >= maxLength) break;
convertedChar[copiedLen++] = value;
}
}
if (!count) return copiedLen;
} else {
CFIndex idx;
for (idx = 0;idx < count;idx++) *(convertedChar++) = (UTF16Char)*(extraMapping++);
return count;
}
}
}
} else if (ctype == kCFUniCharCaseFold) {
ctype = kCFUniCharToLowercase;
goto caseFoldRetry;
}
if (theChar > 0xFFFF) { // non-BMP
theChar = (theChar & 0xFFFFFF) - 0x10000;
*(convertedChar++) = (UTF16Char)(theChar >> 10) + 0xD800UL;
*(convertedChar++) = (UTF16Char)(theChar & 0x3FF) + 0xDC00UL;
return 2;
} else {
*convertedChar = theChar;
return 1;
}
}
CFIndex CFUniCharMapTo(UniChar theChar, UniChar *convertedChar, CFIndex maxLength, uint16_t ctype, uint32_t flags) {
if (ctype == kCFUniCharCaseFold + 1) { // kCFUniCharDecompose
if (CFUniCharIsDecomposableCharacter(theChar, false)) {
UTF32Char buffer[MAX_DECOMPOSED_LENGTH];
CFIndex usedLength = CFUniCharDecomposeCharacter(theChar, buffer, MAX_DECOMPOSED_LENGTH);
CFIndex idx;
for (idx = 0;idx < usedLength;idx++) *(convertedChar++) = buffer[idx];
return usedLength;
} else {
*convertedChar = theChar;
return 1;
}
} else {
return CFUniCharMapCaseTo(theChar, convertedChar, maxLength, ctype, flags, NULL);
}
}
CF_INLINE bool __CFUniCharIsMoreAbove(UTF16Char *buffer, CFIndex length) {
UTF32Char currentChar;
uint32_t property;
while (length-- > 0) {
currentChar = *(buffer)++;
if (CFUniCharIsSurrogateHighCharacter(currentChar) && (length > 0) && CFUniCharIsSurrogateLowCharacter(*(buffer + 1))) {
currentChar = CFUniCharGetLongCharacterForSurrogatePair(currentChar, *(buffer++));
--length;
}
if (!CFUniCharIsMemberOf(currentChar, kCFUniCharNonBaseCharacterSet)) break;
property = CFUniCharGetCombiningPropertyForCharacter(currentChar, (const uint8_t *)CFUniCharGetUnicodePropertyDataForPlane(kCFUniCharCombiningProperty, (currentChar >> 16) & 0xFF));
if (property == 230) return true; // Above priority
}
return false;
}
CF_INLINE bool __CFUniCharIsAfter_i(UTF16Char *buffer, CFIndex length) {
UTF32Char currentChar = 0;
uint32_t property;
UTF32Char decomposed[MAX_DECOMPOSED_LENGTH];
CFIndex decompLength;
CFIndex idx;
if (length < 1) return 0;
buffer += length;
while (length-- > 1) {
currentChar = *(--buffer);
if (CFUniCharIsSurrogateLowCharacter(currentChar)) {
if ((length > 1) && CFUniCharIsSurrogateHighCharacter(*(buffer - 1))) {
currentChar = CFUniCharGetLongCharacterForSurrogatePair(*(--buffer), currentChar);
--length;
} else {
break;
}
}
if (!CFUniCharIsMemberOf(currentChar, kCFUniCharNonBaseCharacterSet)) break;
property = CFUniCharGetCombiningPropertyForCharacter(currentChar, (const uint8_t *)CFUniCharGetUnicodePropertyDataForPlane(kCFUniCharCombiningProperty, (currentChar >> 16) & 0xFF));
if (property == 230) return false; // Above priority
}
if (length == 0) {
currentChar = *(--buffer);
} else if (CFUniCharIsSurrogateLowCharacter(currentChar) && CFUniCharIsSurrogateHighCharacter(*(--buffer))) {
currentChar = CFUniCharGetLongCharacterForSurrogatePair(*buffer, currentChar);
}
decompLength = CFUniCharDecomposeCharacter(currentChar, decomposed, MAX_DECOMPOSED_LENGTH);
currentChar = *decomposed;
for (idx = 1;idx < decompLength;idx++) {
currentChar = decomposed[idx];
property = CFUniCharGetCombiningPropertyForCharacter(currentChar, (const uint8_t *)CFUniCharGetUnicodePropertyDataForPlane(kCFUniCharCombiningProperty, (currentChar >> 16) & 0xFF));
if (property == 230) return false; // Above priority
}
return true;
}
__private_extern__ uint32_t CFUniCharGetConditionalCaseMappingFlags(UTF32Char theChar, UTF16Char *buffer, CFIndex currentIndex, CFIndex length, uint32_t type, const uint8_t *langCode, uint32_t lastFlags) {
if (theChar == 0x03A3) { // GREEK CAPITAL LETTER SIGMA
if ((type == kCFUniCharToLowercase) && (currentIndex > 0)) {
UTF16Char *start = buffer;
UTF16Char *end = buffer + length;
UTF32Char otherChar;
// First check if we're after a cased character
buffer += (currentIndex - 1);
while (start <= buffer) {
otherChar = *(buffer--);
if (CFUniCharIsSurrogateLowCharacter(otherChar) && (start <= buffer) && CFUniCharIsSurrogateHighCharacter(*buffer)) {
otherChar = CFUniCharGetLongCharacterForSurrogatePair(*(buffer--), otherChar);
}
if (!CFUniCharIsMemberOf(otherChar, kCFUniCharCaseIgnorableCharacterSet)) {
if (!CFUniCharIsMemberOf(otherChar, kCFUniCharUppercaseLetterCharacterSet) && !CFUniCharIsMemberOf(otherChar, kCFUniCharLowercaseLetterCharacterSet)) return 0; // Uppercase set contains titlecase
break;
}
}
// Next check if we're before a cased character
buffer = start + currentIndex + 1;
while (buffer < end) {
otherChar = *(buffer++);
if (CFUniCharIsSurrogateHighCharacter(otherChar) && (buffer < end) && CFUniCharIsSurrogateLowCharacter(*buffer)) {
otherChar = CFUniCharGetLongCharacterForSurrogatePair(otherChar, *(buffer++));
}
if (!CFUniCharIsMemberOf(otherChar, kCFUniCharCaseIgnorableCharacterSet)) {
if (CFUniCharIsMemberOf(otherChar, kCFUniCharUppercaseLetterCharacterSet) || CFUniCharIsMemberOf(otherChar, kCFUniCharLowercaseLetterCharacterSet)) return 0; // Uppercase set contains titlecase
break;
}
}
return kCFUniCharCaseMapFinalSigma;
}
} else if (langCode) {
if (*((const uint16_t *)langCode) == LITHUANIAN_LANG_CODE) {
if ((theChar == 0x0307) && ((kCFUniCharCaseMapAfter_i|kCFUniCharCaseMapMoreAbove) & lastFlags) == (kCFUniCharCaseMapAfter_i|kCFUniCharCaseMapMoreAbove)) {
return (__CFUniCharIsAfter_i(buffer, currentIndex) ? kCFUniCharCaseMapAfter_i : 0);
} else if (type == kCFUniCharToLowercase) {
if ((theChar == 0x0049) || (theChar == 0x004A) || (theChar == 0x012E)) {
return (__CFUniCharIsMoreAbove(buffer + (++currentIndex), length - currentIndex) ? kCFUniCharCaseMapMoreAbove : 0);
}
} else if ((theChar == 'i') || (theChar == 'j')) {
return (__CFUniCharIsMoreAbove(buffer + (++currentIndex), length - currentIndex) ? (kCFUniCharCaseMapAfter_i|kCFUniCharCaseMapMoreAbove) : 0);
}
} else if ((*((const uint16_t *)langCode) == TURKISH_LANG_CODE) || (*((const uint16_t *)langCode) == AZERI_LANG_CODE)) {
if (type == kCFUniCharToLowercase) {
if (theChar == 0x0307) {
return (kCFUniCharCaseMapMoreAbove & lastFlags ? kCFUniCharCaseMapAfter_i : 0);
} else if (theChar == 0x0049) {
return (((++currentIndex < length) && (buffer[currentIndex] == 0x0307)) ? kCFUniCharCaseMapMoreAbove : 0);
}
}
}
}
return 0;
}
// Unicode property database
static __CFUniCharBitmapData *__CFUniCharUnicodePropertyTable = NULL;
static int __CFUniCharUnicodePropertyTableCount = 0;
static CFSpinLock_t __CFUniCharPropTableLock = CFSpinLockInit;
#if USE_MACHO_SEGMENT
#define PROP_DB_FILE "__properties"
#else
#define PROP_DB_FILE "CFUniCharPropertyDatabase.data"
#endif
const void *CFUniCharGetUnicodePropertyDataForPlane(uint32_t propertyType, uint32_t plane) {
__CFSpinLock(&__CFUniCharPropTableLock);
if (NULL == __CFUniCharUnicodePropertyTable) {
__CFUniCharBitmapData *table;
const void *bytes;
const void *bodyBase;
const void *planeBase;
int headerSize;
int idx, count;
int planeIndex, planeCount;
int planeSize;
if (!__CFUniCharLoadFile(PROP_DB_FILE, &bytes)) {
__CFSpinUnlock(&__CFUniCharPropTableLock);
return NULL;
}
#if defined (__cplusplus)
bytes = (uint8_t*)bytes + 4; // Skip Unicode version
headerSize = CFSwapInt32BigToHost(*((uint32_t *)bytes)); bytes = (uint8_t *)bytes + sizeof(uint32_t);
#else
bytes += 4; // Skip Unicode version
headerSize = CFSwapInt32BigToHost(*((uint32_t *)bytes)); bytes += sizeof(uint32_t);
#endif //C++
headerSize -= (sizeof(uint32_t) * 2);
bodyBase = (char *)bytes + headerSize;
count = headerSize / sizeof(uint32_t);
__CFUniCharUnicodePropertyTableCount = count;
table = (__CFUniCharBitmapData *)CFAllocatorAllocate(kCFAllocatorSystemDefault, sizeof(__CFUniCharBitmapData) * count, 0);
for (idx = 0;idx < count;idx++) {
planeCount = *((const uint8_t *)bodyBase);
planeBase = (char *)bodyBase + planeCount + (planeCount % 4 ? 4 - (planeCount % 4) : 0);
table[idx]._planes = (const uint8_t **)CFAllocatorAllocate(kCFAllocatorSystemDefault, sizeof(const void *) * planeCount, 0);
for (planeIndex = 0;planeIndex < planeCount;planeIndex++) {
if ((planeSize = ((const uint8_t *)bodyBase)[planeIndex + 1])) {
table[idx]._planes[planeIndex] = (const uint8_t *)planeBase;
#if defined (__cplusplus)
planeBase = (char*)planeBase + (planeSize * 256);
#else
planeBase += (planeSize * 256);
#endif //C++
} else {
table[idx]._planes[planeIndex] = NULL;
}
}
table[idx]._numPlanes = planeCount;
#if defined (__cplusplus)
bodyBase = (const uint8_t *)bodyBase + (CFSwapInt32BigToHost(*(uint32_t *)bytes));
((uint32_t *&)bytes) ++;
#else
bodyBase += (CFSwapInt32BigToHost(*((uint32_t *)bytes++)));
#endif //C++
}
__CFUniCharUnicodePropertyTable = table;
}
__CFSpinUnlock(&__CFUniCharPropTableLock);
return (plane < __CFUniCharUnicodePropertyTable[propertyType]._numPlanes ? __CFUniCharUnicodePropertyTable[propertyType]._planes[plane] : NULL);
}
__private_extern__ uint32_t CFUniCharGetNumberOfPlanesForUnicodePropertyData(uint32_t propertyType) {
(void)CFUniCharGetUnicodePropertyDataForPlane(propertyType, 0);
return __CFUniCharUnicodePropertyTable[propertyType]._numPlanes;
}
__private_extern__ uint32_t CFUniCharGetUnicodeProperty(UTF32Char character, uint32_t propertyType) {
if (propertyType == kCFUniCharCombiningProperty) {
return CFUniCharGetCombiningPropertyForCharacter(character, (const uint8_t *)CFUniCharGetUnicodePropertyDataForPlane(propertyType, (character >> 16) & 0xFF));
} else if (propertyType == kCFUniCharBidiProperty) {
return CFUniCharGetBidiPropertyForCharacter(character, (const uint8_t *)CFUniCharGetUnicodePropertyDataForPlane(propertyType, (character >> 16) & 0xFF));
} else {
return 0;
}
}
/*
The UTF8 conversion in the following function is derived from ConvertUTF.c
*/
/*
* Copyright 2001 Unicode, Inc.
*
* Disclaimer
*
* This source code is provided as is by Unicode, Inc. No claims are
* made as to fitness for any particular purpose. No warranties of any
* kind are expressed or implied. The recipient agrees to determine
* applicability of information provided. If this file has been
* purchased on magnetic or optical media from Unicode, Inc., the
* sole remedy for any claim will be exchange of defective media
* within 90 days of receipt.
*
* Limitations on Rights to Redistribute This Code
*
* Unicode, Inc. hereby grants the right to freely use the information
* supplied in this file in the creation of products supporting the
* Unicode Standard, and to make copies of this file in any form
* for internal or external distribution as long as this notice
* remains attached.
*/
#define UNI_REPLACEMENT_CHAR (0x0000FFFDUL)
bool CFUniCharFillDestinationBuffer(const UTF32Char *src, CFIndex srcLength, void **dst, CFIndex dstLength, CFIndex *filledLength, uint32_t dstFormat) {
UTF32Char currentChar;
CFIndex usedLength = *filledLength;
if (dstFormat == kCFUniCharUTF16Format) {
UTF16Char *dstBuffer = (UTF16Char *)*dst;
while (srcLength-- > 0) {
currentChar = *(src++);
if (currentChar > 0xFFFF) { // Non-BMP
usedLength += 2;
if (dstLength) {
if (usedLength > dstLength) return false;
currentChar -= 0x10000;
*(dstBuffer++) = (UTF16Char)((currentChar >> 10) + 0xD800UL);
*(dstBuffer++) = (UTF16Char)((currentChar & 0x3FF) + 0xDC00UL);
}
} else {
++usedLength;
if (dstLength) {
if (usedLength > dstLength) return false;
*(dstBuffer++) = (UTF16Char)currentChar;
}
}
}
*dst = dstBuffer;
} else if (dstFormat == kCFUniCharUTF8Format) {
uint8_t *dstBuffer = (uint8_t *)*dst;
uint16_t bytesToWrite = 0;
const UTF32Char byteMask = 0xBF;
const UTF32Char byteMark = 0x80;
static const uint8_t firstByteMark[7] = { 0x00, 0x00, 0xC0, 0xE0, 0xF0, 0xF8, 0xFC };
while (srcLength-- > 0) {
currentChar = *(src++);
/* Figure out how many bytes the result will require */
if (currentChar < (UTF32Char)0x80) {
bytesToWrite = 1;
} else if (currentChar < (UTF32Char)0x800) {
bytesToWrite = 2;
} else if (currentChar < (UTF32Char)0x10000) {
bytesToWrite = 3;
} else if (currentChar < (UTF32Char)0x200000) {
bytesToWrite = 4;
} else {
bytesToWrite = 2;
currentChar = UNI_REPLACEMENT_CHAR;
}
usedLength += bytesToWrite;
if (dstLength) {
if (usedLength > dstLength) return false;
dstBuffer += bytesToWrite;
switch (bytesToWrite) { /* note: everything falls through. */
case 4: *--dstBuffer = (currentChar | byteMark) & byteMask; currentChar >>= 6;
case 3: *--dstBuffer = (currentChar | byteMark) & byteMask; currentChar >>= 6;
case 2: *--dstBuffer = (currentChar | byteMark) & byteMask; currentChar >>= 6;
case 1: *--dstBuffer = currentChar | firstByteMark[bytesToWrite];
}
dstBuffer += bytesToWrite;
}
}
*dst = dstBuffer;
} else {
UTF32Char *dstBuffer = (UTF32Char *)*dst;
while (srcLength-- > 0) {
currentChar = *(src++);
++usedLength;
if (dstLength) {
if (usedLength > dstLength) return false;
*(dstBuffer++) = currentChar;
}
}
*dst = dstBuffer;
}
*filledLength = usedLength;
return true;
}
#if DEPLOYMENT_TARGET_WINDOWS || 0
void __CFUniCharCleanup(void)
{
int idx;
// cleanup memory allocated by __CFUniCharLoadBitmapData()
__CFSpinLock(&__CFUniCharBitmapLock);
if (__CFUniCharBitmapDataArray != NULL) {
for (idx = 0; idx < (int)__CFUniCharNumberOfBitmaps; idx++) {
CFAllocatorDeallocate(kCFAllocatorSystemDefault, __CFUniCharBitmapDataArray[idx]._planes);
__CFUniCharBitmapDataArray[idx]._planes = NULL;
}
CFAllocatorDeallocate(kCFAllocatorSystemDefault, __CFUniCharBitmapDataArray);
__CFUniCharBitmapDataArray = NULL;
__CFUniCharNumberOfBitmaps = 0;
}
__CFSpinUnlock(&__CFUniCharBitmapLock);
// cleanup memory allocated by CFUniCharGetMappingData()
__CFSpinLock(&__CFUniCharMappingTableLock);
if (__CFUniCharMappingTables != NULL) {
CFAllocatorDeallocate(kCFAllocatorSystemDefault, __CFUniCharMappingTables);
__CFUniCharMappingTables = NULL;
}
// cleanup memory allocated by __CFUniCharLoadCaseMappingTable()
if (__CFUniCharCaseMappingTableCounts != NULL) {
CFAllocatorDeallocate(kCFAllocatorSystemDefault, __CFUniCharCaseMappingTableCounts);
__CFUniCharCaseMappingTableCounts = NULL;
__CFUniCharCaseMappingTable = NULL;
__CFUniCharCaseMappingExtraTable = NULL;
}
__CFSpinUnlock(&__CFUniCharMappingTableLock);
// cleanup memory allocated by CFUniCharGetUnicodePropertyDataForPlane()
__CFSpinLock(&__CFUniCharPropTableLock);
if (__CFUniCharUnicodePropertyTable != NULL) {
for (idx = 0; idx < __CFUniCharUnicodePropertyTableCount; idx++) {
CFAllocatorDeallocate(kCFAllocatorSystemDefault, __CFUniCharUnicodePropertyTable[idx]._planes);
__CFUniCharUnicodePropertyTable[idx]._planes = NULL;
}
CFAllocatorDeallocate(kCFAllocatorSystemDefault, __CFUniCharUnicodePropertyTable);
__CFUniCharUnicodePropertyTable = NULL;
__CFUniCharUnicodePropertyTableCount = 0;
}
__CFSpinUnlock(&__CFUniCharPropTableLock);
}
#endif // DEPLOYMENT_TARGET_WINDOWS
#undef USE_MACHO_SEGMENT
Jump to Line
Something went wrong with that request. Please try again.