diff --git a/version0.5/a.txt b/version0.5/a.txt new file mode 100644 index 0000000..4ce2ef2 --- /dev/null +++ b/version0.5/a.txt @@ -0,0 +1,66 @@ +print("a",e); +var e=1; +var e="str"; +var e=[]; +var e={}; +var e=e[0]; +var e=e.e; +var e=e(0); +var e=e(); +var e=e[e()]; +var e=[1,e,1,e,1]; +var e=[e,e,e,e]; +var e={e:1,e:2,e:3}; +var e=e[e.e]; +e=1; +e="str"; +e=[]; +e={}; +e=e[0]; +e=e.e; +e=e(0); +e=e(); +e=e[e()]; +e=[1,e,1,e,1]; +e=[e,e,e,e]; +e={e:1,e:2,e:3}; +e=e[e.e]; +e=e.e(); +var e={ + e:1, + e:func(){}, + e:func(e,e){}, + e:func(){ + e; + e; + }, + e:func(e,e){ + e; + e; + } +}; +var e=func(){} +var e=func(e,e){} +var e=func(){e;e;} +var e=func(e,e){e;e;} +var e=func(e,e,e,e,e){ + e=1; + e=e[0]; + e=e(e,e,e); + return e; +} +e+=e; +e-=e; +e*=e; +e/=e; +e~=e; +e+=(e-e)*(e+(e/e)); +e=e-e*(!2); +if(e==1) + print("hello world"); +else if(e==2) + e=3; +else + print("error"); +for(var i=1;i<9;i+=1) + print("h"); diff --git a/version0.5/b.txt b/version0.5/b.txt new file mode 100644 index 0000000..feb51e7 --- /dev/null +++ b/version0.5/b.txt @@ -0,0 +1,16 @@ +if(e==1) + print("hello world"); +else if(e==2) + e=3; +else + print("error"); +while(1) +{ + print("m"); +} +for(var i=1;i<9;i+=1) + print("h"); +foreach(i;keys(e)) + print("h"); +forindex(i;keys(e)) + print("h"); diff --git a/version0.5/ebnf.cpp b/version0.5/ebnf.cpp new file mode 100644 index 0000000..5540e8c --- /dev/null +++ b/version0.5/ebnf.cpp @@ -0,0 +1,77 @@ +// +//definition: +//var e=1; +//var e=e; +//var e=e[0]; +//var e=e[i]; +//var e=e.e; +//var e=e[func()]; +//var e=func(); +// identifier +// scalar +// call_func -> identifier func_name() +// array_search -> identifier e[0] e[e] +// hash_search -> identifier e.e + +<1> ::= + //NUMBER + //STRING + | + ？？？？？？？？？？| <+>|<->|<*>||<~>|||<==>||<<>|<<=>|<>>|<>=> | + ？？？？？？？？？？<(> | <)> // find a way to distinguish while(scalar) with real (scalar+-scalar)*scalar +<2> ::= + | <,> | + | <,> +<3> ::= + // IDENTIFIER + <[> | <]> //__array_search + <.> //__hash_search + <(> ||| <)> //__call_func + <(><)> //__call_func_null +<4> ::= + | <,> +<5> ::= + <:> ||<__func> + <:> <(><)> <{><}> + <:> <(> | <)> <{><}> + <:> <(><)> <{> | <}> + <:> <(> | <)> <{> | <}> +<6> ::= + | <,> +<7> ::= + <=> | <;> + <=> <[><]> <;> + <=> <{><}> <;> + <=> <[> ||| <]> <;> + <=> <{> | <}> <;> +<8> ::= + <=> | <;> + <=> <[><]> <;> + <=> <{><}> <;> + <=> <[> ||| <]> <;> + <=> <{> | <}> <;> +<9><__func> ::= + <=> <(><)> <{><}> + <=> <(> | <)> <{><}> + <=> <(><)> <{> | <}> + <=> <(> | <)> <{> | <}> +<10> ::= + <(> <)> + <(> <)> <{> | <}> + | <(> <)> + | <(> <{> | <}> + <(> <;> <+=>|<-=>|<*=>||<~=>|<=> <)> + <(> <;> <+=>|<-=>|<*=>||<~=>|<=> <)> <{> | <}> +<11> ::= + | <(> <)> <{> | <}> + | <(> <)> + <(> <)> <{> | <}> + <(> <)> + <{> | <}> + +<12> ::= + ||<__func>|| + || <;> + | <;> +<13> ::= + | diff --git a/version0.5/nasal.h b/version0.5/nasal.h new file mode 100644 index 0000000..33228c7 --- /dev/null +++ b/version0.5/nasal.h @@ -0,0 +1,36 @@ +#ifndef __NASAL_H__ +#define __NASAL_H__ + +#include +#include +#include +#include +#include +#include +#include +#include + +namespace nasal +{ +#include "nasal_functional.h" + +#include "nasal_var.h" +#include "nasal_list.h" +#include "nasal_hash.h" +#include "nasal_token.h" +#include "nasal_func.h" + +#include "nasal_var.cpp" +#include "nasal_list.cpp" +#include "nasal_hash.cpp" +#include "nasal_print.h" +#include "nasal_var_stack.h" +#include "nasal_func_stack.h" +#include "nasal_token.cpp" +#include "nasal_func.cpp" + +#include "nasal_lexer.h" +#include "nasal_parse.h" +} + +#endif diff --git a/version0.5/nasal_func.cpp b/version0.5/nasal_func.cpp new file mode 100644 index 0000000..fa8de63 --- /dev/null +++ b/version0.5/nasal_func.cpp @@ -0,0 +1,174 @@ +#ifndef __NASAL_FUNC_CPP__ +#define __NASAL_FUNC_CPP__ + +#include "nasal_func.h" + +func::func() +{ + statement_head=new token_unit; + statement_head->line=0; + statement_head->type=FUNC_BEGIN; + statement_head->content="__func_begin"; + statement_head->next=NULL; + + parameter_head=new parameter; + parameter_head->param_var.type=VAR_NONE; + parameter_head->param_var.data=NULL; + parameter_head->var_name="__null_var"; + parameter_head->next=NULL; +} +func::func(const func& temp) +{ + token_unit *statement_temp=statement_head; + token_unit *temp_state=temp.statement_head; + parameter *parameter_temp=parameter_head; + parameter *temp_param=temp.parameter_head; + while(temp_state->next) + { + temp_state=temp_state->next; + statement_temp->next=new token_unit; + statement_temp=statement_temp->next; + statement_temp->line=temp_state->line; + statement_temp->content=temp_state->content; + statement_temp->type=temp_state->type; + statement_temp->next=NULL; + } + while(temp_param->next) + { + temp_param=temp_param->next; + parameter_temp->next=new parameter; + parameter_temp=parameter_temp->next; + parameter_temp->param_var=temp_param->param_var; + parameter_temp->var_name=temp_param->var_name; + parameter_temp->next=NULL; + } +} +func::~func() +{ + token_unit *statement_temp=statement_head; + token_unit *statement_last_unit=NULL; + parameter *parameter_temp=parameter_head; + parameter *parameter_last_unit=NULL; + + while(statement_temp->next) + { + statement_last_unit=statement_temp; + statement_temp=statement_temp->next; + delete statement_last_unit; + } + delete statement_temp; + while(parameter_temp->next) + { + parameter_last_unit=parameter_temp; + parameter_temp=parameter_temp->next; + delete parameter_last_unit; + } + delete parameter_temp; +} +func& func::operator=(const func& temp) +{ + token_unit *statement_temp=statement_head->next; + token_unit *temp_state=temp.statement_head; + parameter *parameter_temp=parameter_head->next; + parameter *temp_param=temp.parameter_head; + + token_unit *statement_last=NULL; + parameter *parameter_last=NULL; + if(statement_temp) + { + while(statement_temp->next) + { + statement_last=statement_temp; + statement_temp=statement_temp->next; + delete statement_last; + } + delete statement_temp; + } + if(parameter_temp) + { + while(parameter_temp->next) + { + parameter_last=parameter_temp; + parameter_temp=parameter_temp->next; + delete parameter_last; + } + delete parameter_temp; + } + statement_head->next=NULL; + parameter_head->next=NULL; + statement_temp=statement_head; + parameter_temp=parameter_head; + while(temp_state->next) + { + temp_state=temp_state->next; + statement_temp->next=new token_unit; + statement_temp=statement_temp->next; + statement_temp->line=temp_state->line; + statement_temp->content=temp_state->content; + statement_temp->type=temp_state->type; + statement_temp->next=NULL; + } + while(temp_param->next) + { + temp_param=temp_param->next; + parameter_temp->next=new parameter; + parameter_temp=parameter_temp->next; + parameter_temp->param_var=temp_param->param_var; + parameter_temp->var_name=temp_param->var_name; + parameter_temp->next=NULL; + } + return *this; +} +void func::append_var(std::string& varia_name,var& p) +{ + parameter *parameter_temp=parameter_head; + while(parameter_temp->next) + { + parameter_temp=parameter_temp->next; + if(parameter_temp->var_name==varia_name) + { + std::cout<<"[Error] Redefinition of var \""<next=new parameter; + parameter_temp=parameter_temp->next; + parameter_temp->param_var=p; + parameter_temp->var_name=varia_name; + parameter_temp->next=NULL; + return; +} +void func::append_token(const int _line,const int _type,std::string &_content) +{ + token_unit *statement_temp=statement_head; + while(statement_temp->next) + statement_temp=statement_temp->next; + statement_temp->next=new token_unit; + statement_temp=statement_temp->next; + statement_temp->line=_line; + statement_temp->type=_type; + statement_temp->content=_content; + statement_temp->next=NULL; + return; +} +void func::print_info() +{ + parameter *para_temp=parameter_head; + token_unit *token_temp=statement_head; + std::cout<<"\n\t[parameter] :"; + while(para_temp->next) + { + para_temp=para_temp->next; + std::cout<var_name<<" "; + } + std::cout<<"\n\t[statement] :"; + while(token_temp->next) + { + token_temp=token_temp->next; + std::cout<content<<" "; + } + std::cout<func_name="null"; + head->next=NULL; + } + ~func_stack() + { + func_stack_unit *temp=head; + func_stack_unit *this_node=NULL; + while(temp->next) + { + this_node=temp; + temp=temp->next; + delete this_node; + } + delete temp; + } + void append_function(std::string &function_name,func &temp_func) + { + func_stack_unit *temp=head; + while(temp->next) + { + temp=temp->next; + if(temp->func_name==function_name) + { + std::cout<<"[Error] Redeclaration of function \""<next=new func_stack_unit; + temp=temp->next; + temp->next=NULL; + temp->func_name=function_name; + temp->func_statement=temp_func; + return; + } +// void run_function(std::string &function_name) +// { +// func_stack_unit *temp=head; +// while(temp->next) +// { +// temp=temp->next; +// if(temp->func_name==function_name) +// { +// temp->func_statement.run(); +// return; +// } +// } +// std::cout<<"[Error] Could not find this function."<next) + { + temp=temp->next; + std::cout<<"function: "<func_name; + temp->func_statement.print_info(); + } + return; + } + void pop_function() + { + func_stack_unit *temp=head; + func_stack_unit *end_temp; + if(!head->next) + return; + while(temp->next) + { + end_temp=temp; + temp=temp->next; + } + end_temp->next=NULL; + delete temp; + } + void delete_all() + { + func_stack_unit *temp=head->next; + func_stack_unit *this_node=NULL; + head->next=NULL; + if(!temp) + return; + while(temp->next) + { + this_node=temp; + temp=temp->next; + delete this_node; + } + delete temp; + return; + } +}; +func_stack nasal_func_stack; + +#endif diff --git a/version0.5/nasal_functional.h b/version0.5/nasal_functional.h new file mode 100644 index 0000000..9ec8d1d --- /dev/null +++ b/version0.5/nasal_functional.h @@ -0,0 +1,59 @@ +#ifndef __NASAL_FUNCTIONAL_H__ +#define __NASAL_FUNCTIONAL_H__ + +bool is_float(std::string &str) +{ + for(int i=0;i<(int)str.length();++i) + if(str[i]=='.') + return true; + return false; +} +long long int int_str2num(std::string &str) +{ + for(int i=0;i<(int)str.length();++i) + if(!(('0'<=str[i]) && (str[i]<='9') || (str[i]=='.'))) + { + std::cout<<"[Error] Non-numeric string."<=0;--i) + { + num+=acc*((long long int)(str[i]-'0')); + acc*=10; + } + return num; +} +double double_str2num(std::string &str) +{ + for(int i=0;i<(int)str.length();++i) + if(!(('0'<=str[i]) && (str[i]<='9') || (str[i]=='.'))) + { + std::cout<<"[Error] Non-numeric string."<=0;--i) + { + num+=acc*((double)(str[i]-'0')); + acc*=10; + } + return num; +} + +#endif diff --git a/version0.5/nasal_hash.cpp b/version0.5/nasal_hash.cpp new file mode 100644 index 0000000..7eb376b --- /dev/null +++ b/version0.5/nasal_hash.cpp @@ -0,0 +1,113 @@ +#ifndef __NASAL_HASH_CPP__ +#define __NASAL_HASH_CPP__ + + +#include "nasal_hash.h" + +nasal_hash::nasal_hash() +{ + head=new nasal_hash_unit; + head->name=""; + head->hash_var.type=VAR_NONE; + head->hash_var.data=NULL; + head->next=NULL; +} +nasal_hash::~nasal_hash() +{ + nasal_hash_unit *temp=head; + nasal_hash_unit *this_node=NULL; + while(temp->next) + { + this_node=temp; + temp=temp->next; + delete this_node; + } + delete temp; +} +nasal_hash& nasal_hash::operator=(const nasal_hash &p) +{ + nasal_hash_unit *temp=head; + nasal_hash_unit *this_node=NULL; + if(head->next) + { + temp=temp->next; + head->next=NULL; + while(temp->next) + { + this_node=temp; + temp=temp->next; + delete this_node; + } + delete temp; + } + temp=head; + nasal_hash_unit *temp_p=p.head; + + while(temp_p->next) + { + temp_p=temp_p->next; + temp->next=new nasal_hash_unit; + temp=temp->next; + temp->next=NULL; + temp->hash_var=temp_p->hash_var; + temp->name=temp_p->name; + } + return *this; +} +void nasal_hash::append(std::string& var_name,var& p) +{ + nasal_hash_unit *temp=head; + while(temp->next) + temp=temp->next; + temp->next=new nasal_hash_unit; + temp=temp->next; + temp->next=NULL; + temp->hash_var=p; + temp->name=var_name; + return; +} +int nasal_hash::contains(std::string& var_name) +{ + nasal_hash_unit *temp=head; + while(temp->next) + { + temp=temp->next; + if(temp->name==var_name) + return 1; + } + return 0; +} +int nasal_hash::delete_element(std::string& var_name) +{ + nasal_hash_unit *temp=head; + nasal_hash_unit *last_node=NULL; + while(temp->next) + { + last_node=temp; + temp=temp->next; + if(temp->name==var_name) + { + last_node->next=temp->next; + delete temp; + return 1; + } + } + return 0; +} +nasal_list nasal_hash::keys() +{ + var assist_var; + assist_var.type=VAR_STRING; + nasal_list temp_list; + nasal_hash_unit *temp=head; + while(temp->next) + { + temp=temp->next; + assist_var.data=new std::string; + *((std::string *)assist_var.data)=temp->name; + temp_list.append(assist_var); + } + return temp_list; +} + +#endif diff --git a/version0.5/nasal_hash.h b/version0.5/nasal_hash.h new file mode 100644 index 0000000..b28f4d4 --- /dev/null +++ b/version0.5/nasal_hash.h @@ -0,0 +1,27 @@ +#ifndef __NASAL_HASH_H__ +#define __NASAL_HASH_H__ + +#include "nasal_var.h" + +struct nasal_hash_unit +{ + std::string name; + var hash_var; + nasal_hash_unit *next; +}; + +class nasal_hash +{ + private: + nasal_hash_unit *head; + public: + nasal_hash(); + ~nasal_hash(); + nasal_hash& operator=(const nasal_hash&); + void append(std::string&,var&); + int contains(std::string&); + int delete_element(std::string&); + nasal_list keys(); +}; + +#endif diff --git a/version0.5/nasal_interpreter.cpp b/version0.5/nasal_interpreter.cpp new file mode 100644 index 0000000..c44f045 --- /dev/null +++ b/version0.5/nasal_interpreter.cpp @@ -0,0 +1,55 @@ +#include "nasal.h" + +int main() +{ + std::string command; + std::cout<<">> nasal-- script by ValKmjolnir"<> input \"help\" to find help."<> "; + std::getline(std::cin,command); + if(command=="help") + { + std::cout<<">> nasal-- script by ValKmjolnir"<> 1. |input file name to run the lexer."<> 2. \"cls\" |clear the screen."<> 3. \"exit\" |shut down the program."<> 4. \"lexer\" |see tokens in stack."<> 5. \"parser\"|run parser."<> 6. \"del\" |delete all elements in stack."<> 7. \"run\" |run the programme in stack."<> 8. \"rs\" |check the source program."<",">=","==","!=","~=","!","~", + ",",";","(",")","[","]","{","}","#","?",":", + "&","|","%","^" +}; + +std::string IdentifierTable[1000]={""}; +char ResourceProgram[16777216]; + +int isReserveWord(std::string &p) +{ + for(int i=0;i<15;++i) + if(ReserveWord[i]==p) + return i+1; + return FAIL; +} + +int isOperatorOrDelimiter(std::string &p) +{ + for(int i=0;i<40;++i) + if(OperatorOrDelimiter[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')); +} + +void InputFile(std::string &FileName) +{ + std::ifstream fin(FileName); + int i=0; + bool FindNote=false; + while(!fin.eof()) + { + ResourceProgram[i]=fin.get(); + if(ResourceProgram[i]=='\n') + FindNote=false; + if(ResourceProgram[i]!='#' && !FindNote) + ++i; + else if(ResourceProgram[i]=='#') + { + FindNote=true; + } + if(fin.eof()) + break; + } + ResourceProgram[i]=0; + + fin.close(); + return; +} + +void PrintSourceFile() +{ + int line=1; + std::cout<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; + } + else if(isNumber(temp)) + { + 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=='=' || 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: "<0)//all Syn type is larger than zero + nasal_lexer.append(line,Syn,token); + } + //nasal_lexer.print(); //for debug mode + std::cout<<">> Complete scanning \""<list_var.type=VAR_NONE; + head->list_var.data=NULL; + head->next=NULL; +} +nasal_list::~nasal_list() +{ + nasal_list_unit *temp=head; + nasal_list_unit *this_node=NULL; + while(temp->next) + { + this_node=temp; + temp=temp->next; + delete this_node; + } + delete temp; +} +nasal_list& nasal_list::operator=(const nasal_list &p) +{ + nasal_list_unit *temp=head; + nasal_list_unit *this_node=NULL; + if(head->next) + { + temp=temp->next; + head->next=NULL; + while(temp->next) + { + this_node=temp; + temp=temp->next; + delete this_node; + } + delete temp; + } + temp=head; + nasal_list_unit *temp_p=p.head; + + while(temp_p->next) + { + temp_p=temp_p->next; + temp->next=new nasal_list_unit; + temp=temp->next; + temp->next=NULL; + temp->list_var=temp_p->list_var; + } + return *this; +} +void nasal_list::append(var& p) +{ + nasal_list_unit *temp=head; + while(temp->next) + temp=temp->next; + temp->next=new nasal_list_unit; + temp=temp->next; + temp->next=NULL; + temp->list_var=p; + return; +} +void nasal_list::setsize(const int list_size) +{ + nasal_list_unit *temp=head; + int cnt=0; + while(temp->next) + { + temp=temp->next; + ++cnt; + if(cnt==list_size) + { + nasal_list_unit *this_node=NULL; + nasal_list_unit *t=temp->next; + temp->next=NULL; + if(!t) + return; + while(t->next) + { + this_node=t; + t=t->next; + delete this_node; + } + delete t; + return; + } + } + while(cntnext=new nasal_list_unit; + temp=temp->next; + temp->list_var.type=VAR_NONE; + temp->list_var.data=NULL; + temp->next=NULL; + ++cnt; + } + return; +} +nasal_list nasal_list::subvec(const int list_begin=0,const int list_end=-1) +{ + nasal_list temp_list; + int cnt=-1; + nasal_list_unit *temp=head; + + int beg=list_begin; + int end=list_end; + if(list_end==-1) + { + int end_place=-1; + while(temp->next) + { + temp=temp->next; + ++end_place; + } + temp=head; + end=end_place; + } + while(temp->next) + { + temp=temp->next; + ++cnt; + if(beg<=cnt && cnt<=end) + temp_list.append(temp->list_var); + } + return temp_list; +} +var nasal_list::pop() +{ + nasal_list_unit *temp=head; + nasal_list_unit *this_node; + while(temp->next) + { + this_node=temp; + temp=temp->next; + } + this_node->next=NULL; + var temp_var=temp->list_var; + delete temp; + return temp_var; +} +nasal_list nasal_list::sort_list(const int sort_type,const int _cmp=1) +{ + nasal_list temp_list; + if(sort_type==SORT_INT) + { + nasal_list_unit *temp=head; + while(temp->next) + { + temp=temp->next; + if(temp->list_var.type!=VAR_LLINT) + { + std::cout<<"[Error] Incorrect type inside: "<list_var.type<<".But type must be long int."<list_var.type!=VAR_LLINT) + { + std::cout<<"[Error] Incorrect type inside: "<list_var.type<<".But type must be long int."<next; + while(first_temp_this->next) + { + node_this=first_temp_this; + second_temp_this=first_temp_this->next; + while(second_temp_this->next) + { + if(_cmp>0 && *((int *)node_this->list_var.data)>*((int *)second_temp_this->list_var.data))//from small to large + node_this=second_temp_this; + else if(_cmp<=0 && *((int *)node_this->list_var.data)<*((int *)second_temp_this->list_var.data))//from large to small + node_this=second_temp_this; + second_temp_this=second_temp_this->next; + } + if(_cmp>0 && *((int *)node_this->list_var.data)>*((int *)second_temp_this->list_var.data))//from small to large func(a,b) a-b + node_this=second_temp_this; + else if(_cmp<=0 && *((int *)node_this->list_var.data)<*((int *)second_temp_this->list_var.data))//from large to small func(a,b) b-a + node_this=second_temp_this; + if(node_this!=first_temp_this) + { + int t; + t=*((int *)first_temp_this->list_var.data); + *((int *)first_temp_this->list_var.data)=*((int *)node_this->list_var.data); + *((int *)node_this->list_var.data)=t; + } + first_temp_this=first_temp_this->next; + } + } + else if(sort_type==SORT_DBL) + { + nasal_list_unit *temp=head; + while(temp->next) + { + temp=temp->next; + if(temp->list_var.type!=VAR_DOUBLE) + { + std::cout<<"[Error] Incorrect type inside: "<list_var.type<<".But type must be float."<list_var.type!=VAR_DOUBLE) + { + std::cout<<"[Error] Incorrect type inside: "<list_var.type<<".But type must be float."<next; + while(first_temp_this->next) + { + node_this=first_temp_this; + second_temp_this=first_temp_this->next; + while(second_temp_this->next) + { + if(_cmp>0 && *((double *)node_this->list_var.data)>*((double *)second_temp_this->list_var.data))//from small to large + node_this=second_temp_this; + else if(_cmp<=0 && *((double *)node_this->list_var.data)<*((double *)second_temp_this->list_var.data))//from large to small + node_this=second_temp_this; + second_temp_this=second_temp_this->next; + } + if(_cmp>0 && *((double *)node_this->list_var.data)>*((double *)second_temp_this->list_var.data))//from small to large func(a,b) a-b + node_this=second_temp_this; + else if(_cmp<=0 && *((double *)node_this->list_var.data)<*((double *)second_temp_this->list_var.data))//from large to small func(a,b) b-a + node_this=second_temp_this; + if(node_this!=first_temp_this) + { + double t; + t=*((double *)first_temp_this->list_var.data); + *((double *)first_temp_this->list_var.data)=*((double *)node_this->list_var.data); + *((double *)node_this->list_var.data)=t; + } + first_temp_this=first_temp_this->next; + } + } + else if(sort_type==SORT_STR) + { + nasal_list_unit *temp=head; + while(temp->next) + { + temp=temp->next; + if(temp->list_var.type!=VAR_STRING) + { + std::cout<<"[Error] Incorrect type inside: "<list_var.type<<".But type must be string."<list_var.type!=VAR_STRING) + { + std::cout<<"[Error] Incorrect type inside: "<list_var.type<<".But type must be string."<next; + while(first_temp_this->next) + { + node_this=first_temp_this; + second_temp_this=first_temp_this->next; + while(second_temp_this->next) + { + if(_cmp>0 && *((std::string *)node_this->list_var.data)>*((std::string *)second_temp_this->list_var.data))//from small to large + node_this=second_temp_this; + else if(_cmp<=0 && *((std::string *)node_this->list_var.data)<*((std::string *)second_temp_this->list_var.data))//from large to small + node_this=second_temp_this; + second_temp_this=second_temp_this->next; + } + if(_cmp>0 && *((std::string *)node_this->list_var.data)>*((std::string *)second_temp_this->list_var.data))//from small to large func(a,b) cmp(a,b) + node_this=second_temp_this; + else if(_cmp<=0 && *((std::string *)node_this->list_var.data)<*((std::string *)second_temp_this->list_var.data))//from large to small func(a,b) cmp(b,a) or -cmp(a,b) + node_this=second_temp_this; + if(node_this!=first_temp_this) + { + std::string t; + t=*((std::string *)first_temp_this->list_var.data); + *((std::string *)first_temp_this->list_var.data)=*((std::string *)node_this->list_var.data); + *((std::string *)node_this->list_var.data)=t; + } + first_temp_this=first_temp_this->next; + } + } + return temp_list; +} + +#endif diff --git a/version0.5/nasal_list.h b/version0.5/nasal_list.h new file mode 100644 index 0000000..11946eb --- /dev/null +++ b/version0.5/nasal_list.h @@ -0,0 +1,33 @@ +#ifndef __NASAL_LIST_H__ +#define __NASAL_LIST_H__ + +#include "nasal_var.h" + +#define SORT_INT 1 +#define SORT_DBL 2 +#define SORT_STR 3 + +class nasal_hash; + +struct nasal_list_unit +{ + var list_var; + nasal_list_unit *next; +}; + +class nasal_list +{ + private: + nasal_list_unit *head; + public: + nasal_list(); + ~nasal_list(); + nasal_list& operator=(const nasal_list&); + void append(var&); + void setsize(const int); + nasal_list subvec(const int,const int); + var pop(); + nasal_list sort_list(const int,const int); +}; + +#endif diff --git a/version0.5/nasal_parse.h b/version0.5/nasal_parse.h new file mode 100644 index 0000000..63f3d34 --- /dev/null +++ b/version0.5/nasal_parse.h @@ -0,0 +1,1033 @@ +#ifndef __NASAL_PARSE_H__ +#define __NASAL_PARSE_H__ +#include "nasal_lexer.h" +#include "nasal_token.h" + +enum token_type +{ + __stack_end, + __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,// var reserve word + __func,// func reserve word + __identifier,__identifiers, + __scalar,__scalars, + __hash_member,__hash_members, + __statement,__statements, + __function,//function(){} + __definition,__assignment, + __loop,__continue,__break,__for,__forindex,__foreach,__while,// for()while() continue; break; + __choose,__if,__elsif,__else,// if else if else + __return,__func_return +}; + +struct parse_unit +{ + int type; + int line; +}; + +class parse +{ + public: + std::stack parser; + public: + bool scalars_reduction(); + bool identifier_check(); + bool identifiers_reduction(); + bool hashmember_check(); + bool hashmembers_reduction(); + bool function_def(); + bool statement_check(); + bool statements_reduction(); + bool calculation_reduction(); + bool loop_reduction(); + bool choose_reduction(); + bool definition_check(); + bool assignment_check(); + void parse_work(token_list&); + void print_stack(); + void stack_set_empty(); +}; + +bool parse::scalars_reduction() +{ + int tbl[3]={0}; + std::stack temp; + for(int i=0;i<3;++i) + { + if(parser.empty()) + break; + temp.push(parser.top()); + tbl[i]=temp.top().type; + parser.pop(); + } + for(int i=0;i<3;++i) + { + if(temp.empty()) + break; + parser.push(temp.top()); + temp.pop(); + } + if(((tbl[2]==__scalar) || (tbl[2]==__scalars)) && (tbl[1]==__comma) && ((tbl[0]==__scalar) || (tbl[0]==__identifier))) + { + parse_unit t; + t.type=__scalars; + t.line=parser.top().line; + for(int i=0;i<3;++i) + parser.pop(); + parser.push(t); + return true; + } + else if(((tbl[2]==__identifier) || (tbl[2]==__identifiers)) && (tbl[1]==__comma) && (tbl[0]==__scalar)) + { + parse_unit t; + t.type=__scalars; + t.line=parser.top().line; + for(int i=0;i<3;++i) + parser.pop(); + parser.push(t); + return true; + } + return false; +} +bool parse::identifier_check() +{ + int tbl[4]={0}; + std::stack temp; + for(int i=0;i<4;++i) + { + if(parser.empty()) + break; + temp.push(parser.top()); + tbl[i]=temp.top().type; + parser.pop(); + } + for(int i=0;i<4;++i) + { + if(temp.empty()) + break; + parser.push(temp.top()); + temp.pop(); + } + if((tbl[3]==__identifier) && (tbl[2]==__left_bracket) && ((tbl[1]==__identifier) || (tbl[1]==__scalar)) && (tbl[0]==__right_bracket)) + { + parse_unit t; + t.type=__identifier; + t.line=parser.top().line; + for(int i=0;i<4;++i) + parser.pop(); + parser.push(t); + return true; + } + else if((tbl[2]==__identifier) && (tbl[1]==__dot) && (tbl[0]==__identifier)) + { + parse_unit t; + t.type=__identifier; + t.line=parser.top().line; + for(int i=0;i<3;++i) + parser.pop(); + parser.push(t); + return true; + } + else if((tbl[3]==__identifier) && (tbl[2]==__left_curve) && ((tbl[1]==__identifier) || (tbl[1]==__identifiers) || (tbl[1]==__scalar) || (tbl[1]==__scalars)) && (tbl[0]==__right_curve)) + { + parse_unit t; + t.type=__identifier; + t.line=parser.top().line; + for(int i=0;i<4;++i) + parser.pop(); + parser.push(t); + return true; + } + else if((tbl[2]==__identifier) && (tbl[1]==__left_curve) && (tbl[0]==__right_curve)) + { + parse_unit t; + t.type=__identifier; + t.line=parser.top().line; + for(int i=0;i<3;++i) + parser.pop(); + parser.push(t); + return true; + } + return false; +} +bool parse::identifiers_reduction() +{ + int tbl[3]={0}; + std::stack temp; + for(int i=0;i<3;++i) + { + if(parser.empty()) + break; + temp.push(parser.top()); + tbl[i]=temp.top().type; + parser.pop(); + } + for(int i=0;i<3;++i) + { + if(temp.empty()) + break; + parser.push(temp.top()); + temp.pop(); + } + if(((tbl[2]==__identifier) || (tbl[2]==__identifiers)) && (tbl[1]==__comma) && (tbl[0]==__identifier)) + { + parse_unit t; + t.type=__identifiers; + t.line=parser.top().line; + for(int i=0;i<3;++i) + parser.pop(); + parser.push(t); + return true; + } + return false; +} +bool parse::hashmember_check() +{ + int tbl[9]={0}; + std::stack temp; + for(int i=0;i<9;++i) + { + if(parser.empty()) + break; + temp.push(parser.top()); + tbl[i]=temp.top().type; + parser.pop(); + } + for(int i=0;i<9;++i) + { + if(temp.empty()) + break; + parser.push(temp.top()); + temp.pop(); + } + if((tbl[2]==__identifier) && (tbl[1]==__colon) && ((tbl[0]==__identifier) || (tbl[0]==__scalar))) + { + parse_unit t; + t.type=__hash_member; + t.line=parser.top().line; + for(int i=0;i<3;++i) + parser.pop(); + parser.push(t); + return true; + } + else if((tbl[6]==__identifier) && (tbl[5]==__colon) && (tbl[4]==__func) && (tbl[3]==__left_curve) && (tbl[2]==__right_curve) && (tbl[1]==__left_brace) && (tbl[0]==__right_brace)) + { + parse_unit t; + t.type=__hash_member; + t.line=parser.top().line; + for(int i=0;i<7;++i) + parser.pop(); + parser.push(t); + return true; + } + else if((tbl[7]==__identifier) && (tbl[6]==__colon) && (tbl[5]==__func) && (tbl[4]==__left_curve) && ((tbl[3]==__identifier) || (tbl[3]==__identifiers)) && (tbl[2]==__right_curve) && (tbl[1]==__left_brace) && (tbl[0]==__right_brace)) + { + parse_unit t; + t.type=__hash_member; + t.line=parser.top().line; + for(int i=0;i<8;++i) + parser.pop(); + parser.push(t); + return true; + } + else if((tbl[7]==__identifier) && (tbl[6]==__colon) && (tbl[5]==__func) && (tbl[4]==__left_curve) && (tbl[3]==__right_curve) && (tbl[2]==__left_brace) && ((tbl[1]==__statement) || (tbl[1]==__statements)) && (tbl[0]==__right_brace)) + { + parse_unit t; + t.type=__hash_member; + t.line=parser.top().line; + for(int i=0;i<8;++i) + parser.pop(); + parser.push(t); + return true; + } + else if((tbl[8]==__identifier) && (tbl[7]==__colon) && (tbl[6]==__func) && (tbl[5]==__left_curve) && ((tbl[4]==__identifier) || (tbl[4]==__identifiers)) && (tbl[3]==__right_curve) && (tbl[2]==__left_brace) && ((tbl[1]==__statement) || (tbl[1]==__statements)) && (tbl[0]==__right_brace)) + { + parse_unit t; + t.type=__hash_member; + t.line=parser.top().line; + for(int i=0;i<9;++i) + parser.pop(); + parser.push(t); + return true; + } + return false; +} +bool parse::hashmembers_reduction() +{ + int tbl[3]={0}; + std::stack temp; + for(int i=0;i<3;++i) + { + if(parser.empty()) + break; + temp.push(parser.top()); + tbl[i]=temp.top().type; + parser.pop(); + } + for(int i=0;i<3;++i) + { + if(temp.empty()) + break; + parser.push(temp.top()); + temp.pop(); + } + if(((tbl[2]==__hash_member) || (tbl[2]==__hash_members)) && (tbl[1]==__comma) && (tbl[0]==__hash_member)) + { + parse_unit t; + t.type=__hash_members; + t.line=parser.top().line; + for(int i=0;i<3;++i) + parser.pop(); + parser.push(t); + return true; + } + return false; +} +bool parse::calculation_reduction() //use __scalar +{ + int tbl[3]={0}; + std::stack temp; + for(int i=0;i<3;++i) + { + if(parser.empty()) + break; + temp.push(parser.top()); + tbl[i]=temp.top().type; + parser.pop(); + } + for(int i=0;i<3;++i) + { + if(temp.empty()) + break; + parser.push(temp.top()); + temp.pop(); + } + if((tbl[2]==__left_curve) && ((tbl[1]==__identifier) || (tbl[1]==__scalar)) && (tbl[0]==__right_curve)) + { + parse_unit t; + t.type=__scalar; + t.line=parser.top().line; + for(int i=0;i<3;++i) + parser.pop(); + parser.push(t); + return true; + } + if((tbl[1]==__nor_operator) && ((tbl[0]==__identifier) || (tbl[0]==__scalar))) + { + parse_unit t; + t.type=__scalar; + t.line=parser.top().line; + for(int i=0;i<2;++i) + parser.pop(); + parser.push(t); + return true; + } + else if(((tbl[2]==__identifier) || (tbl[2]==__scalar)) + && ((tbl[1]==__add_operator) || (tbl[1]==__sub_operator) + || (tbl[1]==__mul_operator) || (tbl[1]==__div_operator) + || (tbl[1]==__link_operator) || (tbl[1]==__and_operator) + || (tbl[1]==__or_operator) || (tbl[1]==__cmp_equal) || (tbl[1]==__cmp_not_equal) + || (tbl[1]==__cmp_less) || (tbl[1]==__cmp_less_or_equal) + || (tbl[1]==__cmp_more) || (tbl[1]==__cmp_more_or_equal)) + && ((tbl[0]==__identifier) || (tbl[0]==__scalar))) + { + parse_unit t; + t.type=__scalar; + t.line=parser.top().line; + for(int i=0;i<3;++i) + parser.pop(); + parser.push(t); + return true; + } + return false; +} +bool parse::definition_check() +{ + int tbl[7]={0}; + std::stack temp; + for(int i=0;i<7;++i) + { + if(parser.empty()) + break; + temp.push(parser.top()); + tbl[i]=temp.top().type; + parser.pop(); + } + for(int i=0;i<7;++i) + { + if(temp.empty()) + break; + parser.push(temp.top()); + temp.pop(); + } + if((tbl[4]==__var) && (tbl[3]==__identifier) && (tbl[2]==__equal) && ((tbl[1]==__identifier) || (tbl[1]==__scalar)) && (tbl[0]==__semi)) + { + parse_unit t; + t.type=__definition; + t.line=parser.top().line; + for(int i=0;i<5;++i) + parser.pop(); + parser.push(t); + return true; + } + else if((tbl[5]==__var) && (tbl[4]==__identifier) && (tbl[3]==__equal) && (tbl[2]==__left_bracket) && (tbl[1]==__right_bracket) && (tbl[0]==__semi)) + { + parse_unit t; + t.type=__definition; + t.line=parser.top().line; + for(int i=0;i<6;++i) + parser.pop(); + parser.push(t); + return true; + } + else if((tbl[5]==__var) && (tbl[4]==__identifier) && (tbl[3]==__equal) && (tbl[2]==__left_brace) && (tbl[1]==__right_brace) && (tbl[0]==__semi)) + { + parse_unit t; + t.type=__definition; + t.line=parser.top().line; + for(int i=0;i<6;++i) + parser.pop(); + parser.push(t); + return true; + } + else if((tbl[6]==__var) && (tbl[5]==__identifier) && (tbl[4]==__equal) && (tbl[3]==__left_bracket) && ((tbl[2]==__scalar) || (tbl[2]==__scalars) || (tbl[2]==__identifier) || (tbl[2]==__identifiers)) && (tbl[1]==__right_bracket) && (tbl[0]==__semi)) + { + parse_unit t; + t.type=__definition; + t.line=parser.top().line; + for(int i=0;i<7;++i) + parser.pop(); + parser.push(t); + return true; + } + else if((tbl[6]==__var) && (tbl[5]==__identifier) && (tbl[4]==__equal) && (tbl[3]==__left_brace) && ((tbl[2]==__hash_member) || (tbl[2]==__hash_members)) && (tbl[1]==__right_brace) && (tbl[0]==__semi)) + { + parse_unit t; + t.type=__definition; + t.line=parser.top().line; + for(int i=0;i<7;++i) + parser.pop(); + parser.push(t); + return true; + } + return false; +} +bool parse::assignment_check() +{ + int tbl[6]={0}; + std::stack temp; + for(int i=0;i<6;++i) + { + if(parser.empty()) + break; + temp.push(parser.top()); + tbl[i]=temp.top().type; + parser.pop(); + } + for(int i=0;i<6;++i) + { + if(temp.empty()) + break; + parser.push(temp.top()); + temp.pop(); + } + if((tbl[3]==__identifier) + && ((tbl[2]==__equal) || (tbl[2]==__add_equal) || (tbl[2]==__sub_equal) + || (tbl[2]==__mul_equal) || (tbl[2]==__div_equal) || (tbl[2]==__link_equal)) + && ((tbl[1]==__identifier) || (tbl[1]==__scalar)) && (tbl[0]==__semi)) + { + parse_unit t; + t.type=__assignment; + t.line=parser.top().line; + for(int i=0;i<4;++i) + parser.pop(); + parser.push(t); + return true; + } + else if((tbl[4]==__identifier) && (tbl[3]==__equal) && (tbl[2]==__left_bracket) && (tbl[1]==__right_bracket) && (tbl[0]==__semi)) + { + parse_unit t; + t.type=__assignment; + t.line=parser.top().line; + for(int i=0;i<5;++i) + parser.pop(); + parser.push(t); + return true; + } + else if((tbl[4]==__identifier) && (tbl[3]==__equal) && (tbl[2]==__left_brace) && (tbl[1]==__right_brace) && (tbl[0]==__semi)) + { + parse_unit t; + t.type=__assignment; + t.line=parser.top().line; + for(int i=0;i<5;++i) + parser.pop(); + parser.push(t); + return true; + } + else if((tbl[5]==__identifier) && (tbl[4]==__equal) && (tbl[3]==__left_bracket) && ((tbl[2]==__scalar) || (tbl[2]==__scalars) || (tbl[2]==__identifier) || (tbl[2]==__identifiers)) && (tbl[1]==__right_bracket) && (tbl[0]==__semi)) + { + parse_unit t; + t.type=__assignment; + t.line=parser.top().line; + for(int i=0;i<6;++i) + parser.pop(); + parser.push(t); + return true; + } + else if((tbl[5]==__identifier) && (tbl[4]==__equal) && (tbl[3]==__left_brace) && ((tbl[2]==__hash_member) || (tbl[2]==__hash_members)) && (tbl[1]==__right_brace) && (tbl[0]==__semi)) + { + parse_unit t; + t.type=__assignment; + t.line=parser.top().line; + for(int i=0;i<6;++i) + parser.pop(); + parser.push(t); + return true; + } + return false; +} +bool parse::function_def() +{ + int tbl[10]={0}; + std::stack temp; + for(int i=0;i<10;++i) + { + if(parser.empty()) + break; + temp.push(parser.top()); + tbl[i]=temp.top().type; + parser.pop(); + } + for(int i=0;i<10;++i) + { + if(temp.empty()) + break; + parser.push(temp.top()); + temp.pop(); + } + if((tbl[7]==__var) && (tbl[6]==__identifier) && (tbl[5]==__equal) && (tbl[4]==__func) && (tbl[3]==__left_curve) && (tbl[2]==__right_curve) && (tbl[1]==__left_brace) && (tbl[0]==__right_brace)) + { + parse_unit t; + t.type=__function; + t.line=parser.top().line; + for(int i=0;i<8;++i) + parser.pop(); + parser.push(t); + return true; + } + else if((tbl[8]==__var) && (tbl[7]==__identifier) && (tbl[6]==__equal) && (tbl[5]==__func) && (tbl[4]==__left_curve) && ((tbl[3]==__identifier) || (tbl[3]==__identifiers)) && (tbl[2]==__right_curve) && (tbl[1]==__left_brace) && (tbl[0]==__right_brace)) + { + parse_unit t; + t.type=__function; + t.line=parser.top().line; + for(int i=0;i<9;++i) + parser.pop(); + parser.push(t); + return true; + } + else if((tbl[8]==__var) && (tbl[7]==__identifier) && (tbl[6]==__equal) && (tbl[5]==__func) && (tbl[4]==__left_curve) && (tbl[3]==__right_curve) && (tbl[2]==__left_brace) && ((tbl[1]==__statement) || (tbl[1]==__statements)) && (tbl[0]==__right_brace)) + { + parse_unit t; + t.type=__function; + t.line=parser.top().line; + for(int i=0;i<9;++i) + parser.pop(); + parser.push(t); + return true; + } + else if((tbl[9]==__var) && (tbl[8]==__identifier) && (tbl[7]==__equal) && (tbl[6]==__func) && (tbl[5]==__left_curve) && ((tbl[4]==__identifier) || (tbl[4]==__identifiers)) && (tbl[3]==__right_curve) && (tbl[2]==__left_brace) && ((tbl[1]==__statement) || (tbl[1]==__statements)) && (tbl[0]==__right_brace)) + { + parse_unit t; + t.type=__function; + t.line=parser.top().line; + for(int i=0;i<10;++i) + parser.pop(); + parser.push(t); + return true; + } + return false; +} +bool parse::loop_reduction() +{ + int tbl[7]={0}; + std::stack temp; + for(int i=0;i<7;++i) + { + if(parser.empty()) + break; + temp.push(parser.top()); + tbl[i]=temp.top().type; + parser.pop(); + } + for(int i=0;i<7;++i) + { + if(temp.empty()) + break; + parser.push(temp.top()); + temp.pop(); + } + if((tbl[4]==__while) && (tbl[3]==__left_curve) && (tbl[2]==__scalar) && (tbl[1]==__right_curve) && (tbl[0]==__statement)) + { + parse_unit t; + t.type=__loop; + t.line=parser.top().line; + for(int i=0;i<5;++i) + parser.pop(); + parser.push(t); + return true; + } + else if((tbl[6]==__while) && (tbl[5]==__left_curve) && (tbl[4]==__scalar) && (tbl[3]==__right_curve) && (tbl[2]==__left_brace) && ((tbl[1]==__statement) || (tbl[1]==__statements)) && (tbl[0]==__right_brace)) + { + parse_unit t; + t.type=__loop; + t.line=parser.top().line; + for(int i=0;i<7;++i) + parser.pop(); + parser.push(t); + return true; + } + else if(((tbl[4]==__for) || (tbl[4]==__foreach) || (tbl[4]==__forindex)) && (tbl[3]==__left_curve) && (tbl[2]==__statements) && (tbl[1]==__right_curve) && (tbl[0]==__statement)) + { + parse_unit t; + t.type=__loop; + t.line=parser.top().line; + for(int i=0;i<5;++i) + parser.pop(); + parser.push(t); + return true; + } + else if(((tbl[6]==__for) || (tbl[6]==__foreach) || (tbl[6]==__forindex)) && (tbl[5]==__left_curve) && (tbl[4]==__statements) && (tbl[3]==__right_curve) && (tbl[2]==__left_brace) && ((tbl[1]==__statement) || (tbl[1]==__statements)) && (tbl[0]==__right_brace)) + { + parse_unit t; + t.type=__loop; + t.line=parser.top().line; + for(int i=0;i<7;++i) + parser.pop(); + parser.push(t); + return true; + } + return false; +} +bool parse::choose_reduction() +{ + int tbl[8]={0}; + std::stack temp; + for(int i=0;i<8;++i) + { + if(parser.empty()) + break; + temp.push(parser.top()); + tbl[i]=temp.top().type; + parser.pop(); + } + for(int i=0;i<8;++i) + { + if(temp.empty()) + break; + parser.push(temp.top()); + temp.pop(); + } + if(((tbl[4]==__if) || (tbl[4]==__elsif)) && (tbl[3]==__left_curve) && (tbl[2]==__scalar) && (tbl[1]==__right_curve) && (tbl[0]==__statement)) + { + parse_unit t; + t.type=__choose; + t.line=parser.top().line; + for(int i=0;i<5;++i) + parser.pop(); + parser.push(t); + return true; + } + else if(((tbl[6]==__if) || (tbl[6]==__elsif)) && (tbl[5]==__left_curve) && (tbl[4]==__scalar) && (tbl[3]==__right_curve) && (tbl[2]==__left_brace) && ((tbl[1]==__statement) || (tbl[1]==__statements)) && (tbl[0]==__right_brace)) + { + parse_unit t; + t.type=__choose; + t.line=parser.top().line; + for(int i=0;i<7;++i) + parser.pop(); + parser.push(t); + return true; + } + else if((tbl[5]==__else) && (tbl[4]==__if) && (tbl[3]==__left_curve) && (tbl[2]==__scalar) && (tbl[1]==__right_curve) && (tbl[0]==__statement)) + { + parse_unit t; + t.type=__choose; + t.line=parser.top().line; + for(int i=0;i<6;++i) + parser.pop(); + parser.push(t); + return true; + } + else if((tbl[7]==__else) && (tbl[6]==__if) && (tbl[5]==__left_curve) && (tbl[4]==__scalar) && (tbl[3]==__right_curve) && (tbl[2]==__left_brace) && ((tbl[1]==__statement) || (tbl[1]==__statements)) && (tbl[0]==__right_brace)) + { + parse_unit t; + t.type=__choose; + t.line=parser.top().line; + for(int i=0;i<8;++i) + parser.pop(); + parser.push(t); + return true; + } + else if((tbl[1]==__else) && (tbl[0]==__statement)) + { + parse_unit t; + t.type=__choose; + t.line=parser.top().line; + for(int i=0;i<2;++i) + parser.pop(); + parser.push(t); + return true; + } + else if((tbl[3]==__else) && (tbl[2]==__left_brace) && ((tbl[1]==__statement) || (tbl[1]==__statements)) && (tbl[0]==__right_brace)) + { + parse_unit t; + t.type=__choose; + t.line=parser.top().line; + for(int i=0;i<4;++i) + parser.pop(); + parser.push(t); + return true; + } + return false; +} +bool parse::statement_check() +{ + int tbl[3]={0}; + std::stack temp; + for(int i=0;i<3;++i) + { + if(parser.empty()) + break; + temp.push(parser.top()); + tbl[i]=temp.top().type; + parser.pop(); + } + for(int i=0;i<3;++i) + { + if(temp.empty()) + break; + parser.push(temp.top()); + temp.pop(); + } + if((tbl[0]==__definition) || (tbl[0]==__assignment) || (tbl[0]==__function) || (tbl[0]==__loop) || (tbl[0]==__choose)) + { + parse_unit t; + t.type=__statement; + t.line=parser.top().line; + parser.pop(); + parser.push(t); + return true; + } + else if((tbl[2]==__return) && ((tbl[1]==__identifier) || (tbl[1]==__scalar)) && (tbl[0]==__semi)) + { + parse_unit t; + t.type=__statement; + t.line=parser.top().line; + for(int i=0;i<3;++i) + parser.pop(); + parser.push(t); + return true; + } + else if((tbl[2]!=__return) && ((tbl[1]==__identifier) || (tbl[1]==__continue) || (tbl[1]==__break)) && (tbl[0]==__semi)) + { + parse_unit t; + t.type=__statement; + t.line=parser.top().line; + for(int i=0;i<2;++i) + parser.pop(); + parser.push(t); + return true; + } + return false; +} +bool parse::statements_reduction() +{ + int tbl[2]={0}; + std::stack temp; + for(int i=0;i<2;++i) + { + if(parser.empty()) + break; + temp.push(parser.top()); + tbl[i]=temp.top().type; + parser.pop(); + } + for(int i=0;i<2;++i) + { + if(temp.empty()) + break; + parser.push(temp.top()); + temp.pop(); + } + if(((tbl[1]==__statement) || (tbl[1]==__statements)) && (tbl[0]==__statement)) + { + parse_unit t; + t.type=__statements; + t.line=parser.top().line; + for(int i=0;i<2;++i) + parser.pop(); + parser.push(t); + return true; + } + return false; +} +void parse::stack_set_empty() +{ + while(!parser.empty()) + parser.pop(); + return; +} +void parse::parse_work(token_list& lexer) +{ + parse_unit temp_parse; + token_unit *temp=lexer.get_head(); + stack_set_empty(); + while(temp->next) + { + temp=temp->next; + temp_parse.line=temp->line; + if((temp->content=="var") || (temp->content=="func") || (temp->content=="return") || (temp->content=="nil") || (temp->content=="continue") || (temp->content=="break") || (temp->content=="and") || (temp->content=="or")) + { + if(temp->content=="var") + temp_parse.type=__var; + else if(temp->content=="func") + temp_parse.type=__func; + else if(temp->content=="return") + temp_parse.type=__return; + else if(temp->content=="nil") + temp_parse.type=__scalar; + else if(temp->content=="continue") + temp_parse.type=__continue; + else if(temp->content=="break") + temp_parse.type=__break; + else if(temp->content=="and") + temp_parse.type=__and_operator; + else if(temp->content=="or") + temp_parse.type=__or_operator; + } + else if(temp->type==IDENTIFIER) + { + temp_parse.type=__identifier; + } + else if((temp->content=="for") || (temp->content=="foreach") || (temp->content=="while") || (temp->content=="forindex")) + { + if(temp->content=="for") + temp_parse.type=__for; + else if(temp->content=="forindex") + temp_parse.type=__forindex; + else if(temp->content=="foreach") + temp_parse.type=__foreach; + else if(temp->content=="while") + temp_parse.type=__while; + } + else if((temp->content=="if") || (temp->content=="else") || (temp->content=="elsif")) + { + if(temp->content=="if") + temp_parse.type=__if; + else if(temp->content=="else") + temp_parse.type=__else; + else if(temp->content=="elsif") + temp_parse.type=__elsif; + } + else if((temp->content=="==") || (temp->content=="!=") || (temp->content==">") || (temp->content==">=") || (temp->content=="<") || (temp->content=="<=")) + { + if(temp->content=="==") + temp_parse.type=__cmp_equal; + else if(temp->content=="!=") + temp_parse.type=__cmp_not_equal; + else if(temp->content==">") + temp_parse.type=__cmp_more; + else if(temp->content==">=") + temp_parse.type=__cmp_more_or_equal; + else if(temp->content=="<") + temp_parse.type=__cmp_less; + else if(temp->content=="<=") + temp_parse.type=__cmp_less_or_equal; + } + else if((temp->content==";") || (temp->content==",") || (temp->content=="=") || (temp->content==":") || (temp->content==".")) + { + if(temp->content==";") + temp_parse.type=__semi; + else if(temp->content==",") + temp_parse.type=__comma; + else if(temp->content=="=") + temp_parse.type=__equal; + else if(temp->content==":") + temp_parse.type=__colon; + else if(temp->content==".") + temp_parse.type=__dot; + } + else if((temp->type==NUMBER) || (temp->type==STRING)) + { + temp_parse.type=__scalar; + } + else if((temp->content=="+") || (temp->content=="-") || (temp->content=="*") || (temp->content=="/") || (temp->content=="~") || (temp->content=="!")) + { + if(temp->content=="+") + temp_parse.type=__add_operator; + else if(temp->content=="-") + temp_parse.type=__sub_operator; + else if(temp->content=="*") + temp_parse.type=__mul_operator; + else if(temp->content=="/") + temp_parse.type=__div_operator; + else if(temp->content=="~") + temp_parse.type=__link_operator; + else if(temp->content=="!") + temp_parse.type=__nor_operator; + } + else if((temp->content=="+=") || (temp->content=="-=") || (temp->content=="*=") || (temp->content=="/=") || (temp->content=="~=")) + { + if(temp->content=="+=") + temp_parse.type=__add_equal; + else if(temp->content=="-=") + temp_parse.type=__sub_equal; + else if(temp->content=="*=") + temp_parse.type=__mul_equal; + else if(temp->content=="/=") + temp_parse.type=__div_equal; + else if(temp->content=="~=") + temp_parse.type=__link_equal; + } + else if((temp->content=="(") || (temp->content==")") || (temp->content=="[") || (temp->content=="]") || (temp->content=="{") || (temp->content=="}")) + { + char c=temp->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; + } + } + parser.push(temp_parse);//push this into stack + + bool reduction_complete=false; + while(!reduction_complete) + { + if(scalars_reduction()) + { + std::cout<<"line "<> parser stack:"<=(int)PrintInfo.length()) + { + //error occurred + std::cout<<"[Error]: Missing character after \'\\\'"; + } + else + std::cout<print_list(); + else if(Var.type==VAR_HASH) + ;//((nasal_hash *)Var.data)->PrintHash(); + else + std::cout<<"[Error] Null type or function"; +} + +#endif diff --git a/version0.5/nasal_token.cpp b/version0.5/nasal_token.cpp new file mode 100644 index 0000000..cfbc55e --- /dev/null +++ b/version0.5/nasal_token.cpp @@ -0,0 +1,108 @@ +#ifndef __NASAL_TOKEN_CPP__ +#define __NASAL_TOKEN_CPP__ + +#include "nasal_token.h" +#include "nasal_var_stack.h" +#include "nasal_func_stack.h" + +token_list::token_list() +{ + list_range=0; + head=new token_unit; + head->type=FUNC_BEGIN; + head->content="__process_begin"; + head->line=0; + head->next=NULL; +} +token_list::~token_list() +{ + token_unit *temp=head; + token_unit *this_node=NULL; + while(temp->next) + { + this_node=temp; + temp=temp->next; + delete this_node; + } + delete temp; +} +token_unit* token_list::get_head() +{ + return head; +} +int token_list::get_list_range() +{ + return list_range; +} +void token_list::print_line_token(const int _line) +{ + std::cout<<"line "<<_line<<": "; + token_unit *temp=head; + while(temp->next) + { + temp=temp->next; + if(temp->line==_line) + std::cout<content<<" "; + else if(temp->line>_line) + break; + } + std::cout<next) + return; + token_unit *temp=head; + token_unit *this_node=NULL; + temp=temp->next; + head->next=NULL; + while(temp->next) + { + this_node=temp; + temp=temp->next; + delete this_node; + } + delete temp; + return; +} +void token_list::append(const int _line,const int _type,std::string &_content) +{ + token_unit *temp=head; + while(temp->next) + temp=temp->next; + ++list_range; + temp->next=new token_unit; + temp=temp->next; + temp->next=NULL; + temp->type=_type; + temp->line=_line; + temp->content=_content; + return; +} +void token_list::print() +{ + token_unit *temp=head; + std::cout<<"line "<line<<": "<<"( ProcessBegin | "<content<<" )"<next) + return; + while(temp->next) + { + temp=temp->next; + std::cout<<"line "<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 | "; + std::cout<content<<" )"<var_name="null"; + head->next=NULL; + } + ~var_stack() + { + var_stack_unit *temp=head; + var_stack_unit *this_node=NULL; + while(temp->next) + { + this_node=temp; + temp=temp->next; + delete this_node; + } + delete temp; + } + void append_var(std::string& varia_name,var& temp_var) + { + var_stack_unit *temp=head; + while(temp->next) + temp=temp->next; + temp->next=new var_stack_unit; + temp=temp->next; + temp->var_name=varia_name; + temp->var_detail=temp_var; + temp->next=NULL; + } + void print_var() + { + var_stack_unit *temp=head; + while(temp->next) + { + temp=temp->next; + std::cout<<"["; + switch(temp->var_detail.type) + { + case VAR_NONE: + std::cout<<"null"; + break; + case VAR_LLINT: + std::cout<<"int"; + break; + case VAR_DOUBLE: + std::cout<<"float"; + break; + case VAR_CHAR: + std::cout<<"char"; + break; + case VAR_STRING: + std::cout<<"string"; + break; + case VAR_LIST: + std::cout<<"array"; + break; + case VAR_HASH: + std::cout<<"hash"; + break; + } + std::cout<<"]: "<var_name<<" : "; + if(temp->var_detail.type!=VAR_STRING) + PrintVar(temp->var_detail); + else + std::cout<<*((std::string *)temp->var_detail.data); + std::cout<next) + { + temp=temp->next; + if(temp->var_name==varia_name) + { + temp_var=temp->var_detail; + break; + } + } + return temp_var; + } + void edit_var(std::string varia_name,var &temp_var) + { + var_stack_unit *temp=head; + while(temp->next) + { + temp=temp->next; + if(temp->var_name==varia_name) + { + temp->var_detail=temp_var; + break; + } + } + return; + } + void pop_var() + { + var_stack_unit *temp=head; + var_stack_unit *end_temp; + if(!head->next) + return; + while(temp->next) + { + end_temp=temp; + temp=temp->next; + } + end_temp->next=NULL; + delete temp; + } + void delete_all() + { + var_stack_unit *temp=head->next; + var_stack_unit *this_node=NULL; + head->next=NULL; + if(!temp) + return; + while(temp->next) + { + this_node=temp; + temp=temp->next; + delete this_node; + } + delete temp; + return; + } +}; +var_stack nasal_var_stack; + +#endif