%{

 #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;

 }