xxq250
/
Nasal-Interpreter
mirror of https://github.com/ValKmjolnir/Nasal-Interpreter.git
1
0
Fork 0
Code Issues Actions 2 Packages Projects Releases Wiki Activity

Abstract syntax tree

This commit is contained in:
Valk Richard Li 2019-09-07 22:15:03 +08:00 committed by GitHub
parent da8f45ccdb
commit fffddbe042
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
9 changed files with 992 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
version0.15/version0.15.1/abstract_syntax_tree.h Normal file
View File

@ -0,0 +1,15 @@
#ifndef __ABSTRACT_SYNTAX_TREE_H__
#define __ABSTRACT_SYNTAX_TREE_H__
#include <iostream>
#include <cstring>
#include <list>
#include <stack>
class ast_tree
{
private:
}
#endif

29
version0.15/version0.15.1/ast.h Normal file
View File

@ -0,0 +1,29 @@
#ifndef __AST_H__
#define __AST_H__
#include "token_type.h"
#include <stack>
#include <list>
#include <cstring>
enum tree_node_type
{
__syntax_tree_begin=128,
__error_syntax,
__null_statement,
__definition,
__assignment,
__loop,
__choose
};
struct node
{
int type;
int line;
std::string content;
std::list<node> children;
};
#endif

67
version0.15/version0.15.1/main.cpp Normal file
View File

@ -0,0 +1,67 @@
#include "nasal_lexer.h"
#include "nasal_parser.h"
#include <iostream>
#include <cstring>
int main()
{
resource_programme_process prog;
nasal_lexer lex;
nasal_parser pas;
std::string command;
std::cout<<">> Nasal interpreter by ValKmjolnir"<<std::endl;
std::cout<<">> input [help] to find help."<<std::endl;
while(1)
{
std::cout<<">> ";
std::getline(std::cin,command);
if(command=="help")
{
std::cout<<">> Nasal interpreter by ValKmjolnir"<<std::endl;
std::cout<<">> 1. [ ] |input file name to load the file."<<std::endl;
std::cout<<">> 2. [cls ] |clear the screen."<<std::endl;
std::cout<<">> 3. [exit ] |shut down the interpreter."<<std::endl;
std::cout<<">> 4. [lexer ] |run and show the lexer. (-lexer)"<<std::endl;
std::cout<<">> 5. [parser] |run parser. (-parser)"<<std::endl;
std::cout<<">> 6. [del ] |delete program in memory."<<std::endl;
std::cout<<">> 7. [run ] |run the programme in stack. (-lexer -parser)"<<std::endl;
std::cout<<">> 8. [rs ] |check the source program."<<std::endl;
}
else if(command=="cls")
{
system("cls");
//windows system("cls);
//linux system("clear");
//macOS system("clear");
}
else if(command=="rs")
prog.print_file();
else if(command=="exit")
{
break;
}
else if(command=="lexer")
{
lex.lexer_process(prog.use_file());
lex.print_lexer();
}
else if(command=="del")
{
prog.del_file();
std::cout<<">>[Delete] Complete."<<std::endl;
}
else if(command=="parser")
{
pas.parse_process(lex.return_list());
pas.print_parser_stack();
}
else if(command=="run")
{
lex.lexer_process(prog.use_file());
pas.parse_process(lex.return_list());
}
else
prog.input_file(command);
}
return 0;
}

408
version0.15/version0.15.1/nasal_lexer.h Normal file
View File

@ -0,0 +1,408 @@
#ifndef __NASAL_LEXER_H__
#define __NASAL_LEXER_H__
#include <iostream>
#include <fstream>
#include <list>
#include <cstring>
#define OPERATOR 1 // operator
#define IDENTIFIER 2 // id
#define NUMBER 3 // number
#define RESERVEWORD 4 // reserve word
#define STRING 5 // string
#define DYNAMIC_ID 6 // id...
#define FAIL -1 //fail
#define SCANEND -2 //complete scanning
#define ERRORFOUND -3 //error occurred
std::string reserve_word[15]=
{
"for","foreach","forindex","while",
"var","func","break","continue","return",
"if","else","elsif","nil","and","or"
};
int isReserveWord(std::string &p)
{
for(int i=0;i<15;++i)
if(reserve_word[i]==p)
return i+1;
return FAIL;
}
bool isLetter(char t)
{
return (('a'<=t) && (t<='z') || ('A'<=t) && (t<='Z'));
}
bool isNumber(char t)
{
return (('0'<=t) && (t<='9'));
}
bool isHex(char t)
{
return ((('0'<=t) && (t<='9')) || (('a'<=t) && (t<='f')));
}
bool isOct(char t)
{
return (('0'<=t) && (t<='7'));
}
class resource_programme_process
{
private:
char *resource;
public:
resource_programme_process()
{
resource=NULL;
resource=new char[16777216];
}
~resource_programme_process()
{
if(resource)
delete []resource;
}
char* use_file()
{
return resource;
}
void input_file(std::string& filename)
{
std::ifstream fin(filename);
if(fin.fail())
{
std::cout<<">>[Error] Cannot load file: "<<filename<<" ."<<std::endl;
fin.close();
return;
}
memset(resource,0,sizeof(char));
int i=0;
bool findnote=false;// to find the note with # at the head of line.
while(!fin.eof())
{
resource[i]=fin.get();
if(resource[i]=='\n')
findnote=false;
//when meeting '\n' the findnote is set to false then the next statement can be executed.
if(resource[i]!='#' && !findnote)
++i;
else if(resource[i]=='#')
findnote=true;
if(fin.eof())
break;
}
resource[i]='\0';
fin.close();
return;
}
void print_file()
{
if(!resource[0])
{
std::cout<<"0 null"<<std::endl;
return;
}
int line=1;
std::cout<<line<<" ";
for(int i=0;i<16777216;++i)
{
if(!resource[i])
break;
std::cout<<resource[i];
if(resource[i]=='\n')
{
++line;
std::cout<<line<<" ";
}
}
std::cout<<std::endl;
return;
}
void del_file()
{
memset(resource,0,sizeof(char));
return;
}
};
struct token
{
int line;
int type;
std::string content;
};
class nasal_lexer
{
private:
std::list<token> lexer;
public:
void scanner(int &syn,const char* source,std::string &__token,int &ptr,int &line)
{
char temp;
temp=source[ptr];
while(temp==' ' || temp=='\n' || temp=='\t' || temp=='\r' || temp<0 || temp>127)
{
++ptr;
if(temp=='\n')
++line;
temp=source[ptr];
}
__token="";
if(isLetter(temp) || temp=='_')
{
__token+=temp;
++ptr;
temp=source[ptr];
while(isLetter(temp) || isNumber(temp) || temp=='_')
{
__token+=temp;
++ptr;
temp=source[ptr];
}
syn=isReserveWord(__token);
if(syn==FAIL)
syn=IDENTIFIER;
else
syn=RESERVEWORD;
if((syn==IDENTIFIER) && source[ptr]=='.' && source[ptr+1]=='.' && source[ptr+2]=='.')
{
__token+="...";
syn=DYNAMIC_ID;
ptr+=3;
}
}
else if(isNumber(temp))
{
if((source[ptr]=='0') && (source[ptr+1]=='x'))
{
__token+=source[ptr];
__token+=source[ptr+1];
ptr+=2;
temp=source[ptr];
while(isNumber(temp) || isHex(temp))
{
__token+=temp;
++ptr;
temp=source[ptr];
}
}
else if((source[ptr]=='0') && (source[ptr+1]=='o'))
{
__token+=source[ptr];
__token+=source[ptr+1];
ptr+=2;
temp=source[ptr];
while(isNumber(temp) || isOct(temp))
{
__token+=temp;
++ptr;
temp=source[ptr];
}
}
else
{
int PointCnt=0;
while(isNumber(temp))
{
__token+=temp;
++ptr;
temp=source[ptr];
if(temp=='.' && !PointCnt)
{
++PointCnt;
__token+=temp;
++ptr;
temp=source[ptr];
}
}
}
syn=NUMBER;
}
else if(temp=='(' || temp==')' || temp=='[' || temp==']' || temp=='{' ||
temp=='}' || temp==',' || temp==';' || temp=='|' || temp==':' ||
temp=='?' || temp=='.' || temp=='`' || temp=='&'||
temp=='%' || temp=='$' || temp=='^')
{
__token+=temp;
++ptr;
syn=OPERATOR;
}
else if(temp=='\'')
{
syn=STRING;
__token+=temp;
++ptr;
temp=source[ptr];
while(temp!='\'')
{
if(temp=='\\')
{
__token+=temp;
++ptr;
temp=source[ptr];
__token+=temp;
++ptr;
temp=source[ptr];
}
else
{
__token+=temp;
++ptr;
temp=source[ptr];
}
if(temp==0 || temp=='\n')
break;
}
//add the last char \"
if(temp=='\'')
{
__token+=temp;
++ptr;
}
else
__token+=" __missing_end_of_string";
}
else if(temp=='=' || temp=='+' || temp=='-' || temp=='*' || temp=='!' || temp=='/' || temp=='<' || temp=='>' || temp=='~')
{
syn=OPERATOR;
__token+=temp;
++ptr;
temp=source[ptr];
if(temp=='=')
{
__token+=temp;
++ptr;
}
}
else if(temp=='\\')
{
syn=OPERATOR;
__token+=temp;
++ptr;
temp=source[ptr];
if(temp=='=' || temp=='n' || temp=='t' || temp=='r' || temp=='\\' || temp=='\'' || temp=='\"')
{
__token+=temp;
++ptr;
}
}
else if(temp=='\"')
{
syn=STRING;
__token+=temp;
++ptr;
temp=source[ptr];
while(temp!='\"')
{
if(temp=='\\')
{
__token+=temp;
++ptr;
temp=source[ptr];
__token+=temp;
++ptr;
temp=source[ptr];
}
else
{
__token+=temp;
++ptr;
temp=source[ptr];
}
if(temp==0 || temp=='\n')
break;
}
//add the last char \"
if(temp=='\"')
{
__token+=temp;
++ptr;
}
else
__token+=" __missing_end_of_string";
}
else if(temp==0)
{
syn=SCANEND;
return;
}
else
{
syn=FAIL;
std::cout<<">>[Error] Unexpected error occurred: "<<temp<<std::endl;
system("pause");
++ptr;
return;
}
if(__token=="")
{
syn=ERRORFOUND;
std::cout<<">>[Error] Cannot identify "<<std::endl;
}
return;
}
void lexer_process(const char *source)
{
std::cout<<">>[Lexer] max size: "<<lexer.max_size()<<" ."<<std::endl;
lexer.clear();
int syn=0;//token type
int ptr=0;//pointer to one char in ResourcePrograme
int line=1;
std::string __token;
token temp;
while(syn!=SCANEND && syn!=ERRORFOUND)
{
scanner(syn,source,__token,ptr,line);
if(syn>0)//all Syn type is larger than zero
{
temp.line=line;
temp.type=syn;
temp.content=__token;
lexer.push_back(temp);
}
}
std::cout<<">>[Lexer] Complete scanning."<<std::endl;
return;
}
void print_lexer()
{
token temp;
for(std::list<token>::iterator i=lexer.begin();i!=lexer.end();++i)
{
temp=*i;
std::cout<<"line "<<temp.line<<": ";
if(temp.type==OPERATOR)
std::cout<<"( Operator | ";
else if(temp.type==IDENTIFIER)
std::cout<<"( Identifier | ";
else if(temp.type==NUMBER)
std::cout<<"( Number | ";
else if(temp.type==RESERVEWORD)
std::cout<<"( ReserveWord | ";
else if(temp.type==STRING)
std::cout<<"( String | ";
else if(temp.type==DYNAMIC_ID)
std::cout<<"( Identifier | ";
std::cout<<temp.content<<" )"<<std::endl;
}
return;
}
std::list<token>& return_list()
{
return lexer;
}
};
#endif

219
version0.15/version0.15.1/nasal_parser.h Normal file
View File

@ -0,0 +1,219 @@
#ifndef __NASAL_PARSER_H__
#define __NASAL_PARSER_H__
#include "token_type.h"
#include <iostream>
#include <stack>
#include <cstring>
struct parse_unit
{
int line;
int type;
std::string content;
};
class nasal_parser
{
private:
std::stack<parse_unit> parser;
//abstract_syntax_tree ast;
public:
void print_parser_stack()
{
int line=0;
std::stack<parse_unit> temp;
while(!parser.empty())
{
temp.push(parser.top());
if(line!=temp.top().line)
{
if(line+1==temp.top().line)
{
line=temp.top().line;
std::cout<<std::endl<<"line "<<line<<" ";
}
else
{
while(line!=temp.top().line)
{
++line;
std::cout<<std::endl<<"line "<<line<<" ";
}
}
}
print_token(temp.top().type);
std::cout<<" ";
parser.pop();
}
while(!temp.empty())
{
parser.push(temp.top());
temp.pop();
}
std::cout<<std::endl;
return;
}
void print_ast()
{
return;
}
void parse_process(std::list<token>& lexer)
{
while(!parser.empty())
parser.pop();
std::stack<parse_unit> temp;
for(std::list<token>::iterator i=lexer.begin();i!=lexer.end();++i)
{
parse_unit temp_parse;
temp_parse.line=i->line;
temp_parse.content=i->content;
if((*i).type==RESERVEWORD)
{
if((*i).content=="var")
temp_parse.type=__var;
else if((*i).content=="func")
temp_parse.type=__func;
else if((*i).content=="return")
temp_parse.type=__return;
else if((*i).content=="nil")
temp_parse.type=__number;
else if((*i).content=="continue")
temp_parse.type=__continue;
else if((*i).content=="break")
temp_parse.type=__break;
else if((*i).content=="and")
temp_parse.type=__and_operator;
else if((*i).content=="or")
temp_parse.type=__or_operator;
else if((*i).content=="for")
temp_parse.type=__for;
else if((*i).content=="forindex")
temp_parse.type=__forindex;
else if((*i).content=="foreach")
temp_parse.type=__foreach;
else if((*i).content=="while")
temp_parse.type=__while;
else if((*i).content=="if")
temp_parse.type=__if;
else if((*i).content=="else")
temp_parse.type=__else;
else if((*i).content=="elsif")
temp_parse.type=__elsif;
}
else if(((*i).content=="==") || ((*i).content=="!=") || ((*i).content==">") || ((*i).content==">=") || ((*i).content=="<") || ((*i).content=="<="))
{
if((*i).content=="==")
temp_parse.type=__cmp_equal;
else if((*i).content=="!=")
temp_parse.type=__cmp_not_equal;
else if((*i).content==">")
temp_parse.type=__cmp_more;
else if((*i).content==">=")
temp_parse.type=__cmp_more_or_equal;
else if((*i).content=="<")
temp_parse.type=__cmp_less;
else if((*i).content=="<=")
temp_parse.type=__cmp_less_or_equal;
}
else if(((*i).content==";") || ((*i).content==",") || ((*i).content=="=") || ((*i).content==":") || ((*i).content=="."))
{
char c=(*i).content[0];
switch(c)
{
case ';':temp_parse.type=__semi;break;
case ',':temp_parse.type=__comma;break;
case '=':temp_parse.type=__equal;break;
case ':':temp_parse.type=__colon;break;
case '.':temp_parse.type=__dot;break;
}
}
else if(((*i).type==NUMBER) || ((*i).type==STRING) || ((*i).type==IDENTIFIER) || ((*i).type==DYNAMIC_ID))
{
int t=(*i).type;
switch(t)
{
case NUMBER:temp_parse.type=__number;break;
case STRING:temp_parse.type=__string;break;
case IDENTIFIER:temp_parse.type=__id;break;
case DYNAMIC_ID:temp_parse.type=__dynamic_id;break;
}
}
else if(((*i).content=="+") || ((*i).content=="-") || ((*i).content=="*") || ((*i).content=="/") || ((*i).content=="~") || ((*i).content=="!"))
{
char c=(*i).content[0];
switch(c)
{
case '+':temp_parse.type=__add_operator;break;
case '-':temp_parse.type=__sub_operator;break;
case '*':temp_parse.type=__mul_operator;break;
case '/':temp_parse.type=__div_operator;break;
case '~':temp_parse.type=__link_operator;break;
case '!':temp_parse.type=__nor_operator;break;
}
}
else if(((*i).content=="+=") || ((*i).content=="-=") || ((*i).content=="*=") || ((*i).content=="/=") || ((*i).content=="~="))
{
char c=(*i).content[0];
switch(c)
{
case '+':temp_parse.type=__add_equal;break;
case '-':temp_parse.type=__sub_equal;break;
case '*':temp_parse.type=__mul_equal;break;
case '/':temp_parse.type=__div_equal;break;
case '~':temp_parse.type=__link_equal;break;
}
}
else if(((*i).content=="(") || ((*i).content==")") || ((*i).content=="[") || ((*i).content=="]") || ((*i).content=="{") || ((*i).content=="}"))
{
char c=(*i).content[0];
switch(c)
{
case '(':temp_parse.type=__left_curve;break;
case ')':temp_parse.type=__right_curve;break;
case '[':temp_parse.type=__left_bracket;break;
case ']':temp_parse.type=__right_bracket;break;
case '{':temp_parse.type=__left_brace;break;
case '}':temp_parse.type=__right_brace;break;
}
}
temp.push(temp_parse);//push this into stack
}
if(temp.empty())
{
std::cout<<">>[Warning] Empty lexer."<<std::endl;
std::cout<<">>[Parse] Parser exited."<<std::endl;
return;
}
while(!temp.empty())
{
parser.push(temp.top());
temp.pop();
}
std::list<int> error_list;
error_list.clear();
//ast.init_parser_stack(parser);
//ast.tree_generator(error_list);
if(error_list.empty())
{
std::cout<<">>[Parse] 0 error(s)."<<std::endl;
std::cout<<">>[Parse] Complete checking."<<std::endl;
//ast.run();
}
else
{
int line=0;
for(std::list<int>::iterator i=error_list.begin();i!=error_list.end();++i)
if(line!=*i)
{
line=*i;
std::cout<<">>[Parse] parse error in line "<<line<<"."<<std::endl;
}
std::cout<<">>[Parse] Error occurred, stop."<<std::endl;
}
return;
}
};
#endif

29
version0.15/version0.15.1/newm.cpp Normal file
View File

@ -0,0 +1,29 @@
#include<iostream>
using namespace std;
class a
{
public:
int A;
virtual void setA(int t)=0;
virtual int returnA()=0;
};
class b:public a
{
public:
void setA(int t)
{
A=t;
return;
}
int returnA()
{
return A;
}
};
int main()
{
b m;
m.setA(1);
m.returnA();
return 0;
}

14
version0.15/version0.15.1/template.txt Normal file
View File

@ -0,0 +1,14 @@
var e=1;
var e="str";
var e='str';
var e=e;
var e=e[0];
var e=e();
var e=[];
var e={};
var e=func{
return {parent:[class]};
}

121
version0.15/version0.15.1/test.cpp Normal file
View File

@ -0,0 +1,121 @@
#include <iostream>
#include <cstring>
#include <list>
class ASTree
{
public:
int line;
int type;
std::string content;
std::list<ASTree> children;
ASTree()
{
line=0;
type=0;
content="root";
children.clear();
}
virtual ASTree& child(int n)
{
int cnt=0;
std::list<ASTree>::iterator _child;
for(std::list<ASTree>::iterator i=children.begin();i!=children.end();++i)
{
if(n==cnt)
{
_child=i;
break;
}
++cnt;
}
return *_child;
}
virtual int num_children()
{
int cnt=0;
type=0;
for(std::list<ASTree>::iterator i=children.begin();i!=children.end();++i)
++cnt;
return cnt;
}
virtual std::list<ASTree>& return_child()
{
return children;
}
void print_tree()
{
if(content=="leaf")
{
std::cout<<"( "<<content<<" )";
return;
}
std::cout<<"( "<<content<<" ";
for(std::list<ASTree>::iterator i=children.begin();i!=children.end();++i)
{
i->print_tree();
}
std::cout<<" )";
return;
}
virtual void setcontent(std::string str)
{
content=str;
return;
}
};
class ASTList:public ASTree
{
public:
ASTList()
{
line=0;
type=0;
content="subtree";
children.clear();
}
};
class ASTLeaf:public ASTree
{
public:
ASTLeaf()
{
line=0;
content="leaf";
children.clear();
}
ASTree& child(int n)
{
std::list<ASTree>::iterator _child=children.end();
return *_child;
}
int num_children()
{
return 0;
}
};
int main()
{
ASTList root;
ASTList subroot;
ASTLeaf leaf;
root.setcontent("root");
leaf.setcontent("1");
subroot.return_child().push_back(leaf);
leaf.setcontent("2");
subroot.return_child().push_back(leaf);
subroot.setcontent("+");
root.return_child().push_back(subroot);
leaf.setcontent("2147483648");
root.return_child().push_back(leaf);
subroot.return_child().push_back(subroot);
root.return_child().push_back(subroot);
root.print_tree();
return 0;
}

90
version0.15/version0.15.1/token_type.h Normal file
View File

@ -0,0 +1,90 @@
#ifndef __TOKEN_TYPE_H__
#define __TOKEN_TYPE_H__
#include <cstring>
enum token_type
{
__stack_end=1,
__equal,// =
__cmp_equal,__cmp_not_equal,// == !=
__cmp_less,__cmp_less_or_equal,// < <=
__cmp_more,__cmp_more_or_equal,// > >=
__and_operator,__or_operator,__nor_operator,// and or !
__add_operator,__sub_operator,// + -
__mul_operator,__div_operator,__link_operator,// * / ~
__add_equal,__sub_equal,// += -=
__mul_equal,__div_equal,__link_equal,// *= /= ~=
__left_brace,__right_brace,// {}
__left_bracket,__right_bracket,// []
__left_curve,__right_curve,// ()
__semi,__comma,__colon,__dot,// ; , : .
__var,__func,__return,
__if,__elsif,__else,
__id,__dynamic_id,
__continue,__break,
__for,__forindex,__foreach,__while,
//end of operators & reserve words
__number,__string,
};
void print_token(int type)
{
std::string context="";
switch(type)
{
case __stack_end: context="#";break;
case __equal: context="=";break;
case __cmp_equal: context="==";break;
case __cmp_not_equal: context="!=";break;
case __cmp_less: context="<";break;
case __cmp_less_or_equal: context="<=";break;
case __cmp_more: context=">";break;
case __cmp_more_or_equal: context=">=";break;
case __and_operator: context="and";break;
case __or_operator: context="or";break;
case __nor_operator: context="!";break;
case __add_operator: context="+";break;
case __sub_operator: context="-";break;
case __mul_operator: context="*";break;
case __div_operator: context="/";break;
case __link_operator: context="~";break;
case __add_equal: context="+=";break;
case __sub_equal: context="-=";break;
case __mul_equal: context="*=";break;
case __div_equal: context="/=";break;
case __link_equal: context="~=";break;
case __left_brace: context="{";break;
case __right_brace: context="}";break;
case __left_bracket: context="[";break;
case __right_bracket: context="]";break;
case __left_curve: context="(";break;
case __right_curve: context=")";break;
case __semi: context=";";break;
case __comma: context=",";break;
case __colon: context=":";break;
case __dot: context=".";break;
case __var: context="var";break;
case __func: context="func";break;
case __id: context="id";break;
case __dynamic_id: context="id...";break;
case __number: context="number";break;
case __string: context="string";break;
case __continue: context="continue";break;
case __break: context="break";break;
case __for: context="for";break;
case __forindex: context="forindex";break;
case __foreach: context="foreach";break;
case __while: context="while";break;
case __if: context="if";break;
case __elsif: context="elsif";break;
case __else: context="else";break;
case __return: context="return";break;
default: context="unknown_token";break;
}
std::cout<<context;
return;
}
#endif