From 33e544387eb014491cde2337e79a7e06db1f403c Mon Sep 17 00:00:00 2001 From: Valk Richard Li <48872266+ValKmjolnir@users.noreply.github.com> Date: Tue, 1 Dec 2020 19:35:32 +0800 Subject: [PATCH] update --- nasal_builtin.h | 146 ++++----- nasal_gc.h | 787 ++++++++++-------------------------------------- nasal_runtime.h | 499 ++++++++++++++++++++++++++++-- 3 files changed, 705 insertions(+), 727 deletions(-) diff --git a/nasal_builtin.h b/nasal_builtin.h index b92862b..d4aeca2 100644 --- a/nasal_builtin.h +++ b/nasal_builtin.h @@ -18,50 +18,50 @@ // declaration of builtin functions // to add new builtin function,declare it here and write the definition below -int builtin_print(int); -int builtin_append(int); -int builtin_setsize(int); -int builtin_system(int); -int builtin_input(int); -int builtin_sleep(int); -int builtin_finput(int); -int builtin_foutput(int); -int builtin_split(int); -int builtin_rand(int); -int builtin_id(int); -int builtin_int(int); -int builtin_num(int); -int builtin_pop(int); -int builtin_str(int); -int builtin_size(int); -int builtin_xor(int); -int builtin_and(int); -int builtin_or(int); -int builtin_nand(int); -int builtin_not(int); -int builtin_sin(int); -int builtin_cos(int); -int builtin_tan(int); -int builtin_exp(int); -int builtin_ln(int); -int builtin_sqrt(int); -int builtin_atan2(int); -int builtin_time(int); -int builtin_contains(int); -int builtin_delete(int); -int builtin_getkeys(int); -int builtin_import(int); +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&); int builtin_die_state;// used in builtin_die -int builtin_die(int); -int builtin_type(int); -int builtin_substr(int); +int builtin_die(int,nasal_virtual_machine&); +int builtin_type(int,nasal_virtual_machine&); +int builtin_substr(int,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); + int (*func_pointer)(int x,nasal_virtual_machine& nasal_vm); } builtin_func_table[]= { {"nasal_call_builtin_std_cout", builtin_print}, @@ -103,7 +103,7 @@ struct FUNC_TABLE {"", NULL} }; -int builtin_print(int local_scope_addr) +int builtin_print(int local_scope_addr,nasal_virtual_machine& nasal_vm) { // get arguments int vector_value_addr=in_builtin_find("elements"); @@ -133,7 +133,7 @@ int builtin_print(int local_scope_addr) int ret_addr=nasal_vm.gc_alloc(vm_nil); return ret_addr; } -int builtin_append(int local_scope_addr) +int builtin_append(int local_scope_addr,nasal_virtual_machine& nasal_vm) { int vector_value_addr=in_builtin_find("vector"); int elem_value_addr=in_builtin_find("elements"); @@ -159,7 +159,7 @@ int builtin_append(int local_scope_addr) int ret_addr=nasal_vm.gc_alloc(vm_nil); return ret_addr; } -int builtin_setsize(int local_scope_addr) +int builtin_setsize(int local_scope_addr,nasal_virtual_machine& nasal_vm) { int vector_value_addr=in_builtin_find("vector"); int size_value_addr=in_builtin_find("size"); @@ -217,7 +217,7 @@ int builtin_setsize(int local_scope_addr) return ret_addr; } -int builtin_system(int local_scope_addr) +int builtin_system(int local_scope_addr,nasal_virtual_machine& nasal_vm) { int str_value_addr=in_builtin_find("str"); if(str_value_addr<0 || nasal_vm.gc_get(str_value_addr).get_type()!=vm_string) @@ -237,7 +237,7 @@ int builtin_system(int local_scope_addr) return ret_addr; } -int builtin_input(int local_scope_addr) +int builtin_input(int local_scope_addr,nasal_virtual_machine& nasal_vm) { int ret_addr=nasal_vm.gc_alloc(vm_string); std::string str; @@ -246,7 +246,7 @@ int builtin_input(int local_scope_addr) return ret_addr; } -int builtin_sleep(int local_scope_addr) +int builtin_sleep(int 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)) @@ -272,7 +272,7 @@ int builtin_sleep(int local_scope_addr) return ret_addr; } -int builtin_finput(int local_scope_addr) +int builtin_finput(int 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) @@ -299,7 +299,7 @@ int builtin_finput(int local_scope_addr) return ret_addr; } -int builtin_foutput(int local_scope_addr) +int builtin_foutput(int local_scope_addr,nasal_virtual_machine& nasal_vm) { int value_addr=in_builtin_find("filename"); int str_value_addr=in_builtin_find("str"); @@ -322,7 +322,7 @@ int builtin_foutput(int local_scope_addr) return ret_addr; } -int builtin_split(int local_scope_addr) +int builtin_split(int local_scope_addr,nasal_virtual_machine& nasal_vm) { int delimeter_value_addr=in_builtin_find("delimeter"); int string_value_addr=in_builtin_find("string"); @@ -389,7 +389,7 @@ int builtin_split(int local_scope_addr) } return ret_addr; } -int builtin_rand(int local_scope_addr) +int builtin_rand(int 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)) @@ -411,7 +411,7 @@ int builtin_rand(int local_scope_addr) nasal_vm.gc_get(ret_addr).set_number(num); return ret_addr; } -int builtin_id(int local_scope_addr) +int builtin_id(int local_scope_addr,nasal_virtual_machine& nasal_vm) { int value_addr=in_builtin_find("thing"); if(value_addr<0) @@ -423,7 +423,7 @@ int builtin_id(int local_scope_addr) nasal_vm.gc_get(ret_addr).set_number((double)value_addr); return ret_addr; } -int builtin_int(int local_scope_addr) +int builtin_int(int 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) @@ -436,7 +436,7 @@ int builtin_int(int local_scope_addr) nasal_vm.gc_get(ret_addr).set_number((double)number); return ret_addr; } -int builtin_num(int local_scope_addr) +int builtin_num(int 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)) @@ -449,7 +449,7 @@ int builtin_num(int local_scope_addr) nasal_vm.gc_get(ret_addr).set_number(trans_string_to_number(str)); return ret_addr; } -int builtin_pop(int local_scope_addr) +int builtin_pop(int 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) @@ -460,7 +460,7 @@ int builtin_pop(int local_scope_addr) int ret_addr=nasal_vm.gc_get(value_addr).get_vector().del_elem(); return ret_addr; } -int builtin_str(int local_scope_addr) +int builtin_str(int 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) @@ -473,7 +473,7 @@ int builtin_str(int local_scope_addr) nasal_vm.gc_get(ret_addr).set_string(trans_number_to_string(number)); return ret_addr; } -int builtin_size(int local_scope_addr) +int builtin_size(int local_scope_addr,nasal_virtual_machine& nasal_vm) { int value_addr=in_builtin_find("object"); if(value_addr<0) @@ -503,7 +503,7 @@ int builtin_size(int local_scope_addr) } return ret_addr; } -int builtin_xor(int local_scope_addr) +int builtin_xor(int local_scope_addr,nasal_virtual_machine& nasal_vm) { int a_addr=in_builtin_find("a"); int b_addr=in_builtin_find("b"); @@ -523,7 +523,7 @@ int builtin_xor(int local_scope_addr) nasal_vm.gc_get(ret_addr).set_number((double)(number_a^number_b)); return ret_addr; } -int builtin_and(int local_scope_addr) +int builtin_and(int local_scope_addr,nasal_virtual_machine& nasal_vm) { int a_addr=in_builtin_find("a"); int b_addr=in_builtin_find("b"); @@ -543,7 +543,7 @@ int builtin_and(int local_scope_addr) nasal_vm.gc_get(ret_addr).set_number((double)(number_a&number_b)); return ret_addr; } -int builtin_or(int local_scope_addr) +int builtin_or(int local_scope_addr,nasal_virtual_machine& nasal_vm) { int a_addr=in_builtin_find("a"); int b_addr=in_builtin_find("b"); @@ -563,7 +563,7 @@ int builtin_or(int local_scope_addr) nasal_vm.gc_get(ret_addr).set_number((double)(number_a|number_b)); return ret_addr; } -int builtin_nand(int local_scope_addr) +int builtin_nand(int local_scope_addr,nasal_virtual_machine& nasal_vm) { int a_addr=in_builtin_find("a"); int b_addr=in_builtin_find("b"); @@ -583,7 +583,7 @@ int builtin_nand(int local_scope_addr) nasal_vm.gc_get(ret_addr).set_number((double)(~(number_a&number_b))); return ret_addr; } -int builtin_not(int local_scope_addr) +int builtin_not(int 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) @@ -596,7 +596,7 @@ int builtin_not(int local_scope_addr) nasal_vm.gc_get(ret_addr).set_number((double)(~number)); return ret_addr; } -int builtin_sin(int local_scope_addr) +int builtin_sin(int 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) @@ -609,7 +609,7 @@ int builtin_sin(int local_scope_addr) nasal_vm.gc_get(ret_addr).set_number(sin(number)); return ret_addr; } -int builtin_cos(int local_scope_addr) +int builtin_cos(int 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) @@ -622,7 +622,7 @@ int builtin_cos(int local_scope_addr) nasal_vm.gc_get(ret_addr).set_number(cos(number)); return ret_addr; } -int builtin_tan(int local_scope_addr) +int builtin_tan(int 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) @@ -635,7 +635,7 @@ int builtin_tan(int local_scope_addr) nasal_vm.gc_get(ret_addr).set_number(tan(number)); return ret_addr; } -int builtin_exp(int local_scope_addr) +int builtin_exp(int 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) @@ -648,7 +648,7 @@ int builtin_exp(int local_scope_addr) nasal_vm.gc_get(ret_addr).set_number(exp(number)); return ret_addr; } -int builtin_ln(int local_scope_addr) +int builtin_ln(int 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) @@ -661,7 +661,7 @@ int builtin_ln(int local_scope_addr) nasal_vm.gc_get(ret_addr).set_number(log(number)/log(2.7182818284590452354)); return ret_addr; } -int builtin_sqrt(int local_scope_addr) +int builtin_sqrt(int 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) @@ -674,7 +674,7 @@ int builtin_sqrt(int local_scope_addr) nasal_vm.gc_get(ret_addr).set_number(sqrt(number)); return ret_addr; } -int builtin_atan2(int local_scope_addr) +int builtin_atan2(int local_scope_addr,nasal_virtual_machine& nasal_vm) { int x_value_addr=in_builtin_find("x"); int y_value_addr=in_builtin_find("y"); @@ -694,7 +694,7 @@ int builtin_atan2(int local_scope_addr) nasal_vm.gc_get(ret_addr).set_number(atan2(y,x)); return ret_addr; } -int builtin_time(int local_scope_addr) +int builtin_time(int 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) @@ -707,7 +707,7 @@ int builtin_time(int local_scope_addr) nasal_vm.gc_get(ret_addr).set_number((double)time(&begin_time)); return ret_addr; } -int builtin_contains(int local_scope_addr) +int builtin_contains(int local_scope_addr,nasal_virtual_machine& nasal_vm) { int hash_addr=in_builtin_find("hash"); int key_addr=in_builtin_find("key"); @@ -727,7 +727,7 @@ int builtin_contains(int local_scope_addr) nasal_vm.gc_get(ret_addr).set_number((double)contains); return ret_addr; } -int builtin_delete(int local_scope_addr) +int builtin_delete(int local_scope_addr,nasal_virtual_machine& nasal_vm) { int hash_addr=in_builtin_find("hash"); int key_addr=in_builtin_find("key"); @@ -746,7 +746,7 @@ int builtin_delete(int local_scope_addr) int ret_addr=nasal_vm.gc_alloc(vm_nil); return ret_addr; } -int builtin_getkeys(int local_scope_addr) +int builtin_getkeys(int 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)) @@ -757,7 +757,7 @@ int builtin_getkeys(int local_scope_addr) int ret_addr=nasal_vm.gc_get(hash_addr).get_hash().get_keys(); return ret_addr; } -int builtin_import(int local_scope_addr) +int builtin_import(int local_scope_addr,nasal_virtual_machine& nasal_vm) { // this function is used in preprocessing. // this function will return nothing when running. @@ -765,7 +765,7 @@ int builtin_import(int local_scope_addr) int ret_addr=nasal_vm.gc_alloc(vm_nil); return ret_addr; } -int builtin_die(int local_scope_addr) +int builtin_die(int 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)) @@ -778,7 +778,7 @@ int builtin_die(int local_scope_addr) int ret_addr=nasal_vm.gc_alloc(vm_nil); return ret_addr; } -int builtin_type(int local_scope_addr) +int builtin_type(int local_scope_addr,nasal_virtual_machine& nasal_vm) { int value_addr=in_builtin_find("object"); if(value_addr<0) @@ -799,7 +799,7 @@ int builtin_type(int local_scope_addr) } return ret_addr; } -int builtin_substr(int local_scope_addr) +int builtin_substr(int local_scope_addr,nasal_virtual_machine& nasal_vm) { int str_addr=in_builtin_find("str"); int begin_addr=in_builtin_find("begin"); diff --git a/nasal_gc.h b/nasal_gc.h index 5ccdcbf..3240bd7 100644 --- a/nasal_gc.h +++ b/nasal_gc.h @@ -23,14 +23,18 @@ nasal_function: closure -> value address in gc(type: nasal_closure) nasal_closure: std::list> -> std::map -> (int) -> address in memory -> value address in gc */ +class nasal_virtual_machine; + class nasal_vector { private: // this int points to the space in nasal_vm::memory_manager_memory + nasal_virtual_machine& vm; std::vector elems; public: - nasal_vector(); + nasal_vector(nasal_virtual_machine&); ~nasal_vector(); + void set_vm(nasal_virtual_machine&); void add_elem(int); int del_elem(); int size(); @@ -43,10 +47,12 @@ class nasal_hash { private: // this int points to the space in nasal_vm::memory_manager_memory + nasal_virtual_machine& vm; std::map elems; public: - nasal_hash(); + nasal_hash(nasal_virtual_machine&); ~nasal_hash(); + void set_vm(nasal_virtual_machine&); void add_elem(std::string,int); void del_elem(std::string); int size(); @@ -61,12 +67,14 @@ class nasal_function { private: // this int points to the space in nasal_vm::garbage_collector_memory + nasal_virtual_machine& vm; int closure_addr; nasal_ast argument_list; nasal_ast function_expr; public: - nasal_function(); + nasal_function(nasal_virtual_machine&); ~nasal_function(); + void set_vm(nasal_virtual_machine&); void set_closure_addr(int); int get_closure_addr(); void set_arguments(nasal_ast&); @@ -81,10 +89,12 @@ private: // int in std::map points to the space in nasal_vm::memory_manager_memory // and this memory_manager_memory space stores an address to garbage_collector_memory // and this address points to an nasal_hash + nasal_virtual_machine& vm; std::list > elems; public: - nasal_closure(); + nasal_closure(nasal_virtual_machine&); ~nasal_closure(); + void set_vm(nasal_virtual_machine&); void add_scope(); void del_scope(); void add_new_value(std::string,int); @@ -95,14 +105,14 @@ public: class nasal_scalar { -private: +protected: int type; void* scalar_ptr; public: nasal_scalar(); ~nasal_scalar(); void clear(); - void set_type(int); + void set_type(int,nasal_virtual_machine&); void set_number(double); void set_string(std::string); int get_type(); @@ -112,20 +122,6 @@ public: nasal_hash& get_hash(); nasal_function& get_func(); nasal_closure& get_closure(); - // parameter: memory_manager_memory address - int nasal_scalar_add(int,int); - int nasal_scalar_sub(int,int); - int nasal_scalar_mult(int,int); - int nasal_scalar_div(int,int); - int nasal_scalar_link(int,int); - int nasal_scalar_unary_sub(int); - int nasal_scalar_unary_not(int); - int nasal_scalar_cmp_equal(int,int); - int nasal_scalar_cmp_not_equal(int,int); - int nasal_scalar_cmp_less(int,int); - int nasal_scalar_cmp_greater(int,int); - int nasal_scalar_cmp_less_or_equal(int,int); - int nasal_scalar_cmp_greater_or_equal(int,int); }; class nasal_virtual_machine @@ -147,7 +143,7 @@ private: std::queue garbage_collector_free_space; std::vector garbage_collector_memory; std::queue memory_manager_free_space; - std::vector memory_manager_memory; + std::vector memory_manager_memory; public: nasal_virtual_machine(); ~nasal_virtual_machine(); @@ -163,36 +159,27 @@ public: int mem_get(int); // get value in memory space }; -/* - nasal runtime virtual machine - nasal_scalar_calculator gives functions that calculate nasal_scalar - example: nasal_scalar_calculator.nasal_scalar_add(0x00007c00,0x0000aa55) -*/ -nasal_virtual_machine nasal_vm; -nasal_scalar nasal_scalar_calculator; -// error values set here,if defined before nasal_vm,SIGSEGV will occur. -nasal_vector error_vector; -nasal_hash error_hash; -nasal_function error_function; -nasal_closure error_closure; - /*functions of nasal_vector*/ -nasal_vector::nasal_vector() +nasal_vector::nasal_vector(nasal_virtual_machine& nvm):vm(nvm) { - elems.clear(); return; } nasal_vector::~nasal_vector() { int size=elems.size(); for(int i=0;ielems.size(); + return elems.size(); } int nasal_vector::get_value_address(int index) { @@ -221,7 +208,7 @@ int nasal_vector::get_value_address(int index) std::cout<<">> [runtime] nasal_vector::get_value_address: index out of range: "<::iterator iter=elems.begin();iter!=elems.end();++iter) - nasal_vm.mem_free(iter->second); + vm.mem_free(iter->second); elems.clear(); return; } +void nasal_hash::set_vm(nasal_virtual_machine& nvm) +{ + vm=nvm; + return; +} void nasal_hash::add_elem(std::string key,int value_address) { if(elems.find(key)==elems.end()) { - int memory_address=nasal_vm.mem_alloc(value_address); + int memory_address=vm.mem_alloc(value_address); elems[key]=memory_address; } return; @@ -284,7 +275,7 @@ void nasal_hash::del_elem(std::string key) { if(elems.find(key)!=elems.end()) { - nasal_vm.mem_free(elems[key]); + vm.mem_free(elems[key]); elems.erase(key); } return; @@ -297,20 +288,20 @@ int nasal_hash::get_value_address(std::string key) { int ret_value_addr=-1; if(elems.find(key)!=elems.end()) - return nasal_vm.mem_get(elems[key]); + return vm.mem_get(elems[key]); else if(elems.find("parents")!=elems.end()) { int mem_addr=elems["parents"]; - int val_addr=nasal_vm.mem_get(mem_addr); - if(nasal_vm.gc_get(val_addr).get_type()==vm_vector) + int val_addr=vm.mem_get(mem_addr); + if(vm.gc_get(val_addr).get_type()==vm_vector) { - nasal_vector& vec_ref=nasal_vm.gc_get(val_addr).get_vector(); + nasal_vector& vec_ref=vm.gc_get(val_addr).get_vector(); int size=vec_ref.size(); for(int i=0;i=0) break; } @@ -328,16 +319,16 @@ int nasal_hash::get_mem_address(std::string key) else if(elems.find("parents")!=elems.end()) { int mem_addr=elems["parents"]; - int val_addr=nasal_vm.mem_get(mem_addr); - if(nasal_vm.gc_get(val_addr).get_type()==vm_vector) + int val_addr=vm.mem_get(mem_addr); + if(vm.gc_get(val_addr).get_type()==vm_vector) { - nasal_vector& vec_ref=nasal_vm.gc_get(val_addr).get_vector(); + nasal_vector& vec_ref=vm.gc_get(val_addr).get_vector(); int size=vec_ref.size(); for(int i=0;i=0) break; } @@ -345,8 +336,8 @@ int nasal_hash::get_mem_address(std::string key) } else { - int val_addr=nasal_vm.gc_alloc(vm_nil); - int mem_addr=nasal_vm.mem_alloc(val_addr); + int val_addr=vm.gc_alloc(vm_nil); + int mem_addr=vm.mem_alloc(val_addr); elems[key]=mem_addr; ret_mem_addr=mem_addr; } @@ -360,16 +351,16 @@ bool nasal_hash::check_contain(std::string key) { bool result=false; int mem_addr=elems["parents"]; - int val_addr=nasal_vm.mem_get(mem_addr); - if(nasal_vm.gc_get(val_addr).get_type()==vm_vector) + int val_addr=vm.mem_get(mem_addr); + if(vm.gc_get(val_addr).get_type()==vm_vector) { - nasal_vector& vec_ref=nasal_vm.gc_get(val_addr).get_vector(); + nasal_vector& vec_ref=vm.gc_get(val_addr).get_vector(); int size=vec_ref.size(); for(int i=0;i::iterator iter=elems.begin();iter!=elems.end();++iter) { - int str_addr=nasal_vm.gc_alloc(vm_string); - nasal_vm.gc_get(str_addr).set_string(iter->first); + int str_addr=vm.gc_alloc(vm_string); + vm.gc_get(str_addr).set_string(iter->first); ref_vec.add_elem(str_addr); } return ret_addr; @@ -398,7 +389,7 @@ void nasal_hash::print() for(std::map::iterator i=elems.begin();i!=elems.end();++i) { std::cout<first<<":"; - nasal_scalar& tmp=nasal_vm.gc_get(nasal_vm.mem_get(i->second)); + nasal_scalar& tmp=vm.gc_get(vm.mem_get(i->second)); switch(tmp.get_type()) { case vm_nil:std::cout<<"nil";break; @@ -415,7 +406,7 @@ void nasal_hash::print() } /*functions of nasal_function*/ -nasal_function::nasal_function() +nasal_function::nasal_function(nasal_virtual_machine& nvm):vm(nvm) { closure_addr=-1; argument_list.clear(); @@ -425,7 +416,7 @@ nasal_function::nasal_function() nasal_function::~nasal_function() { if(closure_addr>=0) - nasal_vm.del_reference(closure_addr); + vm.del_reference(closure_addr); argument_list.clear(); function_expr.clear(); return; @@ -433,15 +424,15 @@ nasal_function::~nasal_function() void nasal_function::set_closure_addr(int value_address) { if(closure_addr>=0) - nasal_vm.del_reference(closure_addr); - int new_closure=nasal_vm.gc_alloc(vm_closure); - nasal_vm.gc_get(new_closure).get_closure().set_closure(nasal_vm.gc_get(value_address).get_closure()); + 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()); closure_addr=new_closure; return; } int nasal_function::get_closure_addr() { - return this->closure_addr; + return closure_addr; } void nasal_function::set_arguments(nasal_ast& node) { @@ -463,26 +454,22 @@ nasal_ast& nasal_function::get_run_block() } /*functions of nasal_closure*/ -nasal_closure::nasal_closure() +nasal_closure::nasal_closure(nasal_virtual_machine& nvm):vm(nvm) { - elems.clear(); 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) - nasal_vm.mem_free(j->second); - i->clear(); - } + vm.mem_free(j->second); elems.clear(); return; } void nasal_closure::add_scope() { std::map new_scope; - this->elems.push_back(new_scope); + elems.push_back(new_scope); return; } void nasal_closure::del_scope() @@ -490,18 +477,18 @@ void nasal_closure::del_scope() if(this->elems.empty()) return; for(std::map::iterator i=elems.back().begin();i!=elems.back().end();++i) - nasal_vm.mem_free(i->second); + vm.mem_free(i->second); this->elems.pop_back(); return; } void nasal_closure::add_new_value(std::string key,int value_address) { - int new_mem_address=nasal_vm.mem_alloc(value_address); + int new_mem_address=vm.mem_alloc(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_mem_address=elems.back()[key]; - nasal_vm.mem_free(old_mem_address); + vm.mem_free(old_mem_address); } elems.back()[key]=new_mem_address; return; @@ -512,7 +499,7 @@ int nasal_closure::get_value_address(std::string key) for(std::list >::iterator i=elems.begin();i!=elems.end();++i) { if(i->find(key)!=i->end()) - ret_address=nasal_vm.mem_get((*i)[key]); + ret_address=vm.mem_get((*i)[key]); } return ret_address; } @@ -530,16 +517,16 @@ 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) - nasal_vm.mem_free(j->second); + vm.mem_free(j->second); elems.clear(); for(std::list >::iterator i=tmp.elems.begin();i!=tmp.elems.end();++i) { this->add_scope(); for(std::map::iterator j=i->begin();j!=i->end();++j) { - int value_addr=nasal_vm.mem_get(j->second); - int new_mem_addr=nasal_vm.mem_alloc(value_addr); - nasal_vm.add_reference(value_addr); + int value_addr=vm.mem_get(j->second); + int new_mem_addr=vm.mem_alloc(value_addr); + vm.add_reference(value_addr); elems.back()[j->first]=new_mem_addr; } } @@ -597,28 +584,23 @@ void nasal_scalar::clear() } return; } -void nasal_scalar::set_type(int nasal_scalar_type) +void nasal_scalar::set_type(int nasal_scalar_type,nasal_virtual_machine& nvm) { if(this->scalar_ptr) { - std::cout<<">> [vm] scalar_ptr is in use.\n"; + std::cout<<">> [vm] scalar_ptr is in use: "<type=nasal_scalar_type; switch(nasal_scalar_type) { - case vm_nil: this->scalar_ptr=(void*)NULL; break; - case vm_number: this->scalar_ptr=(void*)(new double); break; - case vm_string: this->scalar_ptr=(void*)(new std::string); break; - case vm_vector: this->scalar_ptr=(void*)(new nasal_vector); break; - case vm_hash: this->scalar_ptr=(void*)(new nasal_hash); break; - case vm_function: this->scalar_ptr=(void*)(new nasal_function); break; - case vm_closure: this->scalar_ptr=(void*)(new nasal_closure); break; - default: - std::cout<<">> [vm] error scalar type: "<type=vm_nil; - this->scalar_ptr=(void*)NULL; - break; + case vm_nil: this->scalar_ptr=(void*)NULL; break; + case vm_number: this->scalar_ptr=(void*)(new double); break; + case vm_string: this->scalar_ptr=(void*)(new std::string); break; + case vm_vector: this->scalar_ptr=(void*)(new nasal_vector(nvm)); break; + case vm_hash: this->scalar_ptr=(void*)(new nasal_hash(nvm)); break; + case vm_function: this->scalar_ptr=(void*)(new nasal_function(nvm)); break; + case vm_closure: this->scalar_ptr=(void*)(new nasal_closure(nvm)); break; } return; } @@ -638,465 +620,27 @@ int nasal_scalar::get_type() } double nasal_scalar::get_number() { - if(this->type==vm_number) - return *(double*)(this->scalar_ptr); - else - return 0; + return *(double*)(this->scalar_ptr); } std::string nasal_scalar::get_string() { - if(this->type==vm_string) - return *(std::string*)(this->scalar_ptr); - else - return "[vm] error value type"; + return *(std::string*)(this->scalar_ptr); } nasal_vector& nasal_scalar::get_vector() { - if(this->type==vm_vector) - return *(nasal_vector*)(this->scalar_ptr); - else - return error_vector; + return *(nasal_vector*)(this->scalar_ptr); } nasal_hash& nasal_scalar::get_hash() { - if(this->type==vm_hash) - return *(nasal_hash*)(this->scalar_ptr); - else - return error_hash; + return *(nasal_hash*)(this->scalar_ptr); } nasal_function& nasal_scalar::get_func() { - if(this->type==vm_function) - return *(nasal_function*)(this->scalar_ptr); - else - return error_function; + return *(nasal_function*)(this->scalar_ptr); } nasal_closure& nasal_scalar::get_closure() { - if(this->type==vm_closure) - return *(nasal_closure*)(this->scalar_ptr); - else - return error_closure; -} - -int nasal_scalar::nasal_scalar_add(int a_scalar_addr,int b_scalar_addr) -{ - if(a_scalar_addr<0 || b_scalar_addr<0) - { - std::cout<<">> [vm] scalar_add: memory returned an invalid address.\n"; - return -1; - } - - nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr); - nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr); - double a_num=(1/0.0)+(-1/0.0); - double b_num=(1/0.0)+(-1/0.0); - if(a_ref.type==vm_number) - a_num=*(double*)a_ref.scalar_ptr; - else if(a_ref.type==vm_string) - a_num=trans_string_to_number(*(std::string*)a_ref.scalar_ptr); - if(b_ref.type==vm_number) - b_num=*(double*)b_ref.scalar_ptr; - else if(b_ref.type==vm_string) - b_num=trans_string_to_number(*(std::string*)b_ref.scalar_ptr); - - int new_value_address=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(new_value_address).set_number(a_num+b_num); - return new_value_address; -} -int nasal_scalar::nasal_scalar_sub(int a_scalar_addr,int b_scalar_addr) -{ - if(a_scalar_addr<0 || b_scalar_addr<0) - { - std::cout<<">> [vm] scalar_sub: memory returned an invalid address.\n"; - return -1; - } - - nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr); - nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr); - double a_num=(1/0.0)+(-1/0.0); - double b_num=(1/0.0)+(-1/0.0); - if(a_ref.type==vm_number) - a_num=*(double*)a_ref.scalar_ptr; - else if(a_ref.type==vm_string) - a_num=trans_string_to_number(*(std::string*)a_ref.scalar_ptr); - if(b_ref.type==vm_number) - b_num=*(double*)b_ref.scalar_ptr; - else if(b_ref.type==vm_string) - b_num=trans_string_to_number(*(std::string*)b_ref.scalar_ptr); - - int new_value_address=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(new_value_address).set_number(a_num-b_num); - return new_value_address; -} -int nasal_scalar::nasal_scalar_mult(int a_scalar_addr,int b_scalar_addr) -{ - if(a_scalar_addr<0 || b_scalar_addr<0) - { - std::cout<<">> [vm] scalar_mult: memory returned an invalid address.\n"; - return -1; - } - - nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr); - nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr); - double a_num=(1/0.0)+(-1/0.0); - double b_num=(1/0.0)+(-1/0.0); - if(a_ref.type==vm_number) - a_num=*(double*)a_ref.scalar_ptr; - else if(a_ref.type==vm_string) - a_num=trans_string_to_number(*(std::string*)a_ref.scalar_ptr); - if(b_ref.type==vm_number) - b_num=*(double*)b_ref.scalar_ptr; - else if(b_ref.type==vm_string) - b_num=trans_string_to_number(*(std::string*)b_ref.scalar_ptr); - - int new_value_address=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(new_value_address).set_number(a_num*b_num); - return new_value_address; -} -int nasal_scalar::nasal_scalar_div(int a_scalar_addr,int b_scalar_addr) -{ - if(a_scalar_addr<0 || b_scalar_addr<0) - { - std::cout<<">> [vm] scalar_div: memory returned an invalid address.\n"; - return -1; - } - - nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr); - nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr); - double a_num=(1/0.0)+(-1/0.0); - double b_num=(1/0.0)+(-1/0.0); - if(a_ref.type==vm_number) - a_num=*(double*)a_ref.scalar_ptr; - else if(a_ref.type==vm_string) - a_num=trans_string_to_number(*(std::string*)a_ref.scalar_ptr); - if(b_ref.type==vm_number) - b_num=*(double*)b_ref.scalar_ptr; - else if(b_ref.type==vm_string) - b_num=trans_string_to_number(*(std::string*)b_ref.scalar_ptr); - - int new_value_address=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(new_value_address).set_number(a_num/b_num); - return new_value_address; -} -int nasal_scalar::nasal_scalar_link(int a_scalar_addr,int b_scalar_addr) -{ - if(a_scalar_addr<0 || b_scalar_addr<0) - { - std::cout<<">> [vm] scalar_link: memory returned an invalid address.\n"; - return -1; - } - nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr); - nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr); - if((a_ref.type!=vm_number && a_ref.type!=vm_string)||(b_ref.type!=vm_number && b_ref.type!=vm_string)) - { - std::cout<<">> [vm] scalar_link: error value type.\n"; - return -1; - } - std::string a_str; - std::string b_str; - a_str=(a_ref.type==vm_number)? trans_number_to_string(*(double*)a_ref.scalar_ptr):*(std::string*)a_ref.scalar_ptr; - b_str=(b_ref.type==vm_number)? trans_number_to_string(*(double*)b_ref.scalar_ptr):*(std::string*)b_ref.scalar_ptr; - int new_value_address=nasal_vm.gc_alloc(vm_string); - nasal_vm.gc_get(new_value_address).set_string(a_str+b_str); - return new_value_address; -} -int nasal_scalar::nasal_scalar_unary_sub(int a_scalar_addr) -{ - if(a_scalar_addr<0) - { - std::cout<<">> [vm] scalar_unary_sub: memory returned an invalid address.\n"; - return -1; - } - - nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr); - double a_num=(1/0.0)+(-1/0.0); - if(a_ref.type==vm_number) - a_num=*(double*)a_ref.scalar_ptr; - else if(a_ref.type==vm_string) - a_num=trans_string_to_number(*(std::string*)a_ref.scalar_ptr); - - int new_value_address=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(new_value_address).set_number(-a_num); - return new_value_address; -} -int nasal_scalar::nasal_scalar_unary_not(int a_scalar_addr) -{ - if(a_scalar_addr<0) - { - std::cout<<">> [vm] scalar_unary_not: memory returned an invalid address.\n"; - return -1; - } - nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr); - int new_value_address=-1; - if(a_ref.type==vm_nil) - { - new_value_address=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(new_value_address).set_number(1); - } - else if(a_ref.type==vm_number) - { - double number=(double)(*(double*)(a_ref.scalar_ptr)==0); - new_value_address=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(new_value_address).set_number(number); - } - else if(a_ref.type==vm_string) - { - double number=trans_string_to_number(*(std::string*)a_ref.scalar_ptr); - if(std::isnan(number)) - { - new_value_address=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(new_value_address).set_number(!(*(std::string*)a_ref.scalar_ptr).length()); - } - else - { - new_value_address=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(new_value_address).set_number((double)(number==0)); - } - } - else - std::cout<<">> [vm] scalar_unary_not: error value type.\n"; - return new_value_address; -} -int nasal_scalar::nasal_scalar_cmp_equal(int a_scalar_addr,int b_scalar_addr) -{ - if(a_scalar_addr<0 || b_scalar_addr<0) - { - std::cout<<">> [vm] scalar_cmp_equal: memory returned an invalid address.\n"; - return -1; - } - if(a_scalar_addr==b_scalar_addr) - { - int new_value_address=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(new_value_address).set_number(1); - return new_value_address; - } - nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr); - nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr); - if(a_ref.type==vm_nil && b_ref.type==vm_nil) - { - int new_value_address=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(new_value_address).set_number(1); - return new_value_address; - } - else if((a_ref.type==vm_number || a_ref.type==vm_string) && (b_ref.type==vm_number || b_ref.type==vm_string)) - { - if(a_ref.type==vm_string && b_ref.type==vm_string) - { - std::string astr=*(std::string*)a_ref.scalar_ptr; - std::string bstr=*(std::string*)b_ref.scalar_ptr; - int new_value_address=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(new_value_address).set_number((double)(astr==bstr)); - return new_value_address; - } - double a_num; - double b_num; - if(a_ref.type==vm_number) - a_num=*(double*)a_ref.scalar_ptr; - else - a_num=trans_string_to_number(*(std::string*)a_ref.scalar_ptr); - if(b_ref.type==vm_number) - b_num=*(double*)b_ref.scalar_ptr; - else - b_num=trans_string_to_number(*(std::string*)b_ref.scalar_ptr); - - int new_value_address=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(new_value_address).set_number((double)(a_num==b_num)); - return new_value_address; - } - else - { - int new_value_address=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(new_value_address).set_number(0); - return new_value_address; - } - return -1; -} -int nasal_scalar::nasal_scalar_cmp_not_equal(int a_scalar_addr,int b_scalar_addr) -{ - if(a_scalar_addr<0 || b_scalar_addr<0) - { - std::cout<<">> [vm] scalar_cmp_not_equal: memory returned an invalid address.\n"; - return -1; - } - if(a_scalar_addr==b_scalar_addr) - { - int new_value_address=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(new_value_address).set_number(0); - return new_value_address; - } - nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr); - nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr); - if(a_ref.type==vm_nil && b_ref.type==vm_nil) - { - int new_value_address=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(new_value_address).set_number(0); - return new_value_address; - } - else if((a_ref.type==vm_number || a_ref.type==vm_string) && (b_ref.type==vm_number || b_ref.type==vm_string)) - { - if(a_ref.type==vm_string && b_ref.type==vm_string) - { - std::string astr=*(std::string*)a_ref.scalar_ptr; - std::string bstr=*(std::string*)b_ref.scalar_ptr; - int new_value_address=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(new_value_address).set_number((double)(astr!=bstr)); - return new_value_address; - } - double a_num; - double b_num; - if(a_ref.type==vm_number) - a_num=*(double*)a_ref.scalar_ptr; - else - a_num=trans_string_to_number(*(std::string*)a_ref.scalar_ptr); - if(b_ref.type==vm_number) - b_num=*(double*)b_ref.scalar_ptr; - else - b_num=trans_string_to_number(*(std::string*)b_ref.scalar_ptr); - - int new_value_address=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(new_value_address).set_number((double)(a_num!=b_num)); - return new_value_address; - } - else - { - int new_value_address=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(new_value_address).set_number(1); - return new_value_address; - } - return -1; -} -int nasal_scalar::nasal_scalar_cmp_less(int a_scalar_addr,int b_scalar_addr) -{ - if(a_scalar_addr<0 || b_scalar_addr<0) - { - std::cout<<">> [vm] scalar_cmp_less: memory returned an invalid address.\n"; - return -1; - } - - nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr); - nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr); - if(a_ref.type==vm_string && b_ref.type==vm_string) - { - std::string a_str=*(std::string*)a_ref.scalar_ptr; - std::string b_str=*(std::string*)b_ref.scalar_ptr; - int new_value_address=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(new_value_address).set_number((double)(a_str> [vm] scalar_cmp_greater: memory returned an invalid address.\n"; - return -1; - } - - nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr); - nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr); - if(a_ref.type==vm_string && b_ref.type==vm_string) - { - std::string a_str=*(std::string*)a_ref.scalar_ptr; - std::string b_str=*(std::string*)b_ref.scalar_ptr; - int new_value_address=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(new_value_address).set_number((double)(a_str>b_str)); - return new_value_address; - } - double a_num=(1/0.0)+(-1/0.0); - double b_num=(1/0.0)+(-1/0.0); - if(a_ref.type==vm_number) - a_num=*(double*)a_ref.scalar_ptr; - else if(a_ref.type==vm_string) - a_num=trans_string_to_number(*(std::string*)a_ref.scalar_ptr); - if(b_ref.type==vm_number) - b_num=*(double*)b_ref.scalar_ptr; - else if(b_ref.type==vm_string) - b_num=trans_string_to_number(*(std::string*)b_ref.scalar_ptr); - - int new_value_address=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(new_value_address).set_number((double)(a_num>b_num)); - return new_value_address; -} -int nasal_scalar::nasal_scalar_cmp_less_or_equal(int a_scalar_addr,int b_scalar_addr) -{ - if(a_scalar_addr<0 || b_scalar_addr<0) - { - std::cout<<">> [vm] scalar_cmp_lequal: memory returned an invalid address.\n"; - return -1; - } - - nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr); - nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr); - if(a_ref.type==vm_string && b_ref.type==vm_string) - { - std::string a_str=*(std::string*)a_ref.scalar_ptr; - std::string b_str=*(std::string*)b_ref.scalar_ptr; - int new_value_address=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(new_value_address).set_number((double)(a_str<=b_str)); - return new_value_address; - } - double a_num=(1/0.0)+(-1/0.0); - double b_num=(1/0.0)+(-1/0.0); - if(a_ref.type==vm_number) - a_num=*(double*)a_ref.scalar_ptr; - else if(a_ref.type==vm_string) - a_num=trans_string_to_number(*(std::string*)a_ref.scalar_ptr); - if(b_ref.type==vm_number) - b_num=*(double*)b_ref.scalar_ptr; - else if(b_ref.type==vm_string) - b_num=trans_string_to_number(*(std::string*)b_ref.scalar_ptr); - - int new_value_address=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(new_value_address).set_number((double)(a_num<=b_num)); - return new_value_address; -} -int nasal_scalar::nasal_scalar_cmp_greater_or_equal(int a_scalar_addr,int b_scalar_addr) -{ - if(a_scalar_addr<0 || b_scalar_addr<0) - { - std::cout<<">> [vm] scalar_cmp_gequal: memory returned an invalid address.\n"; - return -1; - } - - nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr); - nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr); - if(a_ref.type==vm_string && b_ref.type==vm_string) - { - std::string a_str=*(std::string*)a_ref.scalar_ptr; - std::string b_str=*(std::string*)b_ref.scalar_ptr; - int new_value_address=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(new_value_address).set_number((double)(a_str>=b_str)); - return new_value_address; - } - double a_num=(1/0.0)+(-1/0.0); - double b_num=(1/0.0)+(-1/0.0); - if(a_ref.type==vm_number) - a_num=*(double*)a_ref.scalar_ptr; - else if(a_ref.type==vm_string) - a_num=trans_string_to_number(*(std::string*)a_ref.scalar_ptr); - if(b_ref.type==vm_number) - b_num=*(double*)b_ref.scalar_ptr; - else if(b_ref.type==vm_string) - b_num=trans_string_to_number(*(std::string*)b_ref.scalar_ptr); - - int new_value_address=nasal_vm.gc_alloc(vm_number); - nasal_vm.gc_get(new_value_address).set_number((double)(a_num>=b_num)); - return new_value_address; + return *(nasal_closure*)(this->scalar_ptr); } /*functions of nasal_virtual_machine*/ @@ -1107,24 +651,17 @@ nasal_virtual_machine::nasal_virtual_machine() nasal_virtual_machine::~nasal_virtual_machine() { int gc_mem_size=garbage_collector_memory.size(); - int mm_mem_size=memory_manager_memory.size(); for(int i=0;iref_cnt) + { + garbage_collector_memory[i]->ref_cnt=0; + garbage_collector_memory[i]->collected=true; + } for(int i=0;ielem.clear(); + delete garbage_collector_memory[i]; + } while(!garbage_collector_free_space.empty()) garbage_collector_free_space.pop(); while(!memory_manager_free_space.empty()) @@ -1136,47 +673,38 @@ nasal_virtual_machine::~nasal_virtual_machine() void nasal_virtual_machine::debug() { int gc_mem_size=garbage_collector_memory.size(); - int mm_mem_size=memory_manager_memory.size(); for(int i=0;iref_cnt) + { + std::cout<<">> [debug] "<ref_cnt<<" "; + switch(garbage_collector_memory[i]->elem.get_type()) { - std::cout<<">> [debug] "<<((i<<8)+j)<<": "<elem.get_number();break; + case vm_string:std::cout<<"string "<elem.get_string();break; + case vm_vector:std::cout<<"vector";break; + case vm_hash:std::cout<<"hash";break; + case vm_function:std::cout<<"function";break; + case vm_closure:std::cout<<"closure";break; } + std::cout<<"\n"; + } return; } void nasal_virtual_machine::clear() { int gc_mem_size=garbage_collector_memory.size(); - int mm_mem_size=memory_manager_memory.size(); for(int i=0;iref_cnt) + { + garbage_collector_memory[i]->ref_cnt=0; + garbage_collector_memory[i]->collected=true; + } for(int i=0;ielem.clear(); + delete garbage_collector_memory[i]; + } while(!garbage_collector_free_space.empty()) garbage_collector_free_space.pop(); while(!memory_manager_free_space.empty()) @@ -1189,50 +717,44 @@ int nasal_virtual_machine::gc_alloc(int val_type) { if(garbage_collector_free_space.empty()) { - gc_unit* new_block=new gc_unit[256]; - garbage_collector_memory.push_back(new_block); int mem_size=garbage_collector_memory.size(); - int begin=((mem_size-1)<<8); - int end=(mem_size<<8); - for(int i=begin;i>8][ret&0xff]; + gc_unit& unit_ref=*garbage_collector_memory[ret]; unit_ref.collected=false; unit_ref.ref_cnt=1; - unit_ref.elem.set_type(val_type); + unit_ref.elem.set_type(val_type,*this); garbage_collector_free_space.pop(); return ret; } nasal_scalar& nasal_virtual_machine::gc_get(int value_address) { - int blk_num=(value_address>>8); - int blk_plc=(value_address&0xff); - if(0<=value_address && value_address<(garbage_collector_memory.size()<<8) && !garbage_collector_memory[blk_num][blk_plc].collected) - return garbage_collector_memory[blk_num][blk_plc].elem; + if(0<=value_address && value_addresscollected) + return garbage_collector_memory[value_address]->elem; return error_returned_value; } void nasal_virtual_machine::add_reference(int value_address) { - int blk_num=(value_address>>8); - int blk_plc=(value_address&0xff); - if(0<=value_address && value_address<(garbage_collector_memory.size()<<8) && !garbage_collector_memory[blk_num][blk_plc].collected) - ++garbage_collector_memory[blk_num][blk_plc].ref_cnt; + if(0<=value_address && value_addresscollected) + ++garbage_collector_memory[value_address]->ref_cnt; return; } void nasal_virtual_machine::del_reference(int value_address) { - int blk_num=(value_address>>8); - int blk_plc=(value_address&0xff); - if(0<=value_address && value_address<(garbage_collector_memory.size()<<8) && !garbage_collector_memory[blk_num][blk_plc].collected) - --garbage_collector_memory[blk_num][blk_plc].ref_cnt; + if(0<=value_address && value_addresscollected) + --garbage_collector_memory[value_address]->ref_cnt; else return; - if(!garbage_collector_memory[blk_num][blk_plc].ref_cnt) + if(!garbage_collector_memory[value_address]->ref_cnt) { - garbage_collector_memory[blk_num][blk_plc].collected=true; - garbage_collector_memory[blk_num][blk_plc].elem.clear(); + garbage_collector_memory[value_address]->collected=true; + garbage_collector_memory[value_address]->elem.clear(); garbage_collector_free_space.push(value_address); } return; @@ -1241,14 +763,13 @@ int nasal_virtual_machine::mem_alloc(int value_address) { if(memory_manager_free_space.empty()) { - int* new_block=new int[256]; - memory_manager_memory.push_back(new_block); int mem_size=memory_manager_memory.size(); - for(int i=((mem_size-1)<<8);i<(mem_size<<8);++i) + memory_manager_memory.resize(mem_size+256); + for(int i=mem_size;i>8][ret&0xff]=value_address; + memory_manager_memory[ret]=value_address; memory_manager_free_space.pop(); return ret; } @@ -1256,9 +777,9 @@ void nasal_virtual_machine::mem_free(int memory_address) { // mem_free has helped scalar to delete the reference // so don't need to delete reference again - if(0<=memory_address && memory_address<(memory_manager_memory.size()<<8)) + if(0<=memory_address && memory_addressdel_reference(memory_manager_memory[memory_address>>8][memory_address&0xff]); + this->del_reference(memory_manager_memory[memory_address]); memory_manager_free_space.push(memory_address); } return; @@ -1267,19 +788,19 @@ void nasal_virtual_machine::mem_change(int memory_address,int value_address) { // this progress is used to change a memory space's value address // be careful! this process doesn't check if this mem_space is in use. - if(0<=memory_address && memory_address<(memory_manager_memory.size()<<8)) + if(0<=memory_address && memory_addressdel_reference(memory_manager_memory[memory_address>>8][memory_address&0xff]); - memory_manager_memory[memory_address>>8][memory_address&0xff]=value_address; + this->del_reference(memory_manager_memory[memory_address]); + memory_manager_memory[memory_address]=value_address; } return; } int nasal_virtual_machine::mem_get(int memory_address) { - int ret=-1; // be careful! this process doesn't check if this mem_space is in use. - if(0<=memory_address && memory_address<(memory_manager_memory.size()<<8)) - ret=memory_manager_memory[memory_address>>8][memory_address&0xff]; - return ret; + if(0<=memory_address && memory_address builtin_func_hashmap; + nasal_virtual_machine nasal_vm; + std::map builtin_func_hashmap; // function_return_address is an address in garbage_collector_memory int function_returned_address; // global_scope_address is an address in garbage_collector_memory @@ -59,6 +60,19 @@ private: int call_vector_mem(nasal_ast&,int,int); int call_hash_mem(nasal_ast&,int,int); // calculate scalars + int nasal_scalar_add(int,int); + int nasal_scalar_sub(int,int); + int nasal_scalar_mult(int,int); + int nasal_scalar_div(int,int); + int nasal_scalar_link(int,int); + int nasal_scalar_unary_sub(int); + int nasal_scalar_unary_not(int); + int nasal_scalar_cmp_equal(int,int); + int nasal_scalar_cmp_not_equal(int,int); + int nasal_scalar_cmp_less(int,int); + int nasal_scalar_cmp_greater(int,int); + int nasal_scalar_cmp_less_or_equal(int,int); + int nasal_scalar_cmp_greater_or_equal(int,int); int calculation(nasal_ast&,int); void definition(nasal_ast&,int); void multi_assignment(nasal_ast&,int); @@ -773,9 +787,9 @@ int nasal_runtime::call_function(nasal_ast& node,std::string func_name,int base_ int run_closure_addr=reference_of_func.get_closure_addr(); nasal_closure& run_closure=nasal_vm.gc_get(run_closure_addr).get_closure(); run_closure.add_scope(); - // set hash.me if(last_call_hash_addr>=0) { + // set hash.me nasal_vm.add_reference(last_call_hash_addr); run_closure.add_new_value("me",last_call_hash_addr); } @@ -952,7 +966,7 @@ int nasal_runtime::call_builtin_function(std::string val_name,int local_scope_ad int builtin_func_num=-1; if(builtin_func_hashmap.find(val_name)!=builtin_func_hashmap.end()) { - ret_value_addr=(*builtin_func_hashmap[val_name])(local_scope_addr); + ret_value_addr=(*builtin_func_hashmap[val_name])(local_scope_addr,nasal_vm); error+=builtin_die_state; } return ret_value_addr; @@ -1062,6 +1076,449 @@ int nasal_runtime::call_hash_mem(nasal_ast& node,int base_mem_addr,int local_sco int ret_mem_addr=nasal_vm.gc_get(base_value_addr).get_hash().get_mem_address(node.get_str()); return ret_mem_addr; } +int nasal_runtime::nasal_scalar_add(int a_scalar_addr,int b_scalar_addr) +{ + if(a_scalar_addr<0 || b_scalar_addr<0) + { + std::cout<<">> [vm] scalar_add: memory returned an invalid address.\n"; + return -1; + } + + nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr); + nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr); + int a_ref_type=a_ref.get_type(); + int b_ref_type=b_ref.get_type(); + double a_num=(1/0.0)+(-1/0.0); + double b_num=(1/0.0)+(-1/0.0); + if(a_ref_type==vm_number) + a_num=a_ref.get_number(); + else if(a_ref_type==vm_string) + a_num=trans_string_to_number(a_ref.get_string()); + if(b_ref_type==vm_number) + b_num=b_ref.get_number(); + else if(b_ref_type==vm_string) + b_num=trans_string_to_number(b_ref.get_string()); + + int new_value_address=nasal_vm.gc_alloc(vm_number); + nasal_vm.gc_get(new_value_address).set_number(a_num+b_num); + return new_value_address; +} +int nasal_runtime::nasal_scalar_sub(int a_scalar_addr,int b_scalar_addr) +{ + if(a_scalar_addr<0 || b_scalar_addr<0) + { + std::cout<<">> [vm] scalar_sub: memory returned an invalid address.\n"; + return -1; + } + + nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr); + nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr); + int a_ref_type=a_ref.get_type(); + int b_ref_type=b_ref.get_type(); + double a_num=(1/0.0)+(-1/0.0); + double b_num=(1/0.0)+(-1/0.0); + if(a_ref_type==vm_number) + a_num=a_ref.get_number(); + else if(a_ref_type==vm_string) + a_num=trans_string_to_number(a_ref.get_string()); + if(b_ref_type==vm_number) + b_num=b_ref.get_number(); + else if(b_ref_type==vm_string) + b_num=trans_string_to_number(b_ref.get_string()); + + int new_value_address=nasal_vm.gc_alloc(vm_number); + nasal_vm.gc_get(new_value_address).set_number(a_num-b_num); + return new_value_address; +} +int nasal_runtime::nasal_scalar_mult(int a_scalar_addr,int b_scalar_addr) +{ + if(a_scalar_addr<0 || b_scalar_addr<0) + { + std::cout<<">> [vm] scalar_mult: memory returned an invalid address.\n"; + return -1; + } + + nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr); + nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr); + int a_ref_type=a_ref.get_type(); + int b_ref_type=b_ref.get_type(); + double a_num=(1/0.0)+(-1/0.0); + double b_num=(1/0.0)+(-1/0.0); + if(a_ref_type==vm_number) + a_num=a_ref.get_number(); + else if(a_ref_type==vm_string) + a_num=trans_string_to_number(a_ref.get_string()); + if(b_ref_type==vm_number) + b_num=b_ref.get_number(); + else if(b_ref_type==vm_string) + b_num=trans_string_to_number(b_ref.get_string()); + + int new_value_address=nasal_vm.gc_alloc(vm_number); + nasal_vm.gc_get(new_value_address).set_number(a_num*b_num); + return new_value_address; +} +int nasal_runtime::nasal_scalar_div(int a_scalar_addr,int b_scalar_addr) +{ + if(a_scalar_addr<0 || b_scalar_addr<0) + { + std::cout<<">> [vm] scalar_div: memory returned an invalid address.\n"; + return -1; + } + + nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr); + nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr); + int a_ref_type=a_ref.get_type(); + int b_ref_type=b_ref.get_type(); + double a_num=(1/0.0)+(-1/0.0); + double b_num=(1/0.0)+(-1/0.0); + if(a_ref_type==vm_number) + a_num=a_ref.get_number(); + else if(a_ref_type==vm_string) + a_num=trans_string_to_number(a_ref.get_string()); + if(b_ref_type==vm_number) + b_num=b_ref.get_number(); + else if(b_ref_type==vm_string) + b_num=trans_string_to_number(b_ref.get_string()); + + int new_value_address=nasal_vm.gc_alloc(vm_number); + nasal_vm.gc_get(new_value_address).set_number(a_num/b_num); + return new_value_address; +} +int nasal_runtime::nasal_scalar_link(int a_scalar_addr,int b_scalar_addr) +{ + if(a_scalar_addr<0 || b_scalar_addr<0) + { + std::cout<<">> [vm] scalar_link: memory returned an invalid address.\n"; + return -1; + } + nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr); + nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr); + int a_ref_type=a_ref.get_type(); + int b_ref_type=b_ref.get_type(); + if((a_ref_type!=vm_number && a_ref_type!=vm_string)||(b_ref_type!=vm_number && b_ref_type!=vm_string)) + { + std::cout<<">> [vm] scalar_link: error value type.\n"; + return -1; + } + std::string a_str; + std::string b_str; + a_str=(a_ref_type==vm_number)? trans_number_to_string(a_ref.get_number()):a_ref.get_string(); + b_str=(b_ref_type==vm_number)? trans_number_to_string(b_ref.get_number()):b_ref.get_string(); + int new_value_address=nasal_vm.gc_alloc(vm_string); + nasal_vm.gc_get(new_value_address).set_string(a_str+b_str); + return new_value_address; +} +int nasal_runtime::nasal_scalar_unary_sub(int a_scalar_addr) +{ + if(a_scalar_addr<0) + { + std::cout<<">> [vm] scalar_unary_sub: memory returned an invalid address.\n"; + return -1; + } + + nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr); + int a_ref_type=a_ref.get_type(); + double a_num=(1/0.0)+(-1/0.0); + if(a_ref_type==vm_number) + a_num=a_ref.get_number(); + else if(a_ref_type==vm_string) + a_num=trans_string_to_number(a_ref.get_string()); + + int new_value_address=nasal_vm.gc_alloc(vm_number); + nasal_vm.gc_get(new_value_address).set_number(-a_num); + return new_value_address; +} +int nasal_runtime::nasal_scalar_unary_not(int a_scalar_addr) +{ + if(a_scalar_addr<0) + { + std::cout<<">> [vm] scalar_unary_not: memory returned an invalid address.\n"; + return -1; + } + nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr); + int a_ref_type=a_ref.get_type(); + int new_value_address=-1; + if(a_ref_type==vm_nil) + { + new_value_address=nasal_vm.gc_alloc(vm_number); + nasal_vm.gc_get(new_value_address).set_number(1); + } + else if(a_ref_type==vm_number) + { + double number=(a_ref.get_number()==0); + new_value_address=nasal_vm.gc_alloc(vm_number); + nasal_vm.gc_get(new_value_address).set_number(number); + } + else if(a_ref_type==vm_string) + { + double number=trans_string_to_number(a_ref.get_string()); + if(std::isnan(number)) + { + new_value_address=nasal_vm.gc_alloc(vm_number); + nasal_vm.gc_get(new_value_address).set_number(!(a_ref.get_string()).length()); + } + else + { + new_value_address=nasal_vm.gc_alloc(vm_number); + nasal_vm.gc_get(new_value_address).set_number((double)(number==0)); + } + } + else + std::cout<<">> [vm] scalar_unary_not: error value type.\n"; + return new_value_address; +} +int nasal_runtime::nasal_scalar_cmp_equal(int a_scalar_addr,int b_scalar_addr) +{ + if(a_scalar_addr<0 || b_scalar_addr<0) + { + std::cout<<">> [vm] scalar_cmp_equal: memory returned an invalid address.\n"; + return -1; + } + if(a_scalar_addr==b_scalar_addr) + { + int new_value_address=nasal_vm.gc_alloc(vm_number); + nasal_vm.gc_get(new_value_address).set_number(1); + return new_value_address; + } + nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr); + nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr); + int a_ref_type=a_ref.get_type(); + int b_ref_type=b_ref.get_type(); + if(a_ref_type==vm_nil && b_ref_type==vm_nil) + { + int new_value_address=nasal_vm.gc_alloc(vm_number); + nasal_vm.gc_get(new_value_address).set_number(1); + return new_value_address; + } + else if((a_ref_type==vm_number || a_ref_type==vm_string) && (b_ref_type==vm_number || b_ref_type==vm_string)) + { + 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=nasal_vm.gc_alloc(vm_number); + nasal_vm.gc_get(new_value_address).set_number((double)(astr==bstr)); + return new_value_address; + } + double a_num; + double b_num; + if(a_ref_type==vm_number) + a_num=a_ref.get_number(); + else + a_num=trans_string_to_number(a_ref.get_string()); + if(b_ref_type==vm_number) + b_num=b_ref.get_number(); + else + b_num=trans_string_to_number(b_ref.get_string()); + + int new_value_address=nasal_vm.gc_alloc(vm_number); + nasal_vm.gc_get(new_value_address).set_number((double)(a_num==b_num)); + return new_value_address; + } + else + { + int new_value_address=nasal_vm.gc_alloc(vm_number); + nasal_vm.gc_get(new_value_address).set_number(0); + return new_value_address; + } + return -1; +} +int nasal_runtime::nasal_scalar_cmp_not_equal(int a_scalar_addr,int b_scalar_addr) +{ + if(a_scalar_addr<0 || b_scalar_addr<0) + { + std::cout<<">> [vm] scalar_cmp_not_equal: memory returned an invalid address.\n"; + return -1; + } + if(a_scalar_addr==b_scalar_addr) + { + int new_value_address=nasal_vm.gc_alloc(vm_number); + nasal_vm.gc_get(new_value_address).set_number(0); + return new_value_address; + } + nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr); + nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr); + int a_ref_type=a_ref.get_type(); + int b_ref_type=b_ref.get_type(); + if(a_ref_type==vm_nil && b_ref_type==vm_nil) + { + int new_value_address=nasal_vm.gc_alloc(vm_number); + nasal_vm.gc_get(new_value_address).set_number(0); + return new_value_address; + } + else if((a_ref_type==vm_number || a_ref_type==vm_string) && (b_ref_type==vm_number || b_ref_type==vm_string)) + { + 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=nasal_vm.gc_alloc(vm_number); + nasal_vm.gc_get(new_value_address).set_number((double)(astr!=bstr)); + return new_value_address; + } + double a_num; + double b_num; + if(a_ref_type==vm_number) + a_num=a_ref.get_number(); + else + a_num=trans_string_to_number(a_ref.get_string()); + if(b_ref_type==vm_number) + b_num=b_ref.get_number(); + else + b_num=trans_string_to_number(b_ref.get_string()); + + int new_value_address=nasal_vm.gc_alloc(vm_number); + nasal_vm.gc_get(new_value_address).set_number((double)(a_num!=b_num)); + return new_value_address; + } + else + { + int new_value_address=nasal_vm.gc_alloc(vm_number); + nasal_vm.gc_get(new_value_address).set_number(1); + return new_value_address; + } + return -1; +} +int nasal_runtime::nasal_scalar_cmp_less(int a_scalar_addr,int b_scalar_addr) +{ + if(a_scalar_addr<0 || b_scalar_addr<0) + { + std::cout<<">> [vm] scalar_cmp_less: memory returned an invalid address.\n"; + return -1; + } + + nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr); + nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr); + int a_ref_type=a_ref.get_type(); + int b_ref_type=b_ref.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=nasal_vm.gc_alloc(vm_number); + nasal_vm.gc_get(new_value_address).set_number((double)(a_str> [vm] scalar_cmp_greater: memory returned an invalid address.\n"; + return -1; + } + + nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr); + nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr); + int a_ref_type=a_ref.get_type(); + int b_ref_type=b_ref.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=nasal_vm.gc_alloc(vm_number); + nasal_vm.gc_get(new_value_address).set_number((double)(a_str>b_str)); + return new_value_address; + } + double a_num=(1/0.0)+(-1/0.0); + double b_num=(1/0.0)+(-1/0.0); + if(a_ref_type==vm_number) + a_num=a_ref.get_number(); + else if(a_ref_type==vm_string) + a_num=trans_string_to_number(a_ref.get_string()); + if(b_ref_type==vm_number) + b_num=b_ref.get_number(); + else if(b_ref_type==vm_string) + b_num=trans_string_to_number(b_ref.get_string()); + + int new_value_address=nasal_vm.gc_alloc(vm_number); + nasal_vm.gc_get(new_value_address).set_number((double)(a_num>b_num)); + return new_value_address; +} +int nasal_runtime::nasal_scalar_cmp_less_or_equal(int a_scalar_addr,int b_scalar_addr) +{ + if(a_scalar_addr<0 || b_scalar_addr<0) + { + std::cout<<">> [vm] scalar_cmp_lequal: memory returned an invalid address.\n"; + return -1; + } + + nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr); + nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr); + int a_ref_type=a_ref.get_type(); + int b_ref_type=b_ref.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=nasal_vm.gc_alloc(vm_number); + nasal_vm.gc_get(new_value_address).set_number((double)(a_str<=b_str)); + return new_value_address; + } + double a_num=(1/0.0)+(-1/0.0); + double b_num=(1/0.0)+(-1/0.0); + if(a_ref_type==vm_number) + a_num=a_ref.get_number(); + else if(a_ref_type==vm_string) + a_num=trans_string_to_number(a_ref.get_string()); + if(b_ref_type==vm_number) + b_num=b_ref.get_number(); + else if(b_ref_type==vm_string) + b_num=trans_string_to_number(b_ref.get_string()); + + int new_value_address=nasal_vm.gc_alloc(vm_number); + nasal_vm.gc_get(new_value_address).set_number((double)(a_num<=b_num)); + return new_value_address; +} +int nasal_runtime::nasal_scalar_cmp_greater_or_equal(int a_scalar_addr,int b_scalar_addr) +{ + if(a_scalar_addr<0 || b_scalar_addr<0) + { + std::cout<<">> [vm] scalar_cmp_gequal: memory returned an invalid address.\n"; + return -1; + } + + nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr); + nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr); + int a_ref_type=a_ref.get_type(); + int b_ref_type=b_ref.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=nasal_vm.gc_alloc(vm_number); + nasal_vm.gc_get(new_value_address).set_number((double)(a_str>=b_str)); + return new_value_address; + } + double a_num=(1/0.0)+(-1/0.0); + double b_num=(1/0.0)+(-1/0.0); + if(a_ref_type==vm_number) + a_num=a_ref.get_number(); + else if(a_ref_type==vm_string) + a_num=trans_string_to_number(a_ref.get_string()); + if(b_ref_type==vm_number) + b_num=b_ref.get_number(); + else if(b_ref_type==vm_string) + b_num=trans_string_to_number(b_ref.get_string()); + + int new_value_address=nasal_vm.gc_alloc(vm_number); + nasal_vm.gc_get(new_value_address).set_number((double)(a_num>=b_num)); + return new_value_address; +} int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr) { // after this process, a new address(in nasal_vm.garbage_collector_memory) will be returned @@ -1109,7 +1566,7 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr) { int left_gc_addr=calculation(node.get_children()[0],local_scope_addr); int right_gc_addr=calculation(node.get_children()[1],local_scope_addr); - ret_address=nasal_scalar_calculator.nasal_scalar_add(left_gc_addr,right_gc_addr); + ret_address=nasal_scalar_add(left_gc_addr,right_gc_addr); // delete the reference of temporary values nasal_vm.del_reference(left_gc_addr); nasal_vm.del_reference(right_gc_addr); @@ -1118,7 +1575,7 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr) { int left_gc_addr=calculation(node.get_children()[0],local_scope_addr); int right_gc_addr=calculation(node.get_children()[1],local_scope_addr); - ret_address=nasal_scalar_calculator.nasal_scalar_sub(left_gc_addr,right_gc_addr); + ret_address=nasal_scalar_sub(left_gc_addr,right_gc_addr); // delete the reference of temporary values nasal_vm.del_reference(left_gc_addr); nasal_vm.del_reference(right_gc_addr); @@ -1127,7 +1584,7 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr) { int left_gc_addr=calculation(node.get_children()[0],local_scope_addr); int right_gc_addr=calculation(node.get_children()[1],local_scope_addr); - ret_address=nasal_scalar_calculator.nasal_scalar_mult(left_gc_addr,right_gc_addr); + ret_address=nasal_scalar_mult(left_gc_addr,right_gc_addr); // delete the reference of temporary values nasal_vm.del_reference(left_gc_addr); nasal_vm.del_reference(right_gc_addr); @@ -1136,7 +1593,7 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr) { int left_gc_addr=calculation(node.get_children()[0],local_scope_addr); int right_gc_addr=calculation(node.get_children()[1],local_scope_addr); - ret_address=nasal_scalar_calculator.nasal_scalar_div(left_gc_addr,right_gc_addr); + ret_address=nasal_scalar_div(left_gc_addr,right_gc_addr); // delete the reference of temporary values nasal_vm.del_reference(left_gc_addr); nasal_vm.del_reference(right_gc_addr); @@ -1145,7 +1602,7 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr) { int left_gc_addr=calculation(node.get_children()[0],local_scope_addr); int right_gc_addr=calculation(node.get_children()[1],local_scope_addr); - ret_address=nasal_scalar_calculator.nasal_scalar_link(left_gc_addr,right_gc_addr); + ret_address=nasal_scalar_link(left_gc_addr,right_gc_addr); // delete the reference of temporary values nasal_vm.del_reference(left_gc_addr); nasal_vm.del_reference(right_gc_addr); @@ -1154,7 +1611,7 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr) { int left_gc_addr=calculation(node.get_children()[0],local_scope_addr); int right_gc_addr=calculation(node.get_children()[1],local_scope_addr); - ret_address=nasal_scalar_calculator.nasal_scalar_cmp_equal(left_gc_addr,right_gc_addr); + ret_address=nasal_scalar_cmp_equal(left_gc_addr,right_gc_addr); // delete the reference of temporary values nasal_vm.del_reference(left_gc_addr); nasal_vm.del_reference(right_gc_addr); @@ -1163,7 +1620,7 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr) { int left_gc_addr=calculation(node.get_children()[0],local_scope_addr); int right_gc_addr=calculation(node.get_children()[1],local_scope_addr); - ret_address=nasal_scalar_calculator.nasal_scalar_cmp_not_equal(left_gc_addr,right_gc_addr); + ret_address=nasal_scalar_cmp_not_equal(left_gc_addr,right_gc_addr); // delete the reference of temporary values nasal_vm.del_reference(left_gc_addr); nasal_vm.del_reference(right_gc_addr); @@ -1172,7 +1629,7 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr) { int left_gc_addr=calculation(node.get_children()[0],local_scope_addr); int right_gc_addr=calculation(node.get_children()[1],local_scope_addr); - ret_address=nasal_scalar_calculator.nasal_scalar_cmp_less(left_gc_addr,right_gc_addr); + ret_address=nasal_scalar_cmp_less(left_gc_addr,right_gc_addr); // delete the reference of temporary values nasal_vm.del_reference(left_gc_addr); nasal_vm.del_reference(right_gc_addr); @@ -1181,7 +1638,7 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr) { int left_gc_addr=calculation(node.get_children()[0],local_scope_addr); int right_gc_addr=calculation(node.get_children()[1],local_scope_addr); - ret_address=nasal_scalar_calculator.nasal_scalar_cmp_less_or_equal(left_gc_addr,right_gc_addr); + ret_address=nasal_scalar_cmp_less_or_equal(left_gc_addr,right_gc_addr); // delete the reference of temporary values nasal_vm.del_reference(left_gc_addr); nasal_vm.del_reference(right_gc_addr); @@ -1190,7 +1647,7 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr) { int left_gc_addr=calculation(node.get_children()[0],local_scope_addr); int right_gc_addr=calculation(node.get_children()[1],local_scope_addr); - ret_address=nasal_scalar_calculator.nasal_scalar_cmp_greater(left_gc_addr,right_gc_addr); + ret_address=nasal_scalar_cmp_greater(left_gc_addr,right_gc_addr); // delete the reference of temporary values nasal_vm.del_reference(left_gc_addr); nasal_vm.del_reference(right_gc_addr); @@ -1199,7 +1656,7 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr) { int left_gc_addr=calculation(node.get_children()[0],local_scope_addr); int right_gc_addr=calculation(node.get_children()[1],local_scope_addr); - ret_address=nasal_scalar_calculator.nasal_scalar_cmp_greater_or_equal(left_gc_addr,right_gc_addr); + ret_address=nasal_scalar_cmp_greater_or_equal(left_gc_addr,right_gc_addr); // delete the reference of temporary values nasal_vm.del_reference(left_gc_addr); nasal_vm.del_reference(right_gc_addr); @@ -1255,14 +1712,14 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr) else if(calculation_type==ast_unary_not) { int addr=calculation(node.get_children()[0],local_scope_addr); - ret_address=nasal_scalar_calculator.nasal_scalar_unary_not(addr); + ret_address=nasal_scalar_unary_not(addr); // delete the reference of temporary values nasal_vm.del_reference(addr); } else if(calculation_type==ast_unary_sub) { int addr=calculation(node.get_children()[0],local_scope_addr); - ret_address=nasal_scalar_calculator.nasal_scalar_unary_sub(addr); + ret_address=nasal_scalar_unary_sub(addr); // delete the reference of temporary values nasal_vm.del_reference(addr); } @@ -1289,7 +1746,7 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr) int scalar_mem_space=call_scalar_mem(node.get_children()[0],local_scope_addr); int scalar_val_space=nasal_vm.mem_get(scalar_mem_space); int new_scalar_gc_addr=calculation(node.get_children()[1],local_scope_addr); - int result_val_address=nasal_scalar_calculator.nasal_scalar_add(scalar_val_space,new_scalar_gc_addr); + int result_val_address=nasal_scalar_add(scalar_val_space,new_scalar_gc_addr); nasal_vm.del_reference(new_scalar_gc_addr); nasal_vm.mem_change(scalar_mem_space,result_val_address);// this progress will delete the reference to old gc_addr in scalar_mem_space nasal_vm.add_reference(result_val_address);// this reference is reserved for ret_address @@ -1300,7 +1757,7 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr) int scalar_mem_space=call_scalar_mem(node.get_children()[0],local_scope_addr); int scalar_val_space=nasal_vm.mem_get(scalar_mem_space); int new_scalar_gc_addr=calculation(node.get_children()[1],local_scope_addr); - int result_val_address=nasal_scalar_calculator.nasal_scalar_sub(scalar_val_space,new_scalar_gc_addr); + int result_val_address=nasal_scalar_sub(scalar_val_space,new_scalar_gc_addr); nasal_vm.del_reference(new_scalar_gc_addr); nasal_vm.mem_change(scalar_mem_space,result_val_address);// this progress will delete the reference to old gc_addr in scalar_mem_space nasal_vm.add_reference(result_val_address);// this reference is reserved for ret_address @@ -1311,7 +1768,7 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr) int scalar_mem_space=call_scalar_mem(node.get_children()[0],local_scope_addr); int scalar_val_space=nasal_vm.mem_get(scalar_mem_space); int new_scalar_gc_addr=calculation(node.get_children()[1],local_scope_addr); - int result_val_address=nasal_scalar_calculator.nasal_scalar_div(scalar_val_space,new_scalar_gc_addr); + int result_val_address=nasal_scalar_div(scalar_val_space,new_scalar_gc_addr); nasal_vm.del_reference(new_scalar_gc_addr); nasal_vm.mem_change(scalar_mem_space,result_val_address);// this progress will delete the reference to old gc_addr in scalar_mem_space nasal_vm.add_reference(result_val_address);// this reference is reserved for ret_address @@ -1322,7 +1779,7 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr) int scalar_mem_space=call_scalar_mem(node.get_children()[0],local_scope_addr); int scalar_val_space=nasal_vm.mem_get(scalar_mem_space); int new_scalar_gc_addr=calculation(node.get_children()[1],local_scope_addr); - int result_val_address=nasal_scalar_calculator.nasal_scalar_mult(scalar_val_space,new_scalar_gc_addr); + int result_val_address=nasal_scalar_mult(scalar_val_space,new_scalar_gc_addr); nasal_vm.del_reference(new_scalar_gc_addr); nasal_vm.mem_change(scalar_mem_space,result_val_address);// this progress will delete the reference to old gc_addr in scalar_mem_space nasal_vm.add_reference(result_val_address);// this reference is reserved for ret_address @@ -1333,7 +1790,7 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr) int scalar_mem_space=call_scalar_mem(node.get_children()[0],local_scope_addr); int scalar_val_space=nasal_vm.mem_get(scalar_mem_space); int new_scalar_gc_addr=calculation(node.get_children()[1],local_scope_addr); - int result_val_address=nasal_scalar_calculator.nasal_scalar_link(scalar_val_space,new_scalar_gc_addr); + int result_val_address=nasal_scalar_link(scalar_val_space,new_scalar_gc_addr); nasal_vm.del_reference(new_scalar_gc_addr); nasal_vm.mem_change(scalar_mem_space,result_val_address);// this progress will delete the reference to old gc_addr in scalar_mem_space nasal_vm.add_reference(result_val_address);// this reference is reserved for ret_address