bool RedBlackTree<Key, Data>::killNode(RedBlackNode<Key, Data> * z)
{
RedBlackNode<Key, Data> *x, *y;
if (!valid(z->left) || !valid(z->right)) {
/* y has a null node as a child */
y = z;
} else {
/* find tree successor with a null node as a child */
y = z->right;
while (valid(y->left))
y = y->left;
}
/* x is y's only child */
if (valid(y->left))
x = y->left;
else
x = y->right;
/* remove y from the parent chain */
if (valid(x)) x->parent = y->parent;
if (valid(y->parent)) {
if (y == y->parent->left)
y->parent->left = x;
else
y->parent->right = x;
} else
rootNode = x;
if (y != z) {
Dealloc(z->id);
z->id = Duplicate(y->id);
z->data = y->data;
} else {
Dealloc(y->id);
}
if (y->color == BLACK)
deleteFixup(x);
m_cachedSize--;
y->left = NULL;
y->right = NULL;
delete y;
return true;
}
bool SplayTree<Key, Data>::killNode(SplayNode<Key, Data> * z)
{
SplayNode<Key, Data> *x, *y;
if (z->left == NULL || z->right == NULL) {
/* y has a NULL node as a child */
y = z;
} else {
/* find tree successor with a NULL node as a child */
y = z->right;
while (y->left != NULL)
y = y->left;
}
/* x is y's only child */
if (y->left != NULL)
x = y->left;
else
x = y->right;
/* remove y from the parent chain */
if (x) x->parent = y->parent;
if (y->parent) {
if (y == y->parent->left)
y->parent->left = x;
else
y->parent->right = x;
} else
root = x;
if (y != z) {
Dealloc(z->id);
z->id = Duplicate(y->id);
z->data = y->data;
} else {
Dealloc(y->id);
}
m_size--;
y->left = NULL;
y->right = NULL;
delete y;
return true;
}
static void
Decomp_dealloc(compobject *self)
{
if (self->is_initialised)
inflateEnd(&self->zst);
Dealloc(self);
}
bool CLnFaktTab::Init( long n)
// Vytvori tabulku logaritmu faktorialu od 0 do n
// Pri nedostatku pameti vraci FALSE
{
if ( !m_LnFaktTab ||
n > m_n)
{
Dealloc();
m_LnFaktTab= new FAKTVALUE[n+ 1];
if ( !m_LnFaktTab) return false;
m_n= n;
m_LnFaktTab[0]= 0;
long i;
for (i= 1; i <= n; i++) m_LnFaktTab[i]= m_LnFaktTab[i-1]+ log((double) i);
// ln( n!) == ln(1)+ ln(2)+ ...+ ln(n)
// ln( n!) == ln((n-1)!)+ ln( n)
}
return true;
}
void RedBlackTree<Key, Data>::killAll(RedBlackNode<Key, Data> *rec)
{
if (!valid(rec)) {
return;
}
/* First kill our subnodes: */
if (valid(rec->left))
killAll(rec->left);
if (valid(rec->right))
killAll(rec->right);
if (valid(rec->parent)) { /* We're not root. */
if (rec->parent->left == rec)
rec->parent->left = nullNode;
else
rec->parent->right = nullNode;
}
Dealloc(rec->id);
rec->left = NULL;
rec->right = NULL;
delete rec;
}
void HashTable<Data>::empty()
{
for (size_t i = 0; i < m_size; ++i) {
if (m_keys[i] == (char*)-1) m_keys[i] = NULL;
Dealloc(m_keys[i]);
}
memset(m_keys, 0, sizeof(char *) * m_size);
memset(m_data, 0, sizeof(Data) * m_size);
}
bool HashTable<Data>::erase(const char *_key)
{
size_t index = findIndex(_key);
if (index != (size_t)-1) {
Dealloc(m_keys[index]);
m_keys[index] = (char*)-1;
m_slotsFree++;
return true;
}
return false;
}
static ULONG Release(void* instance)
{
BonjourUserEventsPlugin* plugin = (BonjourUserEventsPlugin*)instance;
if (plugin->_refCount != 0)
--plugin->_refCount;
if (plugin->_refCount == 0)
{
Dealloc(instance);
return 0;
}
return plugin->_refCount;
}
MeasureAllocDeallocTime(ElapsedTimeRec& timeRec, std::size_t blockSize, int preAlloc, int maxAlloc) :
m_pPool (NULL)
{
std::vector<char*> ptrs(maxAlloc);
{
Poco::Stopwatch sw_total;
sw_total.start();
{ // initialize
Poco::Stopwatch sw_init;
sw_init.start();
Init(blockSize, preAlloc, maxAlloc);
sw_init.stop();
timeRec.timeInit = (1000.0 * sw_init.elapsed()) / sw_init.resolution();
}
for(std::size_t loop=0; loop<kNumLoop; ++loop)
{
{ // allocate
Poco::Stopwatch sw_alloc;
sw_alloc.start();
for(int i=0; i<maxAlloc; ++i)
{
ptrs[i] = Alloc(blockSize);
}
sw_alloc.stop();
timeRec.timeAlloc[loop] = (1000.0 * sw_alloc.elapsed()) / sw_alloc.resolution();
}
{ // deallocate
Poco::Stopwatch sw_dealloc;
sw_dealloc.start();
for(int i=0; i<maxAlloc; ++i)
{
Dealloc(ptrs[i]);
}
sw_dealloc.stop();
timeRec.timeDealloc[loop] = (1000.0 * sw_dealloc.elapsed()) / sw_dealloc.resolution();
}
}
{ // cleanup
Poco::Stopwatch sw_cleanup;
sw_cleanup.start();
Cleanup();
sw_cleanup.stop();
timeRec.timeCleanup = (1000.0 * sw_cleanup.elapsed()) / sw_cleanup.resolution();
}
sw_total.stop();
timeRec.timeTotal = (1000.0 * sw_total.elapsed()) / sw_total.resolution();
}
}
///////////////////////////////////////
// Deallocate the Hydra's pointers
///////////////////////////////////////
void HydraClass::ZapHydra(void)
{
WORD wNdx;
if (achBankName != NULL)
{
delete [] achBankName;
achBankName = NULL;
}
HydraVersion.wMajor = HydraVersion.wMinor = 0;
if (pPHdr != NULL)
{
if (pPHdr != NULL) Dealloc((VOIDPTR)pPHdr);
if (pPBag != NULL) Dealloc((VOIDPTR)pPBag);
if (pPGen != NULL) Dealloc((VOIDPTR)pPGen);
if (pPMod != NULL) Dealloc((VOIDPTR)pPMod);
if (pInst != NULL) Dealloc((VOIDPTR)pInst);
if (pIBag != NULL) Dealloc((VOIDPTR)pIBag);
if (pIGen != NULL) Dealloc((VOIDPTR)pIGen);
if (pIMod != NULL) Dealloc((VOIDPTR)pIMod);
if (pSHdr != NULL) Dealloc((VOIDPTR)pSHdr);
}
pPHdr = NULL;
pPBag = NULL;
pPGen = NULL;
pPMod = NULL;
pInst = NULL;
pIBag = NULL;
pIGen = NULL;
pIMod = NULL;
pSHdr = NULL;
for (wNdx = 0; wNdx < SF_DATASTRUCTS; wNdx++)
{
awStructSize[wNdx] = 0;
}
}
bool SplayTree<Key, Data>::insert(Key const &key, Data const &x)
{
static SplayNode<Key, Data> *newNode = NULL;
if (newNode == NULL)
newNode = new SplayNode<Key, Data>;
else
Dealloc(newNode->id);
newNode->id = Duplicate(key);
newNode->data = x;
newNode->parent = newNode->right = newNode->left = NULL;
if (root == NULL) {
newNode->left = newNode->right = NULL;
root = newNode;
} else {
splay(key, root);
if (Compare(key, root->id) < 0) {
newNode->left = root->left;
if (newNode->left)
newNode->left->parent = newNode;
newNode->right = root;
root->parent = newNode;
root->left = NULL;
root = newNode;
} else
if (Compare(root->id, key) < 0) {
newNode->right = root->right;
if (newNode->right)
newNode->right->parent = newNode;
newNode->left = root;
root->parent = newNode;
root->right = NULL;
root = newNode;
} else
return false;
}
m_size++;
newNode = NULL; /* So next insert will call new */
return true;
}
bool
GMPSharedMemManager::MgrDeallocShmem(GMPSharedMem::GMPMemoryClasses aClass, ipc::Shmem& aMem)
{
mData->CheckThread();
size_t size = aMem.Size<uint8_t>();
size_t total = 0;
// XXX Bug NNNNNNN Until we put better guards on ipc::shmem, verify we
// weren't fed an shmem we already had.
for (uint32_t i = 0; i < GetGmpFreelist(aClass).Length(); i++) {
if (NS_WARN_IF(aMem == GetGmpFreelist(aClass)[i])) {
// Safest to crash in this case; should never happen in normal
// operation.
MOZ_CRASH("Deallocating Shmem we already have in our cache!");
//return true;
}
}
// XXX This works; there are better pool algorithms. We need to avoid
// "falling off a cliff" with too low a number
if (GetGmpFreelist(aClass).Length() > 10) {
Dealloc(GetGmpFreelist(aClass)[0]);
GetGmpFreelist(aClass).RemoveElementAt(0);
// The allocation numbers will be fubar on the Child!
mData->mGmpAllocated[aClass]--;
}
for (uint32_t i = 0; i < GetGmpFreelist(aClass).Length(); i++) {
MOZ_ASSERT(GetGmpFreelist(aClass)[i].IsWritable());
total += GetGmpFreelist(aClass)[i].Size<uint8_t>();
if (size < GetGmpFreelist(aClass)[i].Size<uint8_t>()) {
GetGmpFreelist(aClass).InsertElementAt(i, aMem);
return true;
}
}
GetGmpFreelist(aClass).AppendElement(aMem);
return true;
}
void Coord::Set(unsigned int width, unsigned int height)
{
Coord::width = width;
Coord::height = height;
Coord::count = width * height;
unsigned int maxSize = static_cast<unsigned int>( pow(2.0,static_cast<double>(8*sizeof(char))) / 2 - 1);
if( std::max(width,height) > maxSize)
{
char str[256];
sprintf_s(str,sizeof(str),"Playing board too big, max size is %u",maxSize);
throw _Exception(str);
}
Dealloc();
distance = new char[count * count];
direction = new Direction[count * count];
neighbourList = new Crd[count * (MAX_NEIGHBOURS + 1)];
influencyList = new Crd[count* directionCount *(MAX_INFLUENCES_DIRECTION + 1)];
SetDistanceDirection();
SetDirectionShift();
SetNeighbourList();
SetInfluencyList();
}
CLnFaktTab::~CLnFaktTab()
{
Dealloc();
}
GamePad_SDL::~GamePad_SDL() {
g_pErr->DFI("GamePad_SDL::~GamePad_SDL", 0L, 1);
Dealloc();
g_pErr->DFO("GamePad_SDL::~GamePad_SDL", 0L, 1);
}
AX_RETURN_NULL
AX_FORCEINLINE tElement *Dealloc( tElement *p )
{
return ( tElement * )Dealloc( ( void * )p );
}
Server::~Server()
{
Dealloc();
delete Net;
}
BYTEPTR sfReader::Allocate(SHORT iHydraSymbol,
SHORT iMemStructSize,
SHORT iFileStructSize,
DWORD dwChkSize,
HydraClass *hf)
//*************************************************************************
//
// Parameters: iHydraSymbol: The SoundFont Data Structure symbol
//
// iMemStructSize: The size in bytes of memory required by
// a HydraFont head, (ie sizeof(whatever)
//
// iFileStructSize: The size in bytes occupied in a file
// by a HydraFont head,
//
// Systems with different byte boundries will allocate memory from
// the heap differently. Thus when allocating and accessing memory,
// the iMemStructSize tells use the padded size of memory if applicable.
//
//***************************************************************************
{
sfVersion *fileVersion;
DWORD rcnt;
BYTEPTR pData = NULL;
WORD mono = monoSample;
tRIFF.SwapBytes(&mono);
fileVersion = (sfVersion*)(infoCkValues[Ifil]);
if ( iHydraSymbol == sampHdr ) {
fileVersion = (sfVersion*)(infoCkValues[Ifil] );
// get the count of how many sampleHdr elements in the array...
hf->awStructSize[iHydraSymbol] =
(WORD) (dwChkSize /(DWORD) SAMPHDRV2_SIZE); // 46 bytes/element
// now allocate our in memory representation... based on elements
// times the inmemory size, (ie sizeof from the invocation )
if ((pData = (BYTEPTR) Alloc((DWORD) hf->awStructSize[iHydraSymbol] *
iMemStructSize)) == 0) {
SetError(EHC_ALLOCATE_PMEM_ERROR);
return (pData);
}
Memset( pData,0,hf->awStructSize[iHydraSymbol]*iMemStructSize);
// now for however many elements we have lets do the reading...
//
// Element for element read of data, to serve as an example of a possible
// issue with cross platform code. See comments below.
//
for(WORD curHdr=0; curHdr < hf->awStructSize[iHydraSymbol]; curHdr++) {
rcnt = 0;
rcnt += tRIFF.RIFFRead((VOIDPTR)
&((sfSampleHdr*)pData)[curHdr].achSampleName,
1, SAMPLENAMESIZE);
rcnt += tRIFF.RIFFRead( &((sfSampleHdr*)pData)[curHdr].dwStart,
1, sizeof(DWORD));
rcnt += tRIFF.RIFFRead( &((sfSampleHdr*)pData)[curHdr].dwEnd,
1, sizeof(DWORD));
rcnt += tRIFF.RIFFRead( &((sfSampleHdr*)pData)[curHdr].dwStartloop,
1, sizeof(DWORD));
rcnt += tRIFF.RIFFRead( &((sfSampleHdr*)pData)[curHdr].dwEndloop,
1, sizeof(DWORD));
rcnt += tRIFF.RIFFRead( &((sfSampleHdr*)pData)[curHdr].dwSampleRate,
1, sizeof(DWORD));
rcnt += tRIFF.RIFFRead( &((sfSampleHdr*)pData)[curHdr].byOriginalKey,
1, sizeof(BYTE));
rcnt += tRIFF.RIFFRead( &((sfSampleHdr*)pData)[curHdr].chFineCorrection,
1, sizeof(CHAR));
rcnt += tRIFF.RIFFRead( &((sfSampleHdr*)pData)[curHdr].wSampleLink,
1, sizeof(WORD));
rcnt += tRIFF.RIFFRead( &((sfSampleHdr*)pData)[curHdr].sfSampleType,
1, sizeof(WORD));
if( rcnt != SAMPHDRV2_SIZE) {
#ifdef DEBUG
qDebug()<<"%Allocate-E-error reading sampleHdr V2 ";
#endif
Dealloc(pData);
SetError(SF_INVALIDBANK);
return (NULL);
}
}// end for all elements
} // do sampleHdr reading,
else {
hf->awStructSize[iHydraSymbol] = (WORD) (dwChkSize /
(DWORD) iFileStructSize);
if ((pData = (BYTEPTR) Alloc((DWORD) hf->awStructSize[iHydraSymbol] *
iMemStructSize)) == 0)
{
SetError(EHC_ALLOCATE_PMEM_ERROR);
return (pData);
}
DWORD dwNdx;
for (WORD wNdx= 0; wNdx< hf->awStructSize[iHydraSymbol]; wNdx++)
{
dwNdx = (DWORD)((DWORD)wNdx* (DWORD)iMemStructSize);
//
// NOTE: ANSI makes NO specification about how elements in a
// data structure is ALIGNED within that data structure.
// Although a byte-for-byte copy from the file image into
// the memory image of the Data Structure like what is happening
// below works with many major commercial compilers for Intel
// Motorola, and Sparc microprocessors under DOS, Windows,
// Mac System 7, SunOS 4.3, and other major operating systems there
// are no guarantees it will work EVERYWHERE.
//
// This READ may need to be re-written to stuff all ELEMENTS
// of each Data Structure INDIVIDUALLY to guarantee alignment!
// (See how the SampleHeader reads are done above)
//
// On the OTHER hand...
// A possible OPTIMIZATION is that if you are on a 16 bit
// bounded system, AND you are NOT reading the defined
// INST and SHDR structures (iHydraSymbol == inst OR sampHdr)
// you can do large reads spanning multiple data structures.
// and get all data in one shot...
//
// IE Kill the 'for' loop and do:
// tRIFF.RIFFRead((VOIDPTR)pData, 1,
// hf->awStructSize[iHydraSymbol] *
// iMemStructSize);
//
// To do this for ALL data structures, remove the RefCount and
// sampleLoaded fields from the definitons of the inst and
// sampHdr structs FIRST!
//
if (0 == tRIFF.RIFFRead((VOIDPTR)(&pData[dwNdx]),
1,
iFileStructSize))
{
Dealloc(pData);
pData = NULL;
SetError(EHC_READFILEERROR);
break;
}
} // end to read all elements
} // end to new else do normal thing.
return (pData);
}// end Allocate
