Finished a calculator!
This commit is contained in:
Valk Richard Li
GitHub
parent
ccd1026819
commit
456f81b76c
|
|
@ -0,0 +1,203 @@
|
|||
#ifndef __ABSTRACT_SYNTAX_TREE_H__
|
||||
#define __ABSTRACT_SYNTAX_TREE_H__
|
||||
|
||||
class ast_tree_node
|
||||
{
|
||||
protected:
|
||||
int line;
|
||||
int type;
|
||||
std::list<ast_tree_node> children;// for node that can be extended
|
||||
|
||||
double num; // for number
|
||||
std::string str; // for string
|
||||
public:
|
||||
ast_tree_node()
|
||||
{
|
||||
line=0;
|
||||
type=__root;
|
||||
children.clear();
|
||||
|
||||
num=0;
|
||||
str="";
|
||||
}
|
||||
void set_line(int _line)
|
||||
{
|
||||
line=_line;
|
||||
return;
|
||||
}
|
||||
int return_type()
|
||||
{
|
||||
return type;
|
||||
}
|
||||
int return_line()
|
||||
{
|
||||
return line;
|
||||
}
|
||||
double run()
|
||||
{
|
||||
if(type==__number)
|
||||
return num;
|
||||
else if(type==__root)
|
||||
{
|
||||
std::cout<<">>[Result(s)]"<<std::endl;
|
||||
for(std::list<ast_tree_node>::iterator i=children.begin();i!=children.end();++i)
|
||||
std::cout<<i->run()<<std::endl;
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
std::list<ast_tree_node>::iterator i=children.begin();
|
||||
double left_child=i->run();
|
||||
++i;
|
||||
double right_child=i->run();
|
||||
switch(type)
|
||||
{
|
||||
case __add_operator:return left_child+right_child;break;
|
||||
case __sub_operator:return left_child-right_child;break;
|
||||
case __mul_operator:return left_child*right_child;break;
|
||||
case __div_operator:return left_child/right_child;break;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
void add_child(ast_tree_node& new_child)
|
||||
{
|
||||
children.push_back(new_child);
|
||||
return;
|
||||
}
|
||||
ast_tree_node& return_last_child()
|
||||
{
|
||||
std::list<ast_tree_node>::iterator i;
|
||||
for(i=children.begin();i!=children.end();++i)
|
||||
;
|
||||
--i;
|
||||
return *i;
|
||||
}
|
||||
void clear_tree()
|
||||
{
|
||||
line=0;
|
||||
type=__root;
|
||||
children.clear();
|
||||
|
||||
num=0;
|
||||
str="";
|
||||
return;
|
||||
}
|
||||
int child_num()
|
||||
{
|
||||
int cnt=0;
|
||||
for(std::list<ast_tree_node>::iterator i=children.begin();i!=children.end();++i)
|
||||
++cnt;
|
||||
return cnt;
|
||||
}
|
||||
void print(int tab_num)
|
||||
{
|
||||
for(int i=0;i<tab_num;++i)
|
||||
std::cout<<" ";
|
||||
if(type==__number)
|
||||
{
|
||||
std::cout<<"[ number:";
|
||||
std::cout<<num;
|
||||
std::cout<<" ]"<<std::endl;
|
||||
return;
|
||||
}
|
||||
else if(type==__string)
|
||||
{
|
||||
std::cout<<"[ string:"<<str<<" ]"<<std::endl;
|
||||
return;
|
||||
}
|
||||
std::cout<<"{ [ node type:";
|
||||
print_token(type);
|
||||
std::cout<<" ]"<<std::endl;
|
||||
for(std::list<ast_tree_node>::iterator i=children.begin();i!=children.end();++i)
|
||||
i->print(tab_num+1);
|
||||
for(int i=0;i<tab_num;++i)
|
||||
std::cout<<" ";
|
||||
std::cout<<"}"<<std::endl;
|
||||
return;
|
||||
}
|
||||
};
|
||||
class operator_expr:public ast_tree_node
|
||||
{
|
||||
public:
|
||||
operator_expr():ast_tree_node()
|
||||
{
|
||||
type=__operator;
|
||||
}
|
||||
void set_operator_type(int oprt_type)
|
||||
{
|
||||
type=oprt_type;
|
||||
return;
|
||||
}
|
||||
};
|
||||
class number_expr:public ast_tree_node
|
||||
{
|
||||
public:
|
||||
number_expr():ast_tree_node()
|
||||
{
|
||||
type=__number;
|
||||
}
|
||||
double return_num()
|
||||
{
|
||||
return num;
|
||||
}
|
||||
void set_number(std::string& str)
|
||||
{
|
||||
type=__number;
|
||||
double is_float=false;
|
||||
int DotPlace=0;
|
||||
for(int i=0;i<(int)str.length();++i)
|
||||
if(str[i]=='.')
|
||||
{
|
||||
is_float=true;
|
||||
DotPlace=i;
|
||||
break;
|
||||
}
|
||||
if(!is_float)
|
||||
{
|
||||
num=0;
|
||||
double acc=1;
|
||||
for(int i=(int)str.length()-1;i>=0;--i)
|
||||
{
|
||||
num+=acc*((double)(str[i]-'0'));
|
||||
acc*=10;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
num=0;
|
||||
double acc=1;
|
||||
double aff=0.1;
|
||||
for(int i=DotPlace+1;i<(int)str.length();++i)
|
||||
{
|
||||
num+=aff*((double)(str[i]-'0'));
|
||||
aff*=0.1;
|
||||
}
|
||||
for(int i=DotPlace-1;i>=0;--i)
|
||||
{
|
||||
num+=acc*((double)(str[i]-'0'));
|
||||
acc*=10;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
};
|
||||
class string_expr:public ast_tree_node
|
||||
{
|
||||
public:
|
||||
string_expr():ast_tree_node()
|
||||
{
|
||||
type=__string;
|
||||
}
|
||||
void set_str(std::string& t)
|
||||
{
|
||||
str=t;
|
||||
return;
|
||||
}
|
||||
std::string& return_str()
|
||||
{
|
||||
return str;
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,196 @@
|
|||
#ifndef __AST_GENERATOR_H__
|
||||
#define __AST_GENERATOR_H__
|
||||
|
||||
class ast_generator
|
||||
{
|
||||
private:
|
||||
ast_tree_node root;
|
||||
std::stack<parse_unit> parse;
|
||||
std::stack<ast_tree_node> node_cache;
|
||||
bool error;
|
||||
public:
|
||||
ast_generator()
|
||||
{
|
||||
error=false;
|
||||
}
|
||||
void input_token_stack(std::stack<parse_unit>& temp)
|
||||
{
|
||||
parse=temp;
|
||||
return;
|
||||
}
|
||||
void number_gen()
|
||||
{
|
||||
number_expr t;
|
||||
t.set_line(parse.top().line);
|
||||
t.set_number(parse.top().content);
|
||||
if(node_cache.empty())
|
||||
node_cache.push(t);
|
||||
else if((node_cache.top().return_type()==__add_operator || node_cache.top().return_type()==__sub_operator || node_cache.top().return_type()==__mul_operator || node_cache.top().return_type()==__div_operator)
|
||||
&& (node_cache.top().child_num()==1))
|
||||
node_cache.top().add_child(t);
|
||||
else
|
||||
{
|
||||
std::cout<<">>[Error] parse error in line "<<parse.top().line<<":missing \';\' at this place."<<std::endl;
|
||||
error=true;
|
||||
}
|
||||
return;
|
||||
}
|
||||
void add_sub_operator_gen()
|
||||
{
|
||||
operator_expr opt;
|
||||
opt.set_line(parse.top().line);
|
||||
opt.set_operator_type(parse.top().type);
|
||||
if(node_cache.empty())
|
||||
{
|
||||
number_expr t;
|
||||
t.set_line(parse.top().line);
|
||||
std::string temp_str="0";
|
||||
t.set_number(temp_str);
|
||||
opt.add_child(t);
|
||||
node_cache.push(opt);
|
||||
}
|
||||
else if(node_cache.top().return_type()==__number
|
||||
|| ((node_cache.top().return_type()==__add_operator
|
||||
|| node_cache.top().return_type()==__sub_operator
|
||||
|| node_cache.top().return_type()==__mul_operator
|
||||
|| node_cache.top().return_type()==__div_operator)
|
||||
&& node_cache.top().child_num()==2))
|
||||
{
|
||||
opt.add_child(node_cache.top());
|
||||
node_cache.pop();
|
||||
node_cache.push(opt);
|
||||
}
|
||||
else
|
||||
{
|
||||
std::cout<<">>[Error] parse error in line "<<parse.top().line<<":missing number/calculation at this place."<<std::endl;
|
||||
error=true;
|
||||
}
|
||||
return;
|
||||
}
|
||||
void mul_div_operator_gen()
|
||||
{
|
||||
operator_expr opt;
|
||||
opt.set_line(parse.top().line);
|
||||
opt.set_operator_type(parse.top().type);
|
||||
if(node_cache.empty())
|
||||
{
|
||||
std::cout<<">>[Error] parse error in line "<<parse.top().line<<":missing number at this place(you cannot use * or / as the begin of calculation)."<<std::endl;
|
||||
error=true;
|
||||
return;
|
||||
}
|
||||
|
||||
if(node_cache.top().return_type()==__number)
|
||||
{
|
||||
// add new leaf node number to operator
|
||||
opt.add_child(node_cache.top());
|
||||
node_cache.pop();
|
||||
node_cache.push(opt);
|
||||
}
|
||||
else if(node_cache.top().return_type()==__add_operator || node_cache.top().return_type()==__sub_operator)
|
||||
{
|
||||
if(node_cache.top().child_num()!=2)
|
||||
{
|
||||
std::cout<<">>[Error] parse error in line "<<parse.top().line<<":missing number at this place."<<std::endl;
|
||||
error=true;
|
||||
}
|
||||
else
|
||||
{
|
||||
// calcu * and / first so pick a number from +-'s children nodes
|
||||
opt.add_child(node_cache.top().return_last_child());
|
||||
parse.pop();
|
||||
// add the next number to fix the operator node's children list
|
||||
if(!parse.empty() && parse.top().type==__number)
|
||||
{
|
||||
number_expr t;
|
||||
t.set_line(parse.top().line);
|
||||
t.set_number(parse.top().content);
|
||||
opt.add_child(t);
|
||||
}
|
||||
else
|
||||
{
|
||||
std::cout<<">>[Error] parse error in line "<<parse.top().line<<":missing number at this place."<<std::endl;
|
||||
error=true;
|
||||
return;
|
||||
}
|
||||
node_cache.top().return_last_child()=opt;
|
||||
}
|
||||
}
|
||||
else if(node_cache.top().return_type()==__mul_operator || node_cache.top().return_type()==__div_operator)
|
||||
{
|
||||
if(node_cache.top().child_num()!=2)
|
||||
{
|
||||
std::cout<<">>[Error] parse error in line "<<parse.top().line<<":missing number at this place."<<std::endl;
|
||||
error=true;
|
||||
}
|
||||
else
|
||||
{
|
||||
opt.add_child(node_cache.top());
|
||||
node_cache.pop();
|
||||
node_cache.push(opt);
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
void gen_main_prog()
|
||||
{
|
||||
error=false;
|
||||
root.clear_tree();
|
||||
// initializing
|
||||
|
||||
while(!node_cache.empty())
|
||||
node_cache.pop();
|
||||
while(!parse.empty())
|
||||
{
|
||||
int type=parse.top().type;
|
||||
bool is_correct=false;
|
||||
switch(type)
|
||||
{
|
||||
case __number:number_gen();break;
|
||||
case __add_operator:add_sub_operator_gen();break;
|
||||
case __sub_operator:add_sub_operator_gen();break;
|
||||
case __mul_operator:mul_div_operator_gen();break;
|
||||
case __div_operator:mul_div_operator_gen();break;
|
||||
case __semi:
|
||||
if(!node_cache.empty())
|
||||
{
|
||||
root.add_child(node_cache.top());
|
||||
node_cache.pop();
|
||||
}
|
||||
break;
|
||||
default:
|
||||
std::cout<<">>[Error] parse error in line "<<parse.top().line<<":";
|
||||
print_token(parse.top().type);
|
||||
std::cout<<" at an incorrect place."<<std::endl;
|
||||
break;
|
||||
}
|
||||
parse.pop();
|
||||
}
|
||||
if(error)
|
||||
{
|
||||
std::cout<<">>[Parse] Error(s) occurred."<<std::endl;
|
||||
std::cout<<">>[Parse] Complete parsing."<<std::endl;
|
||||
}
|
||||
else
|
||||
{
|
||||
std::cout<<">>[Parse] 0 error."<<std::endl;
|
||||
std::cout<<">>[Parse] Complete parsing."<<std::endl;
|
||||
}
|
||||
return;
|
||||
}
|
||||
void print_ast()
|
||||
{
|
||||
std::cout<<">>[Abstract-syntax-tree]"<<std::endl;
|
||||
root.print(0);
|
||||
return;
|
||||
}
|
||||
void run()
|
||||
{
|
||||
if(!error)
|
||||
root.run();
|
||||
else
|
||||
std::cout<<">>[Parse] Error(s) occurred,stop running the code."<<std::endl;
|
||||
return;
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,83 @@
|
|||
#include "nasal.h"
|
||||
int main()
|
||||
{
|
||||
resource_programme_process prog;
|
||||
nasal_lexer lex;
|
||||
nasal_parser pas;
|
||||
ast_generator cod;
|
||||
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. [ast ] |print the abstract syntax tree."<<std::endl;
|
||||
std::cout<<">> 7. [del ] |delete program in memory."<<std::endl;
|
||||
std::cout<<">> 8. [run ] |run the programme in stack. (-lexer -parser)"<<std::endl;
|
||||
std::cout<<">> 9. [rs ] |check the source program."<<std::endl;
|
||||
std::cout<<">>10. [rule ] |see rules of the language."<<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")
|
||||
{
|
||||
lex.lexer_process(prog.use_file());
|
||||
pas.parse_process(lex.return_list());
|
||||
pas.print_parser_stack();
|
||||
}
|
||||
else if(command=="ast")
|
||||
{
|
||||
lex.lexer_process(prog.use_file());
|
||||
pas.parse_process(lex.return_list());
|
||||
cod.input_token_stack(pas.return_stack());
|
||||
cod.gen_main_prog();
|
||||
cod.print_ast();
|
||||
}
|
||||
else if(command=="run")
|
||||
{
|
||||
lex.lexer_process(prog.use_file());
|
||||
pas.parse_process(lex.return_list());
|
||||
cod.input_token_stack(pas.return_stack());
|
||||
cod.gen_main_prog();
|
||||
cod.run();
|
||||
}
|
||||
else if(command=="rule")
|
||||
{
|
||||
std::cout<<">>[Rule] Token types that you can use: number + - * /"<<std::endl;
|
||||
std::cout<<">>[Rule] Each binary operator should have two numbers around it like: 1 + 1"<<std::endl;
|
||||
}
|
||||
else
|
||||
prog.input_file(command);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
#ifndef __NASAL_H__
|
||||
#define __NASAL_H__
|
||||
|
||||
#include <iostream>
|
||||
#include <cstring>
|
||||
#include <fstream>
|
||||
#include <thread>
|
||||
#include <stack>
|
||||
#include <list>
|
||||
|
||||
#include "nasal_token_type.h"
|
||||
#include "nasal_lexer.h"
|
||||
#include "nasal_parser.h"
|
||||
#include "abstract_syntax_tree.h"
|
||||
#include "ast_generator.h"
|
||||
|
||||
#endif
|
||||
|
|
@ -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=='$' || 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,200 @@
|
|||
#ifndef __NASAL_PARSER_H__
|
||||
#define __NASAL_PARSER_H__
|
||||
|
||||
#include "nasal_token_type.h"
|
||||
|
||||
struct parse_unit
|
||||
{
|
||||
int line;
|
||||
int type;
|
||||
std::string content;
|
||||
};
|
||||
|
||||
|
||||
class nasal_parser
|
||||
{
|
||||
private:
|
||||
std::stack<parse_unit> parser;
|
||||
public:
|
||||
void print_parser_stack()
|
||||
{
|
||||
if(parser.empty())
|
||||
return;
|
||||
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;
|
||||
if(line==1)
|
||||
std::cout<<"line "<<line<<" ";
|
||||
else
|
||||
std::cout<<std::endl<<"line "<<line<<" ";
|
||||
}
|
||||
else
|
||||
{
|
||||
while(line!=temp.top().line)
|
||||
{
|
||||
++line;
|
||||
std::cout<<std::endl<<"line "<<line<<" ";
|
||||
}
|
||||
}
|
||||
}
|
||||
std::cout<<"<";
|
||||
print_token(temp.top().type);
|
||||
std::cout<<"> ";
|
||||
parser.pop();
|
||||
}
|
||||
while(!temp.empty())
|
||||
{
|
||||
parser.push(temp.top());
|
||||
temp.pop();
|
||||
}
|
||||
std::cout<<std::endl;
|
||||
return;
|
||||
}
|
||||
std::stack<parse_unit>& return_stack()
|
||||
{
|
||||
return parser;
|
||||
}
|
||||
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==".") || ((*i).content=="?") || ((*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;
|
||||
default:temp_parse.type=__unknown_operator;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<<">>[Parse] [-Warning] Empty lexer list."<<std::endl;
|
||||
return;
|
||||
}
|
||||
while(!temp.empty())
|
||||
{
|
||||
parser.push(temp.top());
|
||||
temp.pop();
|
||||
}
|
||||
return;
|
||||
}
|
||||
};
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,99 @@
|
|||
#ifndef __NASAL_TOKEN_TYPE_H__
|
||||
#define __NASAL_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, // ; , : .
|
||||
__unknown_operator,
|
||||
__var,__func,__return,
|
||||
__if,__elsif,__else,
|
||||
__continue,__break,
|
||||
__for,__forindex,__foreach,__while,
|
||||
//operators & reserve words
|
||||
|
||||
__number,__string,__id,__dynamic_id,
|
||||
//basic elements
|
||||
|
||||
__root,__operator,
|
||||
};
|
||||
|
||||
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 __unknown_operator: context="un_optr";break;
|
||||
case __var: context="var";break;
|
||||
case __func: context="func";break;
|
||||
case __continue: context="ctn";break;
|
||||
case __break: context="brk";break;
|
||||
case __for: context="for";break;
|
||||
case __forindex: context="foridx";break;
|
||||
case __foreach: context="foreh";break;
|
||||
case __while: context="while";break;
|
||||
case __if: context="if";break;
|
||||
case __elsif: context="elsif";break;
|
||||
case __else: context="else";break;
|
||||
case __return: context="rtrn";break;
|
||||
|
||||
case __id: context="id";break;
|
||||
case __dynamic_id: context="id...";break;
|
||||
case __number: context="num";break;
|
||||
case __string: context="str";break;
|
||||
|
||||
case __root: context="root";break;
|
||||
case __operator: context="optr";break;
|
||||
default: context="ukn_tkn";break;
|
||||
}
|
||||
std::cout<<context;
|
||||
return;
|
||||
}
|
||||
|
||||
|
||||
#endif
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
1*1/1+1;
|
||||
1*2*3*4/1-2+3;
|
||||
1+1-1-1+20-2*10;
|
||||
10/10;
|
||||
1*1/1+1;
|
||||
1*2*3*4/1-2+3;
|
||||
1+1-1-1+20-2*10;
|
||||
10/10;
|
||||
1*1/1+1;
|
||||
1*2*3*4/1-2+3;
|
||||
1+1-1-1+20-2*10;
|
||||
10/10;
|
||||
1*1/1+1;
|
||||
1*2*3*4/1-2+3;
|
||||
1+1-1-1+20-2*10;
|
||||
10/10;
|
||||
1*1/1+1;
|
||||
1*2*3*4/1-2+3;
|
||||
1+1-1-1+20-2*10;
|
||||
10/10;
|
||||
1*1/1+1;
|
||||
1*2*3*4/1-2+3;
|
||||
1+1-1-1+20-2*10;
|
||||
10/10;
|
||||
1*1/1+1;
|
||||
1*2*3*4/1-2+3;
|
||||
1+1-1-1+20-2*10;
|
||||
10/10;
|
||||
1*1/1+1;
|
||||
1*2*3*4/1-2+3;
|
||||
1+1-1-1+20-2*10;
|
||||
10/10;
|
||||
Loading…
Reference in New Issue