void
RealmInfoFree(CallRealmInfo *ri, int freefn)
{
if (!ri)
{
return;
}
if (ri->sipdomain)
{
MFree(freefn, ri->sipdomain);
}
MFree(freefn, ri);
}
// 符合条件返回真，否则返回假。
BOOL RunWhereStatment (PMDATA_INF pStatmentInf)
{
if (pStatmentInf->m_dtDataType == SDT_BOOL)
return pStatmentInf->m_bool;
if (pStatmentInf->m_dtDataType == SDT_STATMENT)
{
DWORD dwEBP = pStatmentInf->m_statment.m_dwSubEBP;
DWORD dwSubAdr = pStatmentInf->m_statment.m_dwStatmentSubCodeAdr;
DWORD dwECX, dwEAX;
_asm
{
mov eax, dwEBP
call dwSubAdr
mov dwECX, ecx
mov dwEAX, eax
}
if (dwECX == SDT_BOOL)
return dwEAX != 0;
// 释放文本或字节集数据所分配的内存。
if (dwECX == SDT_TEXT || dwECX == SDT_BIN)
MFree ((void*)dwEAX);
}
void StringBuffer::Free()
{
int all = limit - begin;
if(all == 31)
MFree_S(begin);
if(all > 31)
MFree((Rc *)begin - 1);
}
void MMFreeMessage(MMessage * msg)
{
if (msg)
{
MMClearMessage(msg);
MFree(msg);
}
}
void KheEvennessMonitorDelete(KHE_EVENNESS_MONITOR m)
{
if( m->attached )
KheEvennessMonitorDetachFromSoln(m);
if( m->parent_monitor != NULL )
KheGroupMonitorDeleteChildMonitor(m->parent_monitor, (KHE_MONITOR) m);
KheSolnDeleteMonitor(m->soln, (KHE_MONITOR) m);
MFree(m);
}
void KheLimitIdleTimesMonitorDelete(KHE_LIMIT_IDLE_TIMES_MONITOR m)
{
if( m->attached )
KheLimitIdleTimesMonitorDetachFromSoln(m);
if( m->parent_monitor != NULL )
KheGroupMonitorDeleteChildMonitor(m->parent_monitor, (KHE_MONITOR) m);
KheResourceInSolnDeleteMonitor(m->resource_in_soln, (KHE_MONITOR) m);
KheSolnDeleteMonitor(m->soln, (KHE_MONITOR) m);
MFree(m);
}
void KheOrdinaryDemandMonitorDelete(KHE_ORDINARY_DEMAND_MONITOR m)
{
if( m->attached )
KheOrdinaryDemandMonitorDetachFromSoln(m);
if( m->parent_monitor != NULL )
KheGroupMonitorDeleteChildMonitor(m->parent_monitor, (KHE_MONITOR) m);
KheTaskDeleteDemandMonitor(m->task, m);
KheSolnDeleteMonitor(m->soln, (KHE_MONITOR) m);
MFree(m);
}
void KheLimitWorkloadMonitorDelete(KHE_LIMIT_WORKLOAD_MONITOR m)
{
if( m->attached )
KheLimitWorkloadMonitorDetachFromSoln(m);
if( m->parent_monitor != NULL )
KheGroupMonitorDeleteChildMonitor(m->parent_monitor, (KHE_MONITOR) m);
KheResourceInSolnDeleteMonitor(m->resource_in_soln, (KHE_MONITOR) m);
KheSolnDeleteMonitor(m->soln, (KHE_MONITOR) m);
MFree(m);
}
void KheAvoidUnavailableTimesMonitorDelete(
KHE_AVOID_UNAVAILABLE_TIMES_MONITOR m)
{
if( m->attached )
KheAvoidUnavailableTimesMonitorDetachFromSoln(m);
if( m->parent_monitor != NULL )
KheGroupMonitorDeleteChildMonitor(m->parent_monitor, (KHE_MONITOR) m);
KheResourceInSolnDeleteMonitor(m->resource_in_soln, (KHE_MONITOR) m);
KheSolnDeleteMonitor(m->soln, (KHE_MONITOR) m);
MFree(m);
}
void String0::LFree()
{
if(IsRef()) {
if(ptr != (char *)(voidptr + 1)) {
Rc *rc = Ref();
ASSERT(rc->refcount > 0);
if(AtomicDec(rc->refcount) == 0) MFree(rc);
}
}
else
MFree_S(ptr);
}
void String::LFree()
{
if(IsRef()) {
if(ptr != VoidPtr()) {
Rc *rc = Ref();
ASSERT(rc->refcount > 0);
if(AtomicDec(rc->refcount) == 0) MFree(rc);
}
}
else
MFree_S(ptr);
}
void * MRealloc(void * oldBuf, uint32 newSize)
{
uint32 oldSize = oldBuf ? (*(((uint32*)oldBuf)-1)) : 0;
if (newSize == oldSize) return oldBuf;
else
{
void * newBuf = (newSize > 0) ? MMalloc(newSize) : NULL;
if ((newSize > 0)&&(newBuf == NULL)) return NULL; // out-of-memory error! Avoid side effects
if ((newBuf)&&(oldBuf)) memcpy(newBuf, oldBuf, (newSize<oldSize)?newSize:oldSize);
if (oldBuf) MFree(oldBuf);
return newBuf;
}
}
bool KheLayerParallelAssignTimes(KHE_LAYER layer)
{
ARRAY_KHE_LAYER_INFO layer_infos; KHE_LAYER_INFO layer_info;
KHE_LAYER layer2; KHE_NODE parent_node, child_node; int i, j;
bool res;
if( DEBUG2 )
fprintf(stderr, "[ KheLayerParallelAssignTimes(layer)\n");
/* get the layer_infos and sort them by decreasing no of preassigned meets */
MArrayInit(layer_infos);
parent_node = KheLayerParentNode(layer);
for( i = 0; i < KheNodeChildLayerCount(parent_node); i++ )
{
layer2 = KheNodeChildLayer(parent_node, i);
if( layer2 != layer )
MArrayAddLast(layer_infos, KheLayerInfoMake(layer2));
}
MArraySort(layer_infos, &KheLayerInfoCmp);
/* make parallel assignments for each layer_info in turn */
res = true;
MArrayForEach(layer_infos, &layer_info, &i)
for( j = 0; j < KheLayerChildNodeCount(layer_info->layer); j++ )
{
child_node = KheLayerChildNode(layer_info->layer, j);
if( KheNodeAssignedMeetCount(child_node) > 0 )
res &= KheNodeParallelAssignTimes(child_node, layer);
}
/* free the array of soln layer info objects and the objects themselves */
MArrayForEach(layer_infos, &layer_info, &j)
MFree(layer_info);
MArrayFree(layer_infos);
if( DEBUG2 )
fprintf(stderr, "] KheLayerParallelAssignTimes returning %s\n",
res ? "true" : "false");
return res;
}
static void FreeMMessageField(MMessageField * field)
{
if (field)
{
if (field->isFixedSize == MFalse)
{
/* Oops, this field has alloced-pointer semantics, so we have to free all the items too */
if (field->typeCode == B_MESSAGE_TYPE)
{
MMessage ** array = (MMessage **) field->data;
int32 i;
for (i=field->numItems-1; i>=0; i--) MMFreeMessage(array[i]);
}
else
{
MByteBuffer ** array = (MByteBuffer **) field->data;
int32 i;
for (i=field->numItems-1; i>=0; i--) MBFreeByteBuffer(array[i]);
}
}
MFree(field);
}
}
void KheSpreadSplitTaskFree(KHE_SPREAD_SPLIT_TASK st)
{
MFree(st);
}
void MBFreeByteBuffer(MByteBuffer * msg)
{
/* yup, it's that easy... but you should still always call this function */
/* instead of calling MFree() directly, in case the implementation changes later */
if (msg) MFree(msg);
}
void KheAssignedSplitTaskFree(KHE_ASSIGNED_SPLIT_TASK st)
{
MFree(st);
}
void KheLinkSplitTaskFree(KHE_LINK_SPLIT_TASK st)
{
MFree(st);
}
static MMessageField * CloneMMessageField(const MMessageField * cloneMe)
{
MMessageField * clone = (MMessageField *) MMalloc(cloneMe->allocSize);
if (clone)
{
memcpy(clone, cloneMe, cloneMe->isFixedSize ? cloneMe->allocSize : sizeof(MMessageField));
clone->prevField = clone->nextField = NULL;
clone->data = ((char *)clone) + (((char *)cloneMe->data)-((char *)cloneMe));
clone->name = ((const char *)clone) + (cloneMe->name-((const char *)cloneMe));
if (clone->isFixedSize == MFalse)
{
/* Oops, this field has alloced-pointer semantics, so we have to clone all the items too */
if (clone->typeCode == B_MESSAGE_TYPE)
{
MMessage ** dstArray = (MMessage **) clone->data;
const MMessage ** srcArray = (const MMessage **) cloneMe->data;
int32 i;
for (i=cloneMe->numItems-1; i>=0; i--)
{
if (srcArray[i])
{
if ((dstArray[i] = MMCloneMessage(srcArray[i])) == NULL)
{
/* Allocation failure! Roll back previous allocs and fail cleanly */
int32 j;
for (j=cloneMe->numItems-1; j>i; j--) MMFreeMessage(dstArray[j]);
MFree(clone);
return NULL;
}
}
else dstArray[i] = NULL;
}
}
else
{
MByteBuffer ** dstArray = (MByteBuffer **) clone->data;
const MByteBuffer ** srcArray = (const MByteBuffer **) cloneMe->data;
int32 i;
for (i=cloneMe->numItems-1; i>=0; i--)
{
if (srcArray[i])
{
if ((dstArray[i] = MBCloneByteBuffer(srcArray[i])) == NULL)
{
/* Allocation failure! Roll back previous allocs and fail cleanly */
int32 j;
for (j=cloneMe->numItems-1; j>i; j--) MBFreeByteBuffer(dstArray[j]);
MFree(clone);
return NULL;
}
}
else dstArray[i] = NULL;
}
}
/* copy the name too, since we didn't do it above */
memcpy((char *)clone->name, cloneMe->name, clone->nameBytes);
}
}
return clone;
}
