xxq250
/
Nasal-Interpreter
mirror of https://github.com/ValKmjolnir/Nasal-Interpreter.git
1
0
Fork 0
Code Issues Actions 3 Packages Projects Releases Wiki Activity

update

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

2
main.cpp
View File

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

2
nasal.h
View File

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

467
nasal_builtin.h
View File

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

538
nasal_gc.h
View File

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

13
nasal_parse.h
View File

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

754
nasal_bytecode_vm.h → nasal_vm.h
View File

File diff suppressed because it is too large Load Diff