moncup.cup

/*
    Cyril ISELI, Marco RODRIGUES
    
    Janvier 2017

    GRAMMAIRE HEPIAL
*/

import java_cup.runtime.*;
import java.util.*;
import java.io.*;
import TDS.*;
import TDS.Entrees.*;
import TDS.Symboles.*;
import TDS.Types.*;
import ArbreAbstrait.*;
import ArbreAbstrait.Arithmetiques.*;
import ArbreAbstrait.Instructions.*;
import ArbreAbstrait.Relations.*;
import ArbreAbstrait.Expressions.*;
import outils.*;




parser code {:
    private Lexer lexer = (Lexer)getScanner();
    private TDS tds = TDS.getInstance();
    private Type dernierType;
    private int ligne = 0;
    private Stack<ArbreAbstrait> pileArbres = new Stack<ArbreAbstrait>();
:}

//--------------------Terminaux----------------------------------------
//mot clef
terminal DEBUT_PRG, FIN_PRG, PROGRAMME, DEBUT_FONC, FIN_FONC, RETOURNE;
//type
terminal TypeEntier ENTIER;
terminal TypeBoolean BOOLEEN;
terminal int CONSTANTE_ENT;
terminal String IDENT, CONSTANTE_CHAINE;
terminal CONSTANTE, VRAI, FAUX;
//operateur
terminal PARENTHESE_OUVRANTE, PARENTHESE_FERMANTE, VIRGULE, EGAL, POINT_VIRGULE, CROCHET_OUVRANT, CROCHET_FERMANT, POINT_POINT, PLUS, MOINS, FOIS, DIVISER, EGAL_EGAL, DIFFERENT, PLUS_PETIT, PLUS_PETIT_OU_EGAL, PLUS_GRAND, PLUS_GRAND_OU_EGAL, ET, OU, TILDE, NON;
//IO
terminal LIRE, ECRIRE;
//condition
terminal SI, ALORS, SINON, FIN_SI;
//boucle
terminal TANT_QUE, FAIRE, FIN_TANT_QUE, POUR, ALLANT_DE, A, FIN_POUR;

//--------------------Non Terminaux------------------------------------
non terminal axiome, programme, entete, decla, decla_var, decla_const, decla_fonc, decla_fonc_debut, decla_fonc_fin, type, type_base, tableau, dim, param, corps, instr, lire, ecrire, affectation, retour, condition, tant_que, pour, expr, acces, index, operande, ope_un, appel_fct, par_eff, instrTemp, indexTemp, declas;
non terminal ArrayList<String> lident;
non terminal String ope_bin;

//--------------------Precedences--------------------------------------
precedence left PLUS, MOINS, FOIS, DIVISER, EGAL_EGAL, DIFFERENT, PLUS_PETIT, PLUS_PETIT_OU_EGAL, PLUS_GRAND, PLUS_GRAND_OU_EGAL, ET, OU, POINT_POINT;
precedence right TILDE, NON;


//-------------------Regles de grammaire--------------------------------
axiome ::= programme {:
    System.out.println(tds);
    AnalyseurSemantique.getInstance().analyse((Bloc)pileArbres.peek());
    Erreurs.afficher();
    GenerateurByteCode.getInstance().generer(pileArbres.peek());
:};
programme ::= entete declas DEBUT_PRG corps FIN_PRG
{:
    tds.sortieBloc();
    Linstr linstr = (Linstr)pileArbres.pop();
    ((Bloc) pileArbres.peek()).add(linstr);
:};
entete ::= PROGRAMME IDENT
{:
    pileArbres.push(new Bloc(0)); 
    tds.entreeBloc();
:};
declas ::= decla declas | decla;
decla ::= decla_var | decla_const | decla_fonc;
decla_var ::= type lident:identifiants POINT_VIRGULE
{:
	for (String identifiant : identifiants) {
        Entree e = new EntreeEntBool(new Ident(identifiant));  
        Symbole s = new SymboleEntBool(ligne, dernierType);
        tds.ajouter(e, s);
    }
:};
lident ::= IDENT:identifiant
{:
	ligne = lexer.getLine();
    ArrayList<String> identifiants = new ArrayList<String>();
    identifiants.add(identifiant);	
	RESULT = identifiants;
:}
| lident:identifiants VIRGULE IDENT:identifiant
{:
	identifiants.add(identifiant);
	RESULT = identifiants;
:};
decla_const ::= CONSTANTE type IDENT:identifiant EGAL expr POINT_VIRGULE
{:
    Expression expr = (Expression)pileArbres.pop();
    Entree e = new EntreeEntBool(new Ident(identifiant));
    Symbole s = new SymboleEntBool(lexer.getLine(), dernierType);
    tds.ajouter(e, s);
   ((Bloc) pileArbres.peek()).add(new Affectation(new Idf(identifiant, lexer.getLine()), expr, lexer.getLine()));
:};
decla_fonc ::=  decla_fonc_debut param decla_fonc_fin
              | decla_fonc_debut decla_fonc_fin;
decla_fonc_debut ::= type IDENT:identifiant PARENTHESE_OUVRANTE
{:
        pileArbres.push(new Bloc(lexer.getLine())); 
        ligne = lexer.getLine();
        tds.entreeBloc();
        Entree e = new EntreeFonction(new Ident(identifiant));
        Symbole s = new SymboleFonction(ligne, dernierType);
        tds.ajouter(e, s);
:};
decla_fonc_fin ::= PARENTHESE_FERMANTE decla DEBUT_FONC corps FIN_FONC
{:
    tds.sortieBloc();
    Linstr linstr = (Linstr)pileArbres.pop();
    ((Bloc) pileArbres.peek()).add(linstr);
:};
type ::= type_base | tableau;
type_base ::= ENTIER {: dernierType = TypeEntier.getInstance(); :} | BOOLEEN  {: dernierType = TypeBooleen.getInstance(); :};
tableau ::= type_base CROCHET_OUVRANT dim CROCHET_FERMANT;
dim ::= expr POINT_POINT expr {: :} | dim VIRGULE expr POINT_POINT expr;
param ::= type IDENT:identifiant
{:
        Entree e = new EntreeEntBool(new Ident(identifiant));
        Symbole s = new SymboleEntBool(ligne, dernierType);
        tds.ajouter(e, s);
:}
 | param VIRGULE type IDENT;
corps ::= corps instr
{:
    Instruction i = (Instruction) pileArbres.pop();
    Linstr linstr = (Linstr) pileArbres.pop();
    linstr.add(i);
    pileArbres.push(linstr); 
:}
|
{:
    pileArbres.push(new Linstr(lexer.getLine()));
:};

instr ::= affectation {: System.out.println("affectation"); :} |
ecrire {: System.out.println("écrire"); :} |
lire {: System.out.println("lire"); :} |
condition {: System.out.println("condition"); :} |
retour {: System.out.println("retour"); :} |
tant_que {: System.out.println("tant que"); :} |
pour {: System.out.println("pour"); :};
lire ::= LIRE IDENT:identifiant POINT_VIRGULE
{:
    Idf id = new Idf(identifiant, lexer.getLine());
    pileArbres.push(new Lire(id,lexer.getLine())); 
:};
ecrire ::= ECRIRE expr POINT_VIRGULE
{:
    Expression exp = (Expression)(pileArbres.pop());
    pileArbres.push(new Ecrire(exp,lexer.getLine()));
:}
| ECRIRE CONSTANTE_CHAINE:texte POINT_VIRGULE
{:
    pileArbres.push(new Ecrire(texte,lexer.getLine()));
:};
affectation ::= acces EGAL expr POINT_VIRGULE
{:
    Expression source = (Expression) (pileArbres.pop());
    Idf dest = (Idf)(pileArbres.pop());
    pileArbres.push(new Affectation(dest, source, lexer.getLine())); 
:};
retour ::= RETOURNE expr POINT_VIRGULE
{:
    Expression expr = (Expression) (pileArbres.pop());
    pileArbres.push(new Retour(expr,lexer.getLine())); 
:};
condition ::= SI expr ALORS corps SINON corps FIN_SI
{:
    
    Linstr sinon = (Linstr) (pileArbres.pop());
    Linstr alors = (Linstr) (pileArbres.pop());
    Expression ec = (Expression) (pileArbres.pop());
    pileArbres.push(new Condition(ec, alors, sinon,lexer.getLine())); 
:};
tant_que ::= TANT_QUE expr FAIRE corps FIN_TANT_QUE
{:
    Linstr faire = (Linstr) (pileArbres.pop());
    Expression ec = (Expression)pileArbres.pop();
    //pileArbres.push(new TantQue(ec,faire));
:};
pour ::= POUR IDENT:identifiant ALLANT_DE expr A expr FAIRE corps FIN_POUR
{:
    Linstr faire = (Linstr) (pileArbres.pop());
    Expression ecFin = (Expression)pileArbres.pop();
    Expression ecDebut = (Expression)pileArbres.pop();
    Idf id = new Idf(identifiant, lexer.getLine());
    pileArbres.push(new Pour(id, ecDebut,ecFin,faire, lexer.getLine())); 
:};
expr ::= expr ope_bin:operateur expr
{:
    Expression d = (Expression)pileArbres.pop();
    Expression g = (Expression)pileArbres.pop();
    switch (operateur) {
        case "+":
            pileArbres.push(new Addition(g, d, ligne)); 
            break;
        case "-":
            pileArbres.push(new Soustraction(g, d, ligne)); 
            break;
        case "*":
            pileArbres.push(new Produit(g, d, ligne)); 
            break;
        case "/":
            pileArbres.push(new Division(g, d, ligne)); 
            break;
        case "==":
            pileArbres.push(new Egal(g, d, ligne)); 
            break;
        case "<>":
            pileArbres.push(new Different(g, d, ligne)); 
            break;
        case "<=":
            pileArbres.push(new InfEgal(g, d, ligne)); 
            break;
        case ">=":
            pileArbres.push(new SupEgal(g, d, ligne)); 
            break;
        case "<":
            pileArbres.push(new Inferieur(g, d, ligne)); 
            break;
        case ">":
            pileArbres.push(new Superieur(g, d, ligne)); 
            break;
    }
:}
| ope_un expr | PARENTHESE_OUVRANTE expr PARENTHESE_FERMANTE | operande;
acces ::= IDENT:identifiant
{:
    pileArbres.push(new Idf(identifiant, ligne));
:}
 | IDENT indexTemp;
indexTemp ::= index indexTemp;
index ::= CROCHET_OUVRANT expr CROCHET_FERMANT;
operande ::= acces | appel_fct | CONSTANTE_ENT:val {: pileArbres.push(new Nombre(val,lexer.getLine()));  :}
            | VRAI {: pileArbres.push(new Booleen(true, lexer.getLine()));  :}
            | FAUX {: pileArbres.push(new Booleen(false, lexer.getLine()));  :};
ope_bin ::= PLUS {: RESULT = "+"; :}
            | MOINS {: RESULT = "-"; :}
            | FOIS {: RESULT = "*"; :}
            | DIVISER {: RESULT = "/"; :}
            | EGAL_EGAL {: RESULT = "=="; :}
            | DIFFERENT {: RESULT = "<>"; :}
            | OU {: RESULT = "ou"; :}
            | ET {: RESULT = "et"; :}
            | PLUS_PETIT {: RESULT = "<"; :}
            | PLUS_PETIT_OU_EGAL {: RESULT = "<="; :}
            | PLUS_GRAND {: RESULT = ">"; :}
            | PLUS_GRAND_OU_EGAL {: RESULT = ">="; :};
ope_un ::= TILDE | NON;
appel_fct ::= IDENT PARENTHESE_OUVRANTE PARENTHESE_FERMANTE | IDENT PARENTHESE_OUVRANTE par_eff PARENTHESE_FERMANTE;
par_eff ::= expr | par_eff VIRGULE expr;