forked from xxq250/Nasal-Interpreter
update
This commit is contained in:
Valk Richard Li
+262
-276
@@ -4,110 +4,97 @@
|
||||
enum runtime_scalar_type
|
||||
{
|
||||
vm_nil=0,
|
||||
vm_number,
|
||||
vm_string,
|
||||
vm_closure,
|
||||
vm_function,
|
||||
vm_vector,
|
||||
vm_num,
|
||||
vm_str,
|
||||
vm_scop,
|
||||
vm_func,
|
||||
vm_vec,
|
||||
vm_hash
|
||||
};
|
||||
/*
|
||||
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 -> value address in gc(type: nasal_closure)
|
||||
nasal_closure: std::list<std::map<std::string,int>> -> std::map<std::string,int> -> (int) -> address in memory -> value address in gc
|
||||
*/
|
||||
|
||||
class nasal_virtual_machine;
|
||||
class nasal_vector;
|
||||
class nasal_gc;
|
||||
class nasal_vec;
|
||||
class nasal_hash;
|
||||
class nasal_function;
|
||||
class nasal_closure;
|
||||
class nasal_scalar;
|
||||
class nasal_func;
|
||||
class nasal_scop;
|
||||
class nasal_val;
|
||||
|
||||
class nasal_vector
|
||||
class nasal_vec
|
||||
{
|
||||
private:
|
||||
// this int points to the space in nasal_vm::memory_manager_memory
|
||||
nasal_virtual_machine& vm;
|
||||
std::vector<nasal_scalar*> elems;
|
||||
nasal_gc& gc;
|
||||
std::vector<nasal_val*> elems;
|
||||
public:
|
||||
nasal_vector(nasal_virtual_machine&);
|
||||
~nasal_vector();
|
||||
void add_elem(nasal_scalar*);
|
||||
nasal_scalar* del_elem();
|
||||
nasal_vec(nasal_gc&);
|
||||
~nasal_vec();
|
||||
int size();
|
||||
nasal_scalar* operator[](const int);
|
||||
nasal_scalar* get_value_address(int);
|
||||
nasal_scalar** get_mem_address(int);
|
||||
void add_elem(nasal_val*);
|
||||
void print();
|
||||
nasal_val* del_elem();
|
||||
nasal_val* operator[](const int);
|
||||
nasal_val* get_value_address(int);
|
||||
nasal_val** get_mem_address(int);
|
||||
};
|
||||
|
||||
class nasal_hash
|
||||
{
|
||||
private:
|
||||
// this int points to the space in nasal_vm::memory_manager_memory
|
||||
nasal_virtual_machine& vm;
|
||||
std::map<std::string,nasal_scalar*> elems;
|
||||
nasal_gc& gc;
|
||||
std::map<std::string,nasal_val*> elems;
|
||||
public:
|
||||
nasal_hash(nasal_virtual_machine&);
|
||||
nasal_hash(nasal_gc&);
|
||||
~nasal_hash();
|
||||
void add_elem(std::string,nasal_scalar*);
|
||||
void del_elem(std::string);
|
||||
int size();
|
||||
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);
|
||||
nasal_scalar* get_keys();
|
||||
void add_elem(std::string,nasal_val*);
|
||||
void del_elem(std::string);
|
||||
void print();
|
||||
nasal_val* get_special_para(std::string);
|
||||
nasal_val* get_value_address(std::string);
|
||||
nasal_val** get_mem_address(std::string);
|
||||
nasal_val* get_keys();
|
||||
};
|
||||
|
||||
class nasal_function
|
||||
class nasal_func
|
||||
{
|
||||
private:
|
||||
nasal_virtual_machine& vm;
|
||||
nasal_gc& gc;
|
||||
int entry;
|
||||
nasal_scalar* closure_addr;
|
||||
std::vector<int> para_name;
|
||||
int dynamic_para_name;
|
||||
std::vector<nasal_scalar*> default_para_addr;
|
||||
nasal_val* closure_addr;
|
||||
std::vector<int> para;
|
||||
int dynpara;
|
||||
std::vector<nasal_val*> default_para_addr;
|
||||
public:
|
||||
nasal_function(nasal_virtual_machine&);
|
||||
~nasal_function();
|
||||
void set_entry(int);
|
||||
nasal_func(nasal_gc&);
|
||||
~nasal_func();
|
||||
int get_entry();
|
||||
void add_para(int,nasal_scalar*,bool);
|
||||
std::vector<int>& get_para();
|
||||
int get_dynamic_para();
|
||||
std::vector<nasal_scalar*>& get_default();
|
||||
void set_closure_addr(nasal_scalar*);
|
||||
void set_entry(int);
|
||||
void add_para(int,nasal_val*,bool);
|
||||
void set_closure_addr(nasal_val*);
|
||||
void set_new_closure();
|
||||
nasal_scalar* get_closure_addr();
|
||||
nasal_val* get_closure_addr();
|
||||
std::vector<int>& get_para();
|
||||
std::vector<nasal_val*>& get_default();
|
||||
};
|
||||
|
||||
class nasal_closure
|
||||
class nasal_scop
|
||||
{
|
||||
private:
|
||||
// int in std::map<std::string,int> 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
|
||||
nasal_virtual_machine& vm;
|
||||
std::list<std::map<int,nasal_scalar*> > elems;
|
||||
nasal_gc& gc;
|
||||
std::list<std::map<int,nasal_val*> > elems;
|
||||
public:
|
||||
nasal_closure(nasal_virtual_machine&);
|
||||
~nasal_closure();
|
||||
nasal_scop(nasal_gc&);
|
||||
~nasal_scop();
|
||||
void add_scope();
|
||||
void del_scope();
|
||||
void add_new_value(int,nasal_scalar*);
|
||||
nasal_scalar* get_value_address(int);
|
||||
nasal_scalar** get_mem_address(int);
|
||||
void set_closure(nasal_closure&);
|
||||
void set_closure(nasal_scop&);
|
||||
void add_new_value(int,nasal_val*);
|
||||
nasal_val* get_value_address(int);
|
||||
nasal_val** get_mem_address(int);
|
||||
};
|
||||
|
||||
class nasal_scalar
|
||||
class nasal_val
|
||||
{
|
||||
protected:
|
||||
int type;
|
||||
@@ -115,104 +102,103 @@ protected:
|
||||
{
|
||||
double num;
|
||||
std::string* str;
|
||||
nasal_vector* vec;
|
||||
nasal_hash* hash;
|
||||
nasal_function* func;
|
||||
nasal_closure* cls;
|
||||
nasal_vec* vec;
|
||||
nasal_hash* hash;
|
||||
nasal_func* func;
|
||||
nasal_scop* cls;
|
||||
}ptr;
|
||||
public:
|
||||
int ref_cnt;
|
||||
nasal_scalar();
|
||||
nasal_scalar(int,nasal_virtual_machine&);
|
||||
~nasal_scalar();
|
||||
nasal_val();
|
||||
nasal_val(int,nasal_gc&);
|
||||
~nasal_val();
|
||||
void clear();
|
||||
void set_type(int,nasal_virtual_machine&);
|
||||
void set_type(int,nasal_gc&);
|
||||
void set_number(double);
|
||||
void set_string(std::string);
|
||||
int get_type();
|
||||
double to_number();
|
||||
double get_number();
|
||||
std::string to_string();
|
||||
std::string get_string();
|
||||
nasal_vector& get_vector();
|
||||
nasal_hash& get_hash();
|
||||
nasal_function& get_func();
|
||||
nasal_closure& get_closure();
|
||||
int get_type();
|
||||
double to_number();
|
||||
double get_number();
|
||||
std::string to_string();
|
||||
std::string get_string();
|
||||
nasal_vec& get_vector();
|
||||
nasal_hash& get_hash();
|
||||
nasal_func& get_func();
|
||||
nasal_scop& get_closure();
|
||||
};
|
||||
|
||||
class nasal_virtual_machine
|
||||
class nasal_gc
|
||||
{
|
||||
private:
|
||||
nasal_scalar error_returned_value;
|
||||
std::queue<nasal_scalar*> garbage_collector_free_space;
|
||||
std::vector<nasal_scalar*> garbage_collector_memory;
|
||||
std::queue<nasal_val*> free_space;
|
||||
std::vector<nasal_val*> memory;
|
||||
public:
|
||||
~nasal_virtual_machine();
|
||||
~nasal_gc();
|
||||
void clear();
|
||||
void debug();
|
||||
nasal_scalar* gc_alloc(int);
|
||||
void add_reference(nasal_scalar*);
|
||||
void del_reference(nasal_scalar*);
|
||||
nasal_val* gc_alloc(int);
|
||||
void add_reference(nasal_val*);
|
||||
void del_reference(nasal_val*);
|
||||
};
|
||||
|
||||
/*functions of nasal_vector*/
|
||||
nasal_vector::nasal_vector(nasal_virtual_machine& nvm):vm(nvm)
|
||||
/*functions of nasal_vec*/
|
||||
nasal_vec::nasal_vec(nasal_gc& ngc):gc(ngc)
|
||||
{
|
||||
return;
|
||||
}
|
||||
nasal_vector::~nasal_vector()
|
||||
nasal_vec::~nasal_vec()
|
||||
{
|
||||
int size=elems.size();
|
||||
for(int i=0;i<size;++i)
|
||||
vm.del_reference(elems[i]);
|
||||
gc.del_reference(elems[i]);
|
||||
elems.clear();
|
||||
return;
|
||||
}
|
||||
void nasal_vector::add_elem(nasal_scalar* value_address)
|
||||
void nasal_vec::add_elem(nasal_val* value_address)
|
||||
{
|
||||
elems.push_back(value_address);
|
||||
return;
|
||||
}
|
||||
nasal_scalar* nasal_vector::del_elem()
|
||||
nasal_val* nasal_vec::del_elem()
|
||||
{
|
||||
// pop back
|
||||
if(!elems.size())
|
||||
return NULL;
|
||||
nasal_scalar* ret=elems.back();
|
||||
nasal_val* ret=elems.back();
|
||||
elems.pop_back();
|
||||
return ret;
|
||||
}
|
||||
int nasal_vector::size()
|
||||
int nasal_vec::size()
|
||||
{
|
||||
return elems.size();
|
||||
}
|
||||
nasal_scalar* nasal_vector::operator[](const int index)
|
||||
nasal_val* nasal_vec::operator[](const int index)
|
||||
{
|
||||
return elems[index];
|
||||
}
|
||||
nasal_scalar* nasal_vector::get_value_address(int index)
|
||||
nasal_val* nasal_vec::get_value_address(int index)
|
||||
{
|
||||
int vec_size=elems.size();
|
||||
if(index<-vec_size || index>=vec_size)
|
||||
{
|
||||
std::cout<<">> [vm] nasal_vector::get_value_address: index out of range: "<<index<<"\n";
|
||||
std::cout<<">> [gc] nasal_vec::get_value_address: index out of range: "<<index<<"\n";
|
||||
return NULL;
|
||||
}
|
||||
int idx[2]={index+vec_size,index};
|
||||
return elems[idx[index>=0]];
|
||||
}
|
||||
nasal_scalar** nasal_vector::get_mem_address(int index)
|
||||
nasal_val** nasal_vec::get_mem_address(int index)
|
||||
{
|
||||
int vec_size=elems.size();
|
||||
if(index<-vec_size || index>=vec_size)
|
||||
{
|
||||
std::cout<<">> [vm] nasal_vector::get_mem_address: index out of range: "<<index<<"\n";
|
||||
std::cout<<">> [gc] nasal_vec::get_mem_address: index out of range: "<<index<<"\n";
|
||||
return NULL;
|
||||
}
|
||||
int idx[2]={index+vec_size,index};
|
||||
return &elems[idx[index>=0]];
|
||||
}
|
||||
void nasal_vector::print()
|
||||
void nasal_vec::print()
|
||||
{
|
||||
int size=elems.size();
|
||||
std::cout<<"[";
|
||||
@@ -220,15 +206,15 @@ void nasal_vector::print()
|
||||
std::cout<<"]";
|
||||
for(int i=0;i<size;++i)
|
||||
{
|
||||
nasal_scalar* tmp=elems[i];
|
||||
nasal_val* 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_num: std::cout<<tmp->get_number(); break;
|
||||
case vm_str: std::cout<<tmp->get_string(); break;
|
||||
case vm_vec: tmp->get_vector().print(); break;
|
||||
case vm_hash: tmp->get_hash().print(); break;
|
||||
case vm_function: std::cout<<"func(...){...}"; break;
|
||||
case vm_func: std::cout<<"func(...){...}"; break;
|
||||
}
|
||||
std::cout<<",]"[i==size-1];
|
||||
}
|
||||
@@ -236,18 +222,18 @@ void nasal_vector::print()
|
||||
}
|
||||
|
||||
/*functions of nasal_hash*/
|
||||
nasal_hash::nasal_hash(nasal_virtual_machine& nvm):vm(nvm)
|
||||
nasal_hash::nasal_hash(nasal_gc& ngc):gc(ngc)
|
||||
{
|
||||
return;
|
||||
}
|
||||
nasal_hash::~nasal_hash()
|
||||
{
|
||||
for(std::map<std::string,nasal_scalar*>::iterator iter=elems.begin();iter!=elems.end();++iter)
|
||||
vm.del_reference(iter->second);
|
||||
for(std::map<std::string,nasal_val*>::iterator iter=elems.begin();iter!=elems.end();++iter)
|
||||
gc.del_reference(iter->second);
|
||||
elems.clear();
|
||||
return;
|
||||
}
|
||||
void nasal_hash::add_elem(std::string key,nasal_scalar* value_address)
|
||||
void nasal_hash::add_elem(std::string key,nasal_val* value_address)
|
||||
{
|
||||
if(elems.find(key)==elems.end())
|
||||
elems[key]=value_address;
|
||||
@@ -257,7 +243,7 @@ void nasal_hash::del_elem(std::string key)
|
||||
{
|
||||
if(elems.find(key)!=elems.end())
|
||||
{
|
||||
vm.del_reference(elems[key]);
|
||||
gc.del_reference(elems[key]);
|
||||
elems.erase(key);
|
||||
}
|
||||
return;
|
||||
@@ -266,27 +252,27 @@ int nasal_hash::size()
|
||||
{
|
||||
return elems.size();
|
||||
}
|
||||
nasal_scalar* nasal_hash::get_special_para(std::string key)
|
||||
nasal_val* nasal_hash::get_special_para(std::string key)
|
||||
{
|
||||
if(elems.find(key)!=elems.end())
|
||||
return elems[key];
|
||||
return NULL;
|
||||
}
|
||||
nasal_scalar* nasal_hash::get_value_address(std::string key)
|
||||
nasal_val* nasal_hash::get_value_address(std::string key)
|
||||
{
|
||||
nasal_scalar* ret_value_addr=NULL;
|
||||
nasal_val* ret_value_addr=NULL;
|
||||
if(elems.find(key)!=elems.end())
|
||||
return elems[key];
|
||||
else if(elems.find("parents")!=elems.end())
|
||||
{
|
||||
nasal_scalar* val_addr=elems["parents"];
|
||||
if(val_addr->get_type()==vm_vector)
|
||||
nasal_val* val_addr=elems["parents"];
|
||||
if(val_addr->get_type()==vm_vec)
|
||||
{
|
||||
nasal_vector& vec_ref=val_addr->get_vector();
|
||||
nasal_vec& vec_ref=val_addr->get_vector();
|
||||
int size=vec_ref.size();
|
||||
for(int i=0;i<size;++i)
|
||||
{
|
||||
nasal_scalar* tmp_val_addr=vec_ref.get_value_address(i);
|
||||
nasal_val* 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)
|
||||
@@ -296,21 +282,21 @@ nasal_scalar* nasal_hash::get_value_address(std::string key)
|
||||
}
|
||||
return ret_value_addr;
|
||||
}
|
||||
nasal_scalar** nasal_hash::get_mem_address(std::string key)
|
||||
nasal_val** nasal_hash::get_mem_address(std::string key)
|
||||
{
|
||||
nasal_scalar** mem_addr=NULL;
|
||||
nasal_val** mem_addr=NULL;
|
||||
if(elems.find(key)!=elems.end())
|
||||
return &elems[key];
|
||||
else if(elems.find("parents")!=elems.end())
|
||||
{
|
||||
nasal_scalar* val_addr=elems["parents"];
|
||||
if(val_addr->get_type()==vm_vector)
|
||||
nasal_val* val_addr=elems["parents"];
|
||||
if(val_addr->get_type()==vm_vec)
|
||||
{
|
||||
nasal_vector& vec_ref=val_addr->get_vector();
|
||||
nasal_vec& vec_ref=val_addr->get_vector();
|
||||
int size=vec_ref.size();
|
||||
for(int i=0;i<size;++i)
|
||||
{
|
||||
nasal_scalar* tmp_val_addr=vec_ref.get_value_address(i);
|
||||
nasal_val* 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)
|
||||
@@ -327,14 +313,14 @@ bool nasal_hash::check_contain(std::string key)
|
||||
if(elems.find("parents")!=elems.end())
|
||||
{
|
||||
bool result=false;
|
||||
nasal_scalar* val_addr=elems["parents"];
|
||||
if(val_addr->get_type()==vm_vector)
|
||||
nasal_val* val_addr=elems["parents"];
|
||||
if(val_addr->get_type()==vm_vec)
|
||||
{
|
||||
nasal_vector& vec_ref=val_addr->get_vector();
|
||||
nasal_vec& vec_ref=val_addr->get_vector();
|
||||
int size=vec_ref.size();
|
||||
for(int i=0;i<size;++i)
|
||||
{
|
||||
nasal_scalar* tmp_val_addr=vec_ref.get_value_address(i);
|
||||
nasal_val* 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)
|
||||
@@ -345,13 +331,13 @@ bool nasal_hash::check_contain(std::string key)
|
||||
}
|
||||
return false;
|
||||
}
|
||||
nasal_scalar* nasal_hash::get_keys()
|
||||
nasal_val* nasal_hash::get_keys()
|
||||
{
|
||||
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)
|
||||
nasal_val* ret_addr=gc.gc_alloc(vm_vec);
|
||||
nasal_vec& ref_vec=ret_addr->get_vector();
|
||||
for(std::map<std::string,nasal_val*>::iterator iter=elems.begin();iter!=elems.end();++iter)
|
||||
{
|
||||
nasal_scalar* str_addr=vm.gc_alloc(vm_string);
|
||||
nasal_val* str_addr=gc.gc_alloc(vm_str);
|
||||
str_addr->set_string(iter->first);
|
||||
ref_vec.add_elem(str_addr);
|
||||
}
|
||||
@@ -362,18 +348,18 @@ void nasal_hash::print()
|
||||
std::cout<<"{";
|
||||
if(!elems.size())
|
||||
std::cout<<"}";
|
||||
for(std::map<std::string,nasal_scalar*>::iterator i=elems.begin();i!=elems.end();++i)
|
||||
for(std::map<std::string,nasal_val*>::iterator i=elems.begin();i!=elems.end();++i)
|
||||
{
|
||||
std::cout<<i->first<<":";
|
||||
nasal_scalar* tmp=i->second;
|
||||
nasal_val* 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_num: std::cout<<tmp->get_number(); break;
|
||||
case vm_str: std::cout<<tmp->get_string(); break;
|
||||
case vm_vec: tmp->get_vector().print(); break;
|
||||
case vm_hash: tmp->get_hash().print(); break;
|
||||
case vm_function: std::cout<<"func(...){...}"; break;
|
||||
case vm_func: std::cout<<"func(...){...}"; break;
|
||||
}
|
||||
std::cout<<",}"[(++i)==elems.end()];
|
||||
--i;
|
||||
@@ -381,171 +367,171 @@ void nasal_hash::print()
|
||||
return;
|
||||
}
|
||||
|
||||
/*functions of nasal_function*/
|
||||
nasal_function::nasal_function(nasal_virtual_machine& nvm):vm(nvm)
|
||||
/*functions of nasal_func*/
|
||||
nasal_func::nasal_func(nasal_gc& ngc):gc(ngc)
|
||||
{
|
||||
closure_addr=NULL;
|
||||
dynamic_para_name=-1;
|
||||
dynpara=-1;
|
||||
return;
|
||||
}
|
||||
nasal_function::~nasal_function()
|
||||
nasal_func::~nasal_func()
|
||||
{
|
||||
if(closure_addr)
|
||||
vm.del_reference(closure_addr);
|
||||
gc.del_reference(closure_addr);
|
||||
for(int i=0;i<default_para_addr.size();++i)
|
||||
if(default_para_addr[i])
|
||||
vm.del_reference(default_para_addr[i]);
|
||||
gc.del_reference(default_para_addr[i]);
|
||||
return;
|
||||
}
|
||||
void nasal_function::set_entry(int etr)
|
||||
void nasal_func::set_entry(int etr)
|
||||
{
|
||||
entry=etr;
|
||||
return;
|
||||
}
|
||||
int nasal_function::get_entry()
|
||||
int nasal_func::get_entry()
|
||||
{
|
||||
return entry;
|
||||
}
|
||||
void nasal_function::add_para(int name_index,nasal_scalar* val_addr=NULL,bool is_dynamic=false)
|
||||
void nasal_func::add_para(int name_index,nasal_val* val_addr=NULL,bool is_dynamic=false)
|
||||
{
|
||||
if(is_dynamic)
|
||||
{
|
||||
dynamic_para_name=name_index;
|
||||
dynpara=name_index;
|
||||
return;
|
||||
}
|
||||
para_name.push_back(name_index);
|
||||
para.push_back(name_index);
|
||||
default_para_addr.push_back(val_addr);
|
||||
return;
|
||||
}
|
||||
std::vector<int>& nasal_function::get_para()
|
||||
std::vector<int>& nasal_func::get_para()
|
||||
{
|
||||
return para_name;
|
||||
return para;
|
||||
}
|
||||
int nasal_function::get_dynamic_para()
|
||||
int nasal_func::get_dynamic_para()
|
||||
{
|
||||
return dynamic_para_name;
|
||||
return dynpara;
|
||||
}
|
||||
std::vector<nasal_scalar*>& nasal_function::get_default()
|
||||
std::vector<nasal_val*>& nasal_func::get_default()
|
||||
{
|
||||
return default_para_addr;
|
||||
}
|
||||
void nasal_function::set_closure_addr(nasal_scalar* value_address)
|
||||
void nasal_func::set_closure_addr(nasal_val* value_address)
|
||||
{
|
||||
nasal_scalar* new_closure=vm.gc_alloc(vm_closure);
|
||||
nasal_val* new_closure=gc.gc_alloc(vm_scop);
|
||||
new_closure->get_closure().set_closure(value_address->get_closure());
|
||||
closure_addr=new_closure;
|
||||
return;
|
||||
}
|
||||
void nasal_function::set_new_closure()
|
||||
void nasal_func::set_new_closure()
|
||||
{
|
||||
closure_addr=vm.gc_alloc(vm_closure);
|
||||
closure_addr=gc.gc_alloc(vm_scop);
|
||||
return;
|
||||
}
|
||||
nasal_scalar* nasal_function::get_closure_addr()
|
||||
nasal_val* nasal_func::get_closure_addr()
|
||||
{
|
||||
return closure_addr;
|
||||
}
|
||||
|
||||
/*functions of nasal_closure*/
|
||||
nasal_closure::nasal_closure(nasal_virtual_machine& nvm):vm(nvm)
|
||||
/*functions of nasal_scop*/
|
||||
nasal_scop::nasal_scop(nasal_gc& ngc):gc(ngc)
|
||||
{
|
||||
std::map<int,nasal_scalar*> new_scope;
|
||||
std::map<int,nasal_val*> new_scope;
|
||||
elems.push_back(new_scope);
|
||||
return;
|
||||
}
|
||||
nasal_closure::~nasal_closure()
|
||||
nasal_scop::~nasal_scop()
|
||||
{
|
||||
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);
|
||||
for(std::list<std::map<int,nasal_val*> >::iterator i=elems.begin();i!=elems.end();++i)
|
||||
for(std::map<int,nasal_val*>::iterator j=i->begin();j!=i->end();++j)
|
||||
gc.del_reference(j->second);
|
||||
elems.clear();
|
||||
return;
|
||||
}
|
||||
void nasal_closure::add_scope()
|
||||
void nasal_scop::add_scope()
|
||||
{
|
||||
std::map<int,nasal_scalar*> new_scope;
|
||||
std::map<int,nasal_val*> new_scope;
|
||||
elems.push_front(new_scope);
|
||||
return;
|
||||
}
|
||||
void nasal_closure::del_scope()
|
||||
void nasal_scop::del_scope()
|
||||
{
|
||||
std::map<int,nasal_scalar*>& last_scope=elems.front();
|
||||
for(std::map<int,nasal_scalar*>::iterator i=last_scope.begin();i!=last_scope.end();++i)
|
||||
vm.del_reference(i->second);
|
||||
std::map<int,nasal_val*>& last_scope=elems.front();
|
||||
for(std::map<int,nasal_val*>::iterator i=last_scope.begin();i!=last_scope.end();++i)
|
||||
gc.del_reference(i->second);
|
||||
elems.pop_front();
|
||||
return;
|
||||
}
|
||||
void nasal_closure::add_new_value(int key,nasal_scalar* value_address)
|
||||
void nasal_scop::add_new_value(int key,nasal_val* value_address)
|
||||
{
|
||||
if(elems.front().find(key)!=elems.front().end())
|
||||
{
|
||||
// if this value already exists,delete the old value and update a new value
|
||||
nasal_scalar* old_val_address=elems.front()[key];
|
||||
vm.del_reference(old_val_address);
|
||||
nasal_val* old_val_address=elems.front()[key];
|
||||
gc.del_reference(old_val_address);
|
||||
}
|
||||
elems.front()[key]=value_address;
|
||||
return;
|
||||
}
|
||||
nasal_scalar* nasal_closure::get_value_address(int key)
|
||||
nasal_val* nasal_scop::get_value_address(int key)
|
||||
{
|
||||
nasal_scalar* ret_address=NULL;
|
||||
for(std::list<std::map<int,nasal_scalar*> >::iterator i=elems.begin();i!=elems.end();++i)
|
||||
nasal_val* ret_address=NULL;
|
||||
for(std::list<std::map<int,nasal_val*> >::iterator i=elems.begin();i!=elems.end();++i)
|
||||
if(i->find(key)!=i->end())
|
||||
return (*i)[key];
|
||||
return ret_address;
|
||||
}
|
||||
nasal_scalar** nasal_closure::get_mem_address(int key)
|
||||
nasal_val** nasal_scop::get_mem_address(int key)
|
||||
{
|
||||
nasal_scalar** ret_address=NULL;
|
||||
for(std::list<std::map<int,nasal_scalar*> >::iterator i=elems.begin();i!=elems.end();++i)
|
||||
nasal_val** ret_address=NULL;
|
||||
for(std::list<std::map<int,nasal_val*> >::iterator i=elems.begin();i!=elems.end();++i)
|
||||
if(i->find(key)!=i->end())
|
||||
return &((*i)[key]);
|
||||
return ret_address;
|
||||
}
|
||||
void nasal_closure::set_closure(nasal_closure& tmp)
|
||||
void nasal_scop::set_closure(nasal_scop& tmp)
|
||||
{
|
||||
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);
|
||||
for(std::list<std::map<int,nasal_val*> >::iterator i=elems.begin();i!=elems.end();++i)
|
||||
for(std::map<int,nasal_val*>::iterator j=i->begin();j!=i->end();++j)
|
||||
gc.del_reference(j->second);
|
||||
elems.clear();
|
||||
for(std::list<std::map<int,nasal_scalar*> >::iterator i=tmp.elems.begin();i!=tmp.elems.end();++i)
|
||||
for(std::list<std::map<int,nasal_val*> >::iterator i=tmp.elems.begin();i!=tmp.elems.end();++i)
|
||||
{
|
||||
std::map<int,nasal_scalar*> new_scope;
|
||||
std::map<int,nasal_val*> new_scope;
|
||||
elems.push_back(new_scope);
|
||||
for(std::map<int,nasal_scalar*>::iterator j=i->begin();j!=i->end();++j)
|
||||
for(std::map<int,nasal_val*>::iterator j=i->begin();j!=i->end();++j)
|
||||
{
|
||||
nasal_scalar* value_addr=j->second;
|
||||
vm.add_reference(value_addr);
|
||||
nasal_val* value_addr=j->second;
|
||||
gc.add_reference(value_addr);
|
||||
elems.back()[j->first]=value_addr;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
/*functions of nasal_scalar*/
|
||||
nasal_scalar::nasal_scalar()
|
||||
/*functions of nasal_val*/
|
||||
nasal_val::nasal_val()
|
||||
{
|
||||
ref_cnt=1;
|
||||
type=vm_nil;
|
||||
return;
|
||||
}
|
||||
nasal_scalar::nasal_scalar(int nasal_scalar_type,nasal_virtual_machine& nvm)
|
||||
nasal_val::nasal_val(int nasal_val_type,nasal_gc& nvm)
|
||||
{
|
||||
ref_cnt=1;
|
||||
type=nasal_scalar_type;
|
||||
switch(nasal_scalar_type)
|
||||
type=nasal_val_type;
|
||||
switch(nasal_val_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;
|
||||
case vm_num: ptr.num=0; break;
|
||||
case vm_str: ptr.str=new std::string; break;
|
||||
case vm_vec: ptr.vec=new nasal_vec(nvm); break;
|
||||
case vm_hash: ptr.hash=new nasal_hash(nvm); break;
|
||||
case vm_func: ptr.func=new nasal_func(nvm); break;
|
||||
case vm_scop: ptr.cls=new nasal_scop(nvm); break;
|
||||
}
|
||||
return;
|
||||
}
|
||||
nasal_scalar::~nasal_scalar()
|
||||
nasal_val::~nasal_val()
|
||||
{
|
||||
// must set type and scalar_ptr to default first
|
||||
// this operation will avoid SIGTRAP caused by circular reference
|
||||
@@ -555,16 +541,16 @@ nasal_scalar::~nasal_scalar()
|
||||
switch(tmp_type)
|
||||
{
|
||||
case vm_nil: break;
|
||||
case vm_number: break;
|
||||
case vm_string: delete ptr.str; break;
|
||||
case vm_vector: delete ptr.vec; break;
|
||||
case vm_num: break;
|
||||
case vm_str: delete ptr.str; break;
|
||||
case vm_vec: delete ptr.vec; break;
|
||||
case vm_hash: delete ptr.hash; break;
|
||||
case vm_function: delete ptr.func; break;
|
||||
case vm_closure: delete ptr.cls; break;
|
||||
case vm_func: delete ptr.func; break;
|
||||
case vm_scop: delete ptr.cls; break;
|
||||
}
|
||||
return;
|
||||
}
|
||||
void nasal_scalar::clear()
|
||||
void nasal_val::clear()
|
||||
{
|
||||
// must set type and scalar_ptr to default first
|
||||
// this operation will avoid SIGTRAP caused by circular reference
|
||||
@@ -574,162 +560,162 @@ void nasal_scalar::clear()
|
||||
switch(tmp_type)
|
||||
{
|
||||
case vm_nil: break;
|
||||
case vm_number: break;
|
||||
case vm_string: delete ptr.str; break;
|
||||
case vm_vector: delete ptr.vec; break;
|
||||
case vm_num: break;
|
||||
case vm_str: delete ptr.str; break;
|
||||
case vm_vec: delete ptr.vec; break;
|
||||
case vm_hash: delete ptr.hash; break;
|
||||
case vm_function: delete ptr.func; break;
|
||||
case vm_closure: delete ptr.cls; break;
|
||||
case vm_func: delete ptr.func; break;
|
||||
case vm_scop: delete ptr.cls; break;
|
||||
}
|
||||
return;
|
||||
}
|
||||
void nasal_scalar::set_type(int nasal_scalar_type,nasal_virtual_machine& nvm)
|
||||
void nasal_val::set_type(int nasal_val_type,nasal_gc& nvm)
|
||||
{
|
||||
type=nasal_scalar_type;
|
||||
switch(nasal_scalar_type)
|
||||
type=nasal_val_type;
|
||||
switch(nasal_val_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;
|
||||
case vm_num: ptr.num=0; break;
|
||||
case vm_str: ptr.str=new std::string; break;
|
||||
case vm_vec: ptr.vec=new nasal_vec(nvm); break;
|
||||
case vm_hash: ptr.hash=new nasal_hash(nvm); break;
|
||||
case vm_func: ptr.func=new nasal_func(nvm); break;
|
||||
case vm_scop: ptr.cls=new nasal_scop(nvm); break;
|
||||
}
|
||||
return;
|
||||
}
|
||||
void nasal_scalar::set_number(double num)
|
||||
void nasal_val::set_number(double num)
|
||||
{
|
||||
ptr.num=num;
|
||||
return;
|
||||
}
|
||||
void nasal_scalar::set_string(std::string str)
|
||||
void nasal_val::set_string(std::string str)
|
||||
{
|
||||
*ptr.str=str;
|
||||
return;
|
||||
}
|
||||
int nasal_scalar::get_type()
|
||||
int nasal_val::get_type()
|
||||
{
|
||||
return type;
|
||||
}
|
||||
double nasal_scalar::to_number()
|
||||
double nasal_val::to_number()
|
||||
{
|
||||
switch(type)
|
||||
{
|
||||
case vm_nil: return 0;
|
||||
case vm_number: return ptr.num;
|
||||
case vm_string: return trans_string_to_number(*ptr.str);
|
||||
case vm_num: return ptr.num;
|
||||
case vm_str: return trans_string_to_number(*ptr.str);
|
||||
default: return std::nan("");
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
double nasal_scalar::get_number()
|
||||
double nasal_val::get_number()
|
||||
{
|
||||
return ptr.num;
|
||||
}
|
||||
std::string nasal_scalar::to_string()
|
||||
std::string nasal_val::to_string()
|
||||
{
|
||||
switch(type)
|
||||
{
|
||||
case vm_number:return trans_number_to_string(ptr.num);
|
||||
case vm_string:return *ptr.str;
|
||||
case vm_num:return trans_number_to_string(ptr.num);
|
||||
case vm_str:return *ptr.str;
|
||||
default:return "";
|
||||
}
|
||||
return "";
|
||||
}
|
||||
std::string nasal_scalar::get_string()
|
||||
std::string nasal_val::get_string()
|
||||
{
|
||||
return *ptr.str;
|
||||
}
|
||||
nasal_vector& nasal_scalar::get_vector()
|
||||
nasal_vec& nasal_val::get_vector()
|
||||
{
|
||||
return *ptr.vec;
|
||||
}
|
||||
nasal_hash& nasal_scalar::get_hash()
|
||||
nasal_hash& nasal_val::get_hash()
|
||||
{
|
||||
return *ptr.hash;
|
||||
}
|
||||
nasal_function& nasal_scalar::get_func()
|
||||
nasal_func& nasal_val::get_func()
|
||||
{
|
||||
return *ptr.func;
|
||||
}
|
||||
nasal_closure& nasal_scalar::get_closure()
|
||||
nasal_scop& nasal_val::get_closure()
|
||||
{
|
||||
return *ptr.cls;
|
||||
}
|
||||
|
||||
/*functions of nasal_virtual_machine*/
|
||||
nasal_virtual_machine::~nasal_virtual_machine()
|
||||
/*functions of nasal_gc*/
|
||||
nasal_gc::~nasal_gc()
|
||||
{
|
||||
int gc_mem_size=garbage_collector_memory.size();
|
||||
int gc_mem_size=memory.size();
|
||||
for(int i=0;i<gc_mem_size;++i)
|
||||
garbage_collector_memory[i]->clear();
|
||||
memory[i]->clear();
|
||||
for(int i=0;i<gc_mem_size;++i)
|
||||
delete garbage_collector_memory[i];
|
||||
while(!garbage_collector_free_space.empty())
|
||||
garbage_collector_free_space.pop();
|
||||
garbage_collector_memory.clear();
|
||||
delete memory[i];
|
||||
while(!free_space.empty())
|
||||
free_space.pop();
|
||||
memory.clear();
|
||||
return;
|
||||
}
|
||||
void nasal_virtual_machine::debug()
|
||||
void nasal_gc::debug()
|
||||
{
|
||||
int gc_mem_size=garbage_collector_memory.size();
|
||||
int gc_mem_size=memory.size();
|
||||
for(int i=0;i<gc_mem_size;++i)
|
||||
if(garbage_collector_memory[i]->ref_cnt)
|
||||
if(memory[i]->ref_cnt)
|
||||
{
|
||||
std::cout<<">> [debug] "<<i<<": "<<garbage_collector_memory[i]->ref_cnt<<" ";
|
||||
switch(garbage_collector_memory[i]->get_type())
|
||||
std::cout<<">> [debug] "<<i<<": "<<memory[i]->ref_cnt<<" ";
|
||||
switch(memory[i]->get_type())
|
||||
{
|
||||
case vm_nil:std::cout<<"nil";break;
|
||||
case vm_number:std::cout<<"number "<<garbage_collector_memory[i]->get_number();break;
|
||||
case vm_string:std::cout<<"string "<<garbage_collector_memory[i]->get_string();break;
|
||||
case vm_vector:std::cout<<"vector";break;
|
||||
case vm_num:std::cout<<"number "<<memory[i]->get_number();break;
|
||||
case vm_str:std::cout<<"string "<<memory[i]->get_string();break;
|
||||
case vm_vec:std::cout<<"vector";break;
|
||||
case vm_hash:std::cout<<"hash";break;
|
||||
case vm_function:std::cout<<"function";break;
|
||||
case vm_closure:std::cout<<"closure";break;
|
||||
case vm_func:std::cout<<"function";break;
|
||||
case vm_scop:std::cout<<"closure";break;
|
||||
}
|
||||
std::cout<<"\n";
|
||||
}
|
||||
return;
|
||||
}
|
||||
void nasal_virtual_machine::clear()
|
||||
void nasal_gc::clear()
|
||||
{
|
||||
int gc_mem_size=garbage_collector_memory.size();
|
||||
int gc_mem_size=memory.size();
|
||||
for(int i=0;i<gc_mem_size;++i)
|
||||
garbage_collector_memory[i]->clear();
|
||||
memory[i]->clear();
|
||||
for(int i=0;i<gc_mem_size;++i)
|
||||
delete garbage_collector_memory[i];
|
||||
while(!garbage_collector_free_space.empty())
|
||||
garbage_collector_free_space.pop();
|
||||
garbage_collector_memory.clear();
|
||||
delete memory[i];
|
||||
while(!free_space.empty())
|
||||
free_space.pop();
|
||||
memory.clear();
|
||||
return;
|
||||
}
|
||||
nasal_scalar* nasal_virtual_machine::gc_alloc(int val_type)
|
||||
nasal_val* nasal_gc::gc_alloc(int val_type)
|
||||
{
|
||||
if(garbage_collector_free_space.empty())
|
||||
if(free_space.empty())
|
||||
{
|
||||
nasal_scalar* new_unit=new nasal_scalar(val_type,*this);
|
||||
garbage_collector_memory.push_back(new_unit);
|
||||
nasal_val* new_unit=new nasal_val(val_type,*this);
|
||||
memory.push_back(new_unit);
|
||||
return new_unit;
|
||||
}
|
||||
nasal_scalar* ret=garbage_collector_free_space.front();
|
||||
garbage_collector_free_space.pop();
|
||||
nasal_val* ret=free_space.front();
|
||||
free_space.pop();
|
||||
ret->ref_cnt=1;
|
||||
ret->set_type(val_type,*this);
|
||||
return ret;
|
||||
}
|
||||
void nasal_virtual_machine::add_reference(nasal_scalar* value_address)
|
||||
void nasal_gc::add_reference(nasal_val* value_address)
|
||||
{
|
||||
++value_address->ref_cnt;
|
||||
return;
|
||||
}
|
||||
void nasal_virtual_machine::del_reference(nasal_scalar* value_address)
|
||||
void nasal_gc::del_reference(nasal_val* value_address)
|
||||
{
|
||||
--value_address->ref_cnt;
|
||||
if(!value_address->ref_cnt)
|
||||
{
|
||||
value_address->clear();
|
||||
garbage_collector_free_space.push(value_address);
|
||||
free_space.push(value_address);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user