%{

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <math.h>

using namespace std;

#include "values.h"
#include "listing.h"
#include "symbols.h"
#include <stdlib.h>
#include <stdio.h>

int yylex();
void yyerror(const char* message);

Symbols<int> symbols;

//----------------------------------------------------------------------------------------------

vector<int> case_statements;  //<<<<<<<<<<<<Is this wrong?

//---------------------------------------------------------------------------------------------

int result;
double *params;

%}

%define parse.error verbose

%union
{
	CharPtr iden;
	Operators oper;
	int value;
}

%token <iden> IDENTIFIER
%token <value> INT_LITERAL REAL_LITERAL BOOL_LITERAL CASE TRUE FALSE

%token <oper> ADDOP MULOP RELOP OROP NOTOP REMOP EXPOP
%token ANDOP

%token BEGIN_ BOOLEAN END ENDREDUCE FUNCTION INTEGER IS REDUCE RETURNS
%token THEN WHEN ARROW
%token ELSE ENDCASE ENDIF IF OTHERS REAL

%type <value> body statement_ statement reductions expression relation term
	factor case cases exponent unary primary
%type <oper> operator

%%

function:	
	function_header optional_variable body {result = $3;} ;
	
function_header:	
	FUNCTION IDENTIFIER optional_parameter RETURNS type ';' |
    FUNCTION IDENTIFIER RETURNS type ';' |
    error ';' ;

optional_variable:
	optional_variable variable | 
    error ';' | 
    %empty ;

variable:	
	IDENTIFIER ':' type IS statement_ ;

parameters:
    parameter optional_parameter;

optional_parameter:
    optional_parameter ',' parameter |
    %empty ;

parameter:
    IDENTIFIER ':' type {symbols.insert($1, params[0]);} ;

type:
	INTEGER |
    REAL |
	BOOLEAN ;

body:
	BEGIN_ statement_ END ';' {$$ = $2;} ;
    
statement_:
	statement ';' |
	error ';' {$$ = 0;} ;
	
statement:
	expression |
	REDUCE operator reductions ENDREDUCE {$$ = $3;} |
    IF expression THEN statement_ ELSE statement_ ENDIF {
        if ($2 == true) {
            $$ = $4;
        }
        else {
            $$ = $6;
        }
    } ; |
    CASE expression IS cases OTHERS ARROW statement_ ENDCASE {$$ = $<value>4 == $1 ? $4 : $7;} ;

cases:
    cases case {$$ = $<value>1 == $1 ? $1 : $2;} |
    %empty {$$ = NAN;} ;

//-----------------------------------------------------------------------------------------------------------

case:
    case WHEN INT_LITERAL ARROW statement_ {case_statements.push_back($4);} ;  //<<<<<<<<<How do I declare $4?

//-------------------------------------------------------------------------------------------------------------

operator:
	ADDOP |
    RELOP |
    EXPOP |
	MULOP ;

reductions:
	reductions statement_ {$$ = evaluateReduction($<oper>0, $1, $2);} |
	{$$ = $<oper>0 == ADD ? 0 : 1;} %empty ;

expression:
    expression OROP relation {$$ = $1 || $3;} |
    relation ;

expression:
	expression ANDOP relation {$$ = $1 && $3;} |
	relation ;

relation:
	relation RELOP term {$$ = evaluateRelational($1, $2, $3);} |
	term ;

term:
	term ADDOP factor {$$ = evaluateArithmetic($1, $2, $3);} |
	factor ;
      
factor:
	factor MULOP primary {$$ = evaluateArithmetic($1, $2, $3);} |
    factor REMOP exponent {$$ = $1 % $3;} |
	exponent ;

exponent:
    unary |
    unary EXPOP exponent {$$ = pow($1, $3);} ;

unary:
    NOTOP primary {$$ = $2;} |
    primary;

primary:
	'(' expression ')' {$$ = $2;} |
	INT_LITERAL |
    REAL_LITERAL |
    BOOL_LITERAL |
	IDENTIFIER {if (!symbols.find($1, $$)) appendError(UNDECLARED, $1);} ;

%%

void yyerror(const char* message)
{
	appendError(SYNTAX, message);
}

int main(int argc, char *argv[])    
{
    params = new double[argc - 1]
    for (int i = 1; i < argc; i++)
    {
        params[i - 1] = atof(argv[i]);
    }
	firstLine();
	yyparse();
	if (lastLine() == 0)
		cout << "Result = " << result << endl;
	return 0;
}