diff --git a/version0.17/abstract_syntax_tree.h b/version0.17/abstract_syntax_tree.h
new file mode 100644
index 0000000..a9f7ee2
--- /dev/null
+++ b/version0.17/abstract_syntax_tree.h
@@ -0,0 +1,203 @@
+#ifndef __ABSTRACT_SYNTAX_TREE_H__
+#define __ABSTRACT_SYNTAX_TREE_H__
+
+class ast_tree_node
+{
+	protected:
+		int line;
+		int type;
+		std::list<ast_tree_node> children;// for node that can be extended
+		
+		double num;       // for number
+		std::string str;   // for string
+	public:
+		ast_tree_node()
+		{
+			line=0;
+			type=__root;
+			children.clear();
+			
+			num=0;
+			str="";
+		}
+		void set_line(int _line)
+		{
+			line=_line;
+			return;
+		}
+		int return_type()
+		{
+			return type;
+		}
+		int return_line()
+		{
+			return line;
+		}
+		double run()
+		{
+			if(type==__number)
+				return num;
+			else if(type==__root)
+			{
+				std::cout<<">>[Result(s)]"<<std::endl;
+				for(std::list<ast_tree_node>::iterator i=children.begin();i!=children.end();++i)
+					std::cout<<i->run()<<std::endl;
+				return 1;
+			}
+			else
+			{
+				std::list<ast_tree_node>::iterator i=children.begin();
+				double left_child=i->run();
+				++i;
+				double right_child=i->run();
+				switch(type)
+				{
+					case __add_operator:return left_child+right_child;break;
+					case __sub_operator:return left_child-right_child;break;
+					case __mul_operator:return left_child*right_child;break;
+					case __div_operator:return left_child/right_child;break;
+				}
+			}
+			return 0;
+		}
+		void add_child(ast_tree_node& new_child)
+		{
+			children.push_back(new_child);
+			return;
+		}
+		ast_tree_node& return_last_child()
+		{
+			std::list<ast_tree_node>::iterator i;
+			for(i=children.begin();i!=children.end();++i)
+				;
+			--i;
+			return *i;
+		}
+		void clear_tree()
+		{
+			line=0;
+			type=__root;
+			children.clear();
+			
+			num=0;
+			str="";
+			return;
+		}
+		int child_num()
+		{
+			int cnt=0;
+			for(std::list<ast_tree_node>::iterator i=children.begin();i!=children.end();++i)
+				++cnt;
+			return cnt;
+		}
+		void print(int tab_num)
+		{
+			for(int i=0;i<tab_num;++i)
+				std::cout<<" ";
+			if(type==__number)
+			{
+				std::cout<<"[ number:";
+				std::cout<<num;
+				std::cout<<" ]"<<std::endl;
+				return;
+			}
+			else if(type==__string)
+			{
+				std::cout<<"[ string:"<<str<<" ]"<<std::endl;
+				return;
+			}
+			std::cout<<"{ [ node type:";
+			print_token(type);
+			std::cout<<" ]"<<std::endl;
+			for(std::list<ast_tree_node>::iterator i=children.begin();i!=children.end();++i)
+				i->print(tab_num+1);
+			for(int i=0;i<tab_num;++i)
+				std::cout<<" ";
+			std::cout<<"}"<<std::endl;
+			return;
+		}
+};
+class operator_expr:public ast_tree_node
+{
+	public:
+		operator_expr():ast_tree_node()
+		{
+			type=__operator;
+		}
+		void set_operator_type(int oprt_type)
+		{
+			type=oprt_type;
+			return;
+		}
+};
+class number_expr:public ast_tree_node
+{
+	public:
+		number_expr():ast_tree_node()
+		{
+			type=__number;
+		}
+		double return_num()
+		{
+			return num;
+		}
+		void set_number(std::string& str)
+		{
+			type=__number;
+			double is_float=false;
+			int DotPlace=0;
+			for(int i=0;i<(int)str.length();++i)
+				if(str[i]=='.')
+				{
+					is_float=true;
+					DotPlace=i;
+					break;
+				}
+			if(!is_float)
+			{
+				num=0;
+				double acc=1;
+				for(int i=(int)str.length()-1;i>=0;--i)
+				{
+					num+=acc*((double)(str[i]-'0'));
+					acc*=10;
+				}
+			}
+			else
+			{
+				num=0;
+				double acc=1;
+				double aff=0.1;
+				for(int i=DotPlace+1;i<(int)str.length();++i)
+				{
+					num+=aff*((double)(str[i]-'0'));
+					aff*=0.1;
+				}
+				for(int i=DotPlace-1;i>=0;--i)
+				{
+					num+=acc*((double)(str[i]-'0'));
+					acc*=10;
+				}
+			}
+			return;
+		}
+};
+class string_expr:public ast_tree_node
+{
+	public:
+		string_expr():ast_tree_node()
+		{
+			type=__string;
+		}
+		void set_str(std::string& t)
+		{
+			str=t;
+			return;
+		}
+		std::string& return_str()
+		{
+			return str;
+		}
+};
+
+#endif
diff --git a/version0.17/ast_generator.h b/version0.17/ast_generator.h
new file mode 100644
index 0000000..5f9f9e4
--- /dev/null
+++ b/version0.17/ast_generator.h
@@ -0,0 +1,196 @@
+#ifndef __AST_GENERATOR_H__
+#define __AST_GENERATOR_H__
+
+class ast_generator
+{
+	private:
+		ast_tree_node root;
+		std::stack<parse_unit> parse;
+		std::stack<ast_tree_node> node_cache;
+		bool error;
+	public:
+		ast_generator()
+		{
+			error=false;
+		}
+		void input_token_stack(std::stack<parse_unit>& temp)
+		{
+			parse=temp;
+			return;
+		}
+		void number_gen()
+		{
+			number_expr t;
+			t.set_line(parse.top().line);
+			t.set_number(parse.top().content);
+			if(node_cache.empty())
+				node_cache.push(t);
+			else if((node_cache.top().return_type()==__add_operator || node_cache.top().return_type()==__sub_operator || node_cache.top().return_type()==__mul_operator || node_cache.top().return_type()==__div_operator)
+					&& (node_cache.top().child_num()==1))
+				node_cache.top().add_child(t);
+			else
+			{
+				std::cout<<">>[Error] parse error in line "<<parse.top().line<<":missing \';\' at this place."<<std::endl;
+				error=true;
+			}
+			return;
+		}
+		void add_sub_operator_gen()
+		{
+			operator_expr opt;
+			opt.set_line(parse.top().line);
+			opt.set_operator_type(parse.top().type);
+			if(node_cache.empty())
+			{
+				number_expr t;
+				t.set_line(parse.top().line);
+				std::string temp_str="0";
+				t.set_number(temp_str);
+				opt.add_child(t);
+				node_cache.push(opt);
+			}
+			else if(node_cache.top().return_type()==__number
+					|| ((node_cache.top().return_type()==__add_operator
+					|| node_cache.top().return_type()==__sub_operator
+					|| node_cache.top().return_type()==__mul_operator
+					|| node_cache.top().return_type()==__div_operator)
+					&& node_cache.top().child_num()==2))
+			{
+				opt.add_child(node_cache.top());
+				node_cache.pop();
+				node_cache.push(opt);
+			}
+			else
+			{
+				std::cout<<">>[Error] parse error in line "<<parse.top().line<<":missing number/calculation at this place."<<std::endl;
+				error=true;
+			}
+			return;
+		}
+		void mul_div_operator_gen()
+		{
+			operator_expr opt;
+			opt.set_line(parse.top().line);
+			opt.set_operator_type(parse.top().type);
+			if(node_cache.empty())
+			{
+				std::cout<<">>[Error] parse error in line "<<parse.top().line<<":missing number at this place(you cannot use * or / as the begin of calculation)."<<std::endl;
+				error=true;
+				return;
+			}
+				
+			if(node_cache.top().return_type()==__number)
+			{
+				// add new leaf node number to operator
+				opt.add_child(node_cache.top());
+				node_cache.pop();
+				node_cache.push(opt);
+			}
+			else if(node_cache.top().return_type()==__add_operator || node_cache.top().return_type()==__sub_operator)
+			{
+				if(node_cache.top().child_num()!=2)
+				{
+					std::cout<<">>[Error] parse error in line "<<parse.top().line<<":missing number at this place."<<std::endl;
+					error=true;
+				}
+				else
+				{
+					// calcu * and / first so pick a number from +-'s children nodes
+					opt.add_child(node_cache.top().return_last_child());
+					parse.pop();
+					// add the next number to fix the operator node's children list
+					if(!parse.empty() && parse.top().type==__number)
+					{
+						number_expr t;
+						t.set_line(parse.top().line);
+						t.set_number(parse.top().content);
+						opt.add_child(t);
+					}
+					else
+					{
+						std::cout<<">>[Error] parse error in line "<<parse.top().line<<":missing number at this place."<<std::endl;
+						error=true;
+						return;
+					}
+					node_cache.top().return_last_child()=opt;
+				}
+			}
+			else if(node_cache.top().return_type()==__mul_operator || node_cache.top().return_type()==__div_operator)
+			{
+				if(node_cache.top().child_num()!=2)
+				{
+					std::cout<<">>[Error] parse error in line "<<parse.top().line<<":missing number at this place."<<std::endl;
+					error=true;
+				}
+				else
+				{
+					opt.add_child(node_cache.top());
+					node_cache.pop();
+					node_cache.push(opt);
+				}
+			}
+			return;
+		}
+		void gen_main_prog()
+		{
+			error=false;
+			root.clear_tree();
+			// initializing
+			
+			while(!node_cache.empty())
+				node_cache.pop();
+			while(!parse.empty())
+			{
+				int type=parse.top().type;
+				bool is_correct=false;
+				switch(type)
+				{
+					case __number:number_gen();break;
+					case __add_operator:add_sub_operator_gen();break;
+					case __sub_operator:add_sub_operator_gen();break;
+					case __mul_operator:mul_div_operator_gen();break;
+					case __div_operator:mul_div_operator_gen();break;
+					case __semi:
+						if(!node_cache.empty())
+						{
+							root.add_child(node_cache.top());
+							node_cache.pop();
+						}
+						break;
+					default:
+						std::cout<<">>[Error] parse error in line "<<parse.top().line<<":";
+						print_token(parse.top().type);
+						std::cout<<" at an incorrect place."<<std::endl;
+						break;
+				}
+				parse.pop();
+			}
+			if(error)
+			{
+				std::cout<<">>[Parse] Error(s) occurred."<<std::endl;
+				std::cout<<">>[Parse] Complete parsing."<<std::endl;
+			}
+			else
+			{
+				std::cout<<">>[Parse] 0 error."<<std::endl;
+				std::cout<<">>[Parse] Complete parsing."<<std::endl;
+			}
+			return;
+		}
+		void print_ast()
+		{
+			std::cout<<">>[Abstract-syntax-tree]"<<std::endl;
+			root.print(0);
+			return;
+		}
+		void run()
+		{
+			if(!error)
+				root.run();
+			else
+				std::cout<<">>[Parse] Error(s) occurred,stop running the code."<<std::endl;
+			return;
+		}
+};
+
+#endif
diff --git a/version0.17/main.cpp b/version0.17/main.cpp
new file mode 100644
index 0000000..5145f9f
--- /dev/null
+++ b/version0.17/main.cpp
@@ -0,0 +1,83 @@
+#include "nasal.h"
+int main()
+{
+	resource_programme_process prog;
+	nasal_lexer lex;
+	nasal_parser pas;
+	ast_generator cod;
+	std::string command;
+	std::cout<<">> Nasal interpreter by ValKmjolnir"<<std::endl;
+	std::cout<<">> Input [help] to find help."<<std::endl;
+	while(1)
+	{
+		std::cout<<">> ";
+		std::getline(std::cin,command);
+		if(command=="help")
+		{
+			std::cout<<">> Nasal interpreter by ValKmjolnir"<<std::endl;
+			std::cout<<">> 1. [      ] |input file name to load the file."<<std::endl;
+			std::cout<<">> 2. [cls   ] |clear the screen."<<std::endl;
+			std::cout<<">> 3. [exit  ] |shut down the interpreter."<<std::endl;
+			std::cout<<">> 4. [lexer ] |run and show the lexer. (-lexer)"<<std::endl;
+			std::cout<<">> 5. [parser] |run parser. (-parser)"<<std::endl;
+			std::cout<<">> 6. [ast   ] |print the abstract syntax tree."<<std::endl;
+			std::cout<<">> 7. [del   ] |delete program in memory."<<std::endl;
+			std::cout<<">> 8. [run   ] |run the programme in stack. (-lexer -parser)"<<std::endl;
+			std::cout<<">> 9. [rs    ] |check the source program."<<std::endl;
+			std::cout<<">>10. [rule  ] |see rules of the language."<<std::endl;
+		}
+		else if(command=="cls")
+		{
+			system("cls");
+			//windows  system("cls");
+			//linux system("clear");
+			//macOS system("clear");
+		}
+		else if(command=="rs")
+			prog.print_file();
+		else if(command=="exit")
+		{
+			break;
+		}
+		else if(command=="lexer")
+		{
+			lex.lexer_process(prog.use_file());
+			lex.print_lexer();
+		}
+		else if(command=="del")
+		{
+			prog.del_file();
+			std::cout<<">>[Delete] Complete."<<std::endl;
+		}
+		else if(command=="parser")
+		{
+			lex.lexer_process(prog.use_file());
+			pas.parse_process(lex.return_list());
+			pas.print_parser_stack();
+		}
+		else if(command=="ast")
+		{
+			lex.lexer_process(prog.use_file());
+			pas.parse_process(lex.return_list());
+			cod.input_token_stack(pas.return_stack());
+			cod.gen_main_prog();
+			cod.print_ast();
+		}
+		else if(command=="run")
+		{
+			lex.lexer_process(prog.use_file());
+			pas.parse_process(lex.return_list());
+			cod.input_token_stack(pas.return_stack());
+			cod.gen_main_prog();
+			cod.run();
+		}
+		else if(command=="rule")
+		{
+			std::cout<<">>[Rule] Token types that you can use: number + - * /"<<std::endl;
+			std::cout<<">>[Rule] Each binary operator should have two numbers around it like: 1 + 1"<<std::endl;
+		}
+		else
+			prog.input_file(command);
+	}
+	return 0;
+}
diff --git a/version0.17/nasal.h b/version0.17/nasal.h
new file mode 100644
index 0000000..0b7c1a0
--- /dev/null
+++ b/version0.17/nasal.h
@@ -0,0 +1,17 @@
+#ifndef __NASAL_H__
+#define __NASAL_H__
+
+#include <iostream>
+#include <cstring>
+#include <fstream>
+#include <thread>
+#include <stack>
+#include <list>
+
+#include "nasal_token_type.h"
+#include "nasal_lexer.h"
+#include "nasal_parser.h"
+#include "abstract_syntax_tree.h"
+#include "ast_generator.h"
+
+#endif
diff --git a/version0.17/nasal_lexer.h b/version0.17/nasal_lexer.h
new file mode 100644
index 0000000..1229852
--- /dev/null
+++ b/version0.17/nasal_lexer.h
@@ -0,0 +1,408 @@
+#ifndef __NASAL_LEXER_H__
+#define __NASAL_LEXER_H__
+
+#include <iostream>
+#include <fstream>
+#include <list>
+#include <cstring>
+
+#define OPERATOR     1  // operator
+#define IDENTIFIER   2  // id
+#define NUMBER       3  // number
+#define RESERVEWORD  4  // reserve word
+#define STRING       5  // string 
+#define DYNAMIC_ID   6 // id...
+#define FAIL        -1  //fail
+#define SCANEND     -2  //complete scanning
+#define ERRORFOUND  -3  //error occurred
+
+std::string reserve_word[15]=
+{
+	"for","foreach","forindex","while",
+	"var","func","break","continue","return",
+	"if","else","elsif","nil","and","or"
+};
+
+int isReserveWord(std::string &p)
+{
+	for(int i=0;i<15;++i)
+		if(reserve_word[i]==p)
+			return i+1;
+	return FAIL;
+}
+
+bool isLetter(char t)
+{
+	return (('a'<=t) && (t<='z') || ('A'<=t) && (t<='Z'));
+}
+
+bool isNumber(char t)
+{
+	return (('0'<=t) && (t<='9'));
+}
+
+bool isHex(char t)
+{
+	return ((('0'<=t) && (t<='9')) || (('a'<=t) && (t<='f')));
+}
+
+bool isOct(char t)
+{
+	return (('0'<=t) && (t<='7'));
+}
+
+class resource_programme_process
+{
+	private:
+		char *resource;
+	public:
+		resource_programme_process()
+		{
+			resource=NULL;
+			resource=new char[16777216];
+		}
+		~resource_programme_process()
+		{
+			if(resource)
+				delete []resource;
+		}
+		char* use_file()
+		{
+			return resource;
+		}
+		void input_file(std::string& filename)
+		{
+			std::ifstream fin(filename);
+			if(fin.fail())
+			{
+				std::cout<<">>[Error] Cannot load file: "<<filename<<" ."<<std::endl;
+				fin.close();
+				return;
+			}
+			memset(resource,0,sizeof(char));
+			int i=0;
+			bool findnote=false;// to find the note with # at the head of line.
+			while(!fin.eof())
+			{
+				resource[i]=fin.get();
+				if(resource[i]=='\n')
+					findnote=false;
+				//when meeting '\n' the findnote is set to false then the next statement can be executed.
+				if(resource[i]!='#' && !findnote)
+					++i;
+				else if(resource[i]=='#')
+					findnote=true;
+				if(fin.eof())
+					break;
+			}
+			resource[i]='\0';
+			fin.close();
+			return;
+		}
+		void print_file()
+		{
+			if(!resource[0])
+			{
+				std::cout<<"0	null"<<std::endl;
+				return;
+			}
+			int line=1;
+			std::cout<<line<<"	";
+			for(int i=0;i<16777216;++i)
+			{
+				if(!resource[i])
+					break;
+				std::cout<<resource[i];
+				if(resource[i]=='\n')
+				{
+					++line;
+					std::cout<<line<<"	";
+				}
+			}
+			std::cout<<std::endl;
+			return;
+		}
+		void del_file()
+		{
+			memset(resource,0,sizeof(char));
+			return;
+		}
+};
+
+struct token
+{
+	int line;
+	int type;
+	std::string content;
+};
+
+class nasal_lexer
+{
+	private:
+		std::list<token> lexer;
+	public:
+		void scanner(int &syn,const char* source,std::string &__token,int &ptr,int &line)
+		{
+			char temp;
+			temp=source[ptr];
+			while(temp==' ' || temp=='\n' || temp=='\t' || temp=='\r' || temp<0 || temp>127)
+			{
+				++ptr;
+				if(temp=='\n')
+					++line;
+				temp=source[ptr];
+			}
+			__token="";
+			if(isLetter(temp) || temp=='_')
+			{
+				__token+=temp;
+				++ptr;
+				temp=source[ptr];
+				while(isLetter(temp) || isNumber(temp) || temp=='_')
+				{
+					__token+=temp;
+					++ptr;
+					temp=source[ptr];
+				}
+				syn=isReserveWord(__token);
+				if(syn==FAIL)
+					syn=IDENTIFIER;
+				else
+					syn=RESERVEWORD;
+				if((syn==IDENTIFIER) && source[ptr]=='.' && source[ptr+1]=='.' && source[ptr+2]=='.')
+				{
+					__token+="...";
+					syn=DYNAMIC_ID;
+					ptr+=3;
+				}
+			}
+			else if(isNumber(temp))
+			{
+				if((source[ptr]=='0') && (source[ptr+1]=='x'))
+				{
+					__token+=source[ptr];
+					__token+=source[ptr+1];
+					ptr+=2;
+					temp=source[ptr];
+					while(isNumber(temp) || isHex(temp))
+					{
+						__token+=temp;
+						++ptr;
+						temp=source[ptr];
+					}
+				}
+				else if((source[ptr]=='0') && (source[ptr+1]=='o'))
+				{
+					__token+=source[ptr];
+					__token+=source[ptr+1];
+					ptr+=2;
+					temp=source[ptr];
+					while(isNumber(temp) || isOct(temp))
+					{
+						__token+=temp;
+						++ptr;
+						temp=source[ptr];
+					}
+				}
+				else
+				{
+					int PointCnt=0;
+					while(isNumber(temp))
+					{
+						__token+=temp;
+						++ptr;
+						temp=source[ptr];
+						if(temp=='.' && !PointCnt)
+						{
+							++PointCnt;
+							__token+=temp;
+							++ptr;
+							temp=source[ptr];
+						}
+					}
+				}
+				syn=NUMBER;
+			}
+			else if(temp=='(' || temp==')' || temp=='[' || temp==']' || temp=='{' ||
+					temp=='}' || temp==',' || temp==';' || temp=='|' || temp==':' ||
+					temp=='?' || temp=='.' || temp=='`' || temp=='&' || temp=='@' ||
+					temp=='%' || temp=='$' || temp=='^')
+			{
+				__token+=temp;
+				++ptr;
+				syn=OPERATOR;
+			}
+			else if(temp=='\'')
+			{
+				syn=STRING;
+				__token+=temp;
+				++ptr;
+				temp=source[ptr];
+				while(temp!='\'')
+				{
+					if(temp=='\\')
+					{
+						__token+=temp;
+						
+						++ptr;
+						temp=source[ptr];
+						__token+=temp;
+						
+						++ptr;
+						temp=source[ptr];
+					}
+					else
+					{
+						__token+=temp;
+						++ptr;
+						temp=source[ptr];
+					}
+					if(temp==0 || temp=='\n')
+						break;
+				}
+				//add the last char \"
+				if(temp=='\'')
+				{
+					__token+=temp;
+					++ptr;
+				}
+				else
+					__token+=" __missing_end_of_string";
+			}
+			else if(temp=='=' || temp=='+' || temp=='-' || temp=='*' || temp=='!' || temp=='/' || temp=='<' || temp=='>' || temp=='~')
+			{
+				syn=OPERATOR;
+				__token+=temp;
+				++ptr;
+				temp=source[ptr];
+				if(temp=='=')
+				{
+					__token+=temp;
+					++ptr;
+				}
+			}
+			else if(temp=='\\')
+			{
+				syn=OPERATOR;
+				__token+=temp;
+				++ptr;
+				temp=source[ptr];
+				if(temp=='=' || temp=='n' || temp=='t' || temp=='r' || temp=='\\' || temp=='\'' || temp=='\"')
+				{
+					__token+=temp;
+					++ptr;
+				}
+			}
+			else if(temp=='\"')
+			{
+				syn=STRING;
+				__token+=temp;
+				++ptr;
+				temp=source[ptr];
+				while(temp!='\"')
+				{
+					if(temp=='\\')
+					{
+						__token+=temp;
+						
+						++ptr;
+						temp=source[ptr];
+						__token+=temp;
+						
+						++ptr;
+						temp=source[ptr];
+					}
+					else
+					{
+						__token+=temp;
+						++ptr;
+						temp=source[ptr];
+					}
+					if(temp==0 || temp=='\n')
+						break;
+				}
+				//add the last char \"
+				if(temp=='\"')
+				{
+					__token+=temp;
+					++ptr;
+				}
+				else
+					__token+=" __missing_end_of_string";
+			}
+			else if(temp==0)
+			{
+				syn=SCANEND;
+				return;
+			}
+			else
+			{
+				syn=FAIL;
+				std::cout<<">>[Error] Unexpected error occurred: "<<temp<<std::endl;
+				system("pause");
+				++ptr;
+				return;
+			}
+			if(__token=="")
+			{
+				syn=ERRORFOUND;
+				std::cout<<">>[Error] Cannot identify "<<std::endl;
+			}
+			return;
+		}
+		void lexer_process(const char *source)
+		{
+			std::cout<<">>[Lexer] max size: "<<lexer.max_size()<<" ."<<std::endl;
+			lexer.clear();
+			int syn=0;//token type
+			int ptr=0;//pointer to one char in ResourcePrograme
+			int line=1;
+			std::string __token;
+			token temp;
+			while(syn!=SCANEND && syn!=ERRORFOUND)
+			{
+				scanner(syn,source,__token,ptr,line);
+				if(syn>0)//all Syn type is larger than zero
+				{
+					temp.line=line;
+					temp.type=syn;
+					temp.content=__token;
+					lexer.push_back(temp);
+				}
+			}
+			std::cout<<">>[Lexer] Complete scanning."<<std::endl;
+			return;
+		}
+		void print_lexer()
+		{
+			token temp;
+			for(std::list<token>::iterator i=lexer.begin();i!=lexer.end();++i)
+			{
+				temp=*i;
+				std::cout<<"line "<<temp.line<<": ";
+				if(temp.type==OPERATOR)
+					std::cout<<"( Operator       | ";
+				else if(temp.type==IDENTIFIER)
+					std::cout<<"( Identifier     | ";
+				else if(temp.type==NUMBER)
+					std::cout<<"( Number         | ";
+				else if(temp.type==RESERVEWORD)
+					std::cout<<"( ReserveWord    | ";
+				else if(temp.type==STRING)
+					std::cout<<"( String         | ";
+				else if(temp.type==DYNAMIC_ID)
+					std::cout<<"( Identifier     | ";
+				std::cout<<temp.content<<" )"<<std::endl;
+			}
+			return;
+		}
+		std::list<token>& return_list()
+		{
+			return lexer;
+		}
+};
+		
+
+		
+
+#endif
diff --git a/version0.17/nasal_parser.h b/version0.17/nasal_parser.h
new file mode 100644
index 0000000..3bbe01a
--- /dev/null
+++ b/version0.17/nasal_parser.h
@@ -0,0 +1,200 @@
+#ifndef __NASAL_PARSER_H__
+#define __NASAL_PARSER_H__
+
+#include "nasal_token_type.h"
+
+struct parse_unit
+{
+	int line;
+	int type;
+	std::string content;
+};
+
+
+class nasal_parser
+{
+	private:
+		std::stack<parse_unit> parser;
+	public:
+		void print_parser_stack()
+		{
+			if(parser.empty())
+				return;
+			int line=0;
+			std::stack<parse_unit> temp;
+			while(!parser.empty())
+			{
+				temp.push(parser.top());
+				if(line!=temp.top().line)
+				{
+					if(line+1==temp.top().line)
+					{
+						line=temp.top().line;
+						if(line==1)
+							std::cout<<"line "<<line<<"    ";
+						else
+							std::cout<<std::endl<<"line "<<line<<"    ";
+					}
+					else
+					{
+						while(line!=temp.top().line)
+						{
+							++line;
+							std::cout<<std::endl<<"line "<<line<<"    ";
+						}
+					}
+				}
+				std::cout<<"<";
+				print_token(temp.top().type);
+				std::cout<<"> ";
+				parser.pop();
+			}
+			while(!temp.empty())
+			{
+				parser.push(temp.top());
+				temp.pop();
+			}
+			std::cout<<std::endl;
+			return;
+		}
+		std::stack<parse_unit>& return_stack()
+		{
+			return parser;
+		}
+		void parse_process(std::list<token>& lexer)
+		{
+			while(!parser.empty())
+				parser.pop();
+			std::stack<parse_unit> temp;
+			for(std::list<token>::iterator i=lexer.begin();i!=lexer.end();++i)
+			{
+				parse_unit temp_parse;
+				temp_parse.line=i->line;
+				temp_parse.content=i->content;
+				if((*i).type==RESERVEWORD)
+				{
+					if((*i).content=="var")
+						temp_parse.type=__var;
+					else if((*i).content=="func")
+						temp_parse.type=__func;
+					else if((*i).content=="return")
+						temp_parse.type=__return;
+					else if((*i).content=="nil")
+						temp_parse.type=__number;
+					else if((*i).content=="continue")
+						temp_parse.type=__continue;
+					else if((*i).content=="break")
+						temp_parse.type=__break;
+					else if((*i).content=="and")
+						temp_parse.type=__and_operator;
+					else if((*i).content=="or")
+						temp_parse.type=__or_operator;
+					else if((*i).content=="for")
+						temp_parse.type=__for;
+					else if((*i).content=="forindex")
+						temp_parse.type=__forindex;
+					else if((*i).content=="foreach")
+						temp_parse.type=__foreach;
+					else if((*i).content=="while")
+						temp_parse.type=__while;
+					else if((*i).content=="if")
+						temp_parse.type=__if;
+					else if((*i).content=="else")
+						temp_parse.type=__else;
+					else if((*i).content=="elsif")
+						temp_parse.type=__elsif;
+				}
+				else if(((*i).content=="==") || ((*i).content=="!=") || ((*i).content==">") || ((*i).content==">=") || ((*i).content=="<") || ((*i).content=="<="))
+				{
+					if((*i).content=="==")
+						temp_parse.type=__cmp_equal;
+					else if((*i).content=="!=")
+						temp_parse.type=__cmp_not_equal;
+					else if((*i).content==">")
+						temp_parse.type=__cmp_more;
+					else if((*i).content==">=")
+						temp_parse.type=__cmp_more_or_equal;
+					else if((*i).content=="<")
+						temp_parse.type=__cmp_less;
+					else if((*i).content=="<=")
+						temp_parse.type=__cmp_less_or_equal;
+				}
+				else if(((*i).content==";") || ((*i).content==",") || ((*i).content=="=") || ((*i).content==":") || ((*i).content==".") || ((*i).content=="?") || ((*i).content=="%") || ((*i).content=="$") || ((*i).content=="`") || ((*i).content=="^") || ((*i).content=="@"))
+				{
+					char c=(*i).content[0];
+					switch(c)
+					{
+						case ';':temp_parse.type=__semi;break;
+						case ',':temp_parse.type=__comma;break;
+						case '=':temp_parse.type=__equal;break;
+						case ':':temp_parse.type=__colon;break;
+						case '.':temp_parse.type=__dot;break;
+						default:temp_parse.type=__unknown_operator;break;
+					}
+				}
+				else if(((*i).type==NUMBER) || ((*i).type==STRING) || ((*i).type==IDENTIFIER) || ((*i).type==DYNAMIC_ID))
+				{
+					int t=(*i).type;
+					switch(t)
+					{
+						case NUMBER:temp_parse.type=__number;break;
+						case STRING:temp_parse.type=__string;break;
+						case IDENTIFIER:temp_parse.type=__id;break;
+						case DYNAMIC_ID:temp_parse.type=__dynamic_id;break;
+					}
+				}
+				else if(((*i).content=="+") || ((*i).content=="-") || ((*i).content=="*") || ((*i).content=="/") || ((*i).content=="~") || ((*i).content=="!"))
+				{
+					char c=(*i).content[0];
+					switch(c)
+					{
+						case '+':temp_parse.type=__add_operator;break;
+						case '-':temp_parse.type=__sub_operator;break;
+						case '*':temp_parse.type=__mul_operator;break;
+						case '/':temp_parse.type=__div_operator;break;
+						case '~':temp_parse.type=__link_operator;break;
+						case '!':temp_parse.type=__nor_operator;break;
+					}
+				}
+				else if(((*i).content=="+=") || ((*i).content=="-=") || ((*i).content=="*=") || ((*i).content=="/=") || ((*i).content=="~="))
+				{
+					char c=(*i).content[0];
+					switch(c)
+					{
+						case '+':temp_parse.type=__add_equal;break;
+						case '-':temp_parse.type=__sub_equal;break;
+						case '*':temp_parse.type=__mul_equal;break;
+						case '/':temp_parse.type=__div_equal;break;
+						case '~':temp_parse.type=__link_equal;break;
+					}
+				}
+				else if(((*i).content=="(") || ((*i).content==")") || ((*i).content=="[") || ((*i).content=="]") || ((*i).content=="{") || ((*i).content=="}"))
+				{
+					char c=(*i).content[0];
+					switch(c)
+					{
+						case '(':temp_parse.type=__left_curve;break;
+						case ')':temp_parse.type=__right_curve;break;
+						case '[':temp_parse.type=__left_bracket;break;
+						case ']':temp_parse.type=__right_bracket;break;
+						case '{':temp_parse.type=__left_brace;break;
+						case '}':temp_parse.type=__right_brace;break;
+					}
+				}
+				temp.push(temp_parse);//push this into stack
+			}
+			if(temp.empty())
+			{
+				std::cout<<">>[Parse] [-Warning] Empty lexer list."<<std::endl;
+				return;
+			}
+			while(!temp.empty())
+			{
+				parser.push(temp.top());
+				temp.pop();
+			}
+			return;
+		}
+};
+
+#endif
diff --git a/version0.17/nasal_token_type.h b/version0.17/nasal_token_type.h
new file mode 100644
index 0000000..7bc881c
--- /dev/null
+++ b/version0.17/nasal_token_type.h
@@ -0,0 +1,99 @@
+#ifndef __NASAL_TOKEN_TYPE_H__
+#define __NASAL_TOKEN_TYPE_H__
+
+#include <cstring>
+
+enum token_type
+{
+	__stack_end=1,
+	__equal,                                       // =
+	__cmp_equal,__cmp_not_equal,                   // == !=
+	__cmp_less,__cmp_less_or_equal,                // < <=
+	__cmp_more,__cmp_more_or_equal,                // > >=
+	__and_operator,__or_operator,__nor_operator,   // and or !
+	__add_operator,__sub_operator,                 // + -
+	__mul_operator,__div_operator,__link_operator, // * / ~
+	__add_equal,__sub_equal,                       // += -=
+	__mul_equal,__div_equal,__link_equal,          // *= /= ~=
+	__left_brace,__right_brace,                    // {}
+	__left_bracket,__right_bracket,                // []
+	__left_curve,__right_curve,                    // ()
+	__semi,__comma,__colon,__dot,                  // ; , : .
+	__unknown_operator,
+	__var,__func,__return,
+	__if,__elsif,__else,
+	__continue,__break,
+	__for,__forindex,__foreach,__while,
+	//operators & reserve words
+	
+	__number,__string,__id,__dynamic_id,
+	//basic elements
+	
+	__root,__operator,
+};
+
+void print_token(int type)
+{
+	std::string context="";
+	switch(type)
+	{
+		case __stack_end:         context="#";break;
+		case __equal:             context="=";break;
+		case __cmp_equal:         context="==";break;
+		case __cmp_not_equal:     context="!=";break;
+		case __cmp_less:          context="<";break;
+		case __cmp_less_or_equal: context="<=";break;
+		case __cmp_more:          context=">";break;
+		case __cmp_more_or_equal: context=">=";break;
+		case __and_operator:      context="and";break;
+		case __or_operator:       context="or";break;
+		case __nor_operator:      context="!";break;
+		case __add_operator:      context="+";break;
+		case __sub_operator:      context="-";break;
+		case __mul_operator:      context="*";break;
+		case __div_operator:      context="/";break;
+		case __link_operator:     context="~";break;
+		case __add_equal:         context="+=";break;
+		case __sub_equal:         context="-=";break;
+		case __mul_equal:         context="*=";break;
+		case __div_equal:         context="/=";break;
+		case __link_equal:        context="~=";break;
+		case __left_brace:        context="{";break;
+		case __right_brace:       context="}";break;
+		case __left_bracket:      context="[";break;
+		case __right_bracket:     context="]";break;
+		case __left_curve:        context="(";break;
+		case __right_curve:       context=")";break;
+		case __semi:              context=";";break;
+		case __comma:             context=",";break;
+		case __colon:             context=":";break;
+		case __dot:               context=".";break;
+		case __unknown_operator:  context="un_optr";break;
+		case __var:               context="var";break;
+		case __func:              context="func";break;
+		case __continue:          context="ctn";break;
+		case __break:             context="brk";break;
+		case __for:               context="for";break;
+		case __forindex:          context="foridx";break;
+		case __foreach:           context="foreh";break;
+		case __while:             context="while";break;
+		case __if:                context="if";break;
+		case __elsif:             context="elsif";break;
+		case __else:              context="else";break;
+		case __return:            context="rtrn";break;
+		
+		case __id:                context="id";break;
+		case __dynamic_id:        context="id...";break;
+		case __number:            context="num";break;
+		case __string:            context="str";break;
+		
+		case __root:              context="root";break;
+		case __operator:          context="optr";break;
+		default:                  context="ukn_tkn";break;
+	}
+	std::cout<<context;
+	return;
+}
+
+
+#endif
diff --git a/version0.17/test.txt b/version0.17/test.txt
new file mode 100644
index 0000000..776c287
--- /dev/null
+++ b/version0.17/test.txt
@@ -0,0 +1,32 @@
+1*1/1+1;
+1*2*3*4/1-2+3;
+1+1-1-1+20-2*10;
+10/10;
+1*1/1+1;
+1*2*3*4/1-2+3;
+1+1-1-1+20-2*10;
+10/10;
+1*1/1+1;
+1*2*3*4/1-2+3;
+1+1-1-1+20-2*10;
+10/10;
+1*1/1+1;
+1*2*3*4/1-2+3;
+1+1-1-1+20-2*10;
+10/10;
+1*1/1+1;
+1*2*3*4/1-2+3;
+1+1-1-1+20-2*10;
+10/10;
+1*1/1+1;
+1*2*3*4/1-2+3;
+1+1-1-1+20-2*10;
+10/10;
+1*1/1+1;
+1*2*3*4/1-2+3;
+1+1-1-1+20-2*10;
+10/10;
+1*1/1+1;
+1*2*3*4/1-2+3;
+1+1-1-1+20-2*10;
+10/10;
\ No newline at end of file