From 4617eb8f173b29304b40a960139e0bc0195e09c2 Mon Sep 17 00:00:00 2001 From: Valk Richard Li <48872266+ValKmjolnir@users.noreply.github.com> Date: Sat, 19 Dec 2020 23:47:04 +0800 Subject: [PATCH] update --- nasal_builtin.h | 843 +++++++++++++++++++++----------------------- nasal_bytecode_vm.h | 564 +++++++++++++++-------------- nasal_gc.h | 295 ++++++++-------- nasal_lexer.h | 55 +-- nasal_parse.h | 125 +++---- 5 files changed, 886 insertions(+), 996 deletions(-) diff --git a/nasal_builtin.h b/nasal_builtin.h index 7117adc..a5ee709 100644 --- a/nasal_builtin.h +++ b/nasal_builtin.h @@ -10,59 +10,58 @@ // builtin function nasal_call_builtin_std_cout is wrapped up by print std::map builtin_use_string_table; // used to find values that builtin function uses -#define in_builtin_find(value_name_string)\ - (local_scope_addr>=0?nasal_vm.gc_get(local_scope_addr).get_closure().get_value_address(builtin_use_string_table[value_name_string]):-1) +#define in_builtin_find(value_name_string) (local_scope_addr->get_closure().get_value_address(builtin_use_string_table[value_name_string])) // used to check found value's type // types are:vm_nil vm_number vm_string vm_vector vm_hash vm_function // dynamic values will be generated as vector by the outer function -#define in_builtin_check(value_addr,value_type) (nasal_vm.gc_get(value_addr).get_type()==(value_type)) +#define in_builtin_check(value_addr,value_type) (value_addr->get_type()==(value_type)) // declaration of builtin functions // to add new builtin function,declare it here and write the definition below -int builtin_print(int,nasal_virtual_machine&); -int builtin_append(int,nasal_virtual_machine&); -int builtin_setsize(int,nasal_virtual_machine&); -int builtin_system(int,nasal_virtual_machine&); -int builtin_input(int,nasal_virtual_machine&); -int builtin_sleep(int,nasal_virtual_machine&); -int builtin_finput(int,nasal_virtual_machine&); -int builtin_foutput(int,nasal_virtual_machine&); -int builtin_split(int,nasal_virtual_machine&); -int builtin_rand(int,nasal_virtual_machine&); -int builtin_id(int,nasal_virtual_machine&); -int builtin_int(int,nasal_virtual_machine&); -int builtin_num(int,nasal_virtual_machine&); -int builtin_pop(int,nasal_virtual_machine&); -int builtin_str(int,nasal_virtual_machine&); -int builtin_size(int,nasal_virtual_machine&); -int builtin_xor(int,nasal_virtual_machine&); -int builtin_and(int,nasal_virtual_machine&); -int builtin_or(int,nasal_virtual_machine&); -int builtin_nand(int,nasal_virtual_machine&); -int builtin_not(int,nasal_virtual_machine&); -int builtin_sin(int,nasal_virtual_machine&); -int builtin_cos(int,nasal_virtual_machine&); -int builtin_tan(int,nasal_virtual_machine&); -int builtin_exp(int,nasal_virtual_machine&); -int builtin_ln(int,nasal_virtual_machine&); -int builtin_sqrt(int,nasal_virtual_machine&); -int builtin_atan2(int,nasal_virtual_machine&); -int builtin_time(int,nasal_virtual_machine&); -int builtin_contains(int,nasal_virtual_machine&); -int builtin_delete(int,nasal_virtual_machine&); -int builtin_getkeys(int,nasal_virtual_machine&); -int builtin_import(int,nasal_virtual_machine&); -bool builtin_die_state;// used in builtin_die -int builtin_die(int,nasal_virtual_machine&); -int builtin_type(int,nasal_virtual_machine&); -int builtin_substr(int,nasal_virtual_machine&); +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&); // register builtin function's name and it's address here in this table below // this table must and with {"",NULL} struct FUNC_TABLE { std::string func_name; - int (*func_pointer)(int x,nasal_virtual_machine& nasal_vm); + nasal_scalar* (*func_pointer)(nasal_scalar* x,nasal_virtual_machine& nasal_vm); } builtin_func_table[]= { {"nasal_call_builtin_std_cout", builtin_print}, @@ -104,129 +103,110 @@ struct FUNC_TABLE {"", NULL} }; -int builtin_print(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_print(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { // get arguments - int vector_value_addr=in_builtin_find("elements"); - if(vector_value_addr<0 || !in_builtin_check(vector_value_addr,vm_vector)) + nasal_scalar* vector_value_addr=in_builtin_find("elements"); + if(!in_builtin_check(vector_value_addr,vm_vector)) { - std::cout<<">> [runtime] builtin_print: \"elements\" has wrong value type(must be vector).\n"; - return -1; + std::cout<<">> [vm] builtin_print: \"elements\" has wrong value type(must be vector).\n"; + return NULL; } // main process - nasal_vector& ref_vec=nasal_vm.gc_get(vector_value_addr).get_vector(); + nasal_vector& 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; } } std::cout<<"\n"; // generate return value - int ret_addr=nasal_vm.gc_alloc(vm_nil); + nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_nil); return ret_addr; } -int builtin_append(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_append(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int vector_value_addr=in_builtin_find("vector"); - int elem_value_addr=in_builtin_find("elements"); - if(vector_value_addr<0 || !in_builtin_check(vector_value_addr,vm_vector)) + nasal_scalar* vector_value_addr=in_builtin_find("vector"); + nasal_scalar* elem_value_addr=in_builtin_find("elements"); + if(!in_builtin_check(vector_value_addr,vm_vector)) { - std::cout<<">> [runtime] builtin_append: \"vector\" has wrong value type(must be vector).\n"; - return -1; + std::cout<<">> [vm] builtin_append: \"vector\" has wrong value type(must be vector).\n"; + return NULL; } - if(elem_value_addr<0 || !in_builtin_check(elem_value_addr,vm_vector)) + if(!in_builtin_check(elem_value_addr,vm_vector)) { - std::cout<<">> [runtime] builtin_append: \"elements\" has wrong value type(must be vector).\n"; - return -1; + std::cout<<">> [vm] builtin_append: \"elements\" has wrong value type(must be vector).\n"; + return NULL; } - nasal_vector& ref_vector=nasal_vm.gc_get(vector_value_addr).get_vector(); - nasal_vector& ref_elements=nasal_vm.gc_get(elem_value_addr).get_vector(); + nasal_vector& ref_vector=vector_value_addr->get_vector(); + nasal_vector& ref_elements=elem_value_addr->get_vector(); int size=ref_elements.size(); for(int i=0;iget_type()!=vm_vector) { - std::cout<<">> [runtime] builtin_setsize: \"vector\" has wrong value type(must be vector).\n"; - return -1; + std::cout<<">> [vm] builtin_setsize: \"vector\" has wrong value type(must be vector).\n"; + return NULL; } - if(size_value_addr<0) - { - std::cout<<">> [runtime] builtin_setsize: \"size\" has wrong value type(must be string or number).\n"; - return -1; - } - int type=nasal_vm.gc_get(size_value_addr).get_type(); + int type=size_value_addr->get_type(); if(type!=vm_number && type!=vm_string) { - std::cout<<">> [runtime] builtin_setsize: size is not a number.\n"; - return -1; - } - int number; - if(type==vm_number) - number=(int)nasal_vm.gc_get(size_value_addr).get_number(); - else - { - std::string str=nasal_vm.gc_get(size_value_addr).get_string(); - double tmp=trans_string_to_number(str); - if(std::isnan(tmp)) - { - std::cout<<">> [runtime] builtin_setsize: size is not a numerable string.\n"; - return -1; - } - number=(int)tmp; + std::cout<<">> [vm] builtin_setsize: size is not a number.\n"; + return NULL; } + int number=size_value_addr->to_number(); if(number<0) { - std::cout<<">> [runtime] builtin_setsize: size must be greater than -1.\n"; - return -1; + std::cout<<">> [vm] builtin_setsize: size must be greater than NULL.\n"; + return NULL; } - nasal_vector& ref_vector=nasal_vm.gc_get(vector_value_addr).get_vector(); + nasal_vector& ref_vector=vector_value_addr->get_vector(); int vec_size=ref_vector.size(); if(number=0) - nasal_vm.del_reference(addr); + nasal_scalar* addr=ref_vector.del_elem(); + if(addr) nasal_vm.del_reference(addr); } else if(number>vec_size) for(int i=vec_size;iget_type()!=vm_string) { - std::cout<<">> [runtime] builtin_system: \"str\" has wrong value type(must be string).\n"; - return -1; + std::cout<<">> [vm] builtin_system: \"str\" has wrong value type(must be string).\n"; + return NULL; } - std::string str=nasal_vm.gc_get(str_value_addr).get_string(); + std::string str=str_value_addr->get_string(); int size=str.length(); char* command=new char[size+1]; for(int i=0;i>str; - nasal_vm.gc_get(ret_addr).set_string(str); + ret_addr->set_string(str); return ret_addr; } -int builtin_sleep(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_sleep(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int value_addr=in_builtin_find("duration"); - if(value_addr<0 || (nasal_vm.gc_get(value_addr).get_type()!=vm_string && nasal_vm.gc_get(value_addr).get_type()!=vm_number)) + nasal_scalar* value_addr=in_builtin_find("duration"); + if(value_addr->get_type()!=vm_string && value_addr->get_type()!=vm_number) { - std::cout<<">> [runtime] builtin_sleep: \"duration\" has wrong value type(must be string or number).\n"; - return -1; + std::cout<<">> [vm] builtin_sleep: \"duration\" has wrong value type(must be string or number).\n"; + return NULL; } unsigned long sleep_time=0; - if(nasal_vm.gc_get(value_addr).get_type()==vm_string) + if(value_addr->get_type()==vm_string) { - std::string str=nasal_vm.gc_get(value_addr).get_string(); + std::string str=value_addr->get_string(); double number=trans_string_to_number(str); if(std::isnan(number)) { - std::cout<<">> [runtime] builtin_sleep: this is not a numerable string.\n"; - return -1; - }sleep_time=(unsigned long)number; + std::cout<<">> [vm] builtin_sleep: this is not a numerable string.\n"; + return NULL; + } + sleep_time=(unsigned long)number; } else - sleep_time=(unsigned long)nasal_vm.gc_get(value_addr).get_number(); + sleep_time=(unsigned long)value_addr->get_number(); sleep(sleep_time); // sleep in unistd.h will make this progress sleep sleep_time seconds. - int ret_addr=nasal_vm.gc_alloc(vm_nil); + nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_nil); return ret_addr; } -int builtin_finput(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_finput(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int value_addr=in_builtin_find("filename"); - if(value_addr<0 || nasal_vm.gc_get(value_addr).get_type()!=vm_string) + nasal_scalar* value_addr=in_builtin_find("filename"); + if(value_addr->get_type()!=vm_string) { - std::cout<<">> [runtime] builtin_finput: \"filename\" has wrong value type(must be string).\n"; - return -1; + std::cout<<">> [vm] builtin_finput: \"filename\" has wrong value type(must be string).\n"; + return NULL; } - std::string filename=nasal_vm.gc_get(value_addr).get_string(); + std::string filename=value_addr->get_string(); std::ifstream fin(filename); std::string file_content=""; if(!fin.fail()) @@ -295,55 +276,55 @@ int builtin_finput(int local_scope_addr,nasal_virtual_machine& nasal_vm) else file_content=""; fin.close(); - int ret_addr=nasal_vm.gc_alloc(vm_string); - nasal_vm.gc_get(ret_addr).set_string(file_content); + nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_string); + ret_addr->set_string(file_content); return ret_addr; } -int builtin_foutput(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_foutput(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int value_addr=in_builtin_find("filename"); - int str_value_addr=in_builtin_find("str"); - if(value_addr<0 || nasal_vm.gc_get(value_addr).get_type()!=vm_string) + nasal_scalar* value_addr=in_builtin_find("filename"); + nasal_scalar* str_value_addr=in_builtin_find("str"); + if(value_addr->get_type()!=vm_string) { - std::cout<<">> [runtime] builtin_foutput: \"filename\" has wrong value type(must be string).\n"; - return -1; + std::cout<<">> [vm] builtin_foutput: \"filename\" has wrong value type(must be string).\n"; + return NULL; } - if(str_value_addr<0 || nasal_vm.gc_get(str_value_addr).get_type()!=vm_string) + if(str_value_addr<0 || str_value_addr->get_type()!=vm_string) { - std::cout<<">> [runtime] builtin_foutput: \"str\" has wrong value type(must be string).\n"; - return -1; + std::cout<<">> [vm] builtin_foutput: \"str\" has wrong value type(must be string).\n"; + return NULL; } - std::string filename=nasal_vm.gc_get(value_addr).get_string(); - std::string file_content=nasal_vm.gc_get(str_value_addr).get_string(); + std::string filename=value_addr->get_string(); + std::string file_content=str_value_addr->get_string(); std::ofstream fout(filename); fout<get_type()!=vm_string) { - std::cout<<">> [runtime] builtin_split: \"delimeter\" has wrong value type(must be string).\n"; - return -1; + std::cout<<">> [vm] builtin_split: \"delimeter\" has wrong value type(must be string).\n"; + return NULL; } - if(string_value_addr<0 || nasal_vm.gc_get(string_value_addr).get_type()!=vm_string) + if(string_value_addr->get_type()!=vm_string) { - std::cout<<">> [runtime] builtin_split: \"string\" has wrong value type(must be string).\n"; - return -1; + std::cout<<">> [vm] builtin_split: \"string\" has wrong value type(must be string).\n"; + return NULL; } - std::string delimeter=nasal_vm.gc_get(delimeter_value_addr).get_string(); - std::string source=nasal_vm.gc_get(string_value_addr).get_string(); + std::string delimeter=delimeter_value_addr->get_string(); + std::string source=string_value_addr->get_string(); int delimeter_len=delimeter.length(); int source_len=source.length(); - int ret_addr=nasal_vm.gc_alloc(vm_vector); - nasal_vector& ref_vec=nasal_vm.gc_get(ret_addr).get_vector(); + nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_vector); + nasal_vector& ref_vec=ret_addr->get_vector(); std::string tmp=""; if(!delimeter_len) @@ -351,8 +332,8 @@ int builtin_split(int local_scope_addr,nasal_virtual_machine& nasal_vm) for(int i=0;iset_string(tmp); ref_vec.add_elem(str_addr); tmp=""; } @@ -372,8 +353,8 @@ int builtin_split(int local_scope_addr,nasal_virtual_machine& nasal_vm) } if(check_delimeter) { - int str_addr=nasal_vm.gc_alloc(vm_string); - nasal_vm.gc_get(str_addr).set_string(tmp); + nasal_scalar* str_addr=nasal_vm.gc_alloc(vm_string); + str_addr->set_string(tmp); ref_vec.add_elem(str_addr); tmp=""; i+=delimeter_len-1; @@ -383,456 +364,442 @@ int builtin_split(int local_scope_addr,nasal_virtual_machine& nasal_vm) } if(tmp.length()) { - int str_addr=nasal_vm.gc_alloc(vm_string); - nasal_vm.gc_get(str_addr).set_string(tmp); + nasal_scalar* str_addr=nasal_vm.gc_alloc(vm_string); + str_addr->set_string(tmp); ref_vec.add_elem(str_addr); tmp=""; } return ret_addr; } -int builtin_rand(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_rand(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int value_addr=in_builtin_find("seed"); - if(value_addr<0 || (nasal_vm.gc_get(value_addr).get_type()!=vm_number && nasal_vm.gc_get(value_addr).get_type()!=vm_nil)) + nasal_scalar* value_addr=in_builtin_find("seed"); + if(value_addr->get_type()!=vm_number && value_addr->get_type()!=vm_nil) { - std::cout<<">> [runtime] builtin_rand: \"seed\" has wrong value type(must be nil or number).\n"; - return -1; + std::cout<<">> [vm] builtin_rand: \"seed\" has wrong value type(must be nil or number).\n"; + return NULL; } - if(nasal_vm.gc_get(value_addr).get_type()==vm_number) + if(value_addr->get_type()==vm_number) { - unsigned int number=(unsigned int)nasal_vm.gc_get(value_addr).get_number(); + unsigned int number=(unsigned int)value_addr->get_number(); srand(number); - int ret_addr=nasal_vm.gc_alloc(vm_nil); + nasal_scalar* ret_addr=nasal_vm.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)); - int ret_addr=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(ret_addr).set_number(num); + nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); + ret_addr->set_number(num); return ret_addr; } -int builtin_id(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_id(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int value_addr=in_builtin_find("thing"); - if(value_addr<0) - { - std::cout<<">> [runtime] builtin_id: cannot find \"thing\".\n"; - return -1; - } - int ret_addr=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(ret_addr).set_number((double)value_addr); + nasal_scalar* value_addr=in_builtin_find("thing"); + nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_string); + char buf[32]; + sprintf(buf,"0x%p",value_addr); + ret_addr->set_string(buf); return ret_addr; } -int builtin_int(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_int(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int value_addr=in_builtin_find("value"); - if(value_addr<0 || nasal_vm.gc_get(value_addr).get_type()!=vm_number) + nasal_scalar* value_addr=in_builtin_find("value"); + if(value_addr->get_type()!=vm_number) { - std::cout<<">> [runtime] builtin_int: \"value\" has wrong value type(must be number).\n"; - return -1; + std::cout<<">> [vm] builtin_int: \"value\" has wrong value type(must be number).\n"; + return NULL; } - int number=(int)nasal_vm.gc_get(value_addr).get_number(); - int ret_addr=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(ret_addr).set_number((double)number); + int number=(int)value_addr->get_number(); + nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); + ret_addr->set_number((double)number); return ret_addr; } -int builtin_num(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_num(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int value_addr=in_builtin_find("value"); - if(value_addr<0 || !in_builtin_check(value_addr,vm_string)) + nasal_scalar* value_addr=in_builtin_find("value"); + if(!in_builtin_check(value_addr,vm_string)) { - std::cout<<">> [runtime] builtin_num: \"value\" has wrong value type(must be string).\n"; - return -1; + std::cout<<">> [vm] builtin_num: \"value\" has wrong value type(must be string).\n"; + return NULL; } - std::string str=nasal_vm.gc_get(value_addr).get_string(); - int ret_addr=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(ret_addr).set_number(trans_string_to_number(str)); + std::string str=value_addr->get_string(); + nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); + ret_addr->set_number(trans_string_to_number(str)); return ret_addr; } -int builtin_pop(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_pop(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int value_addr=in_builtin_find("vector"); - if(value_addr<0 || nasal_vm.gc_get(value_addr).get_type()!=vm_vector) + nasal_scalar* value_addr=in_builtin_find("vector"); + if(value_addr->get_type()!=vm_vector) { - std::cout<<">> [runtime] builtin_pop: \"vector\" has wrong value type(must be vector).\n"; - return -1; + std::cout<<">> [vm] builtin_pop: \"vector\" has wrong value type(must be vector).\n"; + return NULL; } - int ret_addr=nasal_vm.gc_get(value_addr).get_vector().del_elem(); + nasal_scalar* ret_addr=value_addr->get_vector().del_elem(); return ret_addr; } -int builtin_str(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_str(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int value_addr=in_builtin_find("number"); - if(value_addr<0 || nasal_vm.gc_get(value_addr).get_type()!=vm_number) + nasal_scalar* value_addr=in_builtin_find("number"); + if(value_addr->get_type()!=vm_number) { - std::cout<<">> [runtime] builtin_str: \"number\" has wrong value type(must be number).\n"; - return -1; + std::cout<<">> [vm] builtin_str: \"number\" has wrong value type(must be number).\n"; + return NULL; } - double number=nasal_vm.gc_get(value_addr).get_number(); - int ret_addr=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(ret_addr).set_string(trans_number_to_string(number)); + double number=value_addr->get_number(); + nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); + ret_addr->set_string(trans_number_to_string(number)); return ret_addr; } -int builtin_size(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_size(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int value_addr=in_builtin_find("object"); - if(value_addr<0) - { - std::cout<<">> [runtime] builtin_size: cannot find value \"object\".\n"; - return -1; - } - int type=nasal_vm.gc_get(value_addr).get_type(); + nasal_scalar* 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:break; - case vm_string:number=nasal_vm.gc_get(value_addr).get_string().length();break; - case vm_vector:number=nasal_vm.gc_get(value_addr).get_vector().size();break; - case vm_hash:number=nasal_vm.gc_get(value_addr).get_hash().size();break; - } - int ret_addr=-1; - if(number<0) - ret_addr=nasal_vm.gc_alloc(vm_nil); - else - { - ret_addr=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(ret_addr).set_number((double)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; } + nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); + ret_addr->set_number((double)number); return ret_addr; } -int builtin_xor(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_xor(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int a_addr=in_builtin_find("a"); - int b_addr=in_builtin_find("b"); - if(a_addr<0 || nasal_vm.gc_get(a_addr).get_type()!=vm_number) + nasal_scalar* a_addr=in_builtin_find("a"); + nasal_scalar* b_addr=in_builtin_find("b"); + if(a_addr->get_type()!=vm_number) { - std::cout<<">> [runtime] builtin_xor: \"a\" has wrong value type(must be number).\n"; - return -1; + std::cout<<">> [vm] builtin_xor: \"a\" has wrong value type(must be number).\n"; + return NULL; } - if(b_addr<0 || nasal_vm.gc_get(b_addr).get_type()!=vm_number) + if(b_addr->get_type()!=vm_number) { - std::cout<<">> [runtime] builtin_xor: \"b\" has wrong value type(must be number).\n"; - return -1; + std::cout<<">> [vm] builtin_xor: \"b\" has wrong value type(must be number).\n"; + return NULL; } - int number_a=(int)nasal_vm.gc_get(a_addr).get_number(); - int number_b=(int)nasal_vm.gc_get(b_addr).get_number(); - int ret_addr=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(ret_addr).set_number((double)(number_a^number_b)); + 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); + ret_addr->set_number((double)(number_a^number_b)); return ret_addr; } -int builtin_and(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_and(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int a_addr=in_builtin_find("a"); - int b_addr=in_builtin_find("b"); - if(a_addr<0 || nasal_vm.gc_get(a_addr).get_type()!=vm_number) + nasal_scalar* a_addr=in_builtin_find("a"); + nasal_scalar* b_addr=in_builtin_find("b"); + if(a_addr->get_type()!=vm_number) { - std::cout<<">> [runtime] builtin_and: \"a\" has wrong value type(must be number).\n"; - return -1; + std::cout<<">> [vm] builtin_and: \"a\" has wrong value type(must be number).\n"; + return NULL; } - if(b_addr<0 || nasal_vm.gc_get(b_addr).get_type()!=vm_number) + if(b_addr->get_type()!=vm_number) { - std::cout<<">> [runtime] builtin_and: \"b\" has wrong value type(must be number).\n"; - return -1; + std::cout<<">> [vm] builtin_and: \"b\" has wrong value type(must be number).\n"; + return NULL; } - int number_a=(int)nasal_vm.gc_get(a_addr).get_number(); - int number_b=(int)nasal_vm.gc_get(b_addr).get_number(); - int ret_addr=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(ret_addr).set_number((double)(number_a&number_b)); + 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); + ret_addr->set_number((double)(number_a&number_b)); return ret_addr; } -int builtin_or(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_or(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int a_addr=in_builtin_find("a"); - int b_addr=in_builtin_find("b"); - if(a_addr<0 || nasal_vm.gc_get(a_addr).get_type()!=vm_number) + nasal_scalar* a_addr=in_builtin_find("a"); + nasal_scalar* b_addr=in_builtin_find("b"); + if(a_addr->get_type()!=vm_number) { - std::cout<<">> [runtime] builtin_or: \"a\" has wrong value type(must be number).\n"; - return -1; + std::cout<<">> [vm] builtin_or: \"a\" has wrong value type(must be number).\n"; + return NULL; } - if(b_addr<0 || nasal_vm.gc_get(b_addr).get_type()!=vm_number) + if(b_addr->get_type()!=vm_number) { - std::cout<<">> [runtime] builtin_or: \"b\" has wrong value type(must be number).\n"; - return -1; + std::cout<<">> [vm] builtin_or: \"b\" has wrong value type(must be number).\n"; + return NULL; } - int number_a=(int)nasal_vm.gc_get(a_addr).get_number(); - int number_b=(int)nasal_vm.gc_get(b_addr).get_number(); - int ret_addr=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(ret_addr).set_number((double)(number_a|number_b)); + 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); + ret_addr->set_number((double)(number_a|number_b)); return ret_addr; } -int builtin_nand(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_nand(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int a_addr=in_builtin_find("a"); - int b_addr=in_builtin_find("b"); - if(a_addr<0 || nasal_vm.gc_get(a_addr).get_type()!=vm_number) + nasal_scalar* a_addr=in_builtin_find("a"); + nasal_scalar* b_addr=in_builtin_find("b"); + if(a_addr->get_type()!=vm_number) { - std::cout<<">> [runtime] builtin_nand: \"a\" has wrong value type(must be number).\n"; - return -1; + std::cout<<">> [vm] builtin_nand: \"a\" has wrong value type(must be number).\n"; + return NULL; } - if(b_addr<0 || nasal_vm.gc_get(b_addr).get_type()!=vm_number) + if(b_addr->get_type()!=vm_number) { - std::cout<<">> [runtime] builtin_nand: \"b\" has wrong value type(must be number).\n"; - return -1; + std::cout<<">> [vm] builtin_nand: \"b\" has wrong value type(must be number).\n"; + return NULL; } - int number_a=(int)nasal_vm.gc_get(a_addr).get_number(); - int number_b=(int)nasal_vm.gc_get(b_addr).get_number(); - int ret_addr=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(ret_addr).set_number((double)(~(number_a&number_b))); + 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); + ret_addr->set_number((double)(~(number_a&number_b))); return ret_addr; } -int builtin_not(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_not(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int a_addr=in_builtin_find("a"); - if(a_addr<0 || nasal_vm.gc_get(a_addr).get_type()!=vm_number) + nasal_scalar* a_addr=in_builtin_find("a"); + if(a_addr->get_type()!=vm_number) { - std::cout<<">> [runtime] builtin_not: \"a\" has wrong value type(must be number).\n"; - return -1; + std::cout<<">> [vm] builtin_not: \"a\" has wrong value type(must be number).\n"; + return NULL; } - int number=(int)nasal_vm.gc_get(a_addr).get_number(); - int ret_addr=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(ret_addr).set_number((double)(~number)); + int number=(int)a_addr->get_number(); + nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); + ret_addr->set_number((double)(~number)); return ret_addr; } -int builtin_sin(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_sin(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int value_addr=in_builtin_find("x"); - if(value_addr<0 || nasal_vm.gc_get(value_addr).get_type()!=vm_number) + nasal_scalar* value_addr=in_builtin_find("x"); + if(value_addr->get_type()!=vm_number) { - std::cout<<">> [runtime] builtin_sin: \"x\" has wrong value type(must be number).\n"; - return -1; + std::cout<<">> [vm] builtin_sin: \"x\" has wrong value type(must be number).\n"; + return NULL; } - double number=nasal_vm.gc_get(value_addr).get_number(); - int ret_addr=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(ret_addr).set_number(sin(number)); + double number=value_addr->get_number(); + nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); + ret_addr->set_number(sin(number)); return ret_addr; } -int builtin_cos(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_cos(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int value_addr=in_builtin_find("x"); - if(value_addr<0 || nasal_vm.gc_get(value_addr).get_type()!=vm_number) + nasal_scalar* value_addr=in_builtin_find("x"); + if(value_addr->get_type()!=vm_number) { - std::cout<<">> [runtime] builtin_cos: \"x\" has wrong value type(must be number).\n"; - return -1; + std::cout<<">> [vm] builtin_cos: \"x\" has wrong value type(must be number).\n"; + return NULL; } - double number=nasal_vm.gc_get(value_addr).get_number(); - int ret_addr=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(ret_addr).set_number(cos(number)); + double number=value_addr->get_number(); + nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); + ret_addr->set_number(cos(number)); return ret_addr; } -int builtin_tan(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_tan(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int value_addr=in_builtin_find("x"); - if(value_addr<0 || nasal_vm.gc_get(value_addr).get_type()!=vm_number) + nasal_scalar* value_addr=in_builtin_find("x"); + if(value_addr->get_type()!=vm_number) { - std::cout<<">> [runtime] builtin_tan: \"x\" has wrong value type(must be number).\n"; - return -1; + std::cout<<">> [vm] builtin_tan: \"x\" has wrong value type(must be number).\n"; + return NULL; } - double number=nasal_vm.gc_get(value_addr).get_number(); - int ret_addr=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(ret_addr).set_number(tan(number)); + double number=value_addr->get_number(); + nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); + ret_addr->set_number(tan(number)); return ret_addr; } -int builtin_exp(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_exp(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int value_addr=in_builtin_find("x"); - if(value_addr<0 || nasal_vm.gc_get(value_addr).get_type()!=vm_number) + nasal_scalar* value_addr=in_builtin_find("x"); + if(value_addr->get_type()!=vm_number) { - std::cout<<">> [runtime] builtin_exp: \"x\" has wrong value type(must be number).\n"; - return -1; + std::cout<<">> [vm] builtin_exp: \"x\" has wrong value type(must be number).\n"; + return NULL; } - double number=nasal_vm.gc_get(value_addr).get_number(); - int ret_addr=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(ret_addr).set_number(exp(number)); + double number=value_addr->get_number(); + nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); + ret_addr->set_number(exp(number)); return ret_addr; } -int builtin_ln(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_ln(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int value_addr=in_builtin_find("x"); - if(value_addr<0 || nasal_vm.gc_get(value_addr).get_type()!=vm_number) + nasal_scalar* value_addr=in_builtin_find("x"); + if(value_addr->get_type()!=vm_number) { - std::cout<<">> [runtime] builtin_ln: \"x\" has wrong value type(must be number).\n"; - return -1; + std::cout<<">> [vm] builtin_ln: \"x\" has wrong value type(must be number).\n"; + return NULL; } - double number=nasal_vm.gc_get(value_addr).get_number(); - int ret_addr=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(ret_addr).set_number(log(number)/log(2.7182818284590452354)); + double number=value_addr->get_number(); + nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); + ret_addr->set_number(log(number)/log(2.7182818284590452354)); return ret_addr; } -int builtin_sqrt(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_sqrt(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int value_addr=in_builtin_find("x"); - if(value_addr<0 || nasal_vm.gc_get(value_addr).get_type()!=vm_number) + nasal_scalar* value_addr=in_builtin_find("x"); + if(value_addr->get_type()!=vm_number) { - std::cout<<">> [runtime] builtin_sqrt: \"x\" has wrong value type(must be number).\n"; - return -1; + std::cout<<">> [vm] builtin_sqrt: \"x\" has wrong value type(must be number).\n"; + return NULL; } - double number=nasal_vm.gc_get(value_addr).get_number(); - int ret_addr=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(ret_addr).set_number(sqrt(number)); + double number=value_addr->get_number(); + nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); + ret_addr->set_number(sqrt(number)); return ret_addr; } -int builtin_atan2(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_atan2(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int x_value_addr=in_builtin_find("x"); - int y_value_addr=in_builtin_find("y"); - if(x_value_addr<0 || nasal_vm.gc_get(x_value_addr).get_type()!=vm_number) + 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) { - std::cout<<">> [runtime] builtin_atan2: \"x\" has wrong value type(must be number).\n"; - return -1; + std::cout<<">> [vm] builtin_atan2: \"x\" has wrong value type(must be number).\n"; + return NULL; } - if(y_value_addr<0 || nasal_vm.gc_get(y_value_addr).get_type()!=vm_number) + if(y_value_addr->get_type()!=vm_number) { - std::cout<<">> [runtime] builtin_atan2: \"y\" has wrong value type(must be number).\n"; - return -1; + std::cout<<">> [vm] builtin_atan2: \"y\" has wrong value type(must be number).\n"; + return NULL; } - double x=nasal_vm.gc_get(x_value_addr).get_number(); - double y=nasal_vm.gc_get(y_value_addr).get_number(); - int ret_addr=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(ret_addr).set_number(atan2(y,x)); + double x=x_value_addr->get_number(); + double y=y_value_addr->get_number(); + nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); + ret_addr->set_number(atan2(y,x)); return ret_addr; } -int builtin_time(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_time(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int value_addr=in_builtin_find("begin_time"); - if(value_addr<0 || nasal_vm.gc_get(value_addr).get_type()!=vm_number) + nasal_scalar* value_addr=in_builtin_find("begin_time"); + if(value_addr->get_type()!=vm_number) { - std::cout<<">> [runtime] builtin_time: \"begin_time\" has wrong value type(must be number).\n"; - return -1; + std::cout<<">> [vm] builtin_time: \"begin_time\" has wrong value type(must be number).\n"; + return NULL; } - time_t begin_time=(time_t)nasal_vm.gc_get(value_addr).get_number(); - int ret_addr=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(ret_addr).set_number((double)time(&begin_time)); + time_t begin_time=(time_t)value_addr->get_number(); + nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); + ret_addr->set_number((double)time(&begin_time)); return ret_addr; } -int builtin_contains(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_contains(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int hash_addr=in_builtin_find("hash"); - int key_addr=in_builtin_find("key"); - if(hash_addr<0 || !in_builtin_check(hash_addr,vm_hash)) + nasal_scalar* hash_addr=in_builtin_find("hash"); + nasal_scalar* key_addr=in_builtin_find("key"); + if(!in_builtin_check(hash_addr,vm_hash)) { - std::cout<<">> [runtime] builtin_contains: \"hash\" has wrong type(must be hash).\n"; - return -1; + std::cout<<">> [vm] builtin_contains: \"hash\" has wrong type(must be hash).\n"; + return NULL; } - if(key_addr<0 || !in_builtin_check(key_addr,vm_string)) + if(!in_builtin_check(key_addr,vm_string)) { - std::cout<<">> [runtime] builtin_contains: \"key\" has wrong type(must be string).\n"; - return -1; + std::cout<<">> [vm] builtin_contains: \"key\" has wrong type(must be string).\n"; + return NULL; } - std::string key=nasal_vm.gc_get(key_addr).get_string(); - bool contains=nasal_vm.gc_get(hash_addr).get_hash().check_contain(key); - int ret_addr=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(ret_addr).set_number((double)contains); + std::string key=key_addr->get_string(); + bool contains=hash_addr->get_hash().check_contain(key); + nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_number); + ret_addr->set_number((double)contains); return ret_addr; } -int builtin_delete(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_delete(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int hash_addr=in_builtin_find("hash"); - int key_addr=in_builtin_find("key"); - if(hash_addr<0 || !in_builtin_check(hash_addr,vm_hash)) + nasal_scalar* hash_addr=in_builtin_find("hash"); + nasal_scalar* key_addr=in_builtin_find("key"); + if(!in_builtin_check(hash_addr,vm_hash)) { - std::cout<<">> [runtime] builtin_delete: \"hash\" has wrong type(must be hash).\n"; - return -1; + std::cout<<">> [vm] builtin_delete: \"hash\" has wrong type(must be hash).\n"; + return NULL; } - if(key_addr<0 || !in_builtin_check(key_addr,vm_string)) + if(!in_builtin_check(key_addr,vm_string)) { - std::cout<<">> [runtime] builtin_delete: \"key\" has wrong type(must be string).\n"; - return -1; + std::cout<<">> [vm] builtin_delete: \"key\" has wrong type(must be string).\n"; + return NULL; } - std::string key=nasal_vm.gc_get(key_addr).get_string(); - nasal_vm.gc_get(hash_addr).get_hash().del_elem(key); - int ret_addr=nasal_vm.gc_alloc(vm_nil); + std::string key=key_addr->get_string(); + hash_addr->get_hash().del_elem(key); + nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_nil); return ret_addr; } -int builtin_getkeys(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_getkeys(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int hash_addr=in_builtin_find("hash"); - if(hash_addr<0 || !in_builtin_check(hash_addr,vm_hash)) + nasal_scalar* hash_addr=in_builtin_find("hash"); + if(!in_builtin_check(hash_addr,vm_hash)) { - std::cout<<">> [runtime] builtin_delete: \"hash\" has wrong type(must be hash).\n"; - return -1; + std::cout<<">> [vm] builtin_delete: \"hash\" has wrong type(must be hash).\n"; + return NULL; } - int ret_addr=nasal_vm.gc_get(hash_addr).get_hash().get_keys(); + nasal_scalar* ret_addr=hash_addr->get_hash().get_keys(); return ret_addr; } -int builtin_import(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_import(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { // this function is used in preprocessing. // this function will return nothing when running. - std::cout<<">> [runtime] builtin_import: cannot use import when running.\n"; - int ret_addr=nasal_vm.gc_alloc(vm_nil); + std::cout<<">> [vm] builtin_import: cannot use import when running.\n"; + nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_nil); return ret_addr; } -int builtin_die(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_die(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int str_addr=in_builtin_find("str"); - if(str_addr<0 || !in_builtin_check(str_addr,vm_string)) + nasal_scalar* str_addr=in_builtin_find("str"); + if(!in_builtin_check(str_addr,vm_string)) { - std::cout<<">> [runtime] builtin_die: \"str\" has wrong type(must be string).\n"; - return -1; + std::cout<<">> [vm] builtin_die: \"str\" has wrong type(must be string).\n"; + return NULL; } builtin_die_state=true; - std::cout<<">> [runtime] error: "<> [vm] error: "<get_string()<<'\n'; + nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_nil); return ret_addr; } -int builtin_type(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_type(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int value_addr=in_builtin_find("object"); + nasal_scalar* value_addr=in_builtin_find("object"); if(value_addr<0) { - std::cout<<">> [runtime] builtin_type: cannot find \"object\".\n"; - return -1; + std::cout<<">> [vm] builtin_type: cannot find \"object\".\n"; + return NULL; } - int type=nasal_vm.gc_get(value_addr).get_type(); - int ret_addr=nasal_vm.gc_alloc(vm_string); + int type=value_addr->get_type(); + nasal_scalar* ret_addr=nasal_vm.gc_alloc(vm_string); switch(type) { - case vm_nil: nasal_vm.gc_get(ret_addr).set_string("nil");break; - case vm_number: nasal_vm.gc_get(ret_addr).set_string("number");break; - case vm_string: nasal_vm.gc_get(ret_addr).set_string("string");break; - case vm_vector: nasal_vm.gc_get(ret_addr).set_string("vector");break; - case vm_hash: nasal_vm.gc_get(ret_addr).set_string("hash");break; - case vm_function: nasal_vm.gc_get(ret_addr).set_string("function");break; + 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_hash: ret_addr->set_string("hash");break; + case vm_function: ret_addr->set_string("function");break; } return ret_addr; } -int builtin_substr(int local_scope_addr,nasal_virtual_machine& nasal_vm) +nasal_scalar* builtin_substr(nasal_scalar* local_scope_addr,nasal_virtual_machine& nasal_vm) { - int str_addr=in_builtin_find("str"); - int begin_addr=in_builtin_find("begin"); - int length_addr=in_builtin_find("length"); - if(str_addr<0 || !in_builtin_check(str_addr,vm_string)) + 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(!in_builtin_check(str_addr,vm_string)) { - std::cout<<">> [runtime] builtin_substr: cannot find \"str\" or wrong type(must be string).\n"; - return -1; + std::cout<<">> [vm] builtin_substr: cannot find \"str\" or wrong type(must be string).\n"; + return NULL; } - if(begin_addr<0 || !in_builtin_check(begin_addr,vm_number)) + if(!in_builtin_check(begin_addr,vm_number)) { - std::cout<<">> [runtime] builtin_substr: cannot find \"begin\" or wrong type(must be number).\n"; - return -1; + std::cout<<">> [vm] builtin_substr: cannot find \"begin\" or wrong type(must be number).\n"; + return NULL; } - if(length_addr<0 || !in_builtin_check(length_addr,vm_number)) + if(!in_builtin_check(length_addr,vm_number)) { - std::cout<<">> [runtime] builtin_substr: cannot find \"length\" or wrong type(must be number).\n"; - return -1; + std::cout<<">> [vm] builtin_substr: cannot find \"length\" or wrong type(must be number).\n"; + return NULL; } - std::string str=nasal_vm.gc_get(str_addr).get_string(); - int begin=(int)nasal_vm.gc_get(begin_addr).get_number(); - int len=(int)nasal_vm.gc_get(length_addr).get_number(); + std::string str=str_addr->get_string(); + int begin=(int)begin_addr->get_number(); + int len=(int)length_addr->get_number(); if(begin>=str.length() || begin+len>=str.length()) { - std::cout<<">> [runtime] builtin_substr: index out of range.\n"; - return -1; + std::cout<<">> [vm] builtin_substr: index out of range.\n"; + return NULL; } std::string tmp=""; for(int i=begin;iset_string(tmp); return ret_addr; } #endif \ No newline at end of file diff --git a/nasal_bytecode_vm.h b/nasal_bytecode_vm.h index ca6b339..4a2da07 100644 --- a/nasal_bytecode_vm.h +++ b/nasal_bytecode_vm.h @@ -7,21 +7,21 @@ private: bool main_loop_break_mark; int ptr; int me_index; // this is the index of "me" in string_table - int global_scope_addr; + nasal_scalar* global_scope_addr; // garbage collector and memory manager nasal_virtual_machine vm; // byte codes store here std::vector exec_code; // main calculation stack #define VALUE_STACK_MAX_DEPTH 2048 - int* value_stack; - int* value_stack_top; + nasal_scalar** value_stack; + nasal_scalar** value_stack_top; // stack for mem_call - std::stack pointer_stack; + std::stack pointer_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(int); + bool check_condition(nasal_scalar*); void opr_nop(); void opr_load(); void opr_pushnum(); @@ -99,9 +99,9 @@ public: nasal_bytecode_vm::nasal_bytecode_vm() { - value_stack=new int[VALUE_STACK_MAX_DEPTH]; + value_stack=new nasal_scalar*[VALUE_STACK_MAX_DEPTH]; value_stack_top=value_stack; - local_scope_stack.push(-1); + 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; @@ -114,11 +114,11 @@ nasal_bytecode_vm::~nasal_bytecode_vm() void nasal_bytecode_vm::clear() { vm.clear(); - global_scope_addr=-1; + global_scope_addr=NULL; value_stack_top=value_stack; while(!pointer_stack.empty())pointer_stack.pop(); while(!local_scope_stack.empty())local_scope_stack.pop(); - local_scope_stack.push(-1); + local_scope_stack.push(NULL); while(!slice_stack.empty())slice_stack.pop(); while(!call_stack.empty())call_stack.pop(); while(!counter_stack.empty())counter_stack.pop(); @@ -133,23 +133,21 @@ void nasal_bytecode_vm::die(std::string str) main_loop_break_mark=false; return; } -bool nasal_bytecode_vm::check_condition(int value_addr) +bool nasal_bytecode_vm::check_condition(nasal_scalar* value_addr) { - if(value_addr<0) - return false; - int type=vm.gc_get(value_addr).get_type(); - if(type==vm_nil || type==vm_vector || type==vm_hash || type==vm_function) + if(!value_addr) return false; + int type=value_addr->get_type(); + if(type==vm_number) + return (value_addr->get_number()!=0); else if(type==vm_string) { - std::string str=vm.gc_get(value_addr).get_string(); + std::string str=value_addr->get_string(); double number=trans_string_to_number(str); if(std::isnan(number)) return str.length()!=0; return (number!=0); } - else if(type==vm_number) - return (vm.gc_get(value_addr).get_number()!=0); return false; } void nasal_bytecode_vm::opr_nop() @@ -160,28 +158,29 @@ void nasal_bytecode_vm::opr_nop() } void nasal_bytecode_vm::opr_load() { - int val_addr=*value_stack_top--; - vm.gc_get(local_scope_stack.top()>=0?local_scope_stack.top():global_scope_addr).get_closure().add_new_value(exec_code[ptr].index,val_addr); + nasal_scalar* val_addr=*value_stack_top--; + nasal_scalar* 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() { - int val_addr=vm.gc_alloc(vm_number); - vm.gc_get(val_addr).set_number(number_table[exec_code[ptr].index]); + nasal_scalar* val_addr=vm.gc_alloc(vm_number); + val_addr->set_number(number_table[exec_code[ptr].index]); *(++value_stack_top)=val_addr; return; } void nasal_bytecode_vm::opr_pushone() { - int val_addr=vm.gc_alloc(vm_number); - vm.gc_get(val_addr).set_number(1); + nasal_scalar* val_addr=vm.gc_alloc(vm_number); + val_addr->set_number(1); *(++value_stack_top)=val_addr; return; } void nasal_bytecode_vm::opr_pushzero() { - int val_addr=vm.gc_alloc(vm_number); - vm.gc_get(val_addr).set_number(0); + nasal_scalar* val_addr=vm.gc_alloc(vm_number); + val_addr->set_number(0); *(++value_stack_top)=val_addr; return; } @@ -192,8 +191,8 @@ void nasal_bytecode_vm::opr_pushnil() } void nasal_bytecode_vm::opr_pushstr() { - int val_addr=vm.gc_alloc(vm_string); - vm.gc_get(val_addr).set_string(string_table[exec_code[ptr].index]); + nasal_scalar* val_addr=vm.gc_alloc(vm_string); + val_addr->set_string(string_table[exec_code[ptr].index]); *(++value_stack_top)=val_addr; return; } @@ -209,13 +208,14 @@ void nasal_bytecode_vm::opr_newhash() } void nasal_bytecode_vm::opr_newfunc() { - int val_addr=vm.gc_alloc(vm_function); - if(local_scope_stack.top()>=0) - vm.gc_get(val_addr).get_func().set_closure_addr(local_scope_stack.top()); + nasal_scalar* val_addr=vm.gc_alloc(vm_function); + nasal_scalar* local_scope_top=local_scope_stack.top(); + if(local_scope_top) + val_addr->get_func().set_closure_addr(local_scope_top); else { - int tmp_closure=vm.gc_alloc(vm_closure); - vm.gc_get(val_addr).get_func().set_closure_addr(tmp_closure); + nasal_scalar* tmp_closure=vm.gc_alloc(vm_closure); + val_addr->get_func().set_closure_addr(tmp_closure); vm.del_reference(tmp_closure); } *(++value_stack_top)=val_addr; @@ -223,66 +223,64 @@ void nasal_bytecode_vm::opr_newfunc() } void nasal_bytecode_vm::opr_vecapp() { - int val_addr=*value_stack_top--; - vm.gc_get(*value_stack_top).get_vector().add_elem(val_addr); + nasal_scalar* val_addr=*value_stack_top--; + (*value_stack_top)->get_vector().add_elem(val_addr); return; } void nasal_bytecode_vm::opr_hashapp() { - int val_addr=*value_stack_top--; - int hash_addr=*value_stack_top; - vm.gc_get(hash_addr).get_hash().add_elem(string_table[exec_code[ptr].index],val_addr); + nasal_scalar* val_addr=*value_stack_top--; + (*value_stack_top)->get_hash().add_elem(string_table[exec_code[ptr].index],val_addr); return; } void nasal_bytecode_vm::opr_para() { - vm.gc_get(*value_stack_top).get_func().add_para(exec_code[ptr].index); + (*value_stack_top)->get_func().add_para(exec_code[ptr].index); return; } void nasal_bytecode_vm::opr_defpara() { - int val_addr=*value_stack_top--; - vm.gc_get(*value_stack_top).get_func().add_para(exec_code[ptr].index,val_addr); + nasal_scalar* val_addr=*value_stack_top--; + (*value_stack_top)->get_func().add_para(exec_code[ptr].index,val_addr); return; } void nasal_bytecode_vm::opr_dynpara() { - vm.gc_get(*value_stack_top).get_func().add_para(exec_code[ptr].index,-1,true); + (*value_stack_top)->get_func().add_para(exec_code[ptr].index,NULL,true); return; } void nasal_bytecode_vm::opr_entry() { - vm.gc_get(*value_stack_top).get_func().set_entry(exec_code[ptr].index); + (*value_stack_top)->get_func().set_entry(exec_code[ptr].index); return; } void nasal_bytecode_vm::opr_unot() { - int val_addr=*value_stack_top--; - nasal_scalar& ref=vm.gc_get(val_addr); - int type=ref.get_type(); - int new_value_address=-1; + nasal_scalar* val_addr=*value_stack_top--; + int type=val_addr->get_type(); + nasal_scalar* new_value_address=NULL; if(type==vm_nil) { new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number(1); + new_value_address->set_number(1); } else if(type==vm_number) { new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number(ref.get_number()==0); + new_value_address->set_number(val_addr->get_number()==0); } else if(type==vm_string) { - double number=trans_string_to_number(ref.get_string()); + double number=trans_string_to_number(val_addr->get_string()); if(std::isnan(number)) { new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number(!ref.get_string().length()); + new_value_address->set_number(!val_addr->get_string().length()); } else { new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number(number==0); + new_value_address->set_number(number==0); } } else @@ -293,19 +291,19 @@ void nasal_bytecode_vm::opr_unot() } void nasal_bytecode_vm::opr_usub() { - int val_addr=*value_stack_top--; - int new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number(-vm.gc_get(val_addr).to_number()); + nasal_scalar* val_addr=*value_stack_top--; + nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + new_value_address->set_number(-val_addr->to_number()); *(++value_stack_top)=new_value_address; vm.del_reference(val_addr); return; } void nasal_bytecode_vm::opr_add() { - int val_addr2=*value_stack_top--; - int val_addr1=*value_stack_top--; - int new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number(vm.gc_get(val_addr1).to_number()+vm.gc_get(val_addr2).to_number()); + nasal_scalar* val_addr2=*value_stack_top--; + nasal_scalar* val_addr1=*value_stack_top--; + nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + new_value_address->set_number(val_addr1->to_number()+val_addr2->to_number()); *(++value_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); @@ -313,10 +311,10 @@ void nasal_bytecode_vm::opr_add() } void nasal_bytecode_vm::opr_sub() { - int val_addr2=*value_stack_top--; - int val_addr1=*value_stack_top--; - int new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number(vm.gc_get(val_addr1).to_number()-vm.gc_get(val_addr2).to_number()); + nasal_scalar* val_addr2=*value_stack_top--; + nasal_scalar* val_addr1=*value_stack_top--; + nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + new_value_address->set_number(val_addr1->to_number()-val_addr2->to_number()); *(++value_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); @@ -324,10 +322,10 @@ void nasal_bytecode_vm::opr_sub() } void nasal_bytecode_vm::opr_mul() { - int val_addr2=*value_stack_top--; - int val_addr1=*value_stack_top--; - int new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number(vm.gc_get(val_addr1).to_number()*vm.gc_get(val_addr2).to_number()); + nasal_scalar* val_addr2=*value_stack_top--; + nasal_scalar* val_addr1=*value_stack_top--; + nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + new_value_address->set_number(val_addr1->to_number()*val_addr2->to_number()); *(++value_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); @@ -335,10 +333,10 @@ void nasal_bytecode_vm::opr_mul() } void nasal_bytecode_vm::opr_div() { - int val_addr2=*value_stack_top--; - int val_addr1=*value_stack_top--; - int new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number(vm.gc_get(val_addr1).to_number()/vm.gc_get(val_addr2).to_number()); + nasal_scalar* val_addr2=*value_stack_top--; + nasal_scalar* val_addr1=*value_stack_top--; + nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + new_value_address->set_number(val_addr1->to_number()/val_addr2->to_number()); *(++value_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); @@ -346,10 +344,10 @@ void nasal_bytecode_vm::opr_div() } void nasal_bytecode_vm::opr_lnk() { - int val_addr2=*value_stack_top--; - int val_addr1=*value_stack_top--; - int new_value_address=vm.gc_alloc(vm_string); - vm.gc_get(new_value_address).set_string(vm.gc_get(val_addr1).to_string()+vm.gc_get(val_addr2).to_string()); + nasal_scalar* val_addr2=*value_stack_top--; + nasal_scalar* val_addr1=*value_stack_top--; + nasal_scalar* new_value_address=vm.gc_alloc(vm_string); + new_value_address->set_string(val_addr1->to_string()+val_addr2->to_string()); *(++value_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); @@ -357,12 +355,12 @@ void nasal_bytecode_vm::opr_lnk() } void nasal_bytecode_vm::opr_addeq() { - int* mem_addr=pointer_stack.top(); + nasal_scalar** mem_addr=pointer_stack.top(); pointer_stack.pop(); - int val_addr2=*value_stack_top--; - int val_addr1=*mem_addr; - int new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number(vm.gc_get(val_addr1).to_number()+vm.gc_get(val_addr2).to_number()); + nasal_scalar* val_addr2=*value_stack_top--; + nasal_scalar* val_addr1=*mem_addr; + nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + 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; vm.del_reference(*mem_addr); @@ -372,12 +370,12 @@ void nasal_bytecode_vm::opr_addeq() } void nasal_bytecode_vm::opr_subeq() { - int* mem_addr=pointer_stack.top(); + nasal_scalar** mem_addr=pointer_stack.top(); pointer_stack.pop(); - int val_addr2=*value_stack_top--; - int val_addr1=*mem_addr; - int new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number(vm.gc_get(val_addr1).to_number()-vm.gc_get(val_addr2).to_number()); + nasal_scalar* val_addr2=*value_stack_top--; + nasal_scalar* val_addr1=*mem_addr; + nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + 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; vm.del_reference(*mem_addr); @@ -387,12 +385,12 @@ void nasal_bytecode_vm::opr_subeq() } void nasal_bytecode_vm::opr_muleq() { - int* mem_addr=pointer_stack.top(); + nasal_scalar** mem_addr=pointer_stack.top(); pointer_stack.pop(); - int val_addr2=*value_stack_top--; - int val_addr1=*mem_addr; - int new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number(vm.gc_get(val_addr1).to_number()*vm.gc_get(val_addr2).to_number()); + nasal_scalar* val_addr2=*value_stack_top--; + nasal_scalar* val_addr1=*mem_addr; + nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + 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; vm.del_reference(*mem_addr); @@ -402,12 +400,12 @@ void nasal_bytecode_vm::opr_muleq() } void nasal_bytecode_vm::opr_diveq() { - int* mem_addr=pointer_stack.top(); + nasal_scalar** mem_addr=pointer_stack.top(); pointer_stack.pop(); - int val_addr2=*value_stack_top--; - int val_addr1=*mem_addr; - int new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number(vm.gc_get(val_addr1).to_number()/vm.gc_get(val_addr2).to_number()); + nasal_scalar* val_addr2=*value_stack_top--; + nasal_scalar* val_addr1=*mem_addr; + nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + 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; vm.del_reference(*mem_addr); @@ -417,12 +415,12 @@ void nasal_bytecode_vm::opr_diveq() } void nasal_bytecode_vm::opr_lnkeq() { - int* mem_addr=pointer_stack.top(); + nasal_scalar** mem_addr=pointer_stack.top(); pointer_stack.pop(); - int val_addr2=*value_stack_top--; - int val_addr1=*mem_addr; - int new_value_address=vm.gc_alloc(vm_string); - vm.gc_get(new_value_address).set_string(vm.gc_get(val_addr1).to_string()+vm.gc_get(val_addr2).to_string()); + nasal_scalar* val_addr2=*value_stack_top--; + nasal_scalar* val_addr1=*mem_addr; + nasal_scalar* new_value_address=vm.gc_alloc(vm_string); + 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; vm.del_reference(*mem_addr); @@ -432,9 +430,9 @@ void nasal_bytecode_vm::opr_lnkeq() } void nasal_bytecode_vm::opr_meq() { - int* mem_addr=pointer_stack.top(); + nasal_scalar** mem_addr=pointer_stack.top(); pointer_stack.pop(); - int val_addr=*value_stack_top; + nasal_scalar* val_addr=*value_stack_top; vm.add_reference(val_addr); vm.del_reference(*mem_addr); *mem_addr=val_addr; @@ -442,25 +440,23 @@ void nasal_bytecode_vm::opr_meq() } void nasal_bytecode_vm::opr_eq() { - int val_addr2=*value_stack_top--; - int val_addr1=*value_stack_top--; + nasal_scalar* val_addr2=*value_stack_top--; + nasal_scalar* val_addr1=*value_stack_top--; if(val_addr1==val_addr2) { - int new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number(1); + nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + new_value_address->set_number(1); *(++value_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); return; } - nasal_scalar& a_ref=vm.gc_get(val_addr1); - nasal_scalar& b_ref=vm.gc_get(val_addr2); - int a_ref_type=a_ref.get_type(); - int b_ref_type=b_ref.get_type(); + 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) { - int new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number(1); + nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + new_value_address->set_number(1); *(++value_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); @@ -470,17 +466,17 @@ void nasal_bytecode_vm::opr_eq() { if(a_ref_type==vm_string && b_ref_type==vm_string) { - std::string astr=a_ref.get_string(); - std::string bstr=b_ref.get_string(); - int new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number((double)(astr==bstr)); + std::string astr=val_addr1->get_string(); + std::string bstr=val_addr2->get_string(); + nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + new_value_address->set_number((double)(astr==bstr)); *(++value_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); return; } - int new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number((double)(a_ref.to_number()==b_ref.to_number())); + nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + new_value_address->set_number((double)(val_addr1->to_number()==val_addr2->to_number())); *(++value_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); @@ -488,8 +484,8 @@ void nasal_bytecode_vm::opr_eq() } else { - int new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number(0); + nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + new_value_address->set_number(0); *(++value_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); @@ -499,25 +495,23 @@ void nasal_bytecode_vm::opr_eq() } void nasal_bytecode_vm::opr_neq() { - int val_addr2=*value_stack_top--; - int val_addr1=*value_stack_top--; + nasal_scalar* val_addr2=*value_stack_top--; + nasal_scalar* val_addr1=*value_stack_top--; if(val_addr1==val_addr2) { - int new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number(0); + nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + new_value_address->set_number(0); *(++value_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); return; } - nasal_scalar& a_ref=vm.gc_get(val_addr1); - nasal_scalar& b_ref=vm.gc_get(val_addr2); - int a_ref_type=a_ref.get_type(); - int b_ref_type=b_ref.get_type(); + 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) { - int new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number(0); + nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + new_value_address->set_number(0); *(++value_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); @@ -527,17 +521,17 @@ void nasal_bytecode_vm::opr_neq() { if(a_ref_type==vm_string && b_ref_type==vm_string) { - std::string astr=a_ref.get_string(); - std::string bstr=b_ref.get_string(); - int new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number((double)(astr!=bstr)); + std::string astr=val_addr1->get_string(); + std::string bstr=val_addr2->get_string(); + nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + new_value_address->set_number((double)(astr!=bstr)); *(++value_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); return; } - int new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number((double)(a_ref.to_number()!=b_ref.to_number())); + nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + new_value_address->set_number((double)(val_addr1->to_number()!=val_addr2->to_number())); *(++value_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); @@ -545,8 +539,8 @@ void nasal_bytecode_vm::opr_neq() } else { - int new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number(1); + nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + new_value_address->set_number(1); *(++value_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); @@ -558,25 +552,23 @@ void nasal_bytecode_vm::opr_neq() } void nasal_bytecode_vm::opr_less() { - int val_addr2=*value_stack_top--; - int val_addr1=*value_stack_top--; - nasal_scalar& a_ref=vm.gc_get(val_addr1); - nasal_scalar& b_ref=vm.gc_get(val_addr2); - int a_ref_type=a_ref.get_type(); - int b_ref_type=b_ref.get_type(); + nasal_scalar* val_addr2=*value_stack_top--; + nasal_scalar* val_addr1=*value_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) { - std::string a_str=a_ref.get_string(); - std::string b_str=b_ref.get_string(); - int new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number(a_strget_string(); + std::string b_str=val_addr2->get_string(); + nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + new_value_address->set_number(a_strset_number(val_addr1->to_number()to_number()); *(++value_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); @@ -584,25 +576,23 @@ void nasal_bytecode_vm::opr_less() } void nasal_bytecode_vm::opr_leq() { - int val_addr2=*value_stack_top--; - int val_addr1=*value_stack_top--; - nasal_scalar& a_ref=vm.gc_get(val_addr1); - nasal_scalar& b_ref=vm.gc_get(val_addr2); - int a_ref_type=a_ref.get_type(); - int b_ref_type=b_ref.get_type(); + nasal_scalar* val_addr2=*value_stack_top--; + nasal_scalar* val_addr1=*value_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) { - std::string a_str=a_ref.get_string(); - std::string b_str=b_ref.get_string(); - int new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number(a_str<=b_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); + new_value_address->set_number(a_str<=b_str); *(++value_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); return; } - int new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number(a_ref.to_number()<=b_ref.to_number()); + nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + new_value_address->set_number(val_addr1->to_number()<=val_addr2->to_number()); *(++value_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); @@ -610,25 +600,23 @@ void nasal_bytecode_vm::opr_leq() } void nasal_bytecode_vm::opr_grt() { - int val_addr2=*value_stack_top--; - int val_addr1=*value_stack_top--; - nasal_scalar& a_ref=vm.gc_get(val_addr1); - nasal_scalar& b_ref=vm.gc_get(val_addr2); - int a_ref_type=a_ref.get_type(); - int b_ref_type=b_ref.get_type(); + nasal_scalar* val_addr2=*value_stack_top--; + nasal_scalar* val_addr1=*value_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) { - std::string a_str=a_ref.get_string(); - std::string b_str=b_ref.get_string(); - int new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number(a_str>b_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); + new_value_address->set_number(a_str>b_str); *(++value_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); return; } - int new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number(a_ref.to_number()>b_ref.to_number()); + nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + new_value_address->set_number(val_addr1->to_number()>val_addr2->to_number()); *(++value_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); @@ -636,25 +624,23 @@ void nasal_bytecode_vm::opr_grt() } void nasal_bytecode_vm::opr_geq() { - int val_addr2=*value_stack_top--; - int val_addr1=*value_stack_top--; - nasal_scalar& a_ref=vm.gc_get(val_addr1); - nasal_scalar& b_ref=vm.gc_get(val_addr2); - int a_ref_type=a_ref.get_type(); - int b_ref_type=b_ref.get_type(); + nasal_scalar* val_addr2=*value_stack_top--; + nasal_scalar* val_addr1=*value_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) { - std::string a_str=a_ref.get_string(); - std::string b_str=b_ref.get_string(); - int new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number(a_str>=b_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); + new_value_address->set_number(a_str>=b_str); *(++value_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); return; } - int new_value_address=vm.gc_alloc(vm_number); - vm.gc_get(new_value_address).set_number(a_ref.to_number()>=b_ref.to_number()); + nasal_scalar* new_value_address=vm.gc_alloc(vm_number); + new_value_address->set_number(val_addr1->to_number()>=val_addr2->to_number()); *(++value_stack_top)=new_value_address; vm.del_reference(val_addr1); vm.del_reference(val_addr2); @@ -684,7 +670,7 @@ void nasal_bytecode_vm::opr_jmpfalse() } void nasal_bytecode_vm::opr_counter() { - if(vm.gc_get(*value_stack_top).get_type()!=vm_vector) + if((*value_stack_top)->get_type()!=vm_vector) { die("cnt: must use vector in forindex/foreach"); return; @@ -694,7 +680,7 @@ void nasal_bytecode_vm::opr_counter() } void nasal_bytecode_vm::opr_forindex() { - nasal_vector& ref=vm.gc_get(*value_stack_top).get_vector(); + nasal_vector& ref=(*value_stack_top)->get_vector(); counter_stack.top()++; if(counter_stack.top()>=ref.size()) { @@ -703,14 +689,14 @@ void nasal_bytecode_vm::opr_forindex() ptr=exec_code[ptr].index-1; return; } - int res=vm.gc_alloc(vm_number); - vm.gc_get(res).set_number((double)counter_stack.top()); + nasal_scalar* res=vm.gc_alloc(vm_number); + res->set_number((double)counter_stack.top()); *(++value_stack_top)=res; return; } void nasal_bytecode_vm::opr_foreach() { - nasal_vector& ref=vm.gc_get(*value_stack_top).get_vector(); + nasal_vector& ref=(*value_stack_top)->get_vector(); counter_stack.top()++; if(counter_stack.top()>=ref.size()) { @@ -719,27 +705,27 @@ void nasal_bytecode_vm::opr_foreach() ptr=exec_code[ptr].index-1; return; } - int res=ref.get_value_address(counter_stack.top()); + nasal_scalar* res=ref.get_value_address(counter_stack.top()); vm.add_reference(res); *(++value_stack_top)=res; return; } void nasal_bytecode_vm::opr_call() { - int val_addr=-1; + nasal_scalar* val_addr=NULL; int name_index=exec_code[ptr].index; - int local_scope_top=local_scope_stack.top(); - if(local_scope_top>=0) - val_addr=vm.gc_get(local_scope_top).get_closure().get_value_address(name_index); - if(val_addr>=0) + nasal_scalar* 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; return; } else - val_addr=vm.gc_get(global_scope_addr).get_closure().get_value_address(name_index); - if(val_addr>=0) + val_addr=global_scope_addr->get_closure().get_value_address(name_index); + if(val_addr) { vm.add_reference(val_addr); *(++value_stack_top)=val_addr; @@ -750,14 +736,14 @@ void nasal_bytecode_vm::opr_call() } void nasal_bytecode_vm::opr_callv() { - int val_addr=*value_stack_top--; - int vec_addr=*value_stack_top--; - int type=vm.gc_get(vec_addr).get_type(); + nasal_scalar* val_addr=*value_stack_top--; + nasal_scalar* vec_addr=*value_stack_top--; + int type=vec_addr->get_type(); if(type==vm_vector) { - int num=vm.gc_get(val_addr).to_number(); - int res=vm.gc_get(vec_addr).get_vector().get_value_address(num); - if(res>=0) + int num=val_addr->to_number(); + nasal_scalar* res=vec_addr->get_vector().get_value_address(num); + if(res) { vm.add_reference(res); *(++value_stack_top)=res; @@ -770,20 +756,20 @@ void nasal_bytecode_vm::opr_callv() } else if(type==vm_hash) { - if(vm.gc_get(val_addr).get_type()!=vm_string) + if(val_addr->get_type()!=vm_string) { die("callv: must use string as the key"); return; } - int res=vm.gc_get(vec_addr).get_hash().get_value_address(vm.gc_get(val_addr).get_string()); - if(res<0) + nasal_scalar* res=vec_addr->get_hash().get_value_address(val_addr->get_string()); + if(!res) { - die("callv: cannot find member \""+vm.gc_get(val_addr).get_string()+"\" of this hash"); + die("callv: cannot find member \""+val_addr->get_string()+"\" of this hash"); return; } - if(vm.gc_get(res).get_type()==vm_function) + if(res->get_type()==vm_function) { - vm.gc_get(vm.gc_get(res).get_func().get_closure_addr()).get_closure().add_new_value(me_index,val_addr); + (res->get_func().get_closure_addr())->get_closure().add_new_value(me_index,val_addr); vm.add_reference(val_addr); } vm.add_reference(res); @@ -791,16 +777,16 @@ void nasal_bytecode_vm::opr_callv() } else if(type==vm_string) { - std::string str=vm.gc_get(vec_addr).get_string(); - int num=vm.gc_get(val_addr).to_number(); + std::string str=vec_addr->get_string(); + int num=val_addr->to_number(); int str_size=str.length(); if(num<-str_size || num>=str_size) { die("callv: index out of range"); return; } - int res=vm.gc_alloc(vm_number); - vm.gc_get(res).set_number((double)str[num>=0? num:num+str_size]); + nasal_scalar* res=vm.gc_alloc(vm_number); + res->set_number((double)str[num>=0? num:num+str_size]); *(++value_stack_top)=res; } vm.del_reference(val_addr); @@ -809,14 +795,14 @@ void nasal_bytecode_vm::opr_callv() } void nasal_bytecode_vm::opr_callvi() { - int val_addr=*value_stack_top; - if(vm.gc_get(val_addr).get_type()!=vm_vector) + nasal_scalar* val_addr=*value_stack_top; + if(val_addr->get_type()!=vm_vector) { die("callvi: multi-definition/multi-assignment must use a vector"); return; } - int res=vm.gc_get(val_addr).get_vector().get_value_address(exec_code[ptr].index); - if(res<0) + nasal_scalar* res=val_addr->get_vector().get_value_address(exec_code[ptr].index); + if(!res) { die("callvi: index out of range"); return; @@ -827,22 +813,22 @@ void nasal_bytecode_vm::opr_callvi() } void nasal_bytecode_vm::opr_callh() { - int val_addr=*value_stack_top--; - if(vm.gc_get(val_addr).get_type()!=vm_hash) + nasal_scalar* val_addr=*value_stack_top--; + if(val_addr->get_type()!=vm_hash) { die("callh: must call a hash"); return; } - int res=vm.gc_get(val_addr).get_hash().get_value_address(string_table[exec_code[ptr].index]); - if(res>=0) + nasal_scalar* res=val_addr->get_hash().get_value_address(string_table[exec_code[ptr].index]); + if(res) vm.add_reference(res); else { die("callh: hash member \""+string_table[exec_code[ptr].index]+"\" does not exist"); return; } - if(vm.gc_get(res).get_type()==vm_function) - vm.gc_get(vm.gc_get(res).get_func().get_closure_addr()).get_closure().add_new_value(me_index,val_addr); + if(res->get_type()==vm_function) + (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; @@ -850,30 +836,30 @@ void nasal_bytecode_vm::opr_callh() } void nasal_bytecode_vm::opr_callf() { - int para_addr=*value_stack_top--; - int func_addr=*value_stack_top; - if(vm.gc_get(func_addr).get_type()!=vm_function) + nasal_scalar* para_addr=*value_stack_top--; + nasal_scalar* func_addr=*value_stack_top; + if(func_addr->get_type()!=vm_function) { die("callf: called a value that is not a function"); return; } - nasal_function& ref=vm.gc_get(func_addr).get_func(); - int closure=ref.get_closure_addr(); - nasal_closure& ref_closure=vm.gc_get(closure).get_closure(); + nasal_function& ref=func_addr->get_func(); + nasal_scalar* closure=ref.get_closure_addr(); + nasal_closure& ref_closure=closure->get_closure(); ref_closure.add_scope(); local_scope_stack.push(closure); vm.add_reference(closure); - if(vm.gc_get(para_addr).get_type()==vm_vector) + if(para_addr->get_type()==vm_vector) { - nasal_vector& ref_vec=vm.gc_get(para_addr).get_vector(); + nasal_vector& 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=ref_vec.size()) { - if(ref_default[i]<0) + if(!ref_default[i]) { die("callf: lack argument(s)"); return; @@ -883,18 +869,18 @@ void nasal_bytecode_vm::opr_callf() } else { - int tmp=ref_vec[i]; + nasal_scalar* tmp=ref_vec[i]; ref_closure.add_new_value(ref_para[i],tmp); vm.add_reference(tmp); } } if(ref.get_dynamic_para()>=0) { - int vec_addr=vm.gc_alloc(vm_vector); + nasal_scalar* vec_addr=vm.gc_alloc(vm_vector); for(;iget_vector().add_elem(tmp); vm.add_reference(tmp); } ref_closure.add_new_value(ref.get_dynamic_para(),vec_addr); @@ -902,9 +888,9 @@ void nasal_bytecode_vm::opr_callf() } else { - nasal_hash& ref_hash=vm.gc_get(para_addr).get_hash(); + 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"); @@ -912,10 +898,10 @@ void nasal_bytecode_vm::opr_callf() } for(int i=0;iget_type()==vm_vector) return; die("slcbegin: must slice a vector"); return; @@ -955,20 +941,20 @@ void nasal_bytecode_vm::opr_sliceend() } void nasal_bytecode_vm::opr_slice() { - int val_addr=*value_stack_top--; - int type=vm.gc_get(val_addr).get_type(); + nasal_scalar* val_addr=*value_stack_top--; + int type=val_addr->get_type(); double num; switch(type) { - case vm_number:num=vm.gc_get(val_addr).get_number();break; - case vm_string:num=trans_string_to_number(vm.gc_get(val_addr).get_string());break; + case vm_number:num=val_addr->get_number();break; + case vm_string:num=trans_string_to_number(val_addr->get_string());break; default:die("slc: error value type");break; } - int res=vm.gc_get(*value_stack_top).get_vector().get_value_address((int)num); - if(res>=0) + nasal_scalar* res=(*value_stack_top)->get_vector().get_value_address((int)num); + if(res) { vm.add_reference(res); - vm.gc_get(slice_stack.top()).get_vector().add_elem(res); + (slice_stack.top())->get_vector().add_elem(res); vm.del_reference(val_addr); return; } @@ -977,27 +963,27 @@ void nasal_bytecode_vm::opr_slice() } void nasal_bytecode_vm::opr_slice2() { - int val_addr2=*value_stack_top--; - int val_addr1=*value_stack_top--; - nasal_vector& ref=vm.gc_get(*value_stack_top).get_vector(); - nasal_vector& aim=vm.gc_get(slice_stack.top()).get_vector(); + 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(); - int type1=vm.gc_get(val_addr1).get_type(); + int type1=val_addr1->get_type(); int num1; switch(type1) { case vm_nil:break; - case vm_number:num1=(int)vm.gc_get(val_addr1).get_number();break; - case vm_string:num1=(int)trans_string_to_number(vm.gc_get(val_addr1).get_string());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; default:die("slc2: error value type");break; } - int type2=vm.gc_get(val_addr2).get_type(); + int type2=val_addr2->get_type(); int num2; switch(type2) { case vm_nil:break; - case vm_number:num2=(int)vm.gc_get(val_addr2).get_number();break; - case vm_string:num2=(int)trans_string_to_number(vm.gc_get(val_addr2).get_string());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; default:die("slc2: error value type");break; } int ref_size=ref.size(); @@ -1022,7 +1008,7 @@ void nasal_bytecode_vm::opr_slice2() } for(int i=num1;i<=num2;++i) { - int tmp=ref.get_value_address(i); + nasal_scalar* tmp=ref.get_value_address(i); vm.add_reference(tmp); aim.add_elem(tmp); } @@ -1032,18 +1018,18 @@ void nasal_bytecode_vm::opr_slice2() } void nasal_bytecode_vm::opr_mcall() { - int* mem_addr=NULL; + nasal_scalar** mem_addr=NULL; int name_index=exec_code[ptr].index; - int local_scope_top=local_scope_stack.top(); - if(local_scope_top>=0) - mem_addr=vm.gc_get(local_scope_top).get_closure().get_mem_address(name_index); + nasal_scalar* 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); return; } else - mem_addr=vm.gc_get(global_scope_addr).get_closure().get_mem_address(name_index); + mem_addr=global_scope_addr->get_closure().get_mem_address(name_index); if(mem_addr) { pointer_stack.push(mem_addr); @@ -1054,20 +1040,20 @@ void nasal_bytecode_vm::opr_mcall() } void nasal_bytecode_vm::opr_mcallv() { - int val_addr=*value_stack_top--; - int* vec_addr=pointer_stack.top(); + nasal_scalar* val_addr=*value_stack_top--; + nasal_scalar** vec_addr=pointer_stack.top(); pointer_stack.pop(); - int type=vm.gc_get(*vec_addr).get_type(); + int type=(*vec_addr)->get_type(); if(type==vm_vector) { int num; - switch(vm.gc_get(val_addr).get_type()) + switch(val_addr->get_type()) { - case vm_number:num=(int)vm.gc_get(val_addr).get_number();break; - case vm_string:num=(int)trans_string_to_number(vm.gc_get(val_addr).get_string());break; + case vm_number:num=(int)val_addr->get_number();break; + case vm_string:num=(int)trans_string_to_number(val_addr->get_string());break; default:die("mcallv: error value type");break; } - int* res=vm.gc_get(*vec_addr).get_vector().get_mem_address(num); + nasal_scalar** res=(*vec_addr)->get_vector().get_mem_address(num); if(!res) { die("mcallv: index out of range"); @@ -1077,14 +1063,14 @@ void nasal_bytecode_vm::opr_mcallv() } else if(type==vm_hash) { - if(vm.gc_get(val_addr).get_type()!=vm_string) + if(val_addr->get_type()!=vm_string) { die("mcallv: must use string as the key"); return; } - nasal_hash& ref=vm.gc_get(*vec_addr).get_hash(); - std::string str=vm.gc_get(val_addr).get_string(); - int* res=ref.get_mem_address(str); + nasal_hash& ref=(*vec_addr)->get_hash(); + std::string str=val_addr->get_string(); + nasal_scalar** res=ref.get_mem_address(str); if(!res) { ref.add_elem(str,vm.gc_alloc(vm_nil)); @@ -1102,15 +1088,15 @@ void nasal_bytecode_vm::opr_mcallv() } void nasal_bytecode_vm::opr_mcallh() { - int* mem_addr=NULL; - int* hash_addr=pointer_stack.top(); + nasal_scalar** mem_addr=NULL; + nasal_scalar** hash_addr=pointer_stack.top(); pointer_stack.pop(); - if(vm.gc_get(*hash_addr).get_type()!=vm_hash) + if((*hash_addr)->get_type()!=vm_hash) { die("mcallh: must call a hash"); return; } - nasal_hash& ref=vm.gc_get(*hash_addr).get_hash(); + nasal_hash& ref=(*hash_addr)->get_hash(); std::string str=string_table[exec_code[ptr].index]; mem_addr=ref.get_mem_address(str); if(!mem_addr) @@ -1123,13 +1109,13 @@ void nasal_bytecode_vm::opr_mcallh() } void nasal_bytecode_vm::opr_return() { - int closure_addr=local_scope_stack.top(); + nasal_scalar* closure_addr=local_scope_stack.top(); local_scope_stack.pop(); - vm.gc_get(closure_addr).get_closure().del_scope(); + closure_addr->get_closure().del_scope(); vm.del_reference(closure_addr); ptr=call_stack.top(); call_stack.pop(); - int tmp=*value_stack_top--; + nasal_scalar* tmp=*value_stack_top--; // delete function vm.del_reference(*value_stack_top); *value_stack_top=tmp; diff --git a/nasal_gc.h b/nasal_gc.h index ca5688a..fb4154a 100644 --- a/nasal_gc.h +++ b/nasal_gc.h @@ -21,22 +21,27 @@ nasal_closure: std::list> -> std::map */ class nasal_virtual_machine; +class nasal_vector; +class nasal_hash; +class nasal_function; +class nasal_closure; +class nasal_scalar; class nasal_vector { private: // this int points to the space in nasal_vm::memory_manager_memory nasal_virtual_machine& vm; - std::vector elems; + std::vector elems; public: nasal_vector(nasal_virtual_machine&); ~nasal_vector(); - void add_elem(int); - int del_elem(); + void add_elem(nasal_scalar*); + nasal_scalar* del_elem(); int size(); - int operator[](const int); - int get_value_address(int); - int* get_mem_address(int); + nasal_scalar* operator[](const int); + nasal_scalar* get_value_address(int); + nasal_scalar** get_mem_address(int); void print(); }; @@ -45,18 +50,18 @@ class nasal_hash private: // this int points to the space in nasal_vm::memory_manager_memory nasal_virtual_machine& vm; - std::map elems; + std::map elems; public: nasal_hash(nasal_virtual_machine&); ~nasal_hash(); - void add_elem(std::string,int); + void add_elem(std::string,nasal_scalar*); void del_elem(std::string); int size(); - int get_special_para(std::string); - int get_value_address(std::string); - int* get_mem_address(std::string); + 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); - int get_keys(); + nasal_scalar* get_keys(); void print(); }; @@ -65,21 +70,21 @@ class nasal_function private: nasal_virtual_machine& vm; int entry; - int closure_addr; + nasal_scalar* closure_addr; std::vector para_name; int dynamic_para_name; - std::vector default_para_addr; + std::vector default_para_addr; public: nasal_function(nasal_virtual_machine&); ~nasal_function(); void set_entry(int); int get_entry(); - void add_para(int,int,bool); + void add_para(int,nasal_scalar*,bool); std::vector& get_para(); - int get_dynamic_para(); - std::vector& get_default(); - void set_closure_addr(int); - int get_closure_addr(); + int get_dynamic_para(); + std::vector& get_default(); + void set_closure_addr(nasal_scalar*); + nasal_scalar* get_closure_addr(); }; class nasal_closure @@ -89,15 +94,15 @@ private: // 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; + std::list > elems; public: nasal_closure(nasal_virtual_machine&); ~nasal_closure(); void add_scope(); void del_scope(); - void add_new_value(int,int); - int get_value_address(int); - int* get_mem_address(int); + void add_new_value(int,nasal_scalar*); + nasal_scalar* get_value_address(int); + nasal_scalar** get_mem_address(int); void set_closure(nasal_closure&); }; @@ -117,6 +122,7 @@ protected: public: int ref_cnt; nasal_scalar(); + nasal_scalar(int,nasal_virtual_machine&); ~nasal_scalar(); void clear(); void set_type(int,nasal_virtual_machine&); @@ -137,16 +143,15 @@ class nasal_virtual_machine { private: nasal_scalar error_returned_value; - std::queue garbage_collector_free_space; + std::queue garbage_collector_free_space; std::vector garbage_collector_memory; public: ~nasal_virtual_machine(); void clear(); void debug(); - int gc_alloc(int); // garbage collector gives a new space - nasal_scalar& gc_get(int); // get scalar that stored in gc - void add_reference(int); - void del_reference(int); + nasal_scalar* gc_alloc(int); + void add_reference(nasal_scalar*); + void del_reference(nasal_scalar*); }; /*functions of nasal_vector*/ @@ -162,17 +167,17 @@ nasal_vector::~nasal_vector() elems.clear(); return; } -void nasal_vector::add_elem(int value_address) +void nasal_vector::add_elem(nasal_scalar* value_address) { elems.push_back(value_address); return; } -int nasal_vector::del_elem() +nasal_scalar* nasal_vector::del_elem() { // pop back if(!elems.size()) - return -1; - int ret=elems.back(); + return NULL; + nasal_scalar* ret=elems.back(); elems.pop_back(); return ret; } @@ -180,21 +185,21 @@ int nasal_vector::size() { return elems.size(); } -int nasal_vector::operator[](const int index) +nasal_scalar* nasal_vector::operator[](const int index) { return elems[index]; } -int nasal_vector::get_value_address(int index) +nasal_scalar* nasal_vector::get_value_address(int index) { int vec_size=elems.size(); if(index<-vec_size || index>=vec_size) { std::cout<<">> [runtime] nasal_vector::get_value_address: index out of range: "<=vec_size) @@ -212,15 +217,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_hash: tmp->get_hash().print(); break; + case vm_function: std::cout<<"func(...){...}"; break; } std::cout<<",]"[i==size-1]; } @@ -234,12 +239,12 @@ nasal_hash::nasal_hash(nasal_virtual_machine& nvm):vm(nvm) } nasal_hash::~nasal_hash() { - for(std::map::iterator iter=elems.begin();iter!=elems.end();++iter) + for(std::map::iterator iter=elems.begin();iter!=elems.end();++iter) vm.del_reference(iter->second); elems.clear(); return; } -void nasal_hash::add_elem(std::string key,int value_address) +void nasal_hash::add_elem(std::string key,nasal_scalar* value_address) { if(elems.find(key)==elems.end()) elems[key]=value_address; @@ -258,29 +263,29 @@ int nasal_hash::size() { return elems.size(); } -int nasal_hash::get_special_para(std::string key) +nasal_scalar* nasal_hash::get_special_para(std::string key) { if(elems.find(key)!=elems.end()) return elems[key]; - return -1; + return NULL; } -int nasal_hash::get_value_address(std::string key) +nasal_scalar* nasal_hash::get_value_address(std::string key) { - int ret_value_addr=-1; + nasal_scalar* ret_value_addr=NULL; if(elems.find(key)!=elems.end()) return elems[key]; else if(elems.find("parents")!=elems.end()) { - int val_addr=elems["parents"]; - if(vm.gc_get(val_addr).get_type()==vm_vector) + nasal_scalar* val_addr=elems["parents"]; + if(val_addr->get_type()==vm_vector) { - nasal_vector& vec_ref=vm.gc_get(val_addr).get_vector(); + nasal_vector& 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) break; } @@ -288,23 +293,23 @@ int nasal_hash::get_value_address(std::string key) } return ret_value_addr; } -int* nasal_hash::get_mem_address(std::string key) +nasal_scalar** nasal_hash::get_mem_address(std::string key) { - int* mem_addr=NULL; + nasal_scalar** mem_addr=NULL; if(elems.find(key)!=elems.end()) return &elems[key]; else if(elems.find("parents")!=elems.end()) { - int val_addr=elems["parents"]; - if(vm.gc_get(val_addr).get_type()==vm_vector) + nasal_scalar* val_addr=elems["parents"]; + if(val_addr->get_type()==vm_vector) { - nasal_vector& vec_ref=vm.gc_get(val_addr).get_vector(); + nasal_vector& 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) break; } @@ -319,16 +324,16 @@ bool nasal_hash::check_contain(std::string key) if(elems.find("parents")!=elems.end()) { bool result=false; - int val_addr=elems["parents"]; - if(vm.gc_get(val_addr).get_type()==vm_vector) + nasal_scalar* val_addr=elems["parents"]; + if(val_addr->get_type()==vm_vector) { - nasal_vector& vec_ref=vm.gc_get(val_addr).get_vector(); + nasal_vector& 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) break; } @@ -337,14 +342,14 @@ bool nasal_hash::check_contain(std::string key) } return false; } -int nasal_hash::get_keys() +nasal_scalar* nasal_hash::get_keys() { - int ret_addr=vm.gc_alloc(vm_vector); - nasal_vector& ref_vec=vm.gc_get(ret_addr).get_vector(); - for(std::map::iterator iter=elems.begin();iter!=elems.end();++iter) + 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) { - int str_addr=vm.gc_alloc(vm_string); - vm.gc_get(str_addr).set_string(iter->first); + nasal_scalar* str_addr=vm.gc_alloc(vm_string); + str_addr->set_string(iter->first); ref_vec.add_elem(str_addr); } return ret_addr; @@ -354,18 +359,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=vm.gc_get(i->second); - switch(tmp.get_type()) + nasal_scalar* 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_hash: tmp->get_hash().print(); break; + case vm_function: std::cout<<"func(...){...}"; break; } std::cout<<",}"[(++i)==elems.end()]; --i; @@ -376,13 +381,13 @@ void nasal_hash::print() /*functions of nasal_function*/ nasal_function::nasal_function(nasal_virtual_machine& nvm):vm(nvm) { - closure_addr=-1; + closure_addr=NULL; dynamic_para_name=-1; return; } nasal_function::~nasal_function() { - if(closure_addr>=0) + if(closure_addr) vm.del_reference(closure_addr); for(int i=0;i=0) @@ -398,7 +403,7 @@ int nasal_function::get_entry() { return entry; } -void nasal_function::add_para(int name_index,int val_addr=-1,bool is_dynamic=false) +void nasal_function::add_para(int name_index,nasal_scalar* val_addr=NULL,bool is_dynamic=false) { if(is_dynamic) { @@ -417,20 +422,20 @@ int nasal_function::get_dynamic_para() { return dynamic_para_name; } -std::vector& nasal_function::get_default() +std::vector& nasal_function::get_default() { return default_para_addr; } -void nasal_function::set_closure_addr(int value_address) +void nasal_function::set_closure_addr(nasal_scalar* value_address) { - if(closure_addr>=0) + if(closure_addr) vm.del_reference(closure_addr); - int new_closure=vm.gc_alloc(vm_closure); - vm.gc_get(new_closure).get_closure().set_closure(vm.gc_get(value_address).get_closure()); + nasal_scalar* new_closure=vm.gc_alloc(vm_closure); + new_closure->get_closure().set_closure(value_address->get_closure()); closure_addr=new_closure; return; } -int nasal_function::get_closure_addr() +nasal_scalar* nasal_function::get_closure_addr() { return closure_addr; } @@ -438,72 +443,72 @@ int nasal_function::get_closure_addr() /*functions of nasal_closure*/ nasal_closure::nasal_closure(nasal_virtual_machine& nvm):vm(nvm) { - std::map new_scope; + std::map new_scope; elems.push_back(new_scope); return; } nasal_closure::~nasal_closure() { - for(std::list >::iterator i=elems.begin();i!=elems.end();++i) - for(std::map::iterator j=i->begin();j!=i->end();++j) + 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); elems.clear(); return; } void nasal_closure::add_scope() { - std::map new_scope; + std::map new_scope; elems.push_back(new_scope); return; } void nasal_closure::del_scope() { - std::map& last_scope=elems.back(); - for(std::map::iterator i=last_scope.begin();i!=last_scope.end();++i) + std::map& last_scope=elems.back(); + for(std::map::iterator i=last_scope.begin();i!=last_scope.end();++i) vm.del_reference(i->second); elems.pop_back(); return; } -void nasal_closure::add_new_value(int key,int value_address) +void nasal_closure::add_new_value(int key,nasal_scalar* value_address) { if(elems.back().find(key)!=elems.back().end()) { // if this value already exists,delete the old value and update a new value - int old_val_address=elems.back()[key]; + nasal_scalar* old_val_address=elems.back()[key]; vm.del_reference(old_val_address); } elems.back()[key]=value_address; return; } -int nasal_closure::get_value_address(int key) +nasal_scalar* nasal_closure::get_value_address(int key) { - int ret_address=-1; - for(std::list >::iterator i=elems.begin();i!=elems.end();++i) + nasal_scalar* ret_address=NULL; + for(std::list >::iterator i=elems.begin();i!=elems.end();++i) if(i->find(key)!=i->end()) ret_address=(*i)[key]; return ret_address; } -int* nasal_closure::get_mem_address(int key) +nasal_scalar** nasal_closure::get_mem_address(int key) { - int* ret_address=NULL; - for(std::list >::iterator i=elems.begin();i!=elems.end();++i) + nasal_scalar** ret_address=NULL; + for(std::list >::iterator i=elems.begin();i!=elems.end();++i) if(i->find(key)!=i->end()) ret_address=&((*i)[key]); return ret_address; } void nasal_closure::set_closure(nasal_closure& tmp) { - for(std::list >::iterator i=elems.begin();i!=elems.end();++i) - for(std::map::iterator j=i->begin();j!=i->end();++j) + 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); 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) { - int value_addr=j->second; + nasal_scalar* value_addr=j->second; vm.add_reference(value_addr); elems.back()[j->first]=value_addr; } @@ -514,9 +519,26 @@ void nasal_closure::set_closure(nasal_closure& tmp) /*functions of nasal_scalar*/ nasal_scalar::nasal_scalar() { + ref_cnt=1; type=vm_nil; return; } +nasal_scalar::nasal_scalar(int nasal_scalar_type,nasal_virtual_machine& nvm) +{ + ref_cnt=1; + type=nasal_scalar_type; + switch(nasal_scalar_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; + } + return; +} nasal_scalar::~nasal_scalar() { // must set type and scalar_ptr to default first @@ -635,8 +657,7 @@ nasal_virtual_machine::~nasal_virtual_machine() { int gc_mem_size=garbage_collector_memory.size(); for(int i=0;iref_cnt) - garbage_collector_memory[i]->clear(); + garbage_collector_memory[i]->clear(); for(int i=0;iref_cnt) - garbage_collector_memory[i]->clear(); + garbage_collector_memory[i]->clear(); for(int i=0;iref_cnt=1; - new_unit->set_type(val_type,*this); - return ret; + return new_unit; } - int ret=garbage_collector_free_space.front(); - nasal_scalar& unit_ref=*garbage_collector_memory[ret]; - unit_ref.ref_cnt=1; - unit_ref.set_type(val_type,*this); + nasal_scalar* ret=garbage_collector_free_space.front(); garbage_collector_free_space.pop(); + ret->ref_cnt=1; + ret->set_type(val_type,*this); return ret; } -nasal_scalar& nasal_virtual_machine::gc_get(int value_address) +void nasal_virtual_machine::add_reference(nasal_scalar* value_address) { - if(value_address>=0) - return *garbage_collector_memory[value_address]; - return error_returned_value; -} -void nasal_virtual_machine::add_reference(int value_address) -{ - if(value_address>=0) - ++garbage_collector_memory[value_address]->ref_cnt; + if(value_address) + ++value_address->ref_cnt; return; } -void nasal_virtual_machine::del_reference(int value_address) +void nasal_virtual_machine::del_reference(nasal_scalar* value_address) { - if(value_address>=0) - --garbage_collector_memory[value_address]->ref_cnt; + if(value_address) + --value_address->ref_cnt; else return; - if(!garbage_collector_memory[value_address]->ref_cnt) + if(!value_address->ref_cnt) { - garbage_collector_memory[value_address]->clear(); + value_address->clear(); garbage_collector_free_space.push(value_address); } return; diff --git a/nasal_lexer.h b/nasal_lexer.h index ed9d5bd..4e4dd64 100644 --- a/nasal_lexer.h +++ b/nasal_lexer.h @@ -89,6 +89,7 @@ struct token int line; int type; std::string str; + token(int l=0,int t=tok_null,std::string s=""){line=l;type=t;str=s;return;} }; class nasal_lexer @@ -116,10 +117,7 @@ public: void nasal_lexer::clear() { - error=0; - res_size=0; - line=0; - ptr=0; + error=res_size=line=ptr=0; line_code=""; res.clear(); token_list.clear(); @@ -243,8 +241,6 @@ std::string nasal_lexer::number_gen() die("["+line_code+"_] incorrect number.",line,line_code.length()); return "0"; } - if(ptr=res_size) + if(ptr++>=res_size) die("["+line_code+"_] get EOF when generating string.",line,line_code.length()); - ++ptr; return token_str; } @@ -318,21 +312,17 @@ void nasal_lexer::scanner() { // these characters will be ignored, and '\n' will cause ++line line_code+=res[ptr]; - if(res[ptr]=='\n') + if(res[ptr++]=='\n') { ++line; line_code=""; } - ++ptr; } if(ptr>=res_size) break; if(IS_IDENTIFIER(res[ptr])) { token_str=identifier_gen(); - token new_token; - new_token.line=line; - new_token.str=token_str; - new_token.type=0; + token new_token(line,0,token_str); for(int i=0;token_table[i].str;++i) if(token_str==token_table[i].str) { @@ -346,19 +336,13 @@ void nasal_lexer::scanner() else if(IS_DIGIT(res[ptr])) { token_str=number_gen(); - token new_token; - new_token.line=line; - new_token.str=token_str; - new_token.type=tok_number; + token new_token(line,tok_number,token_str); token_list.push_back(new_token); } else if(IS_STRING(res[ptr])) { token_str=string_gen(); - token new_token; - new_token.line=line; - new_token.type=tok_string; - new_token.str=token_str; + token new_token(line,tok_string,token_str); token_list.push_back(new_token); } else if(IS_SINGLE_OPRATOR(res[ptr])) @@ -366,10 +350,7 @@ void nasal_lexer::scanner() token_str=""; token_str+=res[ptr]; line_code+=res[ptr]; - token new_token; - new_token.line=line; - new_token.str=token_str; - new_token.type=-1; + token new_token(line,-1,token_str); for(int i=0;token_table[i].str;++i) if(token_str==token_table[i].str) { @@ -394,9 +375,7 @@ void nasal_lexer::scanner() ++ptr; } line_code+=token_str; - token new_token; - new_token.line=line; - new_token.str=token_str; + token new_token(line,-1,token_str); for(int i=0;token_table[i].str;++i) if(token_str==token_table[i].str) { @@ -410,15 +389,10 @@ void nasal_lexer::scanner() // get calculation operator token_str=res[ptr]; ++ptr; - if(ptrerror; + return error; } void nasal_parse::clear() { - this->tok_list_size=0; - this->ptr=0; - this->error=0; - this->in_function=0; - this->in_loop=0; - this->tok_list.clear(); - this->root.clear(); + tok_list_size=ptr=error=in_function=in_loop=0; + tok_list.clear(); + root.clear(); return; } void nasal_parse::set_toklist(std::vector& lex_token) { - this->tok_list=lex_token; - this->tok_list_size=this->tok_list.size(); + tok_list=lex_token; + tok_list_size=tok_list.size(); return; } void nasal_parse::main_process() { - this->reset(); + reset(); root.set_line(1); root.set_type(ast_root); while(ptr=tok_list_size) + if(++ptr>=tok_list_size) break; if(tok_list[ptr].type==tok_semi) ++ptr; @@ -152,10 +147,7 @@ void nasal_parse::main_process() { int type=root.get_children().back().get_type(); if(type==ast_continue || type==ast_break || type==ast_return) - { - ++error; die(root.get_children().back().get_line(),ast_str(type)+" is not allowed in main scope"); - } } } return; @@ -168,11 +160,8 @@ nasal_ast& nasal_parse::get_root() void nasal_parse::reset() { - this->ptr=0; - this->in_function=0; - this->in_loop=0; - this->error=0; - this->root.clear(); + ptr=in_function=in_loop=error=0; + root.clear(); return; } @@ -185,7 +174,7 @@ void nasal_parse::die(int line,std::string info) if(tok_list[ptr].type==tok_semi) { --ptr; - break; + return; } ++ptr; } @@ -199,7 +188,6 @@ bool nasal_parse::check_multi_definition() bool nasal_parse::check_multi_scalar() { - bool ret=false; int check_ptr=ptr+1,curve_cnt=1,bracket_cnt=0,brace_cnt=0; while(check_ptr=tok_list_size) + if(++ptr>=tok_list_size) break; if(tok_list[ptr].type==tok_comma) ++ptr; @@ -348,8 +324,7 @@ nasal_ast nasal_parse::hash_gen() while (ptr=tok_list_size) + if(++ptr>=tok_list_size) break; if(tok_list[ptr].type==tok_comma) ++ptr; @@ -384,8 +359,7 @@ nasal_ast nasal_parse::hash_member_gen() nasal_ast nasal_parse::func_gen() { nasal_ast node(tok_list[ptr].line,ast_function); - ++ptr; - if(ptr>=tok_list_size) + if(++ptr>=tok_list_size) { die(error_line,"expected \"(\""); return node; @@ -444,8 +418,7 @@ nasal_ast nasal_parse::args_list_gen() --ptr; node.add_child(tmp); } - ++ptr; - if(ptr>=tok_list_size) + if(++ptr>=tok_list_size) break; if(tok_list[ptr].type==tok_comma) ++ptr; @@ -556,8 +529,7 @@ nasal_ast nasal_parse::exprs_gen() while(ptr=tok_list_size) + if(++ptr>=tok_list_size) break; else if(tok_list[ptr].type==tok_semi) ++ptr; @@ -661,8 +633,7 @@ nasal_ast nasal_parse::or_expr() { nasal_ast tmp(tok_list[ptr].line,ast_or); tmp.add_child(node); - ++ptr; - if(ptr=tok_list_size) + if(++ptr>=tok_list_size) break; else if(tok_list[ptr].type==tok_comma) ++ptr; @@ -1206,8 +1171,7 @@ nasal_ast nasal_parse::call_func() while(ptr=tok_list_size) + if(++ptr>=tok_list_size) break; else if(tok_list[ptr].type==tok_comma) ++ptr; @@ -1230,8 +1194,7 @@ nasal_ast nasal_parse::subvec() ++ptr; if(ptr=tok_list_size) + if(++ptr>=tok_list_size) return node; nasal_ast tmp(node.get_line(),ast_subvec); tmp.add_child(node); @@ -1271,8 +1234,7 @@ nasal_ast nasal_parse::definition() die(error_line,"expected \"=\" / don\'t call identifier in definition"); return node; } - ++ptr; - if(ptr>=tok_list_size) + if(++ptr>=tok_list_size) { die(error_line,"expected scalar"); return node; @@ -1293,8 +1255,7 @@ nasal_ast nasal_parse::definition() nasal_ast nasal_parse::var_incurve_def() { nasal_ast node; - ++ptr;// check_multi_definition will check the 'var' - ++ptr; + ptr+=2;// check_multi_definition will check the 'var' if(ptr>=tok_list_size || tok_list[ptr].type!=tok_identifier) { die(error_line,"expected identifier"); @@ -1359,8 +1320,7 @@ nasal_ast nasal_parse::multi_scalar(bool check_call_memory) int type=node.get_children().back().get_type(); if(check_call_memory && type!=ast_call && type!=ast_identifier) die(node.get_children().back().get_line(),"cannot use calculation as the memory of scalar"); - ++ptr; - if(ptr>=tok_list_size) + if(++ptr>=tok_list_size) break; if(tok_list[ptr].type==tok_comma) ++ptr; @@ -1381,8 +1341,7 @@ nasal_ast nasal_parse::multi_assgin() die(error_line,"expected \"=\""); return node; } - ++ptr; - if(ptr>=tok_list_size) + if(++ptr>=tok_list_size) { die(error_line,"expected value list"); return node; @@ -1470,8 +1429,7 @@ nasal_ast nasal_parse::for_loop() return node; } // conditional expression - ++ptr; - if(ptr>=tok_list_size) + if(++ptr>=tok_list_size) { die(error_line,"expected conditional expression"); return node; @@ -1490,8 +1448,7 @@ nasal_ast nasal_parse::for_loop() return node; } //after loop expression - ++ptr; - if(ptr>=tok_list_size) + if(++ptr>=tok_list_size) { die(error_line,"expected calculation"); return node; @@ -1542,8 +1499,7 @@ nasal_ast nasal_parse::forei_loop() die(error_line,"expected \";\""); return node; } - ++ptr; - if(ptr>=tok_list_size) + if(++ptr>=tok_list_size) { die(error_line,"expected vector"); return node; @@ -1669,8 +1625,7 @@ nasal_ast nasal_parse::break_expr() nasal_ast nasal_parse::return_expr() { nasal_ast node(tok_list[ptr].line,ast_return); - ++ptr; - if(ptr