├── .gitignore
├── Document
    ├── Thumbs.db
    ├── image1.JPG
    ├── image2.JPG
    ├── image3.JPG
    ├── image4.JPG
    └── image5.JPG
├── IO
    ├── output
    │   ├── tree.jpg
    │   ├── postfix_regular_expression.txt
    │   ├── tokens.txt
    │   ├── tree.html
    │   └── NFA.dat
    └── input
    │   ├── program.pas
    │   └── regular_expression.txt
├── sources
    ├── tree_node.cpp
    ├── main.cpp
    ├── token.cpp
    ├── state.cpp
    ├── lex_analyser.cpp
    └── parser.cpp
├── headers
    ├── token.hpp
    ├── tree_node.hpp
    ├── state.hpp
    ├── lex_analyser.hpp
    └── parser.hpp
├── CMakeLists.txt
├── readme.md
└── .github
    └── workflows
        └── cmake.yml


/.gitignore:
--------------------------------------------------------------------------------
1 | .vscode
2 | build


--------------------------------------------------------------------------------
/Document/Thumbs.db:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SajjadAemmi/Pascal-recursive-descent-parser/HEAD/Document/Thumbs.db


--------------------------------------------------------------------------------
/Document/image1.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SajjadAemmi/Pascal-recursive-descent-parser/HEAD/Document/image1.JPG


--------------------------------------------------------------------------------
/Document/image2.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SajjadAemmi/Pascal-recursive-descent-parser/HEAD/Document/image2.JPG


--------------------------------------------------------------------------------
/Document/image3.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SajjadAemmi/Pascal-recursive-descent-parser/HEAD/Document/image3.JPG


--------------------------------------------------------------------------------
/Document/image4.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SajjadAemmi/Pascal-recursive-descent-parser/HEAD/Document/image4.JPG


--------------------------------------------------------------------------------
/Document/image5.JPG:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SajjadAemmi/Pascal-recursive-descent-parser/HEAD/Document/image5.JPG


--------------------------------------------------------------------------------
/IO/output/tree.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/SajjadAemmi/Pascal-recursive-descent-parser/HEAD/IO/output/tree.jpg


--------------------------------------------------------------------------------
/sources/tree_node.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include "tree_node.hpp"
 3 | 
 4 | using namespace std;
 5 | 
 6 | TreeNode::TreeNode(string label)
 7 | {
 8 |     data = label;
 9 | }
10 | 
11 | TreeNode::TreeNode()
12 | {
13 |     data = "";
14 | }
15 | 


--------------------------------------------------------------------------------
/IO/input/program.pas:
--------------------------------------------------------------------------------
 1 | program example(input, output);
 2 | var x, y: integer;
 3 | function gcd(a, b: integer): result integer;
 4 | begin 
 5 | 	if b = 0 then gcd:= a 
 6 | 	else gcd:= gcd(b, a mod b)
 7 | end
 8 | begin
 9 | 	READ(x, y); 
10 | 	WRITE(gcd(x, y)) 
11 | end
12 | 


--------------------------------------------------------------------------------
/headers/token.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <iostream>
 4 | 
 5 | using namespace std;
 6 | 
 7 | class Token
 8 | {
 9 | public:
10 | 	string value;
11 | 	string type;
12 | 
13 | 	Token();
14 | 	Token(string value);
15 | 	string typeDetection(string value);
16 | };
17 | 


--------------------------------------------------------------------------------
/IO/input/regular_expression.txt:
--------------------------------------------------------------------------------
1 | (~()+(~))+(~+)+(~*)+(:)+(;)+(,)+(-)+(=)+(:.=)+(<.>)+(<.=)+(>.=)+(>)+(<)+(o.r)+(a.n.d)+(m.o.d)+(d.i.v)
2 | ([0-9]).([0-9])*
3 | ([a-z]+[A-Z]+_).([a-z]+[A-Z]+[0-9]+_)*
4 | (m.a.i.n)+(i.f)+(t.h.e.n)+(e.l.s.e)+(w.h.i.l.e)+(f.o.r)+(d.o)+(b.e.g.i.n)+(e.n.d)+(v.a.r)+(i.n.t.e.g.e.r)+(r.e.a.l)+(f.u.n.c.t.i.o.n)+(a.r.r.a.y)+(p.r.o.c.e.d.u.r.e)+(r.e.s.u.l.t)+(p.r.o.g.r.a.m)


--------------------------------------------------------------------------------
/headers/tree_node.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once 
 2 | 
 3 | #include <iostream>
 4 | #include <fstream>
 5 | #include <vector>
 6 | #include <algorithm>
 7 | #include <stack>
 8 | #include <set>
 9 | #include <list>
10 | #include <string>
11 | #include <sstream>
12 | #include <map>
13 | 
14 | using namespace std;
15 | 
16 | class TreeNode
17 | {
18 | public:
19 | 	string data;
20 | 	vector<TreeNode*> childs;
21 | 
22 | 	TreeNode();
23 | 	TreeNode(string label);
24 | };
25 | 


--------------------------------------------------------------------------------
/IO/output/postfix_regular_expression.txt:
--------------------------------------------------------------------------------
1 | ~(~)+~++~*+:+;+,+-+=+:=.+<>.+<=.+>=.+>+<+or.+an.d.+mo.d.+di.v.+01+2+3+4+5+6+7+8+9+01+2+3+4+5+6+7+8+9+*.+ab+c+d+e+f+g+h+i+j+k+l+m+n+o+p+q+r+s+t+u+v+w+x+y+z+AB+C+D+E+F+G+H+I+J+K+L+M+N+O+P+Q+R+S+T+U+V+W+X+Y+Z++_+ab+c+d+e+f+g+h+i+j+k+l+m+n+o+p+q+r+s+t+u+v+w+x+y+z+AB+C+D+E+F+G+H+I+J+K+L+M+N+O+P+Q+R+S+T+U+V+W+X+Y+Z++01+2+3+4+5+6+7+8+9++_+*.+ma.i.n.if.+th.e.n.+el.s.e.+wh.i.l.e.+fo.r.+do.+be.g.i.n.+en.d.+va.r.+in.t.e.g.e.r.+re.a.l.+fu.n.c.t.i.o.n.+ar.r.a.y.+pr.o.c.e.d.u.r.e.+re.s.u.l.t.+pr.o.g.r.a.m.++


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | # CMakeList.txt : CMake project for Pascal-recursive-descent-parser, include source and define
 2 | # project specific logic here.
 3 | #
 4 | cmake_minimum_required (VERSION 3.10)
 5 | 
 6 | set(CMAKE_CXX_STANDARD 17)
 7 | set(CMAKE_CXX_STANDARD_REQUIRED ON)
 8 | 
 9 | project ("Pascal-recursive-descent-parser")
10 | 
11 | include_directories(headers)
12 | 
13 | file(GLOB SOURCES sources/*.cpp)
14 | 
15 | # target_include_directories(headers sources)
16 | 
17 | # set(sources
18 | # file(GLOB SRC main.cpp sources/*.cpp headers/*.hpp)
19 | 
20 | # Add source to this project's executable.
21 | add_executable(Pascal-recursive-descent-parser ${SOURCES})
22 | 
23 | # TODO: Add tests and install targets if needed.
24 | 


--------------------------------------------------------------------------------
/readme.md:
--------------------------------------------------------------------------------
 1 | # Pascal recursive descent parser
 2 | 
 3 | [![CMake](https://github.com/SajjadAemmi/Pascal-recursive-descent-parser/actions/workflows/cmake.yml/badge.svg)](https://github.com/SajjadAemmi/Pascal-recursive-descent-parser/actions/workflows/cmake.yml)
 4 | 
 5 | This program consists of two main phases: 
 6 | - Lexical Analyzer (find tokens)
 7 | - Parser (check syntax and create parse tree)
 8 | 
 9 | We used a recursive descent parser algorithm. This algorithm creates the tree in the Top Down method.
10 | 
11 | ## Run
12 | The desired simple program in Pascal language and a simple regular  expression for pascal are placed in the `IO/input` directory. Just run the following commands:
13 | ```
14 | cmake -S . -B build
15 | cmake --build build
16 | ./build/Pascal-recursive-descent-parser
17 | ```
18 | The outputs will be saved in the `IO/output` directory.
19 | 


--------------------------------------------------------------------------------
/headers/state.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <iostream>
 4 | #include <vector>
 5 | #include <algorithm>
 6 | #include <stack>
 7 | #include <set>
 8 | #include <list>
 9 | #include <string>
10 | #include <sstream>
11 | #include <map>
12 | 
13 | using namespace std;
14 | 
15 | class State
16 | {
17 | public:
18 | 	set<State*> NFAStates;
19 | 
20 | 	typedef vector<State*> Table;
21 | 	typedef set<State*>::iterator StateIterator;
22 | 	multimap<char, State*> transition;
23 | 	int state_id;
24 | 	bool accept;
25 | 	bool Marked;
26 | 	int  GroupID;
27 | 
28 | 	State() : state_id(-1), accept(false) {};
29 | 	State(int nID) : state_id(nID), accept(false), GroupID(0) {};
30 | 	State(std::set<State*> NFAState, int nID);
31 | 	State(const State& other);
32 | 	~State();
33 | 	void addTransition(char inputCh, State* pState);
34 | 	void getTransition(char inputCh, Table& States);
35 | 	State& operator=(const State& other);
36 | 	bool operator==(const State& other);
37 | 	string getStringID();
38 | 	set<State*>& getNFAState();
39 | 
40 | };


--------------------------------------------------------------------------------
/sources/main.cpp:
--------------------------------------------------------------------------------
 1 | /** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **
 2 | *  Pascal recursive descent parser
 3 | *  Copyright (C) 2017 SajjadAemmi ( Telegram: @Sajjad_Aemmi )
 4 | *
 5 | ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** **/
 6 | #include <iostream>
 7 | #include "lex_analyser.hpp"
 8 | #include "parser.hpp"
 9 | 
10 | using namespace std;
11 | 
12 | int main()
13 | {
14 | 	LexAnalyser LA;
15 | 	Parser PA;
16 | 
17 | 	cout << "LexAnalyser" << endl;
18 | 	LA.readInfixREFromFile();
19 | 	LA.preProcessInfixRE();
20 | 	LA.convertInfixREToPostfixRE();
21 | 	LA.writePostfixREToFile();
22 | 	LA.convertPostfixREToNFA();
23 | 	LA.writeNFATableToFile();
24 | 	LA.convertNFAToDFA();
25 | 	LA.readProgramFromFile();
26 | 	LA.scanner();
27 | 	LA.writeTokensToFile();
28 | 
29 | 	cout << "Parser" << endl;
30 | 	PA.tokens = LA.tokens;
31 | 	PA.createTree();
32 | 
33 | 	if (PA.good_program == true)
34 | 	{
35 | 		PA.writeHtmlTreeToFile();
36 | 		PA.printTree(PA.root);
37 | 	}
38 | 
39 | 	return 0;
40 | }
41 | 


--------------------------------------------------------------------------------
/IO/output/tokens.txt:
--------------------------------------------------------------------------------
 1 | program			KEYWORD
 2 | example			IDENTIFIER
 3 | (			SPECIALSYMBOL
 4 | input			IDENTIFIER
 5 | ,			SPECIALSYMBOL
 6 | output			IDENTIFIER
 7 | )			SPECIALSYMBOL
 8 | ;			SPECIALSYMBOL
 9 | var			KEYWORD
10 | x			IDENTIFIER
11 | ,			SPECIALSYMBOL
12 | y			IDENTIFIER
13 | :			SPECIALSYMBOL
14 | integer			KEYWORD
15 | ;			SPECIALSYMBOL
16 | function			KEYWORD
17 | gcd			IDENTIFIER
18 | (			SPECIALSYMBOL
19 | a			IDENTIFIER
20 | ,			SPECIALSYMBOL
21 | b			IDENTIFIER
22 | :			SPECIALSYMBOL
23 | integer			KEYWORD
24 | )			SPECIALSYMBOL
25 | :			SPECIALSYMBOL
26 | result			KEYWORD
27 | integer			KEYWORD
28 | ;			SPECIALSYMBOL
29 | begin			KEYWORD
30 | if			KEYWORD
31 | b			IDENTIFIER
32 | =			RELOP
33 | 0			CONSTANT
34 | then			KEYWORD
35 | gcd			IDENTIFIER
36 | :=			ASSIGNOP
37 | a			IDENTIFIER
38 | else			KEYWORD
39 | gcd			IDENTIFIER
40 | :=			ASSIGNOP
41 | gcd			IDENTIFIER
42 | (			SPECIALSYMBOL
43 | b			IDENTIFIER
44 | ,			SPECIALSYMBOL
45 | a			IDENTIFIER
46 | mod			MULOP
47 | b			IDENTIFIER
48 | )			SPECIALSYMBOL
49 | end			KEYWORD
50 | begin			KEYWORD
51 | READ			IDENTIFIER
52 | (			SPECIALSYMBOL
53 | x			IDENTIFIER
54 | ,			SPECIALSYMBOL
55 | y			IDENTIFIER
56 | )			SPECIALSYMBOL
57 | ;			SPECIALSYMBOL
58 | WRITE			IDENTIFIER
59 | (			SPECIALSYMBOL
60 | gcd			IDENTIFIER
61 | (			SPECIALSYMBOL
62 | x			IDENTIFIER
63 | ,			SPECIALSYMBOL
64 | y			IDENTIFIER
65 | )			SPECIALSYMBOL
66 | )			SPECIALSYMBOL
67 | end			KEYWORD
68 | 


--------------------------------------------------------------------------------
/sources/token.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include "token.hpp"
 3 | 
 4 | using namespace std;
 5 | 
 6 | Token::Token()
 7 | {
 8 | 
 9 | }
10 | 
11 | Token::Token(string value)
12 | {
13 |     this->value = value;
14 |     this->type = typeDetection(this->value);
15 | }
16 | 
17 | string Token::typeDetection(string value)
18 | {
19 | 	if (value == "main" || value == "if" || value == "then" || value == "else" || value == "while" || value == "do" || value == "begin" || value == "end" || value == "var" || value == "integer" || value == "real" || value == "for" || value == "function" || value == "array" || value == "procedure" || value == "result" || value == "program")
20 | 	{
21 | 		return "KEYWORD";
22 | 	}
23 | 	else if (value == "=" || value == "<>" || value == "<=" || value == ">=" || value == ">" || value == "<")
24 | 	{
25 | 		return "RELOP";
26 | 	}
27 | 	else if (value == "+" || value == "-" || value == "or")
28 | 	{
29 | 		return "ADDOP";
30 | 	}
31 | 	else if (value == "*" || value == "/" || value == "div" || value == "mod" || value == "and")
32 | 	{
33 | 		return "MULOP";
34 | 	}
35 | 	else if (value == ":=")
36 | 	{
37 | 		return "ASSIGNOP";
38 | 	}
39 | 	else if (value == "(" || value == ")" || value == "," || value == ":" || value == ";")
40 | 	{
41 | 		return "SPECIALSYMBOL";
42 | 	}
43 | 	else if (value[0] <= '9' && value[0] >= '0')
44 | 	{
45 | 		return "CONSTANT";
46 | 	}
47 | 	else
48 | 	{
49 | 		return "IDENTIFIER";
50 | 	}
51 | }
52 | 


--------------------------------------------------------------------------------
/.github/workflows/cmake.yml:
--------------------------------------------------------------------------------
 1 | name: CMake
 2 | 
 3 | on:
 4 |   push:
 5 |     branches: [ "master" ]
 6 |   pull_request:
 7 |     branches: [ "master" ]
 8 | 
 9 | env:
10 |   # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
11 |   BUILD_TYPE: Release
12 | 
13 | jobs:
14 |   build:
15 |     # The CMake configure and build commands are platform agnostic and should work equally well on Windows or Mac.
16 |     # You can convert this to a matrix build if you need cross-platform coverage.
17 |     # See: https://docs.github.com/en/free-pro-team@latest/actions/learn-github-actions/managing-complex-workflows#using-a-build-matrix
18 |     runs-on: ubuntu-latest
19 | 
20 |     steps:
21 |     - uses: actions/checkout@v3
22 | 
23 |     - name: Configure CMake
24 |       # Configure CMake in a 'build' subdirectory. `CMAKE_BUILD_TYPE` is only required if you are using a single-configuration generator such as make.
25 |       # See https://cmake.org/cmake/help/latest/variable/CMAKE_BUILD_TYPE.html?highlight=cmake_build_type
26 |       run: cmake -B ${{github.workspace}}/build -DCMAKE_BUILD_TYPE=${{env.BUILD_TYPE}}
27 | 
28 |     - name: Build
29 |       # Build your program with the given configuration
30 |       run: cmake --build ${{github.workspace}}/build --config ${{env.BUILD_TYPE}}
31 | 
32 |     - name: Test
33 |       working-directory: ${{github.workspace}}/build
34 |       # Execute tests defined by the CMake configuration.
35 |       # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
36 |       run: ctest -C ${{env.BUILD_TYPE}}
37 | 
38 | 


--------------------------------------------------------------------------------
/headers/lex_analyser.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once
 2 | 
 3 | #include <iostream>
 4 | #include <fstream>
 5 | #include <vector>
 6 | #include <algorithm>
 7 | #include <stack>
 8 | #include <set>
 9 | #include <list>
10 | #include <string>
11 | #include <sstream>
12 | #include <map>
13 | #include "token.hpp"
14 | #include "state.hpp"
15 | 
16 | using namespace std;
17 | 
18 | typedef vector<State*> Table;
19 | typedef Table::reverse_iterator TableReverseIterator;
20 | typedef Table::iterator TableIterator;
21 | typedef set<State*>::iterator StateIterator;
22 | 
23 | class LexAnalyser
24 | {
25 | public:
26 | 
27 | 	stack<Table>		thompson_stack;
28 | 	set<char>           input_set;
29 | 	string              postfix_re;
30 | 	char                CurPreProcChar;
31 | 	int                 next_state_id;
32 | 	vector<string>		regular_expressions;
33 | 	string				infix_re;
34 | 	string				buffer;
35 | 	vector<Token> 		tokens;
36 | 
37 | 	void readInfixREFromFile();
38 | 	void preProcessInfixRE();
39 | 	string removeBracket(string);
40 | 	void convertInfixREToPostfixRE();
41 | 	bool takesPrecedence(char, char);
42 | 	void writePostfixREToFile();
43 | 	bool convertPostfixREToNFA();
44 | 	bool match(string);
45 | 	void createOneCharNFA(char);
46 | 	bool popTable(Table& NFATable);
47 | 
48 | 	bool concat();
49 | 	bool closure();
50 | 	bool or();
51 | 
52 | 	bool isOperator(char inputCh);
53 | 	void epsilonClosure(set<State*> startSet, set<State*>& result);
54 | 	void move(char chInput, set<State*> NFAState, set<State*>& Result);
55 | 	void convertNFAToDFA();
56 | 	void writeNFATableToFile();
57 | 	void readProgramFromFile();
58 | 	void scanner();
59 | 	void writeTokensToFile();
60 | };
61 | 


--------------------------------------------------------------------------------
/sources/state.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <set>
 3 | #include "state.hpp"
 4 | 
 5 | using namespace std;
 6 | 
 7 | State::State(std::set<State*> NFAState, int nID)
 8 | {
 9 |     NFAStates = NFAState;
10 |     state_id = nID;
11 |     accept = false;
12 |     GroupID = 0;
13 |     StateIterator iter;
14 |     for (iter = NFAState.begin(); iter != NFAState.end(); ++iter)
15 |     {
16 |         if ((*iter)->accept)
17 |         {
18 |             accept = true;
19 |         }
20 |     }
21 | }
22 | State::State(const State& other)
23 | {
24 |     *this = other;
25 | }
26 | 
27 | State::~State()
28 | {
29 |     NFAStates.clear();
30 |     transition.clear();
31 | }
32 | 
33 | void State::addTransition(char inputCh, State* pState)
34 | {
35 |     transition.insert(std::make_pair(inputCh, pState));
36 | }
37 | 
38 | void State::getTransition(char inputCh, Table& States)
39 | {
40 |     States.clear();
41 |     multimap<char, State*>::iterator iter;
42 |     for (iter = transition.lower_bound(inputCh); iter != transition.upper_bound(inputCh); ++iter)
43 |     {
44 |         State* pState = iter->second;
45 |         States.push_back(pState);
46 |     }
47 | }
48 | 
49 | State& State::operator=(const State& other)
50 | {
51 |     this->transition = other.transition;
52 |     this->state_id = other.state_id;
53 |     this->NFAStates = other.NFAStates;
54 |     return *this;
55 | }
56 | 
57 | bool State::operator==(const State& other)
58 | {
59 |     if (NFAStates.empty())
60 |         return(state_id == other.state_id);
61 |     else
62 |         return(NFAStates == other.NFAStates);
63 | }
64 | 
65 | string State::getStringID()
66 | {
67 |     stringstream out;
68 |     out << state_id;
69 |     return out.str();
70 | }
71 | 
72 | set<State*>& State::getNFAState()
73 | {
74 |     return NFAStates;
75 | }
76 | 


--------------------------------------------------------------------------------
/headers/parser.hpp:
--------------------------------------------------------------------------------
 1 | #pragma once 
 2 | 
 3 | #include <iostream>
 4 | #include <fstream>
 5 | #include <vector>
 6 | #include <algorithm>
 7 | #include <stack>
 8 | #include <set>
 9 | #include <list>
10 | #include <string>
11 | #include <sstream>
12 | #include <map>
13 | #include "token.hpp"
14 | #include "state.hpp"
15 | #include "tree_node.hpp"
16 | 
17 | using namespace std;
18 | 
19 | class Parser
20 | {
21 | public:
22 | 	TreeNode* 			root;
23 | 	int 				token_index;
24 | 	Token 				token;
25 | 	bool 				good_program;
26 | 	string 				html_tree;
27 | 	bool 				see_epsilon;
28 | 	vector<Token> 		tokens;
29 | 
30 | 	Parser();
31 | 
32 | 	TreeNode* program();
33 | 	TreeNode* identifier_list();
34 | 	TreeNode* identifier_list_prime();
35 | 	TreeNode* declarations();
36 | 	TreeNode* declaration_list();
37 | 	TreeNode* declaration_list_prime();
38 | 	TreeNode* type();
39 | 	TreeNode* standard_type();
40 | 	TreeNode* array_type();
41 | 	TreeNode* argumenrs();
42 | 	TreeNode* parameter_list();
43 | 	TreeNode* parameter_list_prime();
44 | 	TreeNode* statement_list();
45 | 	TreeNode* statement_list_prime();
46 | 	TreeNode* statement();
47 | 	TreeNode* statement_prime();
48 | 	TreeNode* restricted_statement();
49 | 	TreeNode* elementary_statement();
50 | 	TreeNode* elementary_statement_prime();
51 | 	TreeNode* variable();
52 | 	TreeNode* variable_prime();
53 | 	TreeNode* subprogram_declarations();
54 | 	TreeNode* subprogram_declarations_prime();
55 | 	TreeNode* subprogram_declaration();
56 | 	TreeNode* subprogram_head();
57 | 	TreeNode* compound_statement();
58 | 	TreeNode* expression();
59 | 	TreeNode* expression_prime();
60 | 	TreeNode* expression_list();
61 | 	TreeNode* expression_list_prime();
62 | 	TreeNode* simple_expression();
63 | 	TreeNode* simple_expression_prime();
64 | 	TreeNode* term();
65 | 	TreeNode* term_prime();
66 | 	TreeNode* factor();
67 | 
68 | 	void Error();
69 | 	Token nextToken();
70 | 	void createTree();
71 | 
72 | 	void writeHtmlTreeToFile();
73 | 	void createHtmlTree(TreeNode*);
74 | 	void printTree(TreeNode*);
75 | };
76 | 


--------------------------------------------------------------------------------
/sources/lex_analyser.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <fstream>
  3 | #include <vector>
  4 | #include <algorithm>
  5 | #include <stack>
  6 | #include <set>
  7 | #include <list>
  8 | #include <string>
  9 | #include <map>
 10 | #include "token.hpp"
 11 | #include "state.hpp"
 12 | #include "lex_analyser.hpp"
 13 | 
 14 | using namespace std;
 15 | 
 16 | #define EPSILON			-1
 17 | #define CLOSURE			'*'
 18 | #define OPEN_PAREN		'('
 19 | #define CLOSE_PAREN		')'
 20 | #define OR				'+'
 21 | #define CONCAT			'.'
 22 | 
 23 | typedef vector<State*> Table;
 24 | typedef Table::reverse_iterator TableReverseIterator;
 25 | typedef Table::iterator TableIterator;
 26 | typedef set<State*>::iterator StateIterator;
 27 | 
 28 | Table NFATable;
 29 | Table DFATable;
 30 | 
 31 | bool LexAnalyser::match(string S)
 32 | {
 33 | 	State* pState = DFATable[0];
 34 | 	vector<State*>  Transition;
 35 | 	for (int i = 0; i < S.size(); i++)
 36 | 	{
 37 | 		char CurrChar = S[i];
 38 | 		pState->getTransition(CurrChar, Transition);
 39 | 		if (Transition.empty())
 40 | 			return false;
 41 | 		pState = Transition[0];
 42 | 	}
 43 | 	if (pState->accept)
 44 | 		return true;
 45 | 
 46 | 	return false;
 47 | }
 48 | 
 49 | bool LexAnalyser::convertPostfixREToNFA()
 50 | {
 51 | 	//Thompson NFA
 52 | 
 53 | 	for (int i = 0; i < (int)postfix_re.size(); i++)
 54 | 	{
 55 | 		char Ch = postfix_re[i];
 56 | 
 57 | 		if (!isOperator(Ch))
 58 | 		{
 59 | 			if (Ch == '~')
 60 | 			{
 61 | 				i++;
 62 | 				Ch = postfix_re[i];
 63 | 			}
 64 | 			createOneCharNFA(Ch);
 65 | 		}
 66 | 		else if (isOperator(Ch))
 67 | 		{
 68 | 			if (Ch == '.')
 69 | 				concat();
 70 | 			else if (Ch == '*')
 71 | 				closure();
 72 | 			else if (Ch == '+')
 73 | 				or();
 74 | 		}
 75 | 	}
 76 | 	popTable(NFATable);
 77 | 	NFATable[NFATable.size() - 1]->accept = true;
 78 | 	return true;
 79 | }
 80 | 
 81 | void LexAnalyser::createOneCharNFA(char ch)
 82 | {
 83 | 	State* s0 = new State(next_state_id++);
 84 | 	State* s1 = new State(next_state_id++);
 85 | 
 86 | 	s0->addTransition(ch, s1);
 87 | 
 88 | 	Table NewSubTable;
 89 | 	NewSubTable.push_back(s0);
 90 | 	NewSubTable.push_back(s1);
 91 | 	thompson_stack.push(NewSubTable);
 92 | 
 93 | 	input_set.insert(ch);
 94 | }
 95 | 
 96 | bool LexAnalyser::popTable(Table& NFATable)
 97 | {
 98 | 	if (thompson_stack.size() > 0)
 99 | 	{
100 | 		NFATable = thompson_stack.top();
101 | 		thompson_stack.pop();
102 | 		return true;
103 | 	}
104 | 	return false;
105 | }
106 | 
107 | bool LexAnalyser::concat()
108 | {
109 | 	Table LeftTable, RightTable;
110 | 
111 | 	if (!popTable(RightTable) || !popTable(LeftTable))
112 | 		return false;
113 | 
114 | 	(*(LeftTable.rbegin()))->addTransition(EPSILON, *(RightTable.begin()));
115 | 	LeftTable.insert(LeftTable.end(), RightTable.begin(), RightTable.end());
116 | 	thompson_stack.push(LeftTable);
117 | 
118 | 	return true;
119 | }
120 | 
121 | bool LexAnalyser::closure()
122 | {
123 | 	Table PrevTable;
124 | 
125 | 	if (!popTable(PrevTable))
126 | 		return false;
127 | 
128 | 	State* LeftTable = new State(next_state_id++);
129 | 	State* RightTable = new State(next_state_id++);
130 | 
131 | 	LeftTable->addTransition(EPSILON, RightTable);
132 | 	LeftTable->addTransition(EPSILON, *(PrevTable.begin()));
133 | 	(*(PrevTable.rbegin()))->addTransition(EPSILON, RightTable);
134 | 	(*(PrevTable.rbegin()))->addTransition(EPSILON, *(PrevTable.begin()));
135 | 
136 | 	PrevTable.insert(PrevTable.begin(), LeftTable);
137 | 	PrevTable.push_back(RightTable);
138 | 
139 | 	thompson_stack.push(PrevTable);
140 | 
141 | 	return true;
142 | }
143 | 
144 | bool LexAnalyser::or()
145 | {
146 | 	Table  UpperTable, LowerTable;
147 | 
148 | 	if (!popTable(LowerTable) || !popTable(UpperTable))
149 | 		return false;
150 | 
151 | 	State* LeftTable = new State(next_state_id++);
152 | 	State* RightTable = new State(next_state_id++);
153 | 
154 | 	LeftTable->addTransition(EPSILON, *(UpperTable.begin()));
155 | 	LeftTable->addTransition(EPSILON, *(LowerTable.begin()));
156 | 	(*(UpperTable.rbegin()))->addTransition(EPSILON, RightTable);
157 | 	(*(LowerTable.rbegin()))->addTransition(EPSILON, RightTable);
158 | 
159 | 	LowerTable.push_back(RightTable);
160 | 	UpperTable.insert(UpperTable.begin(), LeftTable);
161 | 	UpperTable.insert(UpperTable.end(), LowerTable.begin(), LowerTable.end());
162 | 
163 | 	thompson_stack.push(UpperTable);
164 | 	return true;
165 | }
166 | 
167 | bool LexAnalyser::isOperator(char Ch)
168 | {
169 | 	if (Ch == CLOSURE || Ch == OR || Ch == OPEN_PAREN || Ch == CLOSE_PAREN || Ch == CONCAT)
170 | 	{
171 | 		return true;
172 | 	}
173 | 	else
174 | 	{
175 | 		return false;
176 | 	}
177 | }
178 | 
179 | void LexAnalyser::epsilonClosure(set<State*> startSet, set<State*>& result)
180 | {
181 | 	stack<State*> UnVisitedStates;
182 | 	result = startSet;
183 | 	StateIterator iter;
184 | 	for (iter = startSet.begin(); iter != startSet.end(); ++iter)
185 | 	{
186 | 		UnVisitedStates.push(*iter);
187 | 	}
188 | 
189 | 	while (!UnVisitedStates.empty())
190 | 	{
191 | 		State* curState = UnVisitedStates.top();
192 | 		UnVisitedStates.pop();
193 | 
194 | 		Table epsilonStates;
195 | 		curState->getTransition(EPSILON, epsilonStates);
196 | 
197 | 		TableIterator epsilonItr;
198 | 
199 | 		for (epsilonItr = epsilonStates.begin(); epsilonItr != epsilonStates.end(); ++epsilonItr)
200 | 		{
201 | 			if (result.find(*epsilonItr) == result.end())
202 | 			{
203 | 				result.insert(*epsilonItr);
204 | 				UnVisitedStates.push(*epsilonItr);
205 | 			}
206 | 		}
207 | 	}
208 | }
209 | 
210 | void LexAnalyser::move(char chInput, set<State*> NFAState, set<State*>& Result)
211 | {
212 | 	Result.clear();
213 | 	StateIterator iter;
214 | 	for (iter = NFAState.begin(); iter != NFAState.end(); ++iter)
215 | 	{
216 | 		Table States;
217 | 		(*iter)->getTransition(chInput, States);
218 | 		for (int index = 0; index < (int)States.size(); ++index)
219 | 		{
220 | 			Result.insert(States[index]);
221 | 		}
222 | 	}
223 | }
224 | 
225 | void LexAnalyser::convertNFAToDFA()
226 | {
227 | 	set<State*> NFAStartStateSet;
228 | 	NFAStartStateSet.insert(NFATable[0]);
229 | 
230 | 	set<State*> DFAStartStateSet;
231 | 	epsilonClosure(NFAStartStateSet, DFAStartStateSet);
232 | 
233 | 	next_state_id = 0;
234 | 	State* DFAStartState = new State(DFAStartStateSet, next_state_id++);
235 | 
236 | 	DFATable.push_back(DFAStartState);
237 | 
238 | 	Table UnVisitedStates;
239 | 	UnVisitedStates.push_back(DFAStartState);
240 | 	while (!UnVisitedStates.empty()) {
241 | 
242 | 		State* CurDFAState = UnVisitedStates[UnVisitedStates.size() - 1];
243 | 		UnVisitedStates.pop_back();
244 | 
245 | 		std::set<char>::iterator iter;
246 | 		for (iter = input_set.begin(); iter != input_set.end(); ++iter) {
247 | 			std::set<State*> moveRes, epsilonClosureRes;
248 | 
249 | 			move(*iter, CurDFAState->getNFAState(), moveRes);
250 | 			epsilonClosure(moveRes, epsilonClosureRes);
251 | 
252 | 			StateIterator moveResItr;
253 | 			StateIterator epsilonClosureResItr;
254 | 
255 | 			bool bFound = false;
256 | 			State* s = NULL;
257 | 			for (int i = 0; i < (int)DFATable.size(); ++i) {
258 | 				s = DFATable[i];
259 | 				if (s->getNFAState() == epsilonClosureRes) {
260 | 					bFound = true;
261 | 					break;
262 | 				}
263 | 			}
264 | 			if (!bFound) {
265 | 				State* U = new State(epsilonClosureRes, next_state_id++);
266 | 				UnVisitedStates.push_back(U);
267 | 				DFATable.push_back(U);
268 | 				CurDFAState->addTransition(*iter, U);
269 | 			}
270 | 			else {
271 | 				CurDFAState->addTransition(*iter, s);
272 | 			}
273 | 		}
274 | 	}
275 | }
276 | 
277 | void LexAnalyser::convertInfixREToPostfixRE()
278 | {
279 | 	stack<char> OperatorStack;
280 | 	char TopSymbol, Symbol;
281 | 	int k;
282 | 
283 | 	for (k = 0; k < infix_re.size(); k++)
284 | 	{
285 | 		Symbol = infix_re[k];
286 | 
287 | 		if (Symbol == '~')
288 | 		{
289 | 			postfix_re = postfix_re + Symbol;
290 | 			k++;
291 | 			Symbol = infix_re[k];
292 | 			postfix_re = postfix_re + Symbol;
293 | 		}
294 | 		else if (Symbol == '(')
295 | 		{
296 | 			OperatorStack.push(Symbol);
297 | 		}
298 | 		else if (Symbol == ')')
299 | 		{
300 | 			while (OperatorStack.top() != '(')
301 | 			{
302 | 				TopSymbol = OperatorStack.top();
303 | 				OperatorStack.pop();
304 | 				postfix_re = postfix_re + TopSymbol;
305 | 			}
306 | 			OperatorStack.pop();
307 | 		}
308 | 		else if (isOperator(Symbol))
309 | 		{
310 | 			if (OperatorStack.empty() || (!(OperatorStack.empty()) && takesPrecedence(OperatorStack.top(), Symbol)))
311 | 			{
312 | 				OperatorStack.push(Symbol);
313 | 			}
314 | 			else
315 | 			{
316 | 				while (!(OperatorStack.empty()) && !takesPrecedence(OperatorStack.top(), Symbol))
317 | 				{
318 | 					TopSymbol = OperatorStack.top();
319 | 					OperatorStack.pop();
320 | 					postfix_re = postfix_re + TopSymbol;
321 | 				}
322 | 				OperatorStack.push(Symbol);
323 | 			}
324 | 		}
325 | 		else
326 | 		{
327 | 			postfix_re = postfix_re + Symbol;
328 | 		}
329 | 	}
330 | 	while (!OperatorStack.empty())
331 | 	{
332 | 		TopSymbol = OperatorStack.top();
333 | 		OperatorStack.pop();
334 | 		postfix_re = postfix_re + TopSymbol;
335 | 	}
336 | 	postfix_re += "\0";
337 | }
338 | 
339 | void LexAnalyser::writePostfixREToFile()
340 | {
341 | 	fstream f;
342 | 	f.open("IO/output/postfix_regular_expression.txt", ios::out);
343 | 	f << postfix_re;
344 | 	f.close();
345 | }
346 | 
347 | string LexAnalyser::removeBracket(string s)
348 | {
349 | 	string::size_type startPos, endPos, separatorPos;
350 | 	string ReplacedStr;
351 | 
352 | 	startPos = s.find_first_of("[");
353 | 	endPos = s.find_first_of("]");
354 | 	separatorPos = s.find_first_of("-");
355 | 
356 | 	if (startPos == string::npos || endPos == string::npos)
357 | 		return s;
358 | 
359 | 	ReplacedStr += s.substr(0, startPos);
360 | 	ReplacedStr.push_back('(');
361 | 	string result = s.substr(startPos + 1, endPos - startPos - 1);
362 | 	char first = result[0];
363 | 	char last = result[result.size() - 1];
364 | 
365 | 	if (separatorPos != string::npos)
366 | 	{
367 | 		while (first < last)
368 | 		{
369 | 			ReplacedStr.push_back(first);
370 | 			ReplacedStr += "+";
371 | 			first++;
372 | 		}
373 | 		ReplacedStr.push_back(first);
374 | 	}
375 | 	else
376 | 	{
377 | 		startPos++;
378 | 		while (startPos != endPos - 1)
379 | 		{
380 | 			ReplacedStr.push_back(s[startPos]);
381 | 			ReplacedStr += "+";
382 | 			startPos++;
383 | 		}
384 | 		ReplacedStr.push_back(s[endPos - 1]);
385 | 	}
386 | 	ReplacedStr.push_back(')');
387 | 	ReplacedStr += s.substr(endPos + 1, s.size() - endPos);
388 | 
389 | 
390 | 	return ReplacedStr;
391 | }
392 | 
393 | void LexAnalyser::readInfixREFromFile()
394 | {
395 | 	fstream file;
396 | 	string temp;
397 | 	file.open("IO/input/regular_expression.txt", ios::in);
398 | 
399 | 	if (!file)
400 | 	{
401 | 		cout << "no file available\n";
402 | 		exit(1);
403 | 	}
404 | 
405 | 	while (!file.eof())
406 | 	{
407 | 		file >> temp;
408 | 		this->regular_expressions.push_back(temp);
409 | 	}
410 | }
411 | 
412 | void LexAnalyser::preProcessInfixRE()
413 | {
414 | 	int i;
415 | 	for (i = 0; i < regular_expressions.size() - 1; i++)
416 | 	{
417 | 		infix_re += "(" + regular_expressions[i] + ")" + "+";
418 | 	}
419 | 	infix_re += "(" + regular_expressions[i] + ")";
420 | 
421 | 	while (infix_re.find("[") != string::npos)
422 | 	{
423 | 		infix_re = removeBracket(infix_re);
424 | 	}
425 | }
426 | 
427 | void LexAnalyser::writeNFATableToFile()
428 | {
429 | 	fstream f;
430 | 
431 | 	f.open("IO/output/NFA.dat", ios::out);
432 | 
433 | 	if (!f)
434 | 	{
435 | 		cout << "no file available\n";
436 | 		system("pause");
437 | 		exit(0);
438 | 	}
439 | 	for (int i = 0; i < (int)NFATable.size(); ++i)
440 | 	{
441 | 		State* pState = NFATable[i];
442 | 		if (pState->accept)
443 | 		{
444 | 			f << pState->getStringID() << "\n";
445 | 		}
446 | 	}
447 | 	for (int i = 0; i < (int)NFATable.size(); ++i)
448 | 	{
449 | 		State* pState = NFATable[i];
450 | 		vector<State*> State;
451 | 		pState->getTransition(EPSILON, State);
452 | 		for (int j = 0; j < (int)State.size(); ++j)
453 | 		{
454 | 			f << pState->getStringID() << "  " << State[j]->getStringID() << "  epsilon\n";
455 | 		}
456 | 		set<char>::iterator iter;
457 | 		for (iter = input_set.begin(); iter != input_set.end(); ++iter)
458 | 		{
459 | 			pState->getTransition(*iter, State);
460 | 			for (int j = 0; j < (int)State.size(); ++j)
461 | 			{
462 | 				f << pState->getStringID() + "  " << State[j]->getStringID();
463 | 				stringstream out;
464 | 				out << *iter;
465 | 				f << "  " << out.str() << "\n";
466 | 			}
467 | 		}
468 | 	}
469 | 	f.close();
470 | }
471 | 
472 | void LexAnalyser::readProgramFromFile()
473 | {
474 | 	fstream file;
475 | 	string temp;
476 | 
477 | 	file.open("IO/input/program.pas", ios::in);
478 | 
479 | 	if (!file)
480 | 	{
481 | 		cout << "no file available\n";
482 | 		exit(1);
483 | 	}
484 | 
485 | 	std::stringstream buffer_stringstream;
486 | 	buffer_stringstream << file.rdbuf();
487 | 	this->buffer = buffer_stringstream.str();
488 | }
489 | 
490 | void LexAnalyser::scanner()
491 | {
492 | 	int first = 0;
493 | 	int follow = 0;
494 | 	int save = 0;
495 | 
496 | 	while (first < this->buffer.size() - 1)
497 | 	{
498 | 		follow = first;
499 | 		while (follow < buffer.size())
500 | 		{
501 | 			if (match(buffer.substr(first, follow - first + 1)))
502 | 				save = follow;
503 | 
504 | 			follow++;
505 | 		}
506 | 		follow = save;
507 | 
508 | 		string substring = buffer.substr(first, follow - first + 1);
509 | 		Token token(substring);
510 | 		tokens.push_back(token);
511 | 
512 | 		first = follow + 1;
513 | 
514 | 		while ((buffer[first] == ' ' || buffer[first] == '\n' || buffer[first] == '\t') && buffer[first] != '\0')
515 | 			first++;
516 | 	}
517 | }
518 | 
519 | bool LexAnalyser::takesPrecedence(char topStack, char ch)
520 | {
521 | 	if (topStack == '(')
522 | 	{
523 | 		return true;
524 | 	}
525 | 	char operators[6] = { '+', '.', '*', '(' };
526 | 
527 | 	int i, j;
528 | 	for (i = 0; i < strlen(operators); i++)
529 | 	{
530 | 		if (operators[i] == topStack)
531 | 			break;
532 | 	}
533 | 	for (j = 0; j < strlen(operators); j++)
534 | 	{
535 | 		if (operators[j] == ch)
536 | 			break;
537 | 	}
538 | 
539 | 	if (i >= j)
540 | 		return false;
541 | 	else
542 | 		return true;
543 | 
544 | 	// true
545 | 	// اولويت کاراکتر ورودي بيشتر است
546 | 
547 | 	// false
548 | 	// اولويت کاراکتر بالاي پشته بيشتر است
549 | }
550 | 
551 | void LexAnalyser::writeTokensToFile()
552 | {
553 | 	fstream f;
554 | 	f.open("IO/output/tokens.txt", ios::out);
555 | 	for (int i = 0; i < tokens.size(); i++)
556 | 	{
557 | 		f << tokens[i].value << "\t\t\t" << tokens[i].type << "\n";
558 | 	}
559 | 	f.close();
560 | }


--------------------------------------------------------------------------------
/IO/output/tree.html:
--------------------------------------------------------------------------------
1 | <html><head></head><body><table border="1px"><tr><td colspan="100%">program</td></tr><tr><td><table border="1px"><tr><td colspan="100%">program</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">example</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">(</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">identifier_list</td></tr><tr><td><table border="1px"><tr><td colspan="100%">input</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">identifier_list_prime</td></tr><tr><td><table border="1px"><tr><td colspan="100%">,</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">output</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">)</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">;</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">declarations</td></tr><tr><td><table border="1px"><tr><td colspan="100%">var</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">declaration_list</td></tr><tr><td><table border="1px"><tr><td colspan="100%">identifier_list</td></tr><tr><td><table border="1px"><tr><td colspan="100%">x</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">identifier_list_prime</td></tr><tr><td><table border="1px"><tr><td colspan="100%">,</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">y</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">:</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">type</td></tr><tr><td><table border="1px"><tr><td colspan="100%">standard_type</td></tr><tr><td><table border="1px"><tr><td colspan="100%">integer</td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">;</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">subprogram_declarations</td></tr><tr><td><table border="1px"><tr><td colspan="100%">subprogram_declaration</td></tr><tr><td><table border="1px"><tr><td colspan="100%">subprogram_head</td></tr><tr><td><table border="1px"><tr><td colspan="100%">function</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">gcd</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">argumenrs</td></tr><tr><td><table border="1px"><tr><td colspan="100%">(</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">parameter_list</td></tr><tr><td><table border="1px"><tr><td colspan="100%">identifier_list</td></tr><tr><td><table border="1px"><tr><td colspan="100%">a</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">identifier_list_prime</td></tr><tr><td><table border="1px"><tr><td colspan="100%">,</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">b</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">:</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">type</td></tr><tr><td><table border="1px"><tr><td colspan="100%">standard_type</td></tr><tr><td><table border="1px"><tr><td colspan="100%">integer</td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">)</td></tr><tr></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">:</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">result</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">standard_type</td></tr><tr><td><table border="1px"><tr><td colspan="100%">integer</td></tr><tr></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">;</td></tr><tr></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">compound_statement</td></tr><tr><td><table border="1px"><tr><td colspan="100%">begin</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">statement_list</td></tr><tr><td><table border="1px"><tr><td colspan="100%">statement</td></tr><tr><td><table border="1px"><tr><td colspan="100%">if</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">expression</td></tr><tr><td><table border="1px"><tr><td colspan="100%">simple_expression</td></tr><tr><td><table border="1px"><tr><td colspan="100%">term</td></tr><tr><td><table border="1px"><tr><td colspan="100%">factor</td></tr><tr><td><table border="1px"><tr><td colspan="100%">variable</td></tr><tr><td><table border="1px"><tr><td colspan="100%">b</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">expression_prime</td></tr><tr><td><table border="1px"><tr><td colspan="100%">=</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">simple_expression</td></tr><tr><td><table border="1px"><tr><td colspan="100%">term</td></tr><tr><td><table border="1px"><tr><td colspan="100%">factor</td></tr><tr><td><table border="1px"><tr><td colspan="100%">0</td></tr><tr></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">then</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">statement_prime</td></tr><tr><td><table border="1px"><tr><td colspan="100%">restricted_statement</td></tr><tr><td><table border="1px"><tr><td colspan="100%">elementary_statement</td></tr><tr><td><table border="1px"><tr><td colspan="100%">variable</td></tr><tr><td><table border="1px"><tr><td colspan="100%">gcd</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">elementary_statement_prime</td></tr><tr><td><table border="1px"><tr><td colspan="100%">:=</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">expression</td></tr><tr><td><table border="1px"><tr><td colspan="100%">simple_expression</td></tr><tr><td><table border="1px"><tr><td colspan="100%">term</td></tr><tr><td><table border="1px"><tr><td colspan="100%">factor</td></tr><tr><td><table border="1px"><tr><td colspan="100%">variable</td></tr><tr><td><table border="1px"><tr><td colspan="100%">a</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">else</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">statement</td></tr><tr><td><table border="1px"><tr><td colspan="100%">elementary_statement</td></tr><tr><td><table border="1px"><tr><td colspan="100%">variable</td></tr><tr><td><table border="1px"><tr><td colspan="100%">gcd</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">elementary_statement_prime</td></tr><tr><td><table border="1px"><tr><td colspan="100%">:=</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">expression</td></tr><tr><td><table border="1px"><tr><td colspan="100%">simple_expression</td></tr><tr><td><table border="1px"><tr><td colspan="100%">term</td></tr><tr><td><table border="1px"><tr><td colspan="100%">factor</td></tr><tr><td><table border="1px"><tr><td colspan="100%">variable</td></tr><tr><td><table border="1px"><tr><td colspan="100%">gcd</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">variable_prime</td></tr><tr><td><table border="1px"><tr><td colspan="100%">(</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">expression_list</td></tr><tr><td><table border="1px"><tr><td colspan="100%">expression</td></tr><tr><td><table border="1px"><tr><td colspan="100%">simple_expression</td></tr><tr><td><table border="1px"><tr><td colspan="100%">term</td></tr><tr><td><table border="1px"><tr><td colspan="100%">factor</td></tr><tr><td><table border="1px"><tr><td colspan="100%">variable</td></tr><tr><td><table border="1px"><tr><td colspan="100%">b</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">expression_list_prime</td></tr><tr><td><table border="1px"><tr><td colspan="100%">,</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">expression</td></tr><tr><td><table border="1px"><tr><td colspan="100%">simple_expression</td></tr><tr><td><table border="1px"><tr><td colspan="100%">term</td></tr><tr><td><table border="1px"><tr><td colspan="100%">factor</td></tr><tr><td><table border="1px"><tr><td colspan="100%">variable</td></tr><tr><td><table border="1px"><tr><td colspan="100%">a</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">term_prime</td></tr><tr><td><table border="1px"><tr><td colspan="100%">mod</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">factor</td></tr><tr><td><table border="1px"><tr><td colspan="100%">variable</td></tr><tr><td><table border="1px"><tr><td colspan="100%">b</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">)</td></tr><tr></tr></table></td></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td></tr></table></td></tr></table></td></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">end</td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">compound_statement</td></tr><tr><td><table border="1px"><tr><td colspan="100%">begin</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">statement_list</td></tr><tr><td><table border="1px"><tr><td colspan="100%">statement</td></tr><tr><td><table border="1px"><tr><td colspan="100%">elementary_statement</td></tr><tr><td><table border="1px"><tr><td colspan="100%">variable</td></tr><tr><td><table border="1px"><tr><td colspan="100%">READ</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">variable_prime</td></tr><tr><td><table border="1px"><tr><td colspan="100%">(</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">expression_list</td></tr><tr><td><table border="1px"><tr><td colspan="100%">expression</td></tr><tr><td><table border="1px"><tr><td colspan="100%">simple_expression</td></tr><tr><td><table border="1px"><tr><td colspan="100%">term</td></tr><tr><td><table border="1px"><tr><td colspan="100%">factor</td></tr><tr><td><table border="1px"><tr><td colspan="100%">variable</td></tr><tr><td><table border="1px"><tr><td colspan="100%">x</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">expression_list_prime</td></tr><tr><td><table border="1px"><tr><td colspan="100%">,</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">expression</td></tr><tr><td><table border="1px"><tr><td colspan="100%">simple_expression</td></tr><tr><td><table border="1px"><tr><td colspan="100%">term</td></tr><tr><td><table border="1px"><tr><td colspan="100%">factor</td></tr><tr><td><table border="1px"><tr><td colspan="100%">variable</td></tr><tr><td><table border="1px"><tr><td colspan="100%">y</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">)</td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">elementary_statement_prime</td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">statement_list_prime</td></tr><tr><td><table border="1px"><tr><td colspan="100%">;</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">statement</td></tr><tr><td><table border="1px"><tr><td colspan="100%">elementary_statement</td></tr><tr><td><table border="1px"><tr><td colspan="100%">variable</td></tr><tr><td><table border="1px"><tr><td colspan="100%">WRITE</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">variable_prime</td></tr><tr><td><table border="1px"><tr><td colspan="100%">(</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">expression_list</td></tr><tr><td><table border="1px"><tr><td colspan="100%">expression</td></tr><tr><td><table border="1px"><tr><td colspan="100%">simple_expression</td></tr><tr><td><table border="1px"><tr><td colspan="100%">term</td></tr><tr><td><table border="1px"><tr><td colspan="100%">factor</td></tr><tr><td><table border="1px"><tr><td colspan="100%">variable</td></tr><tr><td><table border="1px"><tr><td colspan="100%">gcd</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">variable_prime</td></tr><tr><td><table border="1px"><tr><td colspan="100%">(</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">expression_list</td></tr><tr><td><table border="1px"><tr><td colspan="100%">expression</td></tr><tr><td><table border="1px"><tr><td colspan="100%">simple_expression</td></tr><tr><td><table border="1px"><tr><td colspan="100%">term</td></tr><tr><td><table border="1px"><tr><td colspan="100%">factor</td></tr><tr><td><table border="1px"><tr><td colspan="100%">variable</td></tr><tr><td><table border="1px"><tr><td colspan="100%">x</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">expression_list_prime</td></tr><tr><td><table border="1px"><tr><td colspan="100%">,</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%">expression</td></tr><tr><td><table border="1px"><tr><td colspan="100%">simple_expression</td></tr><tr><td><table border="1px"><tr><td colspan="100%">term</td></tr><tr><td><table border="1px"><tr><td colspan="100%">factor</td></tr><tr><td><table border="1px"><tr><td colspan="100%">variable</td></tr><tr><td><table border="1px"><tr><td colspan="100%">y</td></tr><tr></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">)</td></tr><tr></tr></table></td></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%"></td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">)</td></tr><tr></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">elementary_statement_prime</td></tr><tr><td><table border="1px"><tr><td colspan="100%"></td></tr><tr></tr></table></td></tr></table></td></tr></table></td></tr></table></td></tr></table></td></tr></table></td><td><table border="1px"><tr><td colspan="100%">end</td></tr><tr></tr></table></td></tr></table></td></tr></table></body></html>


--------------------------------------------------------------------------------
/IO/output/NFA.dat:
--------------------------------------------------------------------------------
   1 | -858992625
   2 | -858992626  -858992822  epsilon
   3 | -858992626  -858992628  epsilon
   4 | -858992822  -858993286  epsilon
   5 | -858992822  -858993076  epsilon
   6 | -858993286  -858993366  epsilon
   7 | -858993286  -858993328  epsilon
   8 | -858993366  -858993374  epsilon
   9 | -858993366  -858993372  epsilon
  10 | -858993374  -858993382  epsilon
  11 | -858993374  -858993380  epsilon
  12 | -858993382  -858993390  epsilon
  13 | -858993382  -858993388  epsilon
  14 | -858993390  -858993396  epsilon
  15 | -858993390  -858993394  epsilon
  16 | -858993396  -858993400  epsilon
  17 | -858993396  -858993398  epsilon
  18 | -858993400  -858993404  epsilon
  19 | -858993400  -858993402  epsilon
  20 | -858993404  -858993410  epsilon
  21 | -858993404  -858993408  epsilon
  22 | -858993410  -858993416  epsilon
  23 | -858993410  -858993414  epsilon
  24 | -858993416  -858993422  epsilon
  25 | -858993416  -858993420  epsilon
  26 | -858993422  -858993428  epsilon
  27 | -858993422  -858993426  epsilon
  28 | -858993428  -858993432  epsilon
  29 | -858993428  -858993430  epsilon
  30 | -858993432  -858993436  epsilon
  31 | -858993432  -858993434  epsilon
  32 | -858993436  -858993440  epsilon
  33 | -858993436  -858993438  epsilon
  34 | -858993440  -858993444  epsilon
  35 | -858993440  -858993442  epsilon
  36 | -858993444  -858993448  epsilon
  37 | -858993444  -858993446  epsilon
  38 | -858993448  -858993452  epsilon
  39 | -858993448  -858993450  epsilon
  40 | -858993452  -858993456  epsilon
  41 | -858993452  -858993454  epsilon
  42 | -858993456  -858993460  epsilon
  43 | -858993456  -858993458  epsilon
  44 | -858993460  -858993459  (
  45 | -858993459  -858993455  epsilon
  46 | -858993458  -858993457  )
  47 | -858993457  -858993455  epsilon
  48 | -858993455  -858993451  epsilon
  49 | -858993454  -858993453  +
  50 | -858993453  -858993451  epsilon
  51 | -858993451  -858993447  epsilon
  52 | -858993450  -858993449  *
  53 | -858993449  -858993447  epsilon
  54 | -858993447  -858993443  epsilon
  55 | -858993446  -858993445  :
  56 | -858993445  -858993443  epsilon
  57 | -858993443  -858993439  epsilon
  58 | -858993442  -858993441  ;
  59 | -858993441  -858993439  epsilon
  60 | -858993439  -858993435  epsilon
  61 | -858993438  -858993437  ,
  62 | -858993437  -858993435  epsilon
  63 | -858993435  -858993431  epsilon
  64 | -858993434  -858993433  -
  65 | -858993433  -858993431  epsilon
  66 | -858993431  -858993427  epsilon
  67 | -858993430  -858993429  =
  68 | -858993429  -858993427  epsilon
  69 | -858993427  -858993421  epsilon
  70 | -858993426  -858993425  :
  71 | -858993425  -858993424  epsilon
  72 | -858993424  -858993423  =
  73 | -858993423  -858993421  epsilon
  74 | -858993421  -858993415  epsilon
  75 | -858993420  -858993419  <
  76 | -858993419  -858993418  epsilon
  77 | -858993418  -858993417  >
  78 | -858993417  -858993415  epsilon
  79 | -858993415  -858993409  epsilon
  80 | -858993414  -858993413  <
  81 | -858993413  -858993412  epsilon
  82 | -858993412  -858993411  =
  83 | -858993411  -858993409  epsilon
  84 | -858993409  -858993403  epsilon
  85 | -858993408  -858993407  >
  86 | -858993407  -858993406  epsilon
  87 | -858993406  -858993405  =
  88 | -858993405  -858993403  epsilon
  89 | -858993403  -858993399  epsilon
  90 | -858993402  -858993401  >
  91 | -858993401  -858993399  epsilon
  92 | -858993399  -858993395  epsilon
  93 | -858993398  -858993397  <
  94 | -858993397  -858993395  epsilon
  95 | -858993395  -858993389  epsilon
  96 | -858993394  -858993393  o
  97 | -858993393  -858993392  epsilon
  98 | -858993392  -858993391  r
  99 | -858993391  -858993389  epsilon
 100 | -858993389  -858993381  epsilon
 101 | -858993388  -858993387  a
 102 | -858993387  -858993386  epsilon
 103 | -858993386  -858993385  n
 104 | -858993385  -858993384  epsilon
 105 | -858993384  -858993383  d
 106 | -858993383  -858993381  epsilon
 107 | -858993381  -858993373  epsilon
 108 | -858993380  -858993379  m
 109 | -858993379  -858993378  epsilon
 110 | -858993378  -858993377  o
 111 | -858993377  -858993376  epsilon
 112 | -858993376  -858993375  d
 113 | -858993375  -858993373  epsilon
 114 | -858993373  -858993365  epsilon
 115 | -858993372  -858993371  d
 116 | -858993371  -858993370  epsilon
 117 | -858993370  -858993369  i
 118 | -858993369  -858993368  epsilon
 119 | -858993368  -858993367  v
 120 | -858993367  -858993365  epsilon
 121 | -858993365  -858993285  epsilon
 122 | -858993328  -858993332  epsilon
 123 | -858993328  -858993330  epsilon
 124 | -858993332  -858993336  epsilon
 125 | -858993332  -858993334  epsilon
 126 | -858993336  -858993340  epsilon
 127 | -858993336  -858993338  epsilon
 128 | -858993340  -858993344  epsilon
 129 | -858993340  -858993342  epsilon
 130 | -858993344  -858993348  epsilon
 131 | -858993344  -858993346  epsilon
 132 | -858993348  -858993352  epsilon
 133 | -858993348  -858993350  epsilon
 134 | -858993352  -858993356  epsilon
 135 | -858993352  -858993354  epsilon
 136 | -858993356  -858993360  epsilon
 137 | -858993356  -858993358  epsilon
 138 | -858993360  -858993364  epsilon
 139 | -858993360  -858993362  epsilon
 140 | -858993364  -858993363  0
 141 | -858993363  -858993359  epsilon
 142 | -858993362  -858993361  1
 143 | -858993361  -858993359  epsilon
 144 | -858993359  -858993355  epsilon
 145 | -858993358  -858993357  2
 146 | -858993357  -858993355  epsilon
 147 | -858993355  -858993351  epsilon
 148 | -858993354  -858993353  3
 149 | -858993353  -858993351  epsilon
 150 | -858993351  -858993347  epsilon
 151 | -858993350  -858993349  4
 152 | -858993349  -858993347  epsilon
 153 | -858993347  -858993343  epsilon
 154 | -858993346  -858993345  5
 155 | -858993345  -858993343  epsilon
 156 | -858993343  -858993339  epsilon
 157 | -858993342  -858993341  6
 158 | -858993341  -858993339  epsilon
 159 | -858993339  -858993335  epsilon
 160 | -858993338  -858993337  7
 161 | -858993337  -858993335  epsilon
 162 | -858993335  -858993331  epsilon
 163 | -858993334  -858993333  8
 164 | -858993333  -858993331  epsilon
 165 | -858993331  -858993327  epsilon
 166 | -858993330  -858993329  9
 167 | -858993329  -858993327  epsilon
 168 | -858993327  -858993288  epsilon
 169 | -858993288  -858993287  epsilon
 170 | -858993288  -858993290  epsilon
 171 | -858993290  -858993294  epsilon
 172 | -858993290  -858993292  epsilon
 173 | -858993294  -858993298  epsilon
 174 | -858993294  -858993296  epsilon
 175 | -858993298  -858993302  epsilon
 176 | -858993298  -858993300  epsilon
 177 | -858993302  -858993306  epsilon
 178 | -858993302  -858993304  epsilon
 179 | -858993306  -858993310  epsilon
 180 | -858993306  -858993308  epsilon
 181 | -858993310  -858993314  epsilon
 182 | -858993310  -858993312  epsilon
 183 | -858993314  -858993318  epsilon
 184 | -858993314  -858993316  epsilon
 185 | -858993318  -858993322  epsilon
 186 | -858993318  -858993320  epsilon
 187 | -858993322  -858993326  epsilon
 188 | -858993322  -858993324  epsilon
 189 | -858993326  -858993325  0
 190 | -858993325  -858993321  epsilon
 191 | -858993324  -858993323  1
 192 | -858993323  -858993321  epsilon
 193 | -858993321  -858993317  epsilon
 194 | -858993320  -858993319  2
 195 | -858993319  -858993317  epsilon
 196 | -858993317  -858993313  epsilon
 197 | -858993316  -858993315  3
 198 | -858993315  -858993313  epsilon
 199 | -858993313  -858993309  epsilon
 200 | -858993312  -858993311  4
 201 | -858993311  -858993309  epsilon
 202 | -858993309  -858993305  epsilon
 203 | -858993308  -858993307  5
 204 | -858993307  -858993305  epsilon
 205 | -858993305  -858993301  epsilon
 206 | -858993304  -858993303  6
 207 | -858993303  -858993301  epsilon
 208 | -858993301  -858993297  epsilon
 209 | -858993300  -858993299  7
 210 | -858993299  -858993297  epsilon
 211 | -858993297  -858993293  epsilon
 212 | -858993296  -858993295  8
 213 | -858993295  -858993293  epsilon
 214 | -858993293  -858993289  epsilon
 215 | -858993292  -858993291  9
 216 | -858993291  -858993289  epsilon
 217 | -858993289  -858993287  epsilon
 218 | -858993289  -858993290  epsilon
 219 | -858993287  -858993285  epsilon
 220 | -858993285  -858992821  epsilon
 221 | -858993076  -858993080  epsilon
 222 | -858993076  -858993078  epsilon
 223 | -858993080  -858993184  epsilon
 224 | -858993080  -858993082  epsilon
 225 | -858993184  -858993188  epsilon
 226 | -858993184  -858993186  epsilon
 227 | -858993188  -858993192  epsilon
 228 | -858993188  -858993190  epsilon
 229 | -858993192  -858993196  epsilon
 230 | -858993192  -858993194  epsilon
 231 | -858993196  -858993200  epsilon
 232 | -858993196  -858993198  epsilon
 233 | -858993200  -858993204  epsilon
 234 | -858993200  -858993202  epsilon
 235 | -858993204  -858993208  epsilon
 236 | -858993204  -858993206  epsilon
 237 | -858993208  -858993212  epsilon
 238 | -858993208  -858993210  epsilon
 239 | -858993212  -858993216  epsilon
 240 | -858993212  -858993214  epsilon
 241 | -858993216  -858993220  epsilon
 242 | -858993216  -858993218  epsilon
 243 | -858993220  -858993224  epsilon
 244 | -858993220  -858993222  epsilon
 245 | -858993224  -858993228  epsilon
 246 | -858993224  -858993226  epsilon
 247 | -858993228  -858993232  epsilon
 248 | -858993228  -858993230  epsilon
 249 | -858993232  -858993236  epsilon
 250 | -858993232  -858993234  epsilon
 251 | -858993236  -858993240  epsilon
 252 | -858993236  -858993238  epsilon
 253 | -858993240  -858993244  epsilon
 254 | -858993240  -858993242  epsilon
 255 | -858993244  -858993248  epsilon
 256 | -858993244  -858993246  epsilon
 257 | -858993248  -858993252  epsilon
 258 | -858993248  -858993250  epsilon
 259 | -858993252  -858993256  epsilon
 260 | -858993252  -858993254  epsilon
 261 | -858993256  -858993260  epsilon
 262 | -858993256  -858993258  epsilon
 263 | -858993260  -858993264  epsilon
 264 | -858993260  -858993262  epsilon
 265 | -858993264  -858993268  epsilon
 266 | -858993264  -858993266  epsilon
 267 | -858993268  -858993272  epsilon
 268 | -858993268  -858993270  epsilon
 269 | -858993272  -858993276  epsilon
 270 | -858993272  -858993274  epsilon
 271 | -858993276  -858993280  epsilon
 272 | -858993276  -858993278  epsilon
 273 | -858993280  -858993284  epsilon
 274 | -858993280  -858993282  epsilon
 275 | -858993284  -858993283  a
 276 | -858993283  -858993279  epsilon
 277 | -858993282  -858993281  b
 278 | -858993281  -858993279  epsilon
 279 | -858993279  -858993275  epsilon
 280 | -858993278  -858993277  c
 281 | -858993277  -858993275  epsilon
 282 | -858993275  -858993271  epsilon
 283 | -858993274  -858993273  d
 284 | -858993273  -858993271  epsilon
 285 | -858993271  -858993267  epsilon
 286 | -858993270  -858993269  e
 287 | -858993269  -858993267  epsilon
 288 | -858993267  -858993263  epsilon
 289 | -858993266  -858993265  f
 290 | -858993265  -858993263  epsilon
 291 | -858993263  -858993259  epsilon
 292 | -858993262  -858993261  g
 293 | -858993261  -858993259  epsilon
 294 | -858993259  -858993255  epsilon
 295 | -858993258  -858993257  h
 296 | -858993257  -858993255  epsilon
 297 | -858993255  -858993251  epsilon
 298 | -858993254  -858993253  i
 299 | -858993253  -858993251  epsilon
 300 | -858993251  -858993247  epsilon
 301 | -858993250  -858993249  j
 302 | -858993249  -858993247  epsilon
 303 | -858993247  -858993243  epsilon
 304 | -858993246  -858993245  k
 305 | -858993245  -858993243  epsilon
 306 | -858993243  -858993239  epsilon
 307 | -858993242  -858993241  l
 308 | -858993241  -858993239  epsilon
 309 | -858993239  -858993235  epsilon
 310 | -858993238  -858993237  m
 311 | -858993237  -858993235  epsilon
 312 | -858993235  -858993231  epsilon
 313 | -858993234  -858993233  n
 314 | -858993233  -858993231  epsilon
 315 | -858993231  -858993227  epsilon
 316 | -858993230  -858993229  o
 317 | -858993229  -858993227  epsilon
 318 | -858993227  -858993223  epsilon
 319 | -858993226  -858993225  p
 320 | -858993225  -858993223  epsilon
 321 | -858993223  -858993219  epsilon
 322 | -858993222  -858993221  q
 323 | -858993221  -858993219  epsilon
 324 | -858993219  -858993215  epsilon
 325 | -858993218  -858993217  r
 326 | -858993217  -858993215  epsilon
 327 | -858993215  -858993211  epsilon
 328 | -858993214  -858993213  s
 329 | -858993213  -858993211  epsilon
 330 | -858993211  -858993207  epsilon
 331 | -858993210  -858993209  t
 332 | -858993209  -858993207  epsilon
 333 | -858993207  -858993203  epsilon
 334 | -858993206  -858993205  u
 335 | -858993205  -858993203  epsilon
 336 | -858993203  -858993199  epsilon
 337 | -858993202  -858993201  v
 338 | -858993201  -858993199  epsilon
 339 | -858993199  -858993195  epsilon
 340 | -858993198  -858993197  w
 341 | -858993197  -858993195  epsilon
 342 | -858993195  -858993191  epsilon
 343 | -858993194  -858993193  x
 344 | -858993193  -858993191  epsilon
 345 | -858993191  -858993187  epsilon
 346 | -858993190  -858993189  y
 347 | -858993189  -858993187  epsilon
 348 | -858993187  -858993183  epsilon
 349 | -858993186  -858993185  z
 350 | -858993185  -858993183  epsilon
 351 | -858993183  -858993079  epsilon
 352 | -858993082  -858993086  epsilon
 353 | -858993082  -858993084  epsilon
 354 | -858993086  -858993090  epsilon
 355 | -858993086  -858993088  epsilon
 356 | -858993090  -858993094  epsilon
 357 | -858993090  -858993092  epsilon
 358 | -858993094  -858993098  epsilon
 359 | -858993094  -858993096  epsilon
 360 | -858993098  -858993102  epsilon
 361 | -858993098  -858993100  epsilon
 362 | -858993102  -858993106  epsilon
 363 | -858993102  -858993104  epsilon
 364 | -858993106  -858993110  epsilon
 365 | -858993106  -858993108  epsilon
 366 | -858993110  -858993114  epsilon
 367 | -858993110  -858993112  epsilon
 368 | -858993114  -858993118  epsilon
 369 | -858993114  -858993116  epsilon
 370 | -858993118  -858993122  epsilon
 371 | -858993118  -858993120  epsilon
 372 | -858993122  -858993126  epsilon
 373 | -858993122  -858993124  epsilon
 374 | -858993126  -858993130  epsilon
 375 | -858993126  -858993128  epsilon
 376 | -858993130  -858993134  epsilon
 377 | -858993130  -858993132  epsilon
 378 | -858993134  -858993138  epsilon
 379 | -858993134  -858993136  epsilon
 380 | -858993138  -858993142  epsilon
 381 | -858993138  -858993140  epsilon
 382 | -858993142  -858993146  epsilon
 383 | -858993142  -858993144  epsilon
 384 | -858993146  -858993150  epsilon
 385 | -858993146  -858993148  epsilon
 386 | -858993150  -858993154  epsilon
 387 | -858993150  -858993152  epsilon
 388 | -858993154  -858993158  epsilon
 389 | -858993154  -858993156  epsilon
 390 | -858993158  -858993162  epsilon
 391 | -858993158  -858993160  epsilon
 392 | -858993162  -858993166  epsilon
 393 | -858993162  -858993164  epsilon
 394 | -858993166  -858993170  epsilon
 395 | -858993166  -858993168  epsilon
 396 | -858993170  -858993174  epsilon
 397 | -858993170  -858993172  epsilon
 398 | -858993174  -858993178  epsilon
 399 | -858993174  -858993176  epsilon
 400 | -858993178  -858993182  epsilon
 401 | -858993178  -858993180  epsilon
 402 | -858993182  -858993181  A
 403 | -858993181  -858993177  epsilon
 404 | -858993180  -858993179  B
 405 | -858993179  -858993177  epsilon
 406 | -858993177  -858993173  epsilon
 407 | -858993176  -858993175  C
 408 | -858993175  -858993173  epsilon
 409 | -858993173  -858993169  epsilon
 410 | -858993172  -858993171  D
 411 | -858993171  -858993169  epsilon
 412 | -858993169  -858993165  epsilon
 413 | -858993168  -858993167  E
 414 | -858993167  -858993165  epsilon
 415 | -858993165  -858993161  epsilon
 416 | -858993164  -858993163  F
 417 | -858993163  -858993161  epsilon
 418 | -858993161  -858993157  epsilon
 419 | -858993160  -858993159  G
 420 | -858993159  -858993157  epsilon
 421 | -858993157  -858993153  epsilon
 422 | -858993156  -858993155  H
 423 | -858993155  -858993153  epsilon
 424 | -858993153  -858993149  epsilon
 425 | -858993152  -858993151  I
 426 | -858993151  -858993149  epsilon
 427 | -858993149  -858993145  epsilon
 428 | -858993148  -858993147  J
 429 | -858993147  -858993145  epsilon
 430 | -858993145  -858993141  epsilon
 431 | -858993144  -858993143  K
 432 | -858993143  -858993141  epsilon
 433 | -858993141  -858993137  epsilon
 434 | -858993140  -858993139  L
 435 | -858993139  -858993137  epsilon
 436 | -858993137  -858993133  epsilon
 437 | -858993136  -858993135  M
 438 | -858993135  -858993133  epsilon
 439 | -858993133  -858993129  epsilon
 440 | -858993132  -858993131  N
 441 | -858993131  -858993129  epsilon
 442 | -858993129  -858993125  epsilon
 443 | -858993128  -858993127  O
 444 | -858993127  -858993125  epsilon
 445 | -858993125  -858993121  epsilon
 446 | -858993124  -858993123  P
 447 | -858993123  -858993121  epsilon
 448 | -858993121  -858993117  epsilon
 449 | -858993120  -858993119  Q
 450 | -858993119  -858993117  epsilon
 451 | -858993117  -858993113  epsilon
 452 | -858993116  -858993115  R
 453 | -858993115  -858993113  epsilon
 454 | -858993113  -858993109  epsilon
 455 | -858993112  -858993111  S
 456 | -858993111  -858993109  epsilon
 457 | -858993109  -858993105  epsilon
 458 | -858993108  -858993107  T
 459 | -858993107  -858993105  epsilon
 460 | -858993105  -858993101  epsilon
 461 | -858993104  -858993103  U
 462 | -858993103  -858993101  epsilon
 463 | -858993101  -858993097  epsilon
 464 | -858993100  -858993099  V
 465 | -858993099  -858993097  epsilon
 466 | -858993097  -858993093  epsilon
 467 | -858993096  -858993095  W
 468 | -858993095  -858993093  epsilon
 469 | -858993093  -858993089  epsilon
 470 | -858993092  -858993091  X
 471 | -858993091  -858993089  epsilon
 472 | -858993089  -858993085  epsilon
 473 | -858993088  -858993087  Y
 474 | -858993087  -858993085  epsilon
 475 | -858993085  -858993081  epsilon
 476 | -858993084  -858993083  Z
 477 | -858993083  -858993081  epsilon
 478 | -858993081  -858993079  epsilon
 479 | -858993079  -858993075  epsilon
 480 | -858993078  -858993077  _
 481 | -858993077  -858993075  epsilon
 482 | -858993075  -858992824  epsilon
 483 | -858992824  -858992823  epsilon
 484 | -858992824  -858992826  epsilon
 485 | -858992826  -858992830  epsilon
 486 | -858992826  -858992828  epsilon
 487 | -858992830  -858992870  epsilon
 488 | -858992830  -858992832  epsilon
 489 | -858992870  -858992974  epsilon
 490 | -858992870  -858992872  epsilon
 491 | -858992974  -858992978  epsilon
 492 | -858992974  -858992976  epsilon
 493 | -858992978  -858992982  epsilon
 494 | -858992978  -858992980  epsilon
 495 | -858992982  -858992986  epsilon
 496 | -858992982  -858992984  epsilon
 497 | -858992986  -858992990  epsilon
 498 | -858992986  -858992988  epsilon
 499 | -858992990  -858992994  epsilon
 500 | -858992990  -858992992  epsilon
 501 | -858992994  -858992998  epsilon
 502 | -858992994  -858992996  epsilon
 503 | -858992998  -858993002  epsilon
 504 | -858992998  -858993000  epsilon
 505 | -858993002  -858993006  epsilon
 506 | -858993002  -858993004  epsilon
 507 | -858993006  -858993010  epsilon
 508 | -858993006  -858993008  epsilon
 509 | -858993010  -858993014  epsilon
 510 | -858993010  -858993012  epsilon
 511 | -858993014  -858993018  epsilon
 512 | -858993014  -858993016  epsilon
 513 | -858993018  -858993022  epsilon
 514 | -858993018  -858993020  epsilon
 515 | -858993022  -858993026  epsilon
 516 | -858993022  -858993024  epsilon
 517 | -858993026  -858993030  epsilon
 518 | -858993026  -858993028  epsilon
 519 | -858993030  -858993034  epsilon
 520 | -858993030  -858993032  epsilon
 521 | -858993034  -858993038  epsilon
 522 | -858993034  -858993036  epsilon
 523 | -858993038  -858993042  epsilon
 524 | -858993038  -858993040  epsilon
 525 | -858993042  -858993046  epsilon
 526 | -858993042  -858993044  epsilon
 527 | -858993046  -858993050  epsilon
 528 | -858993046  -858993048  epsilon
 529 | -858993050  -858993054  epsilon
 530 | -858993050  -858993052  epsilon
 531 | -858993054  -858993058  epsilon
 532 | -858993054  -858993056  epsilon
 533 | -858993058  -858993062  epsilon
 534 | -858993058  -858993060  epsilon
 535 | -858993062  -858993066  epsilon
 536 | -858993062  -858993064  epsilon
 537 | -858993066  -858993070  epsilon
 538 | -858993066  -858993068  epsilon
 539 | -858993070  -858993074  epsilon
 540 | -858993070  -858993072  epsilon
 541 | -858993074  -858993073  a
 542 | -858993073  -858993069  epsilon
 543 | -858993072  -858993071  b
 544 | -858993071  -858993069  epsilon
 545 | -858993069  -858993065  epsilon
 546 | -858993068  -858993067  c
 547 | -858993067  -858993065  epsilon
 548 | -858993065  -858993061  epsilon
 549 | -858993064  -858993063  d
 550 | -858993063  -858993061  epsilon
 551 | -858993061  -858993057  epsilon
 552 | -858993060  -858993059  e
 553 | -858993059  -858993057  epsilon
 554 | -858993057  -858993053  epsilon
 555 | -858993056  -858993055  f
 556 | -858993055  -858993053  epsilon
 557 | -858993053  -858993049  epsilon
 558 | -858993052  -858993051  g
 559 | -858993051  -858993049  epsilon
 560 | -858993049  -858993045  epsilon
 561 | -858993048  -858993047  h
 562 | -858993047  -858993045  epsilon
 563 | -858993045  -858993041  epsilon
 564 | -858993044  -858993043  i
 565 | -858993043  -858993041  epsilon
 566 | -858993041  -858993037  epsilon
 567 | -858993040  -858993039  j
 568 | -858993039  -858993037  epsilon
 569 | -858993037  -858993033  epsilon
 570 | -858993036  -858993035  k
 571 | -858993035  -858993033  epsilon
 572 | -858993033  -858993029  epsilon
 573 | -858993032  -858993031  l
 574 | -858993031  -858993029  epsilon
 575 | -858993029  -858993025  epsilon
 576 | -858993028  -858993027  m
 577 | -858993027  -858993025  epsilon
 578 | -858993025  -858993021  epsilon
 579 | -858993024  -858993023  n
 580 | -858993023  -858993021  epsilon
 581 | -858993021  -858993017  epsilon
 582 | -858993020  -858993019  o
 583 | -858993019  -858993017  epsilon
 584 | -858993017  -858993013  epsilon
 585 | -858993016  -858993015  p
 586 | -858993015  -858993013  epsilon
 587 | -858993013  -858993009  epsilon
 588 | -858993012  -858993011  q
 589 | -858993011  -858993009  epsilon
 590 | -858993009  -858993005  epsilon
 591 | -858993008  -858993007  r
 592 | -858993007  -858993005  epsilon
 593 | -858993005  -858993001  epsilon
 594 | -858993004  -858993003  s
 595 | -858993003  -858993001  epsilon
 596 | -858993001  -858992997  epsilon
 597 | -858993000  -858992999  t
 598 | -858992999  -858992997  epsilon
 599 | -858992997  -858992993  epsilon
 600 | -858992996  -858992995  u
 601 | -858992995  -858992993  epsilon
 602 | -858992993  -858992989  epsilon
 603 | -858992992  -858992991  v
 604 | -858992991  -858992989  epsilon
 605 | -858992989  -858992985  epsilon
 606 | -858992988  -858992987  w
 607 | -858992987  -858992985  epsilon
 608 | -858992985  -858992981  epsilon
 609 | -858992984  -858992983  x
 610 | -858992983  -858992981  epsilon
 611 | -858992981  -858992977  epsilon
 612 | -858992980  -858992979  y
 613 | -858992979  -858992977  epsilon
 614 | -858992977  -858992973  epsilon
 615 | -858992976  -858992975  z
 616 | -858992975  -858992973  epsilon
 617 | -858992973  -858992869  epsilon
 618 | -858992872  -858992876  epsilon
 619 | -858992872  -858992874  epsilon
 620 | -858992876  -858992880  epsilon
 621 | -858992876  -858992878  epsilon
 622 | -858992880  -858992884  epsilon
 623 | -858992880  -858992882  epsilon
 624 | -858992884  -858992888  epsilon
 625 | -858992884  -858992886  epsilon
 626 | -858992888  -858992892  epsilon
 627 | -858992888  -858992890  epsilon
 628 | -858992892  -858992896  epsilon
 629 | -858992892  -858992894  epsilon
 630 | -858992896  -858992900  epsilon
 631 | -858992896  -858992898  epsilon
 632 | -858992900  -858992904  epsilon
 633 | -858992900  -858992902  epsilon
 634 | -858992904  -858992908  epsilon
 635 | -858992904  -858992906  epsilon
 636 | -858992908  -858992912  epsilon
 637 | -858992908  -858992910  epsilon
 638 | -858992912  -858992916  epsilon
 639 | -858992912  -858992914  epsilon
 640 | -858992916  -858992920  epsilon
 641 | -858992916  -858992918  epsilon
 642 | -858992920  -858992924  epsilon
 643 | -858992920  -858992922  epsilon
 644 | -858992924  -858992928  epsilon
 645 | -858992924  -858992926  epsilon
 646 | -858992928  -858992932  epsilon
 647 | -858992928  -858992930  epsilon
 648 | -858992932  -858992936  epsilon
 649 | -858992932  -858992934  epsilon
 650 | -858992936  -858992940  epsilon
 651 | -858992936  -858992938  epsilon
 652 | -858992940  -858992944  epsilon
 653 | -858992940  -858992942  epsilon
 654 | -858992944  -858992948  epsilon
 655 | -858992944  -858992946  epsilon
 656 | -858992948  -858992952  epsilon
 657 | -858992948  -858992950  epsilon
 658 | -858992952  -858992956  epsilon
 659 | -858992952  -858992954  epsilon
 660 | -858992956  -858992960  epsilon
 661 | -858992956  -858992958  epsilon
 662 | -858992960  -858992964  epsilon
 663 | -858992960  -858992962  epsilon
 664 | -858992964  -858992968  epsilon
 665 | -858992964  -858992966  epsilon
 666 | -858992968  -858992972  epsilon
 667 | -858992968  -858992970  epsilon
 668 | -858992972  -858992971  A
 669 | -858992971  -858992967  epsilon
 670 | -858992970  -858992969  B
 671 | -858992969  -858992967  epsilon
 672 | -858992967  -858992963  epsilon
 673 | -858992966  -858992965  C
 674 | -858992965  -858992963  epsilon
 675 | -858992963  -858992959  epsilon
 676 | -858992962  -858992961  D
 677 | -858992961  -858992959  epsilon
 678 | -858992959  -858992955  epsilon
 679 | -858992958  -858992957  E
 680 | -858992957  -858992955  epsilon
 681 | -858992955  -858992951  epsilon
 682 | -858992954  -858992953  F
 683 | -858992953  -858992951  epsilon
 684 | -858992951  -858992947  epsilon
 685 | -858992950  -858992949  G
 686 | -858992949  -858992947  epsilon
 687 | -858992947  -858992943  epsilon
 688 | -858992946  -858992945  H
 689 | -858992945  -858992943  epsilon
 690 | -858992943  -858992939  epsilon
 691 | -858992942  -858992941  I
 692 | -858992941  -858992939  epsilon
 693 | -858992939  -858992935  epsilon
 694 | -858992938  -858992937  J
 695 | -858992937  -858992935  epsilon
 696 | -858992935  -858992931  epsilon
 697 | -858992934  -858992933  K
 698 | -858992933  -858992931  epsilon
 699 | -858992931  -858992927  epsilon
 700 | -858992930  -858992929  L
 701 | -858992929  -858992927  epsilon
 702 | -858992927  -858992923  epsilon
 703 | -858992926  -858992925  M
 704 | -858992925  -858992923  epsilon
 705 | -858992923  -858992919  epsilon
 706 | -858992922  -858992921  N
 707 | -858992921  -858992919  epsilon
 708 | -858992919  -858992915  epsilon
 709 | -858992918  -858992917  O
 710 | -858992917  -858992915  epsilon
 711 | -858992915  -858992911  epsilon
 712 | -858992914  -858992913  P
 713 | -858992913  -858992911  epsilon
 714 | -858992911  -858992907  epsilon
 715 | -858992910  -858992909  Q
 716 | -858992909  -858992907  epsilon
 717 | -858992907  -858992903  epsilon
 718 | -858992906  -858992905  R
 719 | -858992905  -858992903  epsilon
 720 | -858992903  -858992899  epsilon
 721 | -858992902  -858992901  S
 722 | -858992901  -858992899  epsilon
 723 | -858992899  -858992895  epsilon
 724 | -858992898  -858992897  T
 725 | -858992897  -858992895  epsilon
 726 | -858992895  -858992891  epsilon
 727 | -858992894  -858992893  U
 728 | -858992893  -858992891  epsilon
 729 | -858992891  -858992887  epsilon
 730 | -858992890  -858992889  V
 731 | -858992889  -858992887  epsilon
 732 | -858992887  -858992883  epsilon
 733 | -858992886  -858992885  W
 734 | -858992885  -858992883  epsilon
 735 | -858992883  -858992879  epsilon
 736 | -858992882  -858992881  X
 737 | -858992881  -858992879  epsilon
 738 | -858992879  -858992875  epsilon
 739 | -858992878  -858992877  Y
 740 | -858992877  -858992875  epsilon
 741 | -858992875  -858992871  epsilon
 742 | -858992874  -858992873  Z
 743 | -858992873  -858992871  epsilon
 744 | -858992871  -858992869  epsilon
 745 | -858992869  -858992829  epsilon
 746 | -858992832  -858992836  epsilon
 747 | -858992832  -858992834  epsilon
 748 | -858992836  -858992840  epsilon
 749 | -858992836  -858992838  epsilon
 750 | -858992840  -858992844  epsilon
 751 | -858992840  -858992842  epsilon
 752 | -858992844  -858992848  epsilon
 753 | -858992844  -858992846  epsilon
 754 | -858992848  -858992852  epsilon
 755 | -858992848  -858992850  epsilon
 756 | -858992852  -858992856  epsilon
 757 | -858992852  -858992854  epsilon
 758 | -858992856  -858992860  epsilon
 759 | -858992856  -858992858  epsilon
 760 | -858992860  -858992864  epsilon
 761 | -858992860  -858992862  epsilon
 762 | -858992864  -858992868  epsilon
 763 | -858992864  -858992866  epsilon
 764 | -858992868  -858992867  0
 765 | -858992867  -858992863  epsilon
 766 | -858992866  -858992865  1
 767 | -858992865  -858992863  epsilon
 768 | -858992863  -858992859  epsilon
 769 | -858992862  -858992861  2
 770 | -858992861  -858992859  epsilon
 771 | -858992859  -858992855  epsilon
 772 | -858992858  -858992857  3
 773 | -858992857  -858992855  epsilon
 774 | -858992855  -858992851  epsilon
 775 | -858992854  -858992853  4
 776 | -858992853  -858992851  epsilon
 777 | -858992851  -858992847  epsilon
 778 | -858992850  -858992849  5
 779 | -858992849  -858992847  epsilon
 780 | -858992847  -858992843  epsilon
 781 | -858992846  -858992845  6
 782 | -858992845  -858992843  epsilon
 783 | -858992843  -858992839  epsilon
 784 | -858992842  -858992841  7
 785 | -858992841  -858992839  epsilon
 786 | -858992839  -858992835  epsilon
 787 | -858992838  -858992837  8
 788 | -858992837  -858992835  epsilon
 789 | -858992835  -858992831  epsilon
 790 | -858992834  -858992833  9
 791 | -858992833  -858992831  epsilon
 792 | -858992831  -858992829  epsilon
 793 | -858992829  -858992825  epsilon
 794 | -858992828  -858992827  _
 795 | -858992827  -858992825  epsilon
 796 | -858992825  -858992823  epsilon
 797 | -858992825  -858992826  epsilon
 798 | -858992823  -858992821  epsilon
 799 | -858992821  -858992625  epsilon
 800 | -858992628  -858992644  epsilon
 801 | -858992628  -858992642  epsilon
 802 | -858992644  -858992658  epsilon
 803 | -858992644  -858992656  epsilon
 804 | -858992658  -858992678  epsilon
 805 | -858992658  -858992676  epsilon
 806 | -858992678  -858992690  epsilon
 807 | -858992678  -858992688  epsilon
 808 | -858992690  -858992708  epsilon
 809 | -858992690  -858992706  epsilon
 810 | -858992708  -858992718  epsilon
 811 | -858992708  -858992716  epsilon
 812 | -858992718  -858992734  epsilon
 813 | -858992718  -858992732  epsilon
 814 | -858992734  -858992742  epsilon
 815 | -858992734  -858992740  epsilon
 816 | -858992742  -858992750  epsilon
 817 | -858992742  -858992748  epsilon
 818 | -858992750  -858992762  epsilon
 819 | -858992750  -858992760  epsilon
 820 | -858992762  -858992768  epsilon
 821 | -858992762  -858992766  epsilon
 822 | -858992768  -858992776  epsilon
 823 | -858992768  -858992774  epsilon
 824 | -858992776  -858992788  epsilon
 825 | -858992776  -858992786  epsilon
 826 | -858992788  -858992798  epsilon
 827 | -858992788  -858992796  epsilon
 828 | -858992798  -858992808  epsilon
 829 | -858992798  -858992806  epsilon
 830 | -858992808  -858992820  epsilon
 831 | -858992808  -858992812  epsilon
 832 | -858992820  -858992819  m
 833 | -858992819  -858992818  epsilon
 834 | -858992818  -858992817  a
 835 | -858992817  -858992816  epsilon
 836 | -858992816  -858992815  i
 837 | -858992815  -858992814  epsilon
 838 | -858992814  -858992813  n
 839 | -858992813  -858992807  epsilon
 840 | -858992812  -858992811  i
 841 | -858992811  -858992810  epsilon
 842 | -858992810  -858992809  f
 843 | -858992809  -858992807  epsilon
 844 | -858992807  -858992797  epsilon
 845 | -858992806  -858992805  t
 846 | -858992805  -858992804  epsilon
 847 | -858992804  -858992803  h
 848 | -858992803  -858992802  epsilon
 849 | -858992802  -858992801  e
 850 | -858992801  -858992800  epsilon
 851 | -858992800  -858992799  n
 852 | -858992799  -858992797  epsilon
 853 | -858992797  -858992787  epsilon
 854 | -858992796  -858992795  e
 855 | -858992795  -858992794  epsilon
 856 | -858992794  -858992793  l
 857 | -858992793  -858992792  epsilon
 858 | -858992792  -858992791  s
 859 | -858992791  -858992790  epsilon
 860 | -858992790  -858992789  e
 861 | -858992789  -858992787  epsilon
 862 | -858992787  -858992775  epsilon
 863 | -858992786  -858992785  w
 864 | -858992785  -858992784  epsilon
 865 | -858992784  -858992783  h
 866 | -858992783  -858992782  epsilon
 867 | -858992782  -858992781  i
 868 | -858992781  -858992780  epsilon
 869 | -858992780  -858992779  l
 870 | -858992779  -858992778  epsilon
 871 | -858992778  -858992777  e
 872 | -858992777  -858992775  epsilon
 873 | -858992775  -858992767  epsilon
 874 | -858992774  -858992773  f
 875 | -858992773  -858992772  epsilon
 876 | -858992772  -858992771  o
 877 | -858992771  -858992770  epsilon
 878 | -858992770  -858992769  r
 879 | -858992769  -858992767  epsilon
 880 | -858992767  -858992761  epsilon
 881 | -858992766  -858992765  d
 882 | -858992765  -858992764  epsilon
 883 | -858992764  -858992763  o
 884 | -858992763  -858992761  epsilon
 885 | -858992761  -858992749  epsilon
 886 | -858992760  -858992759  b
 887 | -858992759  -858992758  epsilon
 888 | -858992758  -858992757  e
 889 | -858992757  -858992756  epsilon
 890 | -858992756  -858992755  g
 891 | -858992755  -858992754  epsilon
 892 | -858992754  -858992753  i
 893 | -858992753  -858992752  epsilon
 894 | -858992752  -858992751  n
 895 | -858992751  -858992749  epsilon
 896 | -858992749  -858992741  epsilon
 897 | -858992748  -858992747  e
 898 | -858992747  -858992746  epsilon
 899 | -858992746  -858992745  n
 900 | -858992745  -858992744  epsilon
 901 | -858992744  -858992743  d
 902 | -858992743  -858992741  epsilon
 903 | -858992741  -858992733  epsilon
 904 | -858992740  -858992739  v
 905 | -858992739  -858992738  epsilon
 906 | -858992738  -858992737  a
 907 | -858992737  -858992736  epsilon
 908 | -858992736  -858992735  r
 909 | -858992735  -858992733  epsilon
 910 | -858992733  -858992717  epsilon
 911 | -858992732  -858992731  i
 912 | -858992731  -858992730  epsilon
 913 | -858992730  -858992729  n
 914 | -858992729  -858992728  epsilon
 915 | -858992728  -858992727  t
 916 | -858992727  -858992726  epsilon
 917 | -858992726  -858992725  e
 918 | -858992725  -858992724  epsilon
 919 | -858992724  -858992723  g
 920 | -858992723  -858992722  epsilon
 921 | -858992722  -858992721  e
 922 | -858992721  -858992720  epsilon
 923 | -858992720  -858992719  r
 924 | -858992719  -858992717  epsilon
 925 | -858992717  -858992707  epsilon
 926 | -858992716  -858992715  r
 927 | -858992715  -858992714  epsilon
 928 | -858992714  -858992713  e
 929 | -858992713  -858992712  epsilon
 930 | -858992712  -858992711  a
 931 | -858992711  -858992710  epsilon
 932 | -858992710  -858992709  l
 933 | -858992709  -858992707  epsilon
 934 | -858992707  -858992689  epsilon
 935 | -858992706  -858992705  f
 936 | -858992705  -858992704  epsilon
 937 | -858992704  -858992703  u
 938 | -858992703  -858992702  epsilon
 939 | -858992702  -858992701  n
 940 | -858992701  -858992700  epsilon
 941 | -858992700  -858992699  c
 942 | -858992699  -858992698  epsilon
 943 | -858992698  -858992697  t
 944 | -858992697  -858992696  epsilon
 945 | -858992696  -858992695  i
 946 | -858992695  -858992694  epsilon
 947 | -858992694  -858992693  o
 948 | -858992693  -858992692  epsilon
 949 | -858992692  -858992691  n
 950 | -858992691  -858992689  epsilon
 951 | -858992689  -858992677  epsilon
 952 | -858992688  -858992687  a
 953 | -858992687  -858992686  epsilon
 954 | -858992686  -858992685  r
 955 | -858992685  -858992684  epsilon
 956 | -858992684  -858992683  r
 957 | -858992683  -858992682  epsilon
 958 | -858992682  -858992681  a
 959 | -858992681  -858992680  epsilon
 960 | -858992680  -858992679  y
 961 | -858992679  -858992677  epsilon
 962 | -858992677  -858992657  epsilon
 963 | -858992676  -858992675  p
 964 | -858992675  -858992674  epsilon
 965 | -858992674  -858992673  r
 966 | -858992673  -858992672  epsilon
 967 | -858992672  -858992671  o
 968 | -858992671  -858992670  epsilon
 969 | -858992670  -858992669  c
 970 | -858992669  -858992668  epsilon
 971 | -858992668  -858992667  e
 972 | -858992667  -858992666  epsilon
 973 | -858992666  -858992665  d
 974 | -858992665  -858992664  epsilon
 975 | -858992664  -858992663  u
 976 | -858992663  -858992662  epsilon
 977 | -858992662  -858992661  r
 978 | -858992661  -858992660  epsilon
 979 | -858992660  -858992659  e
 980 | -858992659  -858992657  epsilon
 981 | -858992657  -858992643  epsilon
 982 | -858992656  -858992655  r
 983 | -858992655  -858992654  epsilon
 984 | -858992654  -858992653  e
 985 | -858992653  -858992652  epsilon
 986 | -858992652  -858992651  s
 987 | -858992651  -858992650  epsilon
 988 | -858992650  -858992649  u
 989 | -858992649  -858992648  epsilon
 990 | -858992648  -858992647  l
 991 | -858992647  -858992646  epsilon
 992 | -858992646  -858992645  t
 993 | -858992645  -858992643  epsilon
 994 | -858992643  -858992627  epsilon
 995 | -858992642  -858992641  p
 996 | -858992641  -858992640  epsilon
 997 | -858992640  -858992639  r
 998 | -858992639  -858992638  epsilon
 999 | -858992638  -858992637  o
1000 | -858992637  -858992636  epsilon
1001 | -858992636  -858992635  g
1002 | -858992635  -858992634  epsilon
1003 | -858992634  -858992633  r
1004 | -858992633  -858992632  epsilon
1005 | -858992632  -858992631  a
1006 | -858992631  -858992630  epsilon
1007 | -858992630  -858992629  m
1008 | -858992629  -858992627  epsilon
1009 | -858992627  -858992625  epsilon
1010 | 


--------------------------------------------------------------------------------
/sources/parser.cpp:
--------------------------------------------------------------------------------
   1 | #include <iostream>
   2 | #include <fstream>
   3 | #include <vector>
   4 | #include <algorithm>
   5 | #include <stack>
   6 | #include <set>
   7 | #include <list>
   8 | #include <string>
   9 | #include <sstream>
  10 | #include <map>
  11 | #include "parser.hpp"
  12 | 
  13 | using namespace std;
  14 | 
  15 | #define EPSILON			-1
  16 | #define CLOSURE			'*'
  17 | #define OPEN_PAREN		'('
  18 | #define CLOSE_PAREN		')'
  19 | #define OR				'+'
  20 | #define CONCAT			'.'
  21 | 
  22 | Parser::Parser()
  23 | {
  24 | 	token_index = 0;
  25 | 	good_program = true;
  26 | 	see_epsilon = false;
  27 | }
  28 | 
  29 | void Parser::createTree()
  30 | {
  31 | 	token = nextToken();
  32 | 	root = program();
  33 | }
  34 | 
  35 | void Parser::Error()
  36 | {
  37 | 	cout << "Syntax Error near " << token.value << "\n";
  38 | 	token_index++;
  39 | 	good_program = false;
  40 | }
  41 | 
  42 | Token Parser::nextToken()
  43 | {
  44 | 	if (see_epsilon == true)
  45 | 	{
  46 | 		see_epsilon = false;
  47 | 		return token;
  48 | 	}
  49 | 	return tokens[token_index++];
  50 | }
  51 | 
  52 | TreeNode* Parser::factor()
  53 | {
  54 | 	if (token.value == "not")
  55 | 	{
  56 | 		TreeNode* not_node = new TreeNode(token.value);
  57 | 		token = nextToken();
  58 | 		TreeNode* factor_node = factor();
  59 | 		if (factor_node != NULL)
  60 | 		{
  61 | 			TreeNode* myroot = new TreeNode("factor");
  62 | 			myroot->childs.push_back(not_node);
  63 | 			myroot->childs.push_back(factor_node);
  64 | 			return myroot;
  65 | 		}
  66 | 	}
  67 | 	else if (token.value == "(")
  68 | 	{
  69 | 		TreeNode* parantez_open_node = new TreeNode(token.value);
  70 | 		token = nextToken();
  71 | 		TreeNode* expression_list_node = expression_list();
  72 | 		if (expression_list_node != NULL)
  73 | 		{
  74 | 			token = nextToken();
  75 | 			if (token.value == ")")
  76 | 			{
  77 | 				TreeNode* parantez_close_node = new TreeNode(token.value);
  78 | 				TreeNode* myroot = new TreeNode("factor");
  79 | 				myroot->childs.push_back(parantez_open_node);
  80 | 				myroot->childs.push_back(expression_list_node);
  81 | 				myroot->childs.push_back(parantez_close_node);
  82 | 				return myroot;
  83 | 			}
  84 | 		}
  85 | 	}
  86 | 	else if (token.type == "CONSTANT")
  87 | 	{
  88 | 		TreeNode* CONSTANT_node = new TreeNode(token.value);
  89 | 		TreeNode* myroot = new TreeNode("factor");
  90 | 		myroot->childs.push_back(CONSTANT_node);
  91 | 		return myroot;
  92 | 	}
  93 | 	else
  94 | 	{
  95 | 		TreeNode* variable_node = variable();
  96 | 		if (variable_node != NULL)
  97 | 		{
  98 | 			TreeNode* myroot = new TreeNode("factor");
  99 | 			myroot->childs.push_back(variable_node);
 100 | 			return myroot;
 101 | 		}
 102 | 	}
 103 | 	Error();
 104 | 	return NULL;
 105 | }
 106 | 
 107 | TreeNode* Parser::term_prime()
 108 | {
 109 | 	if (token.type == "MULOP")
 110 | 	{
 111 | 		TreeNode* MULOP_node = new TreeNode(token.value);
 112 | 		token = nextToken();
 113 | 		TreeNode* factor_node = factor();
 114 | 		if (factor_node != NULL)
 115 | 		{
 116 | 			token = nextToken();
 117 | 			TreeNode* term_prime_node = term_prime();
 118 | 			if (term_prime_node != NULL)
 119 | 			{
 120 | 				TreeNode* myroot = new TreeNode("term_prime");
 121 | 				myroot->childs.push_back(MULOP_node);
 122 | 				myroot->childs.push_back(factor_node);
 123 | 				myroot->childs.push_back(term_prime_node);
 124 | 				return myroot;
 125 | 			}
 126 | 		}
 127 | 	}
 128 | 	else
 129 | 	{
 130 | 		see_epsilon = true;
 131 | 		TreeNode* epsilon_node = new TreeNode(EPSILON + "");
 132 | 		TreeNode* myroot = new TreeNode();
 133 | 		myroot->childs.push_back(epsilon_node);
 134 | 		return myroot;
 135 | 	}
 136 | 	Error();
 137 | 	return NULL;
 138 | }
 139 | 
 140 | TreeNode* Parser::term()
 141 | {
 142 | 	TreeNode* factor_node = factor();
 143 | 	if (factor_node != NULL)
 144 | 	{
 145 | 		token = nextToken();
 146 | 		TreeNode* term_node = term_prime();
 147 | 		if (term_node != NULL)
 148 | 		{
 149 | 			TreeNode* myroot = new TreeNode("term");
 150 | 			myroot->childs.push_back(factor_node);
 151 | 			myroot->childs.push_back(term_node);
 152 | 			return myroot;
 153 | 		}
 154 | 	}
 155 | 	Error();
 156 | 	return NULL;
 157 | }
 158 | 
 159 | TreeNode* Parser::simple_expression_prime()
 160 | {
 161 | 	if (token.type == "ADDOP")
 162 | 	{
 163 | 		TreeNode* ADDOP_node = new TreeNode(token.value);
 164 | 		token = nextToken();
 165 | 		TreeNode* term_node = term();
 166 | 		if (term_node != NULL)
 167 | 		{
 168 | 			token = nextToken();
 169 | 			TreeNode* simple_expression_prime_node = simple_expression_prime();
 170 | 			if (simple_expression_prime_node != NULL)
 171 | 			{
 172 | 				TreeNode* myroot = new TreeNode("simple_expression_prime");
 173 | 				myroot->childs.push_back(ADDOP_node);
 174 | 				myroot->childs.push_back(term_node);
 175 | 				myroot->childs.push_back(simple_expression_prime_node);
 176 | 				return myroot;
 177 | 			}
 178 | 		}
 179 | 	}
 180 | 	else
 181 | 	{
 182 | 		see_epsilon = true;
 183 | 		TreeNode* epsilon_node = new TreeNode(EPSILON + "");
 184 | 		TreeNode* myroot = new TreeNode();
 185 | 		myroot->childs.push_back(epsilon_node);
 186 | 		return myroot;
 187 | 	}
 188 | 	Error();
 189 | 	return NULL;
 190 | }
 191 | 
 192 | TreeNode* Parser::simple_expression()
 193 | {
 194 | 	if (token.value == "+" || token.value == "-")
 195 | 	{
 196 | 		TreeNode* sign_node = new TreeNode(token.value);
 197 | 		token = nextToken();
 198 | 		TreeNode* term_node = term();
 199 | 		if (term_node != NULL)
 200 | 		{
 201 | 			token = nextToken();
 202 | 			TreeNode* simple_expression_prime_node = simple_expression_prime();
 203 | 			if (simple_expression_prime_node != NULL)
 204 | 			{
 205 | 				TreeNode* myroot = new TreeNode("simple_expression");
 206 | 				myroot->childs.push_back(sign_node);
 207 | 				myroot->childs.push_back(term_node);
 208 | 				myroot->childs.push_back(simple_expression_prime_node);
 209 | 				return myroot;
 210 | 			}
 211 | 		}
 212 | 	}
 213 | 	else
 214 | 	{
 215 | 		TreeNode* term_node = term();
 216 | 		if (term_node != NULL)
 217 | 		{
 218 | 			token = nextToken();
 219 | 			TreeNode* simple_expression_prime_node = simple_expression_prime();
 220 | 			if (simple_expression_prime_node != NULL)
 221 | 			{
 222 | 				TreeNode* myroot = new TreeNode("simple_expression");
 223 | 				myroot->childs.push_back(term_node);
 224 | 				myroot->childs.push_back(simple_expression_prime_node);
 225 | 				return myroot;
 226 | 			}
 227 | 		}
 228 | 	}
 229 | 	Error();
 230 | 	return NULL;
 231 | }
 232 | 
 233 | TreeNode* Parser::expression_prime()
 234 | {
 235 | 	if (token.type == "RELOP")
 236 | 	{
 237 | 		TreeNode* RELOP_node = new TreeNode(token.value);
 238 | 		token = nextToken();
 239 | 		TreeNode* simple_expression_node = simple_expression();
 240 | 		if (simple_expression_node != NULL)
 241 | 		{
 242 | 			TreeNode* myroot = new TreeNode("expression_prime");
 243 | 			myroot->childs.push_back(RELOP_node);
 244 | 			myroot->childs.push_back(simple_expression_node);
 245 | 			return myroot;
 246 | 		}
 247 | 	}
 248 | 	else
 249 | 	{
 250 | 		see_epsilon = true;
 251 | 		TreeNode* epsilon_node = new TreeNode(EPSILON + "");
 252 | 		TreeNode* myroot = new TreeNode();
 253 | 		myroot->childs.push_back(epsilon_node);
 254 | 		return myroot;
 255 | 	}
 256 | 	Error();
 257 | 	return NULL;
 258 | }
 259 | 
 260 | TreeNode* Parser::expression()
 261 | {
 262 | 	TreeNode* simple_expression_node = simple_expression();
 263 | 	if (simple_expression_node != NULL)
 264 | 	{
 265 | 		token = nextToken();
 266 | 		TreeNode* expression_prime_node = expression_prime();
 267 | 		if (expression_prime_node != NULL)
 268 | 		{
 269 | 			TreeNode* myroot = new TreeNode("expression");
 270 | 			myroot->childs.push_back(simple_expression_node);
 271 | 			myroot->childs.push_back(expression_prime_node);
 272 | 			return myroot;
 273 | 		}
 274 | 	}
 275 | 	Error();
 276 | 	return NULL;
 277 | }
 278 | 
 279 | TreeNode* Parser::expression_list_prime()
 280 | {
 281 | 	if (token.value == ",")
 282 | 	{
 283 | 		TreeNode* comma_node = new TreeNode(token.value);
 284 | 		token = nextToken();
 285 | 		TreeNode* expression_node = expression();
 286 | 		if (expression_node != NULL)
 287 | 		{
 288 | 			token = nextToken();
 289 | 			TreeNode* expression_list_prime_node = expression_list_prime();
 290 | 			if (expression_list_prime_node != NULL)
 291 | 			{
 292 | 				TreeNode* myroot = new TreeNode("expression_list_prime");
 293 | 				myroot->childs.push_back(comma_node);
 294 | 				myroot->childs.push_back(expression_node);
 295 | 				myroot->childs.push_back(expression_list_prime_node);
 296 | 				return myroot;
 297 | 			}
 298 | 		}
 299 | 	}
 300 | 	else
 301 | 	{
 302 | 		see_epsilon = true;
 303 | 		TreeNode* epsilon_node = new TreeNode(EPSILON + "");
 304 | 		TreeNode* myroot = new TreeNode();
 305 | 		myroot->childs.push_back(epsilon_node);
 306 | 		return myroot;
 307 | 	}
 308 | 	Error();
 309 | 	return NULL;
 310 | }
 311 | 
 312 | TreeNode* Parser::expression_list()
 313 | {
 314 | 	TreeNode* expression_node = expression();
 315 | 	if (expression_node != NULL)
 316 | 	{
 317 | 		token = nextToken();
 318 | 		TreeNode* expression_list_prime_node = expression_list_prime();
 319 | 		if (expression_list_prime_node != NULL)
 320 | 		{
 321 | 			TreeNode* myroot = new TreeNode("expression_list");
 322 | 			myroot->childs.push_back(expression_node);
 323 | 			myroot->childs.push_back(expression_list_prime_node);
 324 | 			return myroot;
 325 | 		}
 326 | 	}
 327 | 	Error();
 328 | 	return NULL;
 329 | }
 330 | 
 331 | TreeNode* Parser::variable_prime()
 332 | {
 333 | 	if (token.value == "(")
 334 | 	{
 335 | 		TreeNode* parantez_open_node = new TreeNode(token.value);
 336 | 		token = nextToken();
 337 | 		TreeNode* expression_list_node = expression_list();
 338 | 		if (expression_list_node != NULL)
 339 | 		{
 340 | 			token = nextToken();
 341 | 			if (token.value == ")")
 342 | 			{
 343 | 				TreeNode* parantez_close_node = new TreeNode(token.value);
 344 | 				TreeNode* myroot = new TreeNode("variable_prime");
 345 | 				myroot->childs.push_back(parantez_open_node);
 346 | 				myroot->childs.push_back(expression_list_node);
 347 | 				myroot->childs.push_back(parantez_close_node);
 348 | 				return myroot;
 349 | 			}
 350 | 		}
 351 | 	}
 352 | 	else if (token.value == "[")
 353 | 	{
 354 | 		TreeNode* bracket_open_node = new TreeNode(token.value);
 355 | 		token = nextToken();
 356 | 		TreeNode* expression_node = expression();
 357 | 		if (expression_node != NULL)
 358 | 		{
 359 | 			token = nextToken();
 360 | 			if (token.value == "]")
 361 | 			{
 362 | 				TreeNode* bracket_close_node = new TreeNode(token.value);
 363 | 				TreeNode* myroot = new TreeNode("variable_prime");
 364 | 				myroot->childs.push_back(bracket_open_node);
 365 | 				myroot->childs.push_back(expression_node);
 366 | 				myroot->childs.push_back(bracket_close_node);
 367 | 				return myroot;
 368 | 			}
 369 | 		}
 370 | 	}
 371 | 	else
 372 | 	{
 373 | 		see_epsilon = true;
 374 | 		TreeNode* epsilon_node = new TreeNode(EPSILON + "");
 375 | 		TreeNode* myroot = new TreeNode();
 376 | 		myroot->childs.push_back(epsilon_node);
 377 | 		return myroot;
 378 | 	}
 379 | 	Error();
 380 | 	return NULL;
 381 | }
 382 | 
 383 | TreeNode* Parser::variable()
 384 | {
 385 | 	if (token.type == "IDENTIFIER")
 386 | 	{
 387 | 		TreeNode* IDENTIFIER_node = new TreeNode(token.value);
 388 | 		token = nextToken();
 389 | 		TreeNode* variable_prime_node = variable_prime();
 390 | 		TreeNode* myroot = new TreeNode("variable");
 391 | 		myroot->childs.push_back(IDENTIFIER_node);
 392 | 		myroot->childs.push_back(variable_prime_node);
 393 | 		return myroot;
 394 | 	}
 395 | 	Error();
 396 | 	return NULL;
 397 | }
 398 | 
 399 | TreeNode* Parser::elementary_statement_prime()
 400 | {
 401 | 	if (token.type == "ASSIGNOP")
 402 | 	{
 403 | 		TreeNode* ASSIGNOP_node = new TreeNode(token.value);
 404 | 		token = nextToken();
 405 | 		TreeNode* expression_node = expression();
 406 | 		if (expression_node != NULL)
 407 | 		{
 408 | 			TreeNode* myroot = new TreeNode("elementary_statement_prime");
 409 | 			myroot->childs.push_back(ASSIGNOP_node);
 410 | 			myroot->childs.push_back(expression_node);
 411 | 			return myroot;
 412 | 		}
 413 | 	}
 414 | 	else
 415 | 	{
 416 | 		see_epsilon = true;
 417 | 		TreeNode* epsilon_node = new TreeNode(EPSILON + "");
 418 | 		TreeNode* myroot = new TreeNode("elementary_statement_prime");
 419 | 		myroot->childs.push_back(epsilon_node);
 420 | 		return myroot;
 421 | 	}
 422 | 	Error();
 423 | 	return NULL;
 424 | }
 425 | 
 426 | TreeNode* Parser::elementary_statement()
 427 | {
 428 | 	TreeNode* variable_node = variable();
 429 | 	if (variable_node != NULL)
 430 | 	{
 431 | 		token = nextToken();
 432 | 		TreeNode* elementary_statement_prime_node = elementary_statement_prime();
 433 | 		if (elementary_statement_prime_node != NULL)
 434 | 		{
 435 | 			TreeNode* myroot = new TreeNode("elementary_statement");
 436 | 			myroot->childs.push_back(variable_node);
 437 | 			myroot->childs.push_back(elementary_statement_prime_node);
 438 | 			return myroot;
 439 | 		}
 440 | 	}
 441 | 	else
 442 | 	{
 443 | 		TreeNode* compound_statement_node = compound_statement();
 444 | 		if (compound_statement_node != NULL)
 445 | 		{
 446 | 			TreeNode* myroot = new TreeNode("elementary_statement");
 447 | 			myroot->childs.push_back(compound_statement_node);
 448 | 			return myroot;
 449 | 		}
 450 | 	}
 451 | 	Error();
 452 | 	return NULL;
 453 | }
 454 | 
 455 | TreeNode* Parser::restricted_statement()
 456 | {
 457 | 	if (token.value == "if")
 458 | 	{
 459 | 		TreeNode* if_node = new TreeNode(token.value);
 460 | 		token = nextToken();
 461 | 		TreeNode* expression_node = expression();
 462 | 		if (expression_node != NULL)
 463 | 		{
 464 | 			token = nextToken();
 465 | 			if (token.value == "then")
 466 | 			{
 467 | 				TreeNode* then_node = new TreeNode(token.value);
 468 | 				token = nextToken();
 469 | 				TreeNode* restricted_statement_node = restricted_statement();
 470 | 				if (restricted_statement_node != NULL)
 471 | 				{
 472 | 					token = nextToken();
 473 | 					if (token.value == "else")
 474 | 					{
 475 | 						TreeNode* else_node = new TreeNode(token.value);
 476 | 						token = nextToken();
 477 | 						TreeNode* restricted_statement2_node = restricted_statement();
 478 | 						if (restricted_statement2_node != NULL)
 479 | 						{
 480 | 							TreeNode* myroot = new TreeNode("restricted_statement");
 481 | 							myroot->childs.push_back(if_node);
 482 | 							myroot->childs.push_back(expression_node);
 483 | 							myroot->childs.push_back(then_node);
 484 | 							myroot->childs.push_back(restricted_statement_node);
 485 | 							myroot->childs.push_back(else_node);
 486 | 							myroot->childs.push_back(restricted_statement2_node);
 487 | 							return myroot;
 488 | 						}
 489 | 					}
 490 | 				}
 491 | 			}
 492 | 		}
 493 | 	}
 494 | 	else if (token.value == "while")
 495 | 	{
 496 | 		TreeNode* while_node = new TreeNode(token.value);
 497 | 		token = nextToken();
 498 | 		TreeNode* expression_node = expression();
 499 | 		if (expression_node != NULL)
 500 | 		{
 501 | 			token = nextToken();
 502 | 			if (token.value == "do")
 503 | 			{
 504 | 				TreeNode* do_node = new TreeNode(token.value);
 505 | 				token = nextToken();
 506 | 				TreeNode* restricted_statement_node = restricted_statement();
 507 | 				if (restricted_statement_node != NULL)
 508 | 				{
 509 | 					TreeNode* myroot = new TreeNode("restricted_statement");
 510 | 					myroot->childs.push_back(while_node);
 511 | 					myroot->childs.push_back(expression_node);
 512 | 					myroot->childs.push_back(do_node);
 513 | 					myroot->childs.push_back(restricted_statement_node);
 514 | 					return myroot;
 515 | 				}
 516 | 			}
 517 | 		}
 518 | 	}
 519 | 	else
 520 | 	{
 521 | 		TreeNode* elementary_statement_node = elementary_statement();
 522 | 		if (elementary_statement_node != NULL)
 523 | 		{
 524 | 			TreeNode* myroot = new TreeNode("restricted_statement");
 525 | 			myroot->childs.push_back(elementary_statement_node);
 526 | 			return myroot;
 527 | 		}
 528 | 	}
 529 | 	Error();
 530 | 	return NULL;
 531 | }
 532 | 
 533 | TreeNode* Parser::statement_prime()
 534 | {
 535 | 	TreeNode* restricted_statement_node = restricted_statement();
 536 | 	if (restricted_statement_node != NULL)
 537 | 	{
 538 | 		token = nextToken();
 539 | 		if (token.value == "else")
 540 | 		{
 541 | 			TreeNode* else_node = new TreeNode(token.value);
 542 | 			token = nextToken();
 543 | 			TreeNode* statement_node = statement();
 544 | 			if (statement_node != NULL)
 545 | 			{
 546 | 				TreeNode* myroot = new TreeNode("statement_prime");
 547 | 				myroot->childs.push_back(restricted_statement_node);
 548 | 				myroot->childs.push_back(else_node);
 549 | 				myroot->childs.push_back(statement_node);
 550 | 				return myroot;
 551 | 			}
 552 | 		}
 553 | 	}
 554 | 	else
 555 | 	{
 556 | 		TreeNode* statement_node = statement();
 557 | 		if (statement_node != NULL)
 558 | 		{
 559 | 			TreeNode* myroot = new TreeNode();
 560 | 			myroot->childs.push_back(statement_node);
 561 | 			return myroot;
 562 | 		}
 563 | 	}
 564 | 	Error();
 565 | 	return NULL;
 566 | }
 567 | 
 568 | TreeNode* Parser::statement()
 569 | {
 570 | 	if (token.value == "if")
 571 | 	{
 572 | 		TreeNode* if_node = new TreeNode(token.value);
 573 | 		token = nextToken();
 574 | 		TreeNode* expression_node = expression();
 575 | 		if (expression_node != NULL)
 576 | 		{
 577 | 			token = nextToken();
 578 | 			if (token.value == "then")
 579 | 			{
 580 | 				TreeNode* then_node = new TreeNode(token.value);
 581 | 				token = nextToken();
 582 | 				TreeNode* statement_prime_node = statement_prime();
 583 | 				if (statement_prime_node != NULL)
 584 | 				{
 585 | 					TreeNode* myroot = new TreeNode("statement");
 586 | 					myroot->childs.push_back(if_node);
 587 | 					myroot->childs.push_back(expression_node);
 588 | 					myroot->childs.push_back(then_node);
 589 | 					myroot->childs.push_back(statement_prime_node);
 590 | 					return myroot;
 591 | 				}
 592 | 			}
 593 | 		}
 594 | 	}
 595 | 	else if (token.value == "while")
 596 | 	{
 597 | 		TreeNode* while_node = new TreeNode(token.value);
 598 | 		token = nextToken();
 599 | 		TreeNode* expression_node = expression();
 600 | 		if (expression_node != NULL)
 601 | 		{
 602 | 			token = nextToken();
 603 | 			if (token.value == "do")
 604 | 			{
 605 | 				TreeNode* do_node = new TreeNode(token.value);
 606 | 				token = nextToken();
 607 | 				TreeNode* statement_node = statement();
 608 | 				if (statement_node != NULL)
 609 | 				{
 610 | 					TreeNode* myroot = new TreeNode("statement");
 611 | 					myroot->childs.push_back(while_node);
 612 | 					myroot->childs.push_back(expression_node);
 613 | 					myroot->childs.push_back(do_node);
 614 | 					myroot->childs.push_back(statement_node);
 615 | 					return myroot;
 616 | 				}
 617 | 			}
 618 | 		}
 619 | 	}
 620 | 	else
 621 | 	{
 622 | 		TreeNode* elementary_statement_node = elementary_statement();
 623 | 		if (elementary_statement_node != NULL)
 624 | 		{
 625 | 			TreeNode* myroot = new TreeNode("statement");
 626 | 			myroot->childs.push_back(elementary_statement_node);
 627 | 			return myroot;
 628 | 		}
 629 | 	}
 630 | 	Error();
 631 | 	return NULL;
 632 | }
 633 | 
 634 | TreeNode* Parser::statement_list_prime()
 635 | {
 636 | 	if (token.value == ";")
 637 | 	{
 638 | 		TreeNode* semicolon_node = new TreeNode(token.value);
 639 | 		token = nextToken();
 640 | 		TreeNode* statement_node = statement();
 641 | 		if (statement_node != NULL)
 642 | 		{
 643 | 			TreeNode* myroot = new TreeNode("statement_list_prime");
 644 | 			myroot->childs.push_back(semicolon_node);
 645 | 			myroot->childs.push_back(statement_node);
 646 | 			return myroot;
 647 | 		}
 648 | 	}
 649 | 	else
 650 | 	{
 651 | 		see_epsilon = true;
 652 | 		TreeNode* epsilon_node = new TreeNode(EPSILON + "");
 653 | 		TreeNode* myroot = new TreeNode();
 654 | 		myroot->childs.push_back(epsilon_node);
 655 | 		return myroot;
 656 | 	}
 657 | 	Error();
 658 | 	return NULL;
 659 | }
 660 | 
 661 | TreeNode* Parser::statement_list()
 662 | {
 663 | 	TreeNode* statement_node = statement();
 664 | 	if (statement_node != NULL)
 665 | 	{
 666 | 		token = nextToken();
 667 | 		TreeNode* statement_list_prime_node = statement_list_prime();
 668 | 		if (statement_list_prime_node != NULL)
 669 | 		{
 670 | 			TreeNode* myroot = new TreeNode("statement_list");
 671 | 			myroot->childs.push_back(statement_node);
 672 | 			myroot->childs.push_back(statement_list_prime_node);
 673 | 			return myroot;
 674 | 		}
 675 | 	}
 676 | 	Error();
 677 | 	return NULL;
 678 | }
 679 | 
 680 | TreeNode* Parser::compound_statement()
 681 | {
 682 | 	if (token.value == "begin")
 683 | 	{
 684 | 		TreeNode* begin_node = new TreeNode(token.value);
 685 | 		token = nextToken();
 686 | 		TreeNode* statement_list_node = statement_list();
 687 | 		if (statement_list_node != NULL)
 688 | 		{
 689 | 			token = nextToken();
 690 | 			if (token.value == "end")
 691 | 			{
 692 | 				TreeNode* end_node = new TreeNode(token.value);
 693 | 				TreeNode* myroot = new TreeNode("compound_statement");
 694 | 				myroot->childs.push_back(begin_node);
 695 | 				myroot->childs.push_back(statement_list_node);
 696 | 				myroot->childs.push_back(end_node);
 697 | 				return myroot;
 698 | 			}
 699 | 		}
 700 | 	}
 701 | 	Error();
 702 | 	return NULL;
 703 | }
 704 | 
 705 | TreeNode* Parser::parameter_list_prime()
 706 | {
 707 | 	if (token.value == ";")
 708 | 	{
 709 | 		TreeNode* semicolon_node = new TreeNode(token.value);
 710 | 		token = nextToken();
 711 | 		TreeNode* identifier_list_node = identifier_list();
 712 | 		if (identifier_list_node != NULL)
 713 | 		{
 714 | 			token = nextToken();
 715 | 			if (token.value == ":")
 716 | 			{
 717 | 				TreeNode* colon_node = new TreeNode(token.value);
 718 | 				token = nextToken();
 719 | 				TreeNode* type_node = type();
 720 | 				if (type_node != NULL)
 721 | 				{
 722 | 					token = nextToken();
 723 | 					TreeNode* parameter_list_prime_node = parameter_list_prime();
 724 | 					if (parameter_list_prime_node != NULL)
 725 | 					{
 726 | 						TreeNode* myroot = new TreeNode("parameter_list_prime");
 727 | 						myroot->childs.push_back(semicolon_node);
 728 | 						myroot->childs.push_back(identifier_list_node);
 729 | 						myroot->childs.push_back(colon_node);
 730 | 						myroot->childs.push_back(type_node);
 731 | 						myroot->childs.push_back(parameter_list_prime_node);
 732 | 						return myroot;
 733 | 					}
 734 | 				}
 735 | 			}
 736 | 		}
 737 | 	}
 738 | 	else
 739 | 	{
 740 | 		see_epsilon = true;
 741 | 		TreeNode* epsilon_node = new TreeNode(EPSILON + "");
 742 | 		TreeNode* myroot = new TreeNode();
 743 | 		myroot->childs.push_back(epsilon_node);
 744 | 		return myroot;
 745 | 	}
 746 | 	Error();
 747 | 	return NULL;
 748 | }
 749 | 
 750 | TreeNode* Parser::parameter_list()
 751 | {
 752 | 	TreeNode* identifier_list_node = identifier_list();
 753 | 	if (identifier_list_node != NULL)
 754 | 	{
 755 | 		token = nextToken();
 756 | 		if (token.value == ":")
 757 | 		{
 758 | 			TreeNode* colon_node = new TreeNode(token.value);
 759 | 			token = nextToken();
 760 | 			TreeNode* type_node = type();
 761 | 			if (type_node != NULL)
 762 | 			{
 763 | 				token = nextToken();
 764 | 				TreeNode* parameter_list_prime_node = parameter_list_prime();
 765 | 				if (parameter_list_prime_node != NULL)
 766 | 				{
 767 | 					TreeNode* myroot = new TreeNode("parameter_list");
 768 | 					myroot->childs.push_back(identifier_list_node);
 769 | 					myroot->childs.push_back(colon_node);
 770 | 					myroot->childs.push_back(type_node);
 771 | 					myroot->childs.push_back(parameter_list_prime_node);
 772 | 					return myroot;
 773 | 				}
 774 | 			}
 775 | 		}
 776 | 	}
 777 | 	Error();
 778 | 	return NULL;
 779 | }
 780 | 
 781 | TreeNode* Parser::argumenrs()
 782 | {
 783 | 	if (token.value == "(")
 784 | 	{
 785 | 		TreeNode* parantez_open_node = new TreeNode(token.value);
 786 | 		token = nextToken();
 787 | 		TreeNode* parameter_list_node = parameter_list();
 788 | 		if (parameter_list_node != NULL)
 789 | 		{
 790 | 			token = nextToken();
 791 | 			if (token.value == ")")
 792 | 			{
 793 | 				TreeNode* parantez_close_node = new TreeNode(token.value);
 794 | 				TreeNode* myroot = new TreeNode("argumenrs");
 795 | 				myroot->childs.push_back(parantez_open_node);
 796 | 				myroot->childs.push_back(parameter_list_node);
 797 | 				myroot->childs.push_back(parantez_close_node);
 798 | 				return myroot;
 799 | 			}
 800 | 		}
 801 | 	}
 802 | 	else
 803 | 	{
 804 | 		see_epsilon = true;
 805 | 		TreeNode* epsilon_node = new TreeNode(EPSILON + "");
 806 | 		TreeNode* myroot = new TreeNode();
 807 | 		myroot->childs.push_back(epsilon_node);
 808 | 		return myroot;
 809 | 	}
 810 | 	Error();
 811 | 	return NULL;
 812 | }
 813 | 
 814 | TreeNode* Parser::subprogram_head()
 815 | {
 816 | 	if (token.value == "function")
 817 | 	{
 818 | 		TreeNode* function_node = new TreeNode(token.value);
 819 | 		token = nextToken();
 820 | 		if (token.type == "IDENTIFIER")
 821 | 		{
 822 | 			TreeNode* IDENTIFIER_node = new TreeNode(token.value);
 823 | 			token = nextToken();
 824 | 			TreeNode* argumenrs_node = argumenrs();
 825 | 			if (argumenrs_node != NULL)
 826 | 			{
 827 | 				token = nextToken();
 828 | 				if (token.value == ":")
 829 | 				{
 830 | 					TreeNode* colon_node = new TreeNode(token.value);
 831 | 					token = nextToken();
 832 | 					if (token.value == "result")
 833 | 					{
 834 | 						TreeNode* result_node = new TreeNode(token.value);
 835 | 						token = nextToken();
 836 | 						TreeNode* standard_type_node = standard_type();
 837 | 						if (standard_type_node != NULL)
 838 | 						{
 839 | 							token = nextToken();
 840 | 							if (token.value == ";")
 841 | 							{
 842 | 								TreeNode* semicolon_node = new TreeNode(token.value);
 843 | 								TreeNode* myroot = new TreeNode("subprogram_head");
 844 | 								myroot->childs.push_back(function_node);
 845 | 								myroot->childs.push_back(IDENTIFIER_node);
 846 | 								myroot->childs.push_back(argumenrs_node);
 847 | 								myroot->childs.push_back(colon_node);
 848 | 								myroot->childs.push_back(result_node);
 849 | 								myroot->childs.push_back(standard_type_node);
 850 | 								myroot->childs.push_back(semicolon_node);
 851 | 								return myroot;
 852 | 							}
 853 | 						}
 854 | 					}
 855 | 				}
 856 | 			}
 857 | 		}
 858 | 	}
 859 | 	else if (token.value == "procedure")
 860 | 	{
 861 | 		TreeNode* procedure_node = new TreeNode(token.value);
 862 | 		token = nextToken();
 863 | 		if (token.type == "IDENTIFIER")
 864 | 		{
 865 | 			TreeNode* IDENTIFIER_node = new TreeNode(token.value);
 866 | 			token = nextToken();
 867 | 			TreeNode* argumenrs_node = argumenrs();
 868 | 			if (argumenrs_node != NULL)
 869 | 			{
 870 | 				token = nextToken();
 871 | 				if (token.value == ";")
 872 | 				{
 873 | 					TreeNode* semicolon_node = new TreeNode(token.value);
 874 | 					TreeNode* myroot = new TreeNode("subprogram_head");
 875 | 					myroot->childs.push_back(procedure_node);
 876 | 					myroot->childs.push_back(IDENTIFIER_node);
 877 | 					myroot->childs.push_back(argumenrs_node);
 878 | 					myroot->childs.push_back(semicolon_node);
 879 | 					return myroot;
 880 | 				}
 881 | 			}
 882 | 		}
 883 | 	}
 884 | 	else
 885 | 	{
 886 | 		return NULL;
 887 | 	}
 888 | 	Error();
 889 | 	return NULL;
 890 | }
 891 | 
 892 | TreeNode* Parser::subprogram_declaration()
 893 | {
 894 | 	TreeNode* subprogram_head_node = subprogram_head();
 895 | 	if (subprogram_head_node != NULL)
 896 | 	{
 897 | 		token = nextToken();
 898 | 		TreeNode* declarations_node = declarations();
 899 | 		if (declarations_node != NULL)
 900 | 		{
 901 | 			token = nextToken();
 902 | 			TreeNode* compound_statement_node = compound_statement();
 903 | 			if (compound_statement_node != NULL)
 904 | 			{
 905 | 				TreeNode* myroot = new TreeNode("subprogram_declaration");
 906 | 				myroot->childs.push_back(subprogram_head_node);
 907 | 				myroot->childs.push_back(declarations_node);
 908 | 				myroot->childs.push_back(compound_statement_node);
 909 | 				return myroot;
 910 | 			}
 911 | 		}
 912 | 	}
 913 | 	else
 914 | 	{
 915 | 		return NULL;
 916 | 	}
 917 | 	Error();
 918 | 	return NULL;
 919 | }
 920 | 
 921 | TreeNode* Parser::subprogram_declarations()
 922 | {
 923 | 	TreeNode* subprogram_declaration_node = subprogram_declaration();
 924 | 	if (subprogram_declaration_node != NULL)
 925 | 	{
 926 | 		token = nextToken();
 927 | 		TreeNode* subprogram_declarations_node = subprogram_declarations();
 928 | 		if (subprogram_declarations_node != NULL)
 929 | 		{
 930 | 			TreeNode* myroot = new TreeNode("subprogram_declarations");
 931 | 			myroot->childs.push_back(subprogram_declaration_node);
 932 | 			myroot->childs.push_back(subprogram_declarations_node);
 933 | 			return myroot;
 934 | 		}
 935 | 	}
 936 | 	else
 937 | 	{
 938 | 		see_epsilon = true;
 939 | 		TreeNode* epsilon_node = new TreeNode(EPSILON + "");
 940 | 		TreeNode* myroot = new TreeNode();
 941 | 		myroot->childs.push_back(epsilon_node);
 942 | 		return myroot;
 943 | 	}
 944 | 	Error();
 945 | 	return NULL;
 946 | }
 947 | 
 948 | TreeNode* Parser::array_type()
 949 | {
 950 | 	if (token.value == "array")
 951 | 	{
 952 | 		TreeNode* array_node = new TreeNode(token.value);
 953 | 		token = nextToken();
 954 | 		if (token.value == "[")
 955 | 		{
 956 | 			TreeNode* bracket_open_node = new TreeNode(token.value);
 957 | 			token = nextToken();
 958 | 			if (token.type == "CONSTANT")
 959 | 			{
 960 | 				TreeNode* CONSTANT_node = new TreeNode(token.value);
 961 | 				token = nextToken();
 962 | 				if (token.value == "..")
 963 | 				{
 964 | 					TreeNode* dot_dot_node = new TreeNode(token.value);
 965 | 					token = nextToken();
 966 | 					if (token.type == "CONSTANT")
 967 | 					{
 968 | 						TreeNode* CONSTANT2_node = new TreeNode(token.value);
 969 | 						token = nextToken();
 970 | 						if (token.value == "]")
 971 | 						{
 972 | 							TreeNode* bracket_close_node = new TreeNode(token.value);
 973 | 							token = nextToken();
 974 | 							if (token.value == "of")
 975 | 							{
 976 | 								TreeNode* of_node = new TreeNode(token.value);
 977 | 								token = nextToken();
 978 | 								TreeNode* standard_type_node = standard_type();
 979 | 								if (standard_type_node != NULL)
 980 | 								{
 981 | 									TreeNode* myroot = new TreeNode("array_type");
 982 | 									myroot->childs.push_back(array_node);
 983 | 									myroot->childs.push_back(bracket_open_node);
 984 | 									myroot->childs.push_back(CONSTANT_node);
 985 | 									myroot->childs.push_back(dot_dot_node);
 986 | 									myroot->childs.push_back(CONSTANT2_node);
 987 | 									myroot->childs.push_back(of_node);
 988 | 									myroot->childs.push_back(standard_type_node);
 989 | 									return myroot;
 990 | 								}
 991 | 							}
 992 | 						}
 993 | 					}
 994 | 				}
 995 | 			}
 996 | 		}
 997 | 	}
 998 | 	Error();
 999 | 	return NULL;
1000 | }
1001 | 
1002 | TreeNode* Parser::standard_type()
1003 | {
1004 | 	if (token.value == "integer")
1005 | 	{
1006 | 		TreeNode* integer_node = new TreeNode(token.value);
1007 | 		TreeNode* myroot = new TreeNode("standard_type");
1008 | 		myroot->childs.push_back(integer_node);
1009 | 		return myroot;
1010 | 	}
1011 | 	else if (token.value == "real")
1012 | 	{
1013 | 		TreeNode* real_node = new TreeNode(token.value);
1014 | 		TreeNode* myroot = new TreeNode("standard_type");
1015 | 		myroot->childs.push_back(real_node);
1016 | 		return myroot;
1017 | 	}
1018 | 	Error();
1019 | 	return NULL;
1020 | }
1021 | 
1022 | TreeNode* Parser::type()
1023 | {
1024 | 	TreeNode* standard_type_node = standard_type();
1025 | 	if (standard_type_node != NULL)
1026 | 	{
1027 | 		TreeNode* myroot = new TreeNode("type");
1028 | 		myroot->childs.push_back(standard_type_node);
1029 | 		return myroot;
1030 | 	}
1031 | 	else
1032 | 	{
1033 | 		TreeNode* array_type_node = array_type();
1034 | 		if (array_type_node != NULL)
1035 | 		{
1036 | 			TreeNode* myroot = new TreeNode("type");
1037 | 			myroot->childs.push_back(array_type_node);
1038 | 			return myroot;
1039 | 		}
1040 | 	}
1041 | 	Error();
1042 | 	return NULL;
1043 | }
1044 | 
1045 | TreeNode* Parser::declaration_list_prime()
1046 | {
1047 | 	TreeNode* identifier_list_node = identifier_list();
1048 | 	if (identifier_list_node != NULL)
1049 | 	{
1050 | 		if (token.value == ":")
1051 | 		{
1052 | 			TreeNode* colon_node = new TreeNode(token.value);
1053 | 			token = nextToken();
1054 | 			TreeNode* type_node = type();
1055 | 			if (type_node != NULL)
1056 | 			{
1057 | 				token = nextToken();
1058 | 				if (token.value == ";")
1059 | 				{
1060 | 					TreeNode* semicolon_node = new TreeNode(token.value);
1061 | 					token = nextToken();
1062 | 					TreeNode* declaration_list_prime_node = declaration_list_prime();
1063 | 					if (declaration_list_prime_node != NULL)
1064 | 					{
1065 | 						TreeNode* myroot = new TreeNode("declaration_list_prime");
1066 | 						myroot->childs.push_back(identifier_list_node);
1067 | 						myroot->childs.push_back(colon_node);
1068 | 						myroot->childs.push_back(type_node);
1069 | 						myroot->childs.push_back(semicolon_node);
1070 | 						myroot->childs.push_back(declaration_list_prime_node);
1071 | 						return myroot;
1072 | 					}
1073 | 				}
1074 | 			}
1075 | 		}
1076 | 	}
1077 | 	else
1078 | 	{
1079 | 		see_epsilon = true;
1080 | 		TreeNode* epsilon_node = new TreeNode(EPSILON + "");
1081 | 		TreeNode* myroot = new TreeNode();
1082 | 		myroot->childs.push_back(epsilon_node);
1083 | 		return myroot;
1084 | 	}
1085 | 	Error();
1086 | 	return NULL;
1087 | }
1088 | 
1089 | TreeNode* Parser::declaration_list()
1090 | {
1091 | 	TreeNode* identifier_list_node = identifier_list();
1092 | 	if (identifier_list_node != NULL)
1093 | 	{
1094 | 		token = nextToken();
1095 | 		if (token.value == ":")
1096 | 		{
1097 | 			TreeNode* colon_node = new TreeNode(token.value);
1098 | 			token = nextToken();
1099 | 			TreeNode* type_node = type();
1100 | 			if (type_node != NULL)
1101 | 			{
1102 | 				token = nextToken();
1103 | 				if (token.value == ";")
1104 | 				{
1105 | 					TreeNode* semicolon_node = new TreeNode(token.value);
1106 | 					token = nextToken();
1107 | 					TreeNode* declaration_list_prime_node = declaration_list_prime();
1108 | 					if (declaration_list_prime_node != NULL)
1109 | 					{
1110 | 						TreeNode* myroot = new TreeNode("declaration_list");
1111 | 						myroot->childs.push_back(identifier_list_node);
1112 | 						myroot->childs.push_back(colon_node);
1113 | 						myroot->childs.push_back(type_node);
1114 | 						myroot->childs.push_back(semicolon_node);
1115 | 						myroot->childs.push_back(declaration_list_prime_node);
1116 | 						return myroot;
1117 | 					}
1118 | 				}
1119 | 			}
1120 | 		}
1121 | 	}
1122 | 	Error();
1123 | 	return NULL;
1124 | }
1125 | 
1126 | TreeNode* Parser::declarations()
1127 | {
1128 | 	if (token.value == "var")
1129 | 	{
1130 | 		TreeNode* var_node = new TreeNode(token.value);
1131 | 		token = nextToken();
1132 | 		TreeNode* declaration_list_node = declaration_list();
1133 | 		if (declaration_list_node != NULL)
1134 | 		{
1135 | 			TreeNode* myroot = new TreeNode("declarations");
1136 | 			myroot->childs.push_back(var_node);
1137 | 			myroot->childs.push_back(declaration_list_node);
1138 | 			return myroot;
1139 | 		}
1140 | 	}
1141 | 	else
1142 | 	{
1143 | 		see_epsilon = true;
1144 | 		TreeNode* epsilon_node = new TreeNode(EPSILON + "");
1145 | 		TreeNode* myroot = new TreeNode();
1146 | 		myroot->childs.push_back(epsilon_node);
1147 | 		return myroot;
1148 | 	}
1149 | 	Error();
1150 | 	return NULL;
1151 | }
1152 | 
1153 | TreeNode* Parser::identifier_list_prime()
1154 | {
1155 | 	if (token.value == ",")
1156 | 	{
1157 | 		TreeNode* comma_node = new TreeNode(token.value);
1158 | 		token = nextToken();
1159 | 		if (token.type == "IDENTIFIER")
1160 | 		{
1161 | 			TreeNode* IDENTIFIER_node = new TreeNode(token.value);
1162 | 			token = nextToken();
1163 | 			TreeNode* identifier_list_prime_node = identifier_list_prime();
1164 | 			if (identifier_list_prime_node != NULL)
1165 | 			{
1166 | 				TreeNode* myroot = new TreeNode("identifier_list_prime");
1167 | 				myroot->childs.push_back(comma_node);
1168 | 				myroot->childs.push_back(IDENTIFIER_node);
1169 | 				myroot->childs.push_back(identifier_list_prime_node);
1170 | 				return myroot;
1171 | 			}
1172 | 		}
1173 | 	}
1174 | 	else
1175 | 	{
1176 | 		see_epsilon = true;
1177 | 		TreeNode* epsilon_node = new TreeNode(EPSILON + "");
1178 | 		TreeNode* myroot = new TreeNode();
1179 | 		myroot->childs.push_back(epsilon_node);
1180 | 		return myroot;
1181 | 	}
1182 | 	Error();
1183 | 	return NULL;
1184 | }
1185 | 
1186 | TreeNode* Parser::identifier_list()
1187 | {
1188 | 	if (token.type == "IDENTIFIER")
1189 | 	{
1190 | 		TreeNode* IDENTIFIER_node = new TreeNode(token.value);
1191 | 		token = nextToken();
1192 | 		TreeNode* identifier_list_prime_node = identifier_list_prime();
1193 | 		if (identifier_list_prime_node != NULL)
1194 | 		{
1195 | 			TreeNode* myroot = new TreeNode("identifier_list");
1196 | 			myroot->childs.push_back(IDENTIFIER_node);
1197 | 			myroot->childs.push_back(identifier_list_prime_node);
1198 | 			return myroot;
1199 | 		}
1200 | 	}
1201 | 	else
1202 | 	{
1203 | 		// Error();
1204 | 		return NULL;
1205 | 	}
1206 | }
1207 | 
1208 | TreeNode* Parser::program()
1209 | {
1210 | 	if (token.value == "program")
1211 | 	{
1212 | 		TreeNode* program_node = new TreeNode(token.value);
1213 | 		token = nextToken();
1214 | 		if (token.type == "IDENTIFIER")
1215 | 		{
1216 | 			TreeNode* IDENTIFIER_node = new TreeNode(token.value);
1217 | 			token = nextToken();
1218 | 			if (token.value == "(")
1219 | 			{
1220 | 				TreeNode* parantez_open_node = new TreeNode(token.value);
1221 | 				token = nextToken();
1222 | 				TreeNode* identifier_list_node = identifier_list();
1223 | 				if (identifier_list_node != NULL)
1224 | 				{
1225 | 					token = nextToken();
1226 | 					if (token.value == ")")
1227 | 					{
1228 | 						TreeNode* parantez_close_node = new TreeNode(token.value);
1229 | 						token = nextToken();
1230 | 						if (token.value == ";")
1231 | 						{
1232 | 							TreeNode* semicolon_node = new TreeNode(token.value);
1233 | 							token = nextToken();
1234 | 							TreeNode* declarations_node = declarations();
1235 | 							if (declarations_node != NULL)
1236 | 							{
1237 | 								token = nextToken();
1238 | 								TreeNode* subprogram_declarations_node = subprogram_declarations();
1239 | 
1240 | 								if (subprogram_declarations_node != NULL)
1241 | 								{
1242 | 									token = nextToken();
1243 | 									TreeNode* compound_statement_node = compound_statement();
1244 | 
1245 | 									if (compound_statement_node != NULL)
1246 | 									{
1247 | 										TreeNode* myroot = new TreeNode("program");
1248 | 										myroot->childs.push_back(program_node);
1249 | 										myroot->childs.push_back(IDENTIFIER_node);
1250 | 										myroot->childs.push_back(parantez_open_node);
1251 | 										myroot->childs.push_back(identifier_list_node);
1252 | 										myroot->childs.push_back(parantez_close_node);
1253 | 										myroot->childs.push_back(semicolon_node);
1254 | 										myroot->childs.push_back(declarations_node);
1255 | 										myroot->childs.push_back(subprogram_declarations_node);
1256 | 										myroot->childs.push_back(compound_statement_node);
1257 | 										return myroot;
1258 | 									}
1259 | 								}
1260 | 							}
1261 | 						}
1262 | 					}
1263 | 				}
1264 | 			}
1265 | 		}
1266 | 	}
1267 | 	Error();
1268 | 	return NULL;
1269 | }
1270 | 
1271 | void Parser::createHtmlTree(TreeNode* x)
1272 | {
1273 | 	html_tree += "<table border=\"1px\"><tr><td colspan=\"100%\">";
1274 | 	html_tree += x->data;
1275 | 	html_tree += "</td></tr>";
1276 | 	html_tree += "<tr>";
1277 | 
1278 | 	for(TreeNode* tree_node : x->childs) 
1279 | 	{
1280 | 		html_tree += "<td>";
1281 | 		createHtmlTree(tree_node);
1282 | 		html_tree += "</td>";
1283 | 	}
1284 | 	
1285 | 	html_tree += "</tr></table>";
1286 | }
1287 | 
1288 | void Parser::writeHtmlTreeToFile()
1289 | {
1290 | 	fstream f;
1291 | 	f.open("IO/output/tree.html", ios::out);
1292 | 
1293 | 	if (!f)
1294 | 	{
1295 | 		cout << "no file available\n";
1296 | 		system("pause");
1297 | 		exit(0);
1298 | 	}
1299 | 
1300 | 	html_tree = "<html><head></head><body>";
1301 | 	createHtmlTree(root);
1302 | 	html_tree += "</body></html>";
1303 | 
1304 | 	for (int i = 0; i < html_tree.size(); i++)
1305 | 	{
1306 | 		f << html_tree[i];
1307 | 	}
1308 | 
1309 | 	f.close();
1310 | }
1311 | 
1312 | char depth[2056];
1313 | int di = 0;
1314 | 
1315 | void Parser::printTree(TreeNode* x)
1316 | {
1317 | 	cout << x->data << endl;
1318 | 
1319 | 	for(TreeNode* tree_node : x->childs) 
1320 | 	{
1321 | 		cout << depth << " +--";
1322 | 
1323 | 		if (tree_node != x->childs.back()) // check if node is the last child
1324 | 		{
1325 | 			depth[di++] = ' ';
1326 | 			depth[di++] = '|';
1327 | 			depth[di++] = ' ';
1328 | 			depth[di] = 0;
1329 | 		}
1330 | 		else
1331 | 		{
1332 | 			depth[di++] = ' ';
1333 | 			depth[di++] = ' ';
1334 | 			depth[di++] = ' ';
1335 | 			depth[di] = 0;
1336 | 		}
1337 | 
1338 | 		printTree(tree_node);
1339 | 		depth[di -= 3] = 0;
1340 | 	}
1341 | }
1342 | 


--------------------------------------------------------------------------------