bool OSArray::initWithCapacity(unsigned int inCapacity)
{
unsigned int size;
if (!super::init())
return false;
// integer overflow check
if (inCapacity > (UINT_MAX / sizeof(const OSMetaClassBase*)))
return false;
size = sizeof(const OSMetaClassBase *) * inCapacity;
array = (const OSMetaClassBase **) kalloc_container(size);
if (!array)
return false;
count = 0;
capacity = inCapacity;
capacityIncrement = (inCapacity)? inCapacity : 16;
bzero(array, size);
OSCONTAINER_ACCUMSIZE(size);
return true;
}
unsigned int OSDictionary::ensureCapacity(unsigned int newCapacity)
{
dictEntry *newDict;
unsigned int finalCapacity, oldSize, newSize;
if (newCapacity <= capacity)
return capacity;
// round up
finalCapacity = (((newCapacity - 1) / capacityIncrement) + 1)
* capacityIncrement;
// integer overflow check
if (finalCapacity < newCapacity || (finalCapacity > (UINT_MAX / sizeof(dictEntry))))
return capacity;
newSize = sizeof(dictEntry) * finalCapacity;
newDict = (dictEntry *) kalloc_container(newSize);
if (newDict) {
oldSize = sizeof(dictEntry) * capacity;
bcopy(dictionary, newDict, oldSize);
bzero(&newDict[capacity], newSize - oldSize);
OSCONTAINER_ACCUMSIZE(((size_t)newSize) - ((size_t)oldSize));
kfree(dictionary, oldSize);
dictionary = newDict;
capacity = finalCapacity;
}
return capacity;
}
unsigned int OSArray::ensureCapacity(unsigned int newCapacity)
{
const OSMetaClassBase **newArray;
unsigned int finalCapacity;
unsigned int oldSize, newSize;
if (newCapacity <= capacity)
return capacity;
// round up
finalCapacity = (((newCapacity - 1) / capacityIncrement) + 1)
* capacityIncrement;
// integer overflow check
if ((finalCapacity < newCapacity) || (finalCapacity > (UINT_MAX / sizeof(const OSMetaClassBase*))))
return capacity;
newSize = sizeof(const OSMetaClassBase *) * finalCapacity;
newArray = (const OSMetaClassBase **) kalloc_container(newSize);
if (newArray) {
oldSize = sizeof(const OSMetaClassBase *) * capacity;
OSCONTAINER_ACCUMSIZE(((size_t)newSize) - ((size_t)oldSize));
bcopy(array, newArray, oldSize);
bzero(&newArray[capacity], newSize - oldSize);
kfree(array, oldSize);
array = newArray;
capacity = finalCapacity;
}
return capacity;
}
bool OSOrderedSet::
initWithCapacity(unsigned int inCapacity,
OSOrderFunction inOrdering, void *inOrderingRef)
{
unsigned int size;
if (!super::init())
return false;
if (inCapacity > (UINT_MAX / sizeof(_Element)))
return false;
size = sizeof(_Element) * inCapacity;
array = (_Element *) kalloc_container(size);
if (!array)
return false;
count = 0;
capacity = inCapacity;
capacityIncrement = (inCapacity)? inCapacity : 16;
ordering = inOrdering;
orderingRef = inOrderingRef;
bzero(array, size);
OSCONTAINER_ACCUMSIZE(size);
return true;
}
bool OSDictionary::initWithCapacity(unsigned int inCapacity)
{
if (!super::init())
return false;
if (inCapacity > (UINT_MAX / sizeof(dictEntry)))
return false;
unsigned int size = inCapacity * sizeof(dictEntry);
//fOptions |= kSort;
dictionary = (dictEntry *) kalloc_container(size);
if (!dictionary)
return false;
bzero(dictionary, size);
OSCONTAINER_ACCUMSIZE(size);
count = 0;
capacity = inCapacity;
capacityIncrement = (inCapacity)? inCapacity : 16;
return true;
}
