xxq250/Nasal-Interpreter
1
0
Fork 1
mirror of https://github.com/ValKmjolnir/Nasal-Interpreter.git synced 2026-07-26 12:59:05 +08:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

update

Browse Source
This commit is contained in:
Valk Richard Li
2020-12-19 23:47:04 +08:00
parent fed1e20085
commit 4617eb8f17
5 changed files with 886 additions and 996 deletions
Download Patch File Download Diff File Expand all files Collapse all files
nasal_gc.h
+152 -143
View File
@@ -21,22 +21,27 @@ nasal_closure: std::list<std::map<std::string,int>> -> std::map<std::string,int>
*/
class nasal_virtual_machine;
class nasal_vector;
class nasal_hash;
class nasal_function;
class nasal_closure;
class nasal_scalar;
class nasal_vector
{
private:
// this int points to the space in nasal_vm::memory_manager_memory
nasal_virtual_machine& vm;
std::vector<int> elems;
std::vector<nasal_scalar*> elems;
public:
nasal_vector(nasal_virtual_machine&);
~nasal_vector();
void add_elem(int);
int del_elem();
void add_elem(nasal_scalar*);
nasal_scalar* del_elem();
int size();
int operator[](const int);
int get_value_address(int);
int* get_mem_address(int);
nasal_scalar* operator[](const int);
nasal_scalar* get_value_address(int);
nasal_scalar** get_mem_address(int);
void print();
};
@@ -45,18 +50,18 @@ class nasal_hash
private:
// this int points to the space in nasal_vm::memory_manager_memory
nasal_virtual_machine& vm;
std::map<std::string,int> elems;
std::map<std::string,nasal_scalar*> elems;
public:
nasal_hash(nasal_virtual_machine&);
~nasal_hash();
void add_elem(std::string,int);
void add_elem(std::string,nasal_scalar*);
void del_elem(std::string);
int size();
int get_special_para(std::string);
int get_value_address(std::string);
int* get_mem_address(std::string);
nasal_scalar* get_special_para(std::string);
nasal_scalar* get_value_address(std::string);
nasal_scalar** get_mem_address(std::string);
bool check_contain(std::string);
int get_keys();
nasal_scalar* get_keys();
void print();
};
@@ -65,21 +70,21 @@ class nasal_function
private:
nasal_virtual_machine& vm;
int entry;
int closure_addr;
nasal_scalar* closure_addr;
std::vector<int> para_name;
int dynamic_para_name;
std::vector<int> default_para_addr;
std::vector<nasal_scalar*> default_para_addr;
public:
nasal_function(nasal_virtual_machine&);
~nasal_function();
void set_entry(int);
int get_entry();
void add_para(int,int,bool);
void add_para(int,nasal_scalar*,bool);
std::vector<int>& get_para();
int get_dynamic_para();
std::vector<int>& get_default();
void set_closure_addr(int);
int get_closure_addr();
int get_dynamic_para();
std::vector<nasal_scalar*>& get_default();
void set_closure_addr(nasal_scalar*);
nasal_scalar* get_closure_addr();
};
class nasal_closure
@@ -89,15 +94,15 @@ private:
// and this memory_manager_memory space stores an address to garbage_collector_memory
// and this address points to an nasal_hash
nasal_virtual_machine& vm;
std::list<std::map<int,int> > elems;
std::list<std::map<int,nasal_scalar*> > elems;
public:
nasal_closure(nasal_virtual_machine&);
~nasal_closure();
void add_scope();
void del_scope();
void add_new_value(int,int);
int get_value_address(int);
int* get_mem_address(int);
void add_new_value(int,nasal_scalar*);
nasal_scalar* get_value_address(int);
nasal_scalar** get_mem_address(int);
void set_closure(nasal_closure&);
};
@@ -117,6 +122,7 @@ protected:
public:
int ref_cnt;
nasal_scalar();
nasal_scalar(int,nasal_virtual_machine&);
~nasal_scalar();
void clear();
void set_type(int,nasal_virtual_machine&);
@@ -137,16 +143,15 @@ class nasal_virtual_machine
{
private:
nasal_scalar error_returned_value;
std::queue<int> garbage_collector_free_space;
std::queue<nasal_scalar*> garbage_collector_free_space;
std::vector<nasal_scalar*> garbage_collector_memory;
public:
~nasal_virtual_machine();
void clear();
void debug();
int gc_alloc(int); // garbage collector gives a new space
nasal_scalar& gc_get(int); // get scalar that stored in gc
void add_reference(int);
void del_reference(int);
nasal_scalar* gc_alloc(int);
void add_reference(nasal_scalar*);
void del_reference(nasal_scalar*);
};
/*functions of nasal_vector*/
@@ -162,17 +167,17 @@ nasal_vector::~nasal_vector()
elems.clear();
return;
}
void nasal_vector::add_elem(int value_address)
void nasal_vector::add_elem(nasal_scalar* value_address)
{
elems.push_back(value_address);
return;
}
int nasal_vector::del_elem()
nasal_scalar* nasal_vector::del_elem()
{
// pop back
if(!elems.size())
return -1;
int ret=elems.back();
return NULL;
nasal_scalar* ret=elems.back();
elems.pop_back();
return ret;
}
@@ -180,21 +185,21 @@ int nasal_vector::size()
{
return elems.size();
}
int nasal_vector::operator[](const int index)
nasal_scalar* nasal_vector::operator[](const int index)
{
return elems[index];
}
int nasal_vector::get_value_address(int index)
nasal_scalar* nasal_vector::get_value_address(int index)
{
int vec_size=elems.size();
if(index<-vec_size || index>=vec_size)
{
std::cout<<">> [runtime] nasal_vector::get_value_address: index out of range: "<<index<<"\n";
return -1;
return NULL;
}
return elems[(index+vec_size)%vec_size];
}
int* nasal_vector::get_mem_address(int index)
nasal_scalar** nasal_vector::get_mem_address(int index)
{
int vec_size=elems.size();
if(index<-vec_size || index>=vec_size)
@@ -212,15 +217,15 @@ void nasal_vector::print()
std::cout<<"]";
for(int i=0;i<size;++i)
{
nasal_scalar& tmp=vm.gc_get(elems[i]);
switch(tmp.get_type())
nasal_scalar* tmp=elems[i];
switch(tmp->get_type())
{
case vm_nil:std::cout<<"nil";break;
case vm_number:std::cout<<tmp.get_number();break;
case vm_string:std::cout<<tmp.get_string();break;
case vm_vector:tmp.get_vector().print();break;
case vm_hash:tmp.get_hash().print();break;
case vm_function:std::cout<<"func(...){...}";break;
case vm_nil: std::cout<<"nil"; break;
case vm_number: std::cout<<tmp->get_number(); break;
case vm_string: std::cout<<tmp->get_string(); break;
case vm_vector: tmp->get_vector().print(); break;
case vm_hash: tmp->get_hash().print(); break;
case vm_function: std::cout<<"func(...){...}"; break;
}
std::cout<<",]"[i==size-1];
}
@@ -234,12 +239,12 @@ nasal_hash::nasal_hash(nasal_virtual_machine& nvm):vm(nvm)
}
nasal_hash::~nasal_hash()
{
for(std::map<std::string,int>::iterator iter=elems.begin();iter!=elems.end();++iter)
for(std::map<std::string,nasal_scalar*>::iterator iter=elems.begin();iter!=elems.end();++iter)
vm.del_reference(iter->second);
elems.clear();
return;
}
void nasal_hash::add_elem(std::string key,int value_address)
void nasal_hash::add_elem(std::string key,nasal_scalar* value_address)
{
if(elems.find(key)==elems.end())
elems[key]=value_address;
@@ -258,29 +263,29 @@ int nasal_hash::size()
{
return elems.size();
}
int nasal_hash::get_special_para(std::string key)
nasal_scalar* nasal_hash::get_special_para(std::string key)
{
if(elems.find(key)!=elems.end())
return elems[key];
return -1;
return NULL;
}
int nasal_hash::get_value_address(std::string key)
nasal_scalar* nasal_hash::get_value_address(std::string key)
{
int ret_value_addr=-1;
nasal_scalar* ret_value_addr=NULL;
if(elems.find(key)!=elems.end())
return elems[key];
else if(elems.find("parents")!=elems.end())
{
int val_addr=elems["parents"];
if(vm.gc_get(val_addr).get_type()==vm_vector)
nasal_scalar* val_addr=elems["parents"];
if(val_addr->get_type()==vm_vector)
{
nasal_vector& vec_ref=vm.gc_get(val_addr).get_vector();
nasal_vector& vec_ref=val_addr->get_vector();
int size=vec_ref.size();
for(int i=0;i<size;++i)
{
int tmp_val_addr=vec_ref.get_value_address(i);
if(vm.gc_get(tmp_val_addr).get_type()==vm_hash)
ret_value_addr=vm.gc_get(tmp_val_addr).get_hash().get_value_address(key);
nasal_scalar* tmp_val_addr=vec_ref.get_value_address(i);
if(tmp_val_addr->get_type()==vm_hash)
ret_value_addr=tmp_val_addr->get_hash().get_value_address(key);
if(ret_value_addr>=0)
break;
}
@@ -288,23 +293,23 @@ int nasal_hash::get_value_address(std::string key)
}
return ret_value_addr;
}
int* nasal_hash::get_mem_address(std::string key)
nasal_scalar** nasal_hash::get_mem_address(std::string key)
{
int* mem_addr=NULL;
nasal_scalar** mem_addr=NULL;
if(elems.find(key)!=elems.end())
return &elems[key];
else if(elems.find("parents")!=elems.end())
{
int val_addr=elems["parents"];
if(vm.gc_get(val_addr).get_type()==vm_vector)
nasal_scalar* val_addr=elems["parents"];
if(val_addr->get_type()==vm_vector)
{
nasal_vector& vec_ref=vm.gc_get(val_addr).get_vector();
nasal_vector& vec_ref=val_addr->get_vector();
int size=vec_ref.size();
for(int i=0;i<size;++i)
{
int tmp_val_addr=vec_ref.get_value_address(i);
if(vm.gc_get(tmp_val_addr).get_type()==vm_hash)
mem_addr=vm.gc_get(tmp_val_addr).get_hash().get_mem_address(key);
nasal_scalar* tmp_val_addr=vec_ref.get_value_address(i);
if(tmp_val_addr->get_type()==vm_hash)
mem_addr=tmp_val_addr->get_hash().get_mem_address(key);
if(mem_addr>0)
break;
}
@@ -319,16 +324,16 @@ bool nasal_hash::check_contain(std::string key)
if(elems.find("parents")!=elems.end())
{
bool result=false;
int val_addr=elems["parents"];
if(vm.gc_get(val_addr).get_type()==vm_vector)
nasal_scalar* val_addr=elems["parents"];
if(val_addr->get_type()==vm_vector)
{
nasal_vector& vec_ref=vm.gc_get(val_addr).get_vector();
nasal_vector& vec_ref=val_addr->get_vector();
int size=vec_ref.size();
for(int i=0;i<size;++i)
{
int tmp_val_addr=vec_ref.get_value_address(i);
if(vm.gc_get(tmp_val_addr).get_type()==vm_hash)
result=vm.gc_get(tmp_val_addr).get_hash().check_contain(key);
nasal_scalar* tmp_val_addr=vec_ref.get_value_address(i);
if(tmp_val_addr->get_type()==vm_hash)
result=tmp_val_addr->get_hash().check_contain(key);
if(result)
break;
}
@@ -337,14 +342,14 @@ bool nasal_hash::check_contain(std::string key)
}
return false;
}
int nasal_hash::get_keys()
nasal_scalar* nasal_hash::get_keys()
{
int ret_addr=vm.gc_alloc(vm_vector);
nasal_vector& ref_vec=vm.gc_get(ret_addr).get_vector();
for(std::map<std::string,int>::iterator iter=elems.begin();iter!=elems.end();++iter)
nasal_scalar* ret_addr=vm.gc_alloc(vm_vector);
nasal_vector& ref_vec=ret_addr->get_vector();
for(std::map<std::string,nasal_scalar*>::iterator iter=elems.begin();iter!=elems.end();++iter)
{
int str_addr=vm.gc_alloc(vm_string);
vm.gc_get(str_addr).set_string(iter->first);
nasal_scalar* str_addr=vm.gc_alloc(vm_string);
str_addr->set_string(iter->first);
ref_vec.add_elem(str_addr);
}
return ret_addr;
@@ -354,18 +359,18 @@ void nasal_hash::print()
std::cout<<"{";
if(!elems.size())
std::cout<<"}";
for(std::map<std::string,int>::iterator i=elems.begin();i!=elems.end();++i)
for(std::map<std::string,nasal_scalar*>::iterator i=elems.begin();i!=elems.end();++i)
{
std::cout<<i->first<<":";
nasal_scalar& tmp=vm.gc_get(i->second);
switch(tmp.get_type())
nasal_scalar* tmp=i->second;
switch(tmp->get_type())
{
case vm_nil:std::cout<<"nil";break;
case vm_number:std::cout<<tmp.get_number();break;
case vm_string:std::cout<<tmp.get_string();break;
case vm_vector:tmp.get_vector().print();break;
case vm_hash:tmp.get_hash().print();break;
case vm_function:std::cout<<"func(...){...}";break;
case vm_nil: std::cout<<"nil"; break;
case vm_number: std::cout<<tmp->get_number(); break;
case vm_string: std::cout<<tmp->get_string(); break;
case vm_vector: tmp->get_vector().print(); break;
case vm_hash: tmp->get_hash().print(); break;
case vm_function: std::cout<<"func(...){...}"; break;
}
std::cout<<",}"[(++i)==elems.end()];
--i;
@@ -376,13 +381,13 @@ void nasal_hash::print()
/*functions of nasal_function*/
nasal_function::nasal_function(nasal_virtual_machine& nvm):vm(nvm)
{
closure_addr=-1;
closure_addr=NULL;
dynamic_para_name=-1;
return;
}
nasal_function::~nasal_function()
{
if(closure_addr>=0)
if(closure_addr)
vm.del_reference(closure_addr);
for(int i=0;i<default_para_addr.size();++i)
if(default_para_addr[i]>=0)
@@ -398,7 +403,7 @@ int nasal_function::get_entry()
{
return entry;
}
void nasal_function::add_para(int name_index,int val_addr=-1,bool is_dynamic=false)
void nasal_function::add_para(int name_index,nasal_scalar* val_addr=NULL,bool is_dynamic=false)
{
if(is_dynamic)
{
@@ -417,20 +422,20 @@ int nasal_function::get_dynamic_para()
{
return dynamic_para_name;
}
std::vector<int>& nasal_function::get_default()
std::vector<nasal_scalar*>& nasal_function::get_default()
{
return default_para_addr;
}
void nasal_function::set_closure_addr(int value_address)
void nasal_function::set_closure_addr(nasal_scalar* value_address)
{
if(closure_addr>=0)
if(closure_addr)
vm.del_reference(closure_addr);
int new_closure=vm.gc_alloc(vm_closure);
vm.gc_get(new_closure).get_closure().set_closure(vm.gc_get(value_address).get_closure());
nasal_scalar* new_closure=vm.gc_alloc(vm_closure);
new_closure->get_closure().set_closure(value_address->get_closure());
closure_addr=new_closure;
return;
}
int nasal_function::get_closure_addr()
nasal_scalar* nasal_function::get_closure_addr()
{
return closure_addr;
}
@@ -438,72 +443,72 @@ int nasal_function::get_closure_addr()
/*functions of nasal_closure*/
nasal_closure::nasal_closure(nasal_virtual_machine& nvm):vm(nvm)
{
std::map<int,int> new_scope;
std::map<int,nasal_scalar*> new_scope;
elems.push_back(new_scope);
return;
}
nasal_closure::~nasal_closure()
{
for(std::list<std::map<int,int> >::iterator i=elems.begin();i!=elems.end();++i)
for(std::map<int,int>::iterator j=i->begin();j!=i->end();++j)
for(std::list<std::map<int,nasal_scalar*> >::iterator i=elems.begin();i!=elems.end();++i)
for(std::map<int,nasal_scalar*>::iterator j=i->begin();j!=i->end();++j)
vm.del_reference(j->second);
elems.clear();
return;
}
void nasal_closure::add_scope()
{
std::map<int,int> new_scope;
std::map<int,nasal_scalar*> new_scope;
elems.push_back(new_scope);
return;
}
void nasal_closure::del_scope()
{
std::map<int,int>& last_scope=elems.back();
for(std::map<int,int>::iterator i=last_scope.begin();i!=last_scope.end();++i)
std::map<int,nasal_scalar*>& last_scope=elems.back();
for(std::map<int,nasal_scalar*>::iterator i=last_scope.begin();i!=last_scope.end();++i)
vm.del_reference(i->second);
elems.pop_back();
return;
}
void nasal_closure::add_new_value(int key,int value_address)
void nasal_closure::add_new_value(int key,nasal_scalar* value_address)
{
if(elems.back().find(key)!=elems.back().end())
{
// if this value already exists,delete the old value and update a new value
int old_val_address=elems.back()[key];
nasal_scalar* old_val_address=elems.back()[key];
vm.del_reference(old_val_address);
}
elems.back()[key]=value_address;
return;
}
int nasal_closure::get_value_address(int key)
nasal_scalar* nasal_closure::get_value_address(int key)
{
int ret_address=-1;
for(std::list<std::map<int,int> >::iterator i=elems.begin();i!=elems.end();++i)
nasal_scalar* ret_address=NULL;
for(std::list<std::map<int,nasal_scalar*> >::iterator i=elems.begin();i!=elems.end();++i)
if(i->find(key)!=i->end())
ret_address=(*i)[key];
return ret_address;
}
int* nasal_closure::get_mem_address(int key)
nasal_scalar** nasal_closure::get_mem_address(int key)
{
int* ret_address=NULL;
for(std::list<std::map<int,int> >::iterator i=elems.begin();i!=elems.end();++i)
nasal_scalar** ret_address=NULL;
for(std::list<std::map<int,nasal_scalar*> >::iterator i=elems.begin();i!=elems.end();++i)
if(i->find(key)!=i->end())
ret_address=&((*i)[key]);
return ret_address;
}
void nasal_closure::set_closure(nasal_closure& tmp)
{
for(std::list<std::map<int,int> >::iterator i=elems.begin();i!=elems.end();++i)
for(std::map<int,int>::iterator j=i->begin();j!=i->end();++j)
for(std::list<std::map<int,nasal_scalar*> >::iterator i=elems.begin();i!=elems.end();++i)
for(std::map<int,nasal_scalar*>::iterator j=i->begin();j!=i->end();++j)
vm.del_reference(j->second);
elems.clear();
for(std::list<std::map<int,int> >::iterator i=tmp.elems.begin();i!=tmp.elems.end();++i)
for(std::list<std::map<int,nasal_scalar*> >::iterator i=tmp.elems.begin();i!=tmp.elems.end();++i)
{
std::map<int,int> new_scope;
std::map<int,nasal_scalar*> new_scope;
elems.push_back(new_scope);
for(std::map<int,int>::iterator j=i->begin();j!=i->end();++j)
for(std::map<int,nasal_scalar*>::iterator j=i->begin();j!=i->end();++j)
{
int value_addr=j->second;
nasal_scalar* value_addr=j->second;
vm.add_reference(value_addr);
elems.back()[j->first]=value_addr;
}
@@ -514,9 +519,26 @@ void nasal_closure::set_closure(nasal_closure& tmp)
/*functions of nasal_scalar*/
nasal_scalar::nasal_scalar()
{
ref_cnt=1;
type=vm_nil;
return;
}
nasal_scalar::nasal_scalar(int nasal_scalar_type,nasal_virtual_machine& nvm)
{
ref_cnt=1;
type=nasal_scalar_type;
switch(nasal_scalar_type)
{
case vm_nil: break;
case vm_number: ptr.num=0; break;
case vm_string: ptr.str=new std::string; break;
case vm_vector: ptr.vec=new nasal_vector(nvm); break;
case vm_hash: ptr.hash=new nasal_hash(nvm); break;
case vm_function: ptr.func=new nasal_function(nvm); break;
case vm_closure: ptr.cls=new nasal_closure(nvm); break;
}
return;
}
nasal_scalar::~nasal_scalar()
{
// must set type and scalar_ptr to default first
@@ -635,8 +657,7 @@ nasal_virtual_machine::~nasal_virtual_machine()
{
int gc_mem_size=garbage_collector_memory.size();
for(int i=0;i<gc_mem_size;++i)
if(garbage_collector_memory[i]->ref_cnt)
garbage_collector_memory[i]->clear();
garbage_collector_memory[i]->clear();
for(int i=0;i<gc_mem_size;++i)
delete garbage_collector_memory[i];
while(!garbage_collector_free_space.empty())
@@ -669,8 +690,7 @@ void nasal_virtual_machine::clear()
{
int gc_mem_size=garbage_collector_memory.size();
for(int i=0;i<gc_mem_size;++i)
if(garbage_collector_memory[i]->ref_cnt)
garbage_collector_memory[i]->clear();
garbage_collector_memory[i]->clear();
for(int i=0;i<gc_mem_size;++i)
delete garbage_collector_memory[i];
while(!garbage_collector_free_space.empty())
@@ -678,46 +698,35 @@ void nasal_virtual_machine::clear()
garbage_collector_memory.clear();
return;
}
int nasal_virtual_machine::gc_alloc(int val_type)
nasal_scalar* nasal_virtual_machine::gc_alloc(int val_type)
{
if(garbage_collector_free_space.empty())
{
int mem_size=garbage_collector_memory.size();
nasal_scalar* new_unit=new nasal_scalar;
nasal_scalar* new_unit=new nasal_scalar(val_type,*this);
garbage_collector_memory.push_back(new_unit);
int ret=mem_size;
new_unit->ref_cnt=1;
new_unit->set_type(val_type,*this);
return ret;
return new_unit;
}
int ret=garbage_collector_free_space.front();
nasal_scalar& unit_ref=*garbage_collector_memory[ret];
unit_ref.ref_cnt=1;
unit_ref.set_type(val_type,*this);
nasal_scalar* ret=garbage_collector_free_space.front();
garbage_collector_free_space.pop();
ret->ref_cnt=1;
ret->set_type(val_type,*this);
return ret;
}
nasal_scalar& nasal_virtual_machine::gc_get(int value_address)
void nasal_virtual_machine::add_reference(nasal_scalar* value_address)
{
if(value_address>=0)
return *garbage_collector_memory[value_address];
return error_returned_value;
}
void nasal_virtual_machine::add_reference(int value_address)
{
if(value_address>=0)
++garbage_collector_memory[value_address]->ref_cnt;
if(value_address)
++value_address->ref_cnt;
return;
}
void nasal_virtual_machine::del_reference(int value_address)
void nasal_virtual_machine::del_reference(nasal_scalar* value_address)
{
if(value_address>=0)
--garbage_collector_memory[value_address]->ref_cnt;
if(value_address)
--value_address->ref_cnt;
else
return;
if(!garbage_collector_memory[value_address]->ref_cnt)
if(!value_address->ref_cnt)
{
garbage_collector_memory[value_address]->clear();
value_address->clear();
garbage_collector_free_space.push(value_address);
}
return;