xxq250
/
Nasal-Interpreter
mirror of https://github.com/ValKmjolnir/Nasal-Interpreter.git
1
0
Fork 0
Code Issues Actions 2 Packages Projects Releases Wiki Activity

update

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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

843
nasal_builtin.h
View File

File diff suppressed because it is too large Load Diff

564
nasal_bytecode_vm.h
View File

File diff suppressed because it is too large Load Diff

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

55
nasal_lexer.h
View File

@ -89,6 +89,7 @@ struct token
int line; int line;
int type; int type;
std::string str; std::string str;
token(int l=0,int t=tok_null,std::string s=""){line=l;type=t;str=s;return;}
}; };
class nasal_lexer class nasal_lexer
@ -116,10 +117,7 @@ public:
void nasal_lexer::clear() void nasal_lexer::clear()
{ {
error=0; error=res_size=line=ptr=0;
res_size=0;
line=0;
ptr=0;
line_code=""; line_code="";
res.clear(); res.clear();
token_list.clear(); token_list.clear();
@ -243,8 +241,6 @@ std::string nasal_lexer::number_gen()
die("["+line_code+"_] incorrect number.",line,line_code.length()); die("["+line_code+"_] incorrect number.",line,line_code.length());
return "0"; return "0";
} }
if(ptr<res_size && res[ptr]=='0')
token_str+=res[ptr++];
while(ptr<res_size && IS_DIGIT(res[ptr])) while(ptr<res_size && IS_DIGIT(res[ptr]))
token_str+=res[ptr++]; token_str+=res[ptr++];
// "xxxe(-|+)" is not a correct number // "xxxe(-|+)" is not a correct number
@ -274,8 +270,7 @@ std::string nasal_lexer::string_gen()
} }
if(res[ptr]=='\\' && ptr+1<res_size) if(res[ptr]=='\\' && ptr+1<res_size)
{ {
++ptr; line_code+=res[++ptr];
line_code+=res[ptr];
switch(res[ptr]) switch(res[ptr])
{ {
case 'a':token_str.push_back('\a');break; case 'a':token_str.push_back('\a');break;
@ -298,9 +293,8 @@ std::string nasal_lexer::string_gen()
++ptr; ++ptr;
} }
// check if this string ends with a " or ' // check if this string ends with a " or '
if(ptr>=res_size) if(ptr++>=res_size)
die("["+line_code+"_] get EOF when generating string.",line,line_code.length()); die("["+line_code+"_] get EOF when generating string.",line,line_code.length());
++ptr;
return token_str; return token_str;
} }
@ -318,21 +312,17 @@ void nasal_lexer::scanner()
{ {
// these characters will be ignored, and '\n' will cause ++line // these characters will be ignored, and '\n' will cause ++line
line_code+=res[ptr]; line_code+=res[ptr];
if(res[ptr]=='\n') if(res[ptr++]=='\n')
{ {
++line; ++line;
line_code=""; line_code="";
} }
++ptr;
} }
if(ptr>=res_size) break; if(ptr>=res_size) break;
if(IS_IDENTIFIER(res[ptr])) if(IS_IDENTIFIER(res[ptr]))
{ {
token_str=identifier_gen(); token_str=identifier_gen();
token new_token; token new_token(line,0,token_str);
new_token.line=line;
new_token.str=token_str;
new_token.type=0;
for(int i=0;token_table[i].str;++i) for(int i=0;token_table[i].str;++i)
if(token_str==token_table[i].str) if(token_str==token_table[i].str)
{ {
@ -346,19 +336,13 @@ void nasal_lexer::scanner()
else if(IS_DIGIT(res[ptr])) else if(IS_DIGIT(res[ptr]))
{ {
token_str=number_gen(); token_str=number_gen();
token new_token; token new_token(line,tok_number,token_str);
new_token.line=line;
new_token.str=token_str;
new_token.type=tok_number;
token_list.push_back(new_token); token_list.push_back(new_token);
} }
else if(IS_STRING(res[ptr])) else if(IS_STRING(res[ptr]))
{ {
token_str=string_gen(); token_str=string_gen();
token new_token; token new_token(line,tok_string,token_str);
new_token.line=line;
new_token.type=tok_string;
new_token.str=token_str;
token_list.push_back(new_token); token_list.push_back(new_token);
} }
else if(IS_SINGLE_OPRATOR(res[ptr])) else if(IS_SINGLE_OPRATOR(res[ptr]))
@ -366,10 +350,7 @@ void nasal_lexer::scanner()
token_str=""; token_str="";
token_str+=res[ptr]; token_str+=res[ptr];
line_code+=res[ptr]; line_code+=res[ptr];
token new_token; token new_token(line,-1,token_str);
new_token.line=line;
new_token.str=token_str;
new_token.type=-1;
for(int i=0;token_table[i].str;++i) for(int i=0;token_table[i].str;++i)
if(token_str==token_table[i].str) if(token_str==token_table[i].str)
{ {
@ -394,9 +375,7 @@ void nasal_lexer::scanner()
++ptr; ++ptr;
} }
line_code+=token_str; line_code+=token_str;
token new_token; token new_token(line,-1,token_str);
new_token.line=line;
new_token.str=token_str;
for(int i=0;token_table[i].str;++i) for(int i=0;token_table[i].str;++i)
if(token_str==token_table[i].str) if(token_str==token_table[i].str)
{ {
@ -410,15 +389,10 @@ void nasal_lexer::scanner()
// get calculation operator // get calculation operator
token_str=res[ptr]; token_str=res[ptr];
++ptr; ++ptr;
if(ptr<res.size() && res[ptr]=='=') if(ptr<res_size && res[ptr]=='=')
{ token_str+=res[ptr++];
token_str+=res[ptr];
++ptr;
}
line_code+=token_str; line_code+=token_str;
token new_token; token new_token(line,-1,token_str);
new_token.line=line;
new_token.str=token_str;
for(int i=0;token_table[i].str;++i) for(int i=0;token_table[i].str;++i)
if(token_str==token_table[i].str) if(token_str==token_table[i].str)
{ {
@ -436,9 +410,8 @@ void nasal_lexer::scanner()
} }
else else
{ {
line_code+=res[ptr]; line_code+=res[ptr++];
die("["+line_code+"_] unknown character.",line,line_code.length()); die("["+line_code+"_] unknown character.",line,line_code.length());
++ptr;
} }
} }
return; return;

125
nasal_parse.h
View File

@ -107,38 +107,33 @@ public:
int nasal_parse::get_error() int nasal_parse::get_error()
{ {
return this->error; return error;
} }
void nasal_parse::clear() void nasal_parse::clear()
{ {
this->tok_list_size=0; tok_list_size=ptr=error=in_function=in_loop=0;
this->ptr=0; tok_list.clear();
this->error=0; root.clear();
this->in_function=0;
this->in_loop=0;
this->tok_list.clear();
this->root.clear();
return; return;
} }
void nasal_parse::set_toklist(std::vector<token>& lex_token) void nasal_parse::set_toklist(std::vector<token>& lex_token)
{ {
this->tok_list=lex_token; tok_list=lex_token;
this->tok_list_size=this->tok_list.size(); tok_list_size=tok_list.size();
return; return;
} }
void nasal_parse::main_process() void nasal_parse::main_process()
{ {
this->reset(); reset();
root.set_line(1); root.set_line(1);
root.set_type(ast_root); root.set_type(ast_root);
while(ptr<tok_list_size) while(ptr<tok_list_size)
{ {
root.add_child(expr()); root.add_child(expr());
++ptr; if(++ptr>=tok_list_size)
if(ptr>=tok_list_size)
break; break;
if(tok_list[ptr].type==tok_semi) if(tok_list[ptr].type==tok_semi)
++ptr; ++ptr;
@ -152,10 +147,7 @@ void nasal_parse::main_process()
{ {
int type=root.get_children().back().get_type(); int type=root.get_children().back().get_type();
if(type==ast_continue || type==ast_break || type==ast_return) if(type==ast_continue || type==ast_break || type==ast_return)
{
++error;
die(root.get_children().back().get_line(),ast_str(type)+" is not allowed in main scope"); die(root.get_children().back().get_line(),ast_str(type)+" is not allowed in main scope");
}
} }
} }
return; return;
@ -168,11 +160,8 @@ nasal_ast& nasal_parse::get_root()
void nasal_parse::reset() void nasal_parse::reset()
{ {
this->ptr=0; ptr=in_function=in_loop=error=0;
this->in_function=0; root.clear();
this->in_loop=0;
this->error=0;
this->root.clear();
return; return;
} }
@ -185,7 +174,7 @@ void nasal_parse::die(int line,std::string info)
if(tok_list[ptr].type==tok_semi) if(tok_list[ptr].type==tok_semi)
{ {
--ptr; --ptr;
break; return;
} }
++ptr; ++ptr;
} }
@ -199,7 +188,6 @@ bool nasal_parse::check_multi_definition()
bool nasal_parse::check_multi_scalar() bool nasal_parse::check_multi_scalar()
{ {
bool ret=false;
int check_ptr=ptr+1,curve_cnt=1,bracket_cnt=0,brace_cnt=0; int check_ptr=ptr+1,curve_cnt=1,bracket_cnt=0,brace_cnt=0;
while(check_ptr<tok_list_size && curve_cnt) while(check_ptr<tok_list_size && curve_cnt)
{ {
@ -213,13 +201,10 @@ bool nasal_parse::check_multi_scalar()
case tok_right_brace: --brace_cnt; break; case tok_right_brace: --brace_cnt; break;
} }
if(curve_cnt==1 && !bracket_cnt && !brace_cnt && tok_list[check_ptr].type==tok_comma) if(curve_cnt==1 && !bracket_cnt && !brace_cnt && tok_list[check_ptr].type==tok_comma)
{ return true;
ret=true;
break;
}
++check_ptr; ++check_ptr;
} }
return ret; return false;
} }
bool nasal_parse::check_function_end(nasal_ast& node) bool nasal_parse::check_function_end(nasal_ast& node)
@ -251,9 +236,7 @@ bool nasal_parse::check_special_call()
{ {
// special call means like this: // special call means like this:
// function_name(a:1,b:2,c:3); // function_name(a:1,b:2,c:3);
int check_ptr=ptr+1; int check_ptr=ptr+1,curve_cnt=1,bracket_cnt=0,brace_cnt=0,ques_cnt=0;
int curve_cnt=1,bracket_cnt=0,brace_cnt=0,ques_cnt=0;
bool ret=false;
while(check_ptr<tok_list_size && curve_cnt) while(check_ptr<tok_list_size && curve_cnt)
{ {
switch(tok_list[check_ptr].type) switch(tok_list[check_ptr].type)
@ -265,20 +248,14 @@ bool nasal_parse::check_special_call()
case tok_right_bracket:--bracket_cnt;break; case tok_right_bracket:--bracket_cnt;break;
case tok_right_brace: --brace_cnt; break; case tok_right_brace: --brace_cnt; break;
} }
// m?1:0 will be recognized as normal parameter
if(curve_cnt==1 && !bracket_cnt && !brace_cnt && tok_list[check_ptr].type==tok_quesmark) if(curve_cnt==1 && !bracket_cnt && !brace_cnt && tok_list[check_ptr].type==tok_quesmark)
{ return false;
// m?1:0 will be recognized as normal parameter
ret=false;
break;
}
if(curve_cnt==1 && !bracket_cnt && !brace_cnt && tok_list[check_ptr].type==tok_colon) if(curve_cnt==1 && !bracket_cnt && !brace_cnt && tok_list[check_ptr].type==tok_colon)
{ return true;
ret=true;
break;
}
++check_ptr; ++check_ptr;
} }
return ret; return false;
} }
bool nasal_parse::need_semi_check(nasal_ast& node) bool nasal_parse::need_semi_check(nasal_ast& node)
@ -329,8 +306,7 @@ nasal_ast nasal_parse::vector_gen()
while(ptr<tok_list_size && tok_list[ptr].type!=tok_right_bracket) while(ptr<tok_list_size && tok_list[ptr].type!=tok_right_bracket)
{ {
node.add_child(calculation()); node.add_child(calculation());
++ptr; if(++ptr>=tok_list_size)
if(ptr>=tok_list_size)
break; break;
if(tok_list[ptr].type==tok_comma) if(tok_list[ptr].type==tok_comma)
++ptr; ++ptr;
@ -348,8 +324,7 @@ nasal_ast nasal_parse::hash_gen()
while (ptr<tok_list_size && tok_list[ptr].type!=tok_right_brace) while (ptr<tok_list_size && tok_list[ptr].type!=tok_right_brace)
{ {
node.add_child(hash_member_gen()); node.add_child(hash_member_gen());
++ptr; if(++ptr>=tok_list_size)
if(ptr>=tok_list_size)
break; break;
if(tok_list[ptr].type==tok_comma) if(tok_list[ptr].type==tok_comma)
++ptr; ++ptr;
@ -384,8 +359,7 @@ nasal_ast nasal_parse::hash_member_gen()
nasal_ast nasal_parse::func_gen() nasal_ast nasal_parse::func_gen()
{ {
nasal_ast node(tok_list[ptr].line,ast_function); nasal_ast node(tok_list[ptr].line,ast_function);
++ptr; if(++ptr>=tok_list_size)
if(ptr>=tok_list_size)
{ {
die(error_line,"expected \"(\""); die(error_line,"expected \"(\"");
return node; return node;
@ -444,8 +418,7 @@ nasal_ast nasal_parse::args_list_gen()
--ptr; --ptr;
node.add_child(tmp); node.add_child(tmp);
} }
++ptr; if(++ptr>=tok_list_size)
if(ptr>=tok_list_size)
break; break;
if(tok_list[ptr].type==tok_comma) if(tok_list[ptr].type==tok_comma)
++ptr; ++ptr;
@ -556,8 +529,7 @@ nasal_ast nasal_parse::exprs_gen()
while(ptr<tok_list_size && tok_list[ptr].type!=tok_right_brace) while(ptr<tok_list_size && tok_list[ptr].type!=tok_right_brace)
{ {
node.add_child(expr()); node.add_child(expr());
++ptr; if(++ptr>=tok_list_size)
if(ptr>=tok_list_size)
break; break;
else if(tok_list[ptr].type==tok_semi) else if(tok_list[ptr].type==tok_semi)
++ptr; ++ptr;
@ -661,8 +633,7 @@ nasal_ast nasal_parse::or_expr()
{ {
nasal_ast tmp(tok_list[ptr].line,ast_or); nasal_ast tmp(tok_list[ptr].line,ast_or);
tmp.add_child(node); tmp.add_child(node);
++ptr; if(++ptr<tok_list_size)
if(ptr<tok_list_size)
tmp.add_child(and_expr()); tmp.add_child(and_expr());
else else
die(error_line,"expected calculation"); die(error_line,"expected calculation");
@ -682,8 +653,7 @@ nasal_ast nasal_parse::and_expr()
{ {
nasal_ast tmp(tok_list[ptr].line,ast_and); nasal_ast tmp(tok_list[ptr].line,ast_and);
tmp.add_child(node); tmp.add_child(node);
++ptr; if(++ptr<tok_list_size)
if(ptr<tok_list_size)
tmp.add_child(cmp_expr()); tmp.add_child(cmp_expr());
else else
die(error_line,"expected calculation"); die(error_line,"expected calculation");
@ -740,8 +710,7 @@ nasal_ast nasal_parse::cmp_expr()
// tok_cmp_equal~tok_greater_equal is 43~48,ast_cmp_equal~ast_greater_equal is 27~32 // tok_cmp_equal~tok_greater_equal is 43~48,ast_cmp_equal~ast_greater_equal is 27~32
nasal_ast tmp(tok_list[ptr].line,tok_list[ptr].type-tok_cmp_equal+ast_cmp_equal); nasal_ast tmp(tok_list[ptr].line,tok_list[ptr].type-tok_cmp_equal+ast_cmp_equal);
tmp.add_child(node); tmp.add_child(node);
++ptr; if(++ptr<tok_list_size)
if(ptr<tok_list_size)
tmp.add_child(additive_expr()); tmp.add_child(additive_expr());
else else
die(error_line,"expected calculation"); die(error_line,"expected calculation");
@ -873,8 +842,7 @@ nasal_ast nasal_parse::additive_expr()
case tok_link: tmp.set_type(ast_link); break; case tok_link: tmp.set_type(ast_link); break;
} }
tmp.add_child(node); tmp.add_child(node);
++ptr; if(++ptr<tok_list_size)
if(ptr<tok_list_size)
tmp.add_child(multive_expr()); tmp.add_child(multive_expr());
else else
die(error_line,"expected calculation"); die(error_line,"expected calculation");
@ -978,8 +946,7 @@ nasal_ast nasal_parse::multive_expr()
{ {
nasal_ast tmp(tok_list[ptr].line,tok_list[ptr].type-tok_mult+ast_mult); nasal_ast tmp(tok_list[ptr].line,tok_list[ptr].type-tok_mult+ast_mult);
tmp.add_child(node); tmp.add_child(node);
++ptr; if(++ptr<tok_list_size)
if(ptr<tok_list_size)
tmp.add_child((tok_list[ptr].type==tok_sub || tok_list[ptr].type==tok_not)?unary():scalar()); tmp.add_child((tok_list[ptr].type==tok_sub || tok_list[ptr].type==tok_not)?unary():scalar());
else else
{ {
@ -1052,8 +1019,7 @@ nasal_ast nasal_parse::unary()
case tok_sub:node.set_type(ast_unary_sub);break; case tok_sub:node.set_type(ast_unary_sub);break;
case tok_not:node.set_type(ast_unary_not);break; case tok_not:node.set_type(ast_unary_not);break;
} }
++ptr; if(++ptr<tok_list_size)
if(ptr<tok_list_size)
node.add_child((tok_list[ptr].type==tok_sub || tok_list[ptr].type==tok_not)?unary():scalar()); node.add_child((tok_list[ptr].type==tok_sub || tok_list[ptr].type==tok_not)?unary():scalar());
else else
die(error_line,"expected calculation"); die(error_line,"expected calculation");
@ -1186,8 +1152,7 @@ nasal_ast nasal_parse::call_vector()
while(ptr<tok_list_size && tok_list[ptr].type!=tok_right_bracket) while(ptr<tok_list_size && tok_list[ptr].type!=tok_right_bracket)
{ {
node.add_child(subvec()); node.add_child(subvec());
++ptr; if(++ptr>=tok_list_size)
if(ptr>=tok_list_size)
break; break;
else if(tok_list[ptr].type==tok_comma) else if(tok_list[ptr].type==tok_comma)
++ptr; ++ptr;
@ -1206,8 +1171,7 @@ nasal_ast nasal_parse::call_func()
while(ptr<tok_list_size && tok_list[ptr].type!=tok_right_curve) while(ptr<tok_list_size && tok_list[ptr].type!=tok_right_curve)
{ {
node.add_child(special_call?hash_member_gen():calculation()); node.add_child(special_call?hash_member_gen():calculation());
++ptr; if(++ptr>=tok_list_size)
if(ptr>=tok_list_size)
break; break;
else if(tok_list[ptr].type==tok_comma) else if(tok_list[ptr].type==tok_comma)
++ptr; ++ptr;
@ -1230,8 +1194,7 @@ nasal_ast nasal_parse::subvec()
++ptr; ++ptr;
if(ptr<tok_list_size && tok_list[ptr].type==tok_colon) if(ptr<tok_list_size && tok_list[ptr].type==tok_colon)
{ {
++ptr; if(++ptr>=tok_list_size)
if(ptr>=tok_list_size)
return node; return node;
nasal_ast tmp(node.get_line(),ast_subvec); nasal_ast tmp(node.get_line(),ast_subvec);
tmp.add_child(node); tmp.add_child(node);
@ -1271,8 +1234,7 @@ nasal_ast nasal_parse::definition()
die(error_line,"expected \"=\" / don\'t call identifier in definition"); die(error_line,"expected \"=\" / don\'t call identifier in definition");
return node; return node;
} }
++ptr; if(++ptr>=tok_list_size)
if(ptr>=tok_list_size)
{ {
die(error_line,"expected scalar"); die(error_line,"expected scalar");
return node; return node;
@ -1293,8 +1255,7 @@ nasal_ast nasal_parse::definition()
nasal_ast nasal_parse::var_incurve_def() nasal_ast nasal_parse::var_incurve_def()
{ {
nasal_ast node; nasal_ast node;
++ptr;// check_multi_definition will check the 'var' ptr+=2;// check_multi_definition will check the 'var'
++ptr;
if(ptr>=tok_list_size || tok_list[ptr].type!=tok_identifier) if(ptr>=tok_list_size || tok_list[ptr].type!=tok_identifier)
{ {
die(error_line,"expected identifier"); die(error_line,"expected identifier");
@ -1359,8 +1320,7 @@ nasal_ast nasal_parse::multi_scalar(bool check_call_memory)
int type=node.get_children().back().get_type(); int type=node.get_children().back().get_type();
if(check_call_memory && type!=ast_call && type!=ast_identifier) if(check_call_memory && type!=ast_call && type!=ast_identifier)
die(node.get_children().back().get_line(),"cannot use calculation as the memory of scalar"); die(node.get_children().back().get_line(),"cannot use calculation as the memory of scalar");
++ptr; if(++ptr>=tok_list_size)
if(ptr>=tok_list_size)
break; break;
if(tok_list[ptr].type==tok_comma) if(tok_list[ptr].type==tok_comma)
++ptr; ++ptr;
@ -1381,8 +1341,7 @@ nasal_ast nasal_parse::multi_assgin()
die(error_line,"expected \"=\""); die(error_line,"expected \"=\"");
return node; return node;
} }
++ptr; if(++ptr>=tok_list_size)
if(ptr>=tok_list_size)
{ {
die(error_line,"expected value list"); die(error_line,"expected value list");
return node; return node;
@ -1470,8 +1429,7 @@ nasal_ast nasal_parse::for_loop()
return node; return node;
} }
// conditional expression // conditional expression
++ptr; if(++ptr>=tok_list_size)
if(ptr>=tok_list_size)
{ {
die(error_line,"expected conditional expression"); die(error_line,"expected conditional expression");
return node; return node;
@ -1490,8 +1448,7 @@ nasal_ast nasal_parse::for_loop()
return node; return node;
} }
//after loop expression //after loop expression
++ptr; if(++ptr>=tok_list_size)
if(ptr>=tok_list_size)
{ {
die(error_line,"expected calculation"); die(error_line,"expected calculation");
return node; return node;
@ -1542,8 +1499,7 @@ nasal_ast nasal_parse::forei_loop()
die(error_line,"expected \";\""); die(error_line,"expected \";\"");
return node; return node;
} }
++ptr; if(++ptr>=tok_list_size)
if(ptr>=tok_list_size)
{ {
die(error_line,"expected vector"); die(error_line,"expected vector");
return node; return node;
@ -1669,8 +1625,7 @@ nasal_ast nasal_parse::break_expr()
nasal_ast nasal_parse::return_expr() nasal_ast nasal_parse::return_expr()
{ {
nasal_ast node(tok_list[ptr].line,ast_return); nasal_ast node(tok_list[ptr].line,ast_return);
++ptr; if(++ptr<tok_list_size)
if(ptr<tok_list_size)
{ {
int type=tok_list[ptr].type; int type=tok_list[ptr].type;
if(type==tok_nil || type==tok_number || type==tok_string || type==tok_identifier || type==tok_func || if(type==tok_nil || type==tok_number || type==tok_string || type==tok_identifier || type==tok_func ||