update
This commit is contained in:
Valk Richard Li
GitHub
parent
1ddbf43083
commit
b6bd0d4c76
|
|
@ -0,0 +1,493 @@
|
|||
#ifndef __NASAL_RUNTIME_H__
|
||||
#define __NASAL_RUNTIME_H__
|
||||
|
||||
class var
|
||||
{
|
||||
private:
|
||||
int type;
|
||||
std::string name;
|
||||
double number;
|
||||
std::string str;
|
||||
std::list<var> var_list;
|
||||
std::list<var> var_hash;
|
||||
abstract_syntax_tree function;
|
||||
public:
|
||||
var()
|
||||
{
|
||||
type=0;
|
||||
name="";
|
||||
number=0;
|
||||
str="";
|
||||
function.set_clear();
|
||||
}
|
||||
var(const var& p)
|
||||
{
|
||||
type=p.type;
|
||||
name=p.name;
|
||||
number=p.number;
|
||||
str=p.str;
|
||||
function=p.function;
|
||||
}
|
||||
var& operator=(const var& p)
|
||||
{
|
||||
type=p.type;
|
||||
name=p.name;
|
||||
number=p.number;
|
||||
str=p.str;
|
||||
function=p.function;
|
||||
return *this;
|
||||
}
|
||||
void print_information()
|
||||
{
|
||||
std::cout<<"[ type: ";print_token(type);std::cout<<" ]";
|
||||
std::cout<<"[ name: "<<name<<" ]";
|
||||
std::cout<<"[ number: "<<number<<" ]";
|
||||
std::cout<<"[ string: "<<str<<" ]";
|
||||
std::cout<<std::endl;
|
||||
return;
|
||||
}
|
||||
void set_type(const int var_type)
|
||||
{
|
||||
type=var_type;
|
||||
return;
|
||||
}
|
||||
void set_name(std::string var_name_str)
|
||||
{
|
||||
name=var_name_str;
|
||||
return;
|
||||
}
|
||||
void set_number(const double var_number)
|
||||
{
|
||||
number=var_number;
|
||||
return;
|
||||
}
|
||||
void set_string(std::string s)
|
||||
{
|
||||
str=s;
|
||||
return;
|
||||
}
|
||||
void set_function(abstract_syntax_tree func)
|
||||
{
|
||||
function=func;
|
||||
return;
|
||||
}
|
||||
void set_list(std::list<var> p)
|
||||
{
|
||||
var_list=p;
|
||||
return;
|
||||
}
|
||||
void append_list(var p)
|
||||
{
|
||||
var_list.push_back(p);
|
||||
return;
|
||||
}
|
||||
void set_hash(std::list<var> p)
|
||||
{
|
||||
var_hash=p;
|
||||
return;
|
||||
}
|
||||
void append_hash(var p)
|
||||
{
|
||||
var_hash.push_back(p);
|
||||
return;
|
||||
}
|
||||
int get_type()
|
||||
{
|
||||
return type;
|
||||
}
|
||||
std::string get_name()
|
||||
{
|
||||
return name;
|
||||
}
|
||||
double get_number()
|
||||
{
|
||||
return number;
|
||||
}
|
||||
std::string get_string()
|
||||
{
|
||||
return str;
|
||||
}
|
||||
abstract_syntax_tree get_function()
|
||||
{
|
||||
return function;
|
||||
}
|
||||
std::list<var> get_list()
|
||||
{
|
||||
return var_list;
|
||||
}
|
||||
std::list<var> get_hash()
|
||||
{
|
||||
return var_hash;
|
||||
}
|
||||
};
|
||||
|
||||
class var_scope_manager
|
||||
{
|
||||
private:
|
||||
std::list<std::list<var>> scope_list;
|
||||
var error_var;
|
||||
public:
|
||||
var_scope_manager()
|
||||
{
|
||||
scope_list.clear();
|
||||
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();
|
||||
return;
|
||||
}
|
||||
var& search_var(std::string str)
|
||||
{
|
||||
for(std::list<std::list<var>>::iterator i=scope_list.begin();i!=scope_list.end();++i)
|
||||
for(std::list<var>::iterator j=i->begin();j!=i->end();++j)
|
||||
if(j->get_name()==str)
|
||||
return *j;
|
||||
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)
|
||||
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;
|
||||
return;
|
||||
}
|
||||
if(!scope_list.empty())
|
||||
{
|
||||
std::list<std::list<var>>::iterator i=scope_list.end();
|
||||
--i;
|
||||
i->push_back(new_var);
|
||||
}
|
||||
else
|
||||
std::cout<<">>[Runtime] empty scope list."<<std::endl;
|
||||
return;
|
||||
}
|
||||
void add_new_scope()
|
||||
{
|
||||
std::list<var> new_list;
|
||||
scope_list.push_back(new_list);
|
||||
return;
|
||||
}
|
||||
void pop_last_scope()
|
||||
{
|
||||
if(!scope_list.empty())
|
||||
scope_list.pop_back();
|
||||
else
|
||||
std::cout<<">>[Runtime] scope poped empty thing."<<std::endl;
|
||||
return;
|
||||
}
|
||||
};
|
||||
|
||||
class parameter_list
|
||||
{
|
||||
private:
|
||||
std::list<var> parameters;
|
||||
var error_var;
|
||||
public:
|
||||
parameter_list()
|
||||
{
|
||||
parameters.clear();
|
||||
std::string str="__nas_strc_error_ret";
|
||||
error_var.set_name(str);
|
||||
error_var.set_type(__null_type);
|
||||
return;
|
||||
}
|
||||
parameter_list(const parameter_list& p)
|
||||
{
|
||||
parameters=p.parameters;
|
||||
error_var=p.error_var;
|
||||
return;
|
||||
}
|
||||
void set_clear()
|
||||
{
|
||||
parameters.clear();
|
||||
return;
|
||||
}
|
||||
var& search_var(std::string str)
|
||||
{
|
||||
// parameters have nothing to do with scope_list so
|
||||
// if there is a var whose name appeared in scope_list,
|
||||
// the var will be called only in this function area.
|
||||
for(std::list<var>::iterator i=parameters.begin();i!=parameters.end();++i)
|
||||
if(i->get_name()==str)
|
||||
return *i;
|
||||
return error_var;
|
||||
}
|
||||
void add_var(var new_var)
|
||||
{
|
||||
for(std::list<var>::iterator i=parameters.begin();i!=parameters.end();++i)
|
||||
if(i->get_name()==new_var.get_name())
|
||||
{
|
||||
std::cout<<">>[Runtime] redeclaration of var '"<<new_var.get_name()<<"' ."<<std::endl;
|
||||
return;
|
||||
}
|
||||
parameters.push_back(new_var);
|
||||
return;
|
||||
}
|
||||
};
|
||||
|
||||
class nasal_runtime
|
||||
{
|
||||
private:
|
||||
abstract_syntax_tree root;
|
||||
var_scope_manager scope;
|
||||
public:
|
||||
nasal_runtime()
|
||||
{
|
||||
root.set_clear();
|
||||
return;
|
||||
}
|
||||
void run()
|
||||
{
|
||||
std::cout<<">>[Runtime] process begins."<<std::endl;
|
||||
int time_beg,time_end;
|
||||
time_beg=time(NULL);
|
||||
run_root(root);
|
||||
time_end=time(NULL);
|
||||
std::cout<<">>[Runtime] process exited after "<<time_beg-time_end<<" sec(s)."<<std::endl;
|
||||
return;
|
||||
}
|
||||
void set_root(abstract_syntax_tree& tree)
|
||||
{
|
||||
root.set_clear();
|
||||
root=tree;
|
||||
std::cout<<">>[Runtime] runtime got the ast-root: "<<((void *)&tree)<<"->"<<((void *)&root)<<"."<<std::endl;
|
||||
return;
|
||||
}
|
||||
void run_definition(abstract_syntax_tree& tree);
|
||||
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,int run_type,parameter_list paras);
|
||||
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 identifier_call(abstract_syntax_tree& tree,parameter_list paras);
|
||||
var scalar_call(abstract_syntax_tree& tree);
|
||||
};
|
||||
|
||||
void nasal_runtime::run_root(abstract_syntax_tree& tree)
|
||||
{
|
||||
scope.add_new_scope();
|
||||
parameter_list null_para;
|
||||
if(!tree.get_children().empty())
|
||||
{
|
||||
for(std::list<abstract_syntax_tree>::iterator i=tree.get_children().begin();i!=tree.get_children().end();++i)
|
||||
{
|
||||
switch(i->get_type())
|
||||
{
|
||||
case __add_operator:
|
||||
case __sub_operator:
|
||||
case __mul_operator:
|
||||
case __div_operator:
|
||||
case __link_operator:
|
||||
case __and_operator:
|
||||
case __or_operator:
|
||||
case __nor_operator:
|
||||
case __cmp_equal:
|
||||
case __cmp_not_equal:
|
||||
case __cmp_less:
|
||||
case __cmp_less_or_equal:
|
||||
case __cmp_more:
|
||||
case __cmp_more_or_equal:
|
||||
run_calculation(*i);
|
||||
break;
|
||||
case __definition:
|
||||
run_definition(*i);
|
||||
break;
|
||||
case __assignment:
|
||||
run_assignment(*i);
|
||||
break;
|
||||
case __while:
|
||||
case __for:
|
||||
case __forindex:
|
||||
case __foreach:
|
||||
run_loop(*i);
|
||||
break;
|
||||
case __ifelse:
|
||||
run_if_else(*i);
|
||||
break;
|
||||
case __call_function:
|
||||
run_function(*i);
|
||||
break;
|
||||
case __id:
|
||||
case __hash_search:
|
||||
case __list_search:
|
||||
identifier_call(*i,null_para);
|
||||
break;
|
||||
case __number:
|
||||
case __string:
|
||||
scalar_call(*i);
|
||||
break;
|
||||
default:
|
||||
std::cout<<">>[Debug] error occurred."<<std::endl;
|
||||
scope.pop_last_scope();
|
||||
return;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
scope.pop_last_scope();
|
||||
return;
|
||||
}
|
||||
|
||||
void nasal_runtime::run_definition(abstract_syntax_tree& tree)
|
||||
{
|
||||
var new_var;
|
||||
std::list<abstract_syntax_tree>::iterator iter=tree.get_children().begin();
|
||||
std::string var_name=iter->get_var_name();
|
||||
++iter;
|
||||
if(iter==tree.get_children().end())
|
||||
{
|
||||
new_var.set_type(__null_type);
|
||||
new_var.set_name(var_name);
|
||||
scope.add_var(new_var);
|
||||
return;
|
||||
}
|
||||
else
|
||||
{
|
||||
switch(iter->get_type())
|
||||
{
|
||||
case __add_operator:
|
||||
case __sub_operator:
|
||||
case __mul_operator:
|
||||
case __div_operator:
|
||||
case __link_operator:
|
||||
case __and_operator:
|
||||
case __or_operator:
|
||||
case __nor_operator:
|
||||
case __cmp_equal:
|
||||
case __cmp_not_equal:
|
||||
case __cmp_less:
|
||||
case __cmp_less_or_equal:
|
||||
case __cmp_more:
|
||||
case __cmp_more_or_equal:
|
||||
new_var=run_calculation(*iter);
|
||||
break;
|
||||
case __call_function:
|
||||
new_var=run_function(*iter);
|
||||
break;
|
||||
case __id:
|
||||
case __hash_search:
|
||||
case __list_search:
|
||||
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;
|
||||
case __hash:
|
||||
break;
|
||||
default:
|
||||
std::cout<<">>[Debug] error occurred."<<std::endl;
|
||||
return;
|
||||
break;
|
||||
}
|
||||
new_var.set_name(var_name);
|
||||
scope.add_var(new_var);
|
||||
}
|
||||
return;
|
||||
}
|
||||
void nasal_runtime::run_assignment(abstract_syntax_tree& tree)
|
||||
{
|
||||
return;
|
||||
}
|
||||
void nasal_runtime::run_loop(abstract_syntax_tree& tree)
|
||||
{
|
||||
return;
|
||||
}
|
||||
void nasal_runtime::run_if_else(abstract_syntax_tree& tree)
|
||||
{
|
||||
return;
|
||||
}
|
||||
void nasal_runtime::run_block(abstract_syntax_tree& tree,int run_type,parameter_list paras)
|
||||
{
|
||||
scope.add_new_scope();
|
||||
|
||||
scope.pop_last_scope();
|
||||
return;
|
||||
}
|
||||
|
||||
var nasal_runtime::run_calculation(abstract_syntax_tree& tree)
|
||||
{
|
||||
var ret_var;
|
||||
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 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::identifier_call(abstract_syntax_tree& tree,parameter_list paras)
|
||||
{
|
||||
var ret_var;
|
||||
ret_var=paras.search_var(tree.get_var_name());
|
||||
if(ret_var.get_type()==__null_type)
|
||||
ret_var=scope.search_var(tree.get_var_name());
|
||||
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 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
|
||||
Loading…
Reference in New Issue