void FreeTree(Node *p){
if(p == NULL) return;
FreeTree(p->left);
FreeTree(p->right);
printf("Free '%s/%s'\n", p->path, p->name);
free(p->name);
free(p->path);
free(p);
}
static void
FreeTree(DBexprnode *tree)
{
if (!tree)
return;
FreeTree(tree->left);
FreeTree(tree->right);
free(tree);
}
//-------------------------------------------------------------------------
static void LoadLocals(WATCHDATA *ptr)
{
NAMELIST *names = FindEnclosedAutos(activeScope);
WATCHINFO *p = ptr->watchinfo_list;
int i;
for (i=0; i < ptr->watchinfo_count; i++)
if (!strcmp(ptr->watchinfo_list[i].info->membername, "this"))
{
WATCHINFO *x = &ptr->watchinfo_list[i];
int j;
FreeTree(x->info, ptr);
FreeVarInfo(x->info);
for (j = i; j < ptr->watchinfo_count - 1; j++)
{
ptr->watchinfo_list[j] = ptr->watchinfo_list[j + 1];
RenumberDeleteItems(ptr->watchinfo_list[j].info);
}
ptr->watchinfo_count--;
i--;
}
else
{
p[i].marked = TRUE;
}
while (names)
{
NAMELIST *next = names->next;
DEBUG_INFO *dbg;
VARINFO *var = EvalExpr(&dbg, activeScope, (char*) names->data+1, FALSE);
if (var)
{
AddItem(dbg, var, activeScope->address, ptr);
}
free(names->data);
free(names);
names = next;
}
p = ptr->watchinfo_list;
for (i=0; i < ptr->watchinfo_count; i++)
if (p[i].marked)
{
WATCHINFO *x = &ptr->watchinfo_list[i];
int j;
FreeTree(x->info, ptr);
FreeVarInfo(x->info);
for (j = i; j < ptr->watchinfo_count - 1; j++)
{
ptr->watchinfo_list[j] = ptr->watchinfo_list[j + 1];
RenumberDeleteItems(ptr->watchinfo_list[j].info);
}
ptr->watchinfo_count--;
i--;
}
}
void
PairHeap<Etype>::FreeTree( PairNode<Etype> * T )
{
if( T != NULL )
{
FreeTree( T->NextSibling );
FreeTree( T->LeftChild );
delete T;
}
}
void
AATree<Etype>::FreeTree( BinaryNode<Etype> * T )
{
if( T != NullNode )
{
FreeTree( T->Left );
FreeTree( T->Right );
delete T;
}
}
static void FreeTree( ExprTree& node )
{
if(!node)
return;
FreeTree(node->left);
FreeTree(node->right);
FreeNode(node);
node = 0;
}
void FreeTree(TreeNode *node) {
if (node->child != NULL) {
FreeTree(node->child);
}
if (node->peer != NULL) {
FreeTree(node->peer);
}
if (node->page != NULL) {
free(node->page);
}
free(node);
}
static void
FreeTree(struct export_tree *tree)
{
if (tree) {
if (tree->node) {
FreeExportNode(tree->node);
}
FreeTree(tree->left);
FreeTree(tree->right);
free(tree);
}
}
void FreeTree(HuffmanTreeNode **pTreeHead)
{
if(*pTreeHead != NULL)
{
if((*pTreeHead)->leftChild != NULL)
FreeTree(&((*pTreeHead)->leftChild));
if((*pTreeHead)->rightChild != NULL)
FreeTree(&((*pTreeHead)->rightChild));
free(*pTreeHead);
*pTreeHead = NULL;
}
}
void FreeTree( pNode * proot )
{
#define root (*proot)
if( proot == NULL || root == NULL ) {
return;
}
FreeTree( &(root->Left) );
FreeTree( &(root->Right) );
delete root;
root = NULL;
#undef root
}
void FreeTree(NODE *pNode)
{
if (pNode != NULL)
/* if child exists */
{
FreeTree(pNode->left);
/* traverse left */
FreeTree(pNode->right);
/* traverse right */
free(pNode->strng);
/* free the string */
free(pNode);
/* free the node */
}
}
static void DeleteItem(POINT *pt, WATCHDATA *ptr)
{
int i;
WATCHINFO *x;
TV_HITTESTINFO t;
HTREEITEM titem;
TV_ITEM item;
VARINFO *v;
ScreenToClient(ptr->hwndWatchTree, pt);
t.pt = *pt;
titem = TreeView_HitTest(ptr->hwndWatchTree, &t);
if (titem)
{
int c;
item.mask = TVIF_PARAM;
item.hItem = titem;
TreeView_GetItem(ptr->hwndWatchTree, &item);
v = (VARINFO*)item.lParam;
x = &ptr->watchinfo_list[c = v->watchindex];
FreeTree(x->info, ptr);
FreeVarInfo(x->info);
for (i = c; i < ptr->watchinfo_count - 1; i++)
{
ptr->watchinfo_list[i] = ptr->watchinfo_list[i + 1];
RenumberDeleteItems(ptr->watchinfo_list[i].info);
}
ptr->watchinfo_count--;
}
}
int main(void) {
Menu menu;
BinNode *root;
root = NULL;
do {
BinNode x;
switch (menu = SelectMenu()) {
case Insert :x = Read("Insert");
root = ApndNode(root,&x);break;
case Search: x = Read("Search");
SrchNode(root,&x); break;
case Print: puts("----------------");
PrintTree(root); break;
case PrintSub:
x = Read("Insert");
puts("----------------");
PrintSubTree(root, &x); break;
}
} while (menu != Term);
FreeTree(root);
return(0);
}
void ExpandPointer(VARINFO *v, int code, int page)
{
if (v->pointer)
{
if (code == TVE_EXPAND)
{
int val;
int outofscope = (val = v->derefaddress) == -1 && !ReadValue(v->address, &val, 4, v) || !val;
if (!v->subtype && watchinfo_list[page][v->watchindex].dbg_info)
{
TreeView_DeleteItem(hwndTree[page], v->hTreeHolder);
ExpandPointerInfo(watchinfo_list[page][v->watchindex].dbg_info, v);
if (v->subtype->structure)
{
InsertSubTree(v->hTreeItem, 0, v->subtype->subtype, v->watchindex, page);
}
else
InsertSubTree(v->hTreeItem, 0, v->subtype, v->watchindex, page);
}
RefreshAddresses(v->subtype, val, NULL, outofscope);
RefreshData(watchinfo_list[page][v->watchindex].dbg_info, v);
}
else if (code == TVE_COLLAPSE)
{
if (v->subtype)
{
FreeTree(v->subtype, page);
FreeVarInfo(v->subtype);
v->subtype = 0;
v->hTreeHolder = InsertItem(v->hTreeItem, TVI_LAST, v, page);
}
}
}
}
int main(int argc, char **argv){
DIR *d;
tree = malloc(sizeof(Node));
tree->left = NULL;
tree->right = NULL;
tree->path = NULL;
tree->name = NULL;
duplicates = malloc(sizeof(Duplicate));
duplicates->df = NULL;
duplicates->next = NULL;
d = opendir(".");
if(d != NULL){
FindFilePath(d, ".", 0);
}
else {
perror("Kluda direktorijas atversana: ");
return -1;
}
d = NULL;
PrintTreePreOrder(tree);
FreeTree(tree);
PrintDuplicates();
tree = NULL;
return 0;
}
/*
* ProcessSubModel
*/
static void ProcessSubModel(void){
entity_t *e;
int start, end;
tree_t *tree;
bsp_brush_t *list;
vec3_t mins, maxs;
e = &entities[entity_num];
start = e->first_brush;
end = start + e->num_brushes;
mins[0] = mins[1] = mins[2] = -MAX_WORLD_WIDTH;
maxs[0] = maxs[1] = maxs[2] = MAX_WORLD_WIDTH;
list = MakeBspBrushList(start, end, mins, maxs);
if(!nocsg)
list = ChopBrushes(list);
tree = BrushBSP(list, mins, maxs);
MakeTreePortals(tree);
MarkVisibleSides(tree, start, end);
MakeFaces(tree->head_node);
FixTjuncs(tree->head_node);
WriteBSP(tree->head_node);
FreeTree(tree);
}
KeyTextList* LoadKeyTextList(gchar* filename)
{
KeyTextList* list;
gchar* pathname = NULL;
if( !g_keytext_dir || !filename )
return NULL;
if( (pathname = CheckFileExists(g_keytext_dir, filename)) == NULL )
if( (pathname = CheckFileExists("keytext", filename)) == NULL )
return NULL;
list = (KeyTextList*)g_malloc(sizeof(KeyTextList));
if( list != NULL )
{
if( (list->tree = CreateTree()) != NULL )
{
if( ReadXMLFile(pathname, list->tree) )
{
return list;
}
FreeTree(list->tree);
}
g_free(list);
}
return NULL;
}
void FreeTree(UINode* node)
{
if (node == NULL)
{
free(node);
return;
}
if (node->children != NULL){
for (int i = 0; i < node->childrenCount; i++)
{
FreeTree(node->children[i]);
}
}
FreeControl(node->control);
node->control = NULL;
free(node->children);
node->children = NULL;
node->childrenCount = 0;
node->childrenSize = 0;
node->father = NULL;
node->root = NULL;
free(node);
}
void DeleteItem(POINT *pt, int page)
{
int i;
WATCHINFO *x;
TV_HITTESTINFO t;
HTREEITEM titem;
TV_ITEM item;
VARINFO *v;
ScreenToClient(hwndTree[page], pt);
t.pt = *pt;
titem = TreeView_HitTest(hwndTree[page], &t);
if (titem)
{
int c;
item.mask = TVIF_PARAM;
item.hItem = titem;
TreeView_GetItem(hwndTree[page], &item);
v = (VARINFO*)item.lParam;
x = &watchinfo_list[page][c = v->watchindex];
FreeTree(x->info, page);
FreeVarInfo(x->info);
for (i = c; i < watchinfo_count[page] - 1; i++)
{
watchinfo_list[page][i] = watchinfo_list[page][i + 1];
RenumberDeleteItems(watchinfo_list[page][i].info);
}
watchinfo_count[page]--;
}
}
/*
================
FreeDMapFile
================
*/
void FreeDMapFile( void )
{
int i, j;
FreeBrush( buildBrush );
buildBrush = NULL;
// free the entities and brushes
for( i = 0; i < dmapGlobals.num_entities; i++ )
{
uEntity_t *ent;
primitive_t *prim, *nextPrim;
ent = &dmapGlobals.uEntities[i];
FreeTree( ent->tree );
// free primitives
for( prim = ent->primitives; prim; prim = nextPrim )
{
nextPrim = prim->next;
if( prim->brush )
{
FreeBrush( prim->brush );
}
if( prim->tris )
{
FreeTriList( prim->tris );
}
Mem_Free( prim );
}
// free area surfaces
if( ent->areas )
{
for( j = 0; j < ent->numAreas; j++ )
{
uArea_t *area;
area = &ent->areas[j];
FreeOptimizeGroupList( area->groups );
}
Mem_Free( ent->areas );
}
}
Mem_Free( dmapGlobals.uEntities );
dmapGlobals.num_entities = 0;
// free the map lights
for( i = 0; i < dmapGlobals.mapLights.Num(); i++ )
{
R_FreeLightDefDerivedData( &dmapGlobals.mapLights[i]->def );
}
dmapGlobals.mapLights.DeleteContents( true );
}
void FreeTree(Tree *t) {
Tree *b;
while(t->branches) {b=t->branches; t->branches=b->next; FreeTree(b);}
free(t);
}
void destroyTree(int *result) {
error=OK;
if(current) {FreeTree(current); current=NULL;}
*result=error;
}
// Free entire parse tree, using this node as the root
void FreeTree(struct tree_node* pNode)
{
// Recursively free any non-NULL operands
if (pNode != NULL)
{
int i;
FreeTree(pNode->pNextStatement);
for (i = 0; i < pNode->numOperands; i++)
FreeTree(pNode->operands[i]);
free(pNode->operands);
if (pNode->sval != NULL)
free(pNode->sval);
free(pNode);
}
}
void FreeTree(VARINFO *info, int page)
{
while (info)
{
FreeTree(info->subtype, page);
if (info->hTreeItem)
TreeView_DeleteItem(hwndTree[page], info->hTreeItem);
info = info->link;
}
}
static void FreeTree(VARINFO *info, WATCHDATA *ptr)
{
while (info)
{
FreeTree(info->subtype, ptr);
if (info->hTreeItem)
TreeView_DeleteItem(ptr->hwndWatchTree, info->hTreeItem);
info = info->link;
}
}
/*
============
ProcessSubModel
============
*/
void ProcessSubModel( void ) {
entity_t *e;
tree_t *tree;
bspbrush_t *b, *bc;
node_t *node;
BeginModel ();
e = &entities[entity_num];
e->firstDrawSurf = numMapDrawSurfs;
PatchMapDrawSurfs( e );
// just put all the brushes in an empty leaf
// FIXME: patches?
node = AllocNode();
node->planenum = PLANENUM_LEAF;
for ( b = e->brushes ; b ; b = b->next ) {
bc = CopyBrush( b );
bc->next = node->brushlist;
node->brushlist = bc;
}
tree = AllocTree();
tree->headnode = node;
ClipSidesIntoTree( e, tree );
// subdivide each drawsurf as required by shader tesselation or fog
if ( !nosubdivide ) {
SubdivideDrawSurfs( e, tree );
}
// merge together all common shaders on the same plane and remove
// all colinear points, so extra tjunctions won't be generated
if ( !nomerge ) {
MergeSides( e, tree ); // !@# testing
}
// add in any vertexes required to fix tjunctions
if ( !notjunc ) {
FixTJunctions( e );
}
// allocate lightmaps for faces and patches
AllocateLightmaps( e );
// add references to the final drawsurfs in the apropriate clusters
FilterDrawsurfsIntoTree( e, tree );
EndModel ( node );
FreeTree( tree );
}
void FreeTree(WORD *W)
{
if(NULL != W)
{
if(NULL != W->Word)
{
free(W->Word);
W->Word = NULL;
}
if(NULL != W->Left)
{
FreeTree(W->Left);
W->Left = NULL;
}
if(NULL != W->Right)
{
FreeTree(W->Right);
W->Right = NULL;
}
}
}
/*
============
ProcessSubModel
============
*/
void ProcessSubModel( )
{
entity_t *e;
int start, end;
tree_t *tree;
bspbrush_t *list;
Vector mins, maxs;
e = &entities[entity_num];
start = e->firstbrush;
end = start + e->numbrushes;
mins[0] = mins[1] = mins[2] = MIN_COORD_INTEGER;
maxs[0] = maxs[1] = maxs[2] = MAX_COORD_INTEGER;
list = MakeBspBrushList (start, end, mins, maxs, FULL_DETAIL);
if (!nocsg)
list = ChopBrushes (list);
tree = BrushBSP (list, mins, maxs);
// This would wind up crashing the engine because we'd have a negative leaf index in dmodel_t::headnode.
if ( tree->headnode->planenum == PLANENUM_LEAF )
{
const char *pClassName = ValueForKey( e, "classname" );
const char *pTargetName = ValueForKey( e, "targetname" );
Error( "bmodel %d has no head node (class '%s', targetname '%s')", entity_num, pClassName, pTargetName );
}
MakeTreePortals (tree);
#if DEBUG_BRUSHMODEL
if ( entity_num == DEBUG_BRUSHMODEL )
WriteGLView( tree, "tree_all" );
#endif
MarkVisibleSides (tree, start, end, FULL_DETAIL);
MakeFaces (tree->headnode);
FixTjuncs( tree->headnode, NULL );
WriteBSP( tree->headnode, NULL );
#if DEBUG_BRUSHMODEL
if ( entity_num == DEBUG_BRUSHMODEL )
{
WriteGLView( tree, "tree_vis" );
WriteGLViewFaces( tree, "tree_faces" );
}
#endif
FreeTree (tree);
}
void GetFileHuffmanCode(FILE *fp, DataCode dataCodeArr[CODE_SIZE])
{
HuffmanTreeNode *pTreeHead = NULL;
UINT freqArr[CODE_SIZE];
UCHAR code[CODE_SIZE];
GetDataFreq(fp, freqArr);
BuildHuffmanTree(&pTreeHead, freqArr);
memset(dataCodeArr, 0, sizeof(DataCode) * CODE_SIZE);
memset(code, 0, UCHAR_SIZE * CODE_SIZE);
GetHuffmanCode(pTreeHead, code, 0, dataCodeArr);
FreeTree(&pTreeHead);
}
void buildTreeFromPhylo(
int *lowerNodes,
int *upperNodes,
double *edgeLengths,
int *nedges,
char **tipLabels,
int *ntips,
int *result
) {
error=OK;
if(current) {FreeTree(current); current=NULL;}
if(*nedges<2||*ntips<2) {error=ERROR; *result=error; return;}
current=buildTreeFromPhylo_(-1,lowerNodes,upperNodes,edgeLengths,*nedges,tipLabels,*ntips);
if(error&¤t) {FreeTree(current); current=NULL;}
*result=error;
}
