E_BOOL_TYPE Insert2List(PT_NODE ptHeadNode, char* tagName, char* content)
{
PT_NODE ptNode = NULL;
PT_NODE ptFirst = NULL;
ptNode = (PT_NODE) malloc(sizeof(T_NODE));
if ( ptNode == NULL )
{
return FAIL;
}
ptNode->tagName = (char*)dupstr(tagName);
if ( !ptNode->tagName )
{
FreeNode(&ptNode);
return FAIL;
}
ptNode->content = (char*)dupstr(content);
if ( !ptNode->content )
{
FreeNode(&ptNode);
return FAIL;
}
ptFirst = ptHeadNode->next;
ptHeadNode->next = ptNode;
ptNode->next = ptFirst;
return SUCCESS;
}
/*
** FreeNode() recursively frees a given node.
*/
void FreeNode(node *n) {
if (n->type != TGEN && n->type != TNUM) {
FreeNode(n->cont.op.l);
FreeNode(n->cont.op.r);
}
Free(n);
}
NODE * Mul( NODE *n1, NODE *n2 )
{
if( n1 == 0 ) return n2;
if( n2 == 0 ) return n1;
if( IsConst( n1, 1 ) ) {
n2->sign *= n1->sign;
FreeNode( n1 );
return n2;
}
if( IsConst( n2, 1 ) ) {
n2->sign *= n1->sign;
FreeNode( n2 );
return n1;
}
if( IsConst( n1, 0 ) ) {
FreeNode( n2 );
return n1;
}
if( IsConst( n2, 0 ) ) {
FreeNode( n1 );
return n2;
}
return BinaryOp( MUL, n1, n2 );
}
/**
* 算法2.21
*/
Status MergeList(LinkList &La, LinkList &Lb, LinkList &Lc,
int (*compare)(ElemType, ElemType))
{
Link ha, hb, pa, pb, q;
ElemType a, b;
if (!InitList(Lc))
return ERROR;
ha = GetHead(La);
hb = GetHead(Lb);
pa = NextPos(La, ha);
pb = NextPos(Lb, hb);
while (pa && pb) {
a = GetCurElem(pa);
b = GetCurElem(pb);
if (compare(a, b) <= 0) { // a<=b
DelFirst(ha, q);
Append(Lc, q);
pa = NextPos(La, ha);
} else { // a>b
DelFirst(hb, q);
Append(Lc, q);
pb = NextPos(Lb, hb);
}
} // while
if (pa)
Append(Lc, pa);
else
Append(Lc, pb);
FreeNode(ha);
FreeNode(hb);
return OK;
}
void RmSubst( NODE *n )
{
NODE *pn;
NODE *cn;
pn = 0;
cn = substList;
while( cn != 0 ) {
if( NodeCmp( n, cn ) )
break;
pn = cn;
cn = cn->left;
}
if( cn == 0 ) return;
FreeNode( cn->right );
if( pn )
pn->left = cn->left;
else
substList = cn->left;
cn->right = 0;
cn->left = 0;
FreeNode( cn );
}
//************************************************
// 删除一个节点，可以被派生类重载
//***********************************************
virtual void DeleteItem(HSTREEITEM hItem)
{
HSTREENODE hsNode= (HSTREENODE)hItem;
DUIASSERT(hsNode);
if(hsNode==STVN_ROOT)
{
FreeNode(STVN_ROOT);
m_hRootFirst=NULL;
m_hRootLast=NULL;
return;
}
STREENODE nodeCopy=*hsNode;
BOOL bRootFirst=hsNode==m_hRootFirst;
BOOL bRootLast=hsNode==m_hRootLast;
FreeNode(hsNode);
if(nodeCopy.hPrevSibling)//has prevsibling
nodeCopy.hPrevSibling->hNextSibling=nodeCopy.hNextSibling;
else if(nodeCopy.hParent)//parent's first child
nodeCopy.hParent->hChildFirst=nodeCopy.hNextSibling;
if(nodeCopy.hNextSibling)// update next sibling's previous sibling
nodeCopy.hNextSibling->hPrevSibling=nodeCopy.hPrevSibling;
else if(nodeCopy.hParent)//parent's last child
nodeCopy.hParent->hChildLast=nodeCopy.hPrevSibling;
//update root item
if(bRootFirst) m_hRootFirst=nodeCopy.hNextSibling;
if(bRootLast) m_hRootLast=nodeCopy.hPrevSibling;
}
void SortPolyn(polynomail *p) {
Link *p1, *p2; //采用直接插入排序
for (p1 = p->head->next; p1; p1 = p1->next) {
for (p2 = p->head->next; p2 != p1; p2 = p2->next) {
if (p2->data->expn == p1->data->expn) { //若后边待排序的节点的指数跟前面已排序
Link *pri; //节点的指数相同，则应该合并两项，即删除后者，并入前者
p2->data->coef += p1->data->coef;
pri = PriorPos(*p, p1);
DelFirst(pri, &p1);
FreeNode(p1);
--p->len;
if (fabs(p2->data->coef) < 1e-6) { //如果合并后系数为0，那也要把这个节点删除
pri = PriorPos(*p, p2);
DelFirst(pri, &p2);
FreeNode(p2);
--p->len;
}
p1 = pri;
break;
}
else if (p1->data->expn < p2->data->expn) {
Link *pri1, *pri2;
pri1 = PriorPos(*p, p1);
DelFirst(pri1, &p1);
pri2 = PriorPos(*p, p2);
InsFirst(pri2, p1);
p1 = pri1;
break;
}
}
}
p->tail = GetLast(*p);
}
/* Get the identity-based hash value for an object reference at *v. This may
cause the object to move, thus updating *v. */
AValue AGetIdHashValue(AThread *t, AValue *v)
{
void *p = AValueToPtr(*v);
HashMappingTable *table;
AValue hash;
if (AIsInNursery(p))
table = &NewGenTable;
else
table = &OldGenTable;
ALockHashMappings();
hash = GetHashMapping(table, p);
if (AIsError(hash)) {
/* Could not find a mapping -- insert a new hash mapping. */
int i;
HashValueNode *n;
/* Allocate a new hash node. Note that this may cause the object to be
moved, but we'll handle that case later. */
n = AllocNode(p);
if (n == NULL) {
/* Out of memory. */
AUnlockHashMappings();
return ARaiseMemoryErrorND(t);
}
/* Check if it is time to grow the hash table. This may cause the
object to be moved. */
if (table->num > table->size) {
if (!GrowHashTable(table)) {
/* Out of memory. */
FreeNode(n);
AUnlockHashMappings();
return ARaiseMemoryErrorND(t);
}
}
/* If the target value moved to the old generation, try again. */
if (p != AValueToPtr(*v)) {
FreeNode(n);
AUnlockHashMappings();
return AGetIdHashValue(t, v);
}
/* Calculate hash value for the internal hash table. */
i = PtrHashValue(p) & (table->size - 1);
/* Initialize the new table entry. */
n->next = table->table[i];
table->num++;
table->table[i] = n;
hash = n->hashValue;
}
AUnlockHashMappings();
return hash;
}
void FreeNode( NODE * n )
{
if( n == 0 ) return;
FreeNode( n->left );
FreeNode( n->right );
if( n->elm ) free( n->elm );
free( n );
}
void b2DynamicTree::RemoveLeaf(int32 leaf)
{
if (leaf == m_root)
{
m_root = b2_nullNode;
return;
}
int32 parent = m_nodes[leaf].parent;
int32 grandParent = m_nodes[parent].parent;
int32 sibling;
if (m_nodes[parent].child1 == leaf)
{
sibling = m_nodes[parent].child2;
}
else
{
sibling = m_nodes[parent].child1;
}
if (grandParent != b2_nullNode)
{
// Destroy parent and connect sibling to grandParent.
if (m_nodes[grandParent].child1 == parent)
{
m_nodes[grandParent].child1 = sibling;
}
else
{
m_nodes[grandParent].child2 = sibling;
}
m_nodes[sibling].parent = grandParent;
FreeNode(parent);
// Adjust ancestor bounds.
int32 index = grandParent;
while (index != b2_nullNode)
{
index = Balance(index);
int32 child1 = m_nodes[index].child1;
int32 child2 = m_nodes[index].child2;
m_nodes[index].aabb.Combine(m_nodes[child1].aabb, m_nodes[child2].aabb);
m_nodes[index].height = 1 + b2Max(m_nodes[child1].height, m_nodes[child2].height);
index = m_nodes[index].parent;
}
}
else
{
m_root = sibling;
m_nodes[sibling].parent = b2_nullNode;
FreeNode(parent);
}
//Validate();
}
void b2DynamicTree::RemoveLeaf(int32 leaf)
{
if (leaf == m_root)
{
m_root = b2_nullNode;
return;
}
int32 node2 = m_nodes[leaf].parent;
int32 node1 = m_nodes[node2].parent;
int32 sibling;
if (m_nodes[node2].child1 == leaf)
{
sibling = m_nodes[node2].child2;
}
else
{
sibling = m_nodes[node2].child1;
}
if (node1 != b2_nullNode)
{
// Destroy node2 and connect node1 to sibling.
if (m_nodes[node1].child1 == node2)
{
m_nodes[node1].child1 = sibling;
}
else
{
m_nodes[node1].child2 = sibling;
}
m_nodes[sibling].parent = node1;
FreeNode(node2);
// Adjust ancestor bounds.
while (node1 != b2_nullNode)
{
b2AABB oldAABB = m_nodes[node1].aabb;
m_nodes[node1].aabb.Combine(m_nodes[m_nodes[node1].child1].aabb, m_nodes[m_nodes[node1].child2].aabb);
if (oldAABB.Contains(m_nodes[node1].aabb))
{
break;
}
node1 = m_nodes[node1].parent;
}
}
else
{
m_root = sibling;
m_nodes[sibling].parent = b2_nullNode;
FreeNode(node2);
}
}
/**
* Read multiplexer information from the .xml transistor characteristics.
* This contains the estimates of mux output voltages, depending on 1) Mux Size 2) Mux Vin
* */
static void power_tech_xml_load_multiplexer_info(ezxml_t parent) {
ezxml_t child, prev, gc;
int num_mux_sizes;
int i, j;
/* Process all multiplexer sizes */
num_mux_sizes = CountChildren(parent, "multiplexer", 1);
/* Add entries for 0 and 1, for convenience, although
* they will never be used
*/
g_power_tech->max_mux_sl_size = 1 + num_mux_sizes;
g_power_tech->mux_voltage_inf = (t_power_mux_volt_inf*) my_calloc(
g_power_tech->max_mux_sl_size + 1, sizeof(t_power_mux_volt_inf));
child = FindFirstElement(parent, "multiplexer", TRUE);
i = 1;
while (child) {
int num_voltages;
assert(i == GetFloatProperty(child, "size", TRUE, 0));
/* For each mux size, process all of the Vin levels */
num_voltages = CountChildren(child, "voltages", 1);
g_power_tech->mux_voltage_inf[i].num_voltage_pairs = num_voltages;
g_power_tech->mux_voltage_inf[i].mux_voltage_pairs =
(t_power_mux_volt_pair*) my_calloc(num_voltages,
sizeof(t_power_mux_volt_pair));
gc = FindFirstElement(child, "voltages", TRUE);
j = 0;
while (gc) {
/* For each mux size, and Vin level, get the min/max V_out */
g_power_tech->mux_voltage_inf[i].mux_voltage_pairs[j].v_in =
GetFloatProperty(gc, "in", TRUE, 0.0);
g_power_tech->mux_voltage_inf[i].mux_voltage_pairs[j].v_out_min =
GetFloatProperty(gc, "out_min", TRUE, 0.0);
g_power_tech->mux_voltage_inf[i].mux_voltage_pairs[j].v_out_max =
GetFloatProperty(gc, "out_max", TRUE, 0.0);
prev = gc;
gc = gc->next;
FreeNode(prev);
j++;
}
prev = child;
child = child->next;
FreeNode(prev);
i++;
}
}
void palProfiler::FreeNode(palProfilerNode* node) {
if (node->child) {
palProfilerNode* sibling_node = node->child->sibling;
while (sibling_node != NULL) {
palProfilerNode* next = sibling_node->sibling;
FreeNode(sibling_node);
sibling_node = next;
}
FreeNode(node->child);
}
if (node != &root_) {
_profile_proxy_allocator->Destruct(node);
}
}
void MkSubst( NODE *n1, NODE *n2 )
{
NODE *n;
n = LookUpSubst( n1 );
if( n == 0 ) {
n = n1;
n->left = substList;
substList = n;
} else {
FreeNode( n->right );
FreeNode( n1 );
}
n->right = n2;
}
NODE * Sub( NODE *n1, NODE *n2 )
{
if( n1 == 0 ) return BinaryOp( SUB, 0, n2 );
if( n2 == 0 ) return n1;
if( IsConst( n1, 0 ) ) {
FreeNode( n1 );
return BinaryOp( SUB, 0, n2 );
}
if( IsConst( n2, 0 ) ) {
FreeNode( n2 );
return n1;
}
return BinaryOp( SUB, n1, n2 );
}
NODE * Add( NODE *n1, NODE *n2 )
{
if( n1 == 0 ) return n2;
if( n2 == 0 ) return n1;
if( IsConst( n1, 0 ) ) {
FreeNode( n1 );
return n2;
}
if( IsConst( n2, 0 ) ) {
FreeNode( n2 );
return n1;
}
return BinaryOp( ADD, n1, n2 );
}
//删除树节点,到此时的树节点，最多只有一个孩子,而且是左孩子
void DeleteTreeNode(TreePtr tree,TreeNodePtr node)
{
TreeNodePtr brother = NULL;
TreeNodePtr child = NULL;
TreeNodePtr parent = NULL;
parent = node->parent;
child = (NULL == node->left) ? node->right : node->left;
//child = node->left;
//没有父节点和子女节点,是唯一一个节点,case 1
if ((NULL == child) && (NULL == parent))
{
SetRootNode(tree,NULL);
}
else if ((NULL != child) && (NULL == parent))
{
//只有一个孩子节点,没有父节点,case 2
SetRootNode(tree,child);
}
else if ((NULL == child) && (NULL != parent))
{
//没有孩子节点,有父节点
if (node == parent->left)
{
SetLeftChild(parent,NULL);//child = NULL
}
else
{
SetRightChild(parent,NULL);//child = NULL
}
/*
if (BlackNode == node->color)
{
DeleteNodeFix(tree,node);
}
*/
}
else
{
//有孩子节点,有父节点
if (node == parent->left)
{
SetLeftChild(parent,child);//child = NULL
}
else
{
SetRightChild(parent,child);//child = NULL
}
//N=B但是P=R,C=R时，需要将孩子节点设置为黑色
child->color = BlackNode;
if (BlackNode == node->color)
{
//这个节点已经代替了node的位置
DeleteNodeFix(tree,child);
}
}
FreeNode(tree,node);
}
void H2_3D_Tree::FreeNode(nodeT *A) {
int i;
// Free all child nodes first
for (i=0;i<8;i++) {
if (A->leaves[i] != NULL) {
FreeNode(A->leaves[i]);
}
}
// Free the arrays for the field and source values
if (A->fieldval != NULL)
free(A->fieldval), A->fieldval=NULL;
if (A->sourceval != NULL)
free(A->sourceval), A->sourceval=NULL;
if (A->proxysval != NULL)
free(A->proxysval), A->proxysval=NULL;
if (A->sourcefre != NULL)
free(A->sourcefre), A->sourcefre=NULL;
// Free the field and source lists
if (A->fieldlist != NULL)
free(A->fieldlist), A->fieldlist=NULL;
if (A->sourcelist != NULL)
free(A->sourcelist), A->sourcelist=NULL;
// Last free the node
free(A);
}
H2_3D_Tree::~H2_3D_Tree() {
if (tree != NULL) {
FreeNode(tree);
tree = NULL;
}
if (Kweights!= NULL) {
free(Kweights);
Kweights = NULL;
}
if (Cweights!= NULL) {
free(Cweights);
Cweights = NULL;
}
if (Tkz!= NULL) {
free(Tkz);
Tkz = NULL;
}
if (K!= NULL) {
free(K);
K = NULL;
}
if (U!= NULL) {
free(U);
U = NULL;
}
if (VT!= NULL) {
free(VT);
VT = NULL;
}
dof = NULL;
}
/**
* {{{ 删除列表
*/
int DeleteNode(Link to_delete)
{
Link curr, prev;
int i;
if (Head == NULL)
return 0;
for (prev = NULL, curr = Head; curr != NULL && (i = NodeCmp(to_delete, curr)) > 0; prev = curr, curr = curr->Next) {
// empty loop
}
if (curr != NULL && i == 0) {
if (prev) {
prev->Next = curr->Next;
} else {
Head = curr->Next;
}
FreeNode(curr);
NodeCount -= 1;
return 1;
}
return 0;
}
bool CudaAllocBuckets::Free(void* p) {
AddressMap::iterator it = _addressMap.find(p);
if(it == _addressMap.end()) {
// If the pointer was not found in the address map, cudaFree it anyways
// but return false.
if(p) cudaFree(p);
return false;
}
// Because we're freeing a page, it had better not be in the priority queue.
MemList::iterator memIt = it->second;
assert(memIt->priority == _priorityMap.end());
// Always free allocations larger than the largest bucket
if(NumBuckets == memIt->bucket)
FreeNode(memIt);
else {
it->second->priority = _priorityMap.insert(
std::make_pair(_counter++ - memIt->bucket, memIt));
// Freed nodes are moved to the front, committed nodes are moved to the
// end.
MemList& list = _memLists[memIt->bucket];
list.splice(list.begin(), list, memIt);
_committed -= BucketSizes[memIt->bucket];
}
Compact(0);
return true;
}
void CPtrList::RemoveAt(POSITION position)
{
ASSERT_VALID(this);
CNode* pOldNode = (CNode*) position;
ASSERT(AfxIsValidAddress(pOldNode, sizeof(CNode)));
if (pOldNode == NULL)
{
AfxThrowInvalidArgException();
}
// remove pOldNode from list
if (pOldNode == m_pNodeHead)
{
m_pNodeHead = pOldNode->pNext;
}
else
{
ASSERT(AfxIsValidAddress(pOldNode->pPrev, sizeof(CNode)));
pOldNode->pPrev->pNext = pOldNode->pNext;
}
if (pOldNode == m_pNodeTail)
{
m_pNodeTail = pOldNode->pPrev;
}
else
{
ASSERT(AfxIsValidAddress(pOldNode->pNext, sizeof(CNode)));
pOldNode->pNext->pPrev = pOldNode->pPrev;
}
FreeNode(pOldNode);
}
/* This function prints a URL to glycam online carbohydrate builder
generating a 3D structure (e.g. PDB) of the specified structure.
SYNTAX: print3D <str> */
int BU_PrintStruct3DLink()
{
struct BU_Struct *str;
struct VA_Variable *var;
PA_GetString;
str=(struct BU_Struct *)
FindNode(&(StructList.Head), PA_Result.String);
if(!str)
{
Error(PA_ERR_FAIL,"Structure not found");
}
var=(struct VA_Variable *)FindNode(&(VariableList.Head), "Print3D");
if (var==NULL)
{
var=(struct VA_Variable *)ME_CreateNode(&VariableMethod,&VariableList, "Print3D");
}
var->Value.Value.Float=1;
var->Value.Type=PA_FLOAT;
printf("http://www.glycam.com/CCRC/carbohydrates/cb_cnpSequences.jsp?projectName=casper&text1=");
GFX_StructGfx(str, NULL, 0);
FreeNode((struct Node *)var);
return (PA_ERR_OK);
}
void CudaAllocBuckets::Compact(size_t extra) {
while(_allocated + extra > _capacity && _allocated > _committed) {
// Walk the priority queue from beginning to end removing nodes.
MemList::iterator memIt = _priorityMap.begin()->second;
FreeNode(memIt);
}
}
main()
{
DList *plist = NULL;
PNode p = NULL;
plist = InitList();
p = InsFirst(plist,MakeNode(1));
InsBefore(plist,p,MakeNode(2));
InsAfter(plist,p,MakeNode(3));
printf("p前驱位置的值为%d\n",GetItem(GetPrevious(p)));
printf("p位置的值为%d\n",GetItem(p));
printf("p后继位置的值为%d\n",GetItem(GetNext(p)));
printf("遍历输出各节点数据项:\n");
ListTraverse(plist,print);
printf("除了头节点该链表共有%d个节点\n",GetSize(plist));
FreeNode(DelFirst(plist));
printf("删除第一个节点后重新遍历输出为:\n");
ListTraverse(plist,print);
printf("除了头节点该链表共有%d个节点\n",GetSize(plist));
DestroyList(plist);
printf("链表已被销毁\n");
}
/**
* Read NMOS subthreshold leakage currents from the .xml transistor characteristics
* This builds a table of (Vds,Ids) value pairs
* */
static void power_tech_xml_load_nmos_st_leakages(ezxml_t parent) {
ezxml_t child, prev;
int num_leakage_pairs;
int i;
num_leakage_pairs = CountChildren(parent, "nmos_leakage", 1);
g_power_tech->num_leakage_pairs = num_leakage_pairs;
g_power_tech->leakage_pairs = (t_power_nmos_leakage_pair*) my_calloc(
num_leakage_pairs, sizeof(t_power_nmos_leakage_pair));
child = FindFirstElement(parent, "nmos_leakage", TRUE);
i = 0;
while (child) {
g_power_tech->leakage_pairs[i].v_ds = GetFloatProperty(child, "Vds",
TRUE, 0.0);
g_power_tech->leakage_pairs[i].i_ds = GetFloatProperty(child, "Ids",
TRUE, 0.0);
prev = child;
child = child->next;
FreeNode(prev);
i++;
}
}
Status DestroyList(LinkList *L)
{ /* 销毁线性链表L，L不再存在 */
ClearList(L); /* 清空链表 */
FreeNode(&(*L).head);
(*L).tail=NULL;
(*L).len=0;
return OK;
}
void b2DynamicTree::DestroyProxy(int32 proxyId)
{
b2Assert(0 <= proxyId && proxyId < m_nodeCapacity);
b2Assert(m_nodes[proxyId].IsLeaf());
RemoveLeaf(proxyId);
FreeNode(proxyId);
}
static Status DestroyList(LinkList &L)
{ // 销毁线性链表L，L不再存在
ClearList(L); // 清空链表
FreeNode(L.head);
L.tail=NULL;
L.len=0;
return OK;
}
void FreeHash(HashList* list, int tableSize)
{
int i;
for (i = 0; i < tableSize; i++)
{
FreeNode(list[i]);
}
}
