floraachy/Nasal-Interpreter
1
0
Fork 0
forked from xxq250/Nasal-Interpreter
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

New parser

Browse Source
This commit is contained in:
Valk Richard Li
2019-10-15 22:59:35 +08:00
committed by GitHub
parent 2bd236dd1f
commit 17ca48bb53
13 changed files with 3875 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

407
version1.1/ast.h Normal file
View File

@@ -0,0 +1,407 @@
#ifndef __NASAL_ABSTRACT_SYNTAX_TREE_RUN_H__
#define __NASAL_ABSTRACT_SYNTAX_TREE_RUN_H__
class abstract_syntax_tree
{
protected:
int ast_node_type;
std::list<abstract_syntax_tree> statement_list;
std::list<abstract_syntax_tree> children;
// for definition and assignment
std::list<abstract_syntax_tree> var_list;
std::list<abstract_syntax_tree> var_changed_list;
std::list<abstract_syntax_tree> var_content_list;
// for number and string leaf
double var_number;
std::string var_string;
std::string id_name;
public:
abstract_syntax_tree()
{
ast_node_type=0;
statement_list.clear();
children.clear();
var_list.clear();
var_changed_list.clear();
var_content_list.clear();
var_number=0;
var_string="";
id_name="ukn";
}
abstract_syntax_tree(const abstract_syntax_tree& temp)
{
ast_node_type=temp.ast_node_type;
if(temp.statement_list.empty())
statement_list.clear();
else
statement_list=temp.statement_list;
if(temp.children.empty())
children.clear();
else
children=temp.children;
if(temp.var_list.empty())
var_list.clear();
else
var_list=temp.var_list;
if(temp.var_changed_list.empty())
var_changed_list.clear();
else
var_changed_list=temp.var_changed_list;
if(temp.var_content_list.empty())
var_content_list.clear();
else
var_content_list=temp.var_content_list;
var_number=temp.var_number;
var_string=temp.var_string;
id_name=temp.id_name;
}
abstract_syntax_tree& operator=(const abstract_syntax_tree temp)
{
ast_node_type=temp.ast_node_type;
if(temp.statement_list.empty())
statement_list.clear();
else
statement_list=temp.statement_list;
if(temp.children.empty())
children.clear();
else
children=temp.children;
if(temp.var_list.empty())
var_list.clear();
else
var_list=temp.var_list;
if(temp.var_changed_list.empty())
var_changed_list.clear();
else
var_changed_list=temp.var_changed_list;
if(temp.var_content_list.empty())
var_content_list.clear();
else
var_content_list=temp.var_content_list;
var_number=temp.var_number;
var_string=temp.var_string;
id_name=temp.id_name;
return *this;
}
void tree_set_clear()
{
statement_list.clear();
children.clear();
var_list.clear();
var_changed_list.clear();
var_content_list.clear();
return;
}
void print_ast_node(int tab_num)
{
std::string indent="";
for(int i=0;i<tab_num;++i)
indent+=" ";
std::cout<<indent;
if(ast_node_type==__number)
{
std::cout<<"{Number:"<<var_number<<"}"<<std::endl;
return;
}
else if(ast_node_type==__string)
{
std::cout<<"{String:"<<var_string<<"}"<<std::endl;
return;
}
else if(ast_node_type==__id)
{
std::cout<<"{Identifier:"<<id_name<<"}"<<std::endl;
return;
}
else if(ast_node_type==__definition)
{
std::cout<<"{ Type:";
print_token(ast_node_type);
std::cout<<std::endl<<indent<<" [Var]"<<std::endl;
for(std::list<abstract_syntax_tree>::iterator i=var_list.begin();i!=var_list.end();++i)
i->print_ast_node(tab_num+1);
std::cout<<indent<<" [Content]"<<std::endl;
for(std::list<abstract_syntax_tree>::iterator i=var_content_list.begin();i!=var_content_list.end();++i)
i->print_ast_node(tab_num+1);
return;
}
std::cout<<"{ Type:";
print_token(ast_node_type);
std::cout<<std::endl;
if(!children.empty())
{
std::cout<<indent<<" [Children]"<<std::endl;
for(std::list<abstract_syntax_tree>::iterator i=children.begin();i!=children.end();++i)
i->print_ast_node(tab_num+1);
}
if(!statement_list.empty())
{
std::cout<<indent<<" [Statement]"<<std::endl;
for(std::list<abstract_syntax_tree>::iterator i=statement_list.begin();i!=statement_list.end();++i)
i->print_ast_node(tab_num+1);
}
std::cout<<indent<<"}"<<std::endl;
return;
}
// for root node
void set_root()
{
ast_node_type=__root;
return;
}
// for definition
void set_definition_expr(std::list<abstract_syntax_tree> name_list,std::list<abstract_syntax_tree> var_content)
{
ast_node_type=__definition;
var_list=name_list;
var_content_list=var_content;
return;
}
// for assignment
void set_assignment_expr(std::list<abstract_syntax_tree> to_be_changed,std::list<abstract_syntax_tree> var_content)
{
ast_node_type=__assignment;
var_changed_list=to_be_changed;
var_content_list=var_content;
return;
}
// for choose block
void set_choose_block(std::list<abstract_syntax_tree> if_else_statements)
{
ast_node_type=__ifelse;
statement_list=if_else_statements;
return;
}
// for if
void set_if_expr(abstract_syntax_tree condition,abstract_syntax_tree statements)
{
ast_node_type=__if;
children.push_back(condition);
children.push_back(statements);
return;
}
// for elsif
void set_elsif_expr(abstract_syntax_tree condition,abstract_syntax_tree statements)
{
ast_node_type=__elsif;
children.push_back(condition);
children.push_back(statements);
return;
}
// for else
void set_else_expr(abstract_syntax_tree statements)
{
ast_node_type=__else;
children.push_back(statements);
return;
}
// for statement block
void set_block()
{
ast_node_type=__block;
return;
}
void add_statement(abstract_syntax_tree statement_head)
{
statement_list.push_back(statement_head);
return;
}
// for return expr
void set_node_to_ret(abstract_syntax_tree child)
{
ast_node_type=__return;
children.push_back(child);
return;
}
// for loop
void set_node_to_loop()
{
ast_node_type=__loop;
return;
}
void set_node_to_continue_break(const int type)
{
ast_node_type=type;
return;
}
// for function expr
void set_node_to_function(std::list<abstract_syntax_tree> parameters,abstract_syntax_tree block)
{
ast_node_type=__func;
children=parameters;
statement_list=block.statement_list;
return;
}
// for sub-tree node operator
void set_two_operator(const int operator_type,abstract_syntax_tree f_child,abstract_syntax_tree s_child)
{
ast_node_type=operator_type;
children.push_back(f_child);
children.push_back(s_child);
return;
}
void set_one_operator(const int operator_type,abstract_syntax_tree f_child)
{
ast_node_type=operator_type;
children.push_back(f_child);
return;
}
// for leaf node call
void set_node_to_call_function()
{
ast_node_type=__call_function;
return;
}
void set_node_to_list_search()
{
ast_node_type=__list_search;
return;
}
void set_node_to_hash_search()
{
ast_node_type=__hash_search;
return;
}
// for leaf node list
void set_node_to_list(std::list<abstract_syntax_tree> list_members)
{
ast_node_type=__list;
children=list_members;
return;
}
// for leaf node hash
void set_node_to_hash(std::list<abstract_syntax_tree> hash_members)
{
ast_node_type=__hash;
children=hash_members;
return;
}
// for hash member
void set_node_to_hashmember(std::string& name,abstract_syntax_tree mem_var)
{
ast_node_type=__hash_member;
id_name=name;
children.clear();
children.push_back(mem_var);
return;
}
// for leaf node hash
void set_node_to_hash()
{
ast_node_type=__hash;
return;
}
// for identifier node
void set_node_to_id(std::string& name)
{
ast_node_type=__id;
id_name=name;
return;
}
// for dynamic identifier
void set_node_to_dynid(std::string& name)
{
ast_node_type=__dynamic_id;
id_name="";
for(int i=0;i<(int)name.length()-3;++i)
id_name+=name[i];
return;
}
// for leaf node string
void set_node_to_string(std::string& str)
{
ast_node_type=__string;
var_string=str;
return;
}
std::string get_string()
{
return var_string;
}
// for leaf node number
void set_node_to_number(std::string& str)
{
ast_node_type=__number;
if(str=="nil")
{
var_number=0;
return;
}
if((int)str.length()>2 && (str[1]=='x' || str[1]=='o'))
{
if(str[1]=='x')
{
int num=0;
int pw=1;
for(int i=(int)str.length()-1;i>1;--i)
{
if('0'<=str[i] && str[i]<='9')
num+=(str[i]-'0')*pw;
else if('a'<=str[i] && str[i]<='f')
num+=(10+str[i]-'a')*pw;
else if('A'<=str[i] && str[i]<='F')
num+=(10+str[i]-'A')*pw;
pw<<=4;
}
var_number=(double)num;
}
else
{
int num=0;
int pw=1;
for(int i=(int)str.length()-1;i>1;--i)
{
num+=(str[i]-'0')*pw;
pw<<=3;
}
var_number=(double)num;
}
return;
}
int dot_place=-1;
for(int i=0;i<(int)str.length();++i)
if(str[i]=='.')
{
dot_place=i;
break;
}
if(dot_place==-1)
{
var_number=0;
double pw=1;
for(int i=(int)str.length()-1;i>=0;--i)
{
var_number+=(str[i]-'0')*pw;
pw*=10;
}
}
else
{
var_number=0;
double pw=0.1;
for(int i=dot_place+1;i<(int)str.length();++i)
{
var_number+=(str[i]-'0')*pw;
pw/=10;
}
pw=1;
for(int i=dot_place-1;i>=0;--i)
{
var_number+=(str[i]-'0')*pw;
pw*=10;
}
}
return;
}
double get_number()
{
return var_number;
}
};
#endif

1112
version1.1/ast_generator.h Normal file
View File

File diff suppressed because it is too large Load Diff

88
version1.1/main.cpp Normal file
View File

@@ -0,0 +1,88 @@
#include "nasal.h"
int main()
{
resource_programme_process prog;
nasal_lexer lex;
nasal_parser pas;
generator gen;
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 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.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());
lex.token_list_type_detail_edit();
pas.parse_process(lex.return_list());
pas.print_parser_stack();
pas.parse_main_work();
}
else if(command=="ast")
{
lex.lexer_process(prog.use_file());
lex.token_list_type_detail_edit();
pas.parse_process(lex.return_list());
pas.parse_main_work();
if(!pas.get_error_num())
{
gen.set_ast_empty();
gen.gen_process(lex.return_list());
gen.gen_main_work();
gen.print_ast();
}
}
else if(command=="run")
{
lex.lexer_process(prog.use_file());
lex.token_list_type_detail_edit();
pas.parse_process(lex.return_list());
pas.parse_main_work();
if(!pas.get_error_num())
{
;
}
}
else
prog.input_file(command);
}
return 0;
}

19
version1.1/nasal.h Normal file
View File

@@ -0,0 +1,19 @@
#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 "ast.h"
#include "ast_generator.h"
#endif

535
version1.1/nasal_lexer.h Normal file
View File

@@ -0,0 +1,535 @@
#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];
}
if((int)__token.length()==2)
{
std::cout<<">>[Lexer-warning] lexer: expect a hex-number string after '0x' ."<<std::endl;
__token+="0";
}
}
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];
}
if((int)__token.length()==2)
{
std::cout<<">>[Lexer-warning] lexer: expect a oct-number string after '0o' ."<<std::endl;
__token+="0";
}
}
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;
}
void token_list_type_detail_edit()
{
for(std::list<token>::iterator i=lexer.begin();i!=lexer.end();++i)
{
if((*i).type==RESERVEWORD)
{
if((*i).content=="var")
(*i).type=__var;
else if((*i).content=="func")
(*i).type=__func;
else if((*i).content=="return")
(*i).type=__return;
else if((*i).content=="nil")
(*i).type=__number;
else if((*i).content=="continue")
(*i).type=__continue;
else if((*i).content=="break")
(*i).type=__break;
else if((*i).content=="and")
(*i).type=__and_operator;
else if((*i).content=="or")
(*i).type=__or_operator;
else if((*i).content=="for")
(*i).type=__for;
else if((*i).content=="forindex")
(*i).type=__forindex;
else if((*i).content=="foreach")
(*i).type=__foreach;
else if((*i).content=="while")
(*i).type=__while;
else if((*i).content=="if")
(*i).type=__if;
else if((*i).content=="else")
(*i).type=__else;
else if((*i).content=="elsif")
(*i).type=__elsif;
}
else if(((*i).content=="==") || ((*i).content=="!=") || ((*i).content==">") || ((*i).content==">=") || ((*i).content=="<") || ((*i).content=="<="))
{
if((*i).content=="==")
(*i).type=__cmp_equal;
else if((*i).content=="!=")
(*i).type=__cmp_not_equal;
else if((*i).content==">")
(*i).type=__cmp_more;
else if((*i).content==">=")
(*i).type=__cmp_more_or_equal;
else if((*i).content=="<")
(*i).type=__cmp_less;
else if((*i).content=="<=")
(*i).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 ';':(*i).type=__semi;break;
case ',':(*i).type=__comma;break;
case '=':(*i).type=__equal;break;
case ':':(*i).type=__colon;break;
case '.':(*i).type=__dot;break;
default:(*i).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:(*i).type=__number;break;
case STRING:(*i).type=__string;break;
case IDENTIFIER:(*i).type=__id;break;
case DYNAMIC_ID:(*i).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 '+':(*i).type=__add_operator;break;
case '-':(*i).type=__sub_operator;break;
case '*':(*i).type=__mul_operator;break;
case '/':(*i).type=__div_operator;break;
case '~':(*i).type=__link_operator;break;
case '!':(*i).type=__nor_operator;break;
}
}
else if(((*i).content=="+=") || ((*i).content=="-=") || ((*i).content=="*=") || ((*i).content=="/=") || ((*i).content=="~="))
{
char c=(*i).content[0];
switch(c)
{
case '+':(*i).type=__add_equal;break;
case '-':(*i).type=__sub_equal;break;
case '*':(*i).type=__mul_equal;break;
case '/':(*i).type=__div_equal;break;
case '~':(*i).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 '(':(*i).type=__left_curve;break;
case ')':(*i).type=__right_curve;break;
case '[':(*i).type=__left_bracket;break;
case ']':(*i).type=__right_bracket;break;
case '{':(*i).type=__left_brace;break;
case '}':(*i).type=__right_brace;break;
}
}
}
return;
}
std::list<token>& return_list()
{
return lexer;
}
};
#endif

1393
version1.1/nasal_parser.h Normal file
View File

File diff suppressed because it is too large Load Diff

116
version1.1/nasal_token_type.h Normal file
View File

@@ -0,0 +1,116 @@
#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,
__list,__hash,
__hash_member,
__call_function,__list_search,__hash_search,
__block,
__definition,__assignment,
__function,__loop,__ifelse
};
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="unknown_operator";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 __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 __list: context="list";break;
case __hash: context="hash";break;
case __hash_member: context="hash_member";break;
case __call_function: context="call_func";break;
case __list_search: context="call_list";break;
case __hash_search: context="call_hash";break;
case __block: context="block";break;
case __definition: context="definition";break;
case __assignment: context="assignment";break;
case __function: context="function";break;
case __loop: context="loop";break;
case __ifelse: context="if-else";break;
default: context="unknown_token";break;
}
std::cout<<context;
return;
}
#endif

83
version1.1/test_file/auto_crash.nas Normal file
View File

@@ -0,0 +1,83 @@
# Road check and auto pilot(??) by ValKmjolnir
var position_change = func(position_val,value){
if(position_val+value>180)
position_val += value-360;
else if(position_val+value<-180)
position_val += value+360;
else
position_val += value;
return position_val;
}
var road_check_func = func(){
var lat = props.getNode("/position/latitude-deg",1).getValue();
var lon = props.getNode("/position/longitude-deg",1).getValue();
var position_info = geodinfo(lat,lon);
var position_names = position_info[1].names;
# the friction_factor of freeway runway and road is 1
if((position_names[0]=="Freeway") or (position_names[0]=="Road"))
{
var car_heading = 0;
var lat_change = 0;
var lon_change = 0;
var left_range = 0;
var right_range = 0;
for(var i=0;i>-0.00005;i-=0.000001)
{
car_heading = props.getNode("/orientation/heading-deg",1).getValue();
lat_change = math.sin(math.pi*car_heading/180);
lon_change = -math.cos(math.pi*car_heading/180);
lat = props.getNode("/position/latitude-deg",1).getValue()+0.0001*math.cos(math.pi*car_heading/180);
lon = props.getNode("/position/longitude-deg",1).getValue()+0.0001*math.sin(math.pi*car_heading/180);
var other_position_info = geodinfo(position_change(lat,i*lat_change),position_change(lon,i*lon_change));
var other_names = other_position_info[1].names;
if((other_names[0]=="Freeway") or (other_names[0]=="Road"))
right_range += 1;
else
break;
}
for(var i=0;i<0.00005;i+=0.000001)
{
car_heading = props.getNode("/orientation/heading-deg",1).getValue();
lat_change = math.sin(math.pi*car_heading/180);
lon_change = -math.cos(math.pi*car_heading/180);
lat = props.getNode("/position/latitude-deg",1).getValue()+0.0001*math.cos(math.pi*car_heading/180);
lon = props.getNode("/position/longitude-deg",1).getValue()+0.0001*math.sin(math.pi*car_heading/180);
var other_position_info = geodinfo(position_change(lat,i*lat_change),position_change(lon,i*lon_change));
var other_names = other_position_info[1].names;
if((other_names[0]=="Freeway") or (other_names[0]=="Road"))
left_range+=1;
else
break;
}
#if(left_range>right_range)
#{
# setprop("/controls/flight/rudder",-(right_range-left_range)*(right_range-left_range)/10000);
# print("right ",right_range);
#}
#else if(left_range<right_range)
#{
# setprop("/controls/flight/rudder",(right_range-left_range)*(right_range-left_range)/10000);
# print("left ",left_range);
#}
#else
# setprop("/controls/flight/rudder",0);
props.getNode("/controls/flight/rudder",1).setValue((right_range-left_range)/200);
}
};
var road_check_timer = maketimer(0.1,road_check_func);
var toggle_auto_pilot = func(){
if(!road_check_timer.isRunning)
{
road_check_timer.start();
props.getNode("/sim/messages/copilot",1).setValue("ze dong sheng teaan see tong yee tse yung. Auto Sheng Teaan System Activated!");
}
else
{
road_check_timer.stop();
props.getNode("/sim/messages/copilot",1).setValue("ze dong sheng teaan see tong yee guan bee. Auto Sheng Teaan System is off.");
}
}

30
version1.1/test_file/call_ide.txt Normal file
View File

@@ -0,0 +1,30 @@
id[0] and id[1];
1 or 2;
"str" ==1;
1*1/1+1;
2*3*4/1-2+3;
1-1+20-2*10;
1+s1*(s2+s3[0])-1;
var e=1+s1*(s2+s3[0])-1;
id;
"str";
id(id);
id("str",1,1);
var e=1;
var x=10*2-20;
var id;
var id=[1,2,3,4];
var id={id:"str"};
id();
id.id();
id.id.id();
id[0].id.id(id,"str",1,2,3,4).id[10];
id(0)[1].id;
var hash={
h:"hello",
parent:[id],
};
function_test([1,2,3,4,55],1,2,3,{str:"str"});
var (i,j,k,l,m,n) =[1,2,3,4,5,6];
(var i,j,k)=[1,2,3];
e=e[1:][0];

38
version1.1/test_file/choose.txt Normal file
View File

@@ -0,0 +1,38 @@
if(this_token.type==__if)
{
parse.push(this_token);
return;
}
elsif(this_token.type==__elsif)
{
parse.push(this_token);
return;
}
else if(this_token.type!=__else)
{
exit(0);
}
elsif(this_token.type==__elsif)
{
parse.push(this_token);
return;
}
elsif(this_token.type==__elsif)
{
parse.push(this_token);
return;
}
else if(this==(1+2+3*1))
{
return nil;
}
else
{
parse.push(this_token);
return;
}
if(!id)
{
exit(0);
}

6
version1.1/test_file/first_pro.nas Normal file
View File

@@ -0,0 +1,6 @@
print("hello world!\n");
print("This is the first program for nasal--\n");
var cnt=0;
for(var i=1;i<101;i+=1)
cnt+=i;
print(cnt);

10
version1.1/test_file/func.txt Normal file
View File

@@ -0,0 +1,10 @@
var f=func(n,m,dynamic...)
{
print(n+m," ",dynamic);
n=dynamic;
m=dynamic;
n+=m;
return dynamic;
};
print(f(1,1,0,0,0,0,0,(1+2+3+(1+2+3+4)))[3]);
function([0,1,2,3],{str:"str"});

38
version1.1/test_file/loop.txt Normal file
View File

@@ -0,0 +1,38 @@
while(n==1 )
{
i=i+1;
f(i);
print("str");
}
while(n==1 and "str"==str)
{
print("str");
}
i+=i1;
i+=i.i[0];
i=i.i[0].i(0);
var hash={
f:func {var e=1;return 0;},
};
for(var i=0;i<1024;i+=1)
{
print(i);
}
for(var i=0;(2*512)>=i;i+=1)
{
print(i);
}
foreach(var i;[1+(1+1),2,3,4])
{
print(i);
}
forindex(var i=list;[1,2,3,4])
{
print(i[0]);
}
while(!id)
{
print("yes");
}