#ifndef SYN_DEF
 #define SYN_DEF


//------------------- SYNTAX ANALYZER Module --------------------//
//						  v 08 . 04 .  2007						 //
//																 //
//								MT								 //
//---------------------------------------------------------------//



//---------------------- Incudes 
#include "stdio.h"
#include "ctype.h"
#include "strings.h"
#include "../../ui/onerror.hpp"
#include "stack.hpp"

#include "lex.hpp"
#include "exec.hpp"
#include "sem.hpp"
//====================== Includes


//---------------------- Defines
#define INT_SIZE 10
#define LEX_OVER "lexems are over. \0"
//====================== Defines


enum type {t_var, t_var_array, t_not_var};

class CSyntax {
private:
	CError Error;
	CExecuter *exe;
	CStack<char> stack;

	Lexeme* begin, *prev, *current, *next;
	bool passed;

private:
		void ShowError(const char *message);
	
		void SetToBeginLex() {prev=NULL; current=begin; next=begin->next;};
		void BackLex() { next = current; current = prev; };
		void NextLex();
		bool Comp(char *s);

		bool IsO1HigherO2(char o1, char o2);

		
	//---
		type  sx_Identifier();
		type  sx_RobotData();

		void  sx_Expression();
			void  sx_Expression_And();
			void  sx_Expression_Or();
			void  sx_Expression_Bool();
			void  sx_Expression_Term();
			void  sx_Expression_Primary();

		void  sx_Statement();
			void  sx_Statement_Indetifier();
			void  sx_Statement_IfElse();
			void  sx_Statement_Cycle();
			void  sx_Statement_Goto();
			void  sx_Statement_Robot();
				void  sx_Statement_Robot_Print();

		void sx_Program();
	//===

	public:

		CSyntax(Lexeme* begin_lex, CExecuter *e) { 
			begin = begin_lex; SetToBeginLex(); 
			exe=e; passed = true; 
		};
		~CSyntax() {  };

		bool MakeAnalysis();
};



//---------------------- GRAMMER 

/*
<Program> ::= <statement>

<robot_commands> ::= [turn | auto | prod <expression> | 
					  sell <expression>, <expression> | buy <expression>, <expression>
					  print "<string>", <expression> {,<expression>}  ]

<statement> ::= 
	<identifier> [ '['<expression>']' ] := <expression> | 
	if (<expression>) <statement> [else <statement>] |
    goto <label> | <label> |
	'{' <statement> {;<statement>} '}' |
	<robot_commands>


<expression> ::= <and> {'&' <and>}

<and> ::= <or> {'|' <or>}
<or> ::= <bool> [ > |< |= ] <bool> ]
<bool> ::= <term> { [ +| - ] <term> }
<term> ::= <primary> {[ *| /| %] <primary>}

<primary> ::= 
	<identifier> [ '['<expression>']' ] | 
	<robot_data>{<robot_data>} |
	<integer_const> | 
	(<expression>) |

	-<primary> | 
	!<primary>
*/


//==============================


#endif