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