Node* tree_copy(Node* ptr)
{
if (ptr == 0) {
return 0;
} else {
Node* left_ptr = tree_copy(ptr->left_ptr());
Node* right_ptr = tree_copy(ptr->right_ptr());
return new Node(ptr->data(), left_ptr, right_ptr);
}
}// tree_copy
/**
* For binary operations, there are two cases that need special treatment:
* a = k # a
* a = b # a
* If # is commutable then these can be reversed. Otherwise they will be
* translated to t = a; a = k/b # t.
* After the first phase there are three cases that are already in i386 form:
* a = a # a
* a = a # b
* a = a # k
* There are five cases that need processing:
* a = k # k (should really be handled by constant optimisation)
* a = k # b
* a = b # k
* a = b # b
* a = b # c
* All are translated to a = (k/b); a = a # (k/b/c)
*/
static int i386ify_binary_operation(MODULE *module, FUNCTION *func, NODE *vertex)
{
GRAPH *graph = func->graph;
VARIABLE *dest = tree_get_child(vertex, 0);
EXPRESSION *expr = tree_get_child(vertex, 1);
EXPRESSION *arg0 = tree_get_child(expr, 0);
EXPRESSION *arg1 = tree_get_child(expr, 1);
int source_line = CAST_TO_AST(vertex)->source_line;
/* First deal with special cases, where the first argument is not the
destination but the second argument is. */
if (!is_same_var(CAST_TO_EXPRESSION(dest), arg0) && is_same_var(CAST_TO_EXPRESSION(dest), arg1))
{
if (is_commutable_op(expr))
{
tree_get_child(expr, 0) = arg1;
tree_get_child(expr, 1) = arg0;
}
else
{
TYPE *new_temp_type = arg1->type;
EXPRESSION *new_temp = make_new_temp(module, func, new_temp_type, source_line);
STATEMENT *new_assign = make_assignment(new_temp, arg1, source_line);
tree_get_child(expr, 1) = tree_copy(new_temp);
add_vertex(graph, CAST_TO_NODE(new_assign));
replace_backward(graph, vertex, CAST_TO_NODE(new_assign), 0);
add_edge(graph, CAST_TO_NODE(new_assign), vertex, 0);
}
/* Reset these as the above operations may have changed them, */
arg0 = tree_get_child(expr, 0);
arg1 = tree_get_child(expr, 1);
}
/* If instruction is already in i386 form, we don't need to process it. */
if (is_same_var(CAST_TO_EXPRESSION(dest), arg0))
return 0;
/* Otherwise, translate a = b # c to a = b; a = a # c. */
STATEMENT *new_assign = make_assignment(CAST_TO_EXPRESSION(tree_copy(dest)), arg0, source_line);
tree_get_child(expr, 0) = tree_copy(dest);
add_vertex(graph, CAST_TO_NODE(new_assign));
replace_backward(graph, vertex, CAST_TO_NODE(new_assign), 0);
add_edge(graph, CAST_TO_NODE(new_assign), vertex, 0);
return 1;
}
rbtnode* redblacktree::tree_copy(rbtnode* const node, rbtnode* const senti,rbtnode* const newsenti)const{
if(node == senti ){
return newsenti;
}
rbtnode* result;
if(node->getfather() == senti){
result = new rbtnode( newsenti, node->getvalue(), node->getcolor() );
}
else{
result = new rbtnode( node->getfather(), node->getvalue(), node->getcolor() );
}
result->setleft(tree_copy(node->getleft(), senti, newsenti));
result->setright(tree_copy(node->getright(), senti, newsenti));
return result;
}
/**
* For unary operations, one case is already in i386 form:
* a = #a
* There are two cases which need processing:
* a = #k (should really be handled by constant optimisation)
* a = #b
* These are both translated to a = k/b; a = #a
*/
static int i386ify_unary_operation(MODULE *module, FUNCTION *func, NODE *vertex)
{
GRAPH *graph = func->graph;
VARIABLE *dest = tree_get_child(vertex, 0);
EXPRESSION *expr = tree_get_child(vertex, 1);
EXPRESSION *arg0 = tree_get_child(expr, 0);
if (is_same_var(CAST_TO_EXPRESSION(dest), arg0))
return 0;
STATEMENT *new_assign = make_assignment(CAST_TO_EXPRESSION(tree_copy(dest)), arg0, CAST_TO_AST(vertex)->source_line);
tree_get_child(expr, 0) = tree_copy(dest);
add_vertex(graph, CAST_TO_NODE(new_assign));
replace_backward(graph, vertex, CAST_TO_NODE(new_assign), 0);
add_edge(graph, CAST_TO_NODE(new_assign), vertex, 0);
return 1;
}
Expr *expr_copy(Expr *orig) {
Expr *copy;
if (orig == NULL)
return NULL;
copy = tree_copy(orig);
tree_traverse(copy, expr_copy_helper);
return copy;
}
static STATEMENT *reduce_statement(MODULE *module, FUNCTION *func, BLOCK *block, STATEMENT *stmt)
{
if (stmt == NULL)
return stmt;
if (tree_is_type(stmt, STMT_ASSIGN))
{
EXPRESSION *expr = tree_get_child(stmt, 1);
expr = simplify_expression(module, func, block, expr, stmt);
tree_get_child(stmt, 1) = expr;
}
else if (tree_is_type(stmt, STMT_IF))
{
EXPRESSION *cond = tree_get_child(stmt, 0);
cond = simplify_expression(module, func, block, cond, stmt);
tree_get_child(stmt, 0) = cond;
reduce_block(module, func, tree_get_child(stmt, 1));
reduce_block(module, func, tree_get_child(stmt, 2));
}
else if (tree_is_type(stmt, STMT_WHILE))
{
EXPRESSION *cond = tree_get_child(stmt, 0);
BLOCK *body = tree_get_child(stmt, 1);
if (!is_atomic(cond))
{
EXPRESSION *old_cond = cond;
cond = atomise_expression(module, func, block, cond, stmt);
tree_get_child(stmt, 0) = cond;
STATEMENT *new_assign = make_assignment(cond, CAST_TO_EXPRESSION(tree_copy(old_cond)), CAST_TO_AST(cond)->source_line);
tree_add_child(body, new_assign);
}
reduce_block(module, func, body);
}
else if (tree_is_type(stmt, STMT_RETURN))
{
EXPRESSION *expr = tree_get_child(stmt, 0);
expr = atomise_expression(module, func, block, expr, stmt);
tree_get_child(stmt, 0) = expr;
}
else if (tree_is_type(stmt, STMT_RESTART))
{
/* Do nothing. */
}
else
error("Not sure how to reduce statement of type %d\n", tree_type(stmt));
return stmt;
}
void TestTTreeFunction(TTreeNode<TestData>* root)
{
std::cout << std::endl << "======= Test TTree =======" << std::endl;
TTree<TestData> tree(*root);
// copy
TTree<TestData> tree_copy(tree);
tree_copy.GetRoot()->PreorderTraversal(0, PrintTreeNode);
tree_copy = tree;
tree_copy.GetRoot()->PreorderTraversal(0, PrintTreeNode);
// move
TTree<TestData> tree_swap(std::move(tree_copy));
MASSERT(tree_copy.GetRoot() == nullptr);
tree_swap.GetRoot()->PreorderTraversal(0, PrintTreeNode);
tree_swap = std::move(tree);
MASSERT(tree.GetRoot() == nullptr);
tree_swap.GetRoot()->PreorderTraversal(0, PrintTreeNode);
}
binary_tree_node* binary_search_tree_copy(const binary_tree_node* source_root_ptr)
{
binary_tree_node* n = tree_copy(source_root_ptr);
return n;
}
void init(binary_tree_node*& root_ptr, const binary_tree_node* source_root_ptr)
// Library facilities used: bintree.h
{
root_ptr = tree_copy(source_root_ptr);
}
static cb_ret_t
tree_execute_cmd (WTree * tree, long command)
{
cb_ret_t res = MSG_HANDLED;
if (command != CK_Search)
tree->searching = 0;
switch (command)
{
case CK_Help:
{
ev_help_t event_data = { NULL, "[Directory Tree]" };
mc_event_raise (MCEVENT_GROUP_CORE, "help", &event_data);
}
break;
case CK_Forget:
tree_forget (tree);
break;
case CK_ToggleNavigation:
tree_toggle_navig (tree);
break;
case CK_Copy:
tree_copy (tree, "");
break;
case CK_Move:
tree_move (tree, "");
break;
case CK_Up:
tree_move_up (tree);
break;
case CK_Down:
tree_move_down (tree);
break;
case CK_Top:
tree_move_home (tree);
break;
case CK_Bottom:
tree_move_end (tree);
break;
case CK_PageUp:
tree_move_pgup (tree);
break;
case CK_PageDown:
tree_move_pgdn (tree);
break;
case CK_Enter:
tree_chdir_sel (tree);
break;
case CK_Reread:
tree_rescan (tree);
break;
case CK_Search:
tree_start_search (tree);
break;
case CK_Delete:
tree_rmdir (tree);
break;
case CK_Quit:
if (!tree->is_panel)
dlg_stop (WIDGET (tree)->owner);
return res;
default:
res = MSG_NOT_HANDLED;
}
show_tree (tree);
return res;
}
static void
tree_copy_cmd (void *data)
{
WTree *tree = data;
tree_copy (tree, "");
}
bag<Item>::bag(const bag& source) {
root_ptr = tree_copy(source.root_ptr);
}
