From 2923d24e6c2e4927da9b01510b16e40633d9f17b Mon Sep 17 00:00:00 2001
From: Valk Richard Li <48872266+ValKmjolnir@users.noreply.github.com>
Date: Tue, 27 Oct 2020 19:54:47 +0800
Subject: [PATCH] update

---
 nasal_builtin.h |  24 +--
 nasal_gc.h      | 454 ++++++++----------------------------------------
 nasal_runtime.h |  77 ++++----
 test/lexer.nas  |  65 ++++---
 4 files changed, 166 insertions(+), 454 deletions(-)

diff --git a/nasal_builtin.h b/nasal_builtin.h
index e71a2ac..642c67d 100644
--- a/nasal_builtin.h
+++ b/nasal_builtin.h
@@ -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)
diff --git a/nasal_gc.h b/nasal_gc.h
index 8d6a2c9..bdfc36c 100644
--- a/nasal_gc.h
+++ b/nasal_gc.h
@@ -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));
diff --git a/nasal_runtime.h b/nasal_runtime.h
index bf63f0e..4f78140 100644
--- a/nasal_runtime.h
+++ b/nasal_runtime.h
@@ -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;
diff --git a/test/lexer.nas b/test/lexer.nas
index e57c5be..126ed18 100644
--- a/test/lexer.nas
+++ b/test/lexer.nas
@@ -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;
 }
\ No newline at end of file