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

Add some functions 

but the framework is a little bit bad so i'm trying to make a new one.
This commit is contained in:
Valk Richard Li 2019-10-31 15:38:35 +08:00 committed by GitHub
parent b6bd0d4c76
commit f268911841
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
3 changed files with 253 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
version1.2/hello.nas Normal file
View File

@ -0,0 +1 @@
print("hello world!\n");

2
version1.2/nasal_parser.h
View File

@ -247,7 +247,7 @@ abstract_syntax_tree nasal_parser::function_generate_expr()
while(this_token.type!=__right_curve)
{
temp.set_clear();
if(this_token.type==__id)
if(this_token.type==__id || this_token.type==__dynamic_id)
{
temp.set_node_type(__id);
temp.set_var_name(this_token.content);

276
version1.2/nasal_runtime.h
View File

@ -42,8 +42,43 @@ class var
std::cout<<"[ type: ";print_token(type);std::cout<<" ]";
std::cout<<"[ name: "<<name<<" ]";
std::cout<<"[ number: "<<number<<" ]";
std::cout<<"[ string: "<<str<<" ]";
std::cout<<std::endl;
std::cout<<"[ string: "<<str<<" ]"<<std::endl;
std::cout<<"[ function: ";
function.print_tree(1);
std::cout<<" ]"<<std::endl;
return;
}
void print_detail()
{
switch(type)
{
case __function:
std::cout<<std::endl<<">>[Runtime-error] function type cannot be printed."<<std::endl;
break;
case __number:
std::cout<<number;
break;
case __string:
for(int i=1;i<str.length()-1;++i)
{
if(str[i]!='\\')
std::cout<<str[i];
else
{
switch(str[i+1])
{
case 'n':std::cout<<"\n";++i;break;
case 't':std::cout<<"\t";++i;break;
case 'r':std::cout<<"\r";++i;break;
case '\\':std::cout<<"\\";++i;break;
case '\'':std::cout<<"\'";++i;break;
case '\"':std::cout<<"\"";++i;break;
default:std::cout<<"\\";break;
}
}
}
break;
}
return;
}
void set_type(const int var_type)
@ -91,6 +126,10 @@ class var
var_hash.push_back(p);
return;
}
int get_type()
{
return type;
}
std::string get_name()
{
return name;
@ -121,18 +160,21 @@ class var_scope_manager
{
private:
std::list<std::list<var>> scope_list;
std::list<int> scope_type;
var error_var;
public:
var_scope_manager()
{
scope_list.clear();
std::string str="err_ret";
std::string str="__nas_strc_error_ret";
error_var.set_name(str);
error_var.set_type(__null_type);
return;
}
void set_clear()
{
scope_list.clear();
scope_type.clear();
return;
}
var& search_var(std::string str)
@ -141,40 +183,66 @@ class var_scope_manager
for(std::list<var>::iterator j=i->begin();j!=i->end();++j)
if(j->get_name()==str)
return *j;
std::cout<<">>[Runtime] could not find the var named '"<<str<<"' ."<<std::endl;
std::cout<<std::endl<<">>[Runtime-error] could not find the var '"<<str<<"' ."<<std::endl;
return error_var;
}
void add_var(var new_var)
{
for(std::list<std::list<var>>::iterator i=scope_list.begin();i!=scope_list.end();++i)
std::list<std::list<var>>::iterator i=scope_list.begin();
std::list<int>::iterator t=scope_type.begin();
// get global scopes
for(;i!=scope_list.end();++i,++t)
{
if(*t!=__function)
{
for(std::list<var>::iterator j=i->begin();j!=i->end();++j)
if(j->get_name()==new_var.get_name())
{
std::cout<<std::endl<<">>[Runtime-error] redeclaration of var '"<<new_var.get_name()<<"' ."<<std::endl;
return;
}
}
}
// get parameters_list scope
i=scope_list.end();
--i;
t=scope_type.end();
--t;
if(*t==__function)
{
for(std::list<var>::iterator j=i->begin();j!=i->end();++j)
if(j->get_name()==new_var.get_name())
{
std::cout<<">>[Runtime] redeclaration of var '"<<new_var.get_name()<<"' ."<<std::endl;
std::cout<<std::endl<<">>[Runtime-error] redeclaration of var '"<<new_var.get_name()<<"' ."<<std::endl;
return;
}
}
if(!scope_list.empty())
{
std::list<std::list<var>>::iterator i=scope_list.end();
i=scope_list.end();
--i;
i->push_back(new_var);
}
else
std::cout<<">>[Runtime] empty scope list."<<std::endl;
std::cout<<std::endl<<">>[Runtime-error] empty scope list."<<std::endl;
return;
}
void add_new_scope()
void add_new_scope(int type)
{
std::list<var> new_list;
scope_list.push_back(new_list);
scope_type.push_back(type);
return;
}
void pop_last_scope()
{
if(!scope_list.empty())
{
scope_list.pop_back();
scope_type.pop_back();
}
else
std::cout<<">>[Runtime] scope poped empty thing."<<std::endl;
std::cout<<std::endl<<">>[Runtime-error] scope poped empty thing."<<std::endl;
return;
}
};
@ -195,9 +263,10 @@ class nasal_runtime
std::cout<<">>[Runtime] process begins."<<std::endl;
int time_beg,time_end;
time_beg=time(NULL);
scope.set_clear();
run_root(root);
time_end=time(NULL);
std::cout<<">>[Runtime] process exited after "<<time_beg-time_end<<" sec(s)."<<std::endl;
std::cout<<std::endl<<">>[Runtime] process exited after "<<time_beg-time_end<<" sec(s)."<<std::endl;
return;
}
void set_root(abstract_syntax_tree& tree)
@ -211,17 +280,21 @@ class nasal_runtime
void run_assignment(abstract_syntax_tree& tree);
void run_loop(abstract_syntax_tree& tree);
void run_if_else(abstract_syntax_tree& tree);
void run_block(abstract_syntax_tree& tree);
void run_block(abstract_syntax_tree& tree,int run_type);
void run_root(abstract_syntax_tree& tree);
var run_calculation(abstract_syntax_tree& tree);
var run_function(abstract_syntax_tree& tree);
var list_generation(abstract_syntax_tree& tree);
var hash_generation(abstract_syntax_tree& tree);
var list_search(abstract_syntax_tree& tree);
var hash_search(abstract_syntax_tree& tree);
var identifier_call(abstract_syntax_tree& tree);
var scalar_call(abstract_syntax_tree& tree);
};
void nasal_runtime::run_root(abstract_syntax_tree& tree)
{
scope.add_new_scope();
scope.add_new_scope(__root);
if(!tree.get_children().empty())
{
for(std::list<abstract_syntax_tree>::iterator i=tree.get_children().begin();i!=tree.get_children().end();++i)
@ -322,14 +395,14 @@ void nasal_runtime::run_definition(abstract_syntax_tree& tree)
case __id:
case __hash_search:
case __list_search:
new_var=identifier_call(*iter);
break;
case __number:
case __string:
new_var=scalar_call(*iter);
break;
case __function:
;
new_var.set_type(__function);
new_var.set_function(*iter);
break;
case __list:
break;
@ -357,9 +430,9 @@ void nasal_runtime::run_if_else(abstract_syntax_tree& tree)
{
return;
}
void nasal_runtime::run_block(abstract_syntax_tree& tree)
void nasal_runtime::run_block(abstract_syntax_tree& tree,int run_type)
{
scope.add_new_scope();
scope.add_new_scope(run_type);
scope.pop_last_scope();
return;
@ -367,22 +440,175 @@ void nasal_runtime::run_block(abstract_syntax_tree& tree)
var nasal_runtime::run_calculation(abstract_syntax_tree& tree)
{
var null_var;
return null_var;
var ret_var;
var left_child;
var right_child;
std::list<abstract_syntax_tree>::iterator i;
i=tree.get_children().begin();
switch(i->get_type())
{
case __id:left_child=identifier_call(*i);break;
case __number:
case __string:left_child=scalar_call(*i);break;
case __call_function:left_child=run_function(*i);break;
case __list_search:left_child=list_search(*i);break;
case __hash_search:left_child=hash_search(*i);break;
case __or_operator:
case __and_operator:
case __add_operator:
case __mul_operator:
case __div_operator:
case __link_operator:
case __nor_operator:
case __sub_operator:
case __cmp_equal:
case __cmp_not_equal:
case __cmp_less:
case __cmp_less_or_equal:
case __cmp_more:
case __cmp_more_or_equal:left_child=run_calculation(*i);break;
default:std::cout<<">>[Runtime-error] invalid var."<<std::endl;break;
}
++i;
if(i==tree.get_children().end())
return left_child;
switch(i->get_type())
{
case __id:right_child=identifier_call(*i);break;
case __number:
case __string:right_child=scalar_call(*i);break;
case __call_function:right_child=run_function(*i);break;
case __list_search:right_child=list_search(*i);break;
case __hash_search:right_child=hash_search(*i);break;
case __or_operator:
case __and_operator:
case __add_operator:
case __mul_operator:
case __div_operator:
case __link_operator:
case __nor_operator:
case __sub_operator:
case __cmp_equal:
case __cmp_not_equal:
case __cmp_less:
case __cmp_less_or_equal:
case __cmp_more:
case __cmp_more_or_equal:right_child=run_calculation(*i);break;
default:std::cout<<">>[Runtime-error] invalid var."<<std::endl;break;
}
switch(tree.get_type())
{
case __or_operator:
case __and_operator:
break;
case __add_operator:
case __mul_operator:
case __div_operator:
case __link_operator:
break;
case __nor_operator:
case __sub_operator:
break;
case __cmp_equal:
case __cmp_not_equal:
case __cmp_less:
case __cmp_less_or_equal:
case __cmp_more:
case __cmp_more_or_equal:
break;
}
return ret_var;
}
var nasal_runtime::run_function(abstract_syntax_tree& tree)
{
var null_var;
return null_var;
var ret_var;
scope.add_new_scope(__function);
if(tree.get_var_name()=="print")
{
std::list<var> dynamic_para;
var list_member;
for(std::list<abstract_syntax_tree>::iterator i=tree.get_children().begin();i!=tree.get_children().end();++i)
{
switch(i->get_type())
{
case __id:list_member=identifier_call(*i);break;
case __number:
case __string:list_member=scalar_call(*i);break;
case __call_function:list_member=run_function(*i);break;
case __list_search:list_member=list_search(*i);break;
case __hash_search:list_member=hash_search(*i);break;
case __or_operator:
case __and_operator:
case __add_operator:
case __mul_operator:
case __div_operator:
case __link_operator:
case __nor_operator:
case __sub_operator:
case __cmp_equal:
case __cmp_not_equal:
case __cmp_less:
case __cmp_less_or_equal:
case __cmp_more:
case __cmp_more_or_equal:list_member=run_calculation(*i);break;
default:std::cout<<">>[Runtime-error] invalid var."<<std::endl;break;
}
dynamic_para.push_back(list_member);
}
for(std::list<var>::iterator i=dynamic_para.begin();i!=dynamic_para.end();++i)
i->print_detail();
}
scope.pop_last_scope();
return ret_var;
}
var nasal_runtime::list_generation(abstract_syntax_tree& tree)
{
var new_list;
new_list.set_type(__list);
return new_list;
}
var nasal_runtime::hash_generation(abstract_syntax_tree& tree)
{
var new_hash;
new_hash.set_type(__hash);
return new_hash;
}
var nasal_runtime::list_search(abstract_syntax_tree& tree)
{
var ret_var;
return ret_var;
}
var nasal_runtime::hash_search(abstract_syntax_tree& tree)
{
var ret_var;
return ret_var;
}
var nasal_runtime::identifier_call(abstract_syntax_tree& tree)
{
var null_var;
return null_var;
var ret_var;
ret_var=scope.search_var(tree.get_var_name());
if(ret_var.get_type()==__null_type)
return ret_var;
if(ret_var.get_type()==__number)
std::cout<<ret_var.get_number()<<std::endl;
else if(ret_var.get_type()==__string)
std::cout<<ret_var.get_string()<<std::endl;
return ret_var;
}
var nasal_runtime::scalar_call(abstract_syntax_tree& tree)
{
var null_var;
return null_var;
var ret_var;
if(tree.get_type()==__number)
{
ret_var.set_type(__number);
ret_var.set_number(tree.get_var_number());
}
else if(tree.get_type()==__string)
{
ret_var.set_type(__string);
ret_var.set_string(tree.get_var_string());
}
return ret_var;
}
#endif