From 431a879d2c6805211f34b4fb46719349b89a69c0 Mon Sep 17 00:00:00 2001
From: Valk Richard Li <48872266+ValKmjolnir@users.noreply.github.com>
Date: Thu, 6 Aug 2020 00:41:41 -0700
Subject: [PATCH] update

---
 version3.0/nasal_gc.h      |  60 ++++++----------
 version3.0/nasal_runtime.h | 143 +++++++++++++++++++++++++++++++++++--
 2 files changed, 162 insertions(+), 41 deletions(-)

diff --git a/version3.0/nasal_gc.h b/version3.0/nasal_gc.h
index d66f714..21228f8 100644
--- a/version3.0/nasal_gc.h
+++ b/version3.0/nasal_gc.h
@@ -67,6 +67,8 @@ public:
     bool set_type(int);
     void set_number(double);
     void set_string(std::string);
+    double get_number();
+    std::string get_string();
     nasal_vector& get_vector();
     nasal_hash& get_hash();
     nasal_function& get_func();
@@ -325,6 +327,14 @@ void nasal_scalar::set_string(std::string str)
     *(std::string*)(this->scalar_ptr)=str;
     return;
 }
+double nasal_scalar::get_number()
+{
+    return *(double*)(this->scalar_ptr);
+}
+std::string nasal_scalar::get_string()
+{
+    return *(std::string*)(this->scalar_ptr);
+}
 nasal_vector& nasal_scalar::get_vector()
 {
     return *(nasal_vector*)(this->scalar_ptr);
@@ -341,10 +351,8 @@ nasal_closure& nasal_scalar::get_closure()
 {
     return *(nasal_closure*)(this->scalar_ptr);
 }
-int nasal_scalar::nasal_scalar_add(int a,int b)
+int nasal_scalar::nasal_scalar_add(int a_scalar_addr,int b_scalar_addr)
 {
-    int a_scalar_addr=nasal_vm.mem_get(a);
-    int b_scalar_addr=nasal_vm.mem_get(b);
     if(a_scalar_addr<0 || b_scalar_addr<0)
     {
         std::cout<<">> [vm] scalar_add: memory returned an invalid address"<<std::endl;
@@ -387,10 +395,8 @@ int nasal_scalar::nasal_scalar_add(int a,int b)
     nasal_vm.gc_get(new_value_address).set_number(result);
     return new_value_address;
 }
-int nasal_scalar::nasal_scalar_sub(int a,int b)
+int nasal_scalar::nasal_scalar_sub(int a_scalar_addr,int b_scalar_addr)
 {
-    int a_scalar_addr=nasal_vm.mem_get(a);
-    int b_scalar_addr=nasal_vm.mem_get(b);
     if(a_scalar_addr<0 || b_scalar_addr<0)
     {
         std::cout<<">> [vm] scalar_sub: memory returned an invalid address"<<std::endl;
@@ -433,10 +439,8 @@ int nasal_scalar::nasal_scalar_sub(int a,int b)
     nasal_vm.gc_get(new_value_address).set_number(result);
     return new_value_address;
 }
-int nasal_scalar::nasal_scalar_mult(int a,int b)
+int nasal_scalar::nasal_scalar_mult(int a_scalar_addr,int b_scalar_addr)
 {
-    int a_scalar_addr=nasal_vm.mem_get(a);
-    int b_scalar_addr=nasal_vm.mem_get(b);
     if(a_scalar_addr<0 || b_scalar_addr<0)
     {
         std::cout<<">> [vm] scalar_mult: memory returned an invalid address"<<std::endl;
@@ -479,10 +483,8 @@ int nasal_scalar::nasal_scalar_mult(int a,int b)
     nasal_vm.gc_get(new_value_address).set_number(result);
     return new_value_address;
 }
-int nasal_scalar::nasal_scalar_div(int a,int b)
+int nasal_scalar::nasal_scalar_div(int a_scalar_addr,int b_scalar_addr)
 {
-    int a_scalar_addr=nasal_vm.mem_get(a);
-    int b_scalar_addr=nasal_vm.mem_get(b);
     if(a_scalar_addr<0 || b_scalar_addr<0)
     {
         std::cout<<">> [vm] scalar_div: memory returned an invalid address"<<std::endl;
@@ -525,10 +527,8 @@ int nasal_scalar::nasal_scalar_div(int a,int b)
     nasal_vm.gc_get(new_value_address).set_number(result);
     return new_value_address;
 }
-int nasal_scalar::nasal_scalar_link(int a,int b)
+int nasal_scalar::nasal_scalar_link(int a_scalar_addr,int b_scalar_addr)
 {
-    int a_scalar_addr=nasal_vm.mem_get(a);
-    int b_scalar_addr=nasal_vm.mem_get(b);
     if(a_scalar_addr<0 || b_scalar_addr<0)
     {
         std::cout<<">> [vm] scalar_link: memory returned an invalid address"<<std::endl;
@@ -551,9 +551,8 @@ int nasal_scalar::nasal_scalar_link(int a,int b)
     nasal_vm.gc_get(new_value_address).set_string(result);
     return new_value_address;
 }
-int nasal_scalar::nasal_scalar_unary_sub(int a)
+int nasal_scalar::nasal_scalar_unary_sub(int a_scalar_addr)
 {
-    int a_scalar_addr=nasal_vm.mem_get(a);
     if(a_scalar_addr<0)
     {
         std::cout<<">> [vm] scalar_unary_sub: memory returned an invalid address"<<std::endl;
@@ -582,9 +581,8 @@ int nasal_scalar::nasal_scalar_unary_sub(int a)
     nasal_vm.gc_get(new_value_address).set_number(-a_num);
     return new_value_address;
 }
-int nasal_scalar::nasal_scalar_unary_not(int a)
+int nasal_scalar::nasal_scalar_unary_not(int a_scalar_addr)
 {
-    int a_scalar_addr=nasal_vm.mem_get(a);
     if(a_scalar_addr<0)
     {
         std::cout<<">> [vm] scalar_unary_not: memory returned an invalid address"<<std::endl;
@@ -625,10 +623,8 @@ int nasal_scalar::nasal_scalar_unary_not(int a)
         std::cout<<">> [vm] scalar_unary_not: error value type.number,string and nil can take part in unary not."<<std::endl;
     return new_value_address;
 }
-int nasal_scalar::nasal_scalar_cmp_equal(int a,int b)
+int nasal_scalar::nasal_scalar_cmp_equal(int a_scalar_addr,int b_scalar_addr)
 {
-    int a_scalar_addr=nasal_vm.mem_get(a);
-    int b_scalar_addr=nasal_vm.mem_get(b);
     if(a_scalar_addr<0 || b_scalar_addr<0)
     {
         std::cout<<">> [vm] scalar_cmp_equal: memory returned an invalid address"<<std::endl;
@@ -690,10 +686,8 @@ int nasal_scalar::nasal_scalar_cmp_equal(int a,int b)
     }
     return -1;
 }
-int nasal_scalar::nasal_scalar_cmp_not_equal(int a,int b)
+int nasal_scalar::nasal_scalar_cmp_not_equal(int a_scalar_addr,int b_scalar_addr)
 {
-    int a_scalar_addr=nasal_vm.mem_get(a);
-    int b_scalar_addr=nasal_vm.mem_get(b);
     if(a_scalar_addr<0 || b_scalar_addr<0)
     {
         std::cout<<">> [vm] scalar_cmp_not_equal: memory returned an invalid address"<<std::endl;
@@ -755,10 +749,8 @@ int nasal_scalar::nasal_scalar_cmp_not_equal(int a,int b)
     }
     return -1;
 }
-int nasal_scalar::nasal_scalar_cmp_less(int a,int b)
+int nasal_scalar::nasal_scalar_cmp_less(int a_scalar_addr,int b_scalar_addr)
 {
-    int a_scalar_addr=nasal_vm.mem_get(a);
-    int b_scalar_addr=nasal_vm.mem_get(b);
     if(a_scalar_addr<0 || b_scalar_addr<0)
     {
         std::cout<<">> [vm] scalar_cmp_less: memory returned an invalid address"<<std::endl;
@@ -801,10 +793,8 @@ int nasal_scalar::nasal_scalar_cmp_less(int a,int b)
     nasal_vm.gc_get(new_value_address).set_number(result);
     return new_value_address;
 }
-int nasal_scalar::nasal_scalar_cmp_greater(int a,int b)
+int nasal_scalar::nasal_scalar_cmp_greater(int a_scalar_addr,int b_scalar_addr)
 {
-    int a_scalar_addr=nasal_vm.mem_get(a);
-    int b_scalar_addr=nasal_vm.mem_get(b);
     if(a_scalar_addr<0 || b_scalar_addr<0)
     {
         std::cout<<">> [vm] scalar_cmp_greater: memory returned an invalid address"<<std::endl;
@@ -847,10 +837,8 @@ int nasal_scalar::nasal_scalar_cmp_greater(int a,int b)
     nasal_vm.gc_get(new_value_address).set_number(result);
     return new_value_address;
 }
-int nasal_scalar::nasal_scalar_cmp_less_or_equal(int a,int b)
+int nasal_scalar::nasal_scalar_cmp_less_or_equal(int a_scalar_addr,int b_scalar_addr)
 {
-    int a_scalar_addr=nasal_vm.mem_get(a);
-    int b_scalar_addr=nasal_vm.mem_get(b);
     if(a_scalar_addr<0 || b_scalar_addr<0)
     {
         std::cout<<">> [vm] scalar_cmp_lequal: memory returned an invalid address"<<std::endl;
@@ -893,10 +881,8 @@ int nasal_scalar::nasal_scalar_cmp_less_or_equal(int a,int b)
     nasal_vm.gc_get(new_value_address).set_number(result);
     return new_value_address;
 }
-int nasal_scalar::nasal_scalar_cmp_greater_or_equal(int a,int b)
+int nasal_scalar::nasal_scalar_cmp_greater_or_equal(int a_scalar_addr,int b_scalar_addr)
 {
-    int a_scalar_addr=nasal_vm.mem_get(a);
-    int b_scalar_addr=nasal_vm.mem_get(b);
     if(a_scalar_addr<0 || b_scalar_addr<0)
     {
         std::cout<<">> [vm] scalar_cmp_gequal: memory returned an invalid address"<<std::endl;
diff --git a/version3.0/nasal_runtime.h b/version3.0/nasal_runtime.h
index 6b6b97c..882cbcf 100644
--- a/version3.0/nasal_runtime.h
+++ b/version3.0/nasal_runtime.h
@@ -18,18 +18,34 @@ private:
     int global_scope_address;
     nasal_ast root;
     // process functions are private
+
+    // generate number and return gc place of this number
     int number_generation(nasal_ast&);
+    // generate string and return gc place of this string
     int string_generation(nasal_ast&);
+    // generate vector and return gc place of this vector
     int vector_generation(nasal_ast&);
+    // generate hash and return gc place of this hash
     int hash_generation(nasal_ast&);
+    // generate function and return gc place of this function
     int function_generation(nasal_ast&);
 
+    // main expression block running process
     int main_progress();
+    // function/loop/conditional expression block running process
     int block_progress();
+    // run loop
     int loop_progress();
+    // run conditional
     int conditional_progress();
+    // run function
     int function_progress();
-    int calculation();
+    // get scalars in complex data structure like vector/hash/function/closure(scope)
+    int call_nasal_scalar(nasal_ast&);
+    // get scalars' memory place in complex data structure like vector/hash/function/closure(scope)
+    int call_scalar_mem(nasal_ast&);
+    // calculate scalars
+    int calculation(nasal_ast&);
 public:
     nasal_runtime();
     ~nasal_runtime();
@@ -161,10 +177,129 @@ int nasal_runtime::function_progress()
     int ret_state=rt_exit_without_error;
     return ret_state;
 }
-int nasal_runtime::calculation()
+int nasal_runtime::call_nasal_scalar(nasal_ast& node)
 {
-    int ret_state=rt_exit_without_error;
-    return ret_state;
+    // unfinished
+    return -1;
+}
+int nasal_runtime::call_scalar_mem(nasal_ast& node)
+{
+    // unfinished
+    return -1;
+}
+int nasal_runtime::calculation(nasal_ast& node)
+{
+    int ret_address=-1;
+    int calculation_type=node.get_type();
+    if(calculation_type==ast_number)
+        ret_address=number_generation(node);
+    else if(calculation_type==ast_string)
+        ret_address=string_generation(node);
+    else if(calculation_type==ast_vector)
+        ret_address=vector_generation(node);
+    else if(calculation_type==ast_hash)
+        ret_address=hash_generation(node);
+    else if(calculation_type==ast_function)
+        ret_address=function_generation(node);
+    else if(calculation_type==ast_call)
+        ret_address=call_nasal_scalar(node);
+    else if(calculation_type==ast_add)
+    {
+        int left_gc_addr=calculation(node.get_children()[0]);
+        int right_gc_addr=calculation(node.get_children()[1]);
+        ret_address=nasal_scalar_calculator.nasal_scalar_add(left_gc_addr,right_gc_addr);
+    }
+    else if(calculation_type==ast_sub)
+    {
+        int left_gc_addr=calculation(node.get_children()[0]);
+        int right_gc_addr=calculation(node.get_children()[1]);
+        ret_address=nasal_scalar_calculator.nasal_scalar_sub(left_gc_addr,right_gc_addr);
+    }
+    else if(calculation_type==ast_mult)
+    {
+        int left_gc_addr=calculation(node.get_children()[0]);
+        int right_gc_addr=calculation(node.get_children()[1]);
+        ret_address=nasal_scalar_calculator.nasal_scalar_mult(left_gc_addr,right_gc_addr);
+    }
+    else if(calculation_type==ast_div)
+    {
+        int left_gc_addr=calculation(node.get_children()[0]);
+        int right_gc_addr=calculation(node.get_children()[1]);
+        ret_address=nasal_scalar_calculator.nasal_scalar_div(left_gc_addr,right_gc_addr);
+    }
+    else if(calculation_type==ast_link)
+    {
+        int left_gc_addr=calculation(node.get_children()[0]);
+        int right_gc_addr=calculation(node.get_children()[1]);
+        ret_address=nasal_scalar_calculator.nasal_scalar_link(left_gc_addr,right_gc_addr);
+    }
+    else if(calculation_type==ast_cmp_equal)
+    {
+        int left_gc_addr=calculation(node.get_children()[0]);
+        int right_gc_addr=calculation(node.get_children()[1]);
+        ret_address=nasal_scalar_calculator.nasal_scalar_cmp_equal(left_gc_addr,right_gc_addr);
+    }
+    else if(calculation_type==ast_cmp_not_equal)
+    {
+        int left_gc_addr=calculation(node.get_children()[0]);
+        int right_gc_addr=calculation(node.get_children()[1]);
+        ret_address=nasal_scalar_calculator.nasal_scalar_cmp_not_equal(left_gc_addr,right_gc_addr);
+    }
+    else if(calculation_type==ast_less_than)
+    {
+        int left_gc_addr=calculation(node.get_children()[0]);
+        int right_gc_addr=calculation(node.get_children()[1]);
+        ret_address=nasal_scalar_calculator.nasal_scalar_cmp_less(left_gc_addr,right_gc_addr);
+    }
+    else if(calculation_type==ast_less_equal)
+    {
+        int left_gc_addr=calculation(node.get_children()[0]);
+        int right_gc_addr=calculation(node.get_children()[1]);
+        ret_address=nasal_scalar_calculator.nasal_scalar_cmp_less_or_equal(left_gc_addr,right_gc_addr);
+    }
+    else if(calculation_type==ast_greater_than)
+    {
+        int left_gc_addr=calculation(node.get_children()[0]);
+        int right_gc_addr=calculation(node.get_children()[1]);
+        ret_address=nasal_scalar_calculator.nasal_scalar_cmp_greater(left_gc_addr,right_gc_addr);
+    }
+    else if(calculation_type==ast_greater_equal)
+    {
+        int left_gc_addr=calculation(node.get_children()[0]);
+        int right_gc_addr=calculation(node.get_children()[1]);
+        ret_address=nasal_scalar_calculator.nasal_scalar_cmp_greater_or_equal(left_gc_addr,right_gc_addr);
+    }
+    else if(calculation_type==ast_unary_not)
+    {
+        int addr=calculation(node.get_children()[0]);
+        ret_address=nasal_scalar_calculator.nasal_scalar_unary_not(addr);
+    }
+    else if(calculation_type==ast_unary_sub)
+    {
+        int addr=calculation(node.get_children()[0]);
+        ret_address=nasal_scalar_calculator.nasal_scalar_unary_sub(addr);
+    }
+    else if(calculation_type==ast_trinocular)
+    {
+        int condition_addr=calculation(node.get_children()[0]);
+        int ret_1_addr=calculation(node.get_children()[1]);
+        int ret_2_addr=calculation(node.get_children()[2]);
+        int check_null=nasal_scalar_calculator.nasal_scalar_unary_not(condition_addr);
+        if(nasal_vm.gc_get(check_null).get_number()==0)
+        {
+            ret_address=ret_1_addr;
+            nasal_vm.del_reference(ret_2_addr);
+        }
+        else
+        {
+            ret_address=ret_2_addr;
+            nasal_vm.del_reference(ret_1_addr);
+        }
+        nasal_vm.del_reference(condition_addr);
+        nasal_vm.del_reference(check_null);
+    }
+    // unfinished
+    return ret_address;
 }
 
 #endif
\ No newline at end of file