From 3be50116faedb52c4c3a64725f0964ffa25690d9 Mon Sep 17 00:00:00 2001 From: Valk Richard Li <48872266+ValKmjolnir@users.noreply.github.com> Date: Wed, 10 Feb 2021 00:12:22 +0800 Subject: [PATCH] update --- main.cpp | 2 +- nasal.h | 2 +- nasal_builtin.h | 467 +++++++++--------- nasal_gc.h | 538 +++++++++++---------- nasal_parse.h | 13 +- nasal_bytecode_vm.h => nasal_vm.h | 754 +++++++++++++++--------------- 6 files changed, 889 insertions(+), 887 deletions(-) rename nasal_bytecode_vm.h => nasal_vm.h (53%) diff --git a/main.cpp b/main.cpp index 55b5742..42deb9c 100644 --- a/main.cpp +++ b/main.cpp @@ -5,7 +5,7 @@ nasal_parse parse; nasal_import import; std::string inputfile="null"; nasal_codegen code_generator; -nasal_bytecode_vm bytevm; +nasal_vm bytevm; void help() { diff --git a/nasal.h b/nasal.h index e028236..e29f444 100644 --- a/nasal.h +++ b/nasal.h @@ -134,6 +134,6 @@ std::string trans_number_to_string(double number) #include "nasal_gc.h" #include "nasal_builtin.h" #include "nasal_codegen.h" -#include "nasal_bytecode_vm.h" +#include "nasal_vm.h" #endif diff --git a/nasal_builtin.h b/nasal_builtin.h index bded7f7..86f6a6e 100644 --- a/nasal_builtin.h +++ b/nasal_builtin.h @@ -11,48 +11,54 @@ std::map builtin_use_string_table; // 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 // to add new builtin function,declare it here and write the definition below -nasal_scalar* builtin_print(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_append(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_setsize(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_system(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_input(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_sleep(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_finput(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_foutput(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_split(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_rand(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_id(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_int(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_num(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_pop(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_str(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_size(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_xor(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_and(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_or(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_nand(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_not(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_sin(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_cos(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_tan(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_exp(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_ln(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_sqrt(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_atan2(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_time(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_contains(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_delete(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_getkeys(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_import(nasal_scalar*,nasal_virtual_machine&); -bool builtin_die_state;// used in builtin_die -nasal_scalar* builtin_die(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_type(nasal_scalar*,nasal_virtual_machine&); -nasal_scalar* builtin_substr(nasal_scalar*,nasal_virtual_machine&); +nasal_val* builtin_print(nasal_val*,nasal_gc&); +nasal_val* builtin_append(nasal_val*,nasal_gc&); +nasal_val* builtin_setsize(nasal_val*,nasal_gc&); +nasal_val* builtin_system(nasal_val*,nasal_gc&); +nasal_val* builtin_input(nasal_val*,nasal_gc&); +nasal_val* builtin_sleep(nasal_val*,nasal_gc&); +nasal_val* builtin_finput(nasal_val*,nasal_gc&); +nasal_val* builtin_foutput(nasal_val*,nasal_gc&); +nasal_val* builtin_split(nasal_val*,nasal_gc&); +nasal_val* builtin_rand(nasal_val*,nasal_gc&); +nasal_val* builtin_id(nasal_val*,nasal_gc&); +nasal_val* builtin_int(nasal_val*,nasal_gc&); +nasal_val* builtin_num(nasal_val*,nasal_gc&); +nasal_val* builtin_pop(nasal_val*,nasal_gc&); +nasal_val* builtin_str(nasal_val*,nasal_gc&); +nasal_val* builtin_size(nasal_val*,nasal_gc&); +nasal_val* builtin_xor(nasal_val*,nasal_gc&); +nasal_val* builtin_and(nasal_val*,nasal_gc&); +nasal_val* builtin_or(nasal_val*,nasal_gc&); +nasal_val* builtin_nand(nasal_val*,nasal_gc&); +nasal_val* builtin_not(nasal_val*,nasal_gc&); +nasal_val* builtin_sin(nasal_val*,nasal_gc&); +nasal_val* builtin_cos(nasal_val*,nasal_gc&); +nasal_val* builtin_tan(nasal_val*,nasal_gc&); +nasal_val* builtin_exp(nasal_val*,nasal_gc&); +nasal_val* builtin_ln(nasal_val*,nasal_gc&); +nasal_val* builtin_sqrt(nasal_val*,nasal_gc&); +nasal_val* builtin_atan2(nasal_val*,nasal_gc&); +nasal_val* builtin_time(nasal_val*,nasal_gc&); +nasal_val* builtin_contains(nasal_val*,nasal_gc&); +nasal_val* builtin_delete(nasal_val*,nasal_gc&); +nasal_val* builtin_getkeys(nasal_val*,nasal_gc&); +nasal_val* builtin_import(nasal_val*,nasal_gc&); +bool builtin_die_state;// used in builtin_die +nasal_val* builtin_die(nasal_val*,nasal_gc&); +nasal_val* builtin_type(nasal_val*,nasal_gc&); +nasal_val* builtin_substr(nasal_val*,nasal_gc&); 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 { 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[]= { {"nasal_call_builtin_std_cout", builtin_print}, @@ -108,63 +114,63 @@ struct FUNC_TABLE {"", 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 - nasal_scalar* vector_value_addr=in_builtin_find("elements"); + nasal_val* vector_value_addr=in_builtin_find("elements"); // 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(); for(int i=0;iget_type()) { - case vm_nil: std::cout<<"nil"; break; - case vm_number: std::cout<get_number(); break; - case vm_string: std::cout<get_string(); break; - case vm_vector: tmp->get_vector().print(); break; - case vm_hash: tmp->get_hash().print(); break; - case vm_function: std::cout<<"func(...){...}"; break; + case vm_nil: std::cout<<"nil"; break; + case vm_num: std::cout<get_number(); break; + case vm_str: std::cout<get_string(); break; + case vm_vec: tmp->get_vector().print(); break; + case vm_hash: tmp->get_hash().print(); break; + case vm_func: std::cout<<"func(...){...}"; break; } } std::cout<<"\n"; // 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; } -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_scalar* elem_value_addr=in_builtin_find("elements"); - if(vector_value_addr->get_type()!=vm_vector) + nasal_val* vector_value_addr=in_builtin_find("vector"); + nasal_val* elem_value_addr=in_builtin_find("elements"); + if(vector_value_addr->get_type()!=vm_vec) { builtin_error_occurred("append","\"vector\" must be vector"); return NULL; } - nasal_vector& ref_vector=vector_value_addr->get_vector(); - nasal_vector& ref_elements=elem_value_addr->get_vector(); + nasal_vec& ref_vector=vector_value_addr->get_vector(); + nasal_vec& ref_elements=elem_value_addr->get_vector(); int size=ref_elements.size(); for(int i=0;iget_type()!=vm_vector) + nasal_val* vector_value_addr=in_builtin_find("vector"); + nasal_val* size_value_addr=in_builtin_find("size"); + if(vector_value_addr->get_type()!=vm_vec) { builtin_error_occurred("setsize","\"vector\" must be vector"); return NULL; } int type=size_value_addr->get_type(); - if(type!=vm_number) + if(type!=vm_num) { builtin_error_occurred("setsize","\"size\" is not a number"); 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"); 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(); if(numbervec_size) for(int i=vec_size;iget_type()!=vm_string) + nasal_val* str_value_addr=in_builtin_find("str"); + if(str_value_addr->get_type()!=vm_str) { builtin_error_occurred("system","\"str\" must be string"); return NULL; } std::string str=str_value_addr->get_string(); 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; } -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::cin>>str; ret_addr->set_string(str); 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(); - if(type!=vm_number) + if(type!=vm_num) { builtin_error_occurred("sleep","\"duration\" must be number"); return NULL; } - sleep((unsigned long)value_addr->get_number()); // sleep in unistd.h will make this progress sleep sleep_time seconds. - nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_nil); + // sleep in unistd.h will make this progress sleep sleep_time seconds. + sleep((unsigned long)value_addr->get_number()); + nasal_val* ret_addr=gc.gc_alloc(vm_nil); 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"); - if(value_addr->get_type()!=vm_string) + nasal_val* value_addr=in_builtin_find("filename"); + if(value_addr->get_type()!=vm_str) { builtin_error_occurred("io.fin","\"filename\" must be string"); return NULL; @@ -252,21 +259,21 @@ nasal_scalar* builtin_finput(nasal_scalar* local_scope_addr,nasal_virtual_machin else builtin_error_occurred("io.fin","cannot open \""+filename+"\"."); 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); 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_scalar* str_value_addr=in_builtin_find("str"); - if(value_addr->get_type()!=vm_string) + nasal_val* value_addr=in_builtin_find("filename"); + nasal_val* str_value_addr=in_builtin_find("str"); + if(value_addr->get_type()!=vm_str) { builtin_error_occurred("io.fout","\"filename\" must be string"); 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"); return NULL; @@ -276,20 +283,20 @@ nasal_scalar* builtin_foutput(nasal_scalar* local_scope_addr,nasal_virtual_machi std::ofstream fout(filename); fout<get_type()!=vm_string) + nasal_val* delimeter_value_addr=in_builtin_find("delimeter"); + nasal_val* string_value_addr=in_builtin_find("string"); + if(delimeter_value_addr->get_type()!=vm_str) { builtin_error_occurred("split","\"delimeter\" must be string"); 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"); return NULL; @@ -299,8 +306,8 @@ nasal_scalar* builtin_split(nasal_scalar* local_scope_addr,nasal_virtual_machine int delimeter_len=delimeter.length(); int source_len=source.length(); - nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_vector); - nasal_vector& ref_vec=ret_addr->get_vector(); + nasal_val* ret_addr=gc.gc_alloc(vm_vec); + nasal_vec& ref_vec=ret_addr->get_vector(); std::string tmp=""; if(!delimeter_len) @@ -308,7 +315,7 @@ nasal_scalar* builtin_split(nasal_scalar* local_scope_addr,nasal_virtual_machine for(int i=0;iset_string(tmp); 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) { - nasal_scalar* str_addr=nasal_vm.gc_alloc(vm_string); + nasal_val* str_addr=gc.gc_alloc(vm_str); str_addr->set_string(tmp); ref_vec.add_elem(str_addr); tmp=""; @@ -339,416 +346,416 @@ nasal_scalar* builtin_split(nasal_scalar* local_scope_addr,nasal_virtual_machine } 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); ref_vec.add_elem(str_addr); tmp=""; } 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"); - if(value_addr->get_type()!=vm_number && value_addr->get_type()!=vm_nil) + nasal_val* value_addr=in_builtin_find("seed"); + if(value_addr->get_type()!=vm_num && value_addr->get_type()!=vm_nil) { builtin_error_occurred("rand","\"seed\" must be nil or number"); 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(); srand(number); - nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_nil); + nasal_val* ret_addr=gc.gc_alloc(vm_nil); return ret_addr; } double num=0; for(int i=0;i<5;++i) 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); 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_scalar* ret_addr=nasal_vm.gc_alloc(vm_string); + nasal_val* value_addr=in_builtin_find("thing"); + nasal_val* ret_addr=gc.gc_alloc(vm_str); char buf[32]; sprintf(buf,"0x%p",value_addr); ret_addr->set_string(buf); 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"); - if(value_addr->get_type()!=vm_number) + nasal_val* value_addr=in_builtin_find("value"); + if(value_addr->get_type()!=vm_num) { builtin_error_occurred("int","\"value\" must be number"); return NULL; } 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); 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"); - if(value_addr->get_type()!=vm_string) + nasal_val* value_addr=in_builtin_find("value"); + if(value_addr->get_type()!=vm_str) { builtin_error_occurred("num","\"value\" must be string"); 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()); 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"); - if(value_addr->get_type()!=vm_vector) + nasal_val* value_addr=in_builtin_find("vector"); + if(value_addr->get_type()!=vm_vec) { builtin_error_occurred("pop","\"vector\" must be vector"); 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; } -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"); - if(value_addr->get_type()!=vm_number) + nasal_val* value_addr=in_builtin_find("number"); + if(value_addr->get_type()!=vm_num) { builtin_error_occurred("str","\"number\" must be number"); 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()); 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 number=-1; switch(type) { case vm_nil: - case vm_number: - case vm_function: - case vm_closure: return nasal_vm.gc_alloc(vm_nil); break; - case vm_string: number=value_addr->get_string().length(); break; - case vm_vector: number=value_addr->get_vector().size(); break; - case vm_hash: number=value_addr->get_hash().size(); break; + case vm_num: + case vm_func: + case vm_scop: return gc.gc_alloc(vm_nil); break; + case vm_str: number=value_addr->get_string().length(); break; + case vm_vec: number=value_addr->get_vector().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); 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_scalar* b_addr=in_builtin_find("b"); - if(a_addr->get_type()!=vm_number) + nasal_val* a_addr=in_builtin_find("a"); + nasal_val* b_addr=in_builtin_find("b"); + if(a_addr->get_type()!=vm_num) { builtin_error_occurred("xor","\"a\" must be number"); return NULL; } - if(b_addr->get_type()!=vm_number) + if(b_addr->get_type()!=vm_num) { builtin_error_occurred("xor","\"b\" must be number"); return NULL; } int number_a=(int)a_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)); 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_scalar* b_addr=in_builtin_find("b"); - if(a_addr->get_type()!=vm_number) + nasal_val* a_addr=in_builtin_find("a"); + nasal_val* b_addr=in_builtin_find("b"); + if(a_addr->get_type()!=vm_num) { builtin_error_occurred("and","\"a\" must be number"); return NULL; } - if(b_addr->get_type()!=vm_number) + if(b_addr->get_type()!=vm_num) { builtin_error_occurred("and","\"b\" must be number"); return NULL; } int number_a=(int)a_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)); 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_scalar* b_addr=in_builtin_find("b"); - if(a_addr->get_type()!=vm_number) + nasal_val* a_addr=in_builtin_find("a"); + nasal_val* b_addr=in_builtin_find("b"); + if(a_addr->get_type()!=vm_num) { builtin_error_occurred("or","\"a\" must be number"); return NULL; } - if(b_addr->get_type()!=vm_number) + if(b_addr->get_type()!=vm_num) { builtin_error_occurred("or","\"b\" must be number"); return NULL; } int number_a=(int)a_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)); 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_scalar* b_addr=in_builtin_find("b"); - if(a_addr->get_type()!=vm_number) + nasal_val* a_addr=in_builtin_find("a"); + nasal_val* b_addr=in_builtin_find("b"); + if(a_addr->get_type()!=vm_num) { builtin_error_occurred("nand","\"a\" must be number"); return NULL; } - if(b_addr->get_type()!=vm_number) + if(b_addr->get_type()!=vm_num) { builtin_error_occurred("nand","\"b\" must be number"); return NULL; } int number_a=(int)a_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))); 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"); - if(a_addr->get_type()!=vm_number) + nasal_val* a_addr=in_builtin_find("a"); + if(a_addr->get_type()!=vm_num) { builtin_error_occurred("not","\"a\" must be number"); return NULL; } 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)); 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"); - if(value_addr->get_type()!=vm_number) + nasal_val* value_addr=in_builtin_find("x"); + if(value_addr->get_type()!=vm_num) { builtin_error_occurred("sin","\"x\" must be number"); return NULL; } 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)); 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"); - if(value_addr->get_type()!=vm_number) + nasal_val* value_addr=in_builtin_find("x"); + if(value_addr->get_type()!=vm_num) { builtin_error_occurred("cos","\"x\" must be number"); return NULL; } 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)); 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"); - if(value_addr->get_type()!=vm_number) + nasal_val* value_addr=in_builtin_find("x"); + if(value_addr->get_type()!=vm_num) { builtin_error_occurred("tan","\"x\" must be number"); return NULL; } 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)); 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"); - if(value_addr->get_type()!=vm_number) + nasal_val* value_addr=in_builtin_find("x"); + if(value_addr->get_type()!=vm_num) { builtin_error_occurred("exp","\"x\" must be number"); return NULL; } 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)); 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"); - if(value_addr->get_type()!=vm_number) + nasal_val* value_addr=in_builtin_find("x"); + if(value_addr->get_type()!=vm_num) { builtin_error_occurred("ln","\"x\" must be number"); return NULL; } 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)); 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"); - if(value_addr->get_type()!=vm_number) + nasal_val* value_addr=in_builtin_find("x"); + if(value_addr->get_type()!=vm_num) { builtin_error_occurred("sqrt","\"x\" must be number"); return NULL; } 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)); 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_scalar* y_value_addr=in_builtin_find("y"); - if(x_value_addr->get_type()!=vm_number) + nasal_val* x_value_addr=in_builtin_find("x"); + nasal_val* y_value_addr=in_builtin_find("y"); + if(x_value_addr->get_type()!=vm_num) { builtin_error_occurred("atan2","\"x\" must be number"); 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"); return NULL; } double x=x_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)); 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"); - if(value_addr->get_type()!=vm_number) + nasal_val* value_addr=in_builtin_find("begin_time"); + if(value_addr->get_type()!=vm_num) { builtin_error_occurred("time","\"begin_time\" must be number"); return NULL; } 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)); 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_scalar* key_addr=in_builtin_find("key"); + nasal_val* hash_addr=in_builtin_find("hash"); + nasal_val* key_addr=in_builtin_find("key"); if(hash_addr->get_type()!=vm_hash) { builtin_error_occurred("contains","\"hash\" must be hash"); return NULL; } - if(key_addr->get_type()!=vm_string) + if(key_addr->get_type()!=vm_str) { builtin_error_occurred("contains","\"key\" must be string"); return NULL; } 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); 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_scalar* key_addr=in_builtin_find("key"); + nasal_val* hash_addr=in_builtin_find("hash"); + nasal_val* key_addr=in_builtin_find("key"); if(hash_addr->get_type()!=vm_hash) { builtin_error_occurred("delete","\"hash\" must be hash"); return NULL; } - if(key_addr->get_type()!=vm_string) + if(key_addr->get_type()!=vm_str) { builtin_error_occurred("delete","\"key\" must be string"); return NULL; } 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; } -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) { builtin_error_occurred("keys","\"hash\" must be hash"); 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; } -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 will return nothing 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; } -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"); - if(str_addr->get_type()!=vm_string) + nasal_val* str_addr=in_builtin_find("str"); + if(str_addr->get_type()!=vm_str) { builtin_error_occurred("die","\"str\" must be string"); return NULL; } builtin_die_state=true; std::cout<<">> [vm] error: "<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; } -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(); - nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_string); + nasal_val* ret_addr=gc.gc_alloc(vm_str); switch(type) { case vm_nil: ret_addr->set_string("nil");break; - case vm_number: ret_addr->set_string("number");break; - case vm_string: ret_addr->set_string("string");break; - case vm_vector: ret_addr->set_string("vector");break; + case vm_num: ret_addr->set_string("number");break; + case vm_str: ret_addr->set_string("string");break; + case vm_vec: ret_addr->set_string("vector");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; } -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_scalar* begin_addr=in_builtin_find("begin"); - nasal_scalar* length_addr=in_builtin_find("length"); - if(str_addr->get_type()!=vm_string) + nasal_val* str_addr=in_builtin_find("str"); + nasal_val* begin_addr=in_builtin_find("begin"); + nasal_val* length_addr=in_builtin_find("length"); + if(str_addr->get_type()!=vm_str) { builtin_error_occurred("substr","\"str\" must be string"); return NULL; } - if(begin_addr->get_type()!=vm_number) + if(begin_addr->get_type()!=vm_num) { builtin_error_occurred("substr","\"begin\" must be number"); return NULL; } - if(length_addr->get_type()!=vm_number) + if(length_addr->get_type()!=vm_num) { builtin_error_occurred("substr","\"length\" must be number"); return NULL; @@ -764,7 +771,7 @@ nasal_scalar* builtin_substr(nasal_scalar* local_scope_addr,nasal_virtual_machin std::string tmp=""; for(int i=begin;iset_string(tmp); return ret_addr; } diff --git a/nasal_gc.h b/nasal_gc.h index f03bb6c..15c6385 100644 --- a/nasal_gc.h +++ b/nasal_gc.h @@ -4,110 +4,97 @@ enum runtime_scalar_type { vm_nil=0, - vm_number, - vm_string, - vm_closure, - vm_function, - vm_vector, + vm_num, + vm_str, + vm_scop, + vm_func, + vm_vec, 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 -> (int) -> address in memory -> value address in gc -*/ -class nasal_virtual_machine; -class nasal_vector; +class nasal_gc; +class nasal_vec; class nasal_hash; -class nasal_function; -class nasal_closure; -class nasal_scalar; +class nasal_func; +class nasal_scop; +class nasal_val; -class nasal_vector +class nasal_vec { private: - // this int points to the space in nasal_vm::memory_manager_memory - nasal_virtual_machine& vm; - std::vector elems; + nasal_gc& gc; + std::vector elems; public: - nasal_vector(nasal_virtual_machine&); - ~nasal_vector(); - void add_elem(nasal_scalar*); - nasal_scalar* del_elem(); + nasal_vec(nasal_gc&); + ~nasal_vec(); int size(); - nasal_scalar* operator[](const int); - nasal_scalar* get_value_address(int); - nasal_scalar** get_mem_address(int); + void add_elem(nasal_val*); 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 { private: - // this int points to the space in nasal_vm::memory_manager_memory - nasal_virtual_machine& vm; - std::map elems; + nasal_gc& gc; + std::map elems; public: - nasal_hash(nasal_virtual_machine&); + nasal_hash(nasal_gc&); ~nasal_hash(); - void add_elem(std::string,nasal_scalar*); - void del_elem(std::string); 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); - nasal_scalar* get_keys(); + void add_elem(std::string,nasal_val*); + void del_elem(std::string); 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: - nasal_virtual_machine& vm; + nasal_gc& gc; int entry; - nasal_scalar* closure_addr; - std::vector para_name; - int dynamic_para_name; - std::vector default_para_addr; + nasal_val* closure_addr; + std::vector para; + int dynpara; + std::vector default_para_addr; public: - nasal_function(nasal_virtual_machine&); - ~nasal_function(); - void set_entry(int); + nasal_func(nasal_gc&); + ~nasal_func(); int get_entry(); - void add_para(int,nasal_scalar*,bool); - std::vector& get_para(); int get_dynamic_para(); - std::vector& get_default(); - void set_closure_addr(nasal_scalar*); + void set_entry(int); + void add_para(int,nasal_val*,bool); + void set_closure_addr(nasal_val*); void set_new_closure(); - nasal_scalar* get_closure_addr(); + nasal_val* get_closure_addr(); + std::vector& get_para(); + std::vector& get_default(); }; -class nasal_closure +class nasal_scop { private: - // int in std::map points to the space in nasal_vm::memory_manager_memory - // and this memory_manager_memory space stores an address to garbage_collector_memory - // and this address points to an nasal_hash - nasal_virtual_machine& vm; - std::list > elems; + nasal_gc& gc; + std::list > elems; public: - nasal_closure(nasal_virtual_machine&); - ~nasal_closure(); + nasal_scop(nasal_gc&); + ~nasal_scop(); void add_scope(); void del_scope(); - void add_new_value(int,nasal_scalar*); - nasal_scalar* get_value_address(int); - nasal_scalar** get_mem_address(int); - void set_closure(nasal_closure&); + void set_closure(nasal_scop&); + void add_new_value(int,nasal_val*); + nasal_val* get_value_address(int); + nasal_val** get_mem_address(int); }; -class nasal_scalar +class nasal_val { protected: int type; @@ -115,104 +102,103 @@ protected: { double num; std::string* str; - nasal_vector* vec; - nasal_hash* hash; - nasal_function* func; - nasal_closure* cls; + nasal_vec* vec; + nasal_hash* hash; + nasal_func* func; + nasal_scop* cls; }ptr; public: int ref_cnt; - nasal_scalar(); - nasal_scalar(int,nasal_virtual_machine&); - ~nasal_scalar(); + nasal_val(); + nasal_val(int,nasal_gc&); + ~nasal_val(); void clear(); - void set_type(int,nasal_virtual_machine&); + void set_type(int,nasal_gc&); void set_number(double); void set_string(std::string); - int get_type(); - double to_number(); - double get_number(); - std::string to_string(); - std::string get_string(); - nasal_vector& get_vector(); - nasal_hash& get_hash(); - nasal_function& get_func(); - nasal_closure& get_closure(); + int get_type(); + double to_number(); + double get_number(); + std::string to_string(); + std::string get_string(); + nasal_vec& get_vector(); + nasal_hash& get_hash(); + nasal_func& get_func(); + nasal_scop& get_closure(); }; -class nasal_virtual_machine +class nasal_gc { private: - nasal_scalar error_returned_value; - std::queue garbage_collector_free_space; - std::vector garbage_collector_memory; + std::queue free_space; + std::vector memory; public: - ~nasal_virtual_machine(); + ~nasal_gc(); void clear(); void debug(); - nasal_scalar* gc_alloc(int); - void add_reference(nasal_scalar*); - void del_reference(nasal_scalar*); + nasal_val* gc_alloc(int); + void add_reference(nasal_val*); + void del_reference(nasal_val*); }; -/*functions of nasal_vector*/ -nasal_vector::nasal_vector(nasal_virtual_machine& nvm):vm(nvm) +/*functions of nasal_vec*/ +nasal_vec::nasal_vec(nasal_gc& ngc):gc(ngc) { return; } -nasal_vector::~nasal_vector() +nasal_vec::~nasal_vec() { int size=elems.size(); for(int i=0;i=vec_size) { - std::cout<<">> [vm] nasal_vector::get_value_address: index out of range: "<> [gc] nasal_vec::get_value_address: index out of range: "<=0]]; } -nasal_scalar** nasal_vector::get_mem_address(int index) +nasal_val** nasal_vec::get_mem_address(int index) { int vec_size=elems.size(); if(index<-vec_size || index>=vec_size) { - std::cout<<">> [vm] nasal_vector::get_mem_address: index out of range: "<> [gc] nasal_vec::get_mem_address: index out of range: "<=0]]; } -void nasal_vector::print() +void nasal_vec::print() { int size=elems.size(); std::cout<<"["; @@ -220,15 +206,15 @@ void nasal_vector::print() std::cout<<"]"; for(int i=0;iget_type()) { case vm_nil: std::cout<<"nil"; break; - case vm_number: std::cout<get_number(); break; - case vm_string: std::cout<get_string(); break; - case vm_vector: tmp->get_vector().print(); break; + case vm_num: std::cout<get_number(); break; + case vm_str: std::cout<get_string(); break; + case vm_vec: tmp->get_vector().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]; } @@ -236,18 +222,18 @@ void nasal_vector::print() } /*functions of nasal_hash*/ -nasal_hash::nasal_hash(nasal_virtual_machine& nvm):vm(nvm) +nasal_hash::nasal_hash(nasal_gc& ngc):gc(ngc) { return; } nasal_hash::~nasal_hash() { - for(std::map::iterator iter=elems.begin();iter!=elems.end();++iter) - vm.del_reference(iter->second); + for(std::map::iterator iter=elems.begin();iter!=elems.end();++iter) + gc.del_reference(iter->second); elems.clear(); 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()) elems[key]=value_address; @@ -257,7 +243,7 @@ void nasal_hash::del_elem(std::string key) { if(elems.find(key)!=elems.end()) { - vm.del_reference(elems[key]); + gc.del_reference(elems[key]); elems.erase(key); } return; @@ -266,27 +252,27 @@ int nasal_hash::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()) return elems[key]; 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()) return elems[key]; else if(elems.find("parents")!=elems.end()) { - nasal_scalar* val_addr=elems["parents"]; - if(val_addr->get_type()==vm_vector) + nasal_val* val_addr=elems["parents"]; + 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(); for(int i=0;iget_type()==vm_hash) ret_value_addr=tmp_val_addr->get_hash().get_value_address(key); if(ret_value_addr>=0) @@ -296,21 +282,21 @@ nasal_scalar* nasal_hash::get_value_address(std::string key) } 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()) return &elems[key]; else if(elems.find("parents")!=elems.end()) { - nasal_scalar* val_addr=elems["parents"]; - if(val_addr->get_type()==vm_vector) + nasal_val* val_addr=elems["parents"]; + 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(); for(int i=0;iget_type()==vm_hash) mem_addr=tmp_val_addr->get_hash().get_mem_address(key); if(mem_addr>0) @@ -327,14 +313,14 @@ bool nasal_hash::check_contain(std::string key) if(elems.find("parents")!=elems.end()) { bool result=false; - nasal_scalar* val_addr=elems["parents"]; - if(val_addr->get_type()==vm_vector) + nasal_val* val_addr=elems["parents"]; + 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(); for(int i=0;iget_type()==vm_hash) result=tmp_val_addr->get_hash().check_contain(key); if(result) @@ -345,13 +331,13 @@ bool nasal_hash::check_contain(std::string key) } return false; } -nasal_scalar* nasal_hash::get_keys() +nasal_val* nasal_hash::get_keys() { - nasal_scalar* ret_addr=vm.gc_alloc(vm_vector); - nasal_vector& ref_vec=ret_addr->get_vector(); - for(std::map::iterator iter=elems.begin();iter!=elems.end();++iter) + nasal_val* ret_addr=gc.gc_alloc(vm_vec); + nasal_vec& ref_vec=ret_addr->get_vector(); + for(std::map::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); ref_vec.add_elem(str_addr); } @@ -362,18 +348,18 @@ void nasal_hash::print() std::cout<<"{"; if(!elems.size()) std::cout<<"}"; - for(std::map::iterator i=elems.begin();i!=elems.end();++i) + for(std::map::iterator i=elems.begin();i!=elems.end();++i) { std::cout<first<<":"; - nasal_scalar* tmp=i->second; + nasal_val* tmp=i->second; switch(tmp->get_type()) { case vm_nil: std::cout<<"nil"; break; - case vm_number: std::cout<get_number(); break; - case vm_string: std::cout<get_string(); break; - case vm_vector: tmp->get_vector().print(); break; + case vm_num: std::cout<get_number(); break; + case vm_str: std::cout<get_string(); break; + case vm_vec: tmp->get_vector().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()]; --i; @@ -381,171 +367,171 @@ void nasal_hash::print() return; } -/*functions of nasal_function*/ -nasal_function::nasal_function(nasal_virtual_machine& nvm):vm(nvm) +/*functions of nasal_func*/ +nasal_func::nasal_func(nasal_gc& ngc):gc(ngc) { closure_addr=NULL; - dynamic_para_name=-1; + dynpara=-1; return; } -nasal_function::~nasal_function() +nasal_func::~nasal_func() { if(closure_addr) - vm.del_reference(closure_addr); + gc.del_reference(closure_addr); for(int i=0;i& nasal_function::get_para() +std::vector& 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_function::get_default() +std::vector& nasal_func::get_default() { 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()); closure_addr=new_closure; 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; } -nasal_scalar* nasal_function::get_closure_addr() +nasal_val* nasal_func::get_closure_addr() { return closure_addr; } -/*functions of nasal_closure*/ -nasal_closure::nasal_closure(nasal_virtual_machine& nvm):vm(nvm) +/*functions of nasal_scop*/ +nasal_scop::nasal_scop(nasal_gc& ngc):gc(ngc) { - std::map new_scope; + std::map new_scope; elems.push_back(new_scope); return; } -nasal_closure::~nasal_closure() +nasal_scop::~nasal_scop() { - for(std::list >::iterator i=elems.begin();i!=elems.end();++i) - for(std::map::iterator j=i->begin();j!=i->end();++j) - vm.del_reference(j->second); + for(std::list >::iterator i=elems.begin();i!=elems.end();++i) + for(std::map::iterator j=i->begin();j!=i->end();++j) + gc.del_reference(j->second); elems.clear(); return; } -void nasal_closure::add_scope() +void nasal_scop::add_scope() { - std::map new_scope; + std::map new_scope; elems.push_front(new_scope); return; } -void nasal_closure::del_scope() +void nasal_scop::del_scope() { - std::map& last_scope=elems.front(); - for(std::map::iterator i=last_scope.begin();i!=last_scope.end();++i) - vm.del_reference(i->second); + std::map& last_scope=elems.front(); + for(std::map::iterator i=last_scope.begin();i!=last_scope.end();++i) + gc.del_reference(i->second); elems.pop_front(); 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 this value already exists,delete the old value and update a new value - nasal_scalar* old_val_address=elems.front()[key]; - vm.del_reference(old_val_address); + nasal_val* old_val_address=elems.front()[key]; + gc.del_reference(old_val_address); } elems.front()[key]=value_address; return; } -nasal_scalar* nasal_closure::get_value_address(int key) +nasal_val* nasal_scop::get_value_address(int key) { - nasal_scalar* ret_address=NULL; - for(std::list >::iterator i=elems.begin();i!=elems.end();++i) + nasal_val* ret_address=NULL; + for(std::list >::iterator i=elems.begin();i!=elems.end();++i) if(i->find(key)!=i->end()) return (*i)[key]; 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; - for(std::list >::iterator i=elems.begin();i!=elems.end();++i) + nasal_val** ret_address=NULL; + for(std::list >::iterator i=elems.begin();i!=elems.end();++i) if(i->find(key)!=i->end()) return &((*i)[key]); return ret_address; } -void nasal_closure::set_closure(nasal_closure& tmp) +void nasal_scop::set_closure(nasal_scop& tmp) { - for(std::list >::iterator i=elems.begin();i!=elems.end();++i) - for(std::map::iterator j=i->begin();j!=i->end();++j) - vm.del_reference(j->second); + for(std::list >::iterator i=elems.begin();i!=elems.end();++i) + for(std::map::iterator j=i->begin();j!=i->end();++j) + gc.del_reference(j->second); elems.clear(); - for(std::list >::iterator i=tmp.elems.begin();i!=tmp.elems.end();++i) + for(std::list >::iterator i=tmp.elems.begin();i!=tmp.elems.end();++i) { - std::map new_scope; + std::map new_scope; elems.push_back(new_scope); - for(std::map::iterator j=i->begin();j!=i->end();++j) + for(std::map::iterator j=i->begin();j!=i->end();++j) { - nasal_scalar* value_addr=j->second; - vm.add_reference(value_addr); + nasal_val* value_addr=j->second; + gc.add_reference(value_addr); elems.back()[j->first]=value_addr; } } return; } -/*functions of nasal_scalar*/ -nasal_scalar::nasal_scalar() +/*functions of nasal_val*/ +nasal_val::nasal_val() { ref_cnt=1; type=vm_nil; 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; - type=nasal_scalar_type; - switch(nasal_scalar_type) + type=nasal_val_type; + switch(nasal_val_type) { case vm_nil: break; - case vm_number: ptr.num=0; break; - case vm_string: ptr.str=new std::string; break; - case vm_vector: ptr.vec=new nasal_vector(nvm); break; - case vm_hash: ptr.hash=new nasal_hash(nvm); break; - case vm_function: ptr.func=new nasal_function(nvm); break; - case vm_closure: ptr.cls=new nasal_closure(nvm); break; + case vm_num: ptr.num=0; break; + case vm_str: ptr.str=new std::string; break; + case vm_vec: ptr.vec=new nasal_vec(nvm); break; + case vm_hash: ptr.hash=new nasal_hash(nvm); break; + case vm_func: ptr.func=new nasal_func(nvm); break; + case vm_scop: ptr.cls=new nasal_scop(nvm); break; } return; } -nasal_scalar::~nasal_scalar() +nasal_val::~nasal_val() { // must set type and scalar_ptr to default first // this operation will avoid SIGTRAP caused by circular reference @@ -555,16 +541,16 @@ nasal_scalar::~nasal_scalar() switch(tmp_type) { case vm_nil: break; - case vm_number: break; - case vm_string: delete ptr.str; break; - case vm_vector: delete ptr.vec; break; + case vm_num: break; + case vm_str: delete ptr.str; break; + case vm_vec: delete ptr.vec; break; case vm_hash: delete ptr.hash; break; - case vm_function: delete ptr.func; break; - case vm_closure: delete ptr.cls; break; + case vm_func: delete ptr.func; break; + case vm_scop: delete ptr.cls; break; } return; } -void nasal_scalar::clear() +void nasal_val::clear() { // must set type and scalar_ptr to default first // this operation will avoid SIGTRAP caused by circular reference @@ -574,162 +560,162 @@ void nasal_scalar::clear() switch(tmp_type) { case vm_nil: break; - case vm_number: break; - case vm_string: delete ptr.str; break; - case vm_vector: delete ptr.vec; break; + case vm_num: break; + case vm_str: delete ptr.str; break; + case vm_vec: delete ptr.vec; break; case vm_hash: delete ptr.hash; break; - case vm_function: delete ptr.func; break; - case vm_closure: delete ptr.cls; break; + case vm_func: delete ptr.func; break; + case vm_scop: delete ptr.cls; break; } 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; - switch(nasal_scalar_type) + type=nasal_val_type; + switch(nasal_val_type) { case vm_nil: break; - case vm_number: ptr.num=0; break; - case vm_string: ptr.str=new std::string; break; - case vm_vector: ptr.vec=new nasal_vector(nvm); break; - case vm_hash: ptr.hash=new nasal_hash(nvm); break; - case vm_function: ptr.func=new nasal_function(nvm); break; - case vm_closure: ptr.cls=new nasal_closure(nvm); break; + case vm_num: ptr.num=0; break; + case vm_str: ptr.str=new std::string; break; + case vm_vec: ptr.vec=new nasal_vec(nvm); break; + case vm_hash: ptr.hash=new nasal_hash(nvm); break; + case vm_func: ptr.func=new nasal_func(nvm); break; + case vm_scop: ptr.cls=new nasal_scop(nvm); break; } return; } -void nasal_scalar::set_number(double num) +void nasal_val::set_number(double num) { ptr.num=num; return; } -void nasal_scalar::set_string(std::string str) +void nasal_val::set_string(std::string str) { *ptr.str=str; return; } -int nasal_scalar::get_type() +int nasal_val::get_type() { return type; } -double nasal_scalar::to_number() +double nasal_val::to_number() { switch(type) { case vm_nil: return 0; - case vm_number: return ptr.num; - case vm_string: return trans_string_to_number(*ptr.str); + case vm_num: return ptr.num; + case vm_str: return trans_string_to_number(*ptr.str); default: return std::nan(""); } return 0; } -double nasal_scalar::get_number() +double nasal_val::get_number() { return ptr.num; } -std::string nasal_scalar::to_string() +std::string nasal_val::to_string() { switch(type) { - case vm_number:return trans_number_to_string(ptr.num); - case vm_string:return *ptr.str; + case vm_num:return trans_number_to_string(ptr.num); + case vm_str:return *ptr.str; default:return ""; } return ""; } -std::string nasal_scalar::get_string() +std::string nasal_val::get_string() { return *ptr.str; } -nasal_vector& nasal_scalar::get_vector() +nasal_vec& nasal_val::get_vector() { return *ptr.vec; } -nasal_hash& nasal_scalar::get_hash() +nasal_hash& nasal_val::get_hash() { return *ptr.hash; } -nasal_function& nasal_scalar::get_func() +nasal_func& nasal_val::get_func() { return *ptr.func; } -nasal_closure& nasal_scalar::get_closure() +nasal_scop& nasal_val::get_closure() { return *ptr.cls; } -/*functions of nasal_virtual_machine*/ -nasal_virtual_machine::~nasal_virtual_machine() +/*functions of nasal_gc*/ +nasal_gc::~nasal_gc() { - int gc_mem_size=garbage_collector_memory.size(); + int gc_mem_size=memory.size(); for(int i=0;iclear(); + memory[i]->clear(); for(int i=0;iref_cnt) + if(memory[i]->ref_cnt) { - std::cout<<">> [debug] "<ref_cnt<<" "; - switch(garbage_collector_memory[i]->get_type()) + std::cout<<">> [debug] "<ref_cnt<<" "; + switch(memory[i]->get_type()) { case vm_nil:std::cout<<"nil";break; - case vm_number:std::cout<<"number "<get_number();break; - case vm_string:std::cout<<"string "<get_string();break; - case vm_vector:std::cout<<"vector";break; + case vm_num:std::cout<<"number "<get_number();break; + case vm_str:std::cout<<"string "<get_string();break; + case vm_vec:std::cout<<"vector";break; case vm_hash:std::cout<<"hash";break; - case vm_function:std::cout<<"function";break; - case vm_closure:std::cout<<"closure";break; + case vm_func:std::cout<<"function";break; + case vm_scop:std::cout<<"closure";break; } std::cout<<"\n"; } 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;iclear(); + memory[i]->clear(); for(int i=0;iref_cnt=1; ret->set_type(val_type,*this); 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; return; } -void nasal_virtual_machine::del_reference(nasal_scalar* value_address) +void nasal_gc::del_reference(nasal_val* value_address) { --value_address->ref_cnt; if(!value_address->ref_cnt) { value_address->clear(); - garbage_collector_free_space.push(value_address); + free_space.push(value_address); } return; } diff --git a/nasal_parse.h b/nasal_parse.h index 315b79c..901c3eb 100644 --- a/nasal_parse.h +++ b/nasal_parse.h @@ -986,7 +986,8 @@ nasal_ast nasal_parse::multi_assgin() node.add_child(check_multi_scalar()?multi_scalar(false):calculation()); else 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"); return node; } @@ -1045,7 +1046,15 @@ nasal_ast nasal_parse::for_loop() else if(tok_list[ptr].type==tok_var) node.add_child(definition()); 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 node.add_child(calculation()); if(++ptr>=tok_list_size || tok_list[ptr].type!=tok_semi) diff --git a/nasal_bytecode_vm.h b/nasal_vm.h similarity index 53% rename from nasal_bytecode_vm.h rename to nasal_vm.h index 16745be..9a20041 100644 --- a/nasal_bytecode_vm.h +++ b/nasal_vm.h @@ -1,27 +1,27 @@ -#ifndef __NASAL_BYTECODE_VM_H__ -#define __NASAL_BYTECODE_VM_H__ +#ifndef __NASAL_VM_H__ +#define __NASAL_VM_H__ -class nasal_bytecode_vm +class nasal_vm { private: bool main_loop_break_mark; int ptr; int me_index; // this is the index of "me" in string_table - nasal_scalar* global_scope_addr; + nasal_val* global_scope_addr; // garbage collector and memory manager - nasal_virtual_machine vm; + nasal_gc vm; // byte codes store here std::vector exec_code; // main calculation stack -#define VALUE_STACK_MAX_DEPTH 8192 - nasal_scalar** value_stack; - nasal_scalar** value_stack_top; +#define val_stack_MAX_DEPTH 8192 + nasal_val** val_stack; + nasal_val** val_stack_top; // stack for mem_call - std::stack pointer_stack; + std::stack ptr_stack; // local scope for function block - std::stack local_scope_stack; + std::stack local_scope_stack; // slice stack for vec[val,val,val:val] - std::stack slice_stack; + std::stack slice_stack; // ptr stack stores address for function to return std::stack call_stack; // iterator stack for forindex/foreach @@ -31,9 +31,9 @@ private: // number table std::vector number_table; // builtin function address table - std::map builtin_func_hashmap; + std::map builtin_func_hashmap; void die(std::string); - bool check_condition(nasal_scalar*); + bool check_condition(nasal_val*); void opr_nop(); void opr_load(); void opr_pushnum(); @@ -92,32 +92,32 @@ private: void opr_mcallh(); void opr_return(); public: - nasal_bytecode_vm(); - ~nasal_bytecode_vm(); + nasal_vm(); + ~nasal_vm(); void clear(); void run(std::vector&,std::vector&,std::vector&); }; -nasal_bytecode_vm::nasal_bytecode_vm() +nasal_vm::nasal_vm() { - value_stack=new nasal_scalar*[VALUE_STACK_MAX_DEPTH]; - value_stack_top=value_stack; + val_stack=new nasal_val*[val_stack_MAX_DEPTH]; + val_stack_top=val_stack; local_scope_stack.push(NULL); for(int i=0;builtin_func_table[i].func_pointer;++i) builtin_func_hashmap[builtin_func_table[i].func_name]=builtin_func_table[i].func_pointer; return; } -nasal_bytecode_vm::~nasal_bytecode_vm() +nasal_vm::~nasal_vm() { - delete []value_stack; + delete []val_stack; return; } -void nasal_bytecode_vm::clear() +void nasal_vm::clear() { vm.clear(); global_scope_addr=NULL; - value_stack_top=value_stack; - while(!pointer_stack.empty())pointer_stack.pop(); + val_stack_top=val_stack; + while(!ptr_stack.empty())ptr_stack.pop(); while(!local_scope_stack.empty())local_scope_stack.pop(); local_scope_stack.push(NULL); while(!slice_stack.empty())slice_stack.pop(); @@ -128,18 +128,18 @@ void nasal_bytecode_vm::clear() exec_code.clear(); return; } -void nasal_bytecode_vm::die(std::string str) +void nasal_vm::die(std::string str) { printf(">> [vm] 0x%.8x: %s\n",ptr,str.data()); main_loop_break_mark=false; return; } -bool nasal_bytecode_vm::check_condition(nasal_scalar* value_addr) +bool nasal_vm::check_condition(nasal_val* value_addr) { int type=value_addr->get_type(); - if(type==vm_number) + if(type==vm_num) return (value_addr->get_number()!=0); - else if(type==vm_string) + else if(type==vm_str) { std::string str=value_addr->get_string(); double number=trans_string_to_number(str); @@ -149,376 +149,376 @@ bool nasal_bytecode_vm::check_condition(nasal_scalar* value_addr) } return false; } -void nasal_bytecode_vm::opr_nop() +void nasal_vm::opr_nop() { // nop is the end of this program main_loop_break_mark=false; return; } -void nasal_bytecode_vm::opr_load() +void nasal_vm::opr_load() { - nasal_scalar* val_addr=*value_stack_top--; - nasal_scalar* local_scope_top=local_scope_stack.top(); + nasal_val* val_addr=*val_stack_top--; + nasal_val* local_scope_top=local_scope_stack.top(); (local_scope_top?local_scope_top:global_scope_addr)->get_closure().add_new_value(exec_code[ptr].index,val_addr); return; } -void nasal_bytecode_vm::opr_pushnum() +void nasal_vm::opr_pushnum() { - nasal_scalar* val_addr=vm.gc_alloc(vm_number); + nasal_val* val_addr=vm.gc_alloc(vm_num); val_addr->set_number(number_table[exec_code[ptr].index]); - *(++value_stack_top)=val_addr; + *(++val_stack_top)=val_addr; return; } -void nasal_bytecode_vm::opr_pushone() +void nasal_vm::opr_pushone() { - nasal_scalar* val_addr=vm.gc_alloc(vm_number); + nasal_val* val_addr=vm.gc_alloc(vm_num); val_addr->set_number(1); - *(++value_stack_top)=val_addr; + *(++val_stack_top)=val_addr; return; } -void nasal_bytecode_vm::opr_pushzero() +void nasal_vm::opr_pushzero() { - nasal_scalar* val_addr=vm.gc_alloc(vm_number); + nasal_val* val_addr=vm.gc_alloc(vm_num); val_addr->set_number(0); - *(++value_stack_top)=val_addr; + *(++val_stack_top)=val_addr; return; } -void nasal_bytecode_vm::opr_pushnil() +void nasal_vm::opr_pushnil() { - *(++value_stack_top)=vm.gc_alloc(vm_nil); + *(++val_stack_top)=vm.gc_alloc(vm_nil); return; } -void nasal_bytecode_vm::opr_pushstr() +void nasal_vm::opr_pushstr() { - nasal_scalar* val_addr=vm.gc_alloc(vm_string); + nasal_val* val_addr=vm.gc_alloc(vm_str); val_addr->set_string(string_table[exec_code[ptr].index]); - *(++value_stack_top)=val_addr; + *(++val_stack_top)=val_addr; return; } -void nasal_bytecode_vm::opr_newvec() +void nasal_vm::opr_newvec() { - *(++value_stack_top)=vm.gc_alloc(vm_vector); + *(++val_stack_top)=vm.gc_alloc(vm_vec); return; } -void nasal_bytecode_vm::opr_newhash() +void nasal_vm::opr_newhash() { - *(++value_stack_top)=vm.gc_alloc(vm_hash); + *(++val_stack_top)=vm.gc_alloc(vm_hash); return; } -void nasal_bytecode_vm::opr_newfunc() +void nasal_vm::opr_newfunc() { - nasal_scalar* val_addr=vm.gc_alloc(vm_function); - nasal_scalar* local_scope_top=local_scope_stack.top(); + nasal_val* val_addr=vm.gc_alloc(vm_func); + nasal_val* local_scope_top=local_scope_stack.top(); if(local_scope_top) val_addr->get_func().set_closure_addr(local_scope_top); else val_addr->get_func().set_new_closure(); - *(++value_stack_top)=val_addr; + *(++val_stack_top)=val_addr; return; } -void nasal_bytecode_vm::opr_vecapp() +void nasal_vm::opr_vecapp() { - nasal_scalar* val_addr=*value_stack_top--; - (*value_stack_top)->get_vector().add_elem(val_addr); + nasal_val* val_addr=*val_stack_top--; + (*val_stack_top)->get_vector().add_elem(val_addr); return; } -void nasal_bytecode_vm::opr_hashapp() +void nasal_vm::opr_hashapp() { - nasal_scalar* val_addr=*value_stack_top--; - (*value_stack_top)->get_hash().add_elem(string_table[exec_code[ptr].index],val_addr); + nasal_val* val_addr=*val_stack_top--; + (*val_stack_top)->get_hash().add_elem(string_table[exec_code[ptr].index],val_addr); return; } -void nasal_bytecode_vm::opr_para() +void nasal_vm::opr_para() { - (*value_stack_top)->get_func().add_para(exec_code[ptr].index); + (*val_stack_top)->get_func().add_para(exec_code[ptr].index); return; } -void nasal_bytecode_vm::opr_defpara() +void nasal_vm::opr_defpara() { - nasal_scalar* val_addr=*value_stack_top--; - (*value_stack_top)->get_func().add_para(exec_code[ptr].index,val_addr); + nasal_val* val_addr=*val_stack_top--; + (*val_stack_top)->get_func().add_para(exec_code[ptr].index,val_addr); return; } -void nasal_bytecode_vm::opr_dynpara() +void nasal_vm::opr_dynpara() { - (*value_stack_top)->get_func().add_para(exec_code[ptr].index,NULL,true); + (*val_stack_top)->get_func().add_para(exec_code[ptr].index,NULL,true); return; } -void nasal_bytecode_vm::opr_entry() +void nasal_vm::opr_entry() { - (*value_stack_top)->get_func().set_entry(exec_code[ptr].index); + (*val_stack_top)->get_func().set_entry(exec_code[ptr].index); return; } -void nasal_bytecode_vm::opr_unot() +void nasal_vm::opr_unot() { - nasal_scalar* val_addr=*value_stack_top; + nasal_val* val_addr=*val_stack_top; int type=val_addr->get_type(); - nasal_scalar* new_value_address=NULL; + nasal_val* new_value_address=NULL; if(type==vm_nil) { - new_value_address=vm.gc_alloc(vm_number); + new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number(1); } - else if(type==vm_number) + else if(type==vm_num) { - new_value_address=vm.gc_alloc(vm_number); + new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number(val_addr->get_number()==0); } - else if(type==vm_string) + else if(type==vm_str) { double number=trans_string_to_number(val_addr->get_string()); if(std::isnan(number)) { - new_value_address=vm.gc_alloc(vm_number); + new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number(!val_addr->get_string().length()); } else { - new_value_address=vm.gc_alloc(vm_number); + new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number(number==0); } } else die("unot: incorrect value type"); - *value_stack_top=new_value_address; + *val_stack_top=new_value_address; vm.del_reference(val_addr); return; } -void nasal_bytecode_vm::opr_usub() +void nasal_vm::opr_usub() { - nasal_scalar* val_addr=*value_stack_top; - nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + nasal_val* val_addr=*val_stack_top; + nasal_val* new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number(-val_addr->to_number()); - *value_stack_top=new_value_address; + *val_stack_top=new_value_address; vm.del_reference(val_addr); return; } -void nasal_bytecode_vm::opr_add() +void nasal_vm::opr_add() { - nasal_scalar* val_addr2=*value_stack_top--; - nasal_scalar* val_addr1=*value_stack_top; - nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + nasal_val* val_addr2=*val_stack_top--; + nasal_val* val_addr1=*val_stack_top; + nasal_val* new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number(val_addr1->to_number()+val_addr2->to_number()); - *value_stack_top=new_value_address; + *val_stack_top=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); return; } -void nasal_bytecode_vm::opr_sub() +void nasal_vm::opr_sub() { - nasal_scalar* val_addr2=*value_stack_top--; - nasal_scalar* val_addr1=*value_stack_top; - nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + nasal_val* val_addr2=*val_stack_top--; + nasal_val* val_addr1=*val_stack_top; + nasal_val* new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number(val_addr1->to_number()-val_addr2->to_number()); - *value_stack_top=new_value_address; + *val_stack_top=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); return; } -void nasal_bytecode_vm::opr_mul() +void nasal_vm::opr_mul() { - nasal_scalar* val_addr2=*value_stack_top--; - nasal_scalar* val_addr1=*value_stack_top; - nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + nasal_val* val_addr2=*val_stack_top--; + nasal_val* val_addr1=*val_stack_top; + nasal_val* new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number(val_addr1->to_number()*val_addr2->to_number()); - *value_stack_top=new_value_address; + *val_stack_top=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); return; } -void nasal_bytecode_vm::opr_div() +void nasal_vm::opr_div() { - nasal_scalar* val_addr2=*value_stack_top--; - nasal_scalar* val_addr1=*value_stack_top; - nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + nasal_val* val_addr2=*val_stack_top--; + nasal_val* val_addr1=*val_stack_top; + nasal_val* new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number(val_addr1->to_number()/val_addr2->to_number()); - *value_stack_top=new_value_address; + *val_stack_top=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); return; } -void nasal_bytecode_vm::opr_lnk() +void nasal_vm::opr_lnk() { - nasal_scalar* val_addr2=*value_stack_top--; - nasal_scalar* val_addr1=*value_stack_top; - nasal_scalar* new_value_address=vm.gc_alloc(vm_string); + nasal_val* val_addr2=*val_stack_top--; + nasal_val* val_addr1=*val_stack_top; + nasal_val* new_value_address=vm.gc_alloc(vm_str); new_value_address->set_string(val_addr1->to_string()+val_addr2->to_string()); - *value_stack_top=new_value_address; + *val_stack_top=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); return; } -void nasal_bytecode_vm::opr_addeq() +void nasal_vm::opr_addeq() { - nasal_scalar** mem_addr=pointer_stack.top(); - pointer_stack.pop(); - nasal_scalar* val_addr2=*value_stack_top; - nasal_scalar* val_addr1=*mem_addr; - nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + nasal_val** mem_addr=ptr_stack.top(); + ptr_stack.pop(); + nasal_val* val_addr2=*val_stack_top; + nasal_val* val_addr1=*mem_addr; + nasal_val* new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number(val_addr1->to_number()+val_addr2->to_number()); vm.add_reference(new_value_address); - *value_stack_top=new_value_address; + *val_stack_top=new_value_address; vm.del_reference(*mem_addr); *mem_addr=new_value_address; vm.del_reference(val_addr2); return; } -void nasal_bytecode_vm::opr_subeq() +void nasal_vm::opr_subeq() { - nasal_scalar** mem_addr=pointer_stack.top(); - pointer_stack.pop(); - nasal_scalar* val_addr2=*value_stack_top; - nasal_scalar* val_addr1=*mem_addr; - nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + nasal_val** mem_addr=ptr_stack.top(); + ptr_stack.pop(); + nasal_val* val_addr2=*val_stack_top; + nasal_val* val_addr1=*mem_addr; + nasal_val* new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number(val_addr1->to_number()-val_addr2->to_number()); vm.add_reference(new_value_address); - *value_stack_top=new_value_address; + *val_stack_top=new_value_address; vm.del_reference(*mem_addr); *mem_addr=new_value_address; vm.del_reference(val_addr2); return; } -void nasal_bytecode_vm::opr_muleq() +void nasal_vm::opr_muleq() { - nasal_scalar** mem_addr=pointer_stack.top(); - pointer_stack.pop(); - nasal_scalar* val_addr2=*value_stack_top; - nasal_scalar* val_addr1=*mem_addr; - nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + nasal_val** mem_addr=ptr_stack.top(); + ptr_stack.pop(); + nasal_val* val_addr2=*val_stack_top; + nasal_val* val_addr1=*mem_addr; + nasal_val* new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number(val_addr1->to_number()*val_addr2->to_number()); vm.add_reference(new_value_address); - *value_stack_top=new_value_address; + *val_stack_top=new_value_address; vm.del_reference(*mem_addr); *mem_addr=new_value_address; vm.del_reference(val_addr2); return; } -void nasal_bytecode_vm::opr_diveq() +void nasal_vm::opr_diveq() { - nasal_scalar** mem_addr=pointer_stack.top(); - pointer_stack.pop(); - nasal_scalar* val_addr2=*value_stack_top; - nasal_scalar* val_addr1=*mem_addr; - nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + nasal_val** mem_addr=ptr_stack.top(); + ptr_stack.pop(); + nasal_val* val_addr2=*val_stack_top; + nasal_val* val_addr1=*mem_addr; + nasal_val* new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number(val_addr1->to_number()/val_addr2->to_number()); vm.add_reference(new_value_address); - *value_stack_top=new_value_address; + *val_stack_top=new_value_address; vm.del_reference(*mem_addr); *mem_addr=new_value_address; vm.del_reference(val_addr2); return; } -void nasal_bytecode_vm::opr_lnkeq() +void nasal_vm::opr_lnkeq() { - nasal_scalar** mem_addr=pointer_stack.top(); - pointer_stack.pop(); - nasal_scalar* val_addr2=*value_stack_top; - nasal_scalar* val_addr1=*mem_addr; - nasal_scalar* new_value_address=vm.gc_alloc(vm_string); + nasal_val** mem_addr=ptr_stack.top(); + ptr_stack.pop(); + nasal_val* val_addr2=*val_stack_top; + nasal_val* val_addr1=*mem_addr; + nasal_val* new_value_address=vm.gc_alloc(vm_str); new_value_address->set_string(val_addr1->to_string()+val_addr2->to_string()); vm.add_reference(new_value_address); - *value_stack_top=new_value_address; + *val_stack_top=new_value_address; vm.del_reference(*mem_addr); *mem_addr=new_value_address; vm.del_reference(val_addr2); return; } -void nasal_bytecode_vm::opr_meq() +void nasal_vm::opr_meq() { - nasal_scalar** mem_addr=pointer_stack.top(); - pointer_stack.pop(); - nasal_scalar* val_addr=*value_stack_top; + nasal_val** mem_addr=ptr_stack.top(); + ptr_stack.pop(); + nasal_val* val_addr=*val_stack_top; vm.add_reference(val_addr); vm.del_reference(*mem_addr); *mem_addr=val_addr; return; } -void nasal_bytecode_vm::opr_eq() +void nasal_vm::opr_eq() { - nasal_scalar* val_addr2=*value_stack_top--; - nasal_scalar* val_addr1=*value_stack_top--; + nasal_val* val_addr2=*val_stack_top--; + nasal_val* val_addr1=*val_stack_top--; int a_ref_type=val_addr1->get_type(); int b_ref_type=val_addr2->get_type(); if(a_ref_type==vm_nil && b_ref_type==vm_nil) { - nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + nasal_val* new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number(1); - *(++value_stack_top)=new_value_address; + *(++val_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); return; } - else if((a_ref_type==vm_number || a_ref_type==vm_string) && (b_ref_type==vm_number || b_ref_type==vm_string)) + else if((a_ref_type==vm_num || a_ref_type==vm_str) && (b_ref_type==vm_num || b_ref_type==vm_str)) { - if(a_ref_type==vm_string && b_ref_type==vm_string) + if(a_ref_type==vm_str && b_ref_type==vm_str) { std::string astr=val_addr1->get_string(); std::string bstr=val_addr2->get_string(); - nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + nasal_val* new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number((double)(astr==bstr)); - *(++value_stack_top)=new_value_address; + *(++val_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); return; } - nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + nasal_val* new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number((double)(val_addr1->to_number()==val_addr2->to_number())); - *(++value_stack_top)=new_value_address; + *(++val_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); return; } else { - nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + nasal_val* new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number(val_addr1==val_addr2); - *(++value_stack_top)=new_value_address; + *(++val_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); return; } return; } -void nasal_bytecode_vm::opr_neq() +void nasal_vm::opr_neq() { - nasal_scalar* val_addr2=*value_stack_top--; - nasal_scalar* val_addr1=*value_stack_top--; + nasal_val* val_addr2=*val_stack_top--; + nasal_val* val_addr1=*val_stack_top--; int a_ref_type=val_addr1->get_type(); int b_ref_type=val_addr2->get_type(); if(a_ref_type==vm_nil && b_ref_type==vm_nil) { - nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + nasal_val* new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number(0); - *(++value_stack_top)=new_value_address; + *(++val_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); return; } - else if((a_ref_type==vm_number || a_ref_type==vm_string) && (b_ref_type==vm_number || b_ref_type==vm_string)) + else if((a_ref_type==vm_num || a_ref_type==vm_str) && (b_ref_type==vm_num || b_ref_type==vm_str)) { - if(a_ref_type==vm_string && b_ref_type==vm_string) + if(a_ref_type==vm_str && b_ref_type==vm_str) { std::string astr=val_addr1->get_string(); std::string bstr=val_addr2->get_string(); - nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + nasal_val* new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number((double)(astr!=bstr)); - *(++value_stack_top)=new_value_address; + *(++val_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); return; } - nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + nasal_val* new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number((double)(val_addr1->to_number()!=val_addr2->to_number())); - *(++value_stack_top)=new_value_address; + *(++val_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); return; } else { - nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + nasal_val* new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number(val_addr1!=val_addr2); - *(++value_stack_top)=new_value_address; + *(++val_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); return; @@ -527,128 +527,128 @@ void nasal_bytecode_vm::opr_neq() vm.del_reference(val_addr2); return; } -void nasal_bytecode_vm::opr_less() +void nasal_vm::opr_less() { - nasal_scalar* val_addr2=*value_stack_top--; - nasal_scalar* val_addr1=*value_stack_top--; + nasal_val* val_addr2=*val_stack_top--; + nasal_val* val_addr1=*val_stack_top--; int a_ref_type=val_addr1->get_type(); int b_ref_type=val_addr2->get_type(); - if(a_ref_type==vm_string && b_ref_type==vm_string) + if(a_ref_type==vm_str && b_ref_type==vm_str) { std::string a_str=val_addr1->get_string(); std::string b_str=val_addr2->get_string(); - nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + nasal_val* new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number(a_strset_number(val_addr1->to_number()to_number()); - *(++value_stack_top)=new_value_address; + *(++val_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); return; } -void nasal_bytecode_vm::opr_leq() +void nasal_vm::opr_leq() { - nasal_scalar* val_addr2=*value_stack_top--; - nasal_scalar* val_addr1=*value_stack_top--; + nasal_val* val_addr2=*val_stack_top--; + nasal_val* val_addr1=*val_stack_top--; int a_ref_type=val_addr1->get_type(); int b_ref_type=val_addr2->get_type(); - if(a_ref_type==vm_string && b_ref_type==vm_string) + if(a_ref_type==vm_str && b_ref_type==vm_str) { std::string a_str=val_addr1->get_string(); std::string b_str=val_addr2->get_string(); - nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + nasal_val* new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number(a_str<=b_str); - *(++value_stack_top)=new_value_address; + *(++val_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); return; } - nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + nasal_val* new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number(val_addr1->to_number()<=val_addr2->to_number()); - *(++value_stack_top)=new_value_address; + *(++val_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); return; } -void nasal_bytecode_vm::opr_grt() +void nasal_vm::opr_grt() { - nasal_scalar* val_addr2=*value_stack_top--; - nasal_scalar* val_addr1=*value_stack_top--; + nasal_val* val_addr2=*val_stack_top--; + nasal_val* val_addr1=*val_stack_top--; int a_ref_type=val_addr1->get_type(); int b_ref_type=val_addr2->get_type(); - if(a_ref_type==vm_string && b_ref_type==vm_string) + if(a_ref_type==vm_str && b_ref_type==vm_str) { std::string a_str=val_addr1->get_string(); std::string b_str=val_addr2->get_string(); - nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + nasal_val* new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number(a_str>b_str); - *(++value_stack_top)=new_value_address; + *(++val_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); return; } - nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + nasal_val* new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number(val_addr1->to_number()>val_addr2->to_number()); - *(++value_stack_top)=new_value_address; + *(++val_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); return; } -void nasal_bytecode_vm::opr_geq() +void nasal_vm::opr_geq() { - nasal_scalar* val_addr2=*value_stack_top--; - nasal_scalar* val_addr1=*value_stack_top--; + nasal_val* val_addr2=*val_stack_top--; + nasal_val* val_addr1=*val_stack_top--; int a_ref_type=val_addr1->get_type(); int b_ref_type=val_addr2->get_type(); - if(a_ref_type==vm_string && b_ref_type==vm_string) + if(a_ref_type==vm_str && b_ref_type==vm_str) { std::string a_str=val_addr1->get_string(); std::string b_str=val_addr2->get_string(); - nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + nasal_val* new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number(a_str>=b_str); - *(++value_stack_top)=new_value_address; + *(++val_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); return; } - nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + nasal_val* new_value_address=vm.gc_alloc(vm_num); new_value_address->set_number(val_addr1->to_number()>=val_addr2->to_number()); - *(++value_stack_top)=new_value_address; + *(++val_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); return; } -void nasal_bytecode_vm::opr_pop() +void nasal_vm::opr_pop() { - vm.del_reference(*value_stack_top--); + vm.del_reference(*val_stack_top--); return; } -void nasal_bytecode_vm::opr_jmp() +void nasal_vm::opr_jmp() { ptr=exec_code[ptr].index-1; return; } -void nasal_bytecode_vm::opr_jmptrue() +void nasal_vm::opr_jmptrue() { - if(check_condition(*value_stack_top)) + if(check_condition(*val_stack_top)) ptr=exec_code[ptr].index-1; return; } -void nasal_bytecode_vm::opr_jmpfalse() +void nasal_vm::opr_jmpfalse() { - if(!check_condition(*value_stack_top)) + if(!check_condition(*val_stack_top)) ptr=exec_code[ptr].index-1; - vm.del_reference(*value_stack_top--); + vm.del_reference(*val_stack_top--); return; } -void nasal_bytecode_vm::opr_counter() +void nasal_vm::opr_counter() { - if((*value_stack_top)->get_type()!=vm_vector) + if((*val_stack_top)->get_type()!=vm_vec) { die("cnt: must use vector in forindex/foreach"); return; @@ -656,50 +656,50 @@ void nasal_bytecode_vm::opr_counter() counter_stack.push(-1); return; } -void nasal_bytecode_vm::opr_cntpop() +void nasal_vm::opr_cntpop() { counter_stack.pop(); return; } -void nasal_bytecode_vm::opr_forindex() +void nasal_vm::opr_forindex() { - nasal_vector& ref=(*value_stack_top)->get_vector(); + nasal_vec& ref=(*val_stack_top)->get_vector(); ++counter_stack.top(); if(counter_stack.top()>=ref.size()) { ptr=exec_code[ptr].index-1; return; } - nasal_scalar* res=vm.gc_alloc(vm_number); + nasal_val* res=vm.gc_alloc(vm_num); res->set_number((double)counter_stack.top()); - *(++value_stack_top)=res; + *(++val_stack_top)=res; return; } -void nasal_bytecode_vm::opr_foreach() +void nasal_vm::opr_foreach() { - nasal_vector& ref=(*value_stack_top)->get_vector(); + nasal_vec& ref=(*val_stack_top)->get_vector(); ++counter_stack.top(); if(counter_stack.top()>=ref.size()) { ptr=exec_code[ptr].index-1; return; } - nasal_scalar* res=ref[counter_stack.top()]; + nasal_val* res=ref[counter_stack.top()]; vm.add_reference(res); - *(++value_stack_top)=res; + *(++val_stack_top)=res; return; } -void nasal_bytecode_vm::opr_call() +void nasal_vm::opr_call() { - nasal_scalar* val_addr=NULL; + nasal_val* val_addr=NULL; int name_index=exec_code[ptr].index; - nasal_scalar* local_scope_top=local_scope_stack.top(); + nasal_val* local_scope_top=local_scope_stack.top(); if(local_scope_top) val_addr=local_scope_top->get_closure().get_value_address(name_index); if(val_addr) { vm.add_reference(val_addr); - *(++value_stack_top)=val_addr; + *(++val_stack_top)=val_addr; return; } else @@ -707,25 +707,25 @@ void nasal_bytecode_vm::opr_call() if(val_addr) { vm.add_reference(val_addr); - *(++value_stack_top)=val_addr; + *(++val_stack_top)=val_addr; return; } die("call: cannot find symbol named \""+string_table[name_index]+"\""); return; } -void nasal_bytecode_vm::opr_callv() +void nasal_vm::opr_callv() { - nasal_scalar* val_addr=*value_stack_top--; - nasal_scalar* vec_addr=*value_stack_top--; + nasal_val* val_addr=*val_stack_top--; + nasal_val* vec_addr=*val_stack_top--; int type=vec_addr->get_type(); - if(type==vm_vector) + if(type==vm_vec) { int num=val_addr->to_number(); - nasal_scalar* res=vec_addr->get_vector().get_value_address(num); + nasal_val* res=vec_addr->get_vector().get_value_address(num); if(res) { vm.add_reference(res); - *(++value_stack_top)=res; + *(++val_stack_top)=res; } else { @@ -735,26 +735,26 @@ void nasal_bytecode_vm::opr_callv() } else if(type==vm_hash) { - if(val_addr->get_type()!=vm_string) + if(val_addr->get_type()!=vm_str) { die("callv: must use string as the key"); return; } - nasal_scalar* res=vec_addr->get_hash().get_value_address(val_addr->get_string()); + nasal_val* res=vec_addr->get_hash().get_value_address(val_addr->get_string()); if(!res) { die("callv: cannot find member \""+val_addr->get_string()+"\" of this hash"); return; } - if(res->get_type()==vm_function) + if(res->get_type()==vm_func) { (res->get_func().get_closure_addr())->get_closure().add_new_value(me_index,val_addr); vm.add_reference(val_addr); } vm.add_reference(res); - *(++value_stack_top)=res; + *(++val_stack_top)=res; } - else if(type==vm_string) + else if(type==vm_str) { std::string str=vec_addr->get_string(); int num=val_addr->to_number(); @@ -764,9 +764,9 @@ void nasal_bytecode_vm::opr_callv() die("callv: index out of range"); return; } - nasal_scalar* res=vm.gc_alloc(vm_number); + nasal_val* res=vm.gc_alloc(vm_num); res->set_number((double)str[num>=0? num:num+str_size]); - *(++value_stack_top)=res; + *(++val_stack_top)=res; } else die("callv: must call a vector/hash/string"); @@ -774,34 +774,34 @@ void nasal_bytecode_vm::opr_callv() vm.del_reference(vec_addr); return; } -void nasal_bytecode_vm::opr_callvi() +void nasal_vm::opr_callvi() { - nasal_scalar* val_addr=*value_stack_top; - if(val_addr->get_type()!=vm_vector) + nasal_val* val_addr=*val_stack_top; + if(val_addr->get_type()!=vm_vec) { die("callvi: multi-definition/multi-assignment must use a vector"); return; } // cannot use operator[],because this may cause overflow - nasal_scalar* res=val_addr->get_vector().get_value_address(exec_code[ptr].index); + nasal_val* res=val_addr->get_vector().get_value_address(exec_code[ptr].index); if(!res) { die("callvi: index out of range"); return; } vm.add_reference(res); - *(++value_stack_top)=res; + *(++val_stack_top)=res; return; } -void nasal_bytecode_vm::opr_callh() +void nasal_vm::opr_callh() { - nasal_scalar* val_addr=*value_stack_top--; + nasal_val* val_addr=*val_stack_top--; if(val_addr->get_type()!=vm_hash) { die("callh: must call a hash"); return; } - nasal_scalar* res=val_addr->get_hash().get_value_address(string_table[exec_code[ptr].index]); + nasal_val* res=val_addr->get_hash().get_value_address(string_table[exec_code[ptr].index]); if(res) vm.add_reference(res); else @@ -809,33 +809,33 @@ void nasal_bytecode_vm::opr_callh() die("callh: hash member \""+string_table[exec_code[ptr].index]+"\" does not exist"); return; } - if(res->get_type()==vm_function) + if(res->get_type()==vm_func) (res->get_func().get_closure_addr())->get_closure().add_new_value(me_index,val_addr); else vm.del_reference(val_addr); - *(++value_stack_top)=res; + *(++val_stack_top)=res; return; } -void nasal_bytecode_vm::opr_callf() +void nasal_vm::opr_callf() { - nasal_scalar* para_addr=*value_stack_top--; - nasal_scalar* func_addr=*value_stack_top; - if(func_addr->get_type()!=vm_function) + nasal_val* para_addr=*val_stack_top--; + nasal_val* func_addr=*val_stack_top; + if(func_addr->get_type()!=vm_func) { die("callf: called a value that is not a function"); return; } - nasal_function& ref=func_addr->get_func(); - nasal_scalar* closure=ref.get_closure_addr(); - nasal_closure& ref_closure=closure->get_closure(); + nasal_func& ref=func_addr->get_func(); + nasal_val* closure=ref.get_closure_addr(); + nasal_scop& ref_closure=closure->get_closure(); ref_closure.add_scope(); local_scope_stack.push(closure); vm.add_reference(closure); - if(para_addr->get_type()==vm_vector) + if(para_addr->get_type()==vm_vec) { - nasal_vector& ref_vec=para_addr->get_vector(); + nasal_vec& ref_vec=para_addr->get_vector(); std::vector& ref_para=ref.get_para(); - std::vector& ref_default=ref.get_default(); + std::vector& ref_default=ref.get_default(); int i=0; for(;i=0) { - nasal_scalar* vec_addr=vm.gc_alloc(vm_vector); + nasal_val* vec_addr=vm.gc_alloc(vm_vec); for(;iget_vector().add_elem(tmp); vm.add_reference(tmp); } @@ -872,7 +872,7 @@ void nasal_bytecode_vm::opr_callf() { nasal_hash& ref_hash=para_addr->get_hash(); std::vector& ref_para=ref.get_para(); - std::vector& ref_default=ref.get_default(); + std::vector& ref_default=ref.get_default(); if(ref.get_dynamic_para()>=0) { die("callf: special call cannot use dynamic parameter"); @@ -880,7 +880,7 @@ void nasal_bytecode_vm::opr_callf() } for(int i=0;iget_type()==vm_vector) + slice_stack.push(vm.gc_alloc(vm_vec)); + if((*val_stack_top)->get_type()==vm_vec) return; die("slcbegin: must slice a vector"); return; } -void nasal_bytecode_vm::opr_sliceend() +void nasal_vm::opr_sliceend() { - vm.del_reference(*value_stack_top); - *value_stack_top=slice_stack.top(); + vm.del_reference(*val_stack_top); + *val_stack_top=slice_stack.top(); slice_stack.pop(); return; } -void nasal_bytecode_vm::opr_slice() +void nasal_vm::opr_slice() { - nasal_scalar* val_addr=*value_stack_top--; + nasal_val* val_addr=*val_stack_top--; int type=val_addr->get_type(); double num; switch(type) { - case vm_number:num=val_addr->get_number();break; - case vm_string:num=trans_string_to_number(val_addr->get_string());break; + case vm_num:num=val_addr->get_number();break; + case vm_str:num=trans_string_to_number(val_addr->get_string());break; default:die("slc: error value type");break; } - nasal_scalar* res=(*value_stack_top)->get_vector().get_value_address((int)num); + nasal_val* res=(*val_stack_top)->get_vector().get_value_address((int)num); if(res) { vm.add_reference(res); @@ -943,20 +943,20 @@ void nasal_bytecode_vm::opr_slice() die("slc: index out of range"); return; } -void nasal_bytecode_vm::opr_slice2() +void nasal_vm::opr_slice2() { - nasal_scalar* val_addr2=*value_stack_top--; - nasal_scalar* val_addr1=*value_stack_top--; - nasal_vector& ref=(*value_stack_top)->get_vector(); - nasal_vector& aim=(slice_stack.top())->get_vector(); + nasal_val* val_addr2=*val_stack_top--; + nasal_val* val_addr1=*val_stack_top--; + nasal_vec& ref=(*val_stack_top)->get_vector(); + nasal_vec& aim=(slice_stack.top())->get_vector(); int type1=val_addr1->get_type(); int num1; switch(type1) { case vm_nil:break; - case vm_number:num1=(int)val_addr1->get_number();break; - case vm_string:num1=(int)trans_string_to_number(val_addr1->get_string());break; + case vm_num:num1=(int)val_addr1->get_number();break; + case vm_str:num1=(int)trans_string_to_number(val_addr1->get_string());break; default:die("slc2: error value type");break; } int type2=val_addr2->get_type(); @@ -964,8 +964,8 @@ void nasal_bytecode_vm::opr_slice2() switch(type2) { case vm_nil:break; - case vm_number:num2=(int)val_addr2->get_number();break; - case vm_string:num2=(int)trans_string_to_number(val_addr2->get_string());break; + case vm_num:num2=(int)val_addr2->get_number();break; + case vm_str:num2=(int)trans_string_to_number(val_addr2->get_string());break; default:die("slc2: error value type");break; } int ref_size=ref.size(); @@ -990,7 +990,7 @@ void nasal_bytecode_vm::opr_slice2() } for(int i=num1;i<=num2;++i) { - nasal_scalar* tmp=ref.get_value_address(i); + nasal_val* tmp=ref.get_value_address(i); vm.add_reference(tmp); aim.add_elem(tmp); } @@ -998,67 +998,67 @@ void nasal_bytecode_vm::opr_slice2() vm.del_reference(val_addr2); return; } -void nasal_bytecode_vm::opr_mcall() +void nasal_vm::opr_mcall() { - nasal_scalar** mem_addr=NULL; + nasal_val** mem_addr=NULL; int name_index=exec_code[ptr].index; - nasal_scalar* local_scope_top=local_scope_stack.top(); + nasal_val* local_scope_top=local_scope_stack.top(); if(local_scope_top) mem_addr=local_scope_top->get_closure().get_mem_address(name_index); if(mem_addr) { - pointer_stack.push(mem_addr); + ptr_stack.push(mem_addr); return; } else mem_addr=global_scope_addr->get_closure().get_mem_address(name_index); if(mem_addr) { - pointer_stack.push(mem_addr); + ptr_stack.push(mem_addr); return; } die("mcall: cannot find symbol named \""+string_table[name_index]+"\""); return; } -void nasal_bytecode_vm::opr_mcallv() +void nasal_vm::opr_mcallv() { - nasal_scalar* val_addr=*value_stack_top--; - nasal_scalar** vec_addr=pointer_stack.top(); - pointer_stack.pop(); + nasal_val* val_addr=*val_stack_top--; + nasal_val** vec_addr=ptr_stack.top(); + ptr_stack.pop(); int type=(*vec_addr)->get_type(); - if(type==vm_vector) + if(type==vm_vec) { int num; switch(val_addr->get_type()) { - case vm_number:num=(int)val_addr->get_number();break; - case vm_string:num=(int)trans_string_to_number(val_addr->get_string());break; + case vm_num:num=(int)val_addr->get_number();break; + case vm_str:num=(int)trans_string_to_number(val_addr->get_string());break; default:die("mcallv: error value type");break; } - nasal_scalar** res=(*vec_addr)->get_vector().get_mem_address(num); + nasal_val** res=(*vec_addr)->get_vector().get_mem_address(num); if(!res) { die("mcallv: index out of range"); return; } - pointer_stack.push(res); + ptr_stack.push(res); } else if(type==vm_hash) { - if(val_addr->get_type()!=vm_string) + if(val_addr->get_type()!=vm_str) { die("mcallv: must use string as the key"); return; } nasal_hash& ref=(*vec_addr)->get_hash(); std::string str=val_addr->get_string(); - nasal_scalar** res=ref.get_mem_address(str); + nasal_val** res=ref.get_mem_address(str); if(!res) { ref.add_elem(str,vm.gc_alloc(vm_nil)); res=ref.get_mem_address(str); } - pointer_stack.push(res); + ptr_stack.push(res); } else { @@ -1068,11 +1068,11 @@ void nasal_bytecode_vm::opr_mcallv() vm.del_reference(val_addr); return; } -void nasal_bytecode_vm::opr_mcallh() +void nasal_vm::opr_mcallh() { - nasal_scalar** mem_addr=NULL; - nasal_scalar** hash_addr=pointer_stack.top(); - pointer_stack.pop(); + nasal_val** mem_addr=NULL; + nasal_val** hash_addr=ptr_stack.top(); + ptr_stack.pop(); if((*hash_addr)->get_type()!=vm_hash) { die("mcallh: must call a hash"); @@ -1086,24 +1086,24 @@ void nasal_bytecode_vm::opr_mcallh() ref.add_elem(str,vm.gc_alloc(vm_nil)); mem_addr=ref.get_mem_address(str); } - pointer_stack.push(mem_addr); + ptr_stack.push(mem_addr); return; } -void nasal_bytecode_vm::opr_return() +void nasal_vm::opr_return() { - nasal_scalar* closure_addr=local_scope_stack.top(); + nasal_val* closure_addr=local_scope_stack.top(); local_scope_stack.pop(); closure_addr->get_closure().del_scope(); vm.del_reference(closure_addr); ptr=call_stack.top(); call_stack.pop(); - nasal_scalar* tmp=*value_stack_top--; + nasal_val* tmp=*val_stack_top--; // delete function - vm.del_reference(*value_stack_top); - *value_stack_top=tmp; + vm.del_reference(*val_stack_top); + *val_stack_top=tmp; return; } -void nasal_bytecode_vm::run(std::vector& strs,std::vector& nums,std::vector& exec) +void nasal_vm::run(std::vector& strs,std::vector& nums,std::vector& exec) { me_index=-1; string_table=strs; @@ -1117,71 +1117,71 @@ void nasal_bytecode_vm::run(std::vector& strs,std::vector& number_table=nums; exec_code=exec; - static void (nasal_bytecode_vm::*opr_table[])()= + static void (nasal_vm::*opr_table[])()= { - &nasal_bytecode_vm::opr_nop, - &nasal_bytecode_vm::opr_load, - &nasal_bytecode_vm::opr_pushnum, - &nasal_bytecode_vm::opr_pushone, - &nasal_bytecode_vm::opr_pushzero, - &nasal_bytecode_vm::opr_pushnil, - &nasal_bytecode_vm::opr_pushstr, - &nasal_bytecode_vm::opr_newvec, - &nasal_bytecode_vm::opr_newhash, - &nasal_bytecode_vm::opr_newfunc, - &nasal_bytecode_vm::opr_vecapp, - &nasal_bytecode_vm::opr_hashapp, - &nasal_bytecode_vm::opr_para, - &nasal_bytecode_vm::opr_defpara, - &nasal_bytecode_vm::opr_dynpara, - &nasal_bytecode_vm::opr_entry, - &nasal_bytecode_vm::opr_unot, - &nasal_bytecode_vm::opr_usub, - &nasal_bytecode_vm::opr_add, - &nasal_bytecode_vm::opr_sub, - &nasal_bytecode_vm::opr_mul, - &nasal_bytecode_vm::opr_div, - &nasal_bytecode_vm::opr_lnk, - &nasal_bytecode_vm::opr_addeq, - &nasal_bytecode_vm::opr_subeq, - &nasal_bytecode_vm::opr_muleq, - &nasal_bytecode_vm::opr_diveq, - &nasal_bytecode_vm::opr_lnkeq, - &nasal_bytecode_vm::opr_meq, - &nasal_bytecode_vm::opr_eq, - &nasal_bytecode_vm::opr_neq, - &nasal_bytecode_vm::opr_less, - &nasal_bytecode_vm::opr_leq, - &nasal_bytecode_vm::opr_grt, - &nasal_bytecode_vm::opr_geq, - &nasal_bytecode_vm::opr_pop, - &nasal_bytecode_vm::opr_jmp, - &nasal_bytecode_vm::opr_jmptrue, - &nasal_bytecode_vm::opr_jmpfalse, - &nasal_bytecode_vm::opr_counter, - &nasal_bytecode_vm::opr_cntpop, - &nasal_bytecode_vm::opr_forindex, - &nasal_bytecode_vm::opr_foreach, - &nasal_bytecode_vm::opr_call, - &nasal_bytecode_vm::opr_callv, - &nasal_bytecode_vm::opr_callvi, - &nasal_bytecode_vm::opr_callh, - &nasal_bytecode_vm::opr_callf, - &nasal_bytecode_vm::opr_builtincall, - &nasal_bytecode_vm::opr_slicebegin, - &nasal_bytecode_vm::opr_sliceend, - &nasal_bytecode_vm::opr_slice, - &nasal_bytecode_vm::opr_slice2, - &nasal_bytecode_vm::opr_mcall, - &nasal_bytecode_vm::opr_mcallv, - &nasal_bytecode_vm::opr_mcallh, - &nasal_bytecode_vm::opr_return + &nasal_vm::opr_nop, + &nasal_vm::opr_load, + &nasal_vm::opr_pushnum, + &nasal_vm::opr_pushone, + &nasal_vm::opr_pushzero, + &nasal_vm::opr_pushnil, + &nasal_vm::opr_pushstr, + &nasal_vm::opr_newvec, + &nasal_vm::opr_newhash, + &nasal_vm::opr_newfunc, + &nasal_vm::opr_vecapp, + &nasal_vm::opr_hashapp, + &nasal_vm::opr_para, + &nasal_vm::opr_defpara, + &nasal_vm::opr_dynpara, + &nasal_vm::opr_entry, + &nasal_vm::opr_unot, + &nasal_vm::opr_usub, + &nasal_vm::opr_add, + &nasal_vm::opr_sub, + &nasal_vm::opr_mul, + &nasal_vm::opr_div, + &nasal_vm::opr_lnk, + &nasal_vm::opr_addeq, + &nasal_vm::opr_subeq, + &nasal_vm::opr_muleq, + &nasal_vm::opr_diveq, + &nasal_vm::opr_lnkeq, + &nasal_vm::opr_meq, + &nasal_vm::opr_eq, + &nasal_vm::opr_neq, + &nasal_vm::opr_less, + &nasal_vm::opr_leq, + &nasal_vm::opr_grt, + &nasal_vm::opr_geq, + &nasal_vm::opr_pop, + &nasal_vm::opr_jmp, + &nasal_vm::opr_jmptrue, + &nasal_vm::opr_jmpfalse, + &nasal_vm::opr_counter, + &nasal_vm::opr_cntpop, + &nasal_vm::opr_forindex, + &nasal_vm::opr_foreach, + &nasal_vm::opr_call, + &nasal_vm::opr_callv, + &nasal_vm::opr_callvi, + &nasal_vm::opr_callh, + &nasal_vm::opr_callf, + &nasal_vm::opr_builtincall, + &nasal_vm::opr_slicebegin, + &nasal_vm::opr_sliceend, + &nasal_vm::opr_slice, + &nasal_vm::opr_slice2, + &nasal_vm::opr_mcall, + &nasal_vm::opr_mcallv, + &nasal_vm::opr_mcallh, + &nasal_vm::opr_return }; main_loop_break_mark=true; builtin_die_state=false; - global_scope_addr=vm.gc_alloc(vm_closure); + global_scope_addr=vm.gc_alloc(vm_scop); clock_t begin_time=clock(); // main loop