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

bug fixed

This commit is contained in:
Valk Richard Li 2021-03-28 17:39:24 +08:00
parent 144e6f45da
commit be1bcdfe2c
5 changed files with 299 additions and 338 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

40
nasal_ast.h
View File

@ -92,34 +92,34 @@ std::string ast_name(int type)
class nasal_ast class nasal_ast
{ {
private: private:
int line; int line;
int type; int type;
double num;
std::string str; std::string str;
double num;
std::vector<nasal_ast> children; std::vector<nasal_ast> children;
public: public:
nasal_ast(int,int); nasal_ast(int,int);
nasal_ast(const nasal_ast&); nasal_ast(const nasal_ast&);
~nasal_ast(); ~nasal_ast();
nasal_ast& operator=(const nasal_ast&); nasal_ast& operator=(const nasal_ast&);
void clear(); void print_ast(int);
void set_line(int); void clear();
void set_type(int); void set_line(int);
void set_str(std::string&); void set_type(int);
void set_num(double); void set_str(std::string&);
void add_child(nasal_ast); void set_num(double);
void add_child(nasal_ast);
int get_line(); int get_line();
int get_type(); int get_type();
std::string get_str();
double get_num(); double get_num();
std::string get_str();
std::vector<nasal_ast>& get_children(); std::vector<nasal_ast>& get_children();
void print_ast(int);
}; };
nasal_ast::nasal_ast(int init_line=0,int init_type=ast_null) nasal_ast::nasal_ast(int _line=0,int _type=ast_null)
{ {
line=init_line; line=_line;
type=init_type; type=_type;
return; return;
} }
@ -127,8 +127,8 @@ nasal_ast::nasal_ast(const nasal_ast& tmp)
{ {
line=tmp.line; line=tmp.line;
type=tmp.type; type=tmp.type;
str=tmp.str; str =tmp.str;
num=tmp.num; num =tmp.num;
children=tmp.children; children=tmp.children;
return; return;
} }
@ -217,9 +217,9 @@ std::vector<nasal_ast>& nasal_ast::get_children()
void nasal_ast::print_ast(int depth) void nasal_ast::print_ast(int depth)
{ {
std::string indentation=""; std::string indentation="";
for(int i=0;i<depth;++i) indentation+="| "; for(int i=0;i<depth;++i)
indentation+=ast_name(type); indentation+="| ";
std::cout<<indentation; std::cout<<indentation<<ast_name(type);
if(type==ast_str || type==ast_id || type==ast_dynamic_id || type==ast_callh) if(type==ast_str || type==ast_id || type==ast_dynamic_id || type==ast_callh)
std::cout<<":"<<str; std::cout<<":"<<str;
else if(type==ast_num) else if(type==ast_num)

499
nasal_builtin.h
View File

@ -14,7 +14,7 @@ std::unordered_map<std::string,int> builtin_use_str_table;
// used to find values that builtin function uses // used to find values that builtin function uses
#define in_builtin_find(val_name) \ #define in_builtin_find(val_name) \
(\ (\
local_scope_addr\ local_scope\
->ptr.scop\ ->ptr.scop\
->get_val\ ->get_val\
(builtin_use_str_table[val_name])\ (builtin_use_str_table[val_name])\
@ -65,7 +65,7 @@ nasal_val* builtin_right(nasal_val*);
nasal_val* builtin_cmp(nasal_val*); nasal_val* builtin_cmp(nasal_val*);
nasal_val* builtin_chr(nasal_val*); nasal_val* builtin_chr(nasal_val*);
void builtin_error_occurred(std::string func_name,std::string info) void builtin_err(std::string func_name,std::string info)
{ {
std::cout<<">> [vm] "<<func_name<<": "<<info<<".\n"; std::cout<<">> [vm] "<<func_name<<": "<<info<<".\n";
return; return;
@ -123,12 +123,12 @@ struct FUNC_TABLE
{"", nullptr } {"", nullptr }
}; };
nasal_val* builtin_print(nasal_val* local_scope_addr) nasal_val* builtin_print(nasal_val* local_scope)
{ {
// get arguments // get arguments
nasal_val* vector_value_addr=in_builtin_find("elements"); nasal_val* vector_val_addr=in_builtin_find("elements");
// main process // main process
std::vector<nasal_val*>& ref_vec=vector_value_addr->ptr.vec->elems; std::vector<nasal_val*>& ref_vec=vector_val_addr->ptr.vec->elems;
int size=ref_vec.size(); int size=ref_vec.size();
for(int i=0;i<size;++i) for(int i=0;i<size;++i)
{ {
@ -146,103 +146,94 @@ nasal_val* builtin_print(nasal_val* local_scope_addr)
// generate return value // generate return value
return nil_addr; return nil_addr;
} }
nasal_val* builtin_append(nasal_val* local_scope_addr) nasal_val* builtin_append(nasal_val* local_scope)
{ {
nasal_val* vector_value_addr=in_builtin_find("vector"); nasal_val* vec_addr=in_builtin_find("vector");
nasal_val* elem_value_addr=in_builtin_find("elements"); nasal_val* elem_addr=in_builtin_find("elements");
if(vector_value_addr->type!=vm_vec) if(vec_addr->type!=vm_vec)
{ {
builtin_error_occurred("append","\"vector\" must be vector"); builtin_err("append","\"vector\" must be vector");
return nullptr; return nullptr;
} }
nasal_vec& ref_vector=*vector_value_addr->ptr.vec; std::vector<nasal_val*>& ref_vec=vec_addr->ptr.vec->elems;
nasal_vec& ref_elements=*elem_value_addr->ptr.vec; std::vector<nasal_val*>& ref_elems=elem_addr->ptr.vec->elems;
int size=ref_elements.elems.size(); int size=ref_elems.size();
for(int i=0;i<size;++i) for(int i=0;i<size;++i)
{ ref_vec.push_back(ref_elems[i]);
nasal_val* value_address=ref_elements.get_val(i);
ref_vector.elems.push_back(value_address);
}
return nil_addr; return nil_addr;
} }
nasal_val* builtin_setsize(nasal_val* local_scope_addr) nasal_val* builtin_setsize(nasal_val* local_scope)
{ {
nasal_val* vector_value_addr=in_builtin_find("vector"); nasal_val* vec_addr=in_builtin_find("vector");
nasal_val* size_value_addr=in_builtin_find("size"); nasal_val* size_addr=in_builtin_find("size");
if(vector_value_addr->type!=vm_vec) if(vec_addr->type!=vm_vec)
{ {
builtin_error_occurred("setsize","\"vector\" must be vector"); builtin_err("setsize","\"vector\" must be vector");
return nullptr; return nullptr;
} }
int type=size_value_addr->type; if(size_addr->type!=vm_num)
if(type!=vm_num)
{ {
builtin_error_occurred("setsize","\"size\" is not a number"); builtin_err("setsize","\"size\" is not a number");
return nullptr; return nullptr;
} }
int number=size_value_addr->ptr.num; int num=size_addr->ptr.num;
if(number<0) if(num<0)
{ {
builtin_error_occurred("setsize","\"size\" must be greater than -1"); builtin_err("setsize","\"size\" must be greater than -1");
return nullptr; return nullptr;
} }
nasal_vec& ref_vector=*vector_value_addr->ptr.vec; std::vector<nasal_val*>& ref_vec=vec_addr->ptr.vec->elems;
int vec_size=ref_vector.elems.size(); int vec_size=ref_vec.size();
if(number<vec_size) if(num<vec_size)
for(int i=number;i<vec_size;++i) for(int i=num;i<vec_size;++i)
ref_vector.elems.pop_back(); ref_vec.pop_back();
else if(number>vec_size) else if(num>vec_size)
for(int i=vec_size;i<number;++i) for(int i=vec_size;i<num;++i)
{ ref_vec.push_back(nil_addr);
nasal_val* new_val_addr=nil_addr;
ref_vector.elems.push_back(new_val_addr);
}
return nil_addr; return nil_addr;
} }
nasal_val* builtin_system(nasal_val* local_scope_addr) nasal_val* builtin_system(nasal_val* local_scope)
{ {
nasal_val* str_value_addr=in_builtin_find("str"); nasal_val* str_addr=in_builtin_find("str");
if(str_value_addr->type!=vm_str) if(str_addr->type!=vm_str)
{ {
builtin_error_occurred("system","\"str\" must be string"); builtin_err("system","\"str\" must be string");
return nullptr; return nullptr;
} }
system(str_value_addr->ptr.str->data()); system(str_addr->ptr.str->data());
nasal_val* ret_addr=nil_addr; return nil_addr;
return ret_addr;
} }
nasal_val* builtin_input(nasal_val* local_scope_addr) nasal_val* builtin_input(nasal_val* local_scope)
{ {
nasal_val* ret_addr=gc_alloc(vm_str); nasal_val* ret_addr=gc_alloc(vm_str);
std::cin>>*ret_addr->ptr.str; std::cin>>*ret_addr->ptr.str;
return ret_addr; return ret_addr;
} }
nasal_val* builtin_sleep(nasal_val* local_scope_addr) nasal_val* builtin_sleep(nasal_val* local_scope)
{ {
nasal_val* value_addr=in_builtin_find("duration"); nasal_val* val_addr=in_builtin_find("duration");
int type=value_addr->type; if(val_addr->type!=vm_num)
if(type!=vm_num)
{ {
builtin_error_occurred("sleep","\"duration\" must be number"); builtin_err("sleep","\"duration\" must be number");
return nullptr; return nullptr;
} }
// sleep in unistd.h will make this progress sleep sleep_time seconds. // sleep in unistd.h will make this progress sleep sleep_time seconds.
sleep((unsigned long)value_addr->ptr.num); sleep((unsigned long)val_addr->ptr.num);
return nil_addr; return nil_addr;
} }
nasal_val* builtin_fin(nasal_val* local_scope_addr) nasal_val* builtin_fin(nasal_val* local_scope)
{ {
nasal_val* value_addr=in_builtin_find("filename"); nasal_val* val_addr=in_builtin_find("filename");
if(value_addr->type!=vm_str) if(val_addr->type!=vm_str)
{ {
builtin_error_occurred("io.fin","\"filename\" must be string"); builtin_err("io.fin","\"filename\" must be string");
return nullptr; return nullptr;
} }
std::string& filename=*value_addr->ptr.str; std::string& filename=*val_addr->ptr.str;
std::ifstream fin(filename); std::ifstream fin(filename);
nasal_val* ret_addr=gc_alloc(vm_str); nasal_val* ret_addr=gc_alloc(vm_str);
*ret_addr->ptr.str=""; *ret_addr->ptr.str="";
@ -255,57 +246,57 @@ nasal_val* builtin_fin(nasal_val* local_scope_addr)
ret_addr->ptr.str->push_back(c); ret_addr->ptr.str->push_back(c);
} }
else else
builtin_error_occurred("io.fin","cannot open \""+filename+"\""); builtin_err("io.fin","cannot open \""+filename+"\"");
fin.close(); fin.close();
return ret_addr; return ret_addr;
} }
nasal_val* builtin_fout(nasal_val* local_scope_addr) nasal_val* builtin_fout(nasal_val* local_scope)
{ {
nasal_val* value_addr=in_builtin_find("filename"); nasal_val* val_addr=in_builtin_find("filename");
nasal_val* str_value_addr=in_builtin_find("str"); nasal_val* str_addr=in_builtin_find("str");
if(value_addr->type!=vm_str) if(val_addr->type!=vm_str)
{ {
builtin_error_occurred("io.fout","\"filename\" must be string"); builtin_err("io.fout","\"filename\" must be string");
return nullptr; return nullptr;
} }
if(str_value_addr->type!=vm_str) if(str_addr->type!=vm_str)
{ {
builtin_error_occurred("io.fout","\"str\" must be string"); builtin_err("io.fout","\"str\" must be string");
return nullptr; return nullptr;
} }
std::ofstream fout(*value_addr->ptr.str); std::ofstream fout(*val_addr->ptr.str);
if(fout.fail()) if(fout.fail())
{ {
builtin_error_occurred("io.fout","cannot open \""+*value_addr->ptr.str+"\""); builtin_err("io.fout","cannot open \""+*val_addr->ptr.str+"\"");
return nullptr; return nullptr;
} }
fout<<*str_value_addr->ptr.str; fout<<*str_addr->ptr.str;
fout.close(); fout.close();
return nil_addr; return nil_addr;
} }
nasal_val* builtin_split(nasal_val* local_scope_addr) nasal_val* builtin_split(nasal_val* local_scope)
{ {
nasal_val* delimeter_value_addr=in_builtin_find("delimeter"); nasal_val* delimeter_val_addr=in_builtin_find("delimeter");
nasal_val* string_value_addr=in_builtin_find("string"); nasal_val* string_val_addr=in_builtin_find("string");
if(delimeter_value_addr->type!=vm_str) if(delimeter_val_addr->type!=vm_str)
{ {
builtin_error_occurred("split","\"delimeter\" must be string"); builtin_err("split","\"delimeter\" must be string");
return nullptr; return nullptr;
} }
if(string_value_addr->type!=vm_str) if(string_val_addr->type!=vm_str)
{ {
builtin_error_occurred("split","\"string\" must be string"); builtin_err("split","\"string\" must be string");
return nullptr; return nullptr;
} }
std::string delimeter=*delimeter_value_addr->ptr.str; std::string delimeter=*delimeter_val_addr->ptr.str;
std::string source=*string_value_addr->ptr.str; std::string source=*string_val_addr->ptr.str;
int delimeter_len=delimeter.length(); int delimeter_len=delimeter.length();
int source_len=source.length(); int source_len=source.length();
nasal_val* ret_addr=gc_alloc(vm_vec); nasal_val* ret_addr=gc_alloc(vm_vec);
nasal_vec& ref_vec=*ret_addr->ptr.vec; std::vector<nasal_val*>& ref_vec=ret_addr->ptr.vec->elems;
std::string tmp=""; std::string tmp="";
if(!delimeter_len) if(!delimeter_len)
@ -314,7 +305,7 @@ nasal_val* builtin_split(nasal_val* local_scope_addr)
{ {
nasal_val* str_addr=gc_alloc(vm_str); nasal_val* str_addr=gc_alloc(vm_str);
*str_addr->ptr.str=source[i]; *str_addr->ptr.str=source[i];
ref_vec.elems.push_back(str_addr); ref_vec.push_back(str_addr);
} }
return ret_addr; return ret_addr;
} }
@ -336,7 +327,7 @@ nasal_val* builtin_split(nasal_val* local_scope_addr)
{ {
nasal_val* str_addr=gc_alloc(vm_str); nasal_val* str_addr=gc_alloc(vm_str);
*str_addr->ptr.str=tmp; *str_addr->ptr.str=tmp;
ref_vec.elems.push_back(str_addr); ref_vec.push_back(str_addr);
tmp=""; tmp="";
} }
i+=delimeter_len-1; i+=delimeter_len-1;
@ -348,25 +339,23 @@ nasal_val* builtin_split(nasal_val* local_scope_addr)
{ {
nasal_val* str_addr=gc_alloc(vm_str); nasal_val* str_addr=gc_alloc(vm_str);
*str_addr->ptr.str=tmp; *str_addr->ptr.str=tmp;
ref_vec.elems.push_back(str_addr); ref_vec.push_back(str_addr);
tmp=""; tmp="";
} }
return ret_addr; return ret_addr;
} }
nasal_val* builtin_rand(nasal_val* local_scope_addr) nasal_val* builtin_rand(nasal_val* local_scope)
{ {
nasal_val* value_addr=in_builtin_find("seed"); nasal_val* val_addr=in_builtin_find("seed");
if(value_addr->type!=vm_num && value_addr->type!=vm_nil) if(val_addr->type!=vm_num && val_addr->type!=vm_nil)
{ {
builtin_error_occurred("rand","\"seed\" must be nil or number"); builtin_err("rand","\"seed\" must be nil or number");
return nullptr; return nullptr;
} }
if(value_addr->type==vm_num) if(val_addr->type==vm_num)
{ {
unsigned int number=(unsigned int)value_addr->ptr.num; srand((unsigned int)val_addr->ptr.num);
srand(number); return nil_addr;
nasal_val* ret_addr=nil_addr;
return ret_addr;
} }
double num=0; double num=0;
for(int i=0;i<5;++i) for(int i=0;i<5;++i)
@ -375,99 +364,96 @@ nasal_val* builtin_rand(nasal_val* local_scope_addr)
ret_addr->ptr.num=num; ret_addr->ptr.num=num;
return ret_addr; return ret_addr;
} }
nasal_val* builtin_id(nasal_val* local_scope_addr) nasal_val* builtin_id(nasal_val* local_scope)
{ {
nasal_val* value_addr=in_builtin_find("thing"); nasal_val* val_addr=in_builtin_find("thing");
nasal_val* ret_addr=gc_alloc(vm_str); nasal_val* ret_addr=gc_alloc(vm_str);
char buf[32]; char buf[32];
sprintf(buf,"0x%p",value_addr); sprintf(buf,"0x%p",val_addr);
*ret_addr->ptr.str=buf; *ret_addr->ptr.str=buf;
return ret_addr; return ret_addr;
} }
nasal_val* builtin_int(nasal_val* local_scope_addr) nasal_val* builtin_int(nasal_val* local_scope)
{ {
nasal_val* value_addr=in_builtin_find("value"); nasal_val* val_addr=in_builtin_find("value");
if(value_addr->type!=vm_num) if(val_addr->type!=vm_num)
{ {
builtin_error_occurred("int","\"value\" must be number"); builtin_err("int","\"value\" must be number");
return nullptr; return nullptr;
} }
int number=(int)value_addr->ptr.num; int number=(int)val_addr->ptr.num;
nasal_val* ret_addr=gc_alloc(vm_num); nasal_val* ret_addr=gc_alloc(vm_num);
ret_addr->ptr.num=(double)number; ret_addr->ptr.num=(double)number;
return ret_addr; return ret_addr;
} }
nasal_val* builtin_num(nasal_val* local_scope_addr) nasal_val* builtin_num(nasal_val* local_scope)
{ {
nasal_val* value_addr=in_builtin_find("value"); nasal_val* val_addr=in_builtin_find("value");
if(value_addr->type!=vm_str) if(val_addr->type!=vm_str)
{ {
builtin_error_occurred("num","\"value\" must be string"); builtin_err("num","\"value\" must be string");
return nullptr; return nullptr;
} }
nasal_val* ret_addr=gc_alloc(vm_num); nasal_val* ret_addr=gc_alloc(vm_num);
ret_addr->ptr.num=value_addr->to_number(); ret_addr->ptr.num=val_addr->to_number();
return ret_addr; return ret_addr;
} }
nasal_val* builtin_pop(nasal_val* local_scope_addr) nasal_val* builtin_pop(nasal_val* local_scope)
{ {
nasal_val* value_addr=in_builtin_find("vector"); nasal_val* val_addr=in_builtin_find("vector");
if(value_addr->type!=vm_vec) if(val_addr->type!=vm_vec)
{ {
builtin_error_occurred("pop","\"vector\" must be vector"); builtin_err("pop","\"vector\" must be vector");
return nullptr; return nullptr;
} }
if(value_addr->ptr.vec->elems.size()) if(val_addr->ptr.vec->elems.size())
{ {
nasal_val* tmp=value_addr->ptr.vec->elems.back(); nasal_val* tmp=val_addr->ptr.vec->elems.back();
value_addr->ptr.vec->elems.pop_back(); val_addr->ptr.vec->elems.pop_back();
return tmp; return tmp;
} }
return nil_addr; return nil_addr;
} }
nasal_val* builtin_str(nasal_val* local_scope_addr) nasal_val* builtin_str(nasal_val* local_scope)
{ {
nasal_val* value_addr=in_builtin_find("number"); nasal_val* val_addr=in_builtin_find("number");
if(value_addr->type!=vm_num) if(val_addr->type!=vm_num)
{ {
builtin_error_occurred("str","\"number\" must be number"); builtin_err("str","\"number\" must be number");
return nullptr; return nullptr;
} }
nasal_val* ret_addr=gc_alloc(vm_num); nasal_val* ret_addr=gc_alloc(vm_str);
*ret_addr->ptr.str=value_addr->to_string(); *ret_addr->ptr.str=val_addr->to_string();
return ret_addr; return ret_addr;
} }
nasal_val* builtin_size(nasal_val* local_scope_addr) nasal_val* builtin_size(nasal_val* local_scope)
{ {
nasal_val* value_addr=in_builtin_find("object"); nasal_val* val_addr=in_builtin_find("object");
int type=value_addr->type;
int number=-1;
switch(type)
{
case vm_nil:
case vm_num:
case vm_func:
case vm_scop: return nil_addr; break;
case vm_str: number=value_addr->ptr.str->length(); break;
case vm_vec: number=value_addr->ptr.vec->elems.size(); break;
case vm_hash: number=value_addr->ptr.hash->elems.size();break;
}
nasal_val* ret_addr=gc_alloc(vm_num); nasal_val* ret_addr=gc_alloc(vm_num);
ret_addr->ptr.num=number; switch(val_addr->type)
{
case vm_nil: ret_addr->ptr.num=0; break;
case vm_num: ret_addr->ptr.num=val_addr->ptr.num; break;
case vm_func: ret_addr->ptr.num=0; break;
case vm_scop: ret_addr->ptr.num=val_addr->ptr.scop->elems.size();break;
case vm_str: ret_addr->ptr.num=val_addr->ptr.str->length(); break;
case vm_vec: ret_addr->ptr.num=val_addr->ptr.vec->elems.size(); break;
case vm_hash: ret_addr->ptr.num=val_addr->ptr.hash->elems.size();break;
}
return ret_addr; return ret_addr;
} }
nasal_val* builtin_xor(nasal_val* local_scope_addr) nasal_val* builtin_xor(nasal_val* local_scope)
{ {
nasal_val* a_addr=in_builtin_find("a"); nasal_val* a_addr=in_builtin_find("a");
nasal_val* b_addr=in_builtin_find("b"); nasal_val* b_addr=in_builtin_find("b");
if(a_addr->type!=vm_num) if(a_addr->type!=vm_num)
{ {
builtin_error_occurred("xor","\"a\" must be number"); builtin_err("xor","\"a\" must be number");
return nullptr; return nullptr;
} }
if(b_addr->type!=vm_num) if(b_addr->type!=vm_num)
{ {
builtin_error_occurred("xor","\"b\" must be number"); builtin_err("xor","\"b\" must be number");
return nullptr; return nullptr;
} }
int number_a=(int)a_addr->ptr.num; int number_a=(int)a_addr->ptr.num;
@ -476,18 +462,18 @@ nasal_val* builtin_xor(nasal_val* local_scope_addr)
ret_addr->ptr.num=(number_a^number_b); ret_addr->ptr.num=(number_a^number_b);
return ret_addr; return ret_addr;
} }
nasal_val* builtin_and(nasal_val* local_scope_addr) nasal_val* builtin_and(nasal_val* local_scope)
{ {
nasal_val* a_addr=in_builtin_find("a"); nasal_val* a_addr=in_builtin_find("a");
nasal_val* b_addr=in_builtin_find("b"); nasal_val* b_addr=in_builtin_find("b");
if(a_addr->type!=vm_num) if(a_addr->type!=vm_num)
{ {
builtin_error_occurred("and","\"a\" must be number"); builtin_err("and","\"a\" must be number");
return nullptr; return nullptr;
} }
if(b_addr->type!=vm_num) if(b_addr->type!=vm_num)
{ {
builtin_error_occurred("and","\"b\" must be number"); builtin_err("and","\"b\" must be number");
return nullptr; return nullptr;
} }
int number_a=(int)a_addr->ptr.num; int number_a=(int)a_addr->ptr.num;
@ -496,18 +482,18 @@ nasal_val* builtin_and(nasal_val* local_scope_addr)
ret_addr->ptr.num=(number_a&number_b); ret_addr->ptr.num=(number_a&number_b);
return ret_addr; return ret_addr;
} }
nasal_val* builtin_or(nasal_val* local_scope_addr) nasal_val* builtin_or(nasal_val* local_scope)
{ {
nasal_val* a_addr=in_builtin_find("a"); nasal_val* a_addr=in_builtin_find("a");
nasal_val* b_addr=in_builtin_find("b"); nasal_val* b_addr=in_builtin_find("b");
if(a_addr->type!=vm_num) if(a_addr->type!=vm_num)
{ {
builtin_error_occurred("or","\"a\" must be number"); builtin_err("or","\"a\" must be number");
return nullptr; return nullptr;
} }
if(b_addr->type!=vm_num) if(b_addr->type!=vm_num)
{ {
builtin_error_occurred("or","\"b\" must be number"); builtin_err("or","\"b\" must be number");
return nullptr; return nullptr;
} }
int number_a=(int)a_addr->ptr.num; int number_a=(int)a_addr->ptr.num;
@ -516,18 +502,18 @@ nasal_val* builtin_or(nasal_val* local_scope_addr)
ret_addr->ptr.num=(number_a|number_b); ret_addr->ptr.num=(number_a|number_b);
return ret_addr; return ret_addr;
} }
nasal_val* builtin_nand(nasal_val* local_scope_addr) nasal_val* builtin_nand(nasal_val* local_scope)
{ {
nasal_val* a_addr=in_builtin_find("a"); nasal_val* a_addr=in_builtin_find("a");
nasal_val* b_addr=in_builtin_find("b"); nasal_val* b_addr=in_builtin_find("b");
if(a_addr->type!=vm_num) if(a_addr->type!=vm_num)
{ {
builtin_error_occurred("nand","\"a\" must be number"); builtin_err("nand","\"a\" must be number");
return nullptr; return nullptr;
} }
if(b_addr->type!=vm_num) if(b_addr->type!=vm_num)
{ {
builtin_error_occurred("nand","\"b\" must be number"); builtin_err("nand","\"b\" must be number");
return nullptr; return nullptr;
} }
int number_a=(int)a_addr->ptr.num; int number_a=(int)a_addr->ptr.num;
@ -536,12 +522,12 @@ nasal_val* builtin_nand(nasal_val* local_scope_addr)
ret_addr->ptr.num=(~(number_a&number_b)); ret_addr->ptr.num=(~(number_a&number_b));
return ret_addr; return ret_addr;
} }
nasal_val* builtin_not(nasal_val* local_scope_addr) nasal_val* builtin_not(nasal_val* local_scope)
{ {
nasal_val* a_addr=in_builtin_find("a"); nasal_val* a_addr=in_builtin_find("a");
if(a_addr->type!=vm_num) if(a_addr->type!=vm_num)
{ {
builtin_error_occurred("not","\"a\" must be number"); builtin_err("not","\"a\" must be number");
return nullptr; return nullptr;
} }
int number=(int)a_addr->ptr.num; int number=(int)a_addr->ptr.num;
@ -549,178 +535,187 @@ nasal_val* builtin_not(nasal_val* local_scope_addr)
ret_addr->ptr.num=(~number); ret_addr->ptr.num=(~number);
return ret_addr; return ret_addr;
} }
nasal_val* builtin_sin(nasal_val* local_scope_addr) nasal_val* builtin_sin(nasal_val* local_scope)
{ {
nasal_val* value_addr=in_builtin_find("x"); nasal_val* val_addr=in_builtin_find("x");
if(value_addr->type!=vm_num) if(val_addr->type!=vm_num)
{ {
builtin_error_occurred("sin","\"x\" must be number"); builtin_err("sin","\"x\" must be number");
return nullptr; return nullptr;
} }
nasal_val* ret_addr=gc_alloc(vm_num); nasal_val* ret_addr=gc_alloc(vm_num);
ret_addr->ptr.num=sin(value_addr->ptr.num); ret_addr->ptr.num=sin(val_addr->ptr.num);
return ret_addr; return ret_addr;
} }
nasal_val* builtin_cos(nasal_val* local_scope_addr) nasal_val* builtin_cos(nasal_val* local_scope)
{ {
nasal_val* value_addr=in_builtin_find("x"); nasal_val* val_addr=in_builtin_find("x");
if(value_addr->type!=vm_num) if(val_addr->type!=vm_num)
{ {
builtin_error_occurred("cos","\"x\" must be number"); builtin_err("cos","\"x\" must be number");
return nullptr; return nullptr;
} }
nasal_val* ret_addr=gc_alloc(vm_num); nasal_val* ret_addr=gc_alloc(vm_num);
ret_addr->ptr.num=cos(value_addr->ptr.num); ret_addr->ptr.num=cos(val_addr->ptr.num);
return ret_addr; return ret_addr;
} }
nasal_val* builtin_tan(nasal_val* local_scope_addr) nasal_val* builtin_tan(nasal_val* local_scope)
{ {
nasal_val* value_addr=in_builtin_find("x"); nasal_val* val_addr=in_builtin_find("x");
if(value_addr->type!=vm_num) if(val_addr->type!=vm_num)
{ {
builtin_error_occurred("tan","\"x\" must be number"); builtin_err("tan","\"x\" must be number");
return nullptr; return nullptr;
} }
nasal_val* ret_addr=gc_alloc(vm_num); nasal_val* ret_addr=gc_alloc(vm_num);
ret_addr->ptr.num=tan(value_addr->ptr.num); ret_addr->ptr.num=tan(val_addr->ptr.num);
return ret_addr; return ret_addr;
} }
nasal_val* builtin_exp(nasal_val* local_scope_addr) nasal_val* builtin_exp(nasal_val* local_scope)
{ {
nasal_val* value_addr=in_builtin_find("x"); nasal_val* val_addr=in_builtin_find("x");
if(value_addr->type!=vm_num) if(val_addr->type!=vm_num)
{ {
builtin_error_occurred("exp","\"x\" must be number"); builtin_err("exp","\"x\" must be number");
return nullptr; return nullptr;
} }
nasal_val* ret_addr=gc_alloc(vm_num); nasal_val* ret_addr=gc_alloc(vm_num);
ret_addr->ptr.num=exp(value_addr->ptr.num); ret_addr->ptr.num=exp(val_addr->ptr.num);
return ret_addr; return ret_addr;
} }
nasal_val* builtin_ln(nasal_val* local_scope_addr) nasal_val* builtin_ln(nasal_val* local_scope)
{ {
nasal_val* value_addr=in_builtin_find("x"); nasal_val* val_addr=in_builtin_find("x");
if(value_addr->type!=vm_num) if(val_addr->type!=vm_num)
{ {
builtin_error_occurred("ln","\"x\" must be number"); builtin_err("ln","\"x\" must be number");
return nullptr; return nullptr;
} }
nasal_val* ret_addr=gc_alloc(vm_num); nasal_val* ret_addr=gc_alloc(vm_num);
ret_addr->ptr.num=(log(value_addr->ptr.num)/log(2.7182818284590452354)); ret_addr->ptr.num=(log(val_addr->ptr.num)/log(2.7182818284590452354));
return ret_addr; return ret_addr;
} }
nasal_val* builtin_sqrt(nasal_val* local_scope_addr) nasal_val* builtin_sqrt(nasal_val* local_scope)
{ {
nasal_val* value_addr=in_builtin_find("x"); nasal_val* val_addr=in_builtin_find("x");
if(value_addr->type!=vm_num) if(val_addr->type!=vm_num)
{ {
builtin_error_occurred("sqrt","\"x\" must be number"); builtin_err("sqrt","\"x\" must be number");
return nullptr; return nullptr;
} }
nasal_val* ret_addr=gc_alloc(vm_num); nasal_val* ret_addr=gc_alloc(vm_num);
ret_addr->ptr.num=sqrt(value_addr->ptr.num); ret_addr->ptr.num=sqrt(val_addr->ptr.num);
return ret_addr; return ret_addr;
} }
nasal_val* builtin_atan2(nasal_val* local_scope_addr) nasal_val* builtin_atan2(nasal_val* local_scope)
{ {
nasal_val* x_value_addr=in_builtin_find("x"); nasal_val* x_val_addr=in_builtin_find("x");
nasal_val* y_value_addr=in_builtin_find("y"); nasal_val* y_val_addr=in_builtin_find("y");
if(x_value_addr->type!=vm_num) if(x_val_addr->type!=vm_num)
{ {
builtin_error_occurred("atan2","\"x\" must be number"); builtin_err("atan2","\"x\" must be number");
return nullptr; return nullptr;
} }
if(y_value_addr->type!=vm_num) if(y_val_addr->type!=vm_num)
{ {
builtin_error_occurred("atan2","\"y\" must be number"); builtin_err("atan2","\"y\" must be number");
return nullptr; return nullptr;
} }
nasal_val* ret_addr=gc_alloc(vm_num); nasal_val* ret_addr=gc_alloc(vm_num);
ret_addr->ptr.num=atan2(y_value_addr->ptr.num,x_value_addr->ptr.num); ret_addr->ptr.num=atan2(y_val_addr->ptr.num,x_val_addr->ptr.num);
return ret_addr; return ret_addr;
} }
nasal_val* builtin_time(nasal_val* local_scope_addr) nasal_val* builtin_time(nasal_val* local_scope)
{ {
nasal_val* value_addr=in_builtin_find("begin_time"); nasal_val* val_addr=in_builtin_find("begin_time");
if(value_addr->type!=vm_num) if(val_addr->type!=vm_num)
{ {
builtin_error_occurred("time","\"begin_time\" must be number"); builtin_err("time","\"begin_time\" must be number");
return nullptr; return nullptr;
} }
time_t begin_time=(time_t)value_addr->ptr.num; time_t begin_time=(time_t)val_addr->ptr.num;
nasal_val* ret_addr=gc_alloc(vm_num); nasal_val* ret_addr=gc_alloc(vm_num);
ret_addr->ptr.num=time(&begin_time); ret_addr->ptr.num=time(&begin_time);
return ret_addr; return ret_addr;
} }
nasal_val* builtin_contains(nasal_val* local_scope_addr) nasal_val* builtin_contains(nasal_val* local_scope)
{ {
nasal_val* hash_addr=in_builtin_find("hash"); nasal_val* hash_addr=in_builtin_find("hash");
nasal_val* key_addr=in_builtin_find("key"); nasal_val* key_addr=in_builtin_find("key");
if(hash_addr->type!=vm_hash) if(hash_addr->type!=vm_hash)
{ {
builtin_error_occurred("contains","\"hash\" must be hash"); builtin_err("contains","\"hash\" must be hash");
return nullptr; return nullptr;
} }
if(key_addr->type!=vm_str) if(key_addr->type!=vm_str)
{ {
builtin_error_occurred("contains","\"key\" must be string"); builtin_err("contains","\"key\" must be string");
return nullptr; return nullptr;
} }
nasal_val* ret_addr=gc_alloc(vm_num); nasal_val* ret_addr=gc_alloc(vm_num);
ret_addr->ptr.num=hash_addr->ptr.hash->check_contain(*key_addr->ptr.str); ret_addr->ptr.num=hash_addr->ptr.hash->check_contain(*key_addr->ptr.str);
return ret_addr; return ret_addr;
} }
nasal_val* builtin_delete(nasal_val* local_scope_addr) nasal_val* builtin_delete(nasal_val* local_scope)
{ {
nasal_val* hash_addr=in_builtin_find("hash"); nasal_val* hash_addr=in_builtin_find("hash");
nasal_val* key_addr=in_builtin_find("key"); nasal_val* key_addr=in_builtin_find("key");
if(hash_addr->type!=vm_hash) if(hash_addr->type!=vm_hash)
{ {
builtin_error_occurred("delete","\"hash\" must be hash"); builtin_err("delete","\"hash\" must be hash");
return nullptr; return nullptr;
} }
if(key_addr->type!=vm_str) if(key_addr->type!=vm_str)
{ {
builtin_error_occurred("delete","\"key\" must be string"); builtin_err("delete","\"key\" must be string");
return nullptr; return nullptr;
} }
if(hash_addr->ptr.hash->elems.count(*key_addr->ptr.str)) if(hash_addr->ptr.hash->elems.count(*key_addr->ptr.str))
hash_addr->ptr.hash->elems.erase(*key_addr->ptr.str); hash_addr->ptr.hash->elems.erase(*key_addr->ptr.str);
return nil_addr; return nil_addr;
} }
nasal_val* builtin_getkeys(nasal_val* local_scope_addr) nasal_val* builtin_getkeys(nasal_val* local_scope)
{ {
nasal_val* hash_addr=in_builtin_find("hash"); nasal_val* hash_addr=in_builtin_find("hash");
if(hash_addr->type!=vm_hash) if(hash_addr->type!=vm_hash)
{ {
builtin_error_occurred("keys","\"hash\" must be hash"); builtin_err("keys","\"hash\" must be hash");
return nullptr; return nullptr;
} }
return hash_addr->ptr.hash->get_keys(); nasal_val* ret_addr=gc_alloc(vm_vec);
std::vector<nasal_val*>& ref_vec=ret_addr->ptr.vec->elems;
std::unordered_map<std::string,nasal_val*>& ref_hash=hash_addr->ptr.hash->elems;
for(auto iter=ref_hash.begin();iter!=ref_hash.end();++iter)
{
nasal_val* str_addr=gc_alloc(vm_str);
*str_addr->ptr.str=iter->first;
ref_vec.push_back(str_addr);
}
return ret_addr;
} }
nasal_val* builtin_import(nasal_val* local_scope_addr) nasal_val* builtin_import(nasal_val* local_scope)
{ {
// this function is used in preprocessing. // this function is used in preprocessing.
// this function will return nothing when running. // this function will return nothing when running.
builtin_error_occurred("import","cannot use import when running"); builtin_err("import","cannot use import when running");
return nullptr; return nullptr;
} }
nasal_val* builtin_die(nasal_val* local_scope_addr) nasal_val* builtin_die(nasal_val* local_scope)
{ {
nasal_val* str_addr=in_builtin_find("str"); nasal_val* str_addr=in_builtin_find("str");
if(str_addr->type!=vm_str) if(str_addr->type!=vm_str)
{ {
builtin_error_occurred("die","\"str\" must be string"); builtin_err("die","\"str\" must be string");
return nullptr; return nullptr;
} }
std::cout<<">> [vm] error: "<<str_addr->ptr.str<<'\n'; std::cout<<">> [vm] error: "<<str_addr->ptr.str<<'\n';
return nullptr; return nullptr;
} }
nasal_val* builtin_type(nasal_val* local_scope_addr) nasal_val* builtin_type(nasal_val* local_scope)
{ {
nasal_val* value_addr=in_builtin_find("object"); nasal_val* val_addr=in_builtin_find("object");
nasal_val* ret_addr=gc_alloc(vm_str); nasal_val* ret_addr=gc_alloc(vm_str);
switch(value_addr->type) switch(val_addr->type)
{ {
case vm_nil: *ret_addr->ptr.str="nil"; break; case vm_nil: *ret_addr->ptr.str="nil"; break;
case vm_num: *ret_addr->ptr.str="number"; break; case vm_num: *ret_addr->ptr.str="number"; break;
@ -731,127 +726,119 @@ nasal_val* builtin_type(nasal_val* local_scope_addr)
} }
return ret_addr; return ret_addr;
} }
nasal_val* builtin_substr(nasal_val* local_scope_addr) nasal_val* builtin_substr(nasal_val* local_scope)
{ {
nasal_val* str_addr=in_builtin_find("str"); nasal_val* str_addr=in_builtin_find("str");
nasal_val* begin_addr=in_builtin_find("begin"); nasal_val* beg_addr=in_builtin_find("begin");
nasal_val* length_addr=in_builtin_find("length"); nasal_val* len_addr=in_builtin_find("length");
if(str_addr->type!=vm_str) if(str_addr->type!=vm_str)
{ {
builtin_error_occurred("substr","\"str\" must be string"); builtin_err("substr","\"str\" must be string");
return nullptr; return nullptr;
} }
if(begin_addr->type!=vm_num) if(beg_addr->type!=vm_num)
{ {
builtin_error_occurred("substr","\"begin\" must be number"); builtin_err("substr","\"begin\" must be number");
return nullptr; return nullptr;
} }
if(length_addr->type!=vm_num) if(len_addr->type!=vm_num)
{ {
builtin_error_occurred("substr","\"length\" must be number"); builtin_err("substr","\"length\" must be number");
return nullptr; return nullptr;
} }
std::string str=*str_addr->ptr.str; std::string& str=*str_addr->ptr.str;
int begin=(int)begin_addr->ptr.num; int beg=(int)beg_addr->ptr.num;
int len=(int)length_addr->ptr.num; int len=(int)len_addr->ptr.num;
if(begin+len>str.length()) if(beg>=str.length() || beg+len>=str.length())
{ {
builtin_error_occurred("susbtr","index out of range"); builtin_err("susbtr","index out of range");
return nullptr; return nullptr;
} }
std::string tmp=""; if(len<0)
for(int i=begin;i<begin+len;++i) len=0;
tmp+=str[i];
nasal_val* ret_addr=gc_alloc(vm_str); nasal_val* ret_addr=gc_alloc(vm_str);
*ret_addr->ptr.str=tmp; *ret_addr->ptr.str=str.substr(beg,len);
return ret_addr; return ret_addr;
} }
nasal_val* builtin_streq(nasal_val* local_scope_addr) nasal_val* builtin_streq(nasal_val* local_scope)
{ {
nasal_val* a_addr=in_builtin_find("a"); nasal_val* a_addr=in_builtin_find("a");
nasal_val* b_addr=in_builtin_find("b"); nasal_val* b_addr=in_builtin_find("b");
nasal_val* ret_addr=gc_alloc(vm_num); nasal_val* ret_addr=gc_alloc(vm_num);
if(a_addr->type!=vm_str || b_addr->type!=vm_str) ret_addr->ptr.num=(a_addr->type!=vm_str || b_addr->type!=vm_str)?0:(*a_addr->ptr.str==*b_addr->ptr.str);
{
ret_addr->ptr.num=0;
return ret_addr;
}
ret_addr->ptr.num=(a_addr->ptr.str==b_addr->ptr.str);
return ret_addr; return ret_addr;
} }
nasal_val* builtin_left(nasal_val* local_scope_addr) nasal_val* builtin_left(nasal_val* local_scope)
{ {
nasal_val* string_addr=in_builtin_find("string"); nasal_val* str_addr=in_builtin_find("string");
nasal_val* length_addr=in_builtin_find("length"); nasal_val* len_addr=in_builtin_find("length");
if(string_addr->type!=vm_str) if(str_addr->type!=vm_str)
{ {
builtin_error_occurred("left","\"string\" must be string"); builtin_err("left","\"string\" must be string");
return nullptr; return nullptr;
} }
if(length_addr->type!=vm_num) if(len_addr->type!=vm_num)
{ {
builtin_error_occurred("left","\"length\" must be number"); builtin_err("left","\"length\" must be number");
return nullptr; return nullptr;
} }
std::string str=*string_addr->ptr.str; std::string& str=*str_addr->ptr.str;
int len=(int)length_addr->ptr.num; int len=(int)len_addr->ptr.num;
if(len<0) if(len<0)
len=0; len=0;
std::string tmp=str.substr(0, len);
nasal_val* ret_addr=gc_alloc(vm_str); nasal_val* ret_addr=gc_alloc(vm_str);
*ret_addr->ptr.str=tmp; *ret_addr->ptr.str=str.substr(0, len);
return ret_addr; return ret_addr;
} }
nasal_val* builtin_right(nasal_val* local_scope_addr) nasal_val* builtin_right(nasal_val* local_scope)
{ {
nasal_val* string_addr=in_builtin_find("string"); nasal_val* str_addr=in_builtin_find("string");
nasal_val* length_addr=in_builtin_find("length"); nasal_val* len_addr=in_builtin_find("length");
if(string_addr->type!=vm_str) if(str_addr->type!=vm_str)
{ {
builtin_error_occurred("right","\"string\" must be string"); builtin_err("right","\"string\" must be string");
return nullptr; return nullptr;
} }
if(length_addr->type!=vm_num) if(len_addr->type!=vm_num)
{ {
builtin_error_occurred("right","\"length\" must be number"); builtin_err("right","\"length\" must be number");
return nullptr; return nullptr;
} }
std::string str=*string_addr->ptr.str; std::string& str=*str_addr->ptr.str;
int len=(int)length_addr->ptr.num; int len=(int)len_addr->ptr.num;
int srclen=str.length(); int srclen=str.length();
if(len>srclen) if(len>srclen)
len=srclen; len=srclen;
if(len<0) if(len<0)
len=0; len=0;
std::string tmp=str.substr(srclen-len, srclen);
nasal_val* ret_addr=gc_alloc(vm_str); nasal_val* ret_addr=gc_alloc(vm_str);
*ret_addr->ptr.str=tmp; *ret_addr->ptr.str=str.substr(srclen-len, srclen);
return ret_addr; return ret_addr;
} }
nasal_val* builtin_cmp(nasal_val* local_scope_addr) nasal_val* builtin_cmp(nasal_val* local_scope)
{ {
nasal_val* a_addr=in_builtin_find("a"); nasal_val* a_addr=in_builtin_find("a");
nasal_val* b_addr=in_builtin_find("b"); nasal_val* b_addr=in_builtin_find("b");
if(a_addr->type!=vm_str) if(a_addr->type!=vm_str)
{ {
builtin_error_occurred("cmp","\"a\" must be string"); builtin_err("cmp","\"a\" must be string");
return nullptr; return nullptr;
} }
if(b_addr->type!=vm_str) if(b_addr->type!=vm_str)
{ {
builtin_error_occurred("cmp","\"b\" must be string"); builtin_err("cmp","\"b\" must be string");
return nullptr; return nullptr;
} }
nasal_val* ret_addr=gc_alloc(vm_num); nasal_val* ret_addr=gc_alloc(vm_num);
ret_addr->ptr.num=strcmp(a_addr->ptr.str->data(),b_addr->ptr.str->data()); ret_addr->ptr.num=strcmp(a_addr->ptr.str->data(),b_addr->ptr.str->data());
return ret_addr; return ret_addr;
} }
nasal_val* builtin_chr(nasal_val* local_scope_addr) nasal_val* builtin_chr(nasal_val* local_scope)
{ {
nasal_val* code_addr=in_builtin_find("code"); nasal_val* code_addr=in_builtin_find("code");
if(code_addr->type!=vm_num) if(code_addr->type!=vm_num)
{ {
builtin_error_occurred("chr","\"code\" must be number"); builtin_err("chr","\"code\" must be number");
return nullptr; return nullptr;
} }
nasal_val* ret_addr=gc_alloc(vm_str); nasal_val* ret_addr=gc_alloc(vm_str);

24
nasal_gc.h
View File

@ -52,10 +52,8 @@ struct nasal_hash
bool check_contain(std::string&); bool check_contain(std::string&);
void print(); void print();
nasal_val* get_special_para(std::string&);
nasal_val* get_val(std::string&); nasal_val* get_val(std::string&);
nasal_val** get_mem(std::string&); nasal_val** get_mem(std::string&);
nasal_val* get_keys();
}; };
struct nasal_func struct nasal_func
@ -147,12 +145,6 @@ void nasal_vec::print()
} }
/*functions of nasal_hash*/ /*functions of nasal_hash*/
nasal_val* nasal_hash::get_special_para(std::string& key)
{
if(elems.count(key))
return elems[key];
return nullptr;
}
nasal_val* nasal_hash::get_val(std::string& key) nasal_val* nasal_hash::get_val(std::string& key)
{ {
nasal_val* ret_addr=nullptr; nasal_val* ret_addr=nullptr;
@ -225,18 +217,6 @@ bool nasal_hash::check_contain(std::string& key)
} }
return false; return false;
} }
nasal_val* nasal_hash::get_keys()
{
nasal_val* ret_addr=gc_alloc(vm_vec);
std::vector<nasal_val*>& ref_vec=ret_addr->ptr.vec->elems;
for(auto iter=elems.begin();iter!=elems.end();++iter)
{
nasal_val* str_addr=gc_alloc(vm_str);
*str_addr->ptr.str=iter->first;
ref_vec.push_back(str_addr);
}
return ret_addr;
}
void nasal_hash::print() void nasal_hash::print()
{ {
std::cout<<'{'; std::cout<<'{';
@ -426,7 +406,6 @@ void mark()
} }
return; return;
} }
void sweep() void sweep()
{ {
int size=memory.size(); int size=memory.size();
@ -441,7 +420,6 @@ void sweep()
} }
return; return;
} }
void gc_init() void gc_init()
{ {
for(int i=0;i<65536;++i) for(int i=0;i<65536;++i)
@ -452,7 +430,6 @@ void gc_init()
} }
return; return;
} }
void gc_clear() void gc_clear()
{ {
int size=memory.size(); int size=memory.size();
@ -466,7 +443,6 @@ void gc_clear()
free_list.pop(); free_list.pop();
return; return;
} }
nasal_val* gc_alloc(int type) nasal_val* gc_alloc(int type)
{ {
if(free_list.empty()) if(free_list.empty())

54
nasal_vm.h
View File

@ -692,7 +692,7 @@ void nasal_vm::opr_callh()
} }
void nasal_vm::opr_callf() void nasal_vm::opr_callf()
{ {
nasal_val* closure=gc_alloc(vm_scop); // get parameter list and function value
nasal_val* para_addr=*stack_top; nasal_val* para_addr=*stack_top;
nasal_val* func_addr=*(stack_top-1); nasal_val* func_addr=*(stack_top-1);
if(func_addr->type!=vm_func) if(func_addr->type!=vm_func)
@ -700,49 +700,46 @@ void nasal_vm::opr_callf()
die("callf: called a value that is not a function"); die("callf: called a value that is not a function");
return; return;
} }
nasal_func& ref_func=*func_addr->ptr.func; // push new local scope
nasal_scop& ref_closure=*closure->ptr.scop; nasal_val* closure=gc_alloc(vm_scop);
ref_closure.elems=ref_func.closure;
local.push_back(closure); local.push_back(closure);
// load parameters
nasal_func& ref_func=*func_addr->ptr.func;
std::vector<int>& ref_para=ref_func.para;
std::vector<nasal_val*>& ref_default=ref_func.default_para;
std::unordered_map<int,nasal_val*>& ref_closure=closure->ptr.scop->elems;
ref_closure=ref_func.closure;
if(para_addr->type==vm_vec) if(para_addr->type==vm_vec)
{ {
std::vector<nasal_val*>& ref_vec=para_addr->ptr.vec->elems; std::vector<nasal_val*>& ref_vec=para_addr->ptr.vec->elems;
std::vector<int>& ref_para=ref_func.para; int vec_size=ref_vec.size();
std::vector<nasal_val*>& ref_default=ref_func.default_para; int para_size=ref_para.size();
int i=0; for(int i=0;i<para_size;++i)
for(;i<ref_para.size();++i)
{ {
if(i>=ref_vec.size()) if(i>=vec_size)
{ {
if(!ref_default[i]) if(!ref_default[i])
{ {
die("callf: lack argument(s)"); die("callf: lack argument(s)");
return; return;
} }
ref_closure.elems[ref_para[i]]=ref_default[i]; ref_closure[ref_para[i]]=ref_default[i];
} }
else else
{ ref_closure[ref_para[i]]=ref_vec[i];
nasal_val* tmp=ref_vec[i];
ref_closure.elems[ref_para[i]]=tmp;
}
} }
if(ref_func.dynpara>=0) if(ref_func.dynpara>=0)
{ {
nasal_val* vec_addr=gc_alloc(vm_vec); nasal_val* vec_addr=gc_alloc(vm_vec);
for(;i<ref_vec.size();++i) for(int i=para_size;i<vec_size;++i)
{ vec_addr->ptr.vec->elems.push_back(ref_vec[i]);
nasal_val* tmp=ref_vec[i]; ref_closure[ref_func.dynpara]=vec_addr;
vec_addr->ptr.vec->elems.push_back(tmp);
}
ref_closure.elems[ref_func.dynpara]=vec_addr;
} }
} }
else else
{ {
nasal_hash& ref_hash=*para_addr->ptr.hash; std::unordered_map<std::string,nasal_val*>& ref_hash=para_addr->ptr.hash->elems;
std::vector<int>& ref_para=ref_func.para;
std::vector<nasal_val*>& ref_default=ref_func.default_para;
if(ref_func.dynpara>=0) if(ref_func.dynpara>=0)
{ {
die("callf: special call cannot use dynamic parameter"); die("callf: special call cannot use dynamic parameter");
@ -750,15 +747,16 @@ void nasal_vm::opr_callf()
} }
for(int i=0;i<ref_para.size();++i) for(int i=0;i<ref_para.size();++i)
{ {
nasal_val* tmp=ref_hash.get_special_para(str_table[ref_para[i]]); std::string& sym=str_table[ref_para[i]];
if(!tmp) if(ref_hash.count(sym))
tmp=ref_default[i]; ref_closure[ref_para[i]]=ref_hash[sym];
if(!tmp) else if(ref_default[i])
ref_closure[ref_para[i]]=ref_default[i];
else
{ {
die("callf: lack argument(s)"); die("callf: lack argument(s)");
return; return;
} }
ref_closure.elems[ref_para[i]]=tmp;
} }
} }
--stack_top; --stack_top;

20
test/fib.nas
View File

@ -7,13 +7,13 @@ var fib=func(x)
for(var i=0;i<31;i+=1) for(var i=0;i<31;i+=1)
print(fib(i),'\n'); print(fib(i),'\n');
# var m=[0,1,1,2,3,5,8]; var m=[0,1,1,2,3,5,8];
# setsize(m,101); setsize(m,32);
# var fib=func(n) var fib=func(n)
# { {
# if(m[n]!=nil) return m[n]; if(m[n]!=nil) return m[n];
# var t=fib(n-1)+fib(n-2); var t=fib(n-1)+fib(n-2);
# m[n]=t; m[n]=t;
# return t; return t;
# } }
# print(fib(100),'\n'); print(fib(31),'\n');