From 72cac2161306c94a126f7cd96951e12411a01edf Mon Sep 17 00:00:00 2001 From: Valk Richard Li <48872266+ValKmjolnir@users.noreply.github.com> Date: Mon, 31 Aug 2020 08:18:50 -0700 Subject: [PATCH] update --- version3.0/nasal_gc.h | 79 +++++++++++++++++++++++++++++++++++++- version3.0/nasal_runtime.h | 57 +++++++++++++++++++++++---- 2 files changed, 127 insertions(+), 9 deletions(-) diff --git a/version3.0/nasal_gc.h b/version3.0/nasal_gc.h index 62c850b..f59953f 100644 --- a/version3.0/nasal_gc.h +++ b/version3.0/nasal_gc.h @@ -24,6 +24,7 @@ public: int del_elem(int); int get_value_address(int); int get_mem_address(int); + void deepcopy(nasal_vector&); }; class nasal_hash @@ -38,6 +39,7 @@ public: void del_elem(std::string); int get_value_address(std::string); int get_mem_address(std::string); + void deepcopy(nasal_hash&); }; class nasal_function @@ -54,6 +56,7 @@ public: int get_closure_addr(); void set_arguments(nasal_ast&); void set_run_block(nasal_ast&); + void deepcopy(nasal_function&); }; class nasal_closure @@ -71,6 +74,7 @@ public: void add_new_value(std::string,int); int get_value_address(std::string); int get_mem_address(std::string); + void deepcopy(nasal_closure&); }; class nasal_scalar @@ -91,6 +95,7 @@ public: nasal_hash& get_hash(); nasal_function& get_func(); nasal_closure& get_closure(); + void deepcopy(nasal_scalar&); // parameter: memory_manager_memory address int nasal_scalar_add(int,int); int nasal_scalar_sub(int,int); @@ -200,6 +205,20 @@ int nasal_vector::get_mem_address(int index) } return elems[(index+vec_size)%vec_size]; } +void nasal_vector::deepcopy(nasal_vector& tmp) +{ + int tmp_size=tmp.elems.size(); + for(int i=0;ielems.push_back(new_mem_addr); + } + return; +} /*functions of nasal_hash*/ nasal_hash::nasal_hash() @@ -249,6 +268,19 @@ int nasal_hash::get_mem_address(std::string key) std::cout<<">> [vm] nasal_hash:get_mem_address: "<::iterator iter=tmp.elems.begin();iter!=tmp.elems.end();++iter) + { + int new_mem_addr=nasal_vm.mem_alloc(); + int new_value_addr=nasal_vm.gc_alloc(); + nasal_vm.mem_init(new_mem_addr,new_value_addr); + int tmp_value_addr=nasal_vm.mem_get(iter->second); + nasal_vm.gc_get(new_value_addr).deepcopy(nasal_vm.gc_get(tmp_value_addr)); + this->elems[iter->first]=new_mem_addr; + } + return; +} /*functions of nasal_function*/ nasal_function::nasal_function() @@ -284,6 +316,14 @@ void nasal_function::set_run_block(nasal_ast& node) function_expr=node; return; } +void nasal_function::deepcopy(nasal_function& tmp) +{ + this->closure_addr=nasal_vm.gc_alloc(); + nasal_vm.gc_get(this->closure_addr).deepcopy(nasal_vm.gc_get(tmp.closure_addr)); + this->argument_list=tmp.argument_list; + this->function_expr=tmp.function_expr; + return; +} /*functions of nasal_closure*/ nasal_closure::nasal_closure() @@ -350,6 +390,23 @@ int nasal_closure::get_mem_address(std::string key) } return ret_address; } +void nasal_closure::deepcopy(nasal_closure& tmp) +{ + for(std::list >::iterator i=tmp.elems.begin();i!=tmp.elems.end();++i) + { + this->add_scope(); + for(std::map::iterator j=i->begin();j!=i->end();++j) + { + int new_mem_addr=nasal_vm.mem_alloc(); + int new_value_addr=nasal_vm.gc_alloc(); + nasal_vm.mem_init(new_mem_addr,new_value_addr); + int tmp_value_addr=nasal_vm.mem_get(j->second); + nasal_vm.gc_get(new_value_addr).deepcopy(nasal_vm.gc_get(tmp_value_addr)); + this->elems.back()[j->first]=new_mem_addr; + } + } + return; +} /*functions of nasal_scalar*/ nasal_scalar::nasal_scalar() @@ -362,7 +419,7 @@ nasal_scalar::~nasal_scalar() { switch(this->type) { - case vm_nil:break; + case vm_nil: break; case vm_number: delete (double*)(this->scalar_ptr); break; case vm_string: delete (std::string*)(this->scalar_ptr); break; case vm_vector: delete (nasal_vector*)(this->scalar_ptr); break; @@ -370,6 +427,7 @@ nasal_scalar::~nasal_scalar() case vm_function: delete (nasal_function*)(this->scalar_ptr); break; case vm_closure: delete (nasal_closure*)(this->scalar_ptr); break; } + this->scalar_ptr=NULL; return; } void nasal_scalar::clear() @@ -377,7 +435,7 @@ void nasal_scalar::clear() this->type=vm_nil; switch(this->type) { - case vm_nil:break; + case vm_nil: break; case vm_number: delete (double*)(this->scalar_ptr); break; case vm_string: delete (std::string*)(this->scalar_ptr); break; case vm_vector: delete (nasal_vector*)(this->scalar_ptr); break; @@ -385,6 +443,7 @@ void nasal_scalar::clear() case vm_function: delete (nasal_function*)(this->scalar_ptr); break; case vm_closure: delete (nasal_closure*)(this->scalar_ptr); break; } + this->scalar_ptr=NULL; return; } bool nasal_scalar::set_type(int nasal_scalar_type) @@ -443,6 +502,22 @@ nasal_closure& nasal_scalar::get_closure() { return *(nasal_closure*)(this->scalar_ptr); } +void nasal_scalar::deepcopy(nasal_scalar& tmp) +{ + this->clear(); + this->type=tmp.type; + switch(tmp.type) + { + case vm_nil: break; + case vm_number: this->scalar_ptr=(void*)(new double);*(double*)this->scalar_ptr=tmp.get_number();break; + case vm_string: this->scalar_ptr=(void*)(new std::string);*(std::string*)this->scalar_ptr=tmp.get_string();break; + case vm_vector: this->scalar_ptr=(void*)(new nasal_vector);(*(nasal_vector*)this->scalar_ptr).deepcopy(tmp.get_vector());break; + case vm_hash: this->scalar_ptr=(void*)(new nasal_hash);(*(nasal_hash*)this->scalar_ptr).deepcopy(tmp.get_hash());break; + case vm_function: this->scalar_ptr=(void*)(new nasal_function);(*(nasal_function*)this->scalar_ptr).deepcopy(tmp.get_func());break; + case vm_closure: this->scalar_ptr=(void*)(new nasal_closure);(*(nasal_closure*)this->scalar_ptr).deepcopy(tmp.get_closure());break; + } + return; +} int nasal_scalar::nasal_scalar_add(int a_scalar_addr,int b_scalar_addr) { if(a_scalar_addr<0 || b_scalar_addr<0) diff --git a/version3.0/nasal_runtime.h b/version3.0/nasal_runtime.h index 9e45ab1..09c53f7 100644 --- a/version3.0/nasal_runtime.h +++ b/version3.0/nasal_runtime.h @@ -399,76 +399,113 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr) int left_gc_addr=calculation(node.get_children()[0],local_scope_addr); int right_gc_addr=calculation(node.get_children()[1],local_scope_addr); ret_address=nasal_scalar_calculator.nasal_scalar_add(left_gc_addr,right_gc_addr); + // delete the reference of temporary values + nasal_vm.del_reference(left_gc_addr); + nasal_vm.del_reference(right_gc_addr); } else if(calculation_type==ast_sub) { int left_gc_addr=calculation(node.get_children()[0],local_scope_addr); int right_gc_addr=calculation(node.get_children()[1],local_scope_addr); ret_address=nasal_scalar_calculator.nasal_scalar_sub(left_gc_addr,right_gc_addr); + // delete the reference of temporary values + nasal_vm.del_reference(left_gc_addr); + nasal_vm.del_reference(right_gc_addr); } else if(calculation_type==ast_mult) { int left_gc_addr=calculation(node.get_children()[0],local_scope_addr); int right_gc_addr=calculation(node.get_children()[1],local_scope_addr); ret_address=nasal_scalar_calculator.nasal_scalar_mult(left_gc_addr,right_gc_addr); + // delete the reference of temporary values + nasal_vm.del_reference(left_gc_addr); + nasal_vm.del_reference(right_gc_addr); } else if(calculation_type==ast_div) { int left_gc_addr=calculation(node.get_children()[0],local_scope_addr); int right_gc_addr=calculation(node.get_children()[1],local_scope_addr); ret_address=nasal_scalar_calculator.nasal_scalar_div(left_gc_addr,right_gc_addr); + // delete the reference of temporary values + nasal_vm.del_reference(left_gc_addr); + nasal_vm.del_reference(right_gc_addr); } else if(calculation_type==ast_link) { int left_gc_addr=calculation(node.get_children()[0],local_scope_addr); int right_gc_addr=calculation(node.get_children()[1],local_scope_addr); ret_address=nasal_scalar_calculator.nasal_scalar_link(left_gc_addr,right_gc_addr); + // delete the reference of temporary values + nasal_vm.del_reference(left_gc_addr); + nasal_vm.del_reference(right_gc_addr); } else if(calculation_type==ast_cmp_equal) { int left_gc_addr=calculation(node.get_children()[0],local_scope_addr); int right_gc_addr=calculation(node.get_children()[1],local_scope_addr); ret_address=nasal_scalar_calculator.nasal_scalar_cmp_equal(left_gc_addr,right_gc_addr); + // delete the reference of temporary values + nasal_vm.del_reference(left_gc_addr); + nasal_vm.del_reference(right_gc_addr); } else if(calculation_type==ast_cmp_not_equal) { int left_gc_addr=calculation(node.get_children()[0],local_scope_addr); int right_gc_addr=calculation(node.get_children()[1],local_scope_addr); ret_address=nasal_scalar_calculator.nasal_scalar_cmp_not_equal(left_gc_addr,right_gc_addr); + // delete the reference of temporary values + nasal_vm.del_reference(left_gc_addr); + nasal_vm.del_reference(right_gc_addr); } else if(calculation_type==ast_less_than) { int left_gc_addr=calculation(node.get_children()[0],local_scope_addr); int right_gc_addr=calculation(node.get_children()[1],local_scope_addr); ret_address=nasal_scalar_calculator.nasal_scalar_cmp_less(left_gc_addr,right_gc_addr); + // delete the reference of temporary values + nasal_vm.del_reference(left_gc_addr); + nasal_vm.del_reference(right_gc_addr); } else if(calculation_type==ast_less_equal) { int left_gc_addr=calculation(node.get_children()[0],local_scope_addr); int right_gc_addr=calculation(node.get_children()[1],local_scope_addr); ret_address=nasal_scalar_calculator.nasal_scalar_cmp_less_or_equal(left_gc_addr,right_gc_addr); + // delete the reference of temporary values + nasal_vm.del_reference(left_gc_addr); + nasal_vm.del_reference(right_gc_addr); } else if(calculation_type==ast_greater_than) { int left_gc_addr=calculation(node.get_children()[0],local_scope_addr); int right_gc_addr=calculation(node.get_children()[1],local_scope_addr); ret_address=nasal_scalar_calculator.nasal_scalar_cmp_greater(left_gc_addr,right_gc_addr); + // delete the reference of temporary values + nasal_vm.del_reference(left_gc_addr); + nasal_vm.del_reference(right_gc_addr); } else if(calculation_type==ast_greater_equal) { int left_gc_addr=calculation(node.get_children()[0],local_scope_addr); int right_gc_addr=calculation(node.get_children()[1],local_scope_addr); ret_address=nasal_scalar_calculator.nasal_scalar_cmp_greater_or_equal(left_gc_addr,right_gc_addr); + // delete the reference of temporary values + nasal_vm.del_reference(left_gc_addr); + nasal_vm.del_reference(right_gc_addr); } else if(calculation_type==ast_unary_not) { int addr=calculation(node.get_children()[0],local_scope_addr); ret_address=nasal_scalar_calculator.nasal_scalar_unary_not(addr); + // delete the reference of temporary values + nasal_vm.del_reference(addr); } else if(calculation_type==ast_unary_sub) { int addr=calculation(node.get_children()[0],local_scope_addr); ret_address=nasal_scalar_calculator.nasal_scalar_unary_sub(addr); + // delete the reference of temporary values + nasal_vm.del_reference(addr); } else if(calculation_type==ast_trinocular) { @@ -476,7 +513,7 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr) int ret_1_addr=calculation(node.get_children()[1],local_scope_addr); int ret_2_addr=calculation(node.get_children()[2],local_scope_addr); int check_null=nasal_scalar_calculator.nasal_scalar_unary_not(condition_addr); - if(nasal_vm.gc_get(check_null).get_number()==0) + if(nasal_vm.gc_get(check_null).get_number()!=0) { ret_address=ret_1_addr; nasal_vm.del_reference(ret_2_addr); @@ -486,6 +523,7 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr) ret_address=ret_2_addr; nasal_vm.del_reference(ret_1_addr); } + // delete the reference of temporary values nasal_vm.del_reference(condition_addr); nasal_vm.del_reference(check_null); } @@ -493,7 +531,7 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr) { int scalar_mem_space=call_scalar_mem(node.get_children()[0],local_scope_addr); int new_scalar_gc_addr=calculation(node.get_children()[1],local_scope_addr); - nasal_vm.mem_change(scalar_mem_space,new_scalar_gc_addr); + nasal_vm.mem_change(scalar_mem_space,new_scalar_gc_addr);// this progress will delete the reference to old gc_addr in scalar_mem_space nasal_vm.add_reference(new_scalar_gc_addr); ret_address=new_scalar_gc_addr; } @@ -503,7 +541,8 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr) int scalar_val_space=nasal_vm.mem_get(scalar_mem_space); int new_scalar_gc_addr=calculation(node.get_children()[1],local_scope_addr); int result_val_address=nasal_scalar_calculator.nasal_scalar_add(scalar_val_space,new_scalar_gc_addr); - nasal_vm.mem_change(scalar_mem_space,result_val_address); + nasal_vm.del_reference(new_scalar_gc_addr); + nasal_vm.mem_change(scalar_mem_space,result_val_address);// this progress will delete the reference to old gc_addr in scalar_mem_space nasal_vm.add_reference(result_val_address); ret_address=result_val_address; } @@ -513,7 +552,8 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr) int scalar_val_space=nasal_vm.mem_get(scalar_mem_space); int new_scalar_gc_addr=calculation(node.get_children()[1],local_scope_addr); int result_val_address=nasal_scalar_calculator.nasal_scalar_sub(scalar_val_space,new_scalar_gc_addr); - nasal_vm.mem_change(scalar_mem_space,result_val_address); + nasal_vm.del_reference(new_scalar_gc_addr); + nasal_vm.mem_change(scalar_mem_space,result_val_address);// this progress will delete the reference to old gc_addr in scalar_mem_space nasal_vm.add_reference(result_val_address); ret_address=result_val_address; } @@ -523,7 +563,8 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr) int scalar_val_space=nasal_vm.mem_get(scalar_mem_space); int new_scalar_gc_addr=calculation(node.get_children()[1],local_scope_addr); int result_val_address=nasal_scalar_calculator.nasal_scalar_div(scalar_val_space,new_scalar_gc_addr); - nasal_vm.mem_change(scalar_mem_space,result_val_address); + nasal_vm.del_reference(new_scalar_gc_addr); + nasal_vm.mem_change(scalar_mem_space,result_val_address);// this progress will delete the reference to old gc_addr in scalar_mem_space nasal_vm.add_reference(result_val_address); ret_address=result_val_address; } @@ -533,7 +574,8 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr) int scalar_val_space=nasal_vm.mem_get(scalar_mem_space); int new_scalar_gc_addr=calculation(node.get_children()[1],local_scope_addr); int result_val_address=nasal_scalar_calculator.nasal_scalar_mult(scalar_val_space,new_scalar_gc_addr); - nasal_vm.mem_change(scalar_mem_space,result_val_address); + nasal_vm.del_reference(new_scalar_gc_addr); + nasal_vm.mem_change(scalar_mem_space,result_val_address);// this progress will delete the reference to old gc_addr in scalar_mem_space nasal_vm.add_reference(result_val_address); ret_address=result_val_address; } @@ -543,7 +585,8 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr) int scalar_val_space=nasal_vm.mem_get(scalar_mem_space); int new_scalar_gc_addr=calculation(node.get_children()[1],local_scope_addr); int result_val_address=nasal_scalar_calculator.nasal_scalar_link(scalar_val_space,new_scalar_gc_addr); - nasal_vm.mem_change(scalar_mem_space,result_val_address); + nasal_vm.del_reference(new_scalar_gc_addr); + nasal_vm.mem_change(scalar_mem_space,result_val_address);// this progress will delete the reference to old gc_addr in scalar_mem_space nasal_vm.add_reference(result_val_address); ret_address=result_val_address; }