%require "3.2"
%language "c++"

%code requires {
    #include <cstdint>
    #include "elna/source/parser.hpp"


    #if ! defined(yyFlexLexerOnce)
        #include <FlexLexer.h>
    #endif

    namespace elna::syntax
    {
    class FooLexer;
    }
}

%code provides {
    namespace elna::syntax
    {

    class FooLexer : public yyFlexLexer
    {
    public:
        yy::location location;

        FooLexer(std::istream& arg_yyin)
            : yyFlexLexer(&arg_yyin)
        {
        }

        yy::parser::symbol_type lex();
    };

    }
}

%define api.token.raw
%define api.token.constructor
%define api.value.type variant
%define parse.assert

%parse-param {elna::syntax::FooLexer& lexer}
%parse-param {std::unique_ptr<elna::source::program>& program}
%locations

%header

%code {
    #define yylex lexer.lex
}
%start program;

%token <std::string> IDENTIFIER "identifier"
%token <std::int32_t> NUMBER "number"
%token <bool> BOOLEAN
%token IF THEN WHILE DO
%token CONST VAR PROCEDURE
%token BEGIN_BLOCK END_BLOCK
%token TRUE FALSE
%token LEFT_PAREN RIGHT_PAREN SEMICOLON DOT COMMA
%token GREATER_EQUAL LESS_EQUAL LESS_THAN GREATER_THAN NOT_EQUAL EQUALS
%token PLUS MINUS MULTIPLICATION DIVISION
%token ASSIGNMENT COLON HAT AT

%type <std::unique_ptr<elna::source::integer_literal>> integer_literal;
%type <std::unique_ptr<elna::source::boolean_literal>> boolean_literal;
%type <std::unique_ptr<elna::source::variable_expression>> variable_expression;
%type <std::unique_ptr<elna::source::constant_definition>> constant_definition;
%type <std::unique_ptr<elna::source::unary_expression>> reference_expression dereference_expression;
%type <std::vector<std::unique_ptr<elna::source::constant_definition>>> constant_definition_part constant_definitions;
%type <std::unique_ptr<elna::source::type_expression>> type_expression;
%type <std::unique_ptr<elna::source::declaration>> variable_declaration;
%type <std::vector<std::unique_ptr<elna::source::declaration>>> variable_declaration_part variable_declarations;
%type <std::unique_ptr<elna::source::assign_statement>> assign_statement;
%type <std::unique_ptr<elna::source::expression>> expression factor term comparand;
%type <std::unique_ptr<elna::source::statement>> statement;
%type <std::vector<std::unique_ptr<elna::source::expression>>> arguments;
%type <std::unique_ptr<elna::source::call_statement>> call_statement;
%type <std::unique_ptr<elna::source::compound_statement>> compound_statement;
%type <std::vector<std::unique_ptr<elna::source::statement>>> statements;
%type <std::unique_ptr<elna::source::if_statement>> if_statement;
%type <std::unique_ptr<elna::source::while_statement>> while_statement;
%type <std::unique_ptr<elna::source::procedure_definition>> procedure_definition;
%type <std::vector<std::unique_ptr<elna::source::procedure_definition>>> procedure_definition_part procedure_definitions;
%%
program: constant_definition_part variable_declaration_part procedure_definition_part statement DOT
        {
            elna::source::position position;
            std::vector<std::unique_ptr<elna::source::definition>> definitions($1.size());
            std::vector<std::unique_ptr<elna::source::declaration>> declarations($2.size());
            std::vector<std::unique_ptr<elna::source::definition>>::iterator definition = definitions.begin();
            std::vector<std::unique_ptr<elna::source::declaration>>::iterator declaration = declarations.begin();

            for (auto& constant : $1)
            {
                *definition++ = std::move(constant);
            }
            for (auto& variable : $2)
            {
                *declaration++ = std::move(variable);
            }
            program = std::make_unique<elna::source::program>(position,
                 std::move(definitions), std::move(declarations), std::move($4));
        }
procedure_definition:
    PROCEDURE IDENTIFIER SEMICOLON constant_definition_part variable_declaration_part statement SEMICOLON
        {
            elna::source::position position;
            std::vector<std::unique_ptr<elna::source::definition>> definitions($4.size());
            std::vector<std::unique_ptr<elna::source::declaration>> declarations($5.size());
            std::vector<std::unique_ptr<elna::source::definition>>::iterator definition = definitions.begin();
            std::vector<std::unique_ptr<elna::source::declaration>>::iterator declaration = declarations.begin();

            for (auto& constant : $4)
            {
                *definition++ = std::move(constant);
            }
            for (auto& variable : $5)
            {
                *declaration++ = std::move(variable);
            }
            auto block = std::make_unique<elna::source::block>(position,
                 std::move(definitions), std::move(declarations), std::move($6));
            $$ = std::make_unique<elna::source::procedure_definition>(position,
                $2, std::move(block));
        }
procedure_definition_part:
    /* no procedure definitions. */ {}
    | procedure_definitions { std::swap($1, $$); }
procedure_definitions:
    procedure_definition procedure_definitions
        {
            std::swap($$, $2);
            $$.emplace($$.cbegin(), std::move($1));
        }
    | procedure_definition { $$.emplace_back(std::move($1)); }
integer_literal: NUMBER
        {
            elna::source::position position{
                static_cast<std::size_t>(@1.begin.line),
                static_cast<std::size_t>(@1.begin.column)
            };
            $$ = std::make_unique<elna::source::integer_literal>(position, $1); 
        }
boolean_literal: BOOLEAN
        {
            elna::source::position position{
                static_cast<std::size_t>(@1.begin.line),
                static_cast<std::size_t>(@1.begin.column)
            };
            $$ = std::make_unique<elna::source::boolean_literal>(position, $1);
        }
variable_expression: IDENTIFIER
        {
            elna::source::position position{
                static_cast<std::size_t>(@1.begin.line),
                static_cast<std::size_t>(@1.begin.column)
            };
            $$ = std::make_unique<elna::source::variable_expression>(position, $1);
        }
reference_expression: AT variable_expression
        {
            elna::source::position position{
                static_cast<std::size_t>(@1.begin.line),
                static_cast<std::size_t>(@1.begin.column)
            };
            $$ = std::make_unique<elna::source::unary_expression>(position, std::move($2), '@');
        }
dereference_expression: factor HAT
        {
            elna::source::position position{
                static_cast<std::size_t>(@1.begin.line),
                static_cast<std::size_t>(@1.begin.column)
            };
            $$ = std::make_unique<elna::source::unary_expression>(position, std::move($1), '^');
        }
expression:
    comparand EQUALS comparand
        {
            elna::source::position position{
                static_cast<std::size_t>(@1.begin.line),
                static_cast<std::size_t>(@1.begin.column)
            };
            $$ = std::make_unique<elna::source::binary_expression>(position,
                std::move($1), std::move($3), '=');
        }
    | comparand NOT_EQUAL comparand
        {
            elna::source::position position{
                static_cast<std::size_t>(@1.begin.line),
                static_cast<std::size_t>(@1.begin.column)
            };
            $$ = std::make_unique<elna::source::binary_expression>(position,
                std::move($1), std::move($3), 'n');
        }
    | comparand GREATER_THAN comparand
        {
            elna::source::position position{
                static_cast<std::size_t>(@1.begin.line),
                static_cast<std::size_t>(@1.begin.column)
            };
            $$ = std::make_unique<elna::source::binary_expression>(position,
                std::move($1), std::move($3), '>');
        }
    | comparand LESS_THAN comparand
        {
            elna::source::position position{
                static_cast<std::size_t>(@1.begin.line),
                static_cast<std::size_t>(@1.begin.column)
            };
            $$ = std::make_unique<elna::source::binary_expression>(position,
                std::move($1), std::move($3), '<');
        }
    | comparand GREATER_EQUAL comparand
        {
            elna::source::position position{
                static_cast<std::size_t>(@1.begin.line),
                static_cast<std::size_t>(@1.begin.column)
            };
            $$ = std::make_unique<elna::source::binary_expression>(position,
                std::move($1), std::move($3), 'g');
        }
    | comparand LESS_EQUAL comparand
        {
            elna::source::position position{
                static_cast<std::size_t>(@1.begin.line),
                static_cast<std::size_t>(@1.begin.column)
            };
            $$ = std::make_unique<elna::source::binary_expression>(position,
                std::move($1), std::move($3), 'l');
        }
comparand:
    term PLUS term
        {
            elna::source::position position{
                static_cast<std::size_t>(@1.begin.line),
                static_cast<std::size_t>(@1.begin.column)
            };
            $$ = std::make_unique<elna::source::binary_expression>(position,
                std::move($1), std::move($3), '+');
        }
    | term MINUS term
        {
            elna::source::position position{
                static_cast<std::size_t>(@1.begin.line),
                static_cast<std::size_t>(@1.begin.column)
            };
            $$ = std::make_unique<elna::source::binary_expression>(position,
                std::move($1), std::move($3), '-');
        }
    | term { $$ = std::move($1); }
factor:
    integer_literal { $$ = std::move($1); }
    | boolean_literal { $$ = std::move($1); }
    | variable_expression { $$ = std::move($1); }
    | reference_expression { $$ = std::move($1); }
    | dereference_expression { $$ = std::move($1); }
    | LEFT_PAREN expression RIGHT_PAREN { $$ = std::move($2); }
term:
    factor MULTIPLICATION factor
        {
            elna::source::position position{
                static_cast<std::size_t>(@1.begin.line),
                static_cast<std::size_t>(@1.begin.column)
            };
            $$ = std::make_unique<elna::source::binary_expression>(position,
                std::move($1), std::move($3), '*');
        }
    | factor DIVISION factor
        {
            elna::source::position position{
                static_cast<std::size_t>(@1.begin.line),
                static_cast<std::size_t>(@1.begin.column)
            };
            $$ = std::make_unique<elna::source::binary_expression>(position,
                std::move($1), std::move($3), '/');
        }
    | factor { $$ = std::move($1); }
type_expression:
    HAT IDENTIFIER
        {
            elna::source::position position{
                static_cast<std::size_t>(@1.begin.line),
                static_cast<std::size_t>(@1.begin.column)
            };
            $$ = std::make_unique<elna::source::type_expression>(position, $2, true);
        }
    | IDENTIFIER
        {
            elna::source::position position{
                static_cast<std::size_t>(@1.begin.line),
                static_cast<std::size_t>(@1.begin.column)
            };
            $$ = std::make_unique<elna::source::type_expression>(position, $1, false);
        }
assign_statement: IDENTIFIER ASSIGNMENT expression
        {
            elna::source::position position{
                static_cast<std::size_t>(@1.begin.line),
                static_cast<std::size_t>(@2.begin.column)
            };
            $$ = std::make_unique<elna::source::assign_statement>(position, $1, std::move($3));
        }
call_statement: IDENTIFIER LEFT_PAREN arguments RIGHT_PAREN
        {
            elna::source::position position{
                static_cast<std::size_t>(@1.begin.line),
                static_cast<std::size_t>(@1.begin.column)
            };
            $$ = std::make_unique<elna::source::call_statement>(position, $1);
            std::swap($3, $$->arguments());
        }
compound_statement: BEGIN_BLOCK statements END_BLOCK
        {
            elna::source::position position{
                static_cast<std::size_t>(@1.begin.line),
                static_cast<std::size_t>(@1.begin.column)
            };
            $$ = std::make_unique<elna::source::compound_statement>(position);
            std::swap($2, $$->statements());
        }
if_statement: IF expression THEN statement
        {
            elna::source::position position{
                static_cast<std::size_t>(@1.begin.line),
                static_cast<std::size_t>(@1.begin.column)
            };
            $$ = std::make_unique<elna::source::if_statement>(position,
                std::move($2), std::move($4));
        }
while_statement: WHILE expression DO statement
        {
            elna::source::position position{
                static_cast<std::size_t>(@1.begin.line),
                static_cast<std::size_t>(@1.begin.column)
            };
            $$ = std::make_unique<elna::source::while_statement>(position,
                std::move($2), std::move($4));
        }
statement:
    assign_statement { $$ = std::move($1); }
    | call_statement { $$ = std::move($1); }
    | compound_statement { $$ = std::move($1); }
    | if_statement { $$ = std::move($1); }
    | while_statement { $$ = std::move($1); }
variable_declaration: IDENTIFIER COLON type_expression
        {
            elna::source::position position{
                static_cast<std::size_t>(@1.begin.line),
                static_cast<std::size_t>(@1.begin.column)
            };
            $$ = std::make_unique<elna::source::declaration>(position, $1, std::move($3));
        }
variable_declarations:
    variable_declaration COMMA variable_declarations
        {
            std::swap($$, $3);
            $$.emplace($$.cbegin(), std::move($1));
        }
    | variable_declaration { $$.emplace_back(std::move($1)); }
constant_definition: IDENTIFIER EQUALS integer_literal
        {
            elna::source::position position{
                static_cast<std::size_t>(@1.begin.line),
                static_cast<std::size_t>(@1.begin.column)
            };
            $$ = std::make_unique<elna::source::constant_definition>(position,
                $1, std::move($3)); 
        };
constant_definitions:
    constant_definition COMMA constant_definitions
        {
            std::swap($$, $3);
            $$.emplace($$.cbegin(), std::move($1));
        }
    | constant_definition { $$.emplace_back(std::move($1)); }
constant_definition_part:
    /* no constant definitions */ {}
    | CONST constant_definitions SEMICOLON { std::swap($$, $2); };
variable_declaration_part:
    /* no constant declarations */ {}
    | VAR variable_declarations SEMICOLON { std::swap($$, $2); };
arguments:
    /* no arguments */ {}
    | expression COMMA arguments
        {
            std::swap($$, $3);
            $$.emplace($$.cbegin(), std::move($1));
        }
    | expression { $$.emplace_back(std::move($1)); }
statements:
    /* no statements */ {}
    | statement SEMICOLON statements
        {
            std::swap($$, $3);
            $$.emplace($$.cbegin(), std::move($1));
        }
    | statement { $$.emplace_back(std::move($1)); }
%%

void yy::parser::error(const location_type& loc, const std::string &message)
{
    throw yy::parser::syntax_error(loc, message);
}