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

subset of nasal

This commit is contained in:
Valk Richard Li 2019-11-04 18:11:16 +08:00 committed by GitHub
parent f90d1eef91
commit 3357fa8140
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 831 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
balloon/abstract_syntax_tree.h Normal file
View File

@ -0,0 +1,33 @@
#ifndef __ABSTRACT_SYNTAX_TREE_H__
#define __ABSTRACT_SYNTAX_TREE_H__
class abstract_syntax_tree
{
private:
int type;
double number;
std::string str;
std::string name;
std::list<abstract_syntax_tree> children;
public:
abstract_syntax_tree()
{
type=__null_node;
number=0;
str="";
name="";
children.clear();
return;
}
abstract_syntax_tree(const abstract_syntax_tree& p)
{
type=p.type;
number=p.number;
str=p.str;
name=p.name;
children=p.children;
return;
}
};
#endif

16
balloon/balloon.h Normal file
View File

@ -0,0 +1,16 @@
#ifndef __BALLOON_H__
#define __BALLOON_H__
#include <iostream>
#include <cstring>
#include <fstream>
#include <list>
#include <stack>
#include "balloon_type.h"
#include "balloon_var.h"
#include "abstract_syntax_tree.h"
#include "balloon_lexer.h"
#include "balloon_parse.h"
#endif

414
balloon/balloon_lexer.h Normal file
View File

@ -0,0 +1,414 @@
#ifndef __BALLOON_LEXER_H__
#define __BALLOON_LEXER_H__
std::string reserve_word[15]=
{
"for","foreach","forindex","while",
"var","func","break","continue","return",
"if","else","elsif","nil","and","or"
};
int is_reserve_word(std::string str)
{
for(int i=0;i<15;++i)
if(reserve_word[i]==str)
return __reserve_word;
return __token_identifier;
}
class resource_file
{
private:
std::list<char> resource;
public:
void set_clear()
{
resource.clear();
return;
}
void input_file(std::string filename)
{
std::ifstream fin(filename,std::ios::binary);
char c;
while(!fin.eof())
{
c=fin.get();
if(fin.eof())
break;
resource.push_back(c);
}
resource.push_back('\n');
return;
}
std::list<char>& get_resource()
{
return resource;
}
void print_file()
{
int line=1;
std::cout<<line<<" ";
for(std::list<char>::iterator i=resource.begin();i!=resource.end();++i)
{
std::cout<<*i;
if(*i=='\n')
{
++line;
std::cout<<line<<" ";
}
}
std::cout<<std::endl;
return;
}
};
struct token
{
int line;
int type;
std::string str;
};
class balloon_lexer
{
private:
int error;
std::list<token> token_list;
std::list<token> detail_token;
public:
void set_clear()
{
token_list.clear();
detail_token.clear();
return;
}
void print_token_list()
{
for(std::list<token>::iterator i=token_list.begin();i!=token_list.end();++i)
{
std::cout<<"( ";
print_token(i->type);
std::cout<<" | "<<i->str<<" )"<<std::endl;
}
return;
}
void print_detail_token_list()
{
for(std::list<token>::iterator i=detail_token.begin();i!=detail_token.end();++i)
{
std::cout<<"( ";
print_detail_token(i->type);
std::cout<<" | "<<i->str<<" )"<<std::endl;
}
return;
}
void scanner(std::list<char>& res)
{
token_list.clear();
error=0;
int line=1;
std::string token_str;
std::list<char>::iterator ptr=res.begin();
while(1)
{
while(*ptr==' ' || *ptr=='\n' || *ptr=='\t' || *ptr=='\r' || *ptr<0 || *ptr>127)
{
if(*ptr=='\n')
++line;
++ptr;
if(ptr==res.end())
break;
}
if(ptr==res.end())
break;
if(*ptr=='_' || ('a'<=*ptr && *ptr<='z') || ('A'<=*ptr && *ptr<='Z'))
{
token_str="";
while(*ptr=='_' || ('a'<=*ptr && *ptr<='z') || ('A'<=*ptr && *ptr<='Z') || ('0'<=*ptr && *ptr<='9'))
{
token_str+=*ptr;
++ptr;
if(ptr==res.end())
break;
}
if(*ptr=='.')
{
++ptr;
if(ptr!=res.end() && *ptr=='.')
{
++ptr;
if(ptr!=res.end() && *ptr=='.')
{
token_str+="...";
++ptr;
}
else
{
--ptr;
--ptr;
}
}
else
--ptr;
}
token new_token;
new_token.line=line;
new_token.type=is_reserve_word(token_str);
new_token.str=token_str;
token_list.push_back(new_token);
if(ptr==res.end())
break;
}
else if('0'<=*ptr && *ptr<='9')
{
token_str="";
while(('0'<=*ptr && *ptr<='9') || *ptr=='.' || *ptr=='x' || *ptr=='o')
{
token_str+=*ptr;
++ptr;
if(ptr==res.end())
break;
}
token new_token;
new_token.line=line;
new_token.type=__token_number;
new_token.str=token_str;
token_list.push_back(new_token);
if(ptr==res.end())
break;
}
else if(*ptr=='(' || *ptr==')' || *ptr=='[' || *ptr==']' || *ptr=='{' ||
*ptr=='}' || *ptr==',' || *ptr==';' || *ptr=='|' || *ptr==':' ||
*ptr=='?' || *ptr=='.' || *ptr=='`' || *ptr=='&' || *ptr=='@' ||
*ptr=='%' || *ptr=='$' || *ptr=='^' || *ptr=='\\')
{
token_str="";
token_str+=*ptr;
token new_token;
new_token.line=line;
new_token.type=__token_operator;
new_token.str=token_str;
token_list.push_back(new_token);
++ptr;
if(ptr==res.end())
break;
}
else if(*ptr=='\'' || *ptr=='\"')
{
char str_begin=*ptr;
token_str="";
++ptr;
if(ptr==res.end())
break;
while(*ptr!=str_begin && *ptr!='\n')
{
token_str+=*ptr;
if(*ptr=='\\')
{
++ptr;
if(ptr!=res.end())
{
token_str+=*ptr;
++ptr;
}
}
else
++ptr;
if(ptr==res.end())
break;
}
if(ptr==res.end() || *ptr!=str_begin)
{
++error;
std::cout<<">>[Lexer-error] line "<<line<<": this string must have a \' "<<str_begin<<" \' as its end."<<std::endl;
}
else
{
token new_token;
new_token.line=line;
new_token.type=__token_string;
new_token.str=token_str;
token_list.push_back(new_token);
}
++ptr;
if(ptr==res.end())
break;
}
else if(*ptr=='=' || *ptr=='+' || *ptr=='-' || *ptr=='*' || *ptr=='!' || *ptr=='/' || *ptr=='<' || *ptr=='>' || *ptr=='~')
{
token_str="";
token_str+=*ptr;
++ptr;
if(ptr!=res.end() && *ptr=='=')
{
token_str+=*ptr;
++ptr;
}
token new_token;
new_token.line=line;
new_token.type=__token_operator;
new_token.str=token_str;
token_list.push_back(new_token);
if(ptr==res.end())
break;
}
else if(*ptr=='#')
{
while(ptr!=res.end() && *ptr!='\n')++ptr;
if(ptr==res.end())
break;
}
}
return;
}
void generate_detail_token()
{
token detail;
detail_token.clear();
for(std::list<token>::iterator i=token_list.begin();i!=token_list.end();++i)
{
if(i->type==__token_number)
{
detail.line=i->line;
detail.str=i->str;
detail.type=__number;
detail_token.push_back(detail);
}
else if(i->type==__token_string)
{
detail.line=i->line;
detail.str=i->str;
detail.type=__string;
detail_token.push_back(detail);
}
else if(i->type==__reserve_word)
{
detail.line=i->line;
detail.str=i->str;
if(i->str=="for")
detail.type=__for;
else if(i->str=="foreach")
detail.type=__foreach;
else if(i->str=="forindex")
detail.type=__forindex;
else if(i->str=="while")
detail.type=__while;
else if(i->str=="var")
detail.type=__var;
else if(i->str=="func")
detail.type=__func;
else if(i->str=="break")
detail.type=__break;
else if(i->str=="continue")
detail.type=__continue;
else if(i->str=="return")
detail.type=__return;
else if(i->str=="if")
detail.type=__if;
else if(i->str=="else")
detail.type=__else;
else if(i->str=="elsif")
detail.type=__elsif;
else if(i->str=="nil")
detail.type=__nil;
else if(i->str=="and")
detail.type=__and_operator;
else if(i->str=="or")
detail.type=__or_operator;
detail_token.push_back(detail);
}
else if(i->type==__token_identifier)
{
detail.line=i->line;
detail.str=i->str;
if(i->str.length()<=3)
detail.type=__id;
else
{
std::string tempstr=i->str;
int strback=tempstr.length()-1;
if(tempstr[strback]=='.' && tempstr[strback-1]=='.' && tempstr[strback-2]=='.')
detail.type=__dynamic_id;
else
detail.type=__id;
}
detail_token.push_back(detail);
}
else if(i->type==__token_operator)
{
detail.line=i->line;
detail.str=i->str;
if(i->str=="+")
detail.type=__add_operator;
else if(i->str=="-")
detail.type=__sub_operator;
else if(i->str=="*")
detail.type=__mul_operator;
else if(i->str=="/")
detail.type=__div_operator;
else if(i->str=="~")
detail.type=__link_operator;
else if(i->str=="+=")
detail.type=__add_equal;
else if(i->str=="-=")
detail.type=__sub_equal;
else if(i->str=="*=")
detail.type=__mul_equal;
else if(i->str=="/=")
detail.type=__div_equal;
else if(i->str=="~=")
detail.type=__link_equal;
else if(i->str=="=")
detail.type=__equal;
else if(i->str=="==")
detail.type=__cmp_equal;
else if(i->str=="!=")
detail.type=__cmp_not_equal;
else if(i->str=="<")
detail.type=__cmp_less;
else if(i->str=="<=")
detail.type=__cmp_less_or_equal;
else if(i->str==">")
detail.type=__cmp_more;
else if(i->str==">=")
detail.type=__cmp_more_or_equal;
else if(i->str==";")
detail.type=__semi;
else if(i->str==".")
detail.type=__dot;
else if(i->str==":")
detail.type=__colon;
else if(i->str==",")
detail.type=__comma;
else if(i->str=="!")
detail.type=__nor_operator;
else if(i->str=="[")
detail.type=__left_bracket;
else if(i->str=="]")
detail.type=__right_bracket;
else if(i->str=="(")
detail.type=__left_curve;
else if(i->str==")")
detail.type=__right_curve;
else if(i->str=="{")
detail.type=__left_brace;
else if(i->str=="}")
detail.type=__right_brace;
else
{
++error;
std::cout<<">>[Lexer-error] line "<<detail.line<<": unknown operator."<<std::endl;
}
detail_token.push_back(detail);
}
}
return;
}
std::list<token>& get_detail_token()
{
return detail_token;
}
};
#endif

37
balloon/balloon_parse.h Normal file
View File

@ -0,0 +1,37 @@
#ifndef __BALLOON_PARSE_H__
#define __BALLOON_PARSE_H__
class balloon_parse
{
private:
std::stack<token> detail;
token this_token;
int error;
int warning;
public:
void get_token()
{
if(!detail.empty())
{
this_token=detail.top();
detail.pop();
}
else
this_token.type=0;
return;
}
void get_detail_token_stream(std::list<token>& tk_list)
{
std::stack<token> temp;
for(std::list<token>::iterator i=tk_list.begin();i!=tk_list.end();++i)
temp.push(*i);
while(!temp.empty())
{
detail.push(temp.top());
temp.pop();
}
return;
}
};
#endif

134
balloon/balloon_type.h Normal file
View File

@ -0,0 +1,134 @@
#ifndef __BALLOON_TYPE_H__
#define __BALLOON_TYPE_H__
enum token_type
{
__token_number=1,
__token_string,
__reserve_word,
__token_identifier,
__token_operator
};
void print_token(int type)
{
std::string str;
switch(type)
{
case __token_number: str="number ";break;
case __token_string: str="string ";break;
case __reserve_word: str="reserve word ";break;
case __token_identifier:str="identifier ";break;
case __token_operator: str="operator ";break;
default: str="unknown ";break;
}
std::cout<<str;
return;
}
enum parse_type
{
__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,
__continue,__break,
__for,__forindex,__foreach,__while,
__nil,
//operators & reserve words
__number,__string,__id,__dynamic_id,
//basic elements
__null_node,
__root,
__loop,
__ifelse,
__function,
__definition,
__assignment,
__call_array,
__call_hash,
__call_function
};
void print_detail_token(int type)
{
std::string context="";
switch(type)
{
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 __continue: context="continye"; 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;
case __nil: context="nil";break;
case __id: context="id";break;
case __dynamic_id: context="id...";break;
case __number: context="num";break;
case __string: context="str";break;
case __null_node: context="null node";break;
case __root: context="root";break;
case __loop: context="loop";break;
case __ifelse: context="if-else";break;
case __function: context="function";break;
case __definition: context="definition";break;
case __assignment: context="assignment";break;
case __call_array: context="call array";break;
case __call_hash: context="call hash";break;
case __call_function: context="call func";break;
default: context="undefined token";break;
}
std::cout<<context;
return;
}
#endif

132
balloon/balloon_var.h Normal file
View File

@ -0,0 +1,132 @@
#ifndef __BALLOON_VAR_H__
#define __BALLOON_VAR_H__
enum var_type
{
__null_type,
__var_number,
__var_string,
__var_array,
__var_hash
};
class var
{
private:
int type;
double number;
std::string str;
std::string name;
std::list<var> balloon_array;
std::list<var> balloon_hash;
public:
var()
{
number=0;
str="";
name="";
balloon_array.clear();
balloon_hash.clear();
return;
}
var(const var& p)
{
type=p.type;
number=p.number;
str=p.str;
name=p.name;
balloon_array=p.balloon_array;
balloon_hash=p.balloon_hash;
return;
}
var& operator=(const var p)
{
type=p.type;
number=p.number;
str=p.str;
name=p.name;
balloon_array.clear();
balloon_hash.clear();
balloon_array=p.balloon_array;
balloon_hash=p.balloon_hash;
return *this;
}
void set_type(int);
void set_name(std::string);
void set_number(double);
void set_string(std::string);
void append_array(var);
void append_hash(var);
std::string get_name();
double get_number();
std::string get_string();
var& get_array_member(int);
var& get_hash_member(std::string);
};
var error_var;
void var::set_type(int _type)
{
type=_type;
return;
}
void var::set_name(std::string _name)
{
name=_name;
return;
}
void var::set_number(double _num)
{
number=_num;
return;
}
void var::set_string(std::string _str)
{
str=_str;
return;
}
void var::append_array(var _new_var)
{
balloon_array.push_back(_new_var);
return;
}
void var::append_hash(var _new_var)
{
balloon_hash.push_back(_new_var);
return;
}
std::string var::get_name()
{
return name;
}
double var::get_number()
{
return number;
}
std::string var::get_string()
{
return str;
}
var& var::get_array_member(int _place)
{
if(balloon_array.empty())
{
std::cout<<">>[Runtime-error] overflow when searching member "<<_place<<" but the max size of array \'"<<name<<"\' is 0."<<std::endl;
return error_var;
}
int cnt=0;
for(std::list<var>::iterator i=balloon_array.begin();i!=balloon_array.end();++i,++cnt)
if(cnt==_place)
return *i;
std::cout<<">>[Runtime-error] overflow when searching member "<<_place<<" but the max size of array \'"<<name<<"\' is "<<cnt<<"(this means 0-"<<cnt-1<<")."<<std::endl;
return error_var;
}
var& var::get_hash_member(std::string _name)
{
for(std::list<var>::iterator i=balloon_hash.begin();i!=balloon_hash.end();++i)
if(i->name==_name)
return *i;
std::cout<<">>[Runtime-error] hash \'"<<name<<"\' does not have a member named \'"<<_name<<"\'"<<std::endl;
return error_var;
}
#endif

65
balloon/main.cpp Normal file
View File

@ -0,0 +1,65 @@
#include "balloon.h"
int main()
{
resource_file prog;
balloon_lexer lex;
std::string command;
std::cout<<">> Balloon 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<<">> Balloon 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 and see parse stack & parse result(s). (-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;
}
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.scanner(prog.get_resource());
lex.print_token_list();
}
else if(command=="del")
{
prog.set_clear();
lex.set_clear();
std::cout<<">>[Delete] Complete."<<std::endl;
}
else if(command=="parser")
{
lex.scanner(prog.get_resource());
lex.generate_detail_token();
}
else if(command=="ast")
{
;
}
else if(command=="run")
{
;
}
else
prog.input_file(command);
}
return 0;
}