%union {
int nombre;
char id[30];
}

%{
#include <stdio.h>
#include "table_symboles.h"
#include "gen_assembleur.h"

enum Initialised_Variable init;
enum Symbole_Type type;
Table_Symboles table;
instructions_array array;
int whileCondition;
%}


%token<nombre> tENTIER
%token<nombre> tENTIEREXP

%type<nombre> E
%type<nombre> Return
%type<nombre> Cond
%type<nombre> While



%token tADD
%token tSUB
%token tMUL
%token tDIV

%token<nombre> tPO
%token tPF
%token tAO
%token tAF

%token tERROR

%token tPV
%token tVIRGULE
%token tAFFECTATION
%token tEGAL
%token tDIFF
%token tLT
%token tGT
%token tGTE
%token tLTE
%token tMAIN
%token tINT
%token tPRINT
%token tRETURN
%token tOR
%token tAND
%token<nombre> tIF
%token tELSE
%token<nombre> tWHILE
%token tCONST
%token<id> tVAR
%token tNOT

%left tADD
%left tSUB
%left tMUL
%left tDIV
%right tEGAL


%%

//C : Fonctions Main ;

//Fonctions : Fonction Fonctions | ;
//Fonction : tINT tVAR tPO Params tPF Body;


Main : tINT tMAIN tPO Params tPF Body {};

Params : {printf("Sans params\n");} ;
Params : Param SuiteParams ;

Param : tINT tVAR {printf("Parametre : %s\n", $2);} ;


SuiteParams : tVIRGULE Param SuiteParams tPV ;
SuiteParams : ;


Body : tAO Instructions Return tAF {printf("Dans body\n");} ;

Instructions : Instruction Instructions ;
Instructions : ;

Instruction : Aff ;
Instruction : If ;
Instruction : While ;
Instruction : Print ;
Instruction : Decl ;
Instruction : Invocation tPV ;

Decl : Type Valeur SuiteDecl tPV ;

SuiteDecl: tVIRGULE Valeur SuiteDecl ;
SuiteDecl: ;

Type : tINT {type = TYPE_INT;} ; 
Type : tCONST tINT {type = TYPE_CONST_INT;} ;

Valeur : tVAR {add_symbole_top(&table, $1, type, INITIALISED, table.depth);} tAFFECTATION E {int varAddr = variable_exists(&table, $1); generate_instruction_2(&array, COP, $4, varAddr); free_temp(&table);};
Valeur : tVAR {add_symbole_top(&table, $1, type, NOT_INITIALISED, table.depth);};


Aff : tVAR tAFFECTATION E tPV {int varAddr = variable_exists(&table, $1); generate_instruction_2(&array, COP, $3, varAddr); free_temp(&table);};

//E : tENTIER {int vt = gen_entier(&table, &array, $1); $$ = vt;};
E : tENTIER {int vt = new_temp(&table); generate_instruction_2(&array, AFC, vt, $1); $$ = vt;};
//E : tVAR {int vt = gen_var(&table, &array, $1);  $$ = vt;};
E : tVAR {int vt = new_temp(&table); int varAddr = variable_exists(&table, $1); generate_instruction_2(&array, COP, varAddr, vt); $$ = vt;};
//E : E tADD E {gen_arithmetique(&array, ADD, $1, $3); free_temp(&table); $$ = $1;} ;
E : E tADD E {generate_instruction_3(&array, ADD, $1, $1, $3); free_temp(&table); $$ = $1;} ;
E : E tMUL E {generate_instruction_3(&array, MUL, $1, $1, $3); free_temp(&table); $$ = $1;}  ;
E : E tSUB E {generate_instruction_3(&array, SOU, $1, $1, $3); free_temp(&table); $$ = $1;} ;
E : E tDIV E {generate_instruction_3(&array, DIV, $1, $1, $3); free_temp(&table); $$ = $1;} ;
E : tSUB E {printf("Variable negative\n");} ;
E : Invocation {$$ = 1234;};
E : tPO E tPF {printf("Parenthèse\n"); $$ = $2; } ;


Args : tVAR SuiteArgs ;
Args : ;

SuiteArgs : tVIRGULE tVAR SuiteArgs ;
SuiteArgs : ;

If : tIF tPO Cond tPF {
    //gen_jmpf(&table, &array, $3, -1);
    generate_instruction_2(&array, JMF, $3, -1);
    free_temp(&table);
    $1 = array.index;
}
tAO Instructions tAF
{
    int adr_jmp = array.index;
    update_jmf(&array, $1, adr_jmp);
}
Else {};

Else : tELSE tAO Instructions tAF {printf("else\n");} ;
Else : ;
Else : tELSE tIF tPO Cond tPF tAO Instructions tAF Else {printf("elsif\n");} ;

While : tWHILE tPO {
	$2 = array.index ;
} Cond tPF {
	//gen_jmpf(&table, &array, $4, -1);
	generate_instruction_2(&array, JMF, $4, -1);
	free_temp(&table);
	$1 = array.index;
}
tAO Instructions tAF {
	int adr_jmp = array.index;
	update_jmf(&array, $1, adr_jmp);
	//gen_jmpf(&table, &array, $1, $2);
	generate_instruction_1(&array, JMP, $2);
};

//Cond : E tEGAL E {int vt = gen_condition(&table, &array, EQ, $1, $3); $$ = vt;} ;
Cond : E tEGAL E {generate_instruction_3(&array, EQ, $1, $1, $3); free_temp(&table); $$ = $3;};
Cond : E tDIFF E {generate_instruction_3(&array, NEQ, $1, $1, $3); free_temp(&table); $$ = $3;} ;
Cond : E tLT E {generate_instruction_3(&array, LT, $1, $1, $3); free_temp(&table); $$ = $3;} ;
Cond : E tGT E {generate_instruction_3(&array, GT, $1, $1, $3); free_temp(&table); $$ = $3;} ;
Cond : E tLTE E {generate_instruction_3(&array, LTE, $1, $1, $3); free_temp(&table); $$ = $3;} ;
Cond : E tGTE E {generate_instruction_3(&array, GTE, $1, $1, $3); free_temp(&table); $$ = $3;} ;
Cond : E tAND E {generate_instruction_3(&array, AND, $1, $1, $3); free_temp(&table); $$ = $3;} ;
Cond : E tOR E {generate_instruction_3(&array, OR, $1, $1, $3); free_temp(&table); $$ = $3;} ;
Cond : tNOT Cond {generate_instruction_2(&array, NOT, $2, $2); $$ = $2;} ;
Cond : E {$$ = $1; };




Invocation : tVAR tPO  Args  tPF {printf("Dans invocation\n");};

//Print : tPRINT tPO E tPF tPV {gen_print(&table, &array, $3);};
Print : tPRINT tPO E tPF tPV {generate_instruction_1(&array, PRI, $3); free_temp(&table);};

//Return : tRETURN E tPV {$$ = gen_return(&table, &array, $2);};
Return : tRETURN E tPV {$$ = generate_instruction_1(&array, RET, $2); free_temp(&table);};

%%
#include <stdio.h>
void main(void){
    //TODO: rajouter gestion des erreurs
    initialise_table(&table);
    initialise_asm(&array);
    yyparse();
    print_table(&table);
    //remove_symboles(&table, 0);
    //print_table(&table);
    exportInstructions(&array);
}