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-01-17 17:52:11 +08:00 committed by GitHub
parent 3d87602582
commit cb6f4cad4f
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
2 changed files with 96 additions and 91 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

127
version2.0/abstract_syntax_tree.h
View File

@ -4,12 +4,17 @@
class abstract_syntax_tree
{
private:
// basic elements
int line;
int type;
double number;
std::string str;
std::string name;
int node_type;
std::list<abstract_syntax_tree> children;
// is this node is a number|string|identifier node
// then the three elements below is of great use
double var_number;
std::string var_string;
std::string var_name;
public:
// basic
abstract_syntax_tree();
@ -23,41 +28,41 @@ class abstract_syntax_tree
// set
void set_clear();
void set_type(const int);
void set_line(const int);
void set_string(std::string);
void set_number(std::string);
void set_name(std::string);
void add_child(abstract_syntax_tree);
void set_node_type(const int);
void set_node_line(const int);
void set_var_string(std::string);
void set_var_number(std::string);
void set_var_name(std::string);
void add_children(abstract_syntax_tree);
// get
int get_type();
int get_line();
double get_number();
std::string get_string();
std::string get_name();
int get_node_type();
int get_node_line();
double get_var_number();
std::string get_var_string();
std::string get_var_name();
std::list<abstract_syntax_tree>& get_children();
};
abstract_syntax_tree::abstract_syntax_tree()
{
type=0;
node_type=__null_type;
line=0;
number=0;
str="";
name="";
var_number=0;
var_string="";
var_name="";
children.clear();
return;
}
abstract_syntax_tree::abstract_syntax_tree(const abstract_syntax_tree& p)
abstract_syntax_tree::abstract_syntax_tree(const abstract_syntax_tree& tmp)
{
type=p.type;
line=p.line;
number=p.number;
str=p.str;
name=p.name;
children=p.children;
node_type=tmp.node_type;
line=tmp.line;
var_number=tmp.var_number;
var_string=tmp.var_string;
var_name=tmp.var_name;
children=tmp.children;
return;
}
@ -67,15 +72,15 @@ abstract_syntax_tree::~abstract_syntax_tree()
return;
}
abstract_syntax_tree& abstract_syntax_tree::operator=(const abstract_syntax_tree& p)
abstract_syntax_tree& abstract_syntax_tree::operator=(const abstract_syntax_tree& tmp)
{
type=p.type;
line=p.line;
number=p.number;
str=p.str;
name=p.name;
node_type=tmp.node_type;
line=tmp.line;
var_number=tmp.var_number;
var_string=tmp.var_string;
var_name=tmp.var_name;
children.clear();
children=p.children;
children=tmp.children;
return *this;
}
@ -85,16 +90,16 @@ void abstract_syntax_tree::print_tree(const int n)
for(int i=0;i<n;++i)
__str+="| ";
std::cout<<__str;
print_parse_token(type);
switch(type)
print_parse_token(node_type);
switch(node_type)
{
case __number:std::cout<<": "<<number;break;
case __string:std::cout<<": "<<str;break;
case __number:std::cout<<": "<<var_number;break;
case __string:std::cout<<": "<<var_string;break;
case __id:
case __dynamic_id:
case __call_array:
case __call_hash:
case __call_function:std::cout<<": "<<name;break;
case __call_function:std::cout<<": "<<var_name;break;
}
std::cout<<std::endl;
if(!children.empty())
@ -107,22 +112,22 @@ void abstract_syntax_tree::print_tree(const int n)
void abstract_syntax_tree::set_clear()
{
type=0;
node_type=__null_type;
line=0;
number=0;
str="";
name="";
var_number=0;
var_string="";
var_name="";
children.clear();
return;
}
void abstract_syntax_tree::set_type(const int __type)
void abstract_syntax_tree::set_node_type(const int __node_type)
{
type=__type;
node_type=__node_type;
return;
}
void abstract_syntax_tree::set_line(const int __line)
void abstract_syntax_tree::set_node_line(const int __line)
{
if(__line>=0)
line=__line;
@ -134,25 +139,25 @@ void abstract_syntax_tree::set_line(const int __line)
return;
}
void abstract_syntax_tree::set_string(std::string __str)
void abstract_syntax_tree::set_var_string(std::string __str)
{
str=__str;
var_string=__str;
return;
}
void abstract_syntax_tree::set_number(std::string __str)
void abstract_syntax_tree::set_var_number(std::string __str)
{
number=trans_string_to_number(__str);
var_number=trans_string_to_number(__str);
return;
}
void abstract_syntax_tree::set_name(std::string __str)
void abstract_syntax_tree::set_var_name(std::string __str)
{
name=__str;
var_name=__str;
return;
}
void abstract_syntax_tree::add_child(abstract_syntax_tree p)
void abstract_syntax_tree::add_children(abstract_syntax_tree p)
{
// use abstract_syntax_tree instead of abstract_syntax_tree&
// because when this function get a 'p' from returned value of
@ -161,29 +166,29 @@ void abstract_syntax_tree::add_child(abstract_syntax_tree p)
return;
}
int abstract_syntax_tree::get_type()
int abstract_syntax_tree::get_node_type()
{
return type;
return node_type;
}
int abstract_syntax_tree::get_line()
int abstract_syntax_tree::get_node_line()
{
return line;
}
double abstract_syntax_tree::get_number()
double abstract_syntax_tree::get_var_number()
{
return number;
return var_number;
}
std::string abstract_syntax_tree::get_string()
std::string abstract_syntax_tree::get_var_string()
{
return str;
return var_string;
}
std::string abstract_syntax_tree::get_name()
std::string abstract_syntax_tree::get_var_name()
{
return name;
return var_name;
}
std::list<abstract_syntax_tree>& abstract_syntax_tree::get_children()

60
version2.0/nasal_parse.h
View File

@ -134,8 +134,8 @@ void nasal_parse::main_generate()
warning=0;
// initialize error and warning
root.set_clear();
root.set_line(1);
root.set_type(__root);
root.set_node_line(1);
root.set_node_type(__root);
// initialize root node
while(parse_token_stream.top().type!=__stack_end)
{
@ -151,15 +151,15 @@ void nasal_parse::main_generate()
case __left_curve: case __left_bracket: case __left_brace:
case __func:
this->push_token();
root.add_child(scalar_generate());
root.add_children(scalar_generate());
break;
case __if:
this->push_token();
root.add_child(choose_expr());
root.add_children(choose_expr());
break;
case __while: case __for: case __foreach: case __forindex:
this->push_token();
root.add_child(loop_expr());
root.add_children(loop_expr());
break;
case __semi:break;
case __stack_end:break;
@ -177,7 +177,7 @@ abstract_syntax_tree nasal_parse::scalar_generate()
{
this->get_token();
abstract_syntax_tree scalar_node;
scalar_node.set_line(this_token.line);
scalar_node.set_node_line(this_token.line);
switch(this_token.type)
{
case __nor_operator:
@ -205,32 +205,32 @@ abstract_syntax_tree nasal_parse::function_generate()
abstract_syntax_tree function_node;
abstract_syntax_tree parameter_list;
this->get_token(); // get 'func'
function_node.set_type(__function);
function_node.set_line(this_token.line);
parameter_list.set_type(__parameters);
parameter_list.set_line(this_token.line);
function_node.set_node_type(__function);
function_node.set_node_line(this_token.line);
parameter_list.set_node_type(__parameters);
parameter_list.set_node_line(this_token.line);
return function_node;
}
abstract_syntax_tree nasal_parse::var_outside_definition()
{
abstract_syntax_tree var_outsied_definition_node;
var_outsied_definition_node.set_type(__definition);
var_outsied_definition_node.set_node_type(__definition);
this->get_token();// get 'var'
var_outsied_definition_node.set_line(this_token.line);
var_outsied_definition_node.set_node_line(this_token.line);
this->get_token();
if(this_token.type==__id)
{
abstract_syntax_tree new_var_identifier;
new_var_identifier.set_type(__id);
new_var_identifier.set_line(this_token.line);
new_var_identifier.set_name(this_token.str);
var_outsied_definition_node.add_child(new_var_identifier);
new_var_identifier.set_node_type(__id);
new_var_identifier.set_node_line(this_token.line);
new_var_identifier.set_var_name(this_token.str);
var_outsied_definition_node.add_children(new_var_identifier);
this->get_token();
if(this_token.type==__semi)
this->push_token();// var id
else if(this_token.type==__equal)
var_outsied_definition_node.add_child(scalar_generate());// var id = scalar
var_outsied_definition_node.add_children(scalar_generate());// var id = scalar
else
{
this->push_token();
@ -241,8 +241,8 @@ abstract_syntax_tree nasal_parse::var_outside_definition()
else if(this_token.type==__left_curve)
{
abstract_syntax_tree multi_identifier;
multi_identifier.set_type(__multi_id);
multi_identifier.set_line(this_token.line);
multi_identifier.set_node_type(__multi_id);
multi_identifier.set_node_line(this_token.line);
while(this_token.type!=__right_curve)
{
this->get_token();
@ -256,7 +256,7 @@ abstract_syntax_tree nasal_parse::var_outside_definition()
else
{
this->push_token();
multi_identifier.add_child(scalar_generate());
multi_identifier.add_children(scalar_generate());
}
this->get_token();
if(this_token.type!=__semi && this_token.type!=__right_curve)
@ -267,7 +267,7 @@ abstract_syntax_tree nasal_parse::var_outside_definition()
break;
}
}
var_outsied_definition_node.add_child(multi_identifier);
var_outsied_definition_node.add_children(multi_identifier);
this->get_token();
if(this_token.type==__semi)
this->push_token();// var (id,id,id)
@ -294,19 +294,19 @@ abstract_syntax_tree nasal_parse::var_outside_definition()
abstract_syntax_tree nasal_parse::var_inside_definition()
{
abstract_syntax_tree var_inside_definition_node;
var_inside_definition_node.set_type(__definition);
var_inside_definition_node.set_node_type(__definition);
this->get_token(); // get '('
this->get_token(); // get 'var'
var_inside_definition_node.set_line(this_token.line);
var_inside_definition_node.set_node_line(this_token.line);
return var_inside_definition_node;
}
abstract_syntax_tree nasal_parse::loop_expr()
{
abstract_syntax_tree loop_main_node;
loop_main_node.set_type(__loop);
loop_main_node.set_node_type(__loop);
this->get_token(); // get the first token of loop
loop_main_node.set_line(this_token.line);
loop_main_node.set_node_line(this_token.line);
switch(this_token.type)
{
case __for:
@ -323,19 +323,19 @@ abstract_syntax_tree nasal_parse::choose_expr()
abstract_syntax_tree if_node;
abstract_syntax_tree elsif_node;
abstract_syntax_tree else_node;
choose_main_node.set_type(__ifelse);
choose_main_node.set_node_type(__ifelse);
// get 'if'
this->get_token();
choose_main_node.set_line(this_token.line);
if_node.set_type(__if);
if_node.set_line(this_token.line);
choose_main_node.set_node_line(this_token.line);
if_node.set_node_type(__if);
if_node.set_node_line(this_token.line);
this->get_token();
if(this_token.type!=__left_curve)
{
++error;
print_parse_error(lack_left_curve,this_token.line);
}
if_node.add_child(scalar_generate());
if_node.add_children(scalar_generate());
this->get_token();
if(this_token.type!=__right_curve)
{