CFArrayRef CFPreferencesCopyApplicationList(CFStringRef user, CFStringRef host) {
CFArrayRef array;
CFAssert1(user != NULL && host != NULL, __kCFLogAssertion, "%s(): Cannot access preferences for a NULL user or host", __PRETTY_FUNCTION__);
array = _CFPreferencesCreateDomainList(user, host);
return array;
}
const void *CFBinaryHeapGetMinimum(CFBinaryHeapRef heap) {
__CFGenericValidateType(heap, CFBinaryHeapGetTypeID());
CFAssert1(0 < __CFBinaryHeapCount(heap), __kCFLogAssertion, "%s(): binary heap is empty", __PRETTY_FUNCTION__);
return (0 < __CFBinaryHeapCount(heap)) ? heap->_buckets[0]._item : NULL;
}
/* Although named "prolog", for leafs of the tree, this is the only XML generation function called. This is why Comments, Processing Instructions, etc. generate their XML during this function. REW, 2/11/2000 */
static void _CFAppendXMLProlog(CFMutableStringRef str, const CFXMLTreeRef tree) {
switch (CFXMLNodeGetTypeCode(CFXMLTreeGetNode(tree))) {
case kCFXMLNodeTypeDocument:
break;
case kCFXMLNodeTypeElement:
appendElementProlog(str, tree);
break;
case kCFXMLNodeTypeAttribute:
// Should never be encountered
break;
case kCFXMLNodeTypeProcessingInstruction: {
CFXMLProcessingInstructionInfo *data = (CFXMLProcessingInstructionInfo *)CFXMLNodeGetInfoPtr(CFXMLTreeGetNode(tree));
if (data->dataString) {
CFStringAppendFormat(str, NULL, CFSTR("<?%@ %@?>"), CFXMLNodeGetString(CFXMLTreeGetNode(tree)), data->dataString);
} else {
CFStringAppendFormat(str, NULL, CFSTR("<?%@?>"));
}
break;
}
case kCFXMLNodeTypeComment:
CFStringAppendFormat(str, NULL, CFSTR("<!--%@-->"), CFXMLNodeGetString(CFXMLTreeGetNode(tree)));
break;
case kCFXMLNodeTypeText:
CFStringAppend(str, CFXMLNodeGetString(CFXMLTreeGetNode(tree)));
break;
case kCFXMLNodeTypeCDATASection:
CFStringAppendFormat(str, NULL, CFSTR("<![CDATA[%@]]>"), CFXMLNodeGetString(CFXMLTreeGetNode(tree)));
break;
case kCFXMLNodeTypeDocumentFragment:
break;
case kCFXMLNodeTypeEntity: {
CFXMLEntityInfo *data = (CFXMLEntityInfo *)CFXMLNodeGetInfoPtr(CFXMLTreeGetNode(tree));
CFStringAppendCString(str, "<!ENTITY ", kCFStringEncodingASCII);
if (data->entityType == kCFXMLEntityTypeParameter) {
CFStringAppend(str, CFSTR("% "));
}
CFStringAppend(str, CFXMLNodeGetString(CFXMLTreeGetNode(tree)));
CFStringAppend(str, CFSTR(" "));
if (data->replacementText) {
appendQuotedString(str, data->replacementText);
CFStringAppendCString(str, ">", kCFStringEncodingASCII);
} else {
appendExternalID(str, &(data->entityID));
if (data->notationName) {
CFStringAppendFormat(str, NULL, CFSTR(" NDATA %@"), data->notationName);
}
CFStringAppendCString(str, ">", kCFStringEncodingASCII);
}
break;
}
case kCFXMLNodeTypeEntityReference:
{
CFXMLEntityTypeCode entityType = ((CFXMLEntityReferenceInfo *)CFXMLNodeGetInfoPtr(CFXMLTreeGetNode(tree)))->entityType;
if (entityType == kCFXMLEntityTypeParameter) {
CFStringAppendFormat(str, NULL, CFSTR("%%%@;"), CFXMLNodeGetString(CFXMLTreeGetNode(tree)));
} else {
CFStringAppendFormat(str, NULL, CFSTR("&%@;"), CFXMLNodeGetString(CFXMLTreeGetNode(tree)));
}
break;
}
case kCFXMLNodeTypeDocumentType:
CFStringAppendCString(str, "<!DOCTYPE ", kCFStringEncodingASCII);
CFStringAppend(str, CFXMLNodeGetString(CFXMLTreeGetNode(tree)));
if (CFXMLNodeGetInfoPtr(CFXMLTreeGetNode(tree))) {
CFXMLExternalID *extID = &((CFXMLDocumentTypeInfo *)CFXMLNodeGetInfoPtr(CFXMLTreeGetNode(tree)))->externalID;
appendExternalID(str, extID);
}
CFStringAppendCString(str, " [", kCFStringEncodingASCII);
break;
case kCFXMLNodeTypeWhitespace:
CFStringAppend(str, CFXMLNodeGetString(CFXMLTreeGetNode(tree)));
break;
case kCFXMLNodeTypeNotation: {
CFXMLNotationInfo *data = (CFXMLNotationInfo *)CFXMLNodeGetInfoPtr(CFXMLTreeGetNode(tree));
CFStringAppendFormat(str, NULL, CFSTR("<!NOTATION %@ "), CFXMLNodeGetString(CFXMLTreeGetNode(tree)));
appendExternalID(str, &(data->externalID));
CFStringAppendCString(str, ">", kCFStringEncodingASCII);
break;
}
case kCFXMLNodeTypeElementTypeDeclaration:
CFStringAppendFormat(str, NULL, CFSTR("<!ELEMENT %@ %@>"), CFXMLNodeGetString(CFXMLTreeGetNode(tree)), ((CFXMLElementTypeDeclarationInfo *)CFXMLNodeGetInfoPtr(CFXMLTreeGetNode(tree)))->contentDescription);
break;
case kCFXMLNodeTypeAttributeListDeclaration: {
CFXMLAttributeListDeclarationInfo *attListData = (CFXMLAttributeListDeclarationInfo *)CFXMLNodeGetInfoPtr(CFXMLTreeGetNode(tree));
CFIndex idx;
CFStringAppendCString(str, "<!ATTLIST ", kCFStringEncodingASCII);
CFStringAppend(str, CFXMLNodeGetString(CFXMLTreeGetNode(tree)));
for (idx = 0; idx < attListData->numberOfAttributes; idx ++) {
CFXMLAttributeDeclarationInfo *attr = &(attListData->attributes[idx]);
CFStringAppendFormat(str, NULL, CFSTR("\n\t%@ %@ %@"), attr->attributeName, attr->typeString, attr->defaultString);
}
CFStringAppendCString(str, ">", kCFStringEncodingASCII);
break;
}
default:
CFAssert1(false, __kCFLogAssertion, "Encountered unexpected XMLDataTypeID %d", CFXMLNodeGetTypeCode(CFXMLTreeGetNode(tree)));
}
}
void CFDataAppendBytes(CFMutableDataRef data, const uint8_t *bytes, CFIndex length) {
CF_OBJC_FUNCDISPATCH2(__kCFDataTypeID, void, data, "appendBytes:length:", bytes, length);
CFAssert1(__CFDataIsMutable(data), __kCFLogAssertion, "%s(): data is immutable", __PRETTY_FUNCTION__);
CFDataReplaceBytes(data, CFRangeMake(__CFDataLength(data), 0), bytes, length);
}
void CFDataDeleteBytes(CFMutableDataRef data, CFRange range) {
CF_OBJC_FUNCDISPATCH3(__kCFDataTypeID, void, data, "replaceBytesInRange:withBytes:length:", range, NULL, 0);
CFAssert1(__CFDataIsMutable(data), __kCFLogAssertion, "%s(): data is immutable", __PRETTY_FUNCTION__);
CFDataReplaceBytes(data, range, NULL, 0);
}
uint8_t *CFDataGetMutableBytePtr(CFMutableDataRef data) {
CF_OBJC_FUNCDISPATCH0(__kCFDataTypeID, uint8_t *, data, "mutableBytes");
CFAssert1(__CFDataIsMutable(data), __kCFLogAssertion, "%s(): data is immutable", __PRETTY_FUNCTION__);
// compaction: if inline, always do the computation.
return __CFDataBytesInline(data) ? (uint8_t *)__CFDataInlineBytesPtr(data) : data->_bytes;
}
void CFDataIncreaseLength(CFMutableDataRef data, CFIndex extraLength) {
CF_OBJC_FUNCDISPATCH1(__kCFDataTypeID, void, data, "increaseLengthBy:", extraLength);
CFAssert1(__CFDataIsMutable(data), __kCFLogAssertion, "%s(): data is immutable", __PRETTY_FUNCTION__);
if (extraLength < 0) HALT; // Avoid integer overflow.
CFDataSetLength(data, __CFDataLength(data) + extraLength);
}
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);
}
void CFDataDeleteBytes(CFMutableDataRef data, CFRange range) {
CF_OBJC_FUNCDISPATCHV(__kCFDataTypeID, void, (NSMutableData *)data, replaceBytesInRange:NSMakeRange(range.location, range.length) withBytes:NULL length:0);
CFAssert1(__CFDataIsMutable(data), __kCFLogAssertion, "%s(): data is immutable", __PRETTY_FUNCTION__);
CFDataReplaceBytes(data, range, NULL, 0);
}
static void __CFXMLNodeDeallocate(CFTypeRef cf) {
struct __CFXMLNode *node = (struct __CFXMLNode *)cf;
if (node->dataString) CFRelease(node->dataString);
if (node->additionalData) {
switch (node->dataTypeID) {
case kCFXMLNodeTypeDocument:
if (((CFXMLDocumentInfo *)node->additionalData)->sourceURL) {
CFRelease(((CFXMLDocumentInfo *)node->additionalData)->sourceURL);
}
break;
case kCFXMLNodeTypeElement:
if (((CFXMLElementInfo *)node->additionalData)->attributes) {
CFRelease(((CFXMLElementInfo *)node->additionalData)->attributes);
CFRelease(((CFXMLElementInfo *)node->additionalData)->attributeOrder);
}
break;
case kCFXMLNodeTypeProcessingInstruction:
if (((CFXMLProcessingInstructionInfo *)node->additionalData)->dataString) {
CFRelease(((CFXMLProcessingInstructionInfo *)node->additionalData)->dataString);
}
break;
case kCFXMLNodeTypeEntity:
{
CFXMLEntityInfo *data = (CFXMLEntityInfo *)node->additionalData;
if (data->replacementText) CFRelease(data->replacementText);
if (data->entityID.systemID) CFRelease(data->entityID.systemID);
if (data->entityID.publicID) CFRelease(data->entityID.publicID);
if (data->notationName) CFRelease(data->notationName);
break;
}
case kCFXMLNodeTypeEntityReference:
{
// Do nothing; additionalData has no structure of its own, with dependent pieces to release. -- REW, 2/11/2000
break;
}
case kCFXMLNodeTypeDocumentType:
case kCFXMLNodeTypeNotation:
// We get away with this because CFXMLNotationInfo and CFXMLDocumentTypeInfo have identical formats
{
CFXMLNotationInfo *data = (CFXMLNotationInfo *)node->additionalData;
if (data->externalID.systemID) CFRelease(data->externalID.systemID);
if (data->externalID.publicID) CFRelease(data->externalID.publicID);
break;
}
case kCFXMLNodeTypeElementTypeDeclaration:
if (((CFXMLElementTypeDeclarationInfo *)node->additionalData)->contentDescription) {
CFRelease(((CFXMLElementTypeDeclarationInfo *)node->additionalData)->contentDescription);
}
break;
case kCFXMLNodeTypeAttributeListDeclaration:
{
CFXMLAttributeListDeclarationInfo *data = (CFXMLAttributeListDeclarationInfo *)node->additionalData;
CFIndex idx;
for (idx = 0; idx < data->numberOfAttributes; idx ++) {
CFRelease(data->attributes[idx].attributeName);
CFRelease(data->attributes[idx].typeString);
CFRelease(data->attributes[idx].defaultString);
}
CFAllocatorDeallocate(CFGetAllocator(node), data->attributes);
break;
}
default:
CFAssert1(false, __kCFLogAssertion, "%s(): Encountered unexpected typeID %d (additionalData should be empty)", node->dataTypeID);
}
}
}
CFIndex CFPreferencesGetAppIntegerValue(CFStringRef key, CFStringRef appName, Boolean *keyExistsAndHasValidFormat) {
CFAssert1(appName != NULL, __kCFLogAssertion, "%s(): Cannot access application preferences with a NULL application name", __PRETTY_FUNCTION__);
CFAssert1(key != NULL, __kCFLogAssertion, "%s(): Cannot access preferences with a NULL key", __PRETTY_FUNCTION__);
return CFPreferencesAppIntegerValue(key, appName, keyExistsAndHasValidFormat);
}
// This function does no ObjC dispatch or argument checking;
// It should only be called from places where that dispatch and check has already been done, or NSCFArray
void _CFArrayReplaceValues(CFMutableArrayRef array, CFRange range, const void **newValues, CFIndex newCount) {
CHECK_FOR_MUTATION(array);
BEGIN_MUTATION(array);
const CFArrayCallBacks *cb;
CFIndex idx, cnt, futureCnt;
const void **newv, *buffer[256];
cnt = __CFArrayGetCount(array);
futureCnt = cnt - range.length + newCount;
CFAssert1(newCount <= futureCnt, __kCFLogAssertion, "%s(): internal error 1", __PRETTY_FUNCTION__);
cb = __CFArrayGetCallBacks(array);
CFAllocatorRef allocator = __CFGetAllocator(array);
/* Retain new values if needed, possibly allocating a temporary buffer for them */
if (NULL != cb->retain && !hasBeenFinalized(array)) {
newv = (newCount <= 256) ? (const void **)buffer : (const void **)CFAllocatorAllocate(kCFAllocatorSystemDefault, newCount * sizeof(void *), 0); // GC OK
if (newv != buffer && __CFOASafe) __CFSetLastAllocationEventName(newv, "CFArray (temp)");
for (idx = 0; idx < newCount; idx++) {
newv[idx] = (void *)INVOKE_CALLBACK2(cb->retain, allocator, (void *)newValues[idx]);
}
} else {
newv = newValues;
}
array->_mutations++;
/* Now, there are three regions of interest, each of which may be empty:
* A: the region from index 0 to one less than the range.location
* B: the region of the range
* C: the region from range.location + range.length to the end
* Note that index 0 is not necessarily at the lowest-address edge
* of the available storage. The values in region B need to get
* released, and the values in regions A and C (depending) need
* to get shifted if the number of new values is different from
* the length of the range being replaced.
*/
if (0 < range.length) {
__CFArrayReleaseValues(array, range, false);
}
// region B elements are now "dead"
if (0) {
} else if (NULL == array->_store) {
if (0) {
} else if (0 <= futureCnt) {
struct __CFArrayDeque *deque;
CFIndex capacity = __CFArrayDequeRoundUpCapacity(futureCnt);
CFIndex size = sizeof(struct __CFArrayDeque) + capacity * sizeof(struct __CFArrayBucket);
deque = (struct __CFArrayDeque *)CFAllocatorAllocate(_CFConvertAllocatorToGCRefZeroEquivalent(allocator), size, isStrongMemory(array) ? __kCFAllocatorGCScannedMemory : 0);
if (__CFOASafe) __CFSetLastAllocationEventName(deque, "CFArray (store-deque)");
deque->_leftIdx = (capacity - newCount) / 2;
deque->_capacity = capacity;
__CFAssignWithWriteBarrier((void **)&array->_store, (void *)deque);
}
} else { // Deque
// reposition regions A and C for new region B elements in gap
if (0) {
} else if (range.length != newCount) {
__CFArrayRepositionDequeRegions(array, range, newCount);
}
}
// copy in new region B elements
if (0 < newCount) {
if (0) {
} else { // Deque
struct __CFArrayDeque *deque = (struct __CFArrayDeque *)array->_store;
struct __CFArrayBucket *raw_buckets = (struct __CFArrayBucket *)((uint8_t *)deque + sizeof(struct __CFArrayDeque));
objc_memmove_collectable(raw_buckets + deque->_leftIdx + range.location, newv, newCount * sizeof(struct __CFArrayBucket));
}
}
__CFArraySetCount(array, futureCnt);
if (newv != buffer && newv != newValues) CFAllocatorDeallocate(kCFAllocatorSystemDefault, newv);
END_MUTATION(array);
}