void
TclpFree(
char *oldPtr) /* Pointer to memory to free. */
{
register long size;
register union overhead *overPtr;
struct block *bigBlockPtr;
if (oldPtr == NULL) {
return;
}
Tcl_MutexLock(allocMutexPtr);
overPtr = (union overhead *)((caddr_t)oldPtr - sizeof (union overhead));
ASSERT(overPtr->overMagic0 == MAGIC); /* make sure it was in use */
ASSERT(overPtr->overMagic1 == MAGIC);
if (overPtr->overMagic0 != MAGIC || overPtr->overMagic1 != MAGIC) {
Tcl_MutexUnlock(allocMutexPtr);
return;
}
RANGE_ASSERT(overPtr->rangeCheckMagic == RMAGIC);
RANGE_ASSERT(BLOCK_END(overPtr) == RMAGIC);
size = overPtr->bucketIndex;
if (size == 0xff) {
#ifdef MSTATS
numMallocs[NBUCKETS]--;
#endif
bigBlockPtr = (struct block *) overPtr - 1;
bigBlockPtr->prevPtr->nextPtr = bigBlockPtr->nextPtr;
bigBlockPtr->nextPtr->prevPtr = bigBlockPtr->prevPtr;
TclpSysFree(bigBlockPtr);
Tcl_MutexUnlock(allocMutexPtr);
return;
}
ASSERT(size < NBUCKETS);
overPtr->next = nextf[size]; /* also clobbers overMagic */
nextf[size] = overPtr;
#ifdef MSTATS
numMallocs[size]--;
#endif
Tcl_MutexUnlock(allocMutexPtr);
}
PrimitiveShape::PrimitiveShape(
int type, int sourceblend, int destblend, int blendmethod )
: m_blendsf( TABLE_ASSERT(
blendftable, sourceblend, "source blend factor" ) )
, m_blenddf( TABLE_ASSERT(
blendftable, destblend, "destination blend factor" ) )
, m_blendop( TABLE_ASSERT(
blendoptable, blendmethod, "blend method" ) )
#if !defined( _MSC_VER )
, m_matrix{
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
0, 0, 0, 1,
}
#endif
{
#if defined( _MSC_VER )
memset( &m_matrix, 0, sizeof( m_matrix ) );
m_matrix[ 0 ] = m_matrix[ 5 ] = m_matrix[ 10 ] = m_matrix[ 15 ] = 1;
#endif
m_type.store( RANGE_ASSERT(
type, 0, int( primitivetype::invalid ), "primitive type" ),
std::memory_order_release );
}
char *
TclpRealloc(
char *oldPtr, /* Pointer to alloced block. */
unsigned int numBytes) /* New size of memory. */
{
int i;
union overhead *overPtr;
struct block *bigBlockPtr;
int expensive;
unsigned long maxSize;
if (oldPtr == NULL) {
return TclpAlloc(numBytes);
}
Tcl_MutexLock(allocMutexPtr);
overPtr = (union overhead *)((caddr_t)oldPtr - sizeof (union overhead));
ASSERT(overPtr->overMagic0 == MAGIC); /* make sure it was in use */
ASSERT(overPtr->overMagic1 == MAGIC);
if (overPtr->overMagic0 != MAGIC || overPtr->overMagic1 != MAGIC) {
Tcl_MutexUnlock(allocMutexPtr);
return NULL;
}
RANGE_ASSERT(overPtr->rangeCheckMagic == RMAGIC);
RANGE_ASSERT(BLOCK_END(overPtr) == RMAGIC);
i = overPtr->bucketIndex;
/*
* If the block isn't in a bin, just realloc it.
*/
if (i == 0xff) {
struct block *prevPtr, *nextPtr;
bigBlockPtr = (struct block *) overPtr - 1;
prevPtr = bigBlockPtr->prevPtr;
nextPtr = bigBlockPtr->nextPtr;
bigBlockPtr = (struct block *) TclpSysRealloc(bigBlockPtr,
sizeof(struct block) + OVERHEAD + numBytes);
if (bigBlockPtr == NULL) {
Tcl_MutexUnlock(allocMutexPtr);
return NULL;
}
if (prevPtr->nextPtr != bigBlockPtr) {
/*
* If the block has moved, splice the new block into the list
* where the old block used to be.
*/
prevPtr->nextPtr = bigBlockPtr;
nextPtr->prevPtr = bigBlockPtr;
}
overPtr = (union overhead *) (bigBlockPtr + 1);
#ifdef MSTATS
numMallocs[NBUCKETS]++;
#endif
#ifdef RCHECK
/*
* Record allocated size of block and update magic number bounds.
*/
overPtr->realBlockSize = (numBytes + RSLOP - 1) & ~(RSLOP - 1);
BLOCK_END(overPtr) = RMAGIC;
#endif
Tcl_MutexUnlock(allocMutexPtr);
return (char *)(overPtr+1);
}
maxSize = 1 << (i+3);
expensive = 0;
if (numBytes+OVERHEAD > maxSize) {
expensive = 1;
} else if (i>0 && numBytes+OVERHEAD < maxSize/2) {
expensive = 1;
}
if (expensive) {
void *newPtr;
Tcl_MutexUnlock(allocMutexPtr);
newPtr = TclpAlloc(numBytes);
if (newPtr == NULL) {
return NULL;
}
maxSize -= OVERHEAD;
if (maxSize < numBytes) {
numBytes = maxSize;
}
memcpy(newPtr, oldPtr, (size_t) numBytes);
TclpFree(oldPtr);
return newPtr;
}
/*
* Ok, we don't have to copy, it fits as-is
*/
#ifdef RCHECK
overPtr->realBlockSize = (numBytes + RSLOP - 1) & ~(RSLOP - 1);
BLOCK_END(overPtr) = RMAGIC;
#endif
Tcl_MutexUnlock(allocMutexPtr);
return(oldPtr);
}
