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-08-06 00:41:41 -07:00 committed by GitHub
parent 3b50f251c9
commit 431a879d2c
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 162 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
version3.0/nasal_gc.h
View File

@ -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;

143
version3.0/nasal_runtime.h
View File

@ -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