%{

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include "semantic_helper.hh"

#define MAX_ID_TABLE_NO 1024 

char* id_table[MAX_ID_TABLE_NO];

int id_table_no;

ErrorType* errors;

int maxErrorNo;

int errorNo;

int yylex();

int yywrap();

int yyerror(const char *str);

void yyrestart(FILE* file);

%}

%token

CONSTRNT PATTERN FLOWP COM

QUOTE THAN FROM UNTIL ON

%union

{

	int integer;

	double real;

	const char* string;

}

%token <integer> INTEGER

%token <integer> TIME

%token <real> 	REAL

%token <string> STRING

%token <integer> IS 

%token <integer> IN 

%token <integer> GREATER 

%token <integer> LESS 

%token <integer> NOT 

%token <integer> AND 

%token <integer> OR 

%token <integer> AT

%token <integer> COPX

%token <integer> ADEP

%token <integer> ADES

%token <integer> RWY

%token <integer> ROUTE

%token <integer> ATYP

%token <integer> FLVL

%token <integer> TAS

%token <integer> FRUL

%token <integer> FTYP

%token <integer> EQUIP

%token <integer> RFL

%token <integer> TRAVEL_TYPE

%token <integer> TIMESEP 

%token <integer> FL

%type <string> string

%type <string> pttrn

%type <string> flowp

%type <string> constrnt

%type <integer> int

%type <integer> string_array

%type <integer> int_array

%type <integer> int_pt

%type <integer> char_pt

%type <integer> string_pt

%type <integer> string_array_pt

%type <integer> char_array_pt

%type <integer> int_op

%type <integer> string_op

%type <integer> string_array_op

%type <integer> string_string_array_op

%type <integer> si_unit

%left OR

%left AND

%right NOT

%%

prog:			| prog rule {  }

				| error ')' { yyerrok; yyclearin;}				

;

rule:			pttrn 		{ if (!pattern($1)) printf("Error: %s\n", last_error()); }

				| constrnt 	{ if (!constraint($1)) printf("Error: %s\n", last_error()); }

				| flowp 	{ if (!flowpoint($1)) printf("Error: %s\n", last_error()); }

				| COM		{ comment(); }

;

flowp:			FLOWP STRING '(' flowp_entry ')'	{ $$ = $2; }

;

flowp_entry:	pttrn_lbl ':' constrnt_lbl					

;

pttrn_lbl:		STRING						{ if (!pattern_id($1)) printf("Error: %s\n", last_error()); }						

;

constrnt_lbl:	STRING	{ if (!constraint_id($1)) printf("Error: %s\n", last_error()); }

;

constrnt:		CONSTRNT STRING '(' cterm ')' 	{ $$ = $2; }

;

cterm:			TIMESEP AT string IS INTEGER si_unit		

				{ intpt_string_int_cterm(PT_TIMESEP, $3, $5 * $6, 0, 0, 0); }				

				| TIMESEP AT string_array IS INTEGER si_unit

				{ intpt_stringarray_int_cterm(PT_TIMESEP, $3, $5 * $6, 0, 0, 0); }		

				| TIMESEP AT string IS INTEGER si_unit FROM INTEGER UNTIL INTEGER	

				{ intpt_string_int_cterm(PT_TIMESEP, $3, $5 * $6, $8, $10, 0); }				

				| TIMESEP AT string_array IS INTEGER si_unit FROM INTEGER UNTIL INTEGER

				{ intpt_stringarray_int_cterm(PT_TIMESEP, $3, $5 * $6, $8, $10, 0); }		

				| TIMESEP AT string IS INTEGER si_unit AT FL int_array

				{ intpt_string_int_cterm(PT_TIMESEP, $3, $5 * $6, 0, 0, $9); }				

				| TIMESEP AT string_array IS INTEGER si_unit AT FL int_array

				{ intpt_stringarray_int_cterm(PT_TIMESEP, $3, $5 * $6, 0, 0, $9); }		

				| TIMESEP AT string IS INTEGER si_unit FROM INTEGER UNTIL INTEGER AT FL int_array	

				{ intpt_string_int_cterm(PT_TIMESEP, $3, $5 * $6, $8, $10, $13); }				

				| TIMESEP AT string_array IS INTEGER si_unit FROM INTEGER UNTIL INTEGER AT FL int_array

				{ intpt_stringarray_int_cterm(PT_TIMESEP, $3, $5 * $6, $8, $10, $13); }	

				| cterm AND cterm							

				{ and_term(); }

;

si_unit:		STRING	

				{ 

					if (!strcmp($1, "s")) { $$ = 1; }

					else if (!strcmp($1, "min")) { $$ = 60; }

				}

;

pttrn: 			PATTERN STRING '(' term ')'	{ $$ = $2; }

				| PATTERN '(' term ')'		{ $$ = get_pattern_id(); }

;

term:			int_pt int_op INTEGER	

				{ intpt_int_term($2, $1, $3); }	

				| char_pt string_op string

				{ charpt_char_term($2, $1, $3); }

				| string_pt string_op string

				{ stringpt_string_term($2, $1, $3); }

				| string_array_pt string_array_op string_array

				{ stringarraypt_stringarray_term($2, $1, $3); }	

				| string_array string_array_op string_array_pt

				{ 

					if ($2 == OT_IN_C)

					{

						$2 = OT_IN_P;

					}

					else if ($2 == OT_NOTIN_C)

					{

						$2 = OT_NOTIN_P;

					}

					stringarraypt_stringarray_term($2, $3, $1); 

				}			

				| string string_string_array_op string_array_pt

				{ 

					if ($2 == OT_IN_C)

					{

						$2 = OT_IN_P;

					}

					else if ($2 == OT_NOTIN_C)

					{

						$2 = OT_NOTIN_P;

					} 

					stringarraypt_string_term($2, $3, $1); 

				}		

				| string string_string_array_op char_array_pt

				{ 

					if ($2 == OT_IN_C)

					{

						$2 = OT_IN_P;

					}

					else if ($2 == OT_NOTIN_C)

					{

						$2 = OT_NOTIN_P;

					} 

					chararraypt_char_term($2, $3, $1); 

				}	

				| term OR term 		

				{ or_term(); }

				| term AND term

				{ and_term(); } 	

				| NOT term						

				| '(' term ')'				

;

int_op:			IS 				{ $$ = OT_IS; }	

				| IS NOT		{ $$ = OT_ISNOT; } 

				| GREATER THAN	{ $$ = OT_GREATER; }

				| LESS THAN		{ $$ = OT_LESS; }

;

string_op:		IS			{ $$ = OT_IS; }	

				| IS NOT	{ $$ = OT_ISNOT; } 

;

string_array_op:IS			{ $$ = OT_IS; }

				| IS NOT 	{ $$ = OT_ISNOT; } 

				| IN 		{ $$ = OT_IN_P; }

				| NOT IN	{ $$ = OT_NOTIN_P; }

;

string_string_array_op: IN 			{ $$ = OT_IN_P; }

						| NOT IN	{ $$ = OT_NOTIN_P; }

;

int_array:		'[' ints ']' { $$ = integer_array(); }

;

ints:			| ints ',' int

				| ints int

;

int:		INTEGER { integer($1); $$ = $1; }

; 

string_array:	'[' strings ']'	{ $$ = string_array(); }

;

strings:		| strings ',' string

				| strings string

;

int_pt:			TAS		{ $$ = PT_TAS; }			

;

char_pt:		FTYP		{ $$ = PT_FTYP; }

string_pt:		ADEP	{ $$ = PT_ADEP; }

				| ADES	{ $$ = PT_ADES; }

				| RWY 	{ $$ = PT_RWY; }

				| ATYP 	{ $$ = PT_ATYP; }

				| COPX	{ $$ = PT_COPX; }				

				| FRUL 	{ $$ = PT_FRUL; }				

				| RFL	{ $$ = PT_RFL; }

				| TRAVEL_TYPE { $$ = PT_TRAVEL_TYPE; }

;

string_array_pt:ROUTE	{ $$ = PT_ROUTE; }				

;

char_array_pt:	EQUIP	{ $$ = PT_EQUIP; }

;

string:			QUOTE STRING QUOTE	{ string($2); $$ = $2; }

;

%%

#include "atccl_parser.c"

void clear_id_table()

{

	int i;

	for (i = 0; i < id_table_no; ++i)

	{

		free(id_table[i]);

		id_table[i] = 0;

	}

	id_table_no = 0;

}

int yywrap()

{

	clear_id_table();

	return 1;

}

int semantic_error(const char* str)

{

	if (errorNo < maxErrorNo)

	{

		errors[errorNo].line = -1;

		strcpy(errors[errorNo].text, "");

		strcpy(errors[errorNo].error, str);		

		errorNo++;

	}		

	return 1;

}

int yyerror(const char *str)

{

	if (errorNo < maxErrorNo)

	{

		errors[errorNo].line = line_no;

		strcpy(errors[errorNo].text, yytext);

		strcpy(errors[errorNo].error, str);		

		errorNo++;

	}		

	return 1;

}

int parse_syntax(FILE* file, ErrorType* errors_, int maxErrorNo_, int passes)

{

	line_no = 1;

	errors = errors_;

	maxErrorNo = maxErrorNo_;

	errorNo = 0;

	clear_all();

	clear_id_table();		

	yyrestart(file);

	yyparse();

	if (passes > 1)

	{	

		if (!complete_semantics())

		{

			semantic_error(last_error());

		}	

	}	

	return errorNo;

}