void free_tree_node(struct t_node *root) {
if(root) {
struct t_node *temp = root;
free_tree_node(temp->left);
free_tree_node(temp->right);
free(temp);
}
}
void tree_remove_node(TREE_ROOT *root, TREE_NODE *node)
{
int asize = BALIGN(sizeof(TREE_NODE));
node->parent->child.remove(node);
if ((root->mem->mem - asize) == (char *)node) {
free_tree_node(root);
} else {
Dmsg0(0, "Can't release tree node\n");
}
}
void free_tree(tree_node* tree_head)
{
tree_node* next_t_n = NULL;
if(tree_head == NULL)
return;
next_t_n = tree_head->next;
free_tree(tree_head->childs_p[0]);
free_tree(tree_head->childs_p[1]);
free_tree(tree_head->childs_p[2]);
free_tree_node(tree_head);
free_tree(next_t_n);
}
static char *test_insert_new_entry()
{
struct tree_node *node = NULL;
char *word = "New entry";
insert(word, 1, &node);
mu_assert("Error: new element not added", node != NULL);
mu_assert("New entry has NULL word", node->word != NULL);
mu_assert("New entry has wrong word", strcmp(word, node->word) == 0);
mu_assert("No reference created", node->references != NULL);
mu_assert("Reference has wrong line", node->references->line == 1);
mu_assert("Reference has wrong count", node->references->count == 1);
mu_assert("New entry has non-null left leaf", node->left == NULL);
mu_assert("New entry has non-null right leaf", node->right == NULL);
free_tree_node(&node);
return 0;
}
static char *test_insert_duplicate_word_same_line()
{
struct tree_node *node = NULL;
char *word = "New entry";
insert(word, 1, &node);
insert(word, 1, &node);
mu_assert("Existing node deleted", node != NULL);
mu_assert("New entry has NULL word", node->word != NULL);
mu_assert("New entry has wrong word", strcmp(word, node->word) == 0);
mu_assert("Existing reference deleted", node->references != NULL);
mu_assert("Reference has wrong line", node->references->line == 1);
mu_assert("Reference has wrong count", node->references->count == 2);
mu_assert("New entry has non-null left leaf", node->left == NULL);
mu_assert("New entry has non-null right leaf", node->right == NULL);
free_tree_node(&node);
return 0;
}
static char *test_insert_right_node()
{
struct tree_node *node = NULL;
char *head_word = "head";
char *right_word = "lead";
insert(head_word, 1, &node);
insert(right_word, 3, &node);
mu_assert("Tree is null", node != NULL);
mu_assert("Wrong head node word", strcmp(node->word, head_word) == 0);
mu_assert("Wrong head node line", node->references->line == 1);
mu_assert("Wrong head node count", node->references->count == 1);
mu_assert("Left node not null", node->left == NULL);
mu_assert("Right node null", node->right != NULL);
mu_assert("Wrong right node word", strcmp(node->right->word, right_word) == 0);
mu_assert("Wrong right node count", node->right->references->count == 1);
mu_assert("Wrong right node line", node->right->references->line == 3);
mu_assert("Extra right node ref", node->right->references->next == NULL);
free_tree_node(&node);
return 0;
}
/*
* See if the fname already exists. If not insert a new node for it.
*/
static TREE_NODE *search_and_insert_tree_node(char *fname, int type,
TREE_ROOT *root, TREE_NODE *parent)
{
TREE_NODE *node, *found_node;
node = new_tree_node(root);
node->fname = fname;
found_node = (TREE_NODE *)parent->child.insert(node, node_compare);
if (found_node != node) { /* already in list */
free_tree_node(root); /* free node allocated above */
found_node->inserted = false;
return found_node;
}
/*
* It was not found, but is now inserted
*/
node->fname_len = strlen(fname);
node->fname = tree_alloc(root, node->fname_len + 1);
strcpy(node->fname, fname);
node->parent = parent;
node->type = type;
/*
* Maintain a linear chain of nodes
*/
if (!root->first) {
root->first = node;
root->last = node;
} else {
root->last->next = node;
root->last = node;
}
node->inserted = true; /* inserted into tree */
return node;
}
void MyParser::on_start( std::string const& name,
std::vector<Property> const& propertys )
{
if( nodes_stack_.empty() )
{//根节点
free_tree_node();
root_node_ptr_ = new XmlNode( name, propertys );
nodes_stack_.push(root_node_ptr_);
}
else
{
XmlNode* parent_node_ptr = nodes_stack_.top();
XmlNode* node_ptr = new XmlNode( name, propertys );
if( parent_node_ptr->first_child_node_ptr )
add_brother_node( parent_node_ptr->first_child_node_ptr, node_ptr );
else
{
parent_node_ptr->first_child_node_ptr = node_ptr;
node_ptr->parent_node_ptr = parent_node_ptr;
}
nodes_stack_.push( node_ptr );
}
}
MyParser::~MyParser()
{
free_tree_node();
}
void free_tree(struct bs_tree *tree) {
free_tree_node(tree->root);
free(tree);
}
