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.IOException;
import java.io.File;
import java.io.FileInputStream;
import java.util.*;
import java.io.FileOutputStream;
import java.io.PrintStream;

// 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.declaration.*;
import fr.n7.stl.block.ast.type.*;
import fr.n7.stl.util.*;
import fr.n7.stl.tam.ast.Register;
import fr.n7.stl.tam.ast.Fragment;
import fr.n7.stl.tam.ast.impl.TAMFactoryImpl;

/* Variables partagées dans les actions de l'analyseur syntaxique. */
parser code {:
	protected Lexer lexer;
	protected String 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_Classe, UL_Herite ;
terminal			UL_Public, UL_Prive, UL_Protege, UL_Definitif, UL_Abstrait, UL_De_Classe;
terminal			UL_Classe_Principale, UL_Methode_Principale;
terminal			UL_Moi, UL_Super;
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_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 String		UL_Identificateur, 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						Block; 
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 ClassType					ClassType;
non terminal Expression 					Expression;
non terminal AssignableExpression		Affectable;
non terminal List<ClassDeclaration>		Elements;
non terminal ClassDeclaration 			Main, Class ;
non terminal ClassType							SingleInherits ;
non terminal List<ClassElement>			ClassElements ;
non terminal ClassElement 				ClassElement ;
non terminal AttributeDeclaration		Attribute;
non terminal Signature					Signature;
non terminal MethodDeclaration			Method;
non terminal ConstructorDeclaration		Constructor, ConstructorPrelude;
non terminal AccessRight				AccessRight;
non terminal 							ElementNature;

/* 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_Point; // , UL_Crochet_Ouvrant, UL_Parenthese_Ouvrante;
/* Opérateur le plus prioritaire */

/* Règles de grammaire attribuée pour la construction de l'arbre abstrait */
/* Program et Block sont des non terminaux */
/* UL_Identificateur est un terminal (Unité lexicale) */
/* Block est la variable utilisable dans l'action sémantique qui contient la valeur renvoyé par l'analyse du Block */
/* TODO */
Program ::= Elements:elements
			{: 
				//Couleurs pour l'affichage dans le terminal pour s'y retrouver plus facilement
				String GREEN = "\033[0;32m";
				String RESET = "\033[0m"; 
				String RED = "\033[0;31m";     

				SymbolTable tds = new SymbolTable();
				TAMFactoryImpl tamFactory = new TAMFactoryImpl();
				Fragment code = tamFactory.createFragment();

				boolean do_collect = true;
				boolean do_resolve = true;
				boolean do_type = true;
				boolean do_memory = true;
				boolean do_code = true;

				System.out.println(GREEN + "parsing succeeded" +RESET);

				// Collect
				if (do_collect) {
					for (ClassDeclaration elem : elements) {
						System.out.println("Class " + elem.getName());
						try {
							elem.collect(tds);
						} catch (Exception e) {
							e.printStackTrace();
							Logger.error(RED + "Collect failed !" +RESET);
							break;
						}
					}
					System.out.println(GREEN + "collect succeeded" +RESET);
				}
				

				// Resolve
				if (do_resolve) {
					for (ClassDeclaration elem : elements) {
						System.out.println("Class " + elem.getName());
						try {
							elem.resolve(tds);
						} catch (Exception e) {
							e.printStackTrace();
							Logger.error(RED + "Resolve failed !" +RESET);
							break;
						}
					}
					System.out.println(GREEN + "resolve succeeded" + RESET);
				}
				

				// Type
				if (do_type) {
					for (ClassDeclaration elem : elements) {
						System.out.println("Class " + elem.getName());
						try {
							elem.checkType();
						} catch (Exception e) {
							e.printStackTrace();
							Logger.error(RED + "Type failed !" +RESET);
							break;
						}
					}
					System.out.println(GREEN + "type succeeded" +RESET);
				}
				

				// Allocate Memory
				if (do_memory) {
					int i = 0;
					for (ClassDeclaration elem : elements) {
						System.out.println("Class " + elem.getName());
						try {
							//TODO : Vérifier si i ou i+1
							i = elem.allocateMemory(Register.SB, i); 
						} catch (Exception e) {
							e.printStackTrace();
							Logger.error(RED + "Memory failed !" +RESET);
							break;
						}
					}
					System.out.println(GREEN + "memory allocated" +RESET);
				}

				// Code Generation
				if (do_code) {
					int i = 0;
					for (ClassDeclaration elem : elements) {
						System.out.println("Class " + elem.getName());
						try {
							code.append(elem.getCode(tamFactory));
						} catch (Exception e) {
							e.printStackTrace();
							Logger.error(RED + "Code generation failed !" +RESET);
						}
					}
					code.add(tamFactory.createHalt());
					System.out.println(GREEN + "code generated" +RESET);

					try {
						File tamFile = new File (parser.name.replace("./test-mjava/", "./test-mjava/tam/") + ".tam");
						PrintStream stream = new PrintStream(new FileOutputStream(tamFile));
						stream.println(code);
					} catch (Exception e) {
						e.printStackTrace();
						Logger.error(RED + "Writing code failed !" +RESET);
					}
					System.out.println(GREEN + "code written" +RESET);
				}
			:}
		;

Elements ::= Main:main
		{:
			List<ClassDeclaration> elements = new LinkedList<ClassDeclaration>();
			elements.add(  main);
			RESULT = elements;
		:}
		| Class:classe Elements:elements
		{:
			elements.add(classe);
			RESULT = elements;
		:}
		| UL_Abstrait Class:classe Elements:elements
		{:
			classe.setAbstract(true);
			elements.add(classe);
			RESULT = elements;
		:}
		;

Class ::= UL_Classe UL_Identificateur:identifiant SingleInherits:inheritedClass 
		  UL_Accolade_Ouvrante ClassElements:classElements UL_Accolade_Fermante
		{:
			RESULT = new ClassDeclaration(identifiant, classElements, false, inheritedClass);
		:}
		;
		
Main ::= UL_Public UL_Classe UL_Classe_Principale
		UL_Accolade_Ouvrante 
			UL_Public UL_De_Classe UL_Type_Vide UL_Methode_Principale 
			UL_Parenthese_Ouvrante Parameters:parametres UL_Parenthese_Fermante Block:block UL_Accolade_Fermante
		{:
			MethodDeclaration methodePrincipale = new MethodDeclaration(new Signature(AtomicType.VoidType, "main", parametres), block, false, true, false);
			List<ClassElement> l = new ArrayList<ClassElement>();
			l.add(methodePrincipale);
			RESULT = new ClassDeclaration("Main", l, false, null);
		:}
		;

SingleInherits ::= /* Lambda */
		{:
			RESULT = null;
		:}
		|
		UL_Herite ClassType:classType 
		{:
			RESULT = classType;
		:}
		;

ClassElements ::= /* Lambda */
		{:
			List<ClassElement> elements = new LinkedList<ClassElement>();
			RESULT = elements;
		:}
		| AccessRight:accessRight ClassElement:elem ClassElements:elements
		{:
			elem.setTypeAcces(accessRight);
			elements.add(elem);
			RESULT = elements;
		:}
		;

ClassElement ::=
		Attribute:attribute
		{:
			RESULT = attribute;
		:}
		|
		Method:method
		{:
			RESULT = method;
		:}
		|
		Constructor:constructor
		{:
			RESULT = constructor;
		:}
		;

AccessRight ::=
		UL_Public
		{:
			RESULT = AccessRight.PUBLIC;
		:}
		| UL_Protege
		{:
			RESULT = AccessRight.PROTEGE;
		:}
		| UL_Prive
		{:
			RESULT = AccessRight.PRIVE;
		:}
		;

//TODO	
ElementNature ::=
		UL_De_Classe
		{:
		:}
		| /* Lambda */
		{:
		:}
		;		
		

		
Attribute ::=
		Type:type Identifiant:identifiant UL_Point_Virgule
		{:
			Type _type = identifiant.getRight();
				if (_type == null) {
					_type = type;
				} else {
					_type = ((PartialType)_type).complete( type );
 				}
			RESULT = new AttributeDeclaration(identifiant.getLeft(), _type, null, false, false);
		:}
		|
		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 AttributeDeclaration(identifiant.getLeft(), _type, valeur, false, true);
		:}
		|
		UL_De_Classe 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 AttributeDeclaration(identifiant.getLeft(), _type, valeur, false, true);
		:}
		|
		UL_De_Classe UL_Definitif 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 AttributeDeclaration(identifiant.getLeft(), _type, valeur, true, true);
		:}
		;
		
Method ::=
		Signature:entete Block:corps
		{:
			RESULT = new MethodDeclaration(entete,corps, false, false, false);
		:}
		| 
		UL_Definitif Signature:entete Block:corps
		{:
			RESULT = new MethodDeclaration(entete, corps, true, false, false);
		:}
		| 
		UL_De_Classe Signature:entete Block:corps
		{:
			RESULT = new MethodDeclaration(entete,corps, false, true, false);
		:}
		| 
		UL_De_Classe UL_Definitif Signature:entete Block:corps
		{:
			RESULT = new MethodDeclaration(entete, corps, true, true, false);
		:}
		| 
		UL_Abstrait Signature:entete UL_Point_Virgule
		{:
			RESULT = new MethodDeclaration(entete, new Block(new ArrayList<Instruction>()), false, false, true);
		:}
		;
		
Signature ::=
		Type:type Identifiant:identifiant UL_Parenthese_Ouvrante Parameters:parametres UL_Parenthese_Fermante
		{:
			Type _type = identifiant.getRight();
				if (_type == null) {
					_type = type;
				} else {
					_type = ((PartialType)_type).complete( type );
 				}
			RESULT = new Signature(_type,identifiant.getLeft(),parametres);
		:}
		|
		Type:type Identifiant:identifiant UL_Parenthese_Ouvrante UL_Parenthese_Fermante
		{:
			Type _type = identifiant.getRight();
				if (_type == null) {
					_type = type;
				} else {
					_type = ((PartialType)_type).complete( type );
 				}
			RESULT = new Signature(_type,identifiant.getLeft(),new LinkedList<ParameterDeclaration>());
		:}
		;
		
Constructor ::=
		UL_Identificateur:nom UL_Parenthese_Ouvrante Parameters:parametres UL_Parenthese_Fermante Block:corps
		{:
			RESULT = new ConstructorDeclaration(nom, parametres, corps);
		:}
		|
		UL_Identificateur:nom UL_Parenthese_Ouvrante UL_Parenthese_Fermante Block:corps
		{:
			RESULT = new ConstructorDeclaration(nom, new LinkedList<ParameterDeclaration>(), corps);
		:}
		;

Block ::= UL_Accolade_Ouvrante Instructions:instructions UL_Accolade_Fermante 
			{: 
				RESULT = new Block( instructions ); 
			:}
		;
		
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; 
			:}
		| ClassType:classType
			{: 
				RESULT = classType;
			:}
		;

ClassType ::= UL_Identificateur:nom
			{: 
				RESULT = new ClassType( nom ); 
			:}
			;

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;
				:}
			;
			
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);
				:}
			;

Instruction ::= Declaration:declaration
				{: 
					RESULT = declaration; 
				:}
			| Affectable:affectable UL_Egal Expression:expression UL_Point_Virgule
				{:
					RESULT = new Assignment( affectable, expression);
				:}
			| Affectable:affectable UL_Point_Virgule
				{:
				:}
			| UL_Afficher Expression:expression UL_Point_Virgule
				{:
					RESULT = new Printer( expression );
				:}
			| UL_Si UL_Parenthese_Ouvrante Expression:condition UL_Parenthese_Fermante Block:alors UL_Sinon Block:sinon
				{: 
					RESULT = new Conditional( condition, alors, sinon); 
				:}
			| UL_Si UL_Parenthese_Ouvrante Expression:condition UL_Parenthese_Fermante Block:alors
				{: 
					RESULT = new Conditional( condition, alors); 
				:}
			| UL_Tant_Que UL_Parenthese_Ouvrante Expression:condition UL_Parenthese_Fermante Block:corps
				{: 
					RESULT = new Iteration( condition, corps); 
				:}
			| UL_Retour Expression:expression UL_Point_Virgule
				{:
					RESULT = new Return( expression);
				:}
			;
			
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_Moi UL_Point UL_Identificateur:nom
				{:
					RESULT = new AttributeAssignment( nom );
				:}
			//TODO
			| UL_Moi
				{:

				:}
			//TODO
			| UL_Super
				{:
				:}
			| 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 UL_Identificateur:type UL_Parenthese_Fermante Affectable:affectable    
             	{: 
					RESULT = new AssignableConversion( affectable, type); 
				:}
			| UL_Parenthese_Ouvrante Atomique:type UL_Parenthese_Fermante Affectable:affectable    
             	{: 
					RESULT = new AssignableConversion( affectable, type); 
				:}
			| Affectable:enregistrement UL_Point UL_Identificateur:etiquette
				{:
					RESULT = new FieldAssignment( enregistrement, etiquette);
				:}
			//TODO
			| Affectable:affectable UL_Parenthese_Ouvrante UL_Parenthese_Fermante
				{:
				:}
			//TODO
			| Affectable:affectable UL_Parenthese_Ouvrante Expressions:parametres UL_Parenthese_Fermante
				{:
				:}
			;
			            
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
				{:
					RESULT = new FieldAccess( expression, etiquette );
				:}
			| 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 UL_Identificateur:type UL_Parenthese_Fermante Expression:expression    
             	{: 
					RESULT = new AccessibleConversion( expression, type); 
				:}
			| UL_Parenthese_Ouvrante Atomique:type UL_Parenthese_Fermante Expression:expression    
             	{: 
					RESULT = new AccessibleConversion( expression, type); 
				:}
			| UL_Identificateur:nom	                     
             	{: 
					RESULT = new IdentifierAccess( nom ); 
				:}
			//TODO
			| Expression:fonction	UL_Parenthese_Ouvrante Expressions:parametres UL_Parenthese_Fermante                     
             	{: 
					RESULT = new MethodCall((MethodDeclaration) fonction, parametres);
				:}
			//TODO
			|
				Expression:fonction	UL_Parenthese_Ouvrante UL_Parenthese_Fermante                     
             	{:
					RESULT = new MethodCall((MethodDeclaration) fonction, new ArrayList<>());
				:}
			| UL_Nombre_Entier:entier	                     
             	{: 
					RESULT = new IntegerValue( entier ); 
				:}
			| UL_Vrai                     
             	{: 
					RESULT = BooleanValue.True; 
				:}
			| UL_Faux                     
             	{: 
					RESULT = BooleanValue.False; 
				:}
			//TODO
			| UL_Moi
				{:
				:}
			//TODO
			| UL_Super
				{:
				:}
			//TODO
			| 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 ); 
				:}
			/*  constructeur sans paramètre */
			//TODO
			| UL_Nouveau ClassType:classType UL_Parenthese_Ouvrante UL_Parenthese_Fermante	                     
             	{: 
					RESULT = new ConstructorCall(classType, new ArrayList<Expression>());
				:}
			//TODO
			| UL_Nouveau ClassType:classType UL_Parenthese_Ouvrante Expressions:parametres UL_Parenthese_Fermante	                     
             	{: 
					RESULT = new ConstructorCall(classType, parametres);
				:}
            ;