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

update

This commit is contained in:
Valk Richard Li 2021-02-10 00:12:22 +08:00
parent 125d6d3a7d
commit 3be50116fa
6 changed files with 889 additions and 887 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
main.cpp
View File

@ -5,7 +5,7 @@ nasal_parse parse;
nasal_import import; nasal_import import;
std::string inputfile="null"; std::string inputfile="null";
nasal_codegen code_generator; nasal_codegen code_generator;
nasal_bytecode_vm bytevm; nasal_vm bytevm;
void help() void help()
{ {

2
nasal.h
View File

@ -134,6 +134,6 @@ std::string trans_number_to_string(double number)
#include "nasal_gc.h" #include "nasal_gc.h"
#include "nasal_builtin.h" #include "nasal_builtin.h"
#include "nasal_codegen.h" #include "nasal_codegen.h"
#include "nasal_bytecode_vm.h" #include "nasal_vm.h"
#endif #endif

467
nasal_builtin.h
View File

@ -11,48 +11,54 @@
std::map<std::string,int> builtin_use_string_table; std::map<std::string,int> builtin_use_string_table;
// used to find values that builtin function uses // used to find values that builtin function uses
#define in_builtin_find(value_name_string) (local_scope_addr->get_closure().get_value_address(builtin_use_string_table[value_name_string])) #define in_builtin_find(value_name_string) \
(\
local_scope_addr\
->get_closure()\
.get_value_address\
(builtin_use_string_table[value_name_string])\
)
// declaration of builtin functions // declaration of builtin functions
// to add new builtin function,declare it here and write the definition below // to add new builtin function,declare it here and write the definition below
nasal_scalar* builtin_print(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_print(nasal_val*,nasal_gc&);
nasal_scalar* builtin_append(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_append(nasal_val*,nasal_gc&);
nasal_scalar* builtin_setsize(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_setsize(nasal_val*,nasal_gc&);
nasal_scalar* builtin_system(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_system(nasal_val*,nasal_gc&);
nasal_scalar* builtin_input(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_input(nasal_val*,nasal_gc&);
nasal_scalar* builtin_sleep(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_sleep(nasal_val*,nasal_gc&);
nasal_scalar* builtin_finput(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_finput(nasal_val*,nasal_gc&);
nasal_scalar* builtin_foutput(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_foutput(nasal_val*,nasal_gc&);
nasal_scalar* builtin_split(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_split(nasal_val*,nasal_gc&);
nasal_scalar* builtin_rand(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_rand(nasal_val*,nasal_gc&);
nasal_scalar* builtin_id(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_id(nasal_val*,nasal_gc&);
nasal_scalar* builtin_int(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_int(nasal_val*,nasal_gc&);
nasal_scalar* builtin_num(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_num(nasal_val*,nasal_gc&);
nasal_scalar* builtin_pop(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_pop(nasal_val*,nasal_gc&);
nasal_scalar* builtin_str(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_str(nasal_val*,nasal_gc&);
nasal_scalar* builtin_size(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_size(nasal_val*,nasal_gc&);
nasal_scalar* builtin_xor(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_xor(nasal_val*,nasal_gc&);
nasal_scalar* builtin_and(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_and(nasal_val*,nasal_gc&);
nasal_scalar* builtin_or(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_or(nasal_val*,nasal_gc&);
nasal_scalar* builtin_nand(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_nand(nasal_val*,nasal_gc&);
nasal_scalar* builtin_not(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_not(nasal_val*,nasal_gc&);
nasal_scalar* builtin_sin(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_sin(nasal_val*,nasal_gc&);
nasal_scalar* builtin_cos(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_cos(nasal_val*,nasal_gc&);
nasal_scalar* builtin_tan(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_tan(nasal_val*,nasal_gc&);
nasal_scalar* builtin_exp(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_exp(nasal_val*,nasal_gc&);
nasal_scalar* builtin_ln(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_ln(nasal_val*,nasal_gc&);
nasal_scalar* builtin_sqrt(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_sqrt(nasal_val*,nasal_gc&);
nasal_scalar* builtin_atan2(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_atan2(nasal_val*,nasal_gc&);
nasal_scalar* builtin_time(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_time(nasal_val*,nasal_gc&);
nasal_scalar* builtin_contains(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_contains(nasal_val*,nasal_gc&);
nasal_scalar* builtin_delete(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_delete(nasal_val*,nasal_gc&);
nasal_scalar* builtin_getkeys(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_getkeys(nasal_val*,nasal_gc&);
nasal_scalar* builtin_import(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_import(nasal_val*,nasal_gc&);
bool builtin_die_state;// used in builtin_die bool builtin_die_state;// used in builtin_die
nasal_scalar* builtin_die(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_die(nasal_val*,nasal_gc&);
nasal_scalar* builtin_type(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_type(nasal_val*,nasal_gc&);
nasal_scalar* builtin_substr(nasal_scalar*,nasal_virtual_machine&); nasal_val* builtin_substr(nasal_val*,nasal_gc&);
void builtin_error_occurred(std::string func_name,std::string info) void builtin_error_occurred(std::string func_name,std::string info)
{ {
@ -66,7 +72,7 @@ void builtin_error_occurred(std::string func_name,std::string info)
struct FUNC_TABLE struct FUNC_TABLE
{ {
std::string func_name; std::string func_name;
nasal_scalar* (*func_pointer)(nasal_scalar* x,nasal_virtual_machine& nasal_vm); nasal_val* (*func_pointer)(nasal_val* x,nasal_gc& gc);
} builtin_func_table[]= } builtin_func_table[]=
{ {
{"nasal_call_builtin_std_cout", builtin_print}, {"nasal_call_builtin_std_cout", builtin_print},
@ -108,63 +114,63 @@ struct FUNC_TABLE
{"", NULL} {"", NULL}
}; };
nasal_scalar* builtin_print(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_print(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
// get arguments // get arguments
nasal_scalar* vector_value_addr=in_builtin_find("elements"); nasal_val* vector_value_addr=in_builtin_find("elements");
// main process // main process
nasal_vector& ref_vec=vector_value_addr->get_vector(); nasal_vec& ref_vec=vector_value_addr->get_vector();
int size=ref_vec.size(); int size=ref_vec.size();
for(int i=0;i<size;++i) for(int i=0;i<size;++i)
{ {
nasal_scalar* tmp=ref_vec[i]; nasal_val* tmp=ref_vec[i];
switch(tmp->get_type()) switch(tmp->get_type())
{ {
case vm_nil: std::cout<<"nil"; break; case vm_nil: std::cout<<"nil"; break;
case vm_number: std::cout<<tmp->get_number(); break; case vm_num: std::cout<<tmp->get_number(); break;
case vm_string: std::cout<<tmp->get_string(); break; case vm_str: std::cout<<tmp->get_string(); break;
case vm_vector: tmp->get_vector().print(); break; case vm_vec: tmp->get_vector().print(); break;
case vm_hash: tmp->get_hash().print(); break; case vm_hash: tmp->get_hash().print(); break;
case vm_function: std::cout<<"func(...){...}"; break; case vm_func: std::cout<<"func(...){...}"; break;
} }
} }
std::cout<<"\n"; std::cout<<"\n";
// generate return value // generate return value
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_nil); nasal_val* ret_addr=gc.gc_alloc(vm_nil);
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_append(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_append(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* vector_value_addr=in_builtin_find("vector"); nasal_val* vector_value_addr=in_builtin_find("vector");
nasal_scalar* elem_value_addr=in_builtin_find("elements"); nasal_val* elem_value_addr=in_builtin_find("elements");
if(vector_value_addr->get_type()!=vm_vector) if(vector_value_addr->get_type()!=vm_vec)
{ {
builtin_error_occurred("append","\"vector\" must be vector"); builtin_error_occurred("append","\"vector\" must be vector");
return NULL; return NULL;
} }
nasal_vector& ref_vector=vector_value_addr->get_vector(); nasal_vec& ref_vector=vector_value_addr->get_vector();
nasal_vector& ref_elements=elem_value_addr->get_vector(); nasal_vec& ref_elements=elem_value_addr->get_vector();
int size=ref_elements.size(); int size=ref_elements.size();
for(int i=0;i<size;++i) for(int i=0;i<size;++i)
{ {
nasal_scalar* value_address=ref_elements.get_value_address(i); nasal_val* value_address=ref_elements.get_value_address(i);
nasal_vm.add_reference(value_address); gc.add_reference(value_address);
ref_vector.add_elem(value_address); ref_vector.add_elem(value_address);
} }
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_nil); nasal_val* ret_addr=gc.gc_alloc(vm_nil);
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_setsize(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_setsize(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* vector_value_addr=in_builtin_find("vector"); nasal_val* vector_value_addr=in_builtin_find("vector");
nasal_scalar* size_value_addr=in_builtin_find("size"); nasal_val* size_value_addr=in_builtin_find("size");
if(vector_value_addr->get_type()!=vm_vector) if(vector_value_addr->get_type()!=vm_vec)
{ {
builtin_error_occurred("setsize","\"vector\" must be vector"); builtin_error_occurred("setsize","\"vector\" must be vector");
return NULL; return NULL;
} }
int type=size_value_addr->get_type(); int type=size_value_addr->get_type();
if(type!=vm_number) if(type!=vm_num)
{ {
builtin_error_occurred("setsize","\"size\" is not a number"); builtin_error_occurred("setsize","\"size\" is not a number");
return NULL; return NULL;
@ -175,65 +181,66 @@ nasal_scalar* builtin_setsize(nasal_scalar* local_scope_addr,nasal_virtual_machi
builtin_error_occurred("setsize","\"size\" must be greater than -1"); builtin_error_occurred("setsize","\"size\" must be greater than -1");
return NULL; return NULL;
} }
nasal_vector& ref_vector=vector_value_addr->get_vector(); nasal_vec& ref_vector=vector_value_addr->get_vector();
int vec_size=ref_vector.size(); int vec_size=ref_vector.size();
if(number<vec_size) if(number<vec_size)
for(int i=number;i<vec_size;++i) for(int i=number;i<vec_size;++i)
{ {
nasal_scalar* addr=ref_vector.del_elem(); nasal_val* addr=ref_vector.del_elem();
if(addr) nasal_vm.del_reference(addr); if(addr) gc.del_reference(addr);
} }
else if(number>vec_size) else if(number>vec_size)
for(int i=vec_size;i<number;++i) for(int i=vec_size;i<number;++i)
{ {
nasal_scalar* new_val_addr=nasal_vm.gc_alloc(vm_nil); nasal_val* new_val_addr=gc.gc_alloc(vm_nil);
ref_vector.add_elem(new_val_addr); ref_vector.add_elem(new_val_addr);
} }
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_nil); nasal_val* ret_addr=gc.gc_alloc(vm_nil);
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_system(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_system(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* str_value_addr=in_builtin_find("str"); nasal_val* str_value_addr=in_builtin_find("str");
if(str_value_addr->get_type()!=vm_string) if(str_value_addr->get_type()!=vm_str)
{ {
builtin_error_occurred("system","\"str\" must be string"); builtin_error_occurred("system","\"str\" must be string");
return NULL; return NULL;
} }
std::string str=str_value_addr->get_string(); std::string str=str_value_addr->get_string();
system(str.data()); system(str.data());
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_nil); nasal_val* ret_addr=gc.gc_alloc(vm_nil);
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_input(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_input(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_string); nasal_val* ret_addr=gc.gc_alloc(vm_str);
std::string str; std::string str;
std::cin>>str; std::cin>>str;
ret_addr->set_string(str); ret_addr->set_string(str);
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_sleep(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_sleep(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* value_addr=in_builtin_find("duration"); nasal_val* value_addr=in_builtin_find("duration");
int type=value_addr->get_type(); int type=value_addr->get_type();
if(type!=vm_number) if(type!=vm_num)
{ {
builtin_error_occurred("sleep","\"duration\" must be number"); builtin_error_occurred("sleep","\"duration\" must be number");
return NULL; return NULL;
} }
sleep((unsigned long)value_addr->get_number()); // sleep in unistd.h will make this progress sleep sleep_time seconds. // sleep in unistd.h will make this progress sleep sleep_time seconds.
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_nil); sleep((unsigned long)value_addr->get_number());
nasal_val* ret_addr=gc.gc_alloc(vm_nil);
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_finput(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_finput(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* value_addr=in_builtin_find("filename"); nasal_val* value_addr=in_builtin_find("filename");
if(value_addr->get_type()!=vm_string) if(value_addr->get_type()!=vm_str)
{ {
builtin_error_occurred("io.fin","\"filename\" must be string"); builtin_error_occurred("io.fin","\"filename\" must be string");
return NULL; return NULL;
@ -252,21 +259,21 @@ nasal_scalar* builtin_finput(nasal_scalar* local_scope_addr,nasal_virtual_machin
else else
builtin_error_occurred("io.fin","cannot open \""+filename+"\"."); builtin_error_occurred("io.fin","cannot open \""+filename+"\".");
fin.close(); fin.close();
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_string); nasal_val* ret_addr=gc.gc_alloc(vm_str);
ret_addr->set_string(file_content); ret_addr->set_string(file_content);
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_foutput(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_foutput(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* value_addr=in_builtin_find("filename"); nasal_val* value_addr=in_builtin_find("filename");
nasal_scalar* str_value_addr=in_builtin_find("str"); nasal_val* str_value_addr=in_builtin_find("str");
if(value_addr->get_type()!=vm_string) if(value_addr->get_type()!=vm_str)
{ {
builtin_error_occurred("io.fout","\"filename\" must be string"); builtin_error_occurred("io.fout","\"filename\" must be string");
return NULL; return NULL;
} }
if(str_value_addr->get_type()!=vm_string) if(str_value_addr->get_type()!=vm_str)
{ {
builtin_error_occurred("io.fout","\"str\" must be string"); builtin_error_occurred("io.fout","\"str\" must be string");
return NULL; return NULL;
@ -276,20 +283,20 @@ nasal_scalar* builtin_foutput(nasal_scalar* local_scope_addr,nasal_virtual_machi
std::ofstream fout(filename); std::ofstream fout(filename);
fout<<file_content; fout<<file_content;
fout.close(); fout.close();
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_nil); nasal_val* ret_addr=gc.gc_alloc(vm_nil);
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_split(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_split(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* delimeter_value_addr=in_builtin_find("delimeter"); nasal_val* delimeter_value_addr=in_builtin_find("delimeter");
nasal_scalar* string_value_addr=in_builtin_find("string"); nasal_val* string_value_addr=in_builtin_find("string");
if(delimeter_value_addr->get_type()!=vm_string) if(delimeter_value_addr->get_type()!=vm_str)
{ {
builtin_error_occurred("split","\"delimeter\" must be string"); builtin_error_occurred("split","\"delimeter\" must be string");
return NULL; return NULL;
} }
if(string_value_addr->get_type()!=vm_string) if(string_value_addr->get_type()!=vm_str)
{ {
builtin_error_occurred("split","\"string\" must be string"); builtin_error_occurred("split","\"string\" must be string");
return NULL; return NULL;
@ -299,8 +306,8 @@ nasal_scalar* builtin_split(nasal_scalar* local_scope_addr,nasal_virtual_machine
int delimeter_len=delimeter.length(); int delimeter_len=delimeter.length();
int source_len=source.length(); int source_len=source.length();
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_vector); nasal_val* ret_addr=gc.gc_alloc(vm_vec);
nasal_vector& ref_vec=ret_addr->get_vector(); nasal_vec& ref_vec=ret_addr->get_vector();
std::string tmp=""; std::string tmp="";
if(!delimeter_len) if(!delimeter_len)
@ -308,7 +315,7 @@ nasal_scalar* builtin_split(nasal_scalar* local_scope_addr,nasal_virtual_machine
for(int i=0;i<source_len;++i) for(int i=0;i<source_len;++i)
{ {
tmp=source[i]; tmp=source[i];
nasal_scalar* str_addr=nasal_vm.gc_alloc(vm_string); nasal_val* str_addr=gc.gc_alloc(vm_str);
str_addr->set_string(tmp); str_addr->set_string(tmp);
ref_vec.add_elem(str_addr); ref_vec.add_elem(str_addr);
} }
@ -328,7 +335,7 @@ nasal_scalar* builtin_split(nasal_scalar* local_scope_addr,nasal_virtual_machine
} }
if(check_delimeter) if(check_delimeter)
{ {
nasal_scalar* str_addr=nasal_vm.gc_alloc(vm_string); nasal_val* str_addr=gc.gc_alloc(vm_str);
str_addr->set_string(tmp); str_addr->set_string(tmp);
ref_vec.add_elem(str_addr); ref_vec.add_elem(str_addr);
tmp=""; tmp="";
@ -339,416 +346,416 @@ nasal_scalar* builtin_split(nasal_scalar* local_scope_addr,nasal_virtual_machine
} }
if(tmp.length()) if(tmp.length())
{ {
nasal_scalar* str_addr=nasal_vm.gc_alloc(vm_string); nasal_val* str_addr=gc.gc_alloc(vm_str);
str_addr->set_string(tmp); str_addr->set_string(tmp);
ref_vec.add_elem(str_addr); ref_vec.add_elem(str_addr);
tmp=""; tmp="";
} }
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_rand(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_rand(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* value_addr=in_builtin_find("seed"); nasal_val* value_addr=in_builtin_find("seed");
if(value_addr->get_type()!=vm_number && value_addr->get_type()!=vm_nil) if(value_addr->get_type()!=vm_num && value_addr->get_type()!=vm_nil)
{ {
builtin_error_occurred("rand","\"seed\" must be nil or number"); builtin_error_occurred("rand","\"seed\" must be nil or number");
return NULL; return NULL;
} }
if(value_addr->get_type()==vm_number) if(value_addr->get_type()==vm_num)
{ {
unsigned int number=(unsigned int)value_addr->get_number(); unsigned int number=(unsigned int)value_addr->get_number();
srand(number); srand(number);
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_nil); nasal_val* ret_addr=gc.gc_alloc(vm_nil);
return ret_addr; return ret_addr;
} }
double num=0; double num=0;
for(int i=0;i<5;++i) for(int i=0;i<5;++i)
num=(num+rand())*(1.0/(RAND_MAX+1.0)); num=(num+rand())*(1.0/(RAND_MAX+1.0));
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); nasal_val* ret_addr=gc.gc_alloc(vm_num);
ret_addr->set_number(num); ret_addr->set_number(num);
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_id(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_id(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* value_addr=in_builtin_find("thing"); nasal_val* value_addr=in_builtin_find("thing");
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_string); nasal_val* ret_addr=gc.gc_alloc(vm_str);
char buf[32]; char buf[32];
sprintf(buf,"0x%p",value_addr); sprintf(buf,"0x%p",value_addr);
ret_addr->set_string(buf); ret_addr->set_string(buf);
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_int(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_int(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* value_addr=in_builtin_find("value"); nasal_val* value_addr=in_builtin_find("value");
if(value_addr->get_type()!=vm_number) if(value_addr->get_type()!=vm_num)
{ {
builtin_error_occurred("int","\"value\" must be number"); builtin_error_occurred("int","\"value\" must be number");
return NULL; return NULL;
} }
int number=(int)value_addr->get_number(); int number=(int)value_addr->get_number();
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); nasal_val* ret_addr=gc.gc_alloc(vm_num);
ret_addr->set_number((double)number); ret_addr->set_number((double)number);
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_num(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_num(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* value_addr=in_builtin_find("value"); nasal_val* value_addr=in_builtin_find("value");
if(value_addr->get_type()!=vm_string) if(value_addr->get_type()!=vm_str)
{ {
builtin_error_occurred("num","\"value\" must be string"); builtin_error_occurred("num","\"value\" must be string");
return NULL; return NULL;
} }
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); nasal_val* ret_addr=gc.gc_alloc(vm_num);
ret_addr->set_number(value_addr->to_number()); ret_addr->set_number(value_addr->to_number());
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_pop(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_pop(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* value_addr=in_builtin_find("vector"); nasal_val* value_addr=in_builtin_find("vector");
if(value_addr->get_type()!=vm_vector) if(value_addr->get_type()!=vm_vec)
{ {
builtin_error_occurred("pop","\"vector\" must be vector"); builtin_error_occurred("pop","\"vector\" must be vector");
return NULL; return NULL;
} }
nasal_scalar* ret_addr=value_addr->get_vector().del_elem(); nasal_val* ret_addr=value_addr->get_vector().del_elem();
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_str(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_str(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* value_addr=in_builtin_find("number"); nasal_val* value_addr=in_builtin_find("number");
if(value_addr->get_type()!=vm_number) if(value_addr->get_type()!=vm_num)
{ {
builtin_error_occurred("str","\"number\" must be number"); builtin_error_occurred("str","\"number\" must be number");
return NULL; return NULL;
} }
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); nasal_val* ret_addr=gc.gc_alloc(vm_num);
ret_addr->set_string(value_addr->to_string()); ret_addr->set_string(value_addr->to_string());
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_size(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_size(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* value_addr=in_builtin_find("object"); nasal_val* value_addr=in_builtin_find("object");
int type=value_addr->get_type(); int type=value_addr->get_type();
int number=-1; int number=-1;
switch(type) switch(type)
{ {
case vm_nil: case vm_nil:
case vm_number: case vm_num:
case vm_function: case vm_func:
case vm_closure: return nasal_vm.gc_alloc(vm_nil); break; case vm_scop: return gc.gc_alloc(vm_nil); break;
case vm_string: number=value_addr->get_string().length(); break; case vm_str: number=value_addr->get_string().length(); break;
case vm_vector: number=value_addr->get_vector().size(); break; case vm_vec: number=value_addr->get_vector().size(); break;
case vm_hash: number=value_addr->get_hash().size(); break; case vm_hash: number=value_addr->get_hash().size(); break;
} }
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); nasal_val* ret_addr=gc.gc_alloc(vm_num);
ret_addr->set_number((double)number); ret_addr->set_number((double)number);
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_xor(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_xor(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* a_addr=in_builtin_find("a"); nasal_val* a_addr=in_builtin_find("a");
nasal_scalar* b_addr=in_builtin_find("b"); nasal_val* b_addr=in_builtin_find("b");
if(a_addr->get_type()!=vm_number) if(a_addr->get_type()!=vm_num)
{ {
builtin_error_occurred("xor","\"a\" must be number"); builtin_error_occurred("xor","\"a\" must be number");
return NULL; return NULL;
} }
if(b_addr->get_type()!=vm_number) if(b_addr->get_type()!=vm_num)
{ {
builtin_error_occurred("xor","\"b\" must be number"); builtin_error_occurred("xor","\"b\" must be number");
return NULL; return NULL;
} }
int number_a=(int)a_addr->get_number(); int number_a=(int)a_addr->get_number();
int number_b=(int)b_addr->get_number(); int number_b=(int)b_addr->get_number();
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); nasal_val* ret_addr=gc.gc_alloc(vm_num);
ret_addr->set_number((double)(number_a^number_b)); ret_addr->set_number((double)(number_a^number_b));
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_and(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_and(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* a_addr=in_builtin_find("a"); nasal_val* a_addr=in_builtin_find("a");
nasal_scalar* b_addr=in_builtin_find("b"); nasal_val* b_addr=in_builtin_find("b");
if(a_addr->get_type()!=vm_number) if(a_addr->get_type()!=vm_num)
{ {
builtin_error_occurred("and","\"a\" must be number"); builtin_error_occurred("and","\"a\" must be number");
return NULL; return NULL;
} }
if(b_addr->get_type()!=vm_number) if(b_addr->get_type()!=vm_num)
{ {
builtin_error_occurred("and","\"b\" must be number"); builtin_error_occurred("and","\"b\" must be number");
return NULL; return NULL;
} }
int number_a=(int)a_addr->get_number(); int number_a=(int)a_addr->get_number();
int number_b=(int)b_addr->get_number(); int number_b=(int)b_addr->get_number();
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); nasal_val* ret_addr=gc.gc_alloc(vm_num);
ret_addr->set_number((double)(number_a&number_b)); ret_addr->set_number((double)(number_a&number_b));
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_or(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_or(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* a_addr=in_builtin_find("a"); nasal_val* a_addr=in_builtin_find("a");
nasal_scalar* b_addr=in_builtin_find("b"); nasal_val* b_addr=in_builtin_find("b");
if(a_addr->get_type()!=vm_number) if(a_addr->get_type()!=vm_num)
{ {
builtin_error_occurred("or","\"a\" must be number"); builtin_error_occurred("or","\"a\" must be number");
return NULL; return NULL;
} }
if(b_addr->get_type()!=vm_number) if(b_addr->get_type()!=vm_num)
{ {
builtin_error_occurred("or","\"b\" must be number"); builtin_error_occurred("or","\"b\" must be number");
return NULL; return NULL;
} }
int number_a=(int)a_addr->get_number(); int number_a=(int)a_addr->get_number();
int number_b=(int)b_addr->get_number(); int number_b=(int)b_addr->get_number();
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); nasal_val* ret_addr=gc.gc_alloc(vm_num);
ret_addr->set_number((double)(number_a|number_b)); ret_addr->set_number((double)(number_a|number_b));
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_nand(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_nand(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* a_addr=in_builtin_find("a"); nasal_val* a_addr=in_builtin_find("a");
nasal_scalar* b_addr=in_builtin_find("b"); nasal_val* b_addr=in_builtin_find("b");
if(a_addr->get_type()!=vm_number) if(a_addr->get_type()!=vm_num)
{ {
builtin_error_occurred("nand","\"a\" must be number"); builtin_error_occurred("nand","\"a\" must be number");
return NULL; return NULL;
} }
if(b_addr->get_type()!=vm_number) if(b_addr->get_type()!=vm_num)
{ {
builtin_error_occurred("nand","\"b\" must be number"); builtin_error_occurred("nand","\"b\" must be number");
return NULL; return NULL;
} }
int number_a=(int)a_addr->get_number(); int number_a=(int)a_addr->get_number();
int number_b=(int)b_addr->get_number(); int number_b=(int)b_addr->get_number();
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); nasal_val* ret_addr=gc.gc_alloc(vm_num);
ret_addr->set_number((double)(~(number_a&number_b))); ret_addr->set_number((double)(~(number_a&number_b)));
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_not(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_not(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* a_addr=in_builtin_find("a"); nasal_val* a_addr=in_builtin_find("a");
if(a_addr->get_type()!=vm_number) if(a_addr->get_type()!=vm_num)
{ {
builtin_error_occurred("not","\"a\" must be number"); builtin_error_occurred("not","\"a\" must be number");
return NULL; return NULL;
} }
int number=(int)a_addr->get_number(); int number=(int)a_addr->get_number();
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); nasal_val* ret_addr=gc.gc_alloc(vm_num);
ret_addr->set_number((double)(~number)); ret_addr->set_number((double)(~number));
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_sin(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_sin(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* value_addr=in_builtin_find("x"); nasal_val* value_addr=in_builtin_find("x");
if(value_addr->get_type()!=vm_number) if(value_addr->get_type()!=vm_num)
{ {
builtin_error_occurred("sin","\"x\" must be number"); builtin_error_occurred("sin","\"x\" must be number");
return NULL; return NULL;
} }
double number=value_addr->get_number(); double number=value_addr->get_number();
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); nasal_val* ret_addr=gc.gc_alloc(vm_num);
ret_addr->set_number(sin(number)); ret_addr->set_number(sin(number));
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_cos(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_cos(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* value_addr=in_builtin_find("x"); nasal_val* value_addr=in_builtin_find("x");
if(value_addr->get_type()!=vm_number) if(value_addr->get_type()!=vm_num)
{ {
builtin_error_occurred("cos","\"x\" must be number"); builtin_error_occurred("cos","\"x\" must be number");
return NULL; return NULL;
} }
double number=value_addr->get_number(); double number=value_addr->get_number();
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); nasal_val* ret_addr=gc.gc_alloc(vm_num);
ret_addr->set_number(cos(number)); ret_addr->set_number(cos(number));
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_tan(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_tan(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* value_addr=in_builtin_find("x"); nasal_val* value_addr=in_builtin_find("x");
if(value_addr->get_type()!=vm_number) if(value_addr->get_type()!=vm_num)
{ {
builtin_error_occurred("tan","\"x\" must be number"); builtin_error_occurred("tan","\"x\" must be number");
return NULL; return NULL;
} }
double number=value_addr->get_number(); double number=value_addr->get_number();
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); nasal_val* ret_addr=gc.gc_alloc(vm_num);
ret_addr->set_number(tan(number)); ret_addr->set_number(tan(number));
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_exp(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_exp(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* value_addr=in_builtin_find("x"); nasal_val* value_addr=in_builtin_find("x");
if(value_addr->get_type()!=vm_number) if(value_addr->get_type()!=vm_num)
{ {
builtin_error_occurred("exp","\"x\" must be number"); builtin_error_occurred("exp","\"x\" must be number");
return NULL; return NULL;
} }
double number=value_addr->get_number(); double number=value_addr->get_number();
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); nasal_val* ret_addr=gc.gc_alloc(vm_num);
ret_addr->set_number(exp(number)); ret_addr->set_number(exp(number));
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_ln(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_ln(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* value_addr=in_builtin_find("x"); nasal_val* value_addr=in_builtin_find("x");
if(value_addr->get_type()!=vm_number) if(value_addr->get_type()!=vm_num)
{ {
builtin_error_occurred("ln","\"x\" must be number"); builtin_error_occurred("ln","\"x\" must be number");
return NULL; return NULL;
} }
double number=value_addr->get_number(); double number=value_addr->get_number();
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); nasal_val* ret_addr=gc.gc_alloc(vm_num);
ret_addr->set_number(log(number)/log(2.7182818284590452354)); ret_addr->set_number(log(number)/log(2.7182818284590452354));
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_sqrt(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_sqrt(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* value_addr=in_builtin_find("x"); nasal_val* value_addr=in_builtin_find("x");
if(value_addr->get_type()!=vm_number) if(value_addr->get_type()!=vm_num)
{ {
builtin_error_occurred("sqrt","\"x\" must be number"); builtin_error_occurred("sqrt","\"x\" must be number");
return NULL; return NULL;
} }
double number=value_addr->get_number(); double number=value_addr->get_number();
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); nasal_val* ret_addr=gc.gc_alloc(vm_num);
ret_addr->set_number(sqrt(number)); ret_addr->set_number(sqrt(number));
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_atan2(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_atan2(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* x_value_addr=in_builtin_find("x"); nasal_val* x_value_addr=in_builtin_find("x");
nasal_scalar* y_value_addr=in_builtin_find("y"); nasal_val* y_value_addr=in_builtin_find("y");
if(x_value_addr->get_type()!=vm_number) if(x_value_addr->get_type()!=vm_num)
{ {
builtin_error_occurred("atan2","\"x\" must be number"); builtin_error_occurred("atan2","\"x\" must be number");
return NULL; return NULL;
} }
if(y_value_addr->get_type()!=vm_number) if(y_value_addr->get_type()!=vm_num)
{ {
builtin_error_occurred("atan2","\"y\" must be number"); builtin_error_occurred("atan2","\"y\" must be number");
return NULL; return NULL;
} }
double x=x_value_addr->get_number(); double x=x_value_addr->get_number();
double y=y_value_addr->get_number(); double y=y_value_addr->get_number();
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); nasal_val* ret_addr=gc.gc_alloc(vm_num);
ret_addr->set_number(atan2(y,x)); ret_addr->set_number(atan2(y,x));
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_time(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_time(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* value_addr=in_builtin_find("begin_time"); nasal_val* value_addr=in_builtin_find("begin_time");
if(value_addr->get_type()!=vm_number) if(value_addr->get_type()!=vm_num)
{ {
builtin_error_occurred("time","\"begin_time\" must be number"); builtin_error_occurred("time","\"begin_time\" must be number");
return NULL; return NULL;
} }
time_t begin_time=(time_t)value_addr->get_number(); time_t begin_time=(time_t)value_addr->get_number();
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); nasal_val* ret_addr=gc.gc_alloc(vm_num);
ret_addr->set_number((double)time(&begin_time)); ret_addr->set_number((double)time(&begin_time));
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_contains(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_contains(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* hash_addr=in_builtin_find("hash"); nasal_val* hash_addr=in_builtin_find("hash");
nasal_scalar* key_addr=in_builtin_find("key"); nasal_val* key_addr=in_builtin_find("key");
if(hash_addr->get_type()!=vm_hash) if(hash_addr->get_type()!=vm_hash)
{ {
builtin_error_occurred("contains","\"hash\" must be hash"); builtin_error_occurred("contains","\"hash\" must be hash");
return NULL; return NULL;
} }
if(key_addr->get_type()!=vm_string) if(key_addr->get_type()!=vm_str)
{ {
builtin_error_occurred("contains","\"key\" must be string"); builtin_error_occurred("contains","\"key\" must be string");
return NULL; return NULL;
} }
bool contains=hash_addr->get_hash().check_contain(key_addr->get_string()); bool contains=hash_addr->get_hash().check_contain(key_addr->get_string());
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); nasal_val* ret_addr=gc.gc_alloc(vm_num);
ret_addr->set_number((double)contains); ret_addr->set_number((double)contains);
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_delete(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_delete(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* hash_addr=in_builtin_find("hash"); nasal_val* hash_addr=in_builtin_find("hash");
nasal_scalar* key_addr=in_builtin_find("key"); nasal_val* key_addr=in_builtin_find("key");
if(hash_addr->get_type()!=vm_hash) if(hash_addr->get_type()!=vm_hash)
{ {
builtin_error_occurred("delete","\"hash\" must be hash"); builtin_error_occurred("delete","\"hash\" must be hash");
return NULL; return NULL;
} }
if(key_addr->get_type()!=vm_string) if(key_addr->get_type()!=vm_str)
{ {
builtin_error_occurred("delete","\"key\" must be string"); builtin_error_occurred("delete","\"key\" must be string");
return NULL; return NULL;
} }
hash_addr->get_hash().del_elem(key_addr->get_string()); hash_addr->get_hash().del_elem(key_addr->get_string());
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_nil); nasal_val* ret_addr=gc.gc_alloc(vm_nil);
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_getkeys(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_getkeys(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* hash_addr=in_builtin_find("hash"); nasal_val* hash_addr=in_builtin_find("hash");
if(hash_addr->get_type()!=vm_hash) if(hash_addr->get_type()!=vm_hash)
{ {
builtin_error_occurred("keys","\"hash\" must be hash"); builtin_error_occurred("keys","\"hash\" must be hash");
return NULL; return NULL;
} }
nasal_scalar* ret_addr=hash_addr->get_hash().get_keys(); nasal_val* ret_addr=hash_addr->get_hash().get_keys();
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_import(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_import(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
// 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_error_occurred("import","cannot use import when running");
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_nil); nasal_val* ret_addr=gc.gc_alloc(vm_nil);
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_die(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_die(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* str_addr=in_builtin_find("str"); nasal_val* str_addr=in_builtin_find("str");
if(str_addr->get_type()!=vm_string) if(str_addr->get_type()!=vm_str)
{ {
builtin_error_occurred("die","\"str\" must be string"); builtin_error_occurred("die","\"str\" must be string");
return NULL; return NULL;
} }
builtin_die_state=true; builtin_die_state=true;
std::cout<<">> [vm] error: "<<str_addr->get_string()<<'\n'; std::cout<<">> [vm] error: "<<str_addr->get_string()<<'\n';
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_nil); nasal_val* ret_addr=gc.gc_alloc(vm_nil);
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_type(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_type(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* value_addr=in_builtin_find("object"); nasal_val* value_addr=in_builtin_find("object");
int type=value_addr->get_type(); int type=value_addr->get_type();
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_string); nasal_val* ret_addr=gc.gc_alloc(vm_str);
switch(type) switch(type)
{ {
case vm_nil: ret_addr->set_string("nil");break; case vm_nil: ret_addr->set_string("nil");break;
case vm_number: ret_addr->set_string("number");break; case vm_num: ret_addr->set_string("number");break;
case vm_string: ret_addr->set_string("string");break; case vm_str: ret_addr->set_string("string");break;
case vm_vector: ret_addr->set_string("vector");break; case vm_vec: ret_addr->set_string("vector");break;
case vm_hash: ret_addr->set_string("hash");break; case vm_hash: ret_addr->set_string("hash");break;
case vm_function: ret_addr->set_string("function");break; case vm_func: ret_addr->set_string("function");break;
} }
return ret_addr; return ret_addr;
} }
nasal_scalar* builtin_substr(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) nasal_val* builtin_substr(nasal_val* local_scope_addr,nasal_gc& gc)
{ {
nasal_scalar* str_addr=in_builtin_find("str"); nasal_val* str_addr=in_builtin_find("str");
nasal_scalar* begin_addr=in_builtin_find("begin"); nasal_val* begin_addr=in_builtin_find("begin");
nasal_scalar* length_addr=in_builtin_find("length"); nasal_val* length_addr=in_builtin_find("length");
if(str_addr->get_type()!=vm_string) if(str_addr->get_type()!=vm_str)
{ {
builtin_error_occurred("substr","\"str\" must be string"); builtin_error_occurred("substr","\"str\" must be string");
return NULL; return NULL;
} }
if(begin_addr->get_type()!=vm_number) if(begin_addr->get_type()!=vm_num)
{ {
builtin_error_occurred("substr","\"begin\" must be number"); builtin_error_occurred("substr","\"begin\" must be number");
return NULL; return NULL;
} }
if(length_addr->get_type()!=vm_number) if(length_addr->get_type()!=vm_num)
{ {
builtin_error_occurred("substr","\"length\" must be number"); builtin_error_occurred("substr","\"length\" must be number");
return NULL; return NULL;
@ -764,7 +771,7 @@ nasal_scalar* builtin_substr(nasal_scalar* local_scope_addr,nasal_virtual_machin
std::string tmp=""; std::string tmp="";
for(int i=begin;i<begin+len;++i) for(int i=begin;i<begin+len;++i)
tmp+=str[i]; tmp+=str[i];
nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_string); nasal_val* ret_addr=gc.gc_alloc(vm_str);
ret_addr->set_string(tmp); ret_addr->set_string(tmp);
return ret_addr; return ret_addr;
} }

538
nasal_gc.h
View File

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

13
nasal_parse.h
View File

@ -986,7 +986,8 @@ nasal_ast nasal_parse::multi_assgin()
node.add_child(check_multi_scalar()?multi_scalar(false):calculation()); node.add_child(check_multi_scalar()?multi_scalar(false):calculation());
else else
node.add_child(calculation()); node.add_child(calculation());
if(node.get_children()[1].get_type()==ast_multi_scalar && node.get_children()[0].get_children().size()!=node.get_children()[1].get_children().size()) if(node.get_children()[1].get_type()==ast_multi_scalar
&& node.get_children()[0].get_children().size()!=node.get_children()[1].get_children().size())
die(node.get_children()[0].get_line(),"too much or lack values in multi-assignment"); die(node.get_children()[0].get_line(),"too much or lack values in multi-assignment");
return node; return node;
} }
@ -1045,7 +1046,15 @@ nasal_ast nasal_parse::for_loop()
else if(tok_list[ptr].type==tok_var) else if(tok_list[ptr].type==tok_var)
node.add_child(definition()); node.add_child(definition());
else if(tok_list[ptr].type==tok_left_curve) else if(tok_list[ptr].type==tok_left_curve)
node.add_child(check_multi_definition()?definition():(check_multi_scalar()?multi_assgin():calculation())); node.add_child(
check_multi_definition()?
definition():
(
check_multi_scalar()?
multi_assgin():
calculation()
)
);
else else
node.add_child(calculation()); node.add_child(calculation());
if(++ptr>=tok_list_size || tok_list[ptr].type!=tok_semi) if(++ptr>=tok_list_size || tok_list[ptr].type!=tok_semi)

754
nasal_bytecode_vm.h → nasal_vm.h
View File

File diff suppressed because it is too large Load Diff