[apple/cf.git] / Collections.subproj / CFData.c

/*
 * Copyright (c) 2003 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*	CFData.c
	Copyright 1998-2002, Apple, Inc. All rights reserved.
	Responsibility: Christopher Kane
*/

#include <CoreFoundation/CFData.h>
#include "CFUtilities.h"
#include "CFInternal.h"
#include <string.h>

struct __CFData {
    CFRuntimeBase _base;
    CFIndex _length;	/* number of bytes */
    CFIndex _capacity;	/* maximum number of bytes */
    CFAllocatorRef _bytesDeallocator;	/* used only for immutable; if NULL, no deallocation */
    uint8_t *_bytes;
};

/* Bits 3-2 are used for mutability variation */

CF_INLINE UInt32 __CFMutableVariety(const void *cf) {
    return __CFBitfieldGetValue(((const CFRuntimeBase *)cf)->_info, 3, 2);
}

CF_INLINE void __CFSetMutableVariety(void *cf, UInt32 v) {
    __CFBitfieldSetValue(((CFRuntimeBase *)cf)->_info, 3, 2, v);
}

CF_INLINE UInt32 __CFMutableVarietyFromFlags(UInt32 flags) {
    return __CFBitfieldGetValue(flags, 1, 0);
}

#define __CFGenericValidateMutabilityFlags(flags) \
    CFAssert2(__CFMutableVarietyFromFlags(flags) != 0x2, __kCFLogAssertion, "%s(): flags 0x%x do not correctly specify the mutable variety", __PRETTY_FUNCTION__, flags);

CF_INLINE CFIndex __CFDataLength(CFDataRef data) {
    return data->_length;
}

CF_INLINE void __CFDataSetLength(CFMutableDataRef data, CFIndex v) {
    /* for a CFData, _bytesUsed == _length */
}

CF_INLINE CFIndex __CFDataCapacity(CFDataRef data) {
    return data->_capacity;
}

CF_INLINE void __CFDataSetCapacity(CFMutableDataRef data, CFIndex v) {
    /* for a CFData, _bytesNum == _capacity */
}

CF_INLINE CFIndex __CFDataNumBytesUsed(CFDataRef data) {
    return data->_length;
}

CF_INLINE void __CFDataSetNumBytesUsed(CFMutableDataRef data, CFIndex v) {
    data->_length = v;
}

CF_INLINE CFIndex __CFDataNumBytes(CFDataRef data) {
    return data->_capacity;
}

CF_INLINE void __CFDataSetNumBytes(CFMutableDataRef data, CFIndex v) {
    data->_capacity = v;
}

CF_INLINE CFIndex __CFDataRoundUpCapacity(CFIndex capacity) {
    if (capacity < 16) return 16;
// CF: quite probably, this doubling should slow as the data gets larger and larger; should not use strict doubling
    return (1 << (CFLog2(capacity) + 1));
}

CF_INLINE CFIndex __CFDataNumBytesForCapacity(CFIndex capacity) {
    return capacity;
}

#if defined(DEBUG)
CF_INLINE void __CFDataValidateRange(CFDataRef data, CFRange range, const char *func) {
    CFAssert2(0 <= range.location && range.location <= __CFDataLength(data), __kCFLogAssertion, "%s(): range.location index (%d) out of bounds", func, range.location);
    CFAssert2(0 <= range.length, __kCFLogAssertion, "%s(): length (%d) cannot be less than zero", func, range.length);
    CFAssert2(range.location + range.length <= __CFDataLength(data), __kCFLogAssertion, "%s(): ending index (%d) out of bounds", func, range.location + range.length);
}
#else
#define __CFDataValidateRange(a,r,f)
#endif

static bool __CFDataEqual(CFTypeRef cf1, CFTypeRef cf2) {
    CFDataRef data1 = (CFDataRef)cf1;
    CFDataRef data2 = (CFDataRef)cf2;
    CFIndex length;
    length = __CFDataLength(data1);
    if (length != __CFDataLength(data2)) return false;
    return 0 == memcmp(data1->_bytes, data2->_bytes, length);
}

static CFHashCode __CFDataHash(CFTypeRef cf) {
    CFDataRef data = (CFDataRef)cf;
    return CFHashBytes(data->_bytes, __CFMin(__CFDataLength(data), 16));
}

static CFStringRef __CFDataCopyDescription(CFTypeRef cf) {
    CFDataRef data = (CFDataRef)cf;
    CFMutableStringRef result;
    CFIndex idx;
    CFIndex len;
    const uint8_t *bytes;
    len = __CFDataLength(data);
    bytes = data->_bytes;
    result = CFStringCreateMutable(CFGetAllocator(data), 0);
    CFStringAppendFormat(result, NULL, CFSTR("<CFData %p [%p]>{length = %u, capacity = %u, bytes = 0x"), cf, CFGetAllocator(data), len, __CFDataCapacity(data));
    if (24 < len) {
        for (idx = 0; idx < 16; idx += 4) {
	    CFStringAppendFormat(result, NULL, CFSTR("%02x%02x%02x%02x"), bytes[idx], bytes[idx + 1], bytes[idx + 2], bytes[idx + 3]);
	}
        CFStringAppend(result, CFSTR(" ... "));
        for (idx = len - 8; idx < len; idx += 4) {
	    CFStringAppendFormat(result, NULL, CFSTR("%02x%02x%02x%02x"), bytes[idx], bytes[idx + 1], bytes[idx + 2], bytes[idx + 3]);
	}
    } else {
        for (idx = 0; idx < len; idx++) {
	    CFStringAppendFormat(result, NULL, CFSTR("%02x"), bytes[idx]);
	}
    }
    CFStringAppend(result, CFSTR("}"));
    return result;
}

enum {
    kCFImmutable = 0x0,		/* unchangable and fixed capacity; default */
    kCFMutable = 0x1,		/* changeable and variable capacity */
    kCFFixedMutable = 0x3	/* changeable and fixed capacity */
};

static void __CFDataDeallocate(CFTypeRef cf) {
    CFMutableDataRef data = (CFMutableDataRef)cf;
    CFAllocatorRef allocator = CFGetAllocator(data);
    switch (__CFMutableVariety(data)) {
    case kCFMutable:
	CFAllocatorDeallocate(allocator, data->_bytes);
	break;
    case kCFFixedMutable:
	break;
    case kCFImmutable:
	if (NULL != data->_bytesDeallocator) {
	    CFAllocatorDeallocate(data->_bytesDeallocator, data->_bytes);
	    CFRelease(data->_bytesDeallocator);
	}
	break;
    }
}

static CFTypeID __kCFDataTypeID = _kCFRuntimeNotATypeID;

static const CFRuntimeClass __CFDataClass = {
    0,
    "CFData",
    NULL,	// init
    NULL,	// copy
    __CFDataDeallocate,
    (void *)__CFDataEqual,
    __CFDataHash,
    NULL,	// 
    __CFDataCopyDescription
};

__private_extern__ void __CFDataInitialize(void) {
    __kCFDataTypeID = _CFRuntimeRegisterClass(&__CFDataClass);
}

CFTypeID CFDataGetTypeID(void) {
    return __kCFDataTypeID;
}

// 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;
    CFIndex size;
    __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);
    size = sizeof(struct __CFData) - sizeof(CFRuntimeBase);
    if (__CFMutableVarietyFromFlags(flags) != kCFMutable && (bytesDeallocator == NULL)) {
	size += sizeof(uint8_t) * __CFDataNumBytesForCapacity(capacity);
    }
    if (__CFMutableVarietyFromFlags(flags) != kCFMutable) {
	size += 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);
    switch (__CFMutableVarietyFromFlags(flags)) {
    case kCFMutable:
	__CFDataSetCapacity(memory, __CFDataRoundUpCapacity(1));
	__CFDataSetNumBytes(memory, __CFDataNumBytesForCapacity(__CFDataRoundUpCapacity(1)));
	// assume that allocators give 16-byte aligned memory back -- it is their responsibility
	memory->_bytes = CFAllocatorAllocate(allocator, __CFDataNumBytes(memory) * sizeof(uint8_t), 0);
	if (__CFOASafe) __CFSetLastAllocationEventName(memory->_bytes, "CFData (store)");
	if (NULL == memory->_bytes) {
	    CFRelease(memory);
	    return NULL;
	}
	memory->_bytesDeallocator = NULL;
	__CFSetMutableVariety(memory, kCFMutable);
	CFDataReplaceBytes(memory, CFRangeMake(0, 0), bytes, length);
	break;
    case kCFFixedMutable:
	/* Don't round up capacity */
	__CFDataSetCapacity(memory, capacity);
	__CFDataSetNumBytes(memory, __CFDataNumBytesForCapacity(capacity));
	memory->_bytes = (uint8_t *)((uintptr_t)((int8_t *)memory + sizeof(struct __CFData) + 15) & ~0xF);	// 16-byte align
	memory->_bytesDeallocator = NULL;
	__CFSetMutableVariety(memory, kCFFixedMutable);
	CFDataReplaceBytes(memory, CFRangeMake(0, 0), bytes, length);
	break;
    case kCFImmutable:
	/* Don't round up capacity */
	__CFDataSetCapacity(memory, capacity);
	__CFDataSetNumBytes(memory, __CFDataNumBytesForCapacity(capacity));
	if (bytesDeallocator != NULL) {
	    memory->_bytes = (uint8_t *)bytes;
	    memory->_bytesDeallocator = CFRetain(bytesDeallocator);
	    __CFDataSetNumBytesUsed(memory, length);
	    __CFDataSetLength(memory, length);
	} else {
	    memory->_bytes = (uint8_t *)((uintptr_t)((int8_t *)memory + sizeof(struct __CFData) + 15) & ~0xF);	// 16-byte align
	    memory->_bytesDeallocator = NULL;
	    __CFSetMutableVariety(memory, kCFFixedMutable);
	    CFDataReplaceBytes(memory, CFRangeMake(0, 0), bytes, length);
	}
	break;
    }
    __CFSetMutableVariety(memory, __CFMutableVarietyFromFlags(flags));
    return memory;
}

CFDataRef CFDataCreate(CFAllocatorRef allocator, const uint8_t *bytes, CFIndex length) {
    return __CFDataInit(allocator, kCFImmutable, length, bytes, length, NULL);
}

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();
    if (!_CFExecutableLinkedOnOrAfter(CFSystemVersionJaguar)) {
	bytesDeallocator = NULL;
    }
    return __CFDataInit(allocator, kCFImmutable, length, bytes, length, bytesDeallocator);
}

CFDataRef CFDataCreateCopy(CFAllocatorRef allocator, CFDataRef data) {
    CFIndex length = CFDataGetLength(data);
    return __CFDataInit(allocator, kCFImmutable, length, CFDataGetBytePtr(data), length, NULL);
}

CFMutableDataRef CFDataCreateMutable(CFAllocatorRef allocator, CFIndex capacity) {
    return __CFDataInit(allocator, (0 == capacity) ? kCFMutable : kCFFixedMutable, capacity, NULL, 0, NULL);
}

CFMutableDataRef CFDataCreateMutableCopy(CFAllocatorRef allocator, CFIndex capacity, CFDataRef data) {
    return __CFDataInit(allocator, (0 == capacity) ? kCFMutable : kCFFixedMutable, capacity, CFDataGetBytePtr(data), CFDataGetLength(data), NULL);
}

CFIndex CFDataGetLength(CFDataRef data) {
    CF_OBJC_FUNCDISPATCH0(__kCFDataTypeID, CFIndex, data, "length");
    __CFGenericValidateType(data, __kCFDataTypeID);
    return __CFDataLength(data);
}

const uint8_t *CFDataGetBytePtr(CFDataRef data) {
    CF_OBJC_FUNCDISPATCH0(__kCFDataTypeID, const uint8_t *, data, "bytes");
    __CFGenericValidateType(data, __kCFDataTypeID);
    return data->_bytes;
}

uint8_t *CFDataGetMutableBytePtr(CFMutableDataRef data) {
    CF_OBJC_FUNCDISPATCH0(__kCFDataTypeID, uint8_t *, data, "mutableBytes");
    CFAssert1(__CFMutableVariety(data) == kCFMutable || __CFMutableVariety(data) == kCFFixedMutable, __kCFLogAssertion, "%s(): data is immutable", __PRETTY_FUNCTION__);
    return data->_bytes;
}

void CFDataGetBytes(CFDataRef data, CFRange range, uint8_t *buffer) {
    CF_OBJC_FUNCDISPATCH2(__kCFDataTypeID, void, data, "getBytes:range:", buffer, range);
    memmove(buffer, data->_bytes + range.location, range.length);
}

static void __CFDataGrow(CFMutableDataRef data, CFIndex numNewValues) {
    CFIndex oldLength = __CFDataLength(data);
    CFIndex capacity = __CFDataRoundUpCapacity(oldLength + numNewValues);
    __CFDataSetCapacity(data, capacity);
    __CFDataSetNumBytes(data, __CFDataNumBytesForCapacity(capacity));
    data->_bytes = CFAllocatorReallocate(CFGetAllocator(data), data->_bytes, __CFDataNumBytes(data) * sizeof(uint8_t), 0);
    if (__CFOASafe) __CFSetLastAllocationEventName(data->_bytes, "CFData (store)");
    if (NULL == data->_bytes) HALT;
}

void CFDataSetLength(CFMutableDataRef data, CFIndex length) {
    CFIndex len;
    CF_OBJC_FUNCDISPATCH1(__kCFDataTypeID, void, data, "setLength:", length);
    CFAssert1(__CFMutableVariety(data) == kCFMutable || __CFMutableVariety(data) == kCFFixedMutable, __kCFLogAssertion, "%s(): data is immutable", __PRETTY_FUNCTION__);
    len = __CFDataLength(data);
    switch (__CFMutableVariety(data)) {
    case kCFMutable:
	if (len < length) {
// CF: should only grow when new length exceeds current capacity, not whenever it exceeds the current length
	    __CFDataGrow(data, length - len);
	}
	break;
    case kCFFixedMutable:
	CFAssert1(length <= __CFDataCapacity(data), __kCFLogAssertion, "%s(): fixed-capacity data is full", __PRETTY_FUNCTION__);
	break;
    }
    if (len < length) {
	memset(data->_bytes + len, 0, length - len);
    }
    __CFDataSetLength(data, length);
    __CFDataSetNumBytesUsed(data, length);
}

void CFDataIncreaseLength(CFMutableDataRef data, CFIndex extraLength) {
    CF_OBJC_FUNCDISPATCH1(__kCFDataTypeID, void, data, "increaseLengthBy:", extraLength);
    CFAssert1(__CFMutableVariety(data) == kCFMutable || __CFMutableVariety(data) == kCFFixedMutable, __kCFLogAssertion, "%s(): data is immutable", __PRETTY_FUNCTION__);
    CFDataSetLength(data, __CFDataLength(data) + extraLength);
}

void CFDataAppendBytes(CFMutableDataRef data, const uint8_t *bytes, CFIndex length) {
    CF_OBJC_FUNCDISPATCH2(__kCFDataTypeID, void, data, "appendBytes:length:", bytes, length);
    CFAssert1(__CFMutableVariety(data) == kCFMutable || __CFMutableVariety(data) == kCFFixedMutable, __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(__CFMutableVariety(data) == kCFMutable || __CFMutableVariety(data) == kCFFixedMutable, __kCFLogAssertion, "%s(): data is immutable", __PRETTY_FUNCTION__);
    CFDataReplaceBytes(data, range, NULL, 0); 
}

void CFDataReplaceBytes(CFMutableDataRef data, CFRange range, const uint8_t *newBytes, CFIndex newLength) {
    CFIndex len;
    CF_OBJC_FUNCDISPATCH3(__kCFDataTypeID, void, data, "replaceBytesInRange:withBytes:length:", range, newBytes, newLength);
    __CFGenericValidateType(data, __kCFDataTypeID);
    __CFDataValidateRange(data, range, __PRETTY_FUNCTION__);
    CFAssert1(__CFMutableVariety(data) == kCFMutable || __CFMutableVariety(data) == kCFFixedMutable, __kCFLogAssertion, "%s(): data is immutable", __PRETTY_FUNCTION__);
    CFAssert2(0 <= newLength, __kCFLogAssertion, "%s(): newLength (%d) cannot be less than zero", __PRETTY_FUNCTION__, newLength);
    len = __CFDataLength(data);
    switch (__CFMutableVariety(data)) {
    case kCFMutable:
	if (range.length < newLength && __CFDataNumBytes(data) < len - range.length + newLength) {
	    __CFDataGrow(data, newLength - range.length);
	}
	break;
    case kCFFixedMutable:
	CFAssert1(len - range.length + newLength <= __CFDataCapacity(data), __kCFLogAssertion, "%s(): fixed-capacity data is full", __PRETTY_FUNCTION__);
	break;
    }
    if (newLength != range.length && range.location + range.length < len) {
        memmove(data->_bytes + range.location + newLength, data->_bytes + range.location + range.length, (len - range.location - range.length) * sizeof(uint8_t));
    }
    if (0 < newLength) {
        memmove(data->_bytes + range.location, newBytes, newLength * sizeof(uint8_t));
    }
    __CFDataSetNumBytesUsed(data, (len - range.length + newLength));
    __CFDataSetLength(data, (len - range.length + newLength));
}

#undef __CFDataValidateRange
#undef __CFGenericValidateMutabilityFlags
Commit	Line	Data
9ce05555 A	1	/*
	2	* Copyright (c) 2003 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved.
	7	*
	8	* This file contains Original Code and/or Modifications of Original Code
	9	* as defined in and that are subject to the Apple Public Source License
	10	* Version 2.0 (the 'License'). You may not use this file except in
	11	* compliance with the License. Please obtain a copy of the License at
	12	* http://www.opensource.apple.com/apsl/ and read it before using this
	13	* file.
	14	*
	15	* The Original Code and all software distributed under the License are
	16	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	17	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	18	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	19	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	20	* Please see the License for the specific language governing rights and
	21	* limitations under the License.
	22	*
	23	* @APPLE_LICENSE_HEADER_END@
	24	*/
	25	/* CFData.c
	26	Copyright 1998-2002, Apple, Inc. All rights reserved.
	27	Responsibility: Christopher Kane
	28	*/
	29
	30	#include <CoreFoundation/CFData.h>
	31	#include "CFUtilities.h"
	32	#include "CFInternal.h"
	33	#include <string.h>
	34
	35	struct __CFData {
	36	CFRuntimeBase _base;
	37	CFIndex _length; /* number of bytes */
	38	CFIndex _capacity; /* maximum number of bytes */
	39	CFAllocatorRef _bytesDeallocator; /* used only for immutable; if NULL, no deallocation */
	40	uint8_t *_bytes;
	41	};
	42
	43	/* Bits 3-2 are used for mutability variation */
	44
	45	CF_INLINE UInt32 __CFMutableVariety(const void *cf) {
	46	return __CFBitfieldGetValue(((const CFRuntimeBase *)cf)->_info, 3, 2);
	47	}
	48
	49	CF_INLINE void __CFSetMutableVariety(void *cf, UInt32 v) {
	50	__CFBitfieldSetValue(((CFRuntimeBase *)cf)->_info, 3, 2, v);
	51	}
	52
	53	CF_INLINE UInt32 __CFMutableVarietyFromFlags(UInt32 flags) {
	54	return __CFBitfieldGetValue(flags, 1, 0);
	55	}
	56
	57	#define __CFGenericValidateMutabilityFlags(flags) \
	58	CFAssert2(__CFMutableVarietyFromFlags(flags) != 0x2, __kCFLogAssertion, "%s(): flags 0x%x do not correctly specify the mutable variety", __PRETTY_FUNCTION__, flags);
	59
	60	CF_INLINE CFIndex __CFDataLength(CFDataRef data) {
	61	return data->_length;
	62	}
	63
	64	CF_INLINE void __CFDataSetLength(CFMutableDataRef data, CFIndex v) {
65	/* for a CFData, _bytesUsed == _length */
66	}
67
68	CF_INLINE CFIndex __CFDataCapacity(CFDataRef data) {
69	return data->_capacity;
70	}
71
72	CF_INLINE void __CFDataSetCapacity(CFMutableDataRef data, CFIndex v) {
73	/* for a CFData, _bytesNum == _capacity */
74	}
75
76	CF_INLINE CFIndex __CFDataNumBytesUsed(CFDataRef data) {
77	return data->_length;
78	}
79
80	CF_INLINE void __CFDataSetNumBytesUsed(CFMutableDataRef data, CFIndex v) {
81	data->_length = v;
82	}
83
84	CF_INLINE CFIndex __CFDataNumBytes(CFDataRef data) {
85	return data->_capacity;
86	}
87
88	CF_INLINE void __CFDataSetNumBytes(CFMutableDataRef data, CFIndex v) {
89	data->_capacity = v;
90	}
91
92	CF_INLINE CFIndex __CFDataRoundUpCapacity(CFIndex capacity) {
93	if (capacity < 16) return 16;
94	// CF: quite probably, this doubling should slow as the data gets larger and larger; should not use strict doubling
95	return (1 << (CFLog2(capacity) + 1));
96	}
97
98	CF_INLINE CFIndex __CFDataNumBytesForCapacity(CFIndex capacity) {
99	return capacity;
100	}
101
102	#if defined(DEBUG)
103	CF_INLINE void __CFDataValidateRange(CFDataRef data, CFRange range, const char *func) {
104	CFAssert2(0 <= range.location && range.location <= __CFDataLength(data), __kCFLogAssertion, "%s(): range.location index (%d) out of bounds", func, range.location);
105	CFAssert2(0 <= range.length, __kCFLogAssertion, "%s(): length (%d) cannot be less than zero", func, range.length);
106	CFAssert2(range.location + range.length <= __CFDataLength(data), __kCFLogAssertion, "%s(): ending index (%d) out of bounds", func, range.location + range.length);
107	}
108	#else
109	#define __CFDataValidateRange(a,r,f)
110	#endif
111
112	static bool __CFDataEqual(CFTypeRef cf1, CFTypeRef cf2) {
113	CFDataRef data1 = (CFDataRef)cf1;
114	CFDataRef data2 = (CFDataRef)cf2;
115	CFIndex length;
116	length = __CFDataLength(data1);
117	if (length != __CFDataLength(data2)) return false;
118	return 0 == memcmp(data1->_bytes, data2->_bytes, length);
119	}
120
121	static CFHashCode __CFDataHash(CFTypeRef cf) {
122	CFDataRef data = (CFDataRef)cf;
123	return CFHashBytes(data->_bytes, __CFMin(__CFDataLength(data), 16));
124	}
125
126	static CFStringRef __CFDataCopyDescription(CFTypeRef cf) {
127	CFDataRef data = (CFDataRef)cf;
128	CFMutableStringRef result;
129	CFIndex idx;
130	CFIndex len;
131	const uint8_t *bytes;
132	len = __CFDataLength(data);
133	bytes = data->_bytes;
134	result = CFStringCreateMutable(CFGetAllocator(data), 0);
135	CFStringAppendFormat(result, NULL, CFSTR("<CFData %p [%p]>{length = %u, capacity = %u, bytes = 0x"), cf, CFGetAllocator(data), len, __CFDataCapacity(data));
136	if (24 < len) {
137	for (idx = 0; idx < 16; idx += 4) {
138	CFStringAppendFormat(result, NULL, CFSTR("%02x%02x%02x%02x"), bytes[idx], bytes[idx + 1], bytes[idx + 2], bytes[idx + 3]);
139	}
140	CFStringAppend(result, CFSTR(" ... "));
141	for (idx = len - 8; idx < len; idx += 4) {
142	CFStringAppendFormat(result, NULL, CFSTR("%02x%02x%02x%02x"), bytes[idx], bytes[idx + 1], bytes[idx + 2], bytes[idx + 3]);
143	}
144	} else {
145	for (idx = 0; idx < len; idx++) {
146	CFStringAppendFormat(result, NULL, CFSTR("%02x"), bytes[idx]);
147	}
148	}
149	CFStringAppend(result, CFSTR("}"));
150	return result;
151	}
152
153	enum {
154	kCFImmutable = 0x0, /* unchangable and fixed capacity; default */
155	kCFMutable = 0x1, /* changeable and variable capacity */
156	kCFFixedMutable = 0x3 /* changeable and fixed capacity */
157	};
158
159	static void __CFDataDeallocate(CFTypeRef cf) {
160	CFMutableDataRef data = (CFMutableDataRef)cf;
161	CFAllocatorRef allocator = CFGetAllocator(data);
162	switch (__CFMutableVariety(data)) {
163	case kCFMutable:
164	CFAllocatorDeallocate(allocator, data->_bytes);
165	break;
166	case kCFFixedMutable:
167	break;
168	case kCFImmutable:
169	if (NULL != data->_bytesDeallocator) {
170	CFAllocatorDeallocate(data->_bytesDeallocator, data->_bytes);
171	CFRelease(data->_bytesDeallocator);
172	}
173	break;
174	}
175	}
176
177	static CFTypeID __kCFDataTypeID = _kCFRuntimeNotATypeID;
178
179	static const CFRuntimeClass __CFDataClass = {
180	0,
181	"CFData",
182	NULL, // init
183	NULL, // copy
184	__CFDataDeallocate,
185	(void *)__CFDataEqual,
186	__CFDataHash,
187	NULL, //
188	__CFDataCopyDescription
189	};
190
191	__private_extern__ void __CFDataInitialize(void) {
192	__kCFDataTypeID = _CFRuntimeRegisterClass(&__CFDataClass);
193	}
194
195	CFTypeID CFDataGetTypeID(void) {
196	return __kCFDataTypeID;
197	}
198
199	// NULL bytesDeallocator to this function does not mean the default allocator, it means
200	// that there should be no deallocator, and the bytes should be copied.
201	static CFMutableDataRef __CFDataInit(CFAllocatorRef allocator, CFOptionFlags flags, CFIndex capacity, const uint8_t *bytes, CFIndex length, CFAllocatorRef bytesDeallocator) {
202	CFMutableDataRef memory;
203	CFIndex size;
204	__CFGenericValidateMutabilityFlags(flags);
205	CFAssert2(0 <= capacity, __kCFLogAssertion, "%s(): capacity (%d) cannot be less than zero", __PRETTY_FUNCTION__, capacity);
206	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);
207	CFAssert2(0 <= length, __kCFLogAssertion, "%s(): length (%d) cannot be less than zero", __PRETTY_FUNCTION__, length);
208	size = sizeof(struct __CFData) - sizeof(CFRuntimeBase);
209	if (__CFMutableVarietyFromFlags(flags) != kCFMutable && (bytesDeallocator == NULL)) {
210	size += sizeof(uint8_t) * __CFDataNumBytesForCapacity(capacity);
211	}
212	if (__CFMutableVarietyFromFlags(flags) != kCFMutable) {
213	size += sizeof(uint8_t) * 15; // for 16-byte alignment fixup
214	}
215	memory = (CFMutableDataRef)_CFRuntimeCreateInstance(allocator, __kCFDataTypeID, size, NULL);
216	if (NULL == memory) {
217	return NULL;
218	}
219	__CFDataSetNumBytesUsed(memory, 0);
220	__CFDataSetLength(memory, 0);
221	switch (__CFMutableVarietyFromFlags(flags)) {
222	case kCFMutable:
223	__CFDataSetCapacity(memory, __CFDataRoundUpCapacity(1));
224	__CFDataSetNumBytes(memory, __CFDataNumBytesForCapacity(__CFDataRoundUpCapacity(1)));
225	// assume that allocators give 16-byte aligned memory back -- it is their responsibility
226	memory->_bytes = CFAllocatorAllocate(allocator, __CFDataNumBytes(memory) * sizeof(uint8_t), 0);
227	if (__CFOASafe) __CFSetLastAllocationEventName(memory->_bytes, "CFData (store)");
228	if (NULL == memory->_bytes) {
229	CFRelease(memory);
230	return NULL;
231	}
232	memory->_bytesDeallocator = NULL;
233	__CFSetMutableVariety(memory, kCFMutable);
234	CFDataReplaceBytes(memory, CFRangeMake(0, 0), bytes, length);
235	break;
236	case kCFFixedMutable:
237	/* Don't round up capacity */
238	__CFDataSetCapacity(memory, capacity);
239	__CFDataSetNumBytes(memory, __CFDataNumBytesForCapacity(capacity));
240	memory->_bytes = (uint8_t )((uintptr_t)((int8_t )memory + sizeof(struct __CFData) + 15) & ~0xF); // 16-byte align
241	memory->_bytesDeallocator = NULL;
242	__CFSetMutableVariety(memory, kCFFixedMutable);
243	CFDataReplaceBytes(memory, CFRangeMake(0, 0), bytes, length);
244	break;
245	case kCFImmutable:
246	/* Don't round up capacity */
247	__CFDataSetCapacity(memory, capacity);
248	__CFDataSetNumBytes(memory, __CFDataNumBytesForCapacity(capacity));
249	if (bytesDeallocator != NULL) {
250	memory->_bytes = (uint8_t *)bytes;
251	memory->_bytesDeallocator = CFRetain(bytesDeallocator);
252	__CFDataSetNumBytesUsed(memory, length);
253	__CFDataSetLength(memory, length);
254	} else {
255	memory->_bytes = (uint8_t )((uintptr_t)((int8_t )memory + sizeof(struct __CFData) + 15) & ~0xF); // 16-byte align
256	memory->_bytesDeallocator = NULL;
257	__CFSetMutableVariety(memory, kCFFixedMutable);
258	CFDataReplaceBytes(memory, CFRangeMake(0, 0), bytes, length);
259	}
260	break;
261	}
262	__CFSetMutableVariety(memory, __CFMutableVarietyFromFlags(flags));
263	return memory;
264	}
265
266	CFDataRef CFDataCreate(CFAllocatorRef allocator, const uint8_t *bytes, CFIndex length) {
267	return __CFDataInit(allocator, kCFImmutable, length, bytes, length, NULL);
268	}
269
270	CFDataRef CFDataCreateWithBytesNoCopy(CFAllocatorRef allocator, const uint8_t *bytes, CFIndex length, CFAllocatorRef bytesDeallocator) {
271	CFAssert1((0 == length \|\| bytes != NULL), __kCFLogAssertion, "%s(): bytes pointer cannot be NULL if length is non-zero", __PRETTY_FUNCTION__);
272	if (NULL == bytesDeallocator) bytesDeallocator = __CFGetDefaultAllocator();
273	if (!_CFExecutableLinkedOnOrAfter(CFSystemVersionJaguar)) {
274	bytesDeallocator = NULL;
275	}
276	return __CFDataInit(allocator, kCFImmutable, length, bytes, length, bytesDeallocator);
277	}
278
279	CFDataRef CFDataCreateCopy(CFAllocatorRef allocator, CFDataRef data) {
280	CFIndex length = CFDataGetLength(data);
281	return __CFDataInit(allocator, kCFImmutable, length, CFDataGetBytePtr(data), length, NULL);
282	}
283
284	CFMutableDataRef CFDataCreateMutable(CFAllocatorRef allocator, CFIndex capacity) {
285	return __CFDataInit(allocator, (0 == capacity) ? kCFMutable : kCFFixedMutable, capacity, NULL, 0, NULL);
286	}
287
288	CFMutableDataRef CFDataCreateMutableCopy(CFAllocatorRef allocator, CFIndex capacity, CFDataRef data) {
289	return __CFDataInit(allocator, (0 == capacity) ? kCFMutable : kCFFixedMutable, capacity, CFDataGetBytePtr(data), CFDataGetLength(data), NULL);
290	}
291
292	CFIndex CFDataGetLength(CFDataRef data) {
293	CF_OBJC_FUNCDISPATCH0(__kCFDataTypeID, CFIndex, data, "length");
294	__CFGenericValidateType(data, __kCFDataTypeID);
295	return __CFDataLength(data);
296	}
297
298	const uint8_t *CFDataGetBytePtr(CFDataRef data) {
299	CF_OBJC_FUNCDISPATCH0(__kCFDataTypeID, const uint8_t *, data, "bytes");
300	__CFGenericValidateType(data, __kCFDataTypeID);
301	return data->_bytes;
302	}
303
304	uint8_t *CFDataGetMutableBytePtr(CFMutableDataRef data) {
305	CF_OBJC_FUNCDISPATCH0(__kCFDataTypeID, uint8_t *, data, "mutableBytes");
306	CFAssert1(__CFMutableVariety(data) == kCFMutable \|\| __CFMutableVariety(data) == kCFFixedMutable, __kCFLogAssertion, "%s(): data is immutable", __PRETTY_FUNCTION__);
307	return data->_bytes;
308	}
309
310	void CFDataGetBytes(CFDataRef data, CFRange range, uint8_t *buffer) {
311	CF_OBJC_FUNCDISPATCH2(__kCFDataTypeID, void, data, "getBytes:range:", buffer, range);
312	memmove(buffer, data->_bytes + range.location, range.length);
313	}
314
315	static void __CFDataGrow(CFMutableDataRef data, CFIndex numNewValues) {
316	CFIndex oldLength = __CFDataLength(data);
317	CFIndex capacity = __CFDataRoundUpCapacity(oldLength + numNewValues);
318	__CFDataSetCapacity(data, capacity);
319	__CFDataSetNumBytes(data, __CFDataNumBytesForCapacity(capacity));
320	data->_bytes = CFAllocatorReallocate(CFGetAllocator(data), data->_bytes, __CFDataNumBytes(data) * sizeof(uint8_t), 0);
321	if (__CFOASafe) __CFSetLastAllocationEventName(data->_bytes, "CFData (store)");
322	if (NULL == data->_bytes) HALT;
323	}
324
325	void CFDataSetLength(CFMutableDataRef data, CFIndex length) {
326	CFIndex len;
327	CF_OBJC_FUNCDISPATCH1(__kCFDataTypeID, void, data, "setLength:", length);
328	CFAssert1(__CFMutableVariety(data) == kCFMutable \|\| __CFMutableVariety(data) == kCFFixedMutable, __kCFLogAssertion, "%s(): data is immutable", __PRETTY_FUNCTION__);
329	len = __CFDataLength(data);
330	switch (__CFMutableVariety(data)) {
331	case kCFMutable:
332	if (len < length) {
333	// CF: should only grow when new length exceeds current capacity, not whenever it exceeds the current length
334	__CFDataGrow(data, length - len);
335	}
336	break;
337	case kCFFixedMutable:
338	CFAssert1(length <= __CFDataCapacity(data), __kCFLogAssertion, "%s(): fixed-capacity data is full", __PRETTY_FUNCTION__);
339	break;
340	}
341	if (len < length) {
342	memset(data->_bytes + len, 0, length - len);
343	}
344	__CFDataSetLength(data, length);
345	__CFDataSetNumBytesUsed(data, length);
346	}
347
348	void CFDataIncreaseLength(CFMutableDataRef data, CFIndex extraLength) {
349	CF_OBJC_FUNCDISPATCH1(__kCFDataTypeID, void, data, "increaseLengthBy:", extraLength);
350	CFAssert1(__CFMutableVariety(data) == kCFMutable \|\| __CFMutableVariety(data) == kCFFixedMutable, __kCFLogAssertion, "%s(): data is immutable", __PRETTY_FUNCTION__);
351	CFDataSetLength(data, __CFDataLength(data) + extraLength);
352	}
353
354	void CFDataAppendBytes(CFMutableDataRef data, const uint8_t *bytes, CFIndex length) {
355	CF_OBJC_FUNCDISPATCH2(__kCFDataTypeID, void, data, "appendBytes:length:", bytes, length);
356	CFAssert1(__CFMutableVariety(data) == kCFMutable \|\| __CFMutableVariety(data) == kCFFixedMutable, __kCFLogAssertion, "%s(): data is immutable", __PRETTY_FUNCTION__);
357	CFDataReplaceBytes(data, CFRangeMake(__CFDataLength(data), 0), bytes, length);
358	}
359
360	void CFDataDeleteBytes(CFMutableDataRef data, CFRange range) {
361	CF_OBJC_FUNCDISPATCH3(__kCFDataTypeID, void, data, "replaceBytesInRange:withBytes:length:", range, NULL, 0);
362	CFAssert1(__CFMutableVariety(data) == kCFMutable \|\| __CFMutableVariety(data) == kCFFixedMutable, __kCFLogAssertion, "%s(): data is immutable", __PRETTY_FUNCTION__);
363	CFDataReplaceBytes(data, range, NULL, 0);
364	}
365
366	void CFDataReplaceBytes(CFMutableDataRef data, CFRange range, const uint8_t *newBytes, CFIndex newLength) {
367	CFIndex len;
368	CF_OBJC_FUNCDISPATCH3(__kCFDataTypeID, void, data, "replaceBytesInRange:withBytes:length:", range, newBytes, newLength);
369	__CFGenericValidateType(data, __kCFDataTypeID);
370	__CFDataValidateRange(data, range, __PRETTY_FUNCTION__);
371	CFAssert1(__CFMutableVariety(data) == kCFMutable \|\| __CFMutableVariety(data) == kCFFixedMutable, __kCFLogAssertion, "%s(): data is immutable", __PRETTY_FUNCTION__);
372	CFAssert2(0 <= newLength, __kCFLogAssertion, "%s(): newLength (%d) cannot be less than zero", __PRETTY_FUNCTION__, newLength);
373	len = __CFDataLength(data);
374	switch (__CFMutableVariety(data)) {
375	case kCFMutable:
376	if (range.length < newLength && __CFDataNumBytes(data) < len - range.length + newLength) {
377	__CFDataGrow(data, newLength - range.length);
378	}
379	break;
380	case kCFFixedMutable:
381	CFAssert1(len - range.length + newLength <= __CFDataCapacity(data), __kCFLogAssertion, "%s(): fixed-capacity data is full", __PRETTY_FUNCTION__);
382	break;
383	}
384	if (newLength != range.length && range.location + range.length < len) {
385	memmove(data->_bytes + range.location + newLength, data->_bytes + range.location + range.length, (len - range.location - range.length) * sizeof(uint8_t));
386	}
387	if (0 < newLength) {
388	memmove(data->_bytes + range.location, newBytes, newLength * sizeof(uint8_t));
389	}
390	__CFDataSetNumBytesUsed(data, (len - range.length + newLength));
391	__CFDataSetLength(data, (len - range.length + newLength));
392	}
393
394	#undef __CFDataValidateRange
395	#undef __CFGenericValidateMutabilityFlags
396