Try ast but failed
This commit is contained in:
Valk Richard Li
GitHub
parent
caf9d35a82
commit
da8f45ccdb
|
|
@ -0,0 +1,82 @@
|
|||
#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;
|
||||
};
|
||||
|
||||
class abstract_syntax_tree
|
||||
{
|
||||
private:
|
||||
node tree;
|
||||
std::stack<parse_unit> parser_stack;
|
||||
public:
|
||||
abstract_syntax_tree()
|
||||
{
|
||||
tree.type=__syntax_tree_begin;
|
||||
tree.line=0;
|
||||
tree.content="";
|
||||
tree.children.clear();
|
||||
}
|
||||
void init_parser_stack(std::stack<parse_unit>& temp)
|
||||
{
|
||||
parser_stack=temp;
|
||||
return;
|
||||
}
|
||||
void tree_generator(std::list<int>& error_list)
|
||||
{
|
||||
while(!parser_stack.empty())
|
||||
{
|
||||
int type=parser_stack.top().type;
|
||||
node child_node;
|
||||
child_node.line=parser_stack.top().line;
|
||||
child_node.content="";
|
||||
child_node.children.clear();
|
||||
switch(type)
|
||||
{
|
||||
case __var:break;
|
||||
case __id:break;
|
||||
case __number:break;
|
||||
case __string:break;
|
||||
case __if:break;
|
||||
case __for:break;
|
||||
case __forindex:break;
|
||||
case __foreach:break;
|
||||
case __while:break;
|
||||
case __semi:child_node.type=__null_statement;break;
|
||||
default:child_node.type=__error_syntax;break;
|
||||
}
|
||||
if(child_node.type==__error_syntax)
|
||||
error_list.push_back(parser_stack.top().line);
|
||||
parser_stack.pop();
|
||||
}
|
||||
return;
|
||||
}
|
||||
void run()
|
||||
{
|
||||
;
|
||||
return;
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
#include "nasal_lexer.h"
|
||||
#include "nasal_parser.h"
|
||||
#include "ast.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 all elements in stack."<<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;
|
||||
}
|
||||
|
|
@ -0,0 +1,269 @@
|
|||
%%
|
||||
|
||||
program
|
||||
:statement program
|
||||
;
|
||||
|
||||
scalar
|
||||
:number
|
||||
|string
|
||||
|calculation
|
||||
;
|
||||
call
|
||||
:call_list
|
||||
|call_hash
|
||||
|call_function
|
||||
;
|
||||
id_list
|
||||
:id ',' id
|
||||
|id ',' id_list
|
||||
;
|
||||
scalar_list
|
||||
:scalar ',' scalar
|
||||
|scalar ',' call
|
||||
|scalar ',' function
|
||||
|scalar ',' id_list
|
||||
|scalar ',' list
|
||||
|scalar ',' hash
|
||||
|call ',' scalar
|
||||
|call ',' call
|
||||
|call ',' function
|
||||
|call ',' id_list
|
||||
|call ',' list
|
||||
|call ',' hash
|
||||
|function ',' scalar
|
||||
|function ',' call
|
||||
|function ',' function
|
||||
|function ',' id_list
|
||||
|function ',' list
|
||||
|function ',' hash
|
||||
|scalar ',' scalar_list
|
||||
|call ',' scalar_list
|
||||
|function ',' scalar_list
|
||||
|id ',' scalar_list
|
||||
|list ',' scalar_list
|
||||
|hash ',' scalar_list
|
||||
;
|
||||
|
||||
subvec
|
||||
:'['id':'']'
|
||||
|'['id':'id']'
|
||||
|'['id':'scalar']'
|
||||
|'['id':'call']'
|
||||
|'['scalar':'']'
|
||||
|'['scalar':'id']'
|
||||
|'['scalar':'scalar']'
|
||||
|'['scalar':'call']'
|
||||
|'['call':'']'
|
||||
|'['call':'id']'
|
||||
|'['call':'scalar']'
|
||||
|'['call':'call']'
|
||||
;
|
||||
call_list
|
||||
:id'['id']'
|
||||
|id'['scalar']'
|
||||
|id'['call']'
|
||||
|id subvec
|
||||
|call'['id']'
|
||||
|call'['scalar']'
|
||||
|call'['call']'
|
||||
|call subvec
|
||||
;
|
||||
call_hash
|
||||
:id '.' id
|
||||
|id '.' call
|
||||
|call '.' id
|
||||
|call '.' call
|
||||
;
|
||||
call_function
|
||||
:id '('')'
|
||||
|id '(' id ')'
|
||||
|id '(' scalar ')'
|
||||
|id '(' dynamic_id ')'
|
||||
|id '(' call ')'
|
||||
|id '(' function ')'
|
||||
|id '(' id_list ')'
|
||||
|id '(' scalar_list ')'
|
||||
;
|
||||
list
|
||||
:'['']'
|
||||
|'['id']'
|
||||
|'['scalar']'
|
||||
|'['call']'
|
||||
|'['list']'
|
||||
|'['hash']'
|
||||
|'['id_list']'
|
||||
|'['scalar_list']'
|
||||
;
|
||||
hash_member
|
||||
:id':'id
|
||||
|id':'scalar
|
||||
|id':'call
|
||||
|id':'function
|
||||
|id':'list
|
||||
|id':'hash
|
||||
;
|
||||
hash_members
|
||||
:hash_member,hash_member
|
||||
|hash_member,hash_members
|
||||
;
|
||||
hash
|
||||
:'{''}'
|
||||
|'{'hash_member'}'
|
||||
|'{'hash_members'}'
|
||||
;
|
||||
operator
|
||||
:'+'
|
||||
|'-'
|
||||
|'*'
|
||||
|'/'
|
||||
|'~'
|
||||
|'=='
|
||||
|'!='
|
||||
|'<'
|
||||
|'<='
|
||||
|'>'
|
||||
|'>='
|
||||
|and
|
||||
|or
|
||||
;
|
||||
|
||||
calculation
|
||||
:id operator id
|
||||
|id operator scalar
|
||||
|id operator call
|
||||
|scalar operator id
|
||||
|scalar operator scalar
|
||||
|scalar operator call
|
||||
|call operator id
|
||||
|call operator scalar
|
||||
|call operator call
|
||||
|'('id')'
|
||||
|'('scalar')'
|
||||
|'('call')'
|
||||
|'!' id
|
||||
|'!' scalar
|
||||
|'!' call
|
||||
|'-' id
|
||||
|'-' scalar
|
||||
|'-' call
|
||||
|'+' id
|
||||
|'+' scalar
|
||||
|'+' call
|
||||
;
|
||||
|
||||
definition
|
||||
:var id '=' id ';'
|
||||
|var id '=' scalar ';'
|
||||
|var id '=' call ';'
|
||||
|var id '=' function
|
||||
|var id '=' list ';'
|
||||
|var id '=' hash ';'
|
||||
;
|
||||
|
||||
assign_operator
|
||||
:'+='
|
||||
|'-='
|
||||
|'*='
|
||||
|'/='
|
||||
|'~='
|
||||
|'='
|
||||
;
|
||||
pre_assignment
|
||||
:id assign_operator id
|
||||
|id assign_operator scalar
|
||||
|id assign_operator call
|
||||
|call assign_operator id
|
||||
|call assign_operator scalar
|
||||
|call assign_operator call
|
||||
;
|
||||
assignment
|
||||
:pre_assignment ';'
|
||||
|id '=' function
|
||||
|call '=' function
|
||||
;
|
||||
|
||||
function
|
||||
:func'{''}'
|
||||
|func'{'statement'}'
|
||||
|func'('')''{''}'
|
||||
|func'('')''{'statement'}'
|
||||
|func'('id')''{''}'
|
||||
|func'('id')''{'statement'}'
|
||||
|func'('scalar')''{''}'
|
||||
|func'('scalar')''{'statement'}'
|
||||
|func'('call')''{''}'
|
||||
|func'('call')''{'statement'}'
|
||||
|func'('list')''{''}'
|
||||
|func'('list')''{'statement}'
|
||||
|func'('hash')''{''}'
|
||||
|func'('hash')''{'statement'}'
|
||||
|func'('function')''{''}'
|
||||
|func'('function')''{'statement'}'
|
||||
|func'('dynamic_id')''{''}'
|
||||
|func'('dynamic_id')''{'statement'}'
|
||||
|func'('id_list')''{''}'
|
||||
|func'('id_list')''{'statement'}'
|
||||
;
|
||||
|
||||
choose
|
||||
:if'('id')''{''}'
|
||||
|if'('scalar')''{''}'
|
||||
|if'('call')''{'statement'}'
|
||||
|if'('id')''{'statement'}'
|
||||
|if'('scalar')''{'statement'}'
|
||||
|if'('call')''{'statement'}'
|
||||
|else if'('id')''{''}'
|
||||
|else if'('scalar')''{''}'
|
||||
|else if'('call')''{'statement'}'
|
||||
|else if'('id')''{'statement'}'
|
||||
|else if'('scalar')''{'statement'}'
|
||||
|else if'('call')''{'statement'}'
|
||||
|elsif'('id')''{''}'
|
||||
|elsif'('scalar')''{''}'
|
||||
|elsif'('call')''{'statement'}'
|
||||
|elsif'('id')''{'statement'}'
|
||||
|elsif'('scalar')''{'statement'}'
|
||||
|elsif'('call')''{'statement'}'
|
||||
|else'{''}'
|
||||
|else'{'statement'}'
|
||||
;
|
||||
|
||||
loop
|
||||
:while'('id')''{''}'
|
||||
|while'('scalar')''{''}'
|
||||
|while'('call')''{''}'
|
||||
|while'('id')''{'statement'}'
|
||||
|while'('scalar')''{'statement'}'
|
||||
|while'('call')''{'statement'}'
|
||||
|foreach'('statement id')''{''}'
|
||||
|foreach'('statement scalar')''{''}'
|
||||
|foreach'('statement call')''{''}'
|
||||
|foreach'('statement list')''{''}'
|
||||
|foreach'('statement id')''{'statement'}'
|
||||
|foreach'('statement scalar')''{'statement'}'
|
||||
|foreach'('statement call')''{'statement'}'
|
||||
|foreach'('statement list')''{'statement'}'
|
||||
|forindex'('statement id')''{''}'
|
||||
|forindex'('statement scalar')''{''}'
|
||||
|forindex'('statement call')''{''}'
|
||||
|forindex'('statement list')''{''}'
|
||||
|forindex'('statement id')''{'statement'}'
|
||||
|forindex'('statement scalar')''{'statement'}'
|
||||
|forindex'('statement call')''{'statement'}'
|
||||
|forindex'('statement list')''{'statement'}'
|
||||
|for'('statement pre_assignment')''{''}'
|
||||
|for'('statement pre_assignment')''{'statement'}'
|
||||
;
|
||||
|
||||
statement
|
||||
:definition
|
||||
|assignment
|
||||
|loop
|
||||
|choose
|
||||
|return_scalar
|
||||
|continue ';'
|
||||
|break ';'
|
||||
|call_function';'
|
||||
|';'
|
||||
;
|
||||
|
|
@ -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
|
||||
|
|
@ -0,0 +1,211 @@
|
|||
#ifndef __NASAL_PARSER_H__
|
||||
#define __NASAL_PARSER_H__
|
||||
|
||||
#include "ast.h"
|
||||
#include <iostream>
|
||||
#include <stack>
|
||||
#include <cstring>
|
||||
|
||||
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
|
||||
|
|
@ -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]};
|
||||
}
|
||||
|
|
@ -0,0 +1,96 @@
|
|||
#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;
|
||||
}
|
||||
|
||||
struct parse_unit
|
||||
{
|
||||
int line;
|
||||
int type;
|
||||
std::string content;
|
||||
};
|
||||
|
||||
#endif
|
||||
Loading…
Reference in New Issue