forked from xxq250/Nasal-Interpreter
update
This commit is contained in:
Valk Richard Li
+237
-230
@@ -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;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user