From be1bcdfe2ccf7f843cf9ee3d925ccd87e4827005 Mon Sep 17 00:00:00 2001 From: Valk Richard Li <48872266+ValKmjolnir@users.noreply.github.com> Date: Sun, 28 Mar 2021 17:39:24 +0800 Subject: [PATCH] bug fixed --- nasal_ast.h | 40 ++-- nasal_builtin.h | 499 +++++++++++++++++++++++------------------------- nasal_gc.h | 24 --- nasal_vm.h | 54 +++--- test/fib.nas | 20 +- 5 files changed, 299 insertions(+), 338 deletions(-) diff --git a/nasal_ast.h b/nasal_ast.h index b3965f8..90738c4 100644 --- a/nasal_ast.h +++ b/nasal_ast.h @@ -92,34 +92,34 @@ std::string ast_name(int type) class nasal_ast { private: - int line; - int type; + int line; + int type; + double num; std::string str; - double num; std::vector children; public: nasal_ast(int,int); nasal_ast(const nasal_ast&); ~nasal_ast(); - nasal_ast& operator=(const nasal_ast&); - void clear(); - void set_line(int); - void set_type(int); - void set_str(std::string&); - void set_num(double); - void add_child(nasal_ast); + nasal_ast& operator=(const nasal_ast&); + void print_ast(int); + void clear(); + void set_line(int); + void set_type(int); + void set_str(std::string&); + void set_num(double); + void add_child(nasal_ast); int get_line(); int get_type(); - std::string get_str(); double get_num(); + std::string get_str(); std::vector& 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; - type=init_type; + line=_line; + type=_type; return; } @@ -127,8 +127,8 @@ nasal_ast::nasal_ast(const nasal_ast& tmp) { line=tmp.line; type=tmp.type; - str=tmp.str; - num=tmp.num; + str =tmp.str; + num =tmp.num; children=tmp.children; return; } @@ -217,9 +217,9 @@ std::vector& nasal_ast::get_children() void nasal_ast::print_ast(int depth) { std::string indentation=""; - for(int i=0;i builtin_use_str_table; // used to find values that builtin function uses #define in_builtin_find(val_name) \ (\ - local_scope_addr\ + local_scope\ ->ptr.scop\ ->get_val\ (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_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] "<& ref_vec=vector_value_addr->ptr.vec->elems; + std::vector& ref_vec=vector_val_addr->ptr.vec->elems; int size=ref_vec.size(); for(int i=0;itype!=vm_vec) + nasal_val* vec_addr=in_builtin_find("vector"); + nasal_val* elem_addr=in_builtin_find("elements"); + if(vec_addr->type!=vm_vec) { - builtin_error_occurred("append","\"vector\" must be vector"); + builtin_err("append","\"vector\" must be vector"); return nullptr; } - nasal_vec& ref_vector=*vector_value_addr->ptr.vec; - nasal_vec& ref_elements=*elem_value_addr->ptr.vec; - int size=ref_elements.elems.size(); + std::vector& ref_vec=vec_addr->ptr.vec->elems; + std::vector& ref_elems=elem_addr->ptr.vec->elems; + int size=ref_elems.size(); for(int i=0;itype!=vm_vec) + nasal_val* vec_addr=in_builtin_find("vector"); + nasal_val* size_addr=in_builtin_find("size"); + if(vec_addr->type!=vm_vec) { - builtin_error_occurred("setsize","\"vector\" must be vector"); + builtin_err("setsize","\"vector\" must be vector"); return nullptr; } - int type=size_value_addr->type; - if(type!=vm_num) + if(size_addr->type!=vm_num) { - builtin_error_occurred("setsize","\"size\" is not a number"); + builtin_err("setsize","\"size\" is not a number"); return nullptr; } - int number=size_value_addr->ptr.num; - if(number<0) + int num=size_addr->ptr.num; + if(num<0) { - builtin_error_occurred("setsize","\"size\" must be greater than -1"); + builtin_err("setsize","\"size\" must be greater than -1"); return nullptr; } - nasal_vec& ref_vector=*vector_value_addr->ptr.vec; - int vec_size=ref_vector.elems.size(); - if(numbervec_size) - for(int i=vec_size;i& ref_vec=vec_addr->ptr.vec->elems; + int vec_size=ref_vec.size(); + if(numvec_size) + for(int i=vec_size;itype!=vm_str) + nasal_val* str_addr=in_builtin_find("str"); + if(str_addr->type!=vm_str) { - builtin_error_occurred("system","\"str\" must be string"); + builtin_err("system","\"str\" must be string"); return nullptr; } - system(str_value_addr->ptr.str->data()); - nasal_val* ret_addr=nil_addr; - return ret_addr; + system(str_addr->ptr.str->data()); + return nil_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); std::cin>>*ret_addr->ptr.str; 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"); - int type=value_addr->type; - if(type!=vm_num) + nasal_val* val_addr=in_builtin_find("duration"); + if(val_addr->type!=vm_num) { - builtin_error_occurred("sleep","\"duration\" must be number"); + builtin_err("sleep","\"duration\" must be number"); return nullptr; } // 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; } -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"); - if(value_addr->type!=vm_str) + nasal_val* val_addr=in_builtin_find("filename"); + 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; } - std::string& filename=*value_addr->ptr.str; + std::string& filename=*val_addr->ptr.str; std::ifstream fin(filename); nasal_val* ret_addr=gc_alloc(vm_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); } else - builtin_error_occurred("io.fin","cannot open \""+filename+"\""); + builtin_err("io.fin","cannot open \""+filename+"\""); fin.close(); 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* str_value_addr=in_builtin_find("str"); - if(value_addr->type!=vm_str) + nasal_val* val_addr=in_builtin_find("filename"); + nasal_val* str_addr=in_builtin_find("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; } - 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; } - std::ofstream fout(*value_addr->ptr.str); + std::ofstream fout(*val_addr->ptr.str); 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; } - fout<<*str_value_addr->ptr.str; + fout<<*str_addr->ptr.str; fout.close(); 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* string_value_addr=in_builtin_find("string"); - if(delimeter_value_addr->type!=vm_str) + nasal_val* delimeter_val_addr=in_builtin_find("delimeter"); + nasal_val* string_val_addr=in_builtin_find("string"); + if(delimeter_val_addr->type!=vm_str) { - builtin_error_occurred("split","\"delimeter\" must be string"); + builtin_err("split","\"delimeter\" must be string"); 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; } - std::string delimeter=*delimeter_value_addr->ptr.str; - std::string source=*string_value_addr->ptr.str; + std::string delimeter=*delimeter_val_addr->ptr.str; + std::string source=*string_val_addr->ptr.str; int delimeter_len=delimeter.length(); int source_len=source.length(); nasal_val* ret_addr=gc_alloc(vm_vec); - nasal_vec& ref_vec=*ret_addr->ptr.vec; + std::vector& ref_vec=ret_addr->ptr.vec->elems; std::string tmp=""; if(!delimeter_len) @@ -314,7 +305,7 @@ nasal_val* builtin_split(nasal_val* local_scope_addr) { nasal_val* str_addr=gc_alloc(vm_str); *str_addr->ptr.str=source[i]; - ref_vec.elems.push_back(str_addr); + ref_vec.push_back(str_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); *str_addr->ptr.str=tmp; - ref_vec.elems.push_back(str_addr); + ref_vec.push_back(str_addr); tmp=""; } 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); *str_addr->ptr.str=tmp; - ref_vec.elems.push_back(str_addr); + ref_vec.push_back(str_addr); tmp=""; } 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"); - if(value_addr->type!=vm_num && value_addr->type!=vm_nil) + nasal_val* val_addr=in_builtin_find("seed"); + 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; } - if(value_addr->type==vm_num) + if(val_addr->type==vm_num) { - unsigned int number=(unsigned int)value_addr->ptr.num; - srand(number); - nasal_val* ret_addr=nil_addr; - return ret_addr; + srand((unsigned int)val_addr->ptr.num); + return nil_addr; } double num=0; 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; 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); char buf[32]; - sprintf(buf,"0x%p",value_addr); + sprintf(buf,"0x%p",val_addr); *ret_addr->ptr.str=buf; 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"); - if(value_addr->type!=vm_num) + nasal_val* val_addr=in_builtin_find("value"); + if(val_addr->type!=vm_num) { - builtin_error_occurred("int","\"value\" must be number"); + builtin_err("int","\"value\" must be number"); return nullptr; } - int number=(int)value_addr->ptr.num; + int number=(int)val_addr->ptr.num; nasal_val* ret_addr=gc_alloc(vm_num); ret_addr->ptr.num=(double)number; 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"); - if(value_addr->type!=vm_str) + nasal_val* val_addr=in_builtin_find("value"); + if(val_addr->type!=vm_str) { - builtin_error_occurred("num","\"value\" must be string"); + builtin_err("num","\"value\" must be string"); return nullptr; } 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; } -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"); - if(value_addr->type!=vm_vec) + nasal_val* val_addr=in_builtin_find("vector"); + if(val_addr->type!=vm_vec) { - builtin_error_occurred("pop","\"vector\" must be vector"); + builtin_err("pop","\"vector\" must be vector"); 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(); - value_addr->ptr.vec->elems.pop_back(); + nasal_val* tmp=val_addr->ptr.vec->elems.back(); + val_addr->ptr.vec->elems.pop_back(); return tmp; } 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"); - if(value_addr->type!=vm_num) + nasal_val* val_addr=in_builtin_find("number"); + if(val_addr->type!=vm_num) { - builtin_error_occurred("str","\"number\" must be number"); + builtin_err("str","\"number\" must be number"); return nullptr; } - nasal_val* ret_addr=gc_alloc(vm_num); - *ret_addr->ptr.str=value_addr->to_string(); + nasal_val* ret_addr=gc_alloc(vm_str); + *ret_addr->ptr.str=val_addr->to_string(); 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"); - 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* val_addr=in_builtin_find("object"); 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; } -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* b_addr=in_builtin_find("b"); if(a_addr->type!=vm_num) { - builtin_error_occurred("xor","\"a\" must be number"); + builtin_err("xor","\"a\" must be number"); return nullptr; } if(b_addr->type!=vm_num) { - builtin_error_occurred("xor","\"b\" must be number"); + builtin_err("xor","\"b\" must be number"); return nullptr; } 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); 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* b_addr=in_builtin_find("b"); if(a_addr->type!=vm_num) { - builtin_error_occurred("and","\"a\" must be number"); + builtin_err("and","\"a\" must be number"); return nullptr; } if(b_addr->type!=vm_num) { - builtin_error_occurred("and","\"b\" must be number"); + builtin_err("and","\"b\" must be number"); return nullptr; } 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); 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* b_addr=in_builtin_find("b"); if(a_addr->type!=vm_num) { - builtin_error_occurred("or","\"a\" must be number"); + builtin_err("or","\"a\" must be number"); return nullptr; } if(b_addr->type!=vm_num) { - builtin_error_occurred("or","\"b\" must be number"); + builtin_err("or","\"b\" must be number"); return nullptr; } 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); 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* b_addr=in_builtin_find("b"); if(a_addr->type!=vm_num) { - builtin_error_occurred("nand","\"a\" must be number"); + builtin_err("nand","\"a\" must be number"); return nullptr; } if(b_addr->type!=vm_num) { - builtin_error_occurred("nand","\"b\" must be number"); + builtin_err("nand","\"b\" must be number"); return nullptr; } 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)); 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"); if(a_addr->type!=vm_num) { - builtin_error_occurred("not","\"a\" must be number"); + builtin_err("not","\"a\" must be number"); return nullptr; } 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); 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"); - if(value_addr->type!=vm_num) + nasal_val* val_addr=in_builtin_find("x"); + if(val_addr->type!=vm_num) { - builtin_error_occurred("sin","\"x\" must be number"); + builtin_err("sin","\"x\" must be number"); return nullptr; } 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; } -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"); - if(value_addr->type!=vm_num) + nasal_val* val_addr=in_builtin_find("x"); + if(val_addr->type!=vm_num) { - builtin_error_occurred("cos","\"x\" must be number"); + builtin_err("cos","\"x\" must be number"); return nullptr; } 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; } -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"); - if(value_addr->type!=vm_num) + nasal_val* val_addr=in_builtin_find("x"); + if(val_addr->type!=vm_num) { - builtin_error_occurred("tan","\"x\" must be number"); + builtin_err("tan","\"x\" must be number"); return nullptr; } 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; } -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"); - if(value_addr->type!=vm_num) + nasal_val* val_addr=in_builtin_find("x"); + if(val_addr->type!=vm_num) { - builtin_error_occurred("exp","\"x\" must be number"); + builtin_err("exp","\"x\" must be number"); return nullptr; } 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; } -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"); - if(value_addr->type!=vm_num) + nasal_val* val_addr=in_builtin_find("x"); + if(val_addr->type!=vm_num) { - builtin_error_occurred("ln","\"x\" must be number"); + builtin_err("ln","\"x\" must be number"); return nullptr; } 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; } -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"); - if(value_addr->type!=vm_num) + nasal_val* val_addr=in_builtin_find("x"); + if(val_addr->type!=vm_num) { - builtin_error_occurred("sqrt","\"x\" must be number"); + builtin_err("sqrt","\"x\" must be number"); return nullptr; } 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; } -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* y_value_addr=in_builtin_find("y"); - if(x_value_addr->type!=vm_num) + nasal_val* x_val_addr=in_builtin_find("x"); + nasal_val* y_val_addr=in_builtin_find("y"); + if(x_val_addr->type!=vm_num) { - builtin_error_occurred("atan2","\"x\" must be number"); + builtin_err("atan2","\"x\" must be number"); 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; } 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; } -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"); - if(value_addr->type!=vm_num) + nasal_val* val_addr=in_builtin_find("begin_time"); + 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; } - 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); ret_addr->ptr.num=time(&begin_time); 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* key_addr=in_builtin_find("key"); if(hash_addr->type!=vm_hash) { - builtin_error_occurred("contains","\"hash\" must be hash"); + builtin_err("contains","\"hash\" must be hash"); return nullptr; } if(key_addr->type!=vm_str) { - builtin_error_occurred("contains","\"key\" must be string"); + builtin_err("contains","\"key\" must be string"); return nullptr; } nasal_val* ret_addr=gc_alloc(vm_num); ret_addr->ptr.num=hash_addr->ptr.hash->check_contain(*key_addr->ptr.str); 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* key_addr=in_builtin_find("key"); if(hash_addr->type!=vm_hash) { - builtin_error_occurred("delete","\"hash\" must be hash"); + builtin_err("delete","\"hash\" must be hash"); return nullptr; } if(key_addr->type!=vm_str) { - builtin_error_occurred("delete","\"key\" must be string"); + builtin_err("delete","\"key\" must be string"); return nullptr; } if(hash_addr->ptr.hash->elems.count(*key_addr->ptr.str)) hash_addr->ptr.hash->elems.erase(*key_addr->ptr.str); 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"); if(hash_addr->type!=vm_hash) { - builtin_error_occurred("keys","\"hash\" must be hash"); + builtin_err("keys","\"hash\" must be hash"); return nullptr; } - return hash_addr->ptr.hash->get_keys(); + nasal_val* ret_addr=gc_alloc(vm_vec); + std::vector& ref_vec=ret_addr->ptr.vec->elems; + std::unordered_map& 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 will return nothing when running. - builtin_error_occurred("import","cannot use import when running"); + builtin_err("import","cannot use import when running"); 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"); if(str_addr->type!=vm_str) { - builtin_error_occurred("die","\"str\" must be string"); + builtin_err("die","\"str\" must be string"); return nullptr; } std::cout<<">> [vm] error: "<ptr.str<<'\n'; 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); - switch(value_addr->type) + switch(val_addr->type) { case vm_nil: *ret_addr->ptr.str="nil"; 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; } -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* begin_addr=in_builtin_find("begin"); - nasal_val* length_addr=in_builtin_find("length"); + nasal_val* beg_addr=in_builtin_find("begin"); + nasal_val* len_addr=in_builtin_find("length"); if(str_addr->type!=vm_str) { - builtin_error_occurred("substr","\"str\" must be string"); + builtin_err("substr","\"str\" must be string"); 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; } - 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; } - std::string str=*str_addr->ptr.str; - int begin=(int)begin_addr->ptr.num; - int len=(int)length_addr->ptr.num; - if(begin+len>str.length()) + std::string& str=*str_addr->ptr.str; + int beg=(int)beg_addr->ptr.num; + int len=(int)len_addr->ptr.num; + 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; } - std::string tmp=""; - for(int i=begin;iptr.str=tmp; + *ret_addr->ptr.str=str.substr(beg,len); 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* b_addr=in_builtin_find("b"); nasal_val* ret_addr=gc_alloc(vm_num); - if(a_addr->type!=vm_str || b_addr->type!=vm_str) - { - ret_addr->ptr.num=0; - return ret_addr; - } - ret_addr->ptr.num=(a_addr->ptr.str==b_addr->ptr.str); + ret_addr->ptr.num=(a_addr->type!=vm_str || b_addr->type!=vm_str)?0:(*a_addr->ptr.str==*b_addr->ptr.str); 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* length_addr=in_builtin_find("length"); - if(string_addr->type!=vm_str) + nasal_val* str_addr=in_builtin_find("string"); + nasal_val* len_addr=in_builtin_find("length"); + if(str_addr->type!=vm_str) { - builtin_error_occurred("left","\"string\" must be string"); + builtin_err("left","\"string\" must be string"); 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; } - std::string str=*string_addr->ptr.str; - int len=(int)length_addr->ptr.num; + std::string& str=*str_addr->ptr.str; + int len=(int)len_addr->ptr.num; if(len<0) len=0; - std::string tmp=str.substr(0, len); nasal_val* ret_addr=gc_alloc(vm_str); - *ret_addr->ptr.str=tmp; + *ret_addr->ptr.str=str.substr(0, len); 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* length_addr=in_builtin_find("length"); - if(string_addr->type!=vm_str) + nasal_val* str_addr=in_builtin_find("string"); + nasal_val* len_addr=in_builtin_find("length"); + if(str_addr->type!=vm_str) { - builtin_error_occurred("right","\"string\" must be string"); + builtin_err("right","\"string\" must be string"); 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; } - std::string str=*string_addr->ptr.str; - int len=(int)length_addr->ptr.num; + std::string& str=*str_addr->ptr.str; + int len=(int)len_addr->ptr.num; int srclen=str.length(); if(len>srclen) len=srclen; if(len<0) len=0; - std::string tmp=str.substr(srclen-len, srclen); 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; } -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* b_addr=in_builtin_find("b"); if(a_addr->type!=vm_str) { - builtin_error_occurred("cmp","\"a\" must be string"); + builtin_err("cmp","\"a\" must be string"); return nullptr; } if(b_addr->type!=vm_str) { - builtin_error_occurred("cmp","\"b\" must be string"); + builtin_err("cmp","\"b\" must be string"); return nullptr; } nasal_val* ret_addr=gc_alloc(vm_num); ret_addr->ptr.num=strcmp(a_addr->ptr.str->data(),b_addr->ptr.str->data()); 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"); if(code_addr->type!=vm_num) { - builtin_error_occurred("chr","\"code\" must be number"); + builtin_err("chr","\"code\" must be number"); return nullptr; } nasal_val* ret_addr=gc_alloc(vm_str); diff --git a/nasal_gc.h b/nasal_gc.h index d643fc9..74f6f3d 100644 --- a/nasal_gc.h +++ b/nasal_gc.h @@ -52,10 +52,8 @@ struct nasal_hash bool check_contain(std::string&); void print(); - nasal_val* get_special_para(std::string&); nasal_val* get_val(std::string&); nasal_val** get_mem(std::string&); - nasal_val* get_keys(); }; struct nasal_func @@ -147,12 +145,6 @@ void nasal_vec::print() } /*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* ret_addr=nullptr; @@ -225,18 +217,6 @@ bool nasal_hash::check_contain(std::string& key) } return false; } -nasal_val* nasal_hash::get_keys() -{ - nasal_val* ret_addr=gc_alloc(vm_vec); - std::vector& 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() { std::cout<<'{'; @@ -426,7 +406,6 @@ void mark() } return; } - void sweep() { int size=memory.size(); @@ -441,7 +420,6 @@ void sweep() } return; } - void gc_init() { for(int i=0;i<65536;++i) @@ -452,7 +430,6 @@ void gc_init() } return; } - void gc_clear() { int size=memory.size(); @@ -466,7 +443,6 @@ void gc_clear() free_list.pop(); return; } - nasal_val* gc_alloc(int type) { if(free_list.empty()) diff --git a/nasal_vm.h b/nasal_vm.h index 7bbd7b7..952d309 100644 --- a/nasal_vm.h +++ b/nasal_vm.h @@ -692,7 +692,7 @@ void nasal_vm::opr_callh() } 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* func_addr=*(stack_top-1); 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"); return; } - nasal_func& ref_func=*func_addr->ptr.func; - nasal_scop& ref_closure=*closure->ptr.scop; - ref_closure.elems=ref_func.closure; + // push new local scope + nasal_val* closure=gc_alloc(vm_scop); local.push_back(closure); + // load parameters + nasal_func& ref_func=*func_addr->ptr.func; + std::vector& ref_para=ref_func.para; + std::vector& ref_default=ref_func.default_para; + std::unordered_map& ref_closure=closure->ptr.scop->elems; + ref_closure=ref_func.closure; + if(para_addr->type==vm_vec) { std::vector& ref_vec=para_addr->ptr.vec->elems; - std::vector& ref_para=ref_func.para; - std::vector& ref_default=ref_func.default_para; - int i=0; - for(;i=ref_vec.size()) + if(i>=vec_size) { if(!ref_default[i]) { die("callf: lack argument(s)"); return; } - ref_closure.elems[ref_para[i]]=ref_default[i]; + ref_closure[ref_para[i]]=ref_default[i]; } else - { - nasal_val* tmp=ref_vec[i]; - ref_closure.elems[ref_para[i]]=tmp; - } + ref_closure[ref_para[i]]=ref_vec[i]; } if(ref_func.dynpara>=0) { nasal_val* vec_addr=gc_alloc(vm_vec); - for(;iptr.vec->elems.push_back(tmp); - } - ref_closure.elems[ref_func.dynpara]=vec_addr; + for(int i=para_size;iptr.vec->elems.push_back(ref_vec[i]); + ref_closure[ref_func.dynpara]=vec_addr; } } else { - nasal_hash& ref_hash=*para_addr->ptr.hash; - std::vector& ref_para=ref_func.para; - std::vector& ref_default=ref_func.default_para; + std::unordered_map& ref_hash=para_addr->ptr.hash->elems; if(ref_func.dynpara>=0) { die("callf: special call cannot use dynamic parameter"); @@ -750,15 +747,16 @@ void nasal_vm::opr_callf() } for(int i=0;i