%{
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "y.tab.h"

int yylex (void);
void yyerror(char* s);

is_program* myprogram;

%}

%token CHAR ELSE WHILE IF INT SHORT DOUBLE RETURN BITWISEAND BITWISEOR BITWISXOR AND ASSIGN MUL COMMA DIV EQ GE GT LBRACE LE LPAR LT MINUS MOD NE NOT OR PLUS RBRACE RPAR SEMI RESERVED
%token <id> ID
%token <id> CHRLIT
%token <id> INTLIT
%token <id> REALLIT
%token <type_id> VOID


%token<id>IDENTIFIER
%type<ip>program
%type<ivl>vardeclist
%type<iv>vardec
%type<isl>statementlist
%type<is>statement

%type <statement> Statement
%type <statement> Statement_Optional

%type <expression> Expr
%type <expression> ExprAritmetic
%type <expression> ExprComparison
%type <expression> ExprBitwise
%type <expression> ExprUnary
%type <expression> Expr_Optional

%union{
    char *id;
    is_program* ip;

    double value_reallit;
    bool value_boollit;
    disc_type_id type_id;
    is_program *program_union;

    is_expression *expression;
    is_expression_list *expression_list;

    is_class_body_list *class_body_list;
    is_class_body *class_body;

    is_comma_id *comma_id;
    is_comma_type_id *comma_type_id;

    is_method_header *method_header;
    is_method_body *method_body;
    is_method_params *method_params;
    is_method_body_list *method_body_list;

    is_statement *statement;
    is_statement_call *call;
    is_statement_parse_args *parse_args;
    is_statement_assignment *assignment;
}


%right ASSIGN
%left OR
%left AND
%left BITWISEXOR
%left BITWISEOR
%left BITWISEAND
%left EQ NE
%left LT LE GT GE
%left PLUS MINUS
%left MOD DIV MUL
%right NOT
%left "unario"
%left LBRACE LPAR RBRACE RPAR

%nonassoc "then"
%nonassoc ELSE

%%

FunctionsAndDeclarations
    : FunctionDefinition FunctionsAndDeclarations_Optional                  {}
    | FunctionDeclaration FunctionsAndDeclarations_Optional                 {}
    | Declaration FunctionsAndDeclarations_Optional                         {}
    ;

FunctionsAndDeclarations_Optional
    : FunctionsAndDeclarations_Optional FunctionDefinition {}
    | FunctionsAndDeclarations_Optional FunctionDeclaration                         {}
    | FunctionsAndDeclarations_Optional Declaration                                 {}                  
    | /*empty*/                                                                     {$$ = NULL;}
    ;

FunctionDefinition
    : TypeSpec FunctionDeclarator FunctionBody  {}
    ;

FunctionBody
    : LBRACE RBRACE {}
    | LBRACE DeclarationsAndStatements RBRACE               {}
    ;

DeclarationsAndStatements
    : Statement DeclarationsAndStatements                   {}
    | Declaration DeclarationsAndStatements                 {}
    | Statement                                             {}
    | Declaration                                           {}
    ;

FunctionDeclaration
    : TypeSpec FunctionDeclarator SEMI {}
    ;


FunctionDeclarator
    : ID LPAR ParameterList RPAR                  {}
    ;

ParameterList
    : ParameterDeclaration ParameterList_Optional      {}
    ;

ParameterList_Optional
    :  ParameterList_Optional COMMA ParameterDeclaration        {}
    | /*empty*/                                                 {$$ = NULL;}                                                    {$$ = NULL;}
    ;

ParameterDeclaration
    : TypeSpec                  {}
    | TypeSpec ID               {}
    ;

Declaration
    : TypeSpec Declarator Declaration_Optional SEMI          {}
    ;

Declaration_Optional
    :  Declaration_Optional COMMA Declarator            {}
    | /*empty*/                                         {$$ = NULL;}
    ;

TypeSpec
    : CHAR      {}
    | INT       {}
    | VOID      {}
    | SHORT     {}
    | DOUBLE    {}
    ;

Declarator
    : ID                                            {}
    | ID ASSIGN Expr                                {}
    ;

Statement
    : LBRACE Statement_Optional RBRACE              {}
    | SEMI                                          {}
    | Expr SEMI                                     {}
    | IF LPAR Expr RPAR Statement                   {}
    | IF LPAR Expr RPAR Statement ELSE Statement    {}
    | RETURN SEMI                                   {}
    | RETURN Expr SEMI                              {}
    | WHILE LPAR Expr RPAR Statement                {}
    ;

Statement_Optional
    : Statement_Optional Statement                  {}
    | /*empty*/                                     {$$ = NULL;}
    ;


Expr 
    :  Expr COMMA Expr                  {}
    | Expr ASSIGN Expr                  {}
    | ExprAritmetic                     {$$ = $1;}
    | ExprComparison                    {$$ = $1;}
    | ExprBitwise                       {$$ = $1;}
    | ExprUnary                         {$$ = $1;}
    | LPAR Expr RPAR                    {}
    | ID LPar Expr Expr_Optional RPAR   {$$ = insert_expression_comma($1);}
    | ID LPar RPAR                      {$$ = insert_expression_comma($1);}
    | ID                                {$$ = insert_expression_id($1);}
    | INTLIT                            {$$ = insert_expression_intlit($1);}
    | CHRLIT                            {$$ = insert_expression_chrlit($1);}
    | REALLIT                           {$$ = insert_expression_reallit($1);}
    ;

Expr_Optional
    :  Expr_Optional COMMA Expr    {}
    | /*empty*/                         {$$ = NULL;}
    ;

ExprAritmetic
    : Expr PLUS Expr                {$$ = insert_expression_add($1, $3);}
    | Expr MINUS Expr               {$$ = insert_expression_sub($1, $3);}
    | Expr MUL Expr                 {$$ = insert_expression_mul($1, $3);}
    | Expr DIV Expr                 {$$ = insert_expression_div($1, $3);}
    | Expr MOD Expr                 {$$ = insert_expression_mod($1, $3);}
    ;

ExprComparison 
    :  Expr EQ Expr                 {$$ = insert_expression_eq($1, $3);}
    |  Expr GE Expr                 {$$ = insert_expression_ge($1, $3);}
    |  Expr GT Expr                 {$$ = insert_expression_gt($1, $3);}
    |  Expr LE Expr                 {$$ = insert_expression_le($1, $3);}
    |  Expr LT Expr                 {$$ = insert_expression_lt($1, $3);}
    |  Expr NE Expr                 {$$ = insert_expression_ne($1, $3);}
    ;

ExprBitwise
    : Expr AND Expr                 {$$ = insert_expression_and($1, $3);}
    | Expr OR Expr                  {$$ = insert_expression_or($1, $3);}
    | Expr BITWISEXOR Expr          {$$ = insert_expression_bitwisexor($1, $3);}
    | Expr BITWISEAND Expr          {$$ = insert_expression_bitwiseand($1, $3);}
    | Expr BITWISEOR Expr           {$$ = insert_expression_bitwiseor($1, $3);}
    ;

ExprUnary
    : MINUS Expr      %prec "unario"      {$$ = insert_expression_minus($2);}
    | NOT Expr                                  {$$ = insert_expression_not($2);}
    | PLUS Expr     %prec "unario"              {$$ = insert_expression_plus($2);}
    ;


%%

void yyerror(char *msg) {
    printf("%s", msg);
}