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

update

This commit is contained in:
Valk Richard Li 2020-10-27 19:54:47 +08:00
parent b612f73ff7
commit 2923d24e6c
4 changed files with 166 additions and 454 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
nasal_builtin.h
View File

@ -96,14 +96,14 @@ int nasal_runtime::builtin_setsize(int local_scope_addr)
else
{
std::string str=nasal_vm.gc_get(size_value_addr).get_string();
if(check_numerable_string(str))
number=(int)trans_string_to_number(str);
else
double tmp=trans_string_to_number(str);
if(std::isnan(tmp))
{
std::cout<<">> [runtime] builtin_setsize: size is not a numerable string.\n";
++error;
return -1;
}
number=(int)tmp;
}
if(number<0)
{
@ -177,14 +177,13 @@ int nasal_runtime::builtin_sleep(int local_scope_addr)
if(nasal_vm.gc_get(value_addr).get_type()==vm_string)
{
std::string str=nasal_vm.gc_get(value_addr).get_string();
if(check_numerable_string(str))
sleep_time=(unsigned long)trans_string_to_number(str);
else
double number=trans_string_to_number(str);
if(std::isnan(number))
{
std::cout<<">> [runtime] builtin_sleep: this is not a numerable string.\n";
++error;
return -1;
}
}sleep_time=(unsigned long)number;
}
else
sleep_time=(unsigned long)nasal_vm.gc_get(value_addr).get_number();
@ -378,23 +377,16 @@ int nasal_runtime::builtin_int(int local_scope_addr)
int nasal_runtime::builtin_num(int local_scope_addr)
{
int value_addr=in_builtin_find("value");
if(value_addr<0 || nasal_vm.gc_get(value_addr).get_type()!=vm_string)
if(value_addr<0 || !in_builtin_check(value_addr,vm_string))
{
std::cout<<">> [runtime] builtin_num: \"value\" has wrong value type(must be string).\n";
++error;
return -1;
}
std::string str=nasal_vm.gc_get(value_addr).get_string();
if(!check_numerable_string(str))
{
std::cout<<">> [runtime] builtin_num: this is not a numerable string.\n";
++error;
return -1;
}
double number=trans_string_to_number(str);
int ret_addr=nasal_vm.gc_alloc();
nasal_vm.gc_get(ret_addr).set_type(vm_number);
nasal_vm.gc_get(ret_addr).set_number(number);
nasal_vm.gc_get(ret_addr).set_number(trans_string_to_number(str));
return ret_addr;
}
int nasal_runtime::builtin_pop(int local_scope_addr)

454
nasal_gc.h
View File

@ -105,8 +105,6 @@ public:
int nasal_scalar_mult(int,int);
int nasal_scalar_div(int,int);
int nasal_scalar_link(int,int);
int nasal_scalar_and(int,int);
int nasal_scalar_or(int,int);
int nasal_scalar_unary_sub(int);
int nasal_scalar_unary_not(int);
int nasal_scalar_cmp_equal(int,int);
@ -628,33 +626,20 @@ int nasal_scalar::nasal_scalar_add(int a_scalar_addr,int b_scalar_addr)
std::cout<<">> [vm] scalar_add: memory returned an invalid address.\n";
return -1;
}
nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr);
nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr);
if((a_ref.type!=vm_number && a_ref.type!=vm_string)||(b_ref.type!=vm_number && b_ref.type!=vm_string))
{
std::cout<<">> [vm] scalar_add: error value type.\n";
return -1;
}
double a_num;
double b_num;
double a_num=(1/0.0)+(-1/0.0);
double b_num=(1/0.0)+(-1/0.0);
if(a_ref.type==vm_number)
a_num=*(double*)a_ref.scalar_ptr;
else if(check_numerable_string(*(std::string*)a_ref.scalar_ptr))
else if(a_ref.type==vm_string)
a_num=trans_string_to_number(*(std::string*)a_ref.scalar_ptr);
else
{
std::cout<<">> [vm] scalar_add: "<<*(std::string*)a_ref.scalar_ptr<<" is not a numerable string.\n";
return -1;
}
if(b_ref.type==vm_number)
b_num=*(double*)b_ref.scalar_ptr;
else if(check_numerable_string(*(std::string*)b_ref.scalar_ptr))
else if(b_ref.type==vm_string)
b_num=trans_string_to_number(*(std::string*)b_ref.scalar_ptr);
else
{
std::cout<<">> [vm] scalar_add: "<<*(std::string*)b_ref.scalar_ptr<<" is not a numerable string.\n";
return -1;
}
int new_value_address=nasal_vm.gc_alloc();
nasal_vm.gc_get(new_value_address).set_type(vm_number);
nasal_vm.gc_get(new_value_address).set_number(a_num+b_num);
@ -667,33 +652,20 @@ int nasal_scalar::nasal_scalar_sub(int a_scalar_addr,int b_scalar_addr)
std::cout<<">> [vm] scalar_sub: memory returned an invalid address.\n";
return -1;
}
nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr);
nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr);
if((a_ref.type!=vm_number && a_ref.type!=vm_string)||(b_ref.type!=vm_number && b_ref.type!=vm_string))
{
std::cout<<">> [vm] scalar_sub: error value type.\n";
return -1;
}
double a_num;
double b_num;
double a_num=(1/0.0)+(-1/0.0);
double b_num=(1/0.0)+(-1/0.0);
if(a_ref.type==vm_number)
a_num=*(double*)a_ref.scalar_ptr;
else if(check_numerable_string(*(std::string*)a_ref.scalar_ptr))
else if(a_ref.type==vm_string)
a_num=trans_string_to_number(*(std::string*)a_ref.scalar_ptr);
else
{
std::cout<<">> [vm] scalar_sub: "<<*(std::string*)a_ref.scalar_ptr<<" is not a numerable string.\n";
return -1;
}
if(b_ref.type==vm_number)
b_num=*(double*)b_ref.scalar_ptr;
else if(check_numerable_string(*(std::string*)b_ref.scalar_ptr))
else if(b_ref.type==vm_string)
b_num=trans_string_to_number(*(std::string*)b_ref.scalar_ptr);
else
{
std::cout<<">> [vm] scalar_sub: "<<*(std::string*)b_ref.scalar_ptr<<" is not a numerable string.\n";
return -1;
}
int new_value_address=nasal_vm.gc_alloc();
nasal_vm.gc_get(new_value_address).set_type(vm_number);
nasal_vm.gc_get(new_value_address).set_number(a_num-b_num);
@ -706,33 +678,20 @@ int nasal_scalar::nasal_scalar_mult(int a_scalar_addr,int b_scalar_addr)
std::cout<<">> [vm] scalar_mult: memory returned an invalid address.\n";
return -1;
}
nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr);
nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr);
if((a_ref.type!=vm_number && a_ref.type!=vm_string)||(b_ref.type!=vm_number && b_ref.type!=vm_string))
{
std::cout<<">> [vm] scalar_mult: error value type.\n";
return -1;
}
double a_num;
double b_num;
double a_num=(1/0.0)+(-1/0.0);
double b_num=(1/0.0)+(-1/0.0);
if(a_ref.type==vm_number)
a_num=*(double*)a_ref.scalar_ptr;
else if(check_numerable_string(*(std::string*)a_ref.scalar_ptr))
else if(a_ref.type==vm_string)
a_num=trans_string_to_number(*(std::string*)a_ref.scalar_ptr);
else
{
std::cout<<">> [vm] scalar_mult: "<<*(std::string*)a_ref.scalar_ptr<<" is not a numerable string.\n";
return -1;
}
if(b_ref.type==vm_number)
b_num=*(double*)b_ref.scalar_ptr;
else if(check_numerable_string(*(std::string*)b_ref.scalar_ptr))
else if(b_ref.type==vm_string)
b_num=trans_string_to_number(*(std::string*)b_ref.scalar_ptr);
else
{
std::cout<<">> [vm] scalar_mult: "<<*(std::string*)b_ref.scalar_ptr<<" is not a numerable string.\n";
return -1;
}
int new_value_address=nasal_vm.gc_alloc();
nasal_vm.gc_get(new_value_address).set_type(vm_number);
nasal_vm.gc_get(new_value_address).set_number(a_num*b_num);
@ -745,33 +704,20 @@ int nasal_scalar::nasal_scalar_div(int a_scalar_addr,int b_scalar_addr)
std::cout<<">> [vm] scalar_div: memory returned an invalid address.\n";
return -1;
}
nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr);
nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr);
if((a_ref.type!=vm_number && a_ref.type!=vm_string)||(b_ref.type!=vm_number && b_ref.type!=vm_string))
{
std::cout<<">> [vm] scalar_div: error value type.\n";
return -1;
}
double a_num;
double b_num;
double a_num=(1/0.0)+(-1/0.0);
double b_num=(1/0.0)+(-1/0.0);
if(a_ref.type==vm_number)
a_num=*(double*)a_ref.scalar_ptr;
else if(check_numerable_string(*(std::string*)a_ref.scalar_ptr))
else if(a_ref.type==vm_string)
a_num=trans_string_to_number(*(std::string*)a_ref.scalar_ptr);
else
{
std::cout<<">> [vm] scalar_div: "<<*(std::string*)a_ref.scalar_ptr<<" is not a numerable string.\n";
return -1;
}
if(b_ref.type==vm_number)
b_num=*(double*)b_ref.scalar_ptr;
else if(check_numerable_string(*(std::string*)b_ref.scalar_ptr))
else if(b_ref.type==vm_string)
b_num=trans_string_to_number(*(std::string*)b_ref.scalar_ptr);
else
{
std::cout<<">> [vm] scalar_div: "<<*(std::string*)b_ref.scalar_ptr<<" is not a numerable string.\n";
return -1;
}
int new_value_address=nasal_vm.gc_alloc();
nasal_vm.gc_get(new_value_address).set_type(vm_number);
nasal_vm.gc_get(new_value_address).set_number(a_num/b_num);
@ -800,172 +746,6 @@ int nasal_scalar::nasal_scalar_link(int a_scalar_addr,int b_scalar_addr)
nasal_vm.gc_get(new_value_address).set_string(a_str+b_str);
return new_value_address;
}
int nasal_scalar::nasal_scalar_and(int a_scalar_addr,int b_scalar_addr)
{
nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr);
if(a_ref.type==vm_hash || a_ref.type==vm_vector || a_ref.type==vm_function)
{
std::cout<<">> [vm] scalar_and: hash and vector cannot take part in and calculation.\n";
return -1;
}
if(a_ref.type==vm_number)
{
double number=a_ref.get_number();
if(number==0)
{
int new_value_addr=nasal_vm.gc_alloc();
nasal_vm.gc_get(new_value_addr).set_type(vm_number);
nasal_vm.gc_get(new_value_addr).set_number(0);
return new_value_addr;
}
}
else if(a_ref.type==vm_nil)
{
int new_value_addr=nasal_vm.gc_alloc();
nasal_vm.gc_get(new_value_addr).set_type(vm_number);
nasal_vm.gc_get(new_value_addr).set_number(0);
return new_value_addr;
}
else if(a_ref.type==vm_string)
{
std::string str=a_ref.get_string();
if(!str.length() || !check_numerable_string(str))
{
int new_value_addr=nasal_vm.gc_alloc();
nasal_vm.gc_get(new_value_addr).set_type(vm_number);
nasal_vm.gc_get(new_value_addr).set_number(0);
return new_value_addr;
}
else
{
double number=trans_string_to_number(str);
if(number==0)
{
int new_value_addr=nasal_vm.gc_alloc();
nasal_vm.gc_get(new_value_addr).set_type(vm_number);
nasal_vm.gc_get(new_value_addr).set_number(0);
return new_value_addr;
}
}
}
nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr);
if(b_ref.type==vm_hash || b_ref.type==vm_vector || b_ref.type==vm_function)
{
std::cout<<">> [vm] scalar_and: hash and vector cannot take part in and calculation.\n";
return -1;
}
if(b_ref.type==vm_number)
{
double number=b_ref.get_number();
if(number==0)
{
int new_value_addr=nasal_vm.gc_alloc();
nasal_vm.gc_get(new_value_addr).set_type(vm_number);
nasal_vm.gc_get(new_value_addr).set_number(0);
return new_value_addr;
}
else
{
nasal_vm.add_reference(b_scalar_addr);
return b_scalar_addr;
}
}
else if(b_ref.type==vm_nil)
{
int new_value_addr=nasal_vm.gc_alloc();
nasal_vm.gc_get(new_value_addr).set_type(vm_number);
nasal_vm.gc_get(new_value_addr).set_number(0);
return new_value_addr;
}
else if(b_ref.type==vm_string)
{
std::string str=b_ref.get_string();
if(!str.length() || !check_numerable_string(str))
{
int new_value_addr=nasal_vm.gc_alloc();
nasal_vm.gc_get(new_value_addr).set_type(vm_number);
nasal_vm.gc_get(new_value_addr).set_number(0);
return new_value_addr;
}
else
{
double number=trans_string_to_number(str);
if(number==0)
{
int new_value_addr=nasal_vm.gc_alloc();
nasal_vm.gc_get(new_value_addr).set_type(vm_number);
nasal_vm.gc_get(new_value_addr).set_number(0);
return new_value_addr;
}
else
{
nasal_vm.add_reference(b_scalar_addr);
return b_scalar_addr;
}
}
}
int false_value_addr=nasal_vm.gc_alloc();
nasal_vm.gc_get(false_value_addr).set_type(vm_number);
nasal_vm.gc_get(false_value_addr).set_number(0);
return false_value_addr;
}
int nasal_scalar::nasal_scalar_or(int a_scalar_addr,int b_scalar_addr)
{
nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr);
if(a_ref.type==vm_hash || a_ref.type==vm_vector || a_ref.type==vm_function)
{
std::cout<<">> [vm] scalar_or: hash and vector cannot take part in or calculation.\n";
return -1;
}
if(a_ref.type==vm_number)
{
if(a_ref.get_number()!=0)
{
nasal_vm.add_reference(a_scalar_addr);
return a_scalar_addr;
}
}
else if(a_ref.type==vm_string)
{
std::string str=a_ref.get_string();
if(str.length() && (!check_numerable_string(str) || trans_string_to_number(str)!=0))
{
nasal_vm.add_reference(a_scalar_addr);
return a_scalar_addr;
}
}
nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr);
if(b_ref.type==vm_hash || b_ref.type==vm_vector || b_ref.type==vm_function)
{
std::cout<<">> [vm] scalar_or: hash and vector cannot take part in or calculation.\n";
return -1;
}
if(b_ref.type==vm_number)
{
if(b_ref.get_number()!=0)
{
nasal_vm.add_reference(b_scalar_addr);
return b_scalar_addr;
}
}
else if(b_ref.type==vm_string)
{
std::string str=b_ref.get_string();
if(str.length() && (!check_numerable_string(str) || trans_string_to_number(str)!=0))
{
nasal_vm.add_reference(b_scalar_addr);
return b_scalar_addr;
}
}
int false_value_addr=nasal_vm.gc_alloc();
nasal_vm.gc_get(false_value_addr).set_type(vm_number);
nasal_vm.gc_get(false_value_addr).set_number(0);
return false_value_addr;
}
int nasal_scalar::nasal_scalar_unary_sub(int a_scalar_addr)
{
if(a_scalar_addr<0)
@ -973,22 +753,14 @@ int nasal_scalar::nasal_scalar_unary_sub(int a_scalar_addr)
std::cout<<">> [vm] scalar_unary_sub: memory returned an invalid address.\n";
return -1;
}
nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr);
if(a_ref.type!=vm_number && a_ref.type!=vm_string)
{
std::cout<<">> [vm] scalar_unary_sub: error value type.\n";
return -1;
}
double a_num;
double a_num=(1/0.0)+(-1/0.0);
if(a_ref.type==vm_number)
a_num=*(double*)a_ref.scalar_ptr;
else if(check_numerable_string(*(std::string*)a_ref.scalar_ptr))
else if(a_ref.type==vm_string)
a_num=trans_string_to_number(*(std::string*)a_ref.scalar_ptr);
else
{
std::cout<<">> [vm] scalar_unary_sub: "<<*(std::string*)a_ref.scalar_ptr<<" is not a numerable string.\n";
return -1;
}
int new_value_address=nasal_vm.gc_alloc();
nasal_vm.gc_get(new_value_address).set_type(vm_number);
nasal_vm.gc_get(new_value_address).set_number(-a_num);
@ -1018,18 +790,18 @@ int nasal_scalar::nasal_scalar_unary_not(int a_scalar_addr)
}
else if(a_ref.type==vm_string)
{
if(check_numerable_string(*(std::string*)a_ref.scalar_ptr))
double number=trans_string_to_number(*(std::string*)a_ref.scalar_ptr);
if(std::isnan(number))
{
double number=(double)(trans_string_to_number(*(std::string*)a_ref.scalar_ptr)==0);
new_value_address=nasal_vm.gc_alloc();
nasal_vm.gc_get(new_value_address).set_type(vm_number);
nasal_vm.gc_get(new_value_address).set_number(number);
nasal_vm.gc_get(new_value_address).set_number(!(*(std::string*)a_ref.scalar_ptr).length());
}
else
{
new_value_address=nasal_vm.gc_alloc();
nasal_vm.gc_get(new_value_address).set_type(vm_number);
nasal_vm.gc_get(new_value_address).set_number(!(*(std::string*)a_ref.scalar_ptr).length());
nasal_vm.gc_get(new_value_address).set_number((double)(number==0));
}
}
else
@ -1072,32 +844,15 @@ int nasal_scalar::nasal_scalar_cmp_equal(int a_scalar_addr,int b_scalar_addr)
}
double a_num;
double b_num;
if(a_ref.type==vm_number) a_num=*(double*)a_ref.scalar_ptr;
if(a_ref.type==vm_number)
a_num=*(double*)a_ref.scalar_ptr;
else
{
if(check_numerable_string(*(std::string*)a_ref.scalar_ptr))
a_num=trans_string_to_number(*(std::string*)a_ref.scalar_ptr);
else
{
int new_value_address=nasal_vm.gc_alloc();
nasal_vm.gc_get(new_value_address).set_type(vm_number);
nasal_vm.gc_get(new_value_address).set_number((double)0);
return new_value_address;
}
}
if(b_ref.type==vm_number) b_num=*(double*)b_ref.scalar_ptr;
a_num=trans_string_to_number(*(std::string*)a_ref.scalar_ptr);
if(b_ref.type==vm_number)
b_num=*(double*)b_ref.scalar_ptr;
else
{
if(check_numerable_string(*(std::string*)b_ref.scalar_ptr))
b_num=trans_string_to_number(*(std::string*)b_ref.scalar_ptr);
else
{
int new_value_address=nasal_vm.gc_alloc();
nasal_vm.gc_get(new_value_address).set_type(vm_number);
nasal_vm.gc_get(new_value_address).set_number((double)0);
return new_value_address;
}
}
b_num=trans_string_to_number(*(std::string*)b_ref.scalar_ptr);
int new_value_address=nasal_vm.gc_alloc();
nasal_vm.gc_get(new_value_address).set_type(vm_number);
nasal_vm.gc_get(new_value_address).set_number((double)(a_num==b_num));
@ -1148,32 +903,15 @@ int nasal_scalar::nasal_scalar_cmp_not_equal(int a_scalar_addr,int b_scalar_addr
}
double a_num;
double b_num;
if(a_ref.type==vm_number) a_num=*(double*)a_ref.scalar_ptr;
if(a_ref.type==vm_number)
a_num=*(double*)a_ref.scalar_ptr;
else
{
if(check_numerable_string(*(std::string*)a_ref.scalar_ptr))
a_num=trans_string_to_number(*(std::string*)a_ref.scalar_ptr);
else
{
int new_value_address=nasal_vm.gc_alloc();
nasal_vm.gc_get(new_value_address).set_type(vm_number);
nasal_vm.gc_get(new_value_address).set_number((double)1);
return new_value_address;
}
}
if(b_ref.type==vm_number) b_num=*(double*)b_ref.scalar_ptr;
a_num=trans_string_to_number(*(std::string*)a_ref.scalar_ptr);
if(b_ref.type==vm_number)
b_num=*(double*)b_ref.scalar_ptr;
else
{
if(check_numerable_string(*(std::string*)b_ref.scalar_ptr))
b_num=trans_string_to_number(*(std::string*)b_ref.scalar_ptr);
else
{
int new_value_address=nasal_vm.gc_alloc();
nasal_vm.gc_get(new_value_address).set_type(vm_number);
nasal_vm.gc_get(new_value_address).set_number((double)1);
return new_value_address;
}
}
b_num=trans_string_to_number(*(std::string*)b_ref.scalar_ptr);
int new_value_address=nasal_vm.gc_alloc();
nasal_vm.gc_get(new_value_address).set_type(vm_number);
nasal_vm.gc_get(new_value_address).set_number((double)(a_num!=b_num));
@ -1195,13 +933,9 @@ int nasal_scalar::nasal_scalar_cmp_less(int a_scalar_addr,int b_scalar_addr)
std::cout<<">> [vm] scalar_cmp_less: memory returned an invalid address.\n";
return -1;
}
nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr);
nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr);
if((a_ref.type!=vm_number && a_ref.type!=vm_string)||(b_ref.type!=vm_number && b_ref.type!=vm_string))
{
std::cout<<">> [vm] scalar_cmp_less: error value type.\n";
return -1;
}
if(a_ref.type==vm_string && b_ref.type==vm_string)
{
std::string a_str=*(std::string*)a_ref.scalar_ptr;
@ -1211,26 +945,17 @@ int nasal_scalar::nasal_scalar_cmp_less(int a_scalar_addr,int b_scalar_addr)
nasal_vm.gc_get(new_value_address).set_number((double)(a_str<b_str));
return new_value_address;
}
double a_num;
double b_num;
double a_num=(1/0.0)+(-1/0.0);
double b_num=(1/0.0)+(-1/0.0);
if(a_ref.type==vm_number)
a_num=*(double*)a_ref.scalar_ptr;
else if(check_numerable_string(*(std::string*)a_ref.scalar_ptr))
else if(a_ref.type==vm_string)
a_num=trans_string_to_number(*(std::string*)a_ref.scalar_ptr);
else
{
std::cout<<">> [vm] scalar_cmp_less: "<<*(std::string*)a_ref.scalar_ptr<<" is not a numerable string.\n";
return -1;
}
if(b_ref.type==vm_number)
b_num=*(double*)b_ref.scalar_ptr;
else if(check_numerable_string(*(std::string*)b_ref.scalar_ptr))
else if(b_ref.type==vm_string)
b_num=trans_string_to_number(*(std::string*)b_ref.scalar_ptr);
else
{
std::cout<<">> [vm] scalar_cmp_less: "<<*(std::string*)b_ref.scalar_ptr<<" is not a numerable string.\n";
return -1;
}
int new_value_address=nasal_vm.gc_alloc();
nasal_vm.gc_get(new_value_address).set_type(vm_number);
nasal_vm.gc_get(new_value_address).set_number((double)(a_num<b_num));
@ -1243,13 +968,9 @@ int nasal_scalar::nasal_scalar_cmp_greater(int a_scalar_addr,int b_scalar_addr)
std::cout<<">> [vm] scalar_cmp_greater: memory returned an invalid address.\n";
return -1;
}
nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr);
nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr);
if((a_ref.type!=vm_number && a_ref.type!=vm_string)||(b_ref.type!=vm_number && b_ref.type!=vm_string))
{
std::cout<<">> [vm] scalar_cmp_greater: error value type.\n";
return -1;
}
if(a_ref.type==vm_string && b_ref.type==vm_string)
{
std::string a_str=*(std::string*)a_ref.scalar_ptr;
@ -1259,26 +980,17 @@ int nasal_scalar::nasal_scalar_cmp_greater(int a_scalar_addr,int b_scalar_addr)
nasal_vm.gc_get(new_value_address).set_number((double)(a_str>b_str));
return new_value_address;
}
double a_num;
double b_num;
double a_num=(1/0.0)+(-1/0.0);
double b_num=(1/0.0)+(-1/0.0);
if(a_ref.type==vm_number)
a_num=*(double*)a_ref.scalar_ptr;
else if(check_numerable_string(*(std::string*)a_ref.scalar_ptr))
else if(a_ref.type==vm_string)
a_num=trans_string_to_number(*(std::string*)a_ref.scalar_ptr);
else
{
std::cout<<">> [vm] scalar_cmp_greater: "<<*(std::string*)a_ref.scalar_ptr<<" is not a numerable string.\n";
return -1;
}
if(b_ref.type==vm_number)
b_num=*(double*)b_ref.scalar_ptr;
else if(check_numerable_string(*(std::string*)b_ref.scalar_ptr))
else if(b_ref.type==vm_string)
b_num=trans_string_to_number(*(std::string*)b_ref.scalar_ptr);
else
{
std::cout<<">> [vm] scalar_cmp_greater: "<<*(std::string*)b_ref.scalar_ptr<<" is not a numerable string.\n";
return -1;
}
int new_value_address=nasal_vm.gc_alloc();
nasal_vm.gc_get(new_value_address).set_type(vm_number);
nasal_vm.gc_get(new_value_address).set_number((double)(a_num>b_num));
@ -1291,13 +1003,9 @@ int nasal_scalar::nasal_scalar_cmp_less_or_equal(int a_scalar_addr,int b_scalar_
std::cout<<">> [vm] scalar_cmp_lequal: memory returned an invalid address.\n";
return -1;
}
nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr);
nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr);
if((a_ref.type!=vm_number && a_ref.type!=vm_string)||(b_ref.type!=vm_number && b_ref.type!=vm_string))
{
std::cout<<">> [vm] scalar_cmp_lequal: error value type.\n";
return -1;
}
if(a_ref.type==vm_string && b_ref.type==vm_string)
{
std::string a_str=*(std::string*)a_ref.scalar_ptr;
@ -1307,26 +1015,17 @@ int nasal_scalar::nasal_scalar_cmp_less_or_equal(int a_scalar_addr,int b_scalar_
nasal_vm.gc_get(new_value_address).set_number((double)(a_str<=b_str));
return new_value_address;
}
double a_num;
double b_num;
double a_num=(1/0.0)+(-1/0.0);
double b_num=(1/0.0)+(-1/0.0);
if(a_ref.type==vm_number)
a_num=*(double*)a_ref.scalar_ptr;
else if(check_numerable_string(*(std::string*)a_ref.scalar_ptr))
else if(a_ref.type==vm_string)
a_num=trans_string_to_number(*(std::string*)a_ref.scalar_ptr);
else
{
std::cout<<">> [vm] scalar_cmp_lequal: "<<*(std::string*)a_ref.scalar_ptr<<" is not a numerable string.\n";
return -1;
}
if(b_ref.type==vm_number)
b_num=*(double*)b_ref.scalar_ptr;
else if(check_numerable_string(*(std::string*)b_ref.scalar_ptr))
else if(b_ref.type==vm_string)
b_num=trans_string_to_number(*(std::string*)b_ref.scalar_ptr);
else
{
std::cout<<">> [vm] scalar_cmp_lequal: "<<*(std::string*)b_ref.scalar_ptr<<" is not a numerable string.\n";
return -1;
}
int new_value_address=nasal_vm.gc_alloc();
nasal_vm.gc_get(new_value_address).set_type(vm_number);
nasal_vm.gc_get(new_value_address).set_number((double)(a_num<=b_num));
@ -1339,13 +1038,9 @@ int nasal_scalar::nasal_scalar_cmp_greater_or_equal(int a_scalar_addr,int b_scal
std::cout<<">> [vm] scalar_cmp_gequal: memory returned an invalid address.\n";
return -1;
}
nasal_scalar& a_ref=nasal_vm.gc_get(a_scalar_addr);
nasal_scalar& b_ref=nasal_vm.gc_get(b_scalar_addr);
if((a_ref.type!=vm_number && a_ref.type!=vm_string)||(b_ref.type!=vm_number && b_ref.type!=vm_string))
{
std::cout<<">> [vm] scalar_cmp_gequal: error value type.\n";
return -1;
}
if(a_ref.type==vm_string && b_ref.type==vm_string)
{
std::string a_str=*(std::string*)a_ref.scalar_ptr;
@ -1355,26 +1050,17 @@ int nasal_scalar::nasal_scalar_cmp_greater_or_equal(int a_scalar_addr,int b_scal
nasal_vm.gc_get(new_value_address).set_number((double)(a_str>=b_str));
return new_value_address;
}
double a_num;
double b_num;
double a_num=(1/0.0)+(-1/0.0);
double b_num=(1/0.0)+(-1/0.0);
if(a_ref.type==vm_number)
a_num=*(double*)a_ref.scalar_ptr;
else if(check_numerable_string(*(std::string*)a_ref.scalar_ptr))
else if(a_ref.type==vm_string)
a_num=trans_string_to_number(*(std::string*)a_ref.scalar_ptr);
else
{
std::cout<<">> [vm] scalar_cmp_gequal: "<<*(std::string*)a_ref.scalar_ptr<<" is not a numerable string.\n";
return -1;
}
if(b_ref.type==vm_number)
b_num=*(double*)b_ref.scalar_ptr;
else if(check_numerable_string(*(std::string*)b_ref.scalar_ptr))
else if(b_ref.type==vm_string)
b_num=trans_string_to_number(*(std::string*)b_ref.scalar_ptr);
else
{
std::cout<<">> [vm] scalar_cmp_gequal: "<<*(std::string*)b_ref.scalar_ptr<<" is not a numerable string.\n";
return -1;
}
int new_value_address=nasal_vm.gc_alloc();
nasal_vm.gc_get(new_value_address).set_type(vm_number);
nasal_vm.gc_get(new_value_address).set_number((double)(a_num>=b_num));

77
nasal_runtime.h
View File

@ -581,13 +581,10 @@ bool nasal_runtime::check_condition(int value_addr)
else if(type==vm_string)
{
std::string str=nasal_vm.gc_get(value_addr).get_string();
if(!check_numerable_string(str))
{
std::cout<<">> [runtime] check_condition: error value type, \'"<<str<<"\' is not a numerable string.\n";
++error;
return -1;
}
return (trans_string_to_number(str)!=0);
double number=trans_string_to_number(str);
if(std::isnan(number))
return false;
return (number!=0);
}
else if(type==vm_nil)
return false;
@ -729,13 +726,14 @@ int nasal_runtime::call_vector(nasal_ast& node,int base_value_addr,int local_sco
if(begin_value_type==vm_string)
{
std::string str=nasal_vm.gc_get(begin_value_addr).get_string();
if(!check_numerable_string(str))
double number=trans_string_to_number(str);
if(std::isnan(number))
{
std::cout<<">> [runtime] call_vector: begin index is not a numerable string.\n";
++error;
return -1;
}
begin_index=(int)trans_string_to_number(str);
begin_index=(int)number;
begin_is_nil=false;
}
else if(begin_value_type==vm_number)
@ -747,13 +745,14 @@ int nasal_runtime::call_vector(nasal_ast& node,int base_value_addr,int local_sco
if(end_value_type==vm_string)
{
std::string str=nasal_vm.gc_get(end_value_addr).get_string();
if(!check_numerable_string(str))
double number=trans_string_to_number(str);
if(std::isnan(number))
{
std::cout<<">> [runtime] call_vector: end index is not a numerable string.\n";
std::cout<<">> [runtime] call_vector: begin index is not a numerable string.\n";
++error;
return -1;
}
end_index=(int)trans_string_to_number(str);
begin_index=(int)number;
end_is_nil=false;
}
else if(end_value_type==vm_number)
@ -803,13 +802,14 @@ int nasal_runtime::call_vector(nasal_ast& node,int base_value_addr,int local_sco
if(index_value_type==vm_string)
{
std::string str=nasal_vm.gc_get(index_value_addr).get_string();
if(!check_numerable_string(str))
double number=trans_string_to_number(str);
if(std::isnan(number))
{
std::cout<<">> [runtime] call_vector: index is not a numerable string.\n";
++error;
return -1;
}
index_num=(int)trans_string_to_number(str);
index_num=(int)number;
}
else
index_num=(int)nasal_vm.gc_get(index_value_addr).get_number();
@ -890,13 +890,14 @@ int nasal_runtime::call_vector(nasal_ast& node,int base_value_addr,int local_sco
if(index_value_type==vm_string)
{
std::string str=nasal_vm.gc_get(index_value_addr).get_string();
if(!check_numerable_string(str))
double number=trans_string_to_number(str);
if(std::isnan(number))
{
std::cout<<">> [runtime] call_vector: index is not a numerable string.\n";
++error;
return -1;
}
index_num=(int)trans_string_to_number(str);
index_num=(int)number;
}
else
index_num=(int)nasal_vm.gc_get(index_value_addr).get_number();
@ -1242,13 +1243,14 @@ int nasal_runtime::call_vector_mem(nasal_ast& node,int base_mem_addr,int local_s
if(index_value_type==vm_string)
{
std::string str=nasal_vm.gc_get(index_value_addr).get_string();
if(!check_numerable_string(str))
double number=trans_string_to_number(str);
if(std::isnan(number))
{
std::cout<<">> [runtime] call_vector_mem: index is not a numerable string.\n";
++error;
return -1;
}
index_num=(int)trans_string_to_number(str);
index_num=(int)number;
}
else
index_num=(int)nasal_vm.gc_get(index_value_addr).get_number();
@ -1428,7 +1430,6 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr)
int left_gc_addr=calculation(node.get_children()[0],local_scope_addr);
if(!check_condition(left_gc_addr))
{
// delete the reference of temporary values
nasal_vm.del_reference(left_gc_addr);
ret_address=nasal_vm.gc_alloc();
nasal_vm.gc_get(ret_address).set_type(vm_number);
@ -1437,10 +1438,19 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr)
else
{
int right_gc_addr=calculation(node.get_children()[1],local_scope_addr);
ret_address=nasal_scalar_calculator.nasal_scalar_and(left_gc_addr,right_gc_addr);
// delete the reference of temporary values
nasal_vm.del_reference(left_gc_addr);
nasal_vm.del_reference(right_gc_addr);
if(!check_condition(right_gc_addr))
{
nasal_vm.del_reference(left_gc_addr);
nasal_vm.del_reference(right_gc_addr);
ret_address=nasal_vm.gc_alloc();
nasal_vm.gc_get(ret_address).set_type(vm_number);
nasal_vm.gc_get(ret_address).set_number(0);
}
else
{
nasal_vm.del_reference(left_gc_addr);
ret_address=right_gc_addr;
}
}
}
else if(calculation_type==ast_or)
@ -1451,10 +1461,19 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr)
else
{
int right_gc_addr=calculation(node.get_children()[1],local_scope_addr);
ret_address=nasal_scalar_calculator.nasal_scalar_or(left_gc_addr,right_gc_addr);
// delete the reference of temporary values
nasal_vm.del_reference(left_gc_addr);
nasal_vm.del_reference(right_gc_addr);
if(check_condition(right_gc_addr))
{
nasal_vm.del_reference(left_gc_addr);
ret_address=right_gc_addr;
}
else
{
nasal_vm.del_reference(left_gc_addr);
nasal_vm.del_reference(right_gc_addr);
ret_address=nasal_vm.gc_alloc();
nasal_vm.gc_get(ret_address).set_type(vm_number);
nasal_vm.gc_get(ret_address).set_number(0);
}
}
}
else if(calculation_type==ast_unary_not)
@ -1546,13 +1565,13 @@ int nasal_runtime::calculation(nasal_ast& node,int local_scope_addr)
}
else
{
std::cout<<">> [runtime] calculation: this expression cannot be calculated.expression type:"<<ast_str(node.get_type())<<".\n";
std::cout<<">> [runtime] calculation: expression type:"<<ast_str(node.get_type())<<" cannot be calculated.\n";
++error;
return -1;
}
if(ret_address<0)
{
std::cout<<">> [runtime] calculation: incorrect values are used in calculation.\n";
std::cout<<">> [runtime] calculation: incorrect values.\n";
++error;
}
return ret_address;

65
test/lexer.nas
View File

@ -1,22 +1,10 @@
import("lib.nas");
var s=io.fin("lexer.nas");
var s=io.fin("a.nas");
s=split('',s);
var len=size(s);
var ptr=0;
var cmp=func(s1,s2)
{
var size1=size(s1);
var size2=size(s2);
if(size1!=size2)
return size1<size2;
for(var i=0;i<size1;i+=1)
if(s1[i]>s2[i])
return 0;
return 1;
}
var jump_note=func()
{
while(ptr<len and s[ptr]!='\n')
@ -30,10 +18,10 @@ var generate_id=func()
var tmp="";
while(ptr<len)
{
if('a'[0]<=s[ptr][0] and s[ptr][0]<='z'[0]
or 'A'[0]<=s[ptr][0] and s[ptr][0]<='Z'[0]
if('a'<=s[ptr] and s[ptr]<='z'
or 'A'<=s[ptr] and s[ptr]<='Z'
or s[ptr]=='_'
or '0'[0]<=s[ptr][0] and s[ptr][0]<='9'[0])
or '0'<=s[ptr] and s[ptr]<='9')
tmp~=s[ptr];
else
break;
@ -86,7 +74,7 @@ var generate_number=func()
if(s[ptr]=='x')
{
ptr+=1;
while(ptr<len and ('a'[0]<=s[ptr][0] and s[ptr][0]<='f'[0] or '0'[0]<=s[ptr][0] and s[ptr][0]<='9'[0]))
while(ptr<len and ('a'<=s[ptr] and s[ptr]<='f' or '0'<=s[ptr] and s[ptr]<='9'))
{
number~=s[ptr];
ptr+=1;
@ -96,7 +84,7 @@ var generate_number=func()
elsif(s[ptr]=='o')
{
ptr+=1;
while(ptr<len and ('0'[0]<=s[ptr][0] and s[ptr][0]<='7'[0]))
while(ptr<len and ('0'<=s[ptr] and s[ptr]<='7'))
{
number~=s[ptr];
ptr+=1;
@ -104,7 +92,7 @@ var generate_number=func()
return num(number);
}
while(ptr<len and ('0'[0]<=s[ptr][0] and s[ptr][0]<='9'[0]))
while(ptr<len and ('0'<=s[ptr] and s[ptr]<='9'))
{
number~=s[ptr];
ptr+=1;
@ -113,6 +101,27 @@ var generate_number=func()
number~=s[ptr];
else
return num(number);
ptr+=1;
while(ptr<len and ('0'<=s[ptr] and s[ptr]<='9'))
{
number~=s[ptr];
ptr+=1;
}
if(s[ptr]=='e' or s[ptr]=='E')
number~=s[ptr];
else
return num(number);
ptr+=1;
if(s[ptr]=='-' or s[ptr]=='+')
{
number~=s[ptr];
ptr+=1;
}
while(ptr<len and ('0'<=s[ptr] and s[ptr]<='9'))
{
number~=s[ptr];
ptr+=1;
}
return num(number);
}
@ -150,22 +159,28 @@ var generate_operator=func()
return tmp;
}
var cnt=0;
var token=[];
while(ptr<len)
{
if(s[ptr]=='#')
jump_note();
elsif('a'[0]<=s[ptr][0] and s[ptr][0]<='z'[0] or 'A'[0]<=s[ptr][0] and s[ptr][0]<='Z'[0] or s[ptr]=='_')
print("(",cnt+=1," | ",generate_id(),")");
elsif('a'<=s[ptr] and s[ptr]<='z' or 'A'<=s[ptr] and s[ptr]<='Z' or s[ptr]=='_')
append(token,generate_id());
elsif(s[ptr]=='\'' or s[ptr]=='\"')
print("(",cnt+=1," | \"",generate_str(),"\")");
elsif('0'[0]<=s[ptr][0] and s[ptr][0]<='9'[0])
print("(",cnt+=1," | ",generate_number(),")");
append(token,generate_str());
elsif('0'<=s[ptr] and s[ptr]<='9')
append(token,generate_number());
else
{
var tmp=generate_operator();
if(size(tmp))
print("(",cnt+=1," | ",tmp,")");
append(token,tmp);
}
if(ptr>=len)
break;
}
foreach(var i;token)
{
print("(",cnt," | ",i,")");
cnt+=1;
}