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(); }