parser.ypp

%{

#include <iostream> // cerr, endl
#include <string> // string
#include <unordered_map> // unordered_map
#include <vector> // vector
#include <set> // set
#include <memory> // unique_ptr

#include "ast.hpp"
#include "types.hpp"


/*
* @brief Extern lexical parsing function.
*/
extern int yylex();

/*
* @brief Error handling function.
*/
void yyerror(std::string_view msg)
{
	std::cerr << "[yyerror]" << msg << std::endl;
	std::exit(1);
}

// Global symbol table with identifiers and types.
std::unordered_map<std::string, std::unordered_map<std::string, std::unique_ptr<pascalina::types::base>>> symtable;
// Program tree
std::unique_ptr<pascalina::program> root;
// Used variables
std::vector<std::string> identifiers;
std::unordered_map<std::string, std::vector<std::string>> function_identifiers;
// Error logs
std::set<std::string> semantic_errors;

%}

/* Defining yacc union */
%union
{
	/* Expressions */
	pascalina::expression *expression;
	std::vector<pascalina::expression*> *expression_list;
	/* Identifiers */
	std::string *identifier;
	std::vector<std::string> *identifier_list;
	pascalina::identifier *identifier_n;
	/* Statements */
	pascalina::statement *statement;
	std::vector<pascalina::statement*> *statement_list;
	/* Var */
	std::pair<std::vector<std::string>, pascalina::types::base*> *var;
	std::vector<std::pair<std::vector<std::string>, pascalina::types::base*>> *var_list;
	/* Subprograms */
	pascalina::function *subprogram_declaration;
	pascalina::function_prototype *subprogram_head;
	std::vector<pascalina::function*> *subprogram_declarations;
	/* Types */
	pascalina::types::base *type;
	/* Misc */
	pascalina::var *declarations;
	float literal;
}

/* Defining tokens */
%token ID NUM VAR WRITELN
%token IF ELSE THEN DO FUNCTION PROCEDURE WHILE
%token ARRAY ELIPSIS OF INTEGER REAL
%token PROGRAM BEGIN_ END_
%token EQ NE LE GE ASSIGN NOT

/* Defining types */
%type<declarations> declarations
%type<var> var
%type<var_list> var_list arguments
%type<identifier_list> identifier_list
%type<type> base_type type
%type<subprogram_declarations> subprogram_declarations
%type<subprogram_declaration> subprogram_declaration
%type<subprogram_head> subprogram_head
%type<statement_list> statement_list optional_statements
%type<statement> statement compound_statement procedure_statement
%type<identifier_n> variable
%type<expression_list> expression_list
%type<expression> expression

%type<literal> NUM
%type<identifier> ID



/* Handling token precedence for conditional statements */
%nonassoc THEN
%nonassoc ELSE

/* Setting operator precedence */
%left EQ NE
%left '<' '>' LE GE
%left '+' '-'
%left '*' '/'
%right NOT

%%

/* pascalina::program */
program
	: PROGRAM ID ';' declarations subprogram_declarations compound_statement '.' {
			root = std::make_unique<pascalina::program>(*$2, $4, std::move(*$5), $6);

			for(auto &&e1 : $4->ids())
			{
				for(auto &&e2 : e1.first)
				{
					if(symtable["__global__"].end() != symtable["__global__"].find(e2)) {
						semantic_errors.insert("[semantic error]Redeclaration of variable '" + e2 + "' in unit '__global__'.");
					}

					symtable["__global__"][e2] = std::unique_ptr<pascalina::types::base>{e1.second->clone()};
				}
			}

			function_identifiers["__global__"] = std::move(identifiers);
			identifiers.clear();

			// Check if all used variables are in scope
			for(auto &&function : function_identifiers)
			{
				for(auto &&id : function.second)
				{
					if(	symtable[function.first].end() == symtable[function.first].find(id) &&
						symtable["__global__"].end() == symtable["__global__"].find(id)) {
						semantic_errors.insert("[semantic error]Undeclared variable '" + id + "' in unit '" + function.first + "'.");
					}
				}
			}

			delete $2; /* std::string */
			delete $5; /* std::vector<pascalina::function*> */
		}
	;

/* std::vector<std::string> */
identifier_list
	: ID {
			$$ = new std::vector<std::string>{*$1};
			delete $1; /* std::string */
		}
	| identifier_list ',' ID {
			$$ = $1;
			$$->push_back(*$3);
			delete $3; /* std::string */
		}
	;

/* pascalina::var */
declarations
	: VAR var_list ';' {
			$$ = new pascalina::var(std::move(*$2));
			delete $2; /* std::vector<std::pair<std::vector<std::string>, pascalina::types::base*>> */
		}
	| /* eps */ { $$ = new pascalina::var(); }
	;

/* std::vector<std::string> */
var_list
	: var {
			$$ = new std::vector<std::pair<std::vector<std::string>, pascalina::types::base*>>{*$1};
			delete $1; /* std::pair<std::vector<std::string>, pascalina::types::base*> */
		}
	| var_list ';' var {
			$$ = $1;
			$$->push_back(std::move(*$3));
			delete $3; /* std::pair<std::vector<std::string>, pascalina::types::base*> */
		}
	;

/* std:::vector<std::string> */
var
	: identifier_list ':' type {
			std::vector<std::string> id_list($1->begin(), $1->end());
			$$ = new std::pair<std::vector<std::string>, pascalina::types::base*>(std::move(id_list), $3->clone());
			delete $1; /* std::vector<std::string> */
			delete $3; /* pacalina::types::base */
		}
	;

/* pacalina::types::base */
type
	: base_type { $$ = $1; }
	| ARRAY '[' NUM ELIPSIS NUM ']' OF base_type {
			$$ = new pascalina::types::array($8, $5);
		}
	;

/* pacalina::types::base */
base_type
	: INTEGER { $$ = new pascalina::types::integral; }
	| REAL { $$ = new pascalina::types::real; }
	;

/* std::vector<pascalina::function*> */
subprogram_declarations
	: subprogram_declarations subprogram_declaration {
			$$ = $1;
			$$->push_back($2);
		}
	| /* eps */ { $$ = new std::vector<pascalina::function*>; }
	;

/* pascalina::function */
subprogram_declaration
	: subprogram_head declarations compound_statement ';' {
			$$ = new pascalina::function($1, $2, $3);

			// Add declared variables to function scope
			for(auto &&e1 : $2->ids())
			{
				for(auto &&e2 : e1.first)
				{
					if(symtable[$1->id()].end() != symtable[$1->id()].find(e2)) {
						semantic_errors.insert("[semantic error]Redeclaration of variable '" + e2 + "' in unit '" + $1->id() + "'.");
					}

					symtable[$1->id()][e2] = std::unique_ptr<pascalina::types::base>{e1.second->clone()};

				}
			}

			function_identifiers[$1->id()] = std::move(identifiers);
			identifiers.clear();
		}
	;

/* pascalina::function_prototype */
subprogram_head
	: FUNCTION ID arguments ':' base_type ';' {
			if(symtable.end() != symtable.find(*$2)) {
				semantic_errors.insert("[semantic error]Redeclaration of function '" + *$2 + "'.");
			}

			symtable[*$2][*$2] = nullptr;

			for(auto &&e1 : *$3)
			{
				for(auto &&e2 : e1.first)
				{
					if(symtable[*$2].end() != symtable[*$2].find(e2)) {
						semantic_errors.insert("[semantic error]Redeclaration of variable '" + e2 + "' in unit '" + *$2 + "'.");
					}

					symtable[*$2][e2] = std::unique_ptr<pascalina::types::base>{e1.second->clone()};

				}
			}

			$$ = new pascalina::function_prototype(*$2, std::move(*$3));
			delete $2; /* std::string */
			delete $3; /* std::vector<std::string> */
			delete $5; /* pascalina::types::base */
		}
	| PROCEDURE ID arguments ';' {
			if(symtable.end() != symtable.find(*$2)) {
				semantic_errors.insert("[semantic error]Redeclaration of procedure '" + *$2 + "'.");
			}

			symtable[*$2][*$2] = nullptr;

			for(auto &&e1 : *$3)
			{
				for(auto &&e2 : e1.first)
				{
					if(symtable[*$2].end() != symtable[*$2].find(e2)) {
						semantic_errors.insert("[semantic error]Redeclaration of variable '" + e2 + "' in unit '" + *$2 + "'.");
					}

					symtable[*$2][e2] = std::unique_ptr<pascalina::types::base>{e1.second->clone()};
				}
			}

			$$ = new pascalina::function_prototype(*$2, std::move(*$3));
			delete $2; /* std::string */
			delete $3; /* std::vector<std::string> */
		}
	;

/* std::vector<std::string> */
arguments
	: '(' var_list ')' { $$ = $2; }
	| /* eps */ { $$ = new std::vector<std::pair<std::vector<std::string>, pascalina::types::base*>>; }
	;

/* pascalina::statement */
compound_statement
	: BEGIN_ optional_statements END_ {
			$$ = new pascalina::compound(std::move(*$2));
			delete $2; /* std::vector<pascalina::statement*> */
		}
	;

/* std::vector<pascalina::statement*> */
optional_statements
	: statement_list { $$ = $1; }
	| /* eps */ { $$ = new std::vector<pascalina::statement*>; }
	;

/* std::vector<pascalina::statement*> */
statement_list
	: statement { $$ = new std::vector<pascalina::statement*>{$1}; }
	| statement_list ';' statement {
			$$ = $1;
			$$->push_back($3);
		}
	;

/* pascalina::statement */
statement
	: variable ASSIGN expression { $$ = new pascalina::assignment($1, $3); }
	| ID '[' expression ']' ASSIGN expression {
			$$ = new pascalina::array_modify(*$1, $3, $6);
			identifiers.push_back(*$1);
			delete $1; /* std::string */
		}
	| compound_statement { $$ = $1; }
	| procedure_statement { $$ = $1; }
	| WRITELN '(' expression ')' { $$ = new pascalina::writeln($3); }
	| IF expression THEN statement ELSE statement { $$ = new pascalina::selection($2, $4, $6); }
	| IF expression THEN statement { $$ = new pascalina::selection($2, $4); }
	| WHILE expression DO statement { $$ = new pascalina::iteration($2, $4); }
	;

/* pascalina::statement */
procedure_statement
	: ID {
			$$ = new pascalina::procedure_call(*$1);

			// Check if function exists
			if(symtable.end() == symtable.find(*$1)) {
				semantic_errors.insert("[semantic error]Undeclared function '" + *$1 + "'.");
			}

			delete $1; /* std::string */
		}
	| ID '(' expression_list ')' {
			$$ = new pascalina::procedure_call(*$1, std::move(*$3));

			// Check if function exists
			if(symtable.end() == symtable.find(*$1)) {
				semantic_errors.insert("[semantic error]Undeclared function '" + *$1 + "'.");
			}

			delete $1; /* std::string */
			delete $3; /* std::vector<pascalina::expression*> */
		}
	;

/* pascalina::expression */
variable:
	ID {
			$$ = new pascalina::identifier(*$1);
			identifiers.push_back(*$1);
			delete $1; /* std::string */
		}
	;

/* std::vector<pascalina::expression*> */
expression_list
	: expression { $$ = new std::vector<pascalina::expression*>{$1}; }
	| expression_list ',' expression {
			$$ = $1;
			$$->push_back($3);
		}
	;

/* pascalina::expression */
expression
	: expression '+' expression { $$ = new pascalina::binary_operator(pascalina::binary::plus, $1, $3); }
	| expression '-' expression { $$ = new pascalina::binary_operator(pascalina::binary::minus, $1, $3); }
	| expression '*' expression { $$ = new pascalina::binary_operator(pascalina::binary::multiplies, $1, $3); }
	| expression '/' expression { $$ = new pascalina::binary_operator(pascalina::binary::divides, $1, $3); }
	| expression '<' expression { $$ = new pascalina::binary_operator(pascalina::binary::less, $1, $3); }
	| expression '>' expression { $$ = new pascalina::binary_operator(pascalina::binary::greater, $1, $3); }
	| expression EQ expression { $$ = new pascalina::binary_operator(pascalina::binary::equal_to, $1, $3); }
	| expression NE expression { $$ = new pascalina::binary_operator(pascalina::binary::not_equal_to, $1, $3); }
	| expression LE expression { $$ = new pascalina::binary_operator(pascalina::binary::less_equal, $1, $3); }
	| expression GE expression { $$ = new pascalina::binary_operator(pascalina::binary::greater_equal, $1, $3); }
	| '-' %prec '-' expression { $$ = new pascalina::unary_operator(pascalina::unary::minus, $2); }
	| NOT expression { $$ = new pascalina::unary_operator(pascalina::unary::logical_not, $2); }
	| '(' expression ')' { $$ = $2; }
	| variable { $$ = $1; }
	| ID '[' expression ']' {
			$$ = new pascalina::array_index(*$1, $3);
			identifiers.push_back(*$1);
			delete $1; /* std::string */
		}
	| ID '(' expression_list ')' {
			$$ = new pascalina::function_call(*$1, std::move(*$3));

			// Check if function exists
			if(symtable.end() == symtable.find(*$1)) {
				semantic_errors.insert("[semantic error]Undeclared function '" + *$1 + "'.");
			}

			delete $1; /* std::string */
			delete $3; /* std::vector<pascalina::expression*> */
		}
	| NUM { $$ = new pascalina::literal($1); }
	;

%%