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

18
nasal_ast.h
View File

@ -94,14 +94,15 @@ class nasal_ast
private:
int line;
int type;
std::string str;
double num;
std::string str;
std::vector<nasal_ast> children;
public:
nasal_ast(int,int);
nasal_ast(const nasal_ast&);
~nasal_ast();
nasal_ast& operator=(const nasal_ast&);
void print_ast(int);
void clear();
void set_line(int);
void set_type(int);
@ -110,16 +111,15 @@ public:
void add_child(nasal_ast);
int get_line();
int get_type();
std::string get_str();
double get_num();
std::string get_str();
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;
type=init_type;
line=_line;
type=_type;
return;
}
@ -217,9 +217,9 @@ std::vector<nasal_ast>& nasal_ast::get_children()
void nasal_ast::print_ast(int depth)
{
std::string indentation="";
for(int i=0;i<depth;++i) indentation+="| ";
indentation+=ast_name(type);
std::cout<<indentation;
for(int i=0;i<depth;++i)
indentation+="| ";
std::cout<<indentation<<ast_name(type);
if(type==ast_str || type==ast_id || type==ast_dynamic_id || type==ast_callh)
std::cout<<":"<<str;
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
#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] "<<func_name<<": "<<info<<".\n";
return;
@ -123,12 +123,12 @@ struct FUNC_TABLE
{"", nullptr }
};
nasal_val* builtin_print(nasal_val* local_scope_addr)
nasal_val* builtin_print(nasal_val* local_scope)
{
// get arguments
nasal_val* vector_value_addr=in_builtin_find("elements");
nasal_val* vector_val_addr=in_builtin_find("elements");
// 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();
for(int i=0;i<size;++i)
{
@ -146,103 +146,94 @@ nasal_val* builtin_print(nasal_val* local_scope_addr)
// generate return value
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* elem_value_addr=in_builtin_find("elements");
if(vector_value_addr->type!=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<nasal_val*>& ref_vec=vec_addr->ptr.vec->elems;
std::vector<nasal_val*>& ref_elems=elem_addr->ptr.vec->elems;
int size=ref_elems.size();
for(int i=0;i<size;++i)
{
nasal_val* value_address=ref_elements.get_val(i);
ref_vector.elems.push_back(value_address);
}
ref_vec.push_back(ref_elems[i]);
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* size_value_addr=in_builtin_find("size");
if(vector_value_addr->type!=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(number<vec_size)
for(int i=number;i<vec_size;++i)
ref_vector.elems.pop_back();
else if(number>vec_size)
for(int i=vec_size;i<number;++i)
{
nasal_val* new_val_addr=nil_addr;
ref_vector.elems.push_back(new_val_addr);
}
std::vector<nasal_val*>& ref_vec=vec_addr->ptr.vec->elems;
int vec_size=ref_vec.size();
if(num<vec_size)
for(int i=num;i<vec_size;++i)
ref_vec.pop_back();
else if(num>vec_size)
for(int i=vec_size;i<num;++i)
ref_vec.push_back(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");
if(str_value_addr->type!=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<nasal_val*>& 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<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);
}
nasal_val* builtin_import(nasal_val* local_scope_addr)
return ret_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: "<<str_addr->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;i<begin+len;++i)
tmp+=str[i];
if(len<0)
len=0;
nasal_val* ret_addr=gc_alloc(vm_str);
*ret_addr->ptr.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;
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;
}
ret_addr->ptr.num=(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);

24
nasal_gc.h
View File

@ -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<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()
{
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())

54
nasal_vm.h
View File

@ -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<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)
{
std::vector<nasal_val*>& ref_vec=para_addr->ptr.vec->elems;
std::vector<int>& ref_para=ref_func.para;
std::vector<nasal_val*>& ref_default=ref_func.default_para;
int i=0;
for(;i<ref_para.size();++i)
int vec_size=ref_vec.size();
int para_size=ref_para.size();
for(int i=0;i<para_size;++i)
{
if(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(;i<ref_vec.size();++i)
{
nasal_val* tmp=ref_vec[i];
vec_addr->ptr.vec->elems.push_back(tmp);
}
ref_closure.elems[ref_func.dynpara]=vec_addr;
for(int i=para_size;i<vec_size;++i)
vec_addr->ptr.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<int>& ref_para=ref_func.para;
std::vector<nasal_val*>& ref_default=ref_func.default_para;
std::unordered_map<std::string,nasal_val*>& 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<ref_para.size();++i)
{
nasal_val* tmp=ref_hash.get_special_para(str_table[ref_para[i]]);
if(!tmp)
tmp=ref_default[i];
if(!tmp)
std::string& sym=str_table[ref_para[i]];
if(ref_hash.count(sym))
ref_closure[ref_para[i]]=ref_hash[sym];
else if(ref_default[i])
ref_closure[ref_para[i]]=ref_default[i];
else
{
die("callf: lack argument(s)");
return;
}
ref_closure.elems[ref_para[i]]=tmp;
}
}
--stack_top;

20
test/fib.nas
View File

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