/* Allocates new block of data with at least numNewValues more bytes than the current length. If clear is true, the new bytes up to at least the new length with be zeroed. */
static void __CFDataGrow(CFMutableDataRef data, CFIndex numNewValues, Boolean clear) {
CFIndex oldLength = __CFDataLength(data);
CFIndex newLength = oldLength + numNewValues;
if (newLength > CFDATA_MAX_SIZE || newLength < 0) __CFDataHandleOutOfMemory(data, newLength * sizeof(uint8_t));
CFIndex capacity = __CFDataRoundUpCapacity(newLength);
CFIndex numBytes = __CFDataNumBytesForCapacity(capacity);
CFAllocatorRef allocator = CFGetAllocator(data);
void *bytes = NULL;
void *oldBytes = data->_bytes;
Boolean allocateCleared = clear && __CFDataShouldAllocateCleared(data, numBytes);
if (allocateCleared && !__CFDataUseAllocator(data) && (oldLength == 0 || (newLength / oldLength) > 4)) {
// If the length that needs to be zeroed is significantly greater than the length of the data, then calloc/memmove is probably more efficient than realloc/memset.
bytes = __CFDataAllocate(data, numBytes * sizeof(uint8_t), true);
if (NULL != bytes) {
memmove(bytes, oldBytes, oldLength);
__CFDataDeallocate(data);
}
}
if (bytes == NULL) {
// If the calloc/memmove approach either failed or was never attempted, then realloc.
allocateCleared = false;
if (__CFDataUseAllocator(data)) {
bytes = CFAllocatorReallocate(allocator, oldBytes, numBytes * sizeof(uint8_t), 0);
} else {
bytes = realloc(oldBytes, numBytes * sizeof(uint8_t));
}
}
if (NULL == bytes) __CFDataHandleOutOfMemory(data, numBytes * sizeof(uint8_t));
__CFDataSetCapacity(data, capacity);
__CFDataSetNumBytes(data, numBytes);
if (clear && !allocateCleared && oldLength < newLength) memset((uint8_t *)bytes + oldLength, 0, newLength - oldLength);
__CFDataSetNeedsToZero(data, !allocateCleared);
__CFAssignWithWriteBarrier((void **)&data->_bytes, bytes);
if (__CFOASafe) __CFSetLastAllocationEventName(data->_bytes, "CFData (store)");
}
static void
CFDataCheckCapacityAndGrow (CFMutableDataRef data, CFIndex capacity)
{
struct __CFMutableData *d = (struct __CFMutableData*)data;
if (capacity > d->_capacity)
{
d->_contents = CFAllocatorReallocate (d->_allocator, d->_contents,
capacity, 0);
d->_capacity = capacity;
}
}
__private_extern__ void *_CFAllocatorReallocateGC(CFAllocatorRef allocator, void *ptr, CFIndex newsize, CFOptionFlags hint)
{
if (CF_IS_COLLECTABLE_ALLOCATOR(allocator)) {
if (ptr && (newsize == 0)) {
return NULL; // equivalent to _CFAllocatorDeallocateGC.
}
if (ptr == NULL) {
return auto_zone_allocate_object((auto_zone_t*)kCFAllocatorSystemDefault->_context.info, newsize, CF_GET_GC_MEMORY_TYPE(hint), false, false); // eq. to _CFAllocator
}
}
// otherwise, auto_realloc() now preserves layout type and refCount.
return CFAllocatorReallocate(allocator, ptr, newsize, hint);
}
inline CFIndex __JSONElementsAppend(__JSONRef json, CFTypeRef value) {
CFIndex index = json->elementsIndex;
if (json->elementsIndex == json->elementsSize) { // Reallocate
CFIndex largerSize = json->elementsSize ? json->elementsSize << 1 : CORE_JSON_ELEMENTS_INITIAL_SIZE;
CFTypeRef *largerElements = CFAllocatorReallocate(json->allocator, json->elements, sizeof(CFTypeRef) * largerSize, 0);
if (largerElements) {
json->elementsSize = largerSize;
json->elements = largerElements;
}
}
if (json->elementsIndex < json->elementsSize)
json->elements[json->elementsIndex++] = CFRetain(value);
return index;
}
inline bool __JSONStackEntryAppendKey(__JSONStackEntryRef entry, CFIndex key) {
bool success = 0;
if (entry) {
if (entry->keysIndex == entry->keysSize) { // Reallocate more space
CFIndex largerSize = entry->keysSize ? entry->keysSize << 1 : CORE_JSON_STACK_ENTRY_KEYS_INITIAL_SIZE;
CFIndex *largerKeys = CFAllocatorReallocate(entry->allocator, entry->keys, sizeof(CFIndex) * largerSize, 0);
if (largerKeys) {
entry->keysSize = largerSize;
entry->keys = largerKeys;
}
}
if (entry->keysIndex < entry->keysSize) {
entry->keys[entry->keysIndex++] = key;
success = 1;
}
}
return success;
}
inline bool __JSONStackEntryAppendValue(__JSONStackEntryRef entry, CFIndex value) {
bool success = 0;
if (entry) {
if (entry->valuesIndex == entry->valuesSize) { // Reallocate more space
CFIndex largerSize = entry->valuesSize ? entry->valuesSize << 1 : CORE_JSON_STACK_ENTRY_VALUES_INITIAL_SIZE;
CFIndex *largerValues = CFAllocatorReallocate(entry->allocator, entry->values, sizeof(CFIndex) * largerSize, 0);
if (largerValues) {
entry->valuesSize = largerSize;
entry->values = largerValues;
}
}
if (entry->valuesIndex < entry->valuesSize) {
entry->values[entry->valuesIndex++] = value;
success = 1;
}
}
return success;
}
inline bool __JSONStackPush(__JSONStackRef stack, __JSONStackEntryRef entry) {
bool success = 0;
if (stack && entry) {
// Do we need more space? Reallocate to 2 * current size.
if (stack->index == stack->size) {
CFIndex largerSize = stack->size ? stack->size << 1 : CORE_JSON_STACK_INITIAL_SIZE;
__JSONStackEntryRef *largerStack = CFAllocatorReallocate(stack->allocator, stack->stack, sizeof(__JSONStackEntryRef) * largerSize, 0);
if (largerStack) {
stack->size = largerSize;
stack->stack = largerStack;
}
}
if (stack->index < stack->size) {
stack->stack[stack->index++] = __JSONStackEntryRetain(entry);
success = 1;
}
}
return success;
}
static void getVolatileKeysAndValues(CFAllocatorRef alloc, CFTypeRef context, void *domain, void **buf[], CFIndex *numKeyValuePairs) {
CFMutableDictionaryRef dict = (CFMutableDictionaryRef)domain;
CFIndex count = CFDictionaryGetCount(dict);
if (buf) {
void **values;
if ( count < *numKeyValuePairs ) {
values = *buf + count;
CFDictionaryGetKeysAndValues(dict, (const void **)*buf, (const void **)values);
} else if (alloc != kCFAllocatorNull) {
if (*buf) {
*buf = (void **)CFAllocatorReallocate(alloc, *buf, count * 2 * sizeof(void *), 0);
} else {
*buf = (void **)CFAllocatorAllocate(alloc, count*2*sizeof(void *), 0);
}
if (*buf) {
values = *buf + count;
CFDictionaryGetKeysAndValues(dict, (const void **)*buf, (const void **)values);
}
}
}
*numKeyValuePairs = count;
}
static void growCharacterBuffer(_CFXMLInputStream *stream) {
if (!stream->charBuffer) {
stream->charBuffer = (UniChar *)CFAllocatorAllocate(stream->allocator, INITIAL_BUFFER_SIZE*sizeof(UniChar), 0);
stream->bufferCapacity = INITIAL_BUFFER_SIZE;
} else {
CFIndex currCharDelta = stream->currentChar ? stream->currentChar - stream->charBuffer : -1;
CFIndex markDelta = stream->mark ? stream->mark - stream->charBuffer: -1;
CFIndex parserMarkDelta = stream->parserMark ? stream->parserMark - stream->charBuffer: -1;
UniChar *newBuffer = (UniChar *)CFAllocatorReallocate(stream->allocator, stream->charBuffer, stream->bufferCapacity * 2 * sizeof(UniChar), 0);
stream->bufferCapacity *= 2;
if (newBuffer != stream->charBuffer) {
stream->charBuffer = newBuffer;
if (currCharDelta != -1) {
stream->currentChar = newBuffer + currCharDelta;
}
if (markDelta != -1) {
stream->mark = newBuffer + markDelta;
}
if (parserMarkDelta != -1) {
stream->parserMark = newBuffer + parserMarkDelta;
}
}
}
}
static void getXMLKeysAndValues(CFAllocatorRef alloc, CFTypeRef context, void *xmlDomain, void **buf[], CFIndex *numKeyValuePairs) {
_CFXMLPreferencesDomain *domain = (_CFXMLPreferencesDomain *)xmlDomain;
CFIndex count;
__CFLock(&domain->_lock);
if (!domain->_domainDict) {
_loadXMLDomainIfStale((CFURLRef )context, domain);
}
count = CFDictionaryGetCount(domain->_domainDict);
if (buf) {
void **values;
if (count <= *numKeyValuePairs) {
values = *buf + count;
CFDictionaryGetKeysAndValues(domain->_domainDict, (const void **)*buf, (const void **)values);
} else if (alloc != kCFAllocatorNull) {
*buf = (void**) CFAllocatorReallocate(alloc, (*buf ? *buf : NULL), count * 2 * sizeof(void *), 0);
if (*buf) {
values = *buf + count;
CFDictionaryGetKeysAndValues(domain->_domainDict, (const void **)*buf, (const void **)values);
}
}
}
*numKeyValuePairs = count;
__CFUnlock(&domain->_lock);
}
static void *__CFAllocatorCustomRealloc(malloc_zone_t *zone, void *ptr, size_t size) {
CFAllocatorRef allocator = (CFAllocatorRef)zone;
return CFAllocatorReallocate(allocator, ptr, size, 0);
}
inline void *__JSONAllocatorReallocate(void *ctx, void *ptr, size_t sz) {
return CFAllocatorReallocate(ctx, ptr, sz, 0);
}