From fd62fcb1aca03dfb120a3d62aa5ddfdb591939ea Mon Sep 17 00:00:00 2001 From: Valk Richard Li <48872266+ValKmjolnir@users.noreply.github.com> Date: Mon, 24 Aug 2020 07:58:32 -0700 Subject: [PATCH] update --- version3.0/nasal_gc.h | 140 +++++++++++++++++++++++++++++-------- version3.0/nasal_runtime.h | 41 ++++++++++- 2 files changed, 148 insertions(+), 33 deletions(-) diff --git a/version3.0/nasal_gc.h b/version3.0/nasal_gc.h index 21228f8..0acc4a8 100644 --- a/version3.0/nasal_gc.h +++ b/version3.0/nasal_gc.h @@ -3,6 +3,14 @@ #define MEM_BLK_SIZE 256 // 0x00 ~ 0xff #define GC_BLK_SIZE 256 // 0x00 ~ 0xff +/* +nasal_number: basic type(double) +nasal_string: basic type(std::string) +nasal_vector: elems[i] -> address in memory -> value address in gc +nasal_hash: elems[key] -> address in memory -> value address in gc +nasal_function: closure -> address in memory ->value address in gc(type: nasal_closure) +nasal_closure: std::list> -> std::map -> (int) -> address in memory -> value address in gc +*/ class nasal_vector { @@ -14,7 +22,10 @@ public: ~nasal_vector(); void add_elem(int); int del_elem(int); + int get_value_address(int); + int get_mem_address(int); }; + class nasal_hash { private: @@ -25,7 +36,10 @@ public: ~nasal_hash(); void add_elem(std::string,int); void del_elem(std::string); + int get_value_address(std::string); + int get_mem_address(std::string); }; + class nasal_function { private: @@ -41,18 +55,21 @@ public: void set_arguments(nasal_ast&); void set_run_block(nasal_ast&); }; + class nasal_closure { private: - // this int points to the space in nasal_vm::memory_manager_memory + // int in std::map points to the space in nasal_vm::memory_manager_memory // and this memory_manager_memory space stores an address to garbage_collector_memory // and this address points to an nasal_hash - std::list elems; + std::list > elems; public: nasal_closure(); ~nasal_closure(); void add_scope(); void del_scope(); + int get_value_address(std::string); + int get_mem_address(std::string); }; class nasal_scalar @@ -158,6 +175,30 @@ int nasal_vector::del_elem(int index) elems.pop_back(); return ret; } +int nasal_vector::get_value_address(int index) +{ + int vec_size=elems.size(); + int left_range=-vec_size; + int right_range=vec_size-1; + if(indexright_range) + { + std::cout<<">> [runtime] nasal_vector::get_value_address: index out of range."<right_range) + { + std::cout<<">> [runtime] nasal_vector::get_mem_address: index out of range."<> [vm] nasal_hash::del_elem: "<> [vm] nasal_hash:get_value_address: "<> [vm] nasal_hash:get_mem_address: "<::iterator iter=elems.begin();iter!=elems.end();++iter) - nasal_vm.mem_free(*iter); + for(std::list >::iterator i=elems.begin();i!=elems.end();++i) + { + for(std::map::iterator j=i->begin();j!=i->end();++j) + nasal_vm.mem_free(j->second); + i->clear(); + } elems.clear(); return; } void nasal_closure::add_scope() { - int hash_address=nasal_vm.gc_alloc(); - nasal_vm.gc_get(hash_address).set_type(vm_hash); - int scope_memory_address=nasal_vm.mem_alloc(); - nasal_vm.mem_init(scope_memory_address,hash_address); - this->elems.push_back(scope_memory_address); + std::map new_scope; + this->elems.push_back(new_scope); return; } void nasal_closure::del_scope() { if(this->elems.empty()) return; - int scope_memory_address=this->elems.back(); + for(std::map::iterator i=this->elems.back().begin();i!=this->elems.back().end();++i) + nasal_vm.mem_free(i->second); this->elems.pop_back(); - nasal_vm.mem_free(scope_memory_address); return; } +int nasal_closure::get_value_address(std::string key) +{ + int ret_address=-1; + for(std::list >::iterator i=elems.begin();i!=elems.end();++i) + { + if(i->find(key)!=i->end()) + ret_address=nasal_vm.mem_get((*i)[key]); + } + return ret_address; +} +int nasal_closure::get_mem_address(std::string key) +{ + int ret_address=-1; + for(std::list >::iterator i=elems.begin();i!=elems.end();++i) + { + if(i->find(key)!=i->end()) + ret_address=(*i)[key]; + } + return ret_address; +} /*functions of nasal_scalar*/ nasal_scalar::nasal_scalar() @@ -955,47 +1033,47 @@ int nasal_virtual_machine::gc_alloc() garbage_collector_free_space.pop(); return ret; } -nasal_scalar& nasal_virtual_machine::gc_get(int memory_address) +nasal_scalar& nasal_virtual_machine::gc_get(int value_address) { - int blk_num=(memory_address>>8); - int blk_plc=(memory_address&0xff); - if(0<=memory_address && memory_address<(garbage_collector_memory.size()<<8) && !garbage_collector_memory[blk_num][blk_plc].collected) + int blk_num=(value_address>>8); + int blk_plc=(value_address&0xff); + if(0<=value_address && value_address<(garbage_collector_memory.size()<<8) && !garbage_collector_memory[blk_num][blk_plc].collected) return garbage_collector_memory[blk_num][blk_plc].elem; else { - std::cout<<">> [vm] gc_get:unexpected memory \'"<> [vm] gc_get:unexpected memory \'"<>8); - int blk_plc=(memory_address&0xff); - if(0<=memory_address && memory_address<(garbage_collector_memory.size()<<8) && !garbage_collector_memory[blk_num][blk_plc].collected) + int blk_num=(value_address>>8); + int blk_plc=(value_address&0xff); + if(0<=value_address && value_address<(garbage_collector_memory.size()<<8) && !garbage_collector_memory[blk_num][blk_plc].collected) ++garbage_collector_memory[blk_num][blk_plc].ref_cnt; else { - std::cout<<">> [vm] gc_add_ref:unexpected memory \'"<> [vm] gc_add_ref:unexpected memory \'"<>8); - int blk_plc=(memory_address&0xff); - if(0<=memory_address && memory_address<(garbage_collector_memory.size()<<8) && !garbage_collector_memory[blk_num][blk_plc].collected) + int blk_num=(value_address>>8); + int blk_plc=(value_address&0xff); + if(0<=value_address && value_address<(garbage_collector_memory.size()<<8) && !garbage_collector_memory[blk_num][blk_plc].collected) --garbage_collector_memory[blk_num][blk_plc].ref_cnt; else { - std::cout<<">> [vm] gc_del_ref:unexpected memory \'"<> [vm] gc_del_ref:unexpected memory \'"<del_reference(memory_manager_memory[memory_address>>8][memory_address&0xff]); - memory_manager_memory[memory_address>>8][memory_address&0xff]=value_space; + memory_manager_memory[memory_address>>8][memory_address&0xff]=value_address; } else { @@ -1045,12 +1123,12 @@ int nasal_virtual_machine::mem_change(int memory_address,int value_space) } return 1; } -int nasal_virtual_machine::mem_init(int memory_address,int value_space) +int nasal_virtual_machine::mem_init(int memory_address,int value_address) { // this progress is used to init a memory space // be careful! this process doesn't check if this mem_space is in use. if(0<=memory_address && memory_address<(memory_manager_memory.size()<<8)) - memory_manager_memory[memory_address>>8][memory_address&0xff]=value_space; + memory_manager_memory[memory_address>>8][memory_address&0xff]=value_address; else { std::cout<<">> [vm] mem_store:unexpected memory \'"<root.clear(); this->global_scope_address=-1; return; } nasal_runtime::~nasal_runtime() { + error=0; this->root.clear(); this->global_scope_address=-1; return; @@ -190,6 +194,7 @@ int nasal_runtime::call_scalar_mem(nasal_ast& node) } int nasal_runtime::calculation(nasal_ast& node) { + // after this process, a new address(in nasal_vm.garbage_collector_memory) will be returned int ret_address=-1; int calculation_type=node.get_type(); if(calculation_type==ast_number) @@ -299,36 +304,68 @@ int nasal_runtime::calculation(nasal_ast& node) nasal_vm.del_reference(condition_addr); nasal_vm.del_reference(check_null); } - // unfinished else if(calculation_type==ast_equal) { int scalar_mem_space=call_scalar_mem(node.get_children()[0]); int new_scalar_gc_addr=calculation(node.get_children()[1]); + nasal_vm.mem_change(scalar_mem_space,new_scalar_gc_addr); + nasal_vm.add_reference(new_scalar_gc_addr); + ret_address=new_scalar_gc_addr; } else if(calculation_type==ast_add_equal) { int scalar_mem_space=call_scalar_mem(node.get_children()[0]); + int scalar_val_space=nasal_vm.mem_get(scalar_mem_space); int new_scalar_gc_addr=calculation(node.get_children()[1]); + 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.add_reference(result_val_address); + ret_address=result_val_address; } else if(calculation_type==ast_sub_equal) { int scalar_mem_space=call_scalar_mem(node.get_children()[0]); + int scalar_val_space=nasal_vm.mem_get(scalar_mem_space); int new_scalar_gc_addr=calculation(node.get_children()[1]); + 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.add_reference(result_val_address); + ret_address=result_val_address; } else if(calculation_type==ast_div_equal) { int scalar_mem_space=call_scalar_mem(node.get_children()[0]); + int scalar_val_space=nasal_vm.mem_get(scalar_mem_space); int new_scalar_gc_addr=calculation(node.get_children()[1]); + 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.add_reference(result_val_address); + ret_address=result_val_address; } else if(calculation_type==ast_mult_equal) { int scalar_mem_space=call_scalar_mem(node.get_children()[0]); + int scalar_val_space=nasal_vm.mem_get(scalar_mem_space); int new_scalar_gc_addr=calculation(node.get_children()[1]); + 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.add_reference(result_val_address); + ret_address=result_val_address; } else if(calculation_type==ast_link_equal) { int scalar_mem_space=call_scalar_mem(node.get_children()[0]); + int scalar_val_space=nasal_vm.mem_get(scalar_mem_space); int new_scalar_gc_addr=calculation(node.get_children()[1]); + 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.add_reference(result_val_address); + ret_address=result_val_address; + } + if(ret_address<0) + { + std::cout<<">> [runtime] calculation:incorrect values are used in calculation."<