void CFAllocatorSetDefault(CFAllocatorRef allocator) {
CFAllocatorRef current = __CFGetDefaultAllocator();
#if defined(DEBUG)
if (NULL != allocator) {
__CFGenericValidateType(allocator, _kCFRuntimeIDCFAllocator);
}
#endif
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
if (allocator && allocator->_base._cfisa != __CFISAForCFAllocator()) { // malloc_zone_t *
return; // require allocator to this function to be an allocator
}
#endif
if (NULL != allocator && allocator != current) {
if (current) CFRelease(current);
CFRetain(allocator);
// We retain an extra time so that anything set as the default
// allocator never goes away.
CFRetain(allocator);
_CFSetTSD(__CFTSDKeyAllocator, (void *)allocator, NULL);
}
}
Boolean __CFStringDecodeByteStream3(const uint8_t *bytes, UInt32 len, CFStringEncoding encoding, Boolean alwaysUnicode, CFVarWidthCharBuffer *buffer, Boolean *useClientsMemoryPtr, UInt32 converterFlags) {
UInt32 idx;
const UniChar *uniChars = (const UniChar *)bytes;
const uint8_t *chars = (const uint8_t *)bytes;
const uint8_t *end = chars + len;
uint16_t bom;
Boolean allASCII = false;
if (useClientsMemoryPtr) *useClientsMemoryPtr = false;
buffer->isASCII = !alwaysUnicode;
buffer->shouldFreeChars = false;
buffer->numChars = 0;
if (0 == len) return true;
buffer->allocator = (buffer->allocator ? buffer->allocator : __CFGetDefaultAllocator());
switch (encoding) {
case kCFStringEncodingUnicode:
bom = (*uniChars == 0xfffe || *uniChars == 0xfeff) ? (*uniChars++) : 0;
/* If the byte order mark is missing, we assume big endian... */
len = len / 2 - (0 == bom ? 0 : 1);
if (buffer->isASCII) { // Let's see if we can reduce the Unicode down to ASCII...
if (SHOULD_SWAP(bom)) {
for (idx = 0; idx < len; idx++) if ((uniChars[idx] & 0x80ff) != 0) {buffer->isASCII = false; break;}
} else {
for (idx = 0; idx < len; idx++) if (uniChars[idx] > 127) {buffer->isASCII = false; break;}
}
}
if (buffer->isASCII) {
buffer->numChars = len;
buffer->shouldFreeChars = !buffer->chars.ascii && (len <= MAX_LOCAL_CHARS) ? false : true;
buffer->chars.ascii = (buffer->chars.ascii ? buffer->chars.ascii : (len <= MAX_LOCAL_CHARS) ? (uint8_t *)buffer->localBuffer : CFAllocatorAllocate(buffer->allocator, len * sizeof(uint8_t), 0));
if (SHOULD_SWAP(bom)) { // !!! Can be somewhat trickier here and use a single loop with a properly inited ptr
for (idx = 0; idx < len; idx++) buffer->chars.ascii[idx] = (uniChars[idx] >> 8);
} else {
for (idx = 0; idx < len; idx++) buffer->chars.ascii[idx] = uniChars[idx];
}
} else {
CFIndex CFAllocatorGetPreferredSizeForSize(CFAllocatorRef allocator, CFIndex size, CFOptionFlags hint) {
CFAllocatorPreferredSizeCallBack prefFunc;
CFIndex newsize = 0;
allocator = (NULL == allocator) ? __CFGetDefaultAllocator() : allocator;
#if (DEPLOYMENT_TARGET_MACOSX) && defined(DEBUG)
if (allocator->_base._cfisa == __CFISAForTypeID(__kCFAllocatorTypeID)) {
__CFGenericValidateType(allocator, __kCFAllocatorTypeID);
}
#else
__CFGenericValidateType(allocator, __kCFAllocatorTypeID);
#endif
#if DEPLOYMENT_TARGET_MACOSX
if (allocator->_base._cfisa != __CFISAForTypeID(__kCFAllocatorTypeID)) { // malloc_zone_t *
return malloc_good_size(size);
}
#endif
prefFunc = __CFAllocatorGetPreferredSizeFunction(&allocator->_context);
if (0 < size && NULL != prefFunc) {
newsize = (CFIndex)(INVOKE_CALLBACK3(prefFunc, size, hint, allocator->_context.info));
}
if (newsize < size) newsize = size;
return newsize;
}
void CFAllocatorDeallocate(CFAllocatorRef allocator, void *ptr) {
CFAllocatorDeallocateCallBack deallocateFunc;
allocator = (NULL == allocator) ? __CFGetDefaultAllocator() : allocator;
#if (DEPLOYMENT_TARGET_MACOSX) && defined(DEBUG)
if (allocator->_base._cfisa == __CFISAForTypeID(__kCFAllocatorTypeID)) {
__CFGenericValidateType(allocator, __kCFAllocatorTypeID);
}
#else
__CFGenericValidateType(allocator, __kCFAllocatorTypeID);
#endif
#if DEPLOYMENT_TARGET_MACOSX
if (allocator->_base._cfisa != __CFISAForTypeID(__kCFAllocatorTypeID)) { // malloc_zone_t *
#if defined(DEBUG)
size_t size = malloc_size(ptr);
if (size) memset(ptr, 0xCC, size);
#endif
return malloc_zone_free((malloc_zone_t *)allocator, ptr);
}
#endif
deallocateFunc = __CFAllocatorGetDeallocateFunction(&allocator->_context);
if (NULL != ptr && NULL != deallocateFunc) {
INVOKE_CALLBACK2(deallocateFunc, ptr, allocator->_context.info);
}
}
CFDataRef CFDataCreateWithBytesNoCopy(CFAllocatorRef allocator, const uint8_t *bytes, CFIndex length, CFAllocatorRef bytesDeallocator) {
CFAssert1((0 == length || bytes != NULL), __kCFLogAssertion, "%s(): bytes pointer cannot be NULL if length is non-zero", __PRETTY_FUNCTION__);
if (NULL == bytesDeallocator) bytesDeallocator = __CFGetDefaultAllocator();
return __CFDataInit(allocator, kCFImmutable, length, bytes, length, bytesDeallocator);
}
// NULL bytesDeallocator to this function does not mean the default allocator, it means
// that there should be no deallocator, and the bytes should be copied.
static CFMutableDataRef __CFDataInit(CFAllocatorRef allocator, CFOptionFlags flags, CFIndex capacity, const uint8_t *bytes, CFIndex length, CFAllocatorRef bytesDeallocator) {
CFMutableDataRef memory;
__CFGenericValidateMutabilityFlags(flags);
CFAssert2(0 <= capacity, __kCFLogAssertion, "%s(): capacity (%d) cannot be less than zero", __PRETTY_FUNCTION__, capacity);
CFAssert3(kCFFixedMutable != __CFMutableVarietyFromFlags(flags) || length <= capacity, __kCFLogAssertion, "%s(): for kCFFixedMutable type, capacity (%d) must be greater than or equal to number of initial elements (%d)", __PRETTY_FUNCTION__, capacity, length);
CFAssert2(0 <= length, __kCFLogAssertion, "%s(): length (%d) cannot be less than zero", __PRETTY_FUNCTION__, length);
Boolean collectableMemory = CF_IS_COLLECTABLE_ALLOCATOR(allocator);
Boolean noCopy = bytesDeallocator != NULL;
Boolean isMutable = ((flags & __kCFMutable) != 0);
Boolean isGrowable = ((flags & __kCFGrowable) != 0);
Boolean allocateInline = !isGrowable && !noCopy && capacity < INLINE_BYTES_THRESHOLD;
allocator = (allocator == NULL) ? __CFGetDefaultAllocator() : allocator;
Boolean useAllocator = (allocator != kCFAllocatorSystemDefault && allocator != kCFAllocatorMalloc && allocator != kCFAllocatorMallocZone);
CFIndex size = sizeof(struct __CFData) - sizeof(CFRuntimeBase);
if (allocateInline) {
size += sizeof(uint8_t) * __CFDataNumBytesForCapacity(capacity) + sizeof(uint8_t) * 15; // for 16-byte alignment fixup
}
memory = (CFMutableDataRef)_CFRuntimeCreateInstance(allocator, __kCFDataTypeID, size, NULL);
if (NULL == memory) {
return NULL;
}
__CFDataSetNumBytesUsed(memory, 0);
__CFDataSetLength(memory, 0);
__CFDataSetInfoBits(memory,
(allocateInline ? __kCFBytesInline : 0) |
(useAllocator ? __kCFUseAllocator : 0) |
(collectableMemory ? __kCFAllocatesCollectable : 0));
BOOL finalize = YES;
BOOL scan = YES;
if (collectableMemory) {
if (allocateInline) {
// We have no pointer to anything that needs to be reclaimed, so don't scan or finalize.
scan = NO;
finalize = NO;
} else if (noCopy) {
if (CF_IS_COLLECTABLE_ALLOCATOR(bytesDeallocator)) {
// We're taking responsibility for externally GC-allocated memory, so scan us, but we don't need to finalize.
finalize = NO;
} else if (bytesDeallocator == kCFAllocatorNull) {
// We don't have responsibility for these bytes, so there's no need to be scanned and we don't need to finalize.
scan = NO;
finalize = NO;
} else {
// We have a pointer to non-GC-allocated memory, so don't scan, but do finalize.
scan = NO;
}
}
if (!scan) auto_zone_set_unscanned(objc_collectableZone(), memory);
if (!finalize) auto_zone_set_nofinalize(objc_collectableZone(), memory);
}
if (isMutable && isGrowable) {
__CFDataSetCapacity(memory, __CFDataRoundUpCapacity(1));
__CFDataSetNumBytes(memory, __CFDataNumBytesForCapacity(__CFDataRoundUpCapacity(1)));
__CFSetMutableVariety(memory, kCFMutable);
} else {
/* Don't round up capacity */
__CFDataSetCapacity(memory, capacity);
__CFDataSetNumBytes(memory, __CFDataNumBytesForCapacity(capacity));
__CFSetMutableVariety(memory, kCFFixedMutable);
}
if (noCopy) {
__CFAssignWithWriteBarrier((void **)&memory->_bytes, (uint8_t *)bytes);
if (finalize) {
if (_CFAllocatorIsGCRefZero(bytesDeallocator)) {
memory->_bytesDeallocator = bytesDeallocator;
} else {
memory->_bytesDeallocator = (CFAllocatorRef)CFRetain(_CFConvertAllocatorToNonGCRefZeroEquivalent(bytesDeallocator));
}
}
if (CF_IS_COLLECTABLE_ALLOCATOR(bytesDeallocator) && !_CFAllocatorIsGCRefZero(bytesDeallocator)) {
// When given a GC allocator which is not one of the GCRefZero ones as the deallocator, we assume that the no-copy memory is GC-allocated with a retain count of (at least) 1 and we should release it now instead of waiting until __CFDataDeallocate.
auto_zone_release(objc_collectableZone(), memory->_bytes);
}
__CFDataSetNumBytesUsed(memory, length);
__CFDataSetLength(memory, length);
// Mutable no-copy datas are not allowed, so don't bother setting needsToZero flag.
} else {
Boolean cleared = (isMutable && !isGrowable && !_CFExecutableLinkedOnOrAfter(CFSystemVersionSnowLeopard));
if (!allocateInline) {
// assume that allocators give 16-byte aligned memory back -- it is their responsibility
__CFAssignWithWriteBarrier((void **)&memory->_bytes, __CFDataAllocate(memory, __CFDataNumBytes(memory) * sizeof(uint8_t), cleared));
if (__CFOASafe) __CFSetLastAllocationEventName(memory->_bytes, "CFData (store)");
if (NULL == memory->_bytes) {
CFRelease(memory);
return NULL;
}
} else {
if (length == 0 && !isMutable) {
// NSData sets its bytes pointer to NULL when its length is zero. Starting in 10.7 we do the same for CFData.
memory->_bytes = NULL;
// It is important to set this data as not inlined, so we do not recalculate a bytes pointer from null.
__CFDataSetInline(memory, false);
}
cleared = true;
}
__CFDataSetNeedsToZero(memory, !cleared);
memory->_bytesDeallocator = NULL;
CFDataReplaceBytes(memory, CFRangeMake(0, 0), bytes, length);
}
__CFSetMutableVariety(memory, __CFMutableVarietyFromFlags(flags));
return memory;
}
static _CFPFactory *_CFPFactoryCommonCreate(CFAllocatorRef allocator, CFUUIDRef factoryID) {
_CFPFactory *factory;
UInt32 size;
size = sizeof(_CFPFactory);
allocator = (allocator ? (CFAllocatorRef)CFRetain(allocator) : (CFAllocatorRef)CFRetain(__CFGetDefaultAllocator()));
factory = (_CFPFactory *)CFAllocatorAllocate(allocator, size, 0);
if (!factory) {
CFRelease(allocator);
return NULL;
}
factory->_allocator = allocator;
factory->_uuid = (CFUUIDRef)CFRetain(factoryID);
factory->_enabled = true;
factory->_instanceCount = 0;
_CFPFactoryAddToTable(factory);
factory->_types = CFArrayCreateMutable(allocator, 0, &kCFTypeArrayCallBacks);
return factory;
}
const char *_CFProcessPath(void) {
#if !defined(__LINUX__)
CFAllocatorRef alloc = NULL;
char *thePath = NULL;
int execIndex = 0;
if (__CFProcessPath) return __CFProcessPath;
if (!__CFProcessPath) {
thePath = getenv("CFProcessPath");
alloc = CFRetain(__CFGetDefaultAllocator());
if (thePath) {
int len = strlen(thePath);
__CFProcessPath = CFAllocatorAllocate(alloc, len+1, 0);
if (__CFOASafe) __CFSetLastAllocationEventName((void *)__CFProcessPath, "CFUtilities (process-path)");
memmove((char *)__CFProcessPath, thePath, len + 1);
}
}
#if defined(__MACH__)
{
struct stat exec, lcfm;
unsigned long size = CFMaxPathSize;
char buffer[CFMaxPathSize];
if (0 == _NSGetExecutablePath(buffer, &size) &&
strcasestr(buffer, "LaunchCFMApp") != NULL &&
0 == stat("/System/Library/Frameworks/Carbon.framework/Versions/Current/Support/LaunchCFMApp", &lcfm) &&
0 == stat(buffer, &exec) &&
(lcfm.st_dev == exec.st_dev) &&
(lcfm.st_ino == exec.st_ino)) {
// Executable is LaunchCFMApp, take special action
execIndex = 1;
__CFIsCFM = true;
}
}
#endif
if (!__CFProcessPath && NULL != (*_NSGetArgv())[execIndex]) {
char buf[CFMaxPathSize] = {0};
#if defined(__WIN32__)
HINSTANCE hinst = GetModuleHandle(NULL);
DWORD rlen = hinst ? GetModuleFileName(hinst, buf, 1028) : 0;
thePath = rlen ? buf : NULL;
#else
struct stat statbuf;
const char *arg0 = (*_NSGetArgv())[execIndex];
if (arg0[0] == '/') {
// We've got an absolute path; look no further;
thePath = (char *)arg0;
} else {
char *theList = getenv("PATH");
if (NULL != theList && NULL == strrchr(arg0, '/')) {
thePath = _CFSearchForNameInPath(alloc, arg0, theList);
if (thePath) {
// User could have "." or "../bin" or other relative path in $PATH
if (('/' != thePath[0]) && _CFGetCurrentDirectory(buf, CFMaxPathSize)) {
strlcat(buf, "/", CFMaxPathSize);
strlcat(buf, thePath, CFMaxPathSize);
if (0 == stat(buf, &statbuf)) {
CFAllocatorDeallocate(alloc, (void *)thePath);
thePath = buf;
}
}
if (thePath != buf) {
strlcpy(buf, thePath, CFMaxPathSize);
CFAllocatorDeallocate(alloc, (void *)thePath);
thePath = buf;
}
}
}
}
// After attempting a search through $PATH, if existant,
// try prepending the current directory to argv[0].
if (!thePath && _CFGetCurrentDirectory(buf, CFMaxPathSize)) {
if (buf[strlen(buf)-1] != '/') {
strlcat(buf, "/", CFMaxPathSize);
}
strlcat(buf, arg0, CFMaxPathSize);
if (0 == stat(buf, &statbuf)) {
thePath = buf;
}
}
if (thePath) {
// We are going to process the buffer replacing all "/./" with "/"
CFIndex srcIndex = 0, dstIndex = 0;
CFIndex len = strlen(thePath);
for (srcIndex=0; srcIndex<len; srcIndex++) {
thePath[dstIndex] = thePath[srcIndex];
dstIndex++;
if ((srcIndex < len-2) && (thePath[srcIndex] == '/') && (thePath[srcIndex+1] == '.') && (thePath[srcIndex+2] == '/')) {
// We are at the first slash of a "/./" Skip the "./"
srcIndex+=2;
}
}
thePath[dstIndex] = 0;
}
#endif
if (!thePath) {
thePath = (*_NSGetArgv())[execIndex];
}
if (thePath) {
int len = strlen(thePath);
__CFProcessPath = CFAllocatorAllocate(alloc, len + 1, 0);
if (__CFOASafe) __CFSetLastAllocationEventName((void *)__CFProcessPath, "CFUtilities (process-path)");
memmove((char *)__CFProcessPath, thePath, len + 1);
}
if (__CFProcessPath) {
const char *p = 0;
int i;
for (i = 0; __CFProcessPath[i] != 0; i++){
if (__CFProcessPath[i] == '/')
p = __CFProcessPath + i;
}
if (p != 0)
__CFprogname = p + 1;
else
__CFprogname = __CFProcessPath;
}
}
#endif
if (!__CFProcessPath) {
__CFProcessPath = "";
}
return __CFProcessPath;
}
Boolean __CFStringDecodeByteStream3(const uint8_t *bytes, CFIndex len, CFStringEncoding encoding, Boolean alwaysUnicode, CFVarWidthCharBuffer *buffer, Boolean *useClientsMemoryPtr, UInt32 converterFlags) {
CFIndex idx;
const uint8_t *chars = (const uint8_t *)bytes;
const uint8_t *end = chars + len;
Boolean result = TRUE;
if (useClientsMemoryPtr) *useClientsMemoryPtr = false;
buffer->isASCII = !alwaysUnicode;
buffer->shouldFreeChars = false;
buffer->numChars = 0;
if (0 == len) return true;
buffer->allocator = (buffer->allocator ? buffer->allocator : __CFGetDefaultAllocator());
if ((encoding == kCFStringEncodingUTF16) || (encoding == kCFStringEncodingUTF16BE) || (encoding == kCFStringEncodingUTF16LE)) { // UTF-16
const UTF16Char *src = (const UTF16Char *)bytes;
const UTF16Char *limit = src + (len / sizeof(UTF16Char)); // <rdar://problem/7854378> avoiding odd len issue
bool swap = false;
if (kCFStringEncodingUTF16 == encoding) {
UTF16Char bom = ((*src == 0xFFFE) || (*src == 0xFEFF) ? *(src++) : 0);
#if __CF_BIG_ENDIAN__
if (bom == 0xFFFE) swap = true;
#else
if (bom != 0xFEFF) swap = true;
#endif
if (bom) useClientsMemoryPtr = NULL;
} else {
#if __CF_BIG_ENDIAN__
if (kCFStringEncodingUTF16LE == encoding) swap = true;
#else
if (kCFStringEncodingUTF16BE == encoding) swap = true;
#endif
}
buffer->numChars = limit - src;
if (useClientsMemoryPtr && !swap) { // If the caller is ready to deal with no-copy situation, and the situation is possible, indicate it...
*useClientsMemoryPtr = true;
buffer->chars.unicode = (UniChar *)src;
buffer->isASCII = false;
} else {
if (buffer->isASCII) { // Let's see if we can reduce the Unicode down to ASCII...
const UTF16Char *characters = src;
UTF16Char mask = (swap ? 0x80FF : 0xFF80);
while (characters < limit) {
if (*(characters++) & mask) {
buffer->isASCII = false;
break;
}
}
}
if (buffer->isASCII) {
uint8_t *dst;
if (NULL == buffer->chars.ascii) { // we never reallocate when buffer is supplied
if (buffer->numChars > MAX_LOCAL_CHARS) {
buffer->chars.ascii = (UInt8 *)CFAllocatorAllocate(buffer->allocator, (buffer->numChars * sizeof(uint8_t)), 0);
if (!buffer->chars.ascii) goto memoryErrorExit;
buffer->shouldFreeChars = true;
} else {
buffer->chars.ascii = (uint8_t *)buffer->localBuffer;
}
}
dst = buffer->chars.ascii;
if (swap) {
while (src < limit) *(dst++) = (*(src++) >> 8);
} else {
while (src < limit) *(dst++) = (uint8_t)*(src++);
}
} else {
void *CFAllocatorReallocate(CFAllocatorRef allocator, void *ptr, CFIndex newsize, CFOptionFlags hint) {
CFAllocatorAllocateCallBack allocateFunc;
CFAllocatorReallocateCallBack reallocateFunc;
CFAllocatorDeallocateCallBack deallocateFunc;
void *newptr;
if (kCFAllocatorSystemDefaultGCRefZero == allocator) {
allocator = kCFAllocatorSystemDefault;
} else if (kCFAllocatorDefaultGCRefZero == allocator) {
// Under GC, we can't use just any old allocator when the GCRefZero allocator was requested
allocator = kCFUseCollectableAllocator ? kCFAllocatorSystemDefault : __CFGetDefaultAllocator();
} else if (NULL == allocator) {
allocator = __CFGetDefaultAllocator();
}
#if defined(DEBUG) && (DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI)
if (allocator->_base._cfisa == __CFISAForTypeID(__kCFAllocatorTypeID)) {
__CFGenericValidateType(allocator, __kCFAllocatorTypeID);
}
#else
__CFGenericValidateType(allocator, __kCFAllocatorTypeID);
#endif
if (NULL == ptr && 0 < newsize) {
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
if (allocator->_base._cfisa != __CFISAForTypeID(__kCFAllocatorTypeID)) { // malloc_zone_t *
return malloc_zone_malloc((malloc_zone_t *)allocator, newsize);
}
#endif
newptr = NULL;
allocateFunc = __CFAllocatorGetAllocateFunction(&allocator->_context);
if (allocateFunc) {
newptr = (void *)INVOKE_CALLBACK3(allocateFunc, newsize, hint, allocator->_context.info);
}
return newptr;
}
if (NULL != ptr && 0 == newsize) {
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
if (allocator->_base._cfisa != __CFISAForTypeID(__kCFAllocatorTypeID)) { // malloc_zone_t *
#if defined(DEBUG)
size_t size = malloc_size(ptr);
if (size) memset(ptr, 0xCC, size);
#endif
malloc_zone_free((malloc_zone_t *)allocator, ptr);
return NULL;
}
#endif
deallocateFunc = __CFAllocatorGetDeallocateFunction(&allocator->_context);
if (NULL != deallocateFunc) {
INVOKE_CALLBACK2(deallocateFunc, ptr, allocator->_context.info);
}
return NULL;
}
if (NULL == ptr && 0 == newsize) return NULL;
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
if (allocator->_base._cfisa != __CFISAForTypeID(__kCFAllocatorTypeID)) { // malloc_zone_t *
return malloc_zone_realloc((malloc_zone_t *)allocator, ptr, newsize);
}
#endif
reallocateFunc = __CFAllocatorGetReallocateFunction(&allocator->_context);
if (NULL == reallocateFunc) return NULL;
newptr = (void *)INVOKE_CALLBACK4(reallocateFunc, ptr, newsize, hint, allocator->_context.info);
return newptr;
}
static CFAllocatorRef __CFAllocatorCreate(CFAllocatorRef allocator, CFAllocatorContext *context) {
struct __CFAllocator *memory = NULL;
CFAllocatorRetainCallBack retainFunc;
CFAllocatorAllocateCallBack allocateFunc;
void *retainedInfo;
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
if (allocator && kCFAllocatorUseContext != allocator && allocator->_base._cfisa != __CFISAForTypeID(__kCFAllocatorTypeID)) { // malloc_zone_t *
return NULL; // require allocator to this function to be an allocator
}
#endif
retainFunc = context->retain;
FAULT_CALLBACK((void **)&retainFunc);
allocateFunc = context->allocate;
FAULT_CALLBACK((void **)&allocateFunc);
if (NULL != retainFunc) {
retainedInfo = (void *)INVOKE_CALLBACK1(retainFunc, context->info);
} else {
retainedInfo = context->info;
}
// We don't use _CFRuntimeCreateInstance()
if (kCFAllocatorUseContext == allocator) {
memory = NULL;
if (allocateFunc) {
memory = (struct __CFAllocator *)INVOKE_CALLBACK3(allocateFunc, sizeof(struct __CFAllocator), 0, retainedInfo);
}
if (NULL == memory) {
return NULL;
}
} else {
allocator = (NULL == allocator) ? __CFGetDefaultAllocator() : allocator;
memory = (struct __CFAllocator *)CFAllocatorAllocate(allocator, sizeof(struct __CFAllocator), __kCFAllocatorGCObjectMemory);
if (NULL == memory) {
return NULL;
}
if (__CFOASafe) __CFSetLastAllocationEventName(memory, "CFAllocator");
}
memset(memory, 0, sizeof(CFRuntimeBase));
memory->_base._cfisa = 0;
#if __LP64__
memory->_base._rc = 1;
#else
memory->_base._cfinfo[CF_RC_BITS] = 1;
#endif
memory->_base._cfinfo[CF_INFO_BITS] = 0;
_CFRuntimeSetInstanceTypeID(memory, __kCFAllocatorTypeID);
memory->_base._cfisa = __CFISAForTypeID(__kCFAllocatorTypeID);
#if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_EMBEDDED_MINI
memory->size = __CFAllocatorCustomSize;
memory->malloc = __CFAllocatorCustomMalloc;
memory->calloc = __CFAllocatorCustomCalloc;
memory->valloc = __CFAllocatorCustomValloc;
memory->free = __CFAllocatorCustomFree;
memory->realloc = __CFAllocatorCustomRealloc;
memory->destroy = __CFAllocatorCustomDestroy;
memory->zone_name = "Custom CFAllocator";
memory->batch_malloc = NULL;
memory->batch_free = NULL;
memory->introspect = &__CFAllocatorZoneIntrospect;
memory->version = 6;
memory->memalign = NULL;
memory->free_definite_size = NULL;
#endif
memory->_allocator = allocator;
memory->_context.version = context->version;
memory->_context.info = retainedInfo;
memory->_context.retain = retainFunc;
memory->_context.release = context->release;
FAULT_CALLBACK((void **)&(memory->_context.release));
memory->_context.copyDescription = context->copyDescription;
FAULT_CALLBACK((void **)&(memory->_context.copyDescription));
memory->_context.allocate = allocateFunc;
memory->_context.reallocate = context->reallocate;
FAULT_CALLBACK((void **)&(memory->_context.reallocate));
memory->_context.deallocate = context->deallocate;
FAULT_CALLBACK((void **)&(memory->_context.deallocate));
memory->_context.preferredSize = context->preferredSize;
FAULT_CALLBACK((void **)&(memory->_context.preferredSize));
return memory;
}
CFAllocatorRef CFAllocatorGetDefault(void) {
return __CFGetDefaultAllocator();
}
