static void __CFDataDeallocate(CFTypeRef cf) { CFMutableDataRef data = (CFMutableDataRef)cf; if (!__CFDataBytesInline(data)) { CFAllocatorRef deallocator = data->_bytesDeallocator; if (deallocator != NULL) { _CFAllocatorDeallocateGC(deallocator, data->_bytes); if (!_CFAllocatorIsGCRefZero(deallocator)) CFRelease(deallocator); data->_bytes = NULL; } else { if (__CFDataUseAllocator(data)) { _CFAllocatorDeallocateGC(__CFGetAllocator(data), data->_bytes); } else if (!__CFDataAllocatesCollectable(data) && data->_bytes) { free(data->_bytes); } data->_bytes = NULL; } } }
static void __CFBinaryHeapDeallocate(CFTypeRef cf) { CFBinaryHeapRef heap = (CFBinaryHeapRef)cf; CFAllocatorRef allocator = CFGetAllocator(heap); if (CF_IS_COLLECTABLE_ALLOCATOR(allocator)) { if (heap->_callbacks.retain == NULL && heap->_callbacks.release == NULL) return; // GC: keep heap intact during finalization. } // CF: should make the heap mutable here first, a la CFArrayDeallocate CFBinaryHeapRemoveAllValues(heap); // CF: does not release the context info if (__CFBinaryHeapMutableVariety(heap) == kCFBinaryHeapMutable) { _CFAllocatorDeallocateGC(allocator, heap->_buckets); } }
static void __CFTreeDeallocate(CFTypeRef cf) { CFTreeRef tree = (CFTreeRef)cf; const struct __CFTreeCallBacks *cb; CFAllocatorRef allocator = __CFGetAllocator(tree); if (!CF_IS_COLLECTABLE_ALLOCATOR(allocator)) { // GC: keep the tree intact during finalization. CFTreeRemoveAllChildren(tree); } cb = __CFTreeGetCallBacks(tree); if (NULL != cb->release) { INVOKE_CALLBACK1(cb->release, tree->_info); } if (__kCFTreeHasCustomCallBacks == __CFTreeGetCallBacksType(tree)) { _CFAllocatorDeallocateGC(CFGetAllocator(tree), tree->_callbacks); } }
__private_extern__ void __CFAllocatorDeallocate(CFTypeRef cf) { CFAllocatorRef self = (CFAllocatorRef)cf; CFAllocatorRef allocator = self->_allocator; CFAllocatorReleaseCallBack releaseFunc = __CFAllocatorGetReleaseFunction(&self->_context); if (kCFAllocatorUseContext == allocator) { /* Rather a chicken and egg problem here, so we do things in the reverse order from what was done at create time. */ CFAllocatorDeallocateCallBack deallocateFunc = __CFAllocatorGetDeallocateFunction(&self->_context); void *info = self->_context.info; if (NULL != deallocateFunc) { INVOKE_CALLBACK2(deallocateFunc, (void *)self, info); } if (NULL != releaseFunc) { INVOKE_CALLBACK1(releaseFunc, info); } } else { if (NULL != releaseFunc) { INVOKE_CALLBACK1(releaseFunc, self->_context.info); } _CFAllocatorDeallocateGC(allocator, (void *)self); } }
// quick message to indicate that the given domain has changed, and we should go through and invalidate any dictReps that involve this domain. void _CFApplicationPreferencesDomainHasChanged(CFPreferencesDomainRef changedDomain) { CFAllocatorRef alloc = __CFPreferencesAllocator(); __CFSpinLock(&__CFApplicationPreferencesLock); if(__CFStandardUserPreferences) { // only grovel over the prefs if there's something there to grovel _CFApplicationPreferences **prefsArray, *prefsBuf[32]; CFIndex idx, count = CFDictionaryGetCount(__CFStandardUserPreferences); if(count < 32) { prefsArray = prefsBuf; } else { prefsArray = (_CFApplicationPreferences **)CFAllocatorAllocate(alloc, count * sizeof(_CFApplicationPreferences *), 0); } CFDictionaryGetKeysAndValues(__CFStandardUserPreferences, NULL, (const void **)prefsArray); // For this operation, giving up the lock is the last thing we want to do, so use the modified flavor of _CFApplicationPreferencesContainsDomain for(idx = 0; idx < count; idx++) { _CFApplicationPreferences *appPrefs = prefsArray[idx]; if(_CFApplicationPreferencesContainsDomainNoLock(appPrefs, changedDomain)) { updateDictRep(appPrefs); } } if(prefsArray != prefsBuf) _CFAllocatorDeallocateGC(alloc, prefsArray); } __CFSpinUnlock(&__CFApplicationPreferencesLock); }
void CFTreeSetContext(CFTreeRef tree, const CFTreeContext *context) { uint32_t newtype, oldtype = __CFTreeGetCallBacksType(tree); struct __CFTreeCallBacks *oldcb = (struct __CFTreeCallBacks *)__CFTreeGetCallBacks(tree); struct __CFTreeCallBacks *newcb; void *oldinfo = tree->_info; CFAllocatorRef allocator = CFGetAllocator(tree); if (__CFTreeCallBacksMatchNull(context)) { newtype = __kCFTreeHasNullCallBacks; } else if (__CFTreeCallBacksMatchCFType(context)) { newtype = __kCFTreeHasCFTypeCallBacks; } else { newtype = __kCFTreeHasCustomCallBacks; __CFAssignWithWriteBarrier((void **)&tree->_callbacks, _CFAllocatorAllocateGC(allocator, sizeof(struct __CFTreeCallBacks), 0)); if (__CFOASafe) __CFSetLastAllocationEventName(tree->_callbacks, "CFTree (callbacks)"); tree->_callbacks->retain = context->retain; tree->_callbacks->release = context->release; tree->_callbacks->copyDescription = context->copyDescription; FAULT_CALLBACK((void **)&(tree->_callbacks->retain)); FAULT_CALLBACK((void **)&(tree->_callbacks->release)); FAULT_CALLBACK((void **)&(tree->_callbacks->copyDescription)); } __CFBitfieldSetValue(tree->_base._cfinfo[CF_INFO_BITS], 1, 0, newtype); newcb = (struct __CFTreeCallBacks *)__CFTreeGetCallBacks(tree); if (NULL != newcb->retain) { tree->_info = (void *)INVOKE_CALLBACK1(newcb->retain, context->info); } else { __CFAssignWithWriteBarrier((void **)&tree->_info, context->info); } if (NULL != oldcb->release) { INVOKE_CALLBACK1(oldcb->release, oldinfo); } if (oldtype == __kCFTreeHasCustomCallBacks) { _CFAllocatorDeallocateGC(allocator, oldcb); } }