parser.cup

/*
   Grammaire attribuée pour construire l'arbre abstrait correspondant au langage Block
*/

package fr.n7.stl.block;

import java_cup.runtime.*;
import fr.n7.stl.block.Lexer;
import java.io.*;
import java.util.*;

// Elements du métamodèle pour la construction de l'arbre abstrait
import fr.n7.stl.block.ast.*;
import fr.n7.stl.block.ast.expression.*;
import fr.n7.stl.block.ast.expression.accessible.*;
import fr.n7.stl.block.ast.expression.allocation.*;
import fr.n7.stl.block.ast.expression.assignable.*;
import fr.n7.stl.block.ast.expression.value.*;
import fr.n7.stl.block.ast.instruction.*;
import fr.n7.stl.block.ast.instruction.declaration.*;
import fr.n7.stl.block.ast.scope.*;
import fr.n7.stl.block.ast.type.*;
import fr.n7.stl.poo.call.*;

import fr.n7.stl.poo.declaration.*;
import fr.n7.stl.block.poo.methode.*;
import fr.n7.stl.poo.definition.*;
import fr.n7.stl.poo.type.*;
import fr.n7.stl.block.ast.type.declaration.*;
import fr.n7.stl.tam.ast.*;
import fr.n7.stl.tam.ast.impl.*;
import fr.n7.stl.util.*;

/* Variables partagées dans les actions de l'analyseur syntaxique. */
parser code {:
	protected Lexer lexer;
	protected String name;
    public String getName() {
       return this.name;
    }
	public Parser(String _name) {
		this();
		this.name = _name;
	}
:}

/* Initialisation de l'analyseur lexical et des variables partagées. */
init with {:
  ComplexSymbolFactory f = new ComplexSymbolFactory();
  symbolFactory = f;
  File file = new File(this.name);
  FileInputStream fis = null;
  try {
    fis = new FileInputStream(file);
  } catch (IOException e) {
    e.printStackTrace();
  } 
  lexer = new Lexer(f,fis);
:};

/* Expression qui permet de progresser dans l'analyse lexicale. */
scan with {: return lexer.next_token(); :};

/* Terminaux qui seront transmis par l'analyseur lexical. */
terminal 			UL_Point_Virgule, UL_Virgule, UL_Point, UL_Deux_Points, UL_Point_Interrogation, UL_Point_Exclamation;
terminal				UL_Egal, UL_Double_Plus, UL_Double_Moins, UL_Double_Plus_Prefixe, UL_Double_Moins_Prefixe;
terminal 			UL_Plus, UL_Moins, UL_Moins_Unaire, UL_Asterisque, UL_Oblique, UL_Pour_Cent;
terminal				UL_Esperluette, UL_Double_Barre, UL_Double_Esperluette;
terminal				UL_Parenthese_Ouvrante, UL_Parenthese_Fermante;
terminal				UL_Comme, UL_Premier, UL_Second;
terminal				UL_Accolade_Ouvrante, UL_Accolade_Fermante;
terminal				UL_Crochet_Ouvrant, UL_Crochet_Fermant;
terminal				UL_Inferieur, UL_Superieur;
terminal				UL_Inferieur_Egal, UL_Superieur_Egal;
terminal				UL_Double_Egal, UL_Exclamation_Egal;
terminal				UL_Si, UL_Sinon, UL_Tant_Que, UL_Nouveau, UL_Afficher, UL_Retour;
terminal				UL_Definition_Constante, UL_Definition_Type, UL_Enregistrement, UL_Enumeration;
terminal				UL_Type_Booleen, UL_Type_Caractere, UL_Type_Chaine, UL_Type_Entier, UL_Type_Flottant, UL_Type_Vide;
terminal 				UL_Interface, UL_Extends, UL_Final, UL_Abstract, UL_Public, UL_Private, UL_Static, UL_Class, UL_Implements, UL_Protected, UL_This,UL_SUPER, UL_Construct, UL_ARGS;

terminal String		UL_Identificateur, UL_Identificateur_Type, UL_Chaine, UL_Caractere;
terminal String		UL_Nombre_Entier, UL_Nombre_Flottant, UL_Nul, UL_Vrai, UL_Faux; // Valeur transmise par l'analyseur lexical

/* Non terminaux avec type renvoyé par actions sémantiques (RESULT = ...) */
non terminal Block							Program;
non terminal Block							Bloc;
non terminal List<Instruction>				Instructions;
non terminal Instruction					Instruction;
non terminal Instruction					Declaration;
non terminal List<Expression> Expressions;
non terminal List<FieldDeclaration>			Champs;
non terminal FieldDeclaration				Champ;
non terminal List<LabelDeclaration>			Etiquettes;
non terminal LabelDeclaration				Etiquette;
non terminal List<ParameterDeclaration>		Parameters;
non terminal Pair<String,PartialType>		Identifiant;
non terminal Type							Type, Atomique;
non terminal Expression Expression;
non terminal AssignableExpression			Affectable;

non terminal List<ContainerDeclaration>			Programs;
non terminal List<ContainerDeclaration>			Containers;
non terminal ContainerDeclaration				Container;
non terminal ClasseDeclaration 			Classe;
non terminal InterfaceDeclaration 		Interface;
non terminal Extension 					Extension;
non terminal List<Instanciation> 		Implementations;
non terminal Integer 					FinalOrAbstract;
non terminal PooDeclaration	 			PooDeclaration;
non terminal List<GenericTypeDeclaration> 		GenDeclarations;
non terminal GenericTypeDeclaration 	GenDeclaration;
non terminal List<Instanciation> 		ExtendsGenDeclaration;
non terminal List<Instanciation> 		ExtensionsI;
non terminal Instanciation		 		Instanciation;

non terminal List<Instanciation> 		Instanciations;
non terminal List<MethodeSignature>		Entetes;
non terminal MethodeSignature	 		Entete;

non terminal List<Definition> 			Definitions;
non terminal Definition					Definition;
non terminal Methode					Methode;
non terminal Attribut					Attribut;
non terminal Attribut					AttributFinal;
non terminal Boolean 					PublicOrPrivate;
non terminal Boolean 					Static;

/* Associativité et Priorité relative des opérateurs (du moins prioritaire au plus prioritaire) */
/* Opérateur le moins prioritiaire */
// precedence nonassoc UL_Parenthese_Fermante;	// Résolution du conflit décaler/réduire sur conversion de type
precedence right UL_Egal;
precedence nonassoc UL_Point_Interrogation, UL_Deux_Points;
precedence left UL_Double_Barre;
precedence left UL_Double_Esperluette;
precedence nonassoc UL_Double_Egal, UL_Exclamation_Egal;
precedence nonassoc UL_Inferieur, UL_Inferieur_Egal, UL_Superieur, UL_Superieur_Egal;
precedence left UL_Plus, UL_Moins;
precedence left UL_Asterisque, UL_Oblique, UL_Pour_Cent;
precedence right UL_Nouveau;
precedence left UL_Premier, UL_Second;
precedence left UL_Double_Plus_Prefixe, UL_Double_Moins_Prefixe, UL_Moins_Unaire, UL_Esperluette, UL_Point_Exclamation;
precedence nonassoc UL_Double_Plus, UL_Double_Moins;
precedence left UL_Crochet_Ouvrant, UL_Point, UL_Parenthese_Ouvrante;
/* Opérateur le plus prioritaire */

/* Règles de grammaire attribuée pour la construction de l'arbre abstrait */
/* Program et Bloc sont des non terminaux */
/* UL_Identificateur est un terminal (Unité lexicale) */
/* bloc est la variable utilisable dans l'action sémantique qui contient la valeur renvoyé par l'analyse du Bloc */
Program ::= Containers : containers
			{:
//				System.out.println( "Block named : " + nom );
//				System.out.println( bloc );
				SymbolTable tds = new SymbolTable();
				boolean resolveResult = true;
				for(ContainerDeclaration cd : containers){
                    if (cd instanceof ClasseDeclaration){
                                ClasseDeclaration cld = (ClasseDeclaration) cd;
                                resolveResult =  cld.resolvePre(tds) && resolveResult;
                            }else{
                        InterfaceDeclaration id = (InterfaceDeclaration) cd;
                        resolveResult = id.resolvePre(tds) && resolveResult;
				        }
				}
				for(ContainerDeclaration cd : containers){
					if (cd instanceof ClasseDeclaration){
						ClasseDeclaration cld = (ClasseDeclaration) cd;
						resolveResult = cld.completeResolve(tds) && resolveResult;
					}else{
						InterfaceDeclaration id = (InterfaceDeclaration) cd;
						resolveResult = id.completeResolve(tds) && resolveResult;
					}

				}
				if(!resolveResult)
				    System.out.println("Resolve not working");
				else {

				    System.out.println("Resolve Worked");

				    boolean typeResult = true;

				    for(ContainerDeclaration cd : containers){
				        if (cd instanceof ClasseDeclaration){
				            ClasseDeclaration cld = (ClasseDeclaration) cd;
				            typeResult =  cld.checkType() && typeResult;
				        }else{
							InterfaceDeclaration id = (InterfaceDeclaration) cd;
							typeResult = id.checkType() && typeResult;
				            }
				    }
				    if(!typeResult)
				        System.out.println("CheckType failed");
				    else{

				        System.out.println("CheckType Worked");

				        int size = 0 ;

				        for(ContainerDeclaration cd : containers){
				            if(cd instanceof ClasseDeclaration){
				                ClasseDeclaration cld = (ClasseDeclaration) cd;
				                size += cld.allocateMemory(Register.CB,size);
				            }
				        }

						TAMFactoryImpl factory = new TAMFactoryImpl();
						Fragment code = factory.createFragment();
						for(ContainerDeclaration cd : containers){
							if (cd instanceof ClasseDeclaration)
							{
//							            Fragment codeOfclass = cld.getCode(factory);
//							            code.append(codeOfclass);
										ClasseDeclaration cld = (ClasseDeclaration) cd;
										code.append(cld.getCode(factory));


							}
							else{
							//    InterfaceDeclaration id = (InterfaceDeclaration) cd;
							  //  typeResult = id.getCode(factory);
							}
						}

						for(ContainerDeclaration cd : containers){
							if (cd instanceof ClasseDeclaration)
							{
								ClasseDeclaration cld = (ClasseDeclaration) cd;
								Methode main = cld.getMain();
//								if(main != null)
//								{
//									main.allocateMemory(Register.SB,size);
//									code.append(main.getCode(factory));
//								}
							}
						}

						code.add(factory.createHalt());
						File file = new File(parser.getName() + "_tam");
						PrintStream printer = null;
						    try {
						        printer = new PrintStream( new FileOutputStream(file) );
						        printer.println( code );
						    } catch (IOException e) {
						        e.printStackTrace();
						    }

					}

				}

			:}
		;

Containers ::= Containers : containers Container : container
			{:
				containers.add(container);
				RESULT = containers;
			:}

			|{:
				List<ContainerDeclaration> newContainer = new LinkedList<ContainerDeclaration>();
				RESULT = newContainer;
			:}
		;
Container ::= Interface : interf
			{:
				RESULT = interf;
			:}
			| Classe : classe
			{:

				RESULT = classe;
			:}
		;
Interface ::= UL_Interface PooDeclaration : declaration ExtensionsI : extensionsI UL_Accolade_Ouvrante Entetes : entetes UL_Accolade_Fermante
			{:
				RESULT = new InterfaceDeclaration(declaration, extensionsI, entetes);
			:}
		;
Classe ::=  UL_Class PooDeclaration : declaration Extension : extension Implementations:implementations  UL_Accolade_Ouvrante Definitions : definitions UL_Accolade_Fermante
			{:
				RESULT = new ClasseDeclaration(0, declaration, extension, implementations, definitions);
			:}
			| FinalOrAbstract : fOrA UL_Class PooDeclaration : declaration Extension : extension Implementations:implementations  UL_Accolade_Ouvrante Definitions : definitions UL_Accolade_Fermante
			{:
				RESULT = new ClasseDeclaration(fOrA, declaration, extension,implementations, definitions);
			:}
		;

Extension ::=  UL_Extends Instanciation:instanciation
        	{:

            RESULT = new Extension(instanciation);
        	:}
        	|
        	{:
            RESULT = new Extension();
        	:}
        ;

Implementations ::= UL_Implements Instanciations:instanciations
			{:
				RESULT = instanciations;
			:}
			|
			{:
				RESULT = new LinkedList<Instanciation>();
			:}
		;

FinalOrAbstract ::= UL_Final
            {:
                RESULT = 2;
            :}
            | UL_Abstract
            {:
                RESULT = 1;
            :}
		;

PooDeclaration ::= UL_Identificateur_Type:name UL_Inferieur GenDeclarations : genDeclarations UL_Superieur
				{:
					RESULT = new PooDeclaration (name, genDeclarations);
				:}
				| UL_Identificateur_Type:name
				{:
					RESULT = new PooDeclaration (name);
				:}
			;

GenDeclarations ::= GenDeclaration :genDeclaration
				{:
					LinkedList<GenericTypeDeclaration> result = new LinkedList<GenericTypeDeclaration>();
					result.add(genDeclaration);
					RESULT = result;
				:}
				| GenDeclarations:genDeclarations UL_Virgule GenDeclaration :genDeclaration
				{:
					genDeclarations.add(genDeclaration);
					RESULT = genDeclarations;
				:}
			;

GenDeclaration ::= UL_Identificateur_Type:nom
				{:
					RESULT = new GenericTypeDeclaration(nom);
				:}
				| UL_Identificateur_Type:nom ExtendsGenDeclaration:extendsGenDeclaration
				{:
					RESULT = new GenericTypeDeclaration(nom,extendsGenDeclaration);
				:};

ExtendsGenDeclaration ::= Instanciation:instanciation
				{:
					LinkedList<Instanciation> result = new LinkedList<Instanciation>();
					result.add(instanciation);
					RESULT = result;

				:}
				| ExtendsGenDeclaration : extendsGenDeclaration UL_Esperluette Instanciation : instanciation
				{:
					extendsGenDeclaration.add(instanciation);
					RESULT = extendsGenDeclaration;
				:}
			;
ExtensionsI ::= UL_Extends Instanciations : instanciations
			{:
				RESULT = instanciations;
			:}
			|{:
				RESULT = new LinkedList<Instanciation>();
			:}
		;


Instanciation ::= UL_Identificateur_Type:nom
		{:
			RESULT = new Instanciation(nom);
		:}
		| UL_Identificateur_Type:nom UL_Inferieur Instanciations:instanciations UL_Superieur
		{:
			RESULT = new Instanciation(nom,instanciations);
		:}

	;

Instanciations ::= Instanciation:instanciation
	    {:
			LinkedList<Instanciation> result = new LinkedList<Instanciation>();
			result.add(instanciation);
			RESULT = result;
		:}
		| Instanciations:instanciations UL_Virgule Instanciation:instanciation
		{:
			instanciations.add(instanciation);
			RESULT = instanciations;
		:}
	;
Entetes ::= Entetes:entetes Entete:entete UL_Point_Virgule
		{:
			entetes.add(entete);
			RESULT = entetes;
		:}
		|{:
			RESULT = new LinkedList<MethodeSignature>();
		:}
	;
Entete ::= Type:type UL_Identificateur:nom UL_Parenthese_Ouvrante Parameters: parameters UL_Parenthese_Fermante
		{:
			RESULT = new MethodeSignature(nom,type,parameters);
		:}
		| Type:type UL_Identificateur:nom UL_Parenthese_Ouvrante UL_Parenthese_Fermante
		{:
			RESULT = new MethodeSignature(nom,type,null);
		:}
 		| Type:type UL_Identificateur:nom UL_Parenthese_Ouvrante UL_ARGS UL_Parenthese_Fermante
		{:
			RESULT = new MethodeSignature(nom,type,null);
		:}

	;


Definitions ::= Definitions:definitions Definition:definition
		{:
			definitions.add(definition);
			RESULT = definitions;
		:}
		|
		{:
			RESULT = new LinkedList<Definition>();
		:}
	;



Definition ::= PublicOrPrivate:publicOrPrivate  Static:isStatic UL_Final AttributFinal:attribut
		{:
			RESULT = new Definition(publicOrPrivate,isStatic,2,attribut);
		:}
		|PublicOrPrivate:publicOrPrivate  Static:isStatic Attribut:attribut
		{:
			RESULT = new Definition(publicOrPrivate,isStatic,0,attribut);
		:}
		| PublicOrPrivate:publicOrPrivate  Static:isStatic UL_Final Methode:methode
		{:
 			RESULT = new Definition(publicOrPrivate,isStatic,2,methode);
		:}
		| PublicOrPrivate:publicOrPrivate  Static:isStatic UL_Abstract Methode:methode
		{:
 			RESULT = new Definition(publicOrPrivate,isStatic,1,methode);
		:}
		| PublicOrPrivate:publicOrPrivate  Static:isStatic Methode:methode
		{:
 			RESULT = new Definition(publicOrPrivate,isStatic,0,methode);
		:}
	    | PublicOrPrivate:publicOrPrivate UL_Construct Instanciation:instanciation UL_Parenthese_Ouvrante Parameters:params UL_Parenthese_Fermante Bloc:bloc
		{:
			Constructor construct = new Constructor(instanciation,params,bloc);
 			RESULT = new Definition(publicOrPrivate,construct);
		:}
		| PublicOrPrivate:publicOrPrivate UL_Construct Instanciation:instanciation UL_Parenthese_Ouvrante  UL_Parenthese_Fermante Bloc:bloc
		{:
			Constructor construct = new Constructor(instanciation,null,bloc);
			RESULT = new Definition(publicOrPrivate,construct);
		:}
	;

Static	::= UL_Static
		{:
			RESULT = true;

		:}
		|
		{:
			RESULT = false;
		:}
	;

PublicOrPrivate ::= UL_Public
				{:
					RESULT = true;
				:}
				| UL_Private
				{:
					RESULT = false;
				:}
			;

Methode ::=  Entete:entete Bloc:bloc
		{:
			RESULT = new Methode(entete,bloc,1);
		:}
		| Entete:entete UL_Point_Virgule
        		{:
        			RESULT = new Methode(entete,0);
        		:}

	;


Attribut ::= Type:type UL_Identificateur:ident UL_Point_Virgule
		 {:
			RESULT = new Attribut(type,ident);
		 :}
		| Type:type UL_Identificateur:ident UL_Egal Expression:expression UL_Point_Virgule
		{:
			RESULT  = new Attribut(type,ident,expression,false);
		:}
		|Instanciation:instanciation UL_Identificateur:ident UL_Egal Expression:expression UL_Point_Virgule
		{:
			RESULT  = new Attribut(instanciation,ident,expression,false);
		:}
	  ;

AttributFinal ::= Type:type UL_Identificateur:ident UL_Egal Expression:expression UL_Point_Virgule
		{:
			RESULT  = new Attribut(type,ident,expression,true);
		:}
	   ;

Bloc ::= UL_Accolade_Ouvrante Instructions:instructions UL_Accolade_Fermante
			{:
				RESULT = new Block( instructions );
			:}
		;

Champ ::= Type:type Identifiant:identifiant UL_Point_Virgule
			{:
				Type _type = identifiant.getRight();
				if (_type == null) {
					_type = type;
				} else {
					_type = ((PartialType)_type).complete( type );
 				}
				RESULT = new FieldDeclaration( identifiant.getLeft(), _type);
			:}
		;



Champs ::= Champs:champs Champ:champ
			{:
				champs.add(champ);
				RESULT = champs;
			:}
		| Champ:champ
			{:
				List<FieldDeclaration> _champs = new LinkedList<FieldDeclaration>();
				_champs.add(champ);
				RESULT = _champs;
			:}
		;

Etiquette ::= UL_Identificateur:nom
				{:
					RESULT = new LabelDeclaration( nom );
				:}
			;

Etiquettes ::= Etiquettes:etiquettes UL_Virgule Etiquette:etiquette
			{:
				etiquettes.add(etiquette);
				RESULT = etiquettes;
			:}
		| Etiquette:etiquette
			{:
				List<LabelDeclaration> _etiquettes = new LinkedList<LabelDeclaration>();
				_etiquettes.add(etiquette);
				RESULT = _etiquettes;
			:}
		;

Atomique ::= UL_Type_Booleen
			{:
				RESULT = AtomicType.BooleanType;
			:}
		|	UL_Type_Caractere
			{:
				RESULT = AtomicType.CharacterType;
			:}
		|	UL_Type_Chaine
			{:
				RESULT = AtomicType.StringType;
			:}
		|	UL_Type_Entier
			{:
				RESULT = AtomicType.IntegerType;
			:}
		|	UL_Type_Flottant
			{:
				RESULT = AtomicType.FloatingType;
			:}
		|	UL_Type_Vide
			{:
				RESULT = AtomicType.VoidType;
			:}
		;

Type ::= Atomique:atomique
			{:
				RESULT = atomique;
			:}

		| UL_Enumeration UL_Identificateur_Type:nom UL_Accolade_Ouvrante Etiquettes:etiquettes UL_Accolade_Fermante
			{:
				RESULT = new EnumerationType( nom, etiquettes );
			:}

		;

Instructions ::= Instructions:instructions Instruction:instruction
				{:
					instructions.add( instruction );
					RESULT = instructions;
				:}
			|
				{: RESULT = new LinkedList<Instruction>(); :}
			;

Identifiant ::= UL_Identificateur:nom
				{:
					RESULT = new Pair<String,PartialType>( nom, null );
				:}
			| Identifiant:identifiant UL_Crochet_Ouvrant UL_Crochet_Fermant
				{:
					if (identifiant.getRight() == null) {
						identifiant.setRight( new PartialArrayType() );
					} else {
						identifiant.getRight().enrich(new PartialArrayType());
					}
					RESULT = identifiant;
				:}
			| UL_Parenthese_Ouvrante Identifiant:identifiant UL_Parenthese_Fermante
				{:
					RESULT = identifiant;
				:}
			;

Parameters ::= Parameters:parameters UL_Virgule Type:type Identifiant:identifiant
				{:
					Type _type = identifiant.getRight();
					if (_type == null) {
						_type = type;
					} else {
						_type = ((PartialType)_type).complete( type );
 					}
					parameters.add( new ParameterDeclaration( identifiant.getLeft(), _type) );
					RESULT = parameters;
				:}
			| Type:type Identifiant:identifiant
				{:
					List<ParameterDeclaration> _parameters = new LinkedList<ParameterDeclaration>();
					Type _type = identifiant.getRight();
					if (_type == null) {
						_type = type;
					} else {
						_type = ((PartialType)_type).complete( type );
 					}
					_parameters.add( new ParameterDeclaration( identifiant.getLeft(), _type) );
					RESULT = _parameters;
				:}
			;

Declaration ::= Type:type Identifiant:identifiant UL_Egal Expression:valeur UL_Point_Virgule
				{:
					Type _type = identifiant.getRight();
					if (_type == null) {
						_type = type;
					} else {
						_type = ((PartialType)_type).complete( type );
 					}
					RESULT = new VariableDeclaration( identifiant.getLeft(), _type, valeur);
				:}
				| Instanciation:instanciation Identifiant:identifiant UL_Egal Expression:valeur UL_Point_Virgule
				{:
					Type _type = identifiant.getRight();
					if (_type == null) {
						_type = instanciation;
					} else {
						_type = ((PartialType)_type).complete( instanciation );
 					}
					RESULT = new VariableDeclaration( identifiant.getLeft(), _type, valeur);
				:}

			;

Instruction ::= Declaration:declaration
				{:
					RESULT = declaration;
				:}
			| Affectable:affectable UL_Egal Expression:expression UL_Point_Virgule
				{:
					RESULT = new Assignment( affectable, expression);
				:}
			| UL_Afficher Expression:expression UL_Point_Virgule
				{:
					RESULT = new Printer( expression );
				:}
			| UL_Si UL_Parenthese_Ouvrante Expression:condition UL_Parenthese_Fermante Bloc:alors UL_Sinon Bloc:sinon
				{:
					RESULT = new Conditional( condition, alors, sinon);
				:}
			| UL_Si UL_Parenthese_Ouvrante Expression:condition UL_Parenthese_Fermante Bloc:alors
				{:
					RESULT = new Conditional( condition, alors);
				:}
			| UL_Tant_Que UL_Parenthese_Ouvrante Expression:condition UL_Parenthese_Fermante Bloc:corps
				{:
					RESULT = new Repetition( condition, corps);
				:}
			| UL_Retour Expression:expression UL_Point_Virgule
				{:
					RESULT = new Return( expression);
				:}
			|UL_SUPER UL_Parenthese_Ouvrante UL_Parenthese_Fermante UL_Point_Virgule
        	    {:
        	        RESULT = new SuperClass();
        	    :}
        	|UL_SUPER UL_Parenthese_Ouvrante Expressions:parametres UL_Parenthese_Fermante UL_Point_Virgule
        	    {:
        	        RESULT = new SuperClass(parametres);
        	    :}


			;

Expressions ::= Expressions:expressions UL_Virgule Expression:expression
				{:
					expressions.add( expression );
					RESULT = expressions;
				:}
            | Expression:expression
            		{:
					List<Expression> _expressions = new LinkedList<Expression>();
					_expressions.add( expression );
					RESULT = _expressions;
				:}
            ;

Affectable ::= UL_Identificateur:nom
				{:
					RESULT = new VariableAssignment( nom );
				:}
			| UL_This UL_Point UL_Identificateur:attribut
            	{:
            		RESULT = new AttributAssignement(attribut);
           		:}
			| Affectable:tableau UL_Crochet_Ouvrant Expression:indice UL_Crochet_Fermant
				{:
					RESULT = new ArrayAssignment( tableau, indice);
				:}
			| UL_Parenthese_Ouvrante Affectable:affectable UL_Parenthese_Fermante
				{:
					RESULT = affectable;
				:}
			| UL_Parenthese_Ouvrante Type:type UL_Parenthese_Fermante Affectable:affectable
             	{:
					RESULT = new AssignableConversion( affectable, type);
				:}
			| Affectable:enregistrement UL_Point UL_Identificateur:etiquette
				{:
					RESULT = new FieldAssignment( enregistrement, etiquette);
				:}

			;

Expression ::= /*Affectable:affectable UL_Egal Expression:expression
				{:
					RESULT = new Assignment( affectable, expression);
				:}
			| */ Expression:gauche UL_Double_Egal Expression:droite
				{:
					RESULT = new BinaryExpression( gauche, BinaryOperator.Equals, droite);
				:}
			| Expression:gauche UL_Exclamation_Egal Expression:droite
				{:
					RESULT = new BinaryExpression( gauche, BinaryOperator.Different, droite);
				:}
			| Expression:gauche UL_Inferieur Expression:droite
				{:
					RESULT = new BinaryExpression( gauche, BinaryOperator.Lesser, droite);
				:}
			| Expression:gauche UL_Superieur Expression:droite
				{:
					RESULT = new BinaryExpression( gauche, BinaryOperator.Greater, droite);
				:}
			| Expression:gauche UL_Inferieur_Egal Expression:droite
				{:
					RESULT = new BinaryExpression( gauche, BinaryOperator.LesserOrEqual, droite);
				:}
			| Expression:gauche UL_Superieur_Egal Expression:droite
				{:
					RESULT = new BinaryExpression( gauche, BinaryOperator.GreaterOrEqual, droite);
				:}
			| Expression:gauche UL_Double_Barre Expression:droite
				{:
					RESULT = new BinaryExpression( gauche, BinaryOperator.Or, droite);
				:}
            | Expression:gauche UL_Double_Esperluette Expression:droite
             	{:
					RESULT = new BinaryExpression( gauche, BinaryOperator.And, droite);
				:}
			| Expression:gauche UL_Plus Expression:droite
				{:
					RESULT = new BinaryExpression( gauche, BinaryOperator.Add, droite);
				:}
            | Expression:gauche UL_Moins Expression:droite
             	{:
					RESULT = new BinaryExpression( gauche, BinaryOperator.Substract, droite);
				:}
            | Expression:gauche UL_Asterisque Expression:droite
             	{:
					RESULT = new BinaryExpression( gauche, BinaryOperator.Multiply, droite);
				:}
			| Expression:gauche UL_Oblique Expression:droite
             	{:
					RESULT = new BinaryExpression( gauche, BinaryOperator.Divide, droite);
				:}
			| Expression:gauche UL_Pour_Cent Expression:droite
             	{:
					RESULT = new BinaryExpression( gauche, BinaryOperator.Modulo, droite);
				:}
            | UL_Moins Expression:expression
             	{:
					RESULT = new UnaryExpression( UnaryOperator.Opposite, expression);
				:}
            | UL_Point_Exclamation Expression:expression
             	{:
					RESULT = new UnaryExpression( UnaryOperator.Negate, expression);
				:}
			| Expression:expression UL_Crochet_Ouvrant Expression:indice UL_Crochet_Fermant
				{:
					RESULT = new ArrayAccess( expression, indice );
				:}
	//		| Expression:expression UL_Point UL_Identificateur:etiquette      ///////////////////////////// conflicts////////////////////
	//			{:
	//				RESULT = new FieldAccess( expression, etiquette );
	//			:}
       		| Expression:expression UL_Point UL_Identificateur:attribut
				{:
					RESULT = new AttributAccess(expression, attribut);
				:}
			| UL_This UL_Point UL_Identificateur:attribut
                    {:
                       RESULT = new AttributAssignement(attribut);
                       :}
			| Expression:condition UL_Point_Interrogation Expression:alors UL_Deux_Points Expression:sinon
				{:
					RESULT = new ConditionalExpression( condition, alors, sinon);
				:}
			| UL_Parenthese_Ouvrante Expression:expression UL_Parenthese_Fermante
             	{:
					RESULT = expression;
				:}
			| UL_Parenthese_Ouvrante Type:type UL_Parenthese_Fermante Expression:expression
             	{:
					RESULT = new AccessibleConversion( expression, type);
				:}
			| UL_Accolade_Ouvrante Expressions:expressions UL_Accolade_Fermante
             	{:
					RESULT = new Sequence( expressions );
				:}
			| UL_Identificateur:nom
             	{:
					RESULT = new IdentifierAccess( nom );
				:}

			|
				// Expression d'appel de méthode avec paramètres dont le résultat n'est pas de type void
				// Il s'agit d'un appel implicite sur l'objet contenu dans this ou sur la classe contenant l'expression en cours d'exécution
				// Il faut créer la classe MethodCall pour l'arbre abstrait en s'inspirant de FunctionCall
				UL_Identificateur:nom UL_Parenthese_Ouvrante Expressions:parametres UL_Parenthese_Fermante
             	{:
					RESULT = new MethodCall( nom, parametres );
				:}
			|
				// Expression d'appel de méthode sans paramètre dont le résultat n'est pas de type void
				// Il s'agit d'un appel implicite sur l'objet contenu dans this ou sur la classe contenant l'expression en cours d'exécution
				// Il faut créer la classe MethodCall pour l'arbre abstrait en s'inspirant de FunctionCall
				UL_Identificateur:nom UL_Parenthese_Ouvrante UL_Parenthese_Fermante
             	{:
					List<Expression> _parametres = new LinkedList<Expression>();
					RESULT = new MethodCall( nom, _parametres );
				:}
			|
				// Expression d'appel de méthode de classe avec paramètres dont le résultat n'est pas de type void
				// Il s'agit d'un appel explicite sur une classe
				// Il faut créer la classe MethodCall pour l'arbre abstrait en s'inspirant de FunctionCall
				Type:type UL_Point UL_Identificateur:nom UL_Parenthese_Ouvrante Expressions:parametres UL_Parenthese_Fermante
             	{:
					RESULT = new MethodCall( type, nom, parametres );
				:}
			|
				// Expression d'appel de méthode de classe sans paramètre dont le résultat n'est pas de type void
				// Il s'agit d'un appel explicite sur une classe
				// Il faut créer la classe MethodCall pour l'arbre abstrait en s'inspirant de FunctionCall
				Type:type UL_Point UL_Identificateur:nom UL_Parenthese_Ouvrante UL_Parenthese_Fermante
             	{:
					List<Expression> _parametres = new LinkedList<Expression>();
					RESULT = new MethodCall( type, nom, _parametres );
				:}
			|
				// Expression d'appel de méthode avec paramètres dont le résultat n'est pas de type void
				// Il s'agit d'un appel explicite sur un objet
				// Il faut créer la classe MethodCall pour l'arbre abstrait en s'inspirant de FunctionCall
				Expression:objet UL_Point UL_Identificateur:nom UL_Parenthese_Ouvrante Expressions:parametres UL_Parenthese_Fermante
             	{:
					RESULT = new MethodCall( objet, nom, parametres );
				:}
			|
				// Expression d'appel de méthode sans paramètre dont le résultat n'est pas de type void
				// Il s'agit d'un appel explicite sur un objet
				// Il faut créer la classe MethodCall pour l'arbre abstrait en s'inspirant de FunctionCall
				Expression:objet UL_Point UL_Identificateur:nom UL_Parenthese_Ouvrante UL_Parenthese_Fermante
             	{:
					List<Expression> _parametres = new LinkedList<Expression>();
					RESULT = new MethodCall( objet, nom, _parametres );
				:}


			| UL_Nombre_Entier:entier
             	{:
					RESULT = new IntegerValue( entier );
				:}
			| UL_Vrai
             	{:
					RESULT = BooleanValue.True;
				:}
			| UL_Faux
             	{:
					RESULT = BooleanValue.False;
				:}
			| UL_Nul
             	{:
					RESULT = NullValue.Null;
				:}
			| UL_Nombre_Flottant:flottant
             	{:
					RESULT = new FloatingValue( flottant );
				:}
			| UL_Caractere:caractere
             	{:
					RESULT = new CharacterValue( caractere );
				:}
			| UL_Chaine:chaine
             	{:
					RESULT = new StringValue( chaine );
				:}
			| UL_Nouveau Type:type UL_Crochet_Ouvrant Expression:taille UL_Crochet_Fermant
             	{:
					RESULT = new ArrayAllocation( type, taille );
				:}
			| UL_Nouveau Instanciation:instanciation UL_Parenthese_Ouvrante Expressions:parametres UL_Parenthese_Fermante
                {:
                	RESULT = new ConstructorCall(instanciation,parametres);
               	:}
            | UL_Nouveau Instanciation:instanciation UL_Parenthese_Ouvrante UL_Parenthese_Fermante
               	{:
                    RESULT = new ConstructorCall(instanciation);
               	:}
			| Instanciation:instanciation
                {:
                    RESULT = instanciation;
                :}
            ;