cup.cup

import java_cup.runtime.*;
import java.io.*;
import java.util.*;


action code
{:
	Hashtable st,localST,politipos;
	int politipoActual=0;
	char charPolitipo = 'a';
	
	
	private void imprimirPrompt(){
		System.out.print("MLOR> ");
	}
	
	private String nombrePolitipo(Attrs p){ //entro solo con politipo, y devuevlo 'a, 'b... eso
		String aux = (String)politipos.get(p.getPolytype());
		
		if (aux!=null){
			return aux;
		}
		else{
			if (p.getType().equals("politipo numerico")){
				p.setType("int");
				return "int";
			}
			else if (p.getType().equals("politipo con igualdad")){
				politipos.put(p.getPolytype(),"''" + charPolitipo);
				charPolitipo++;
				return (String)politipos.get(p.getPolytype());
			}
			else{
				politipos.put(p.getPolytype(),"'" + charPolitipo);
				charPolitipo++;
				return (String)politipos.get(p.getPolytype());
			}
		}
	}
	
	//lo cambie para que devuelva el string, porque va a ser mas facil cuando apliquemos recursivamente
	private String obtenerStringTipo(Attrs tipo){
	ArrayList<Attrs> list;
	String aux;
		//System.out.println("entre a obtenerStringTipo" + tipo);
		if (tipo.getType().equals("list")){
			// System.out.println("estoy en lista");
			if (tipo.getListType().getType().equals("fun"))
				aux = "(" + obtenerStringTipo(tipo.getListType()) + ")";
			else
				aux = obtenerStringTipo(tipo.getListType());				
			// System.out.println(aux);
			return aux+" list";
		}
		else if (tipo.getType().equals("tuple")){
			//System.out.println("estoy en tupla");
			list = tipo.getTupleTypes();
			aux = "(";
			for (int i=0;i<list.size();i++){
				if (list.get(i).getType().equals("fun"))
					aux += "(" + obtenerStringTipo(list.get(i)) + ")";
				else
					aux += obtenerStringTipo(list.get(i));				
				//System.out.println(aux);
				//aux+=obtenerStringTipo(list.get(i));
				if (i!=list.size()-1){
					aux+=" * ";
				}
			}
			aux+=")";
			// System.out.println(aux);
			return aux;
		}
		else if (tipo.getType().equals("fun")){
			//System.out.println("estoy en fun");
			if (tipo.getDomain().getType().equals("fun"))
				aux = "(" + obtenerStringTipo(tipo.getDomain()) + ")";
			else
				aux = obtenerStringTipo(tipo.getDomain());				
			//System.out.println(aux);
			return aux + " -> " + obtenerStringTipo(tipo.getRange());
		}
		else if (tipo.getType().startsWith("politipo")){ //si es cualquier politipo
			return nombrePolitipo(tipo);
		}
		else{
			//System.out.println("estoy en tipo simple");
			return tipo.getType();
		}
	}	
	
	private boolean esTipoSimple(Attrs type1){
		String t1 = type1.getType();
		return (t1.equals("int") || t1.equals("real") || t1.equals("boolean") || t1.equals("string"));
	}
	
	private boolean esTipoTextOrNum(Attrs type1){
		String t1 = type1.getType();
		return (t1.equals("int") || t1.equals("real") || t1.equals("string"));
	}
	
	private void imprimirTipo(Attrs tipo){
		System.out.print(obtenerStringTipo(tipo));
	}
	
	private Attrs obtenerTipo(String id) throws Exception{
		Attrs t;		
		if (localST != null){
			t = (Attrs) localST.get(id);
			if(t != null)
				return (t);
		}
		t = (Attrs) st.get(id);
		if(t != null){
			return t;
		}else
			throw new Exception("Undeclared identifier (" + id +")");
	}
	
	private boolean putLocalID(String id) throws Exception{
	
		if (localST.get(id)==null){
			Attrs aux =crearPolitipo("politipo");
			localST.put(id,aux);
			//System.out.println("insertando " + id + " a la tabla local con " + aux.getType());
			return true;
		}
		else{
			throw new Exception("Multiple declaration of value "+ id);
		}
	}
	
	private Attrs crearPolitipo(String poli){
		Attrs aux = new Attrs(poli);
		aux.setPolytype(politipoActual);
		politipoActual++;
		return aux;
	}
	
	private void clonarTipos(Attrs type1,Attrs type2){ //type2 es el mas especifico
		Object[] aux;
		
		type2.mergeInvolvedIDs(type1.getInvolvedIDs());
		
		aux = type2.getInvolvedIDs().toArray();
		if (localST!=null){ //cambio la referencia cuando estoy en ambiente de fun
			for (int i=0;i<aux.length;i++){
				cambiarReferencia((String)aux[i],type2);
			}
		}
	}
	
	private void corregirTupla(Attrs tupla){ //corrige las referencias de la tupla para que apunten a los lugares nuevos, en el caso que alguna variable haya cambiado de tipo
		ArrayList<Attrs> auxList = new ArrayList<Attrs>();
		ArrayList<Attrs> oldList = tupla.getTupleTypes();
		Attrs aux;
		Object[] ids;
		String s;
		
		if (localST!=null){
			for (int i = 0;i< tupla.getTupleLenght();i++){

				ids = oldList.get(i).getInvolvedIDs().toArray();
				
				if (ids.length>0){
					s = (String)ids[0];
					if (Character.isLetter(s.charAt(0))){
						aux = (Attrs)localST.get((String)ids[0]);
						if (aux!=null)
							auxList.add(aux);
						else
							auxList.add(oldList.get(i));
					}
					else
						auxList.add(oldList.get(i));
				}
				else
					auxList.add(oldList.get(i));
			}
			tupla.setTupleTypes(auxList);
		}
	}
	
	private void corregirPolitiposNum(){
		// Object[] entries = localST.entrySet().toArray();
		Attrs aux;
		for (Enumeration e = localST.elements();e.hasMoreElements() ;){
			aux = ((Attrs)e.nextElement());
			if (aux.getType().equals("politipo numerico")){
				aux.setType("int");
			}
		}
	}
	
	private void cambiarReferencia(String s,Attrs t){
		int posPar,pos;
		
		if (Character.isLetter(s.charAt(0)))
			localST.put(s,t);
		else{
			
			if (s.charAt(0)=='>'){
				// System.out.println("se cambia el rango de una funcion");
				cambiarReferencia2(s.substring(1)).setRange(t);
			}
			else if (s.charAt(0)=='-'){
				cambiarReferencia2(s.substring(1)).setDomain(t);
			}
			else if (s.charAt(0)=='['){
				cambiarReferencia2(s.substring(1)).setListType(t);
			}
			else if (s.charAt(0)=='('){
				posPar = s.indexOf(')');
				pos = Integer.parseInt(s.substring(1,posPar));
				t.getTupleTypes().remove(pos);
				cambiarReferencia2(s.substring(posPar+1)).getTupleTypes().add(pos,t);
			}
		}
	}
	
	private Attrs cambiarReferencia2(String s){
		int posPar,pos;
		Attrs t;
		if (s.charAt(0)=='>')
			return cambiarReferencia2(s.substring(1)).getRange();
		else if (s.charAt(0)=='-'){
			return cambiarReferencia2(s.substring(1)).getDomain();
		}
		else if (s.charAt(0)=='['){
			return cambiarReferencia2(s.substring(1)).getListType();
		}
		else if (s.charAt(0)=='('){
			posPar = s.indexOf(')');
			pos = Integer.parseInt(s.substring(1,posPar));
			t = cambiarReferencia2(s.substring(posPar+1));
			return t.getTupleTypes().get(pos);
		}
		else 
			return (Attrs)localST.get(s); //se llego al nivel de la tabla local
	}
	
	private void apuntarVariables(Attrs t, String prefix, HashSet<String> set){
		Object[] aux = set.toArray();
		// System.out.println("entro a apuntar Variables");
		for (int i=0;i<aux.length;i++){
			t.agregarID(prefix+aux[i]);
			// System.out.println("se apunto " + prefix+aux[i]);
		}
	}
	
	private void apuntarTipos(Attrs type1,Attrs type2){
		String t2 = type2.getType();
		ArrayList<Attrs> list;
		if (t2.equals("fun")){
			apuntarVariables(type2.getRange(),">",type1.getInvolvedIDs());
			apuntarVariables(type2.getDomain(),"-",type1.getInvolvedIDs());
		}
		else if (t2.equals("list")){
			apuntarVariables(type2.getListType(),"[",type1.getInvolvedIDs());
		}
		else if (t2.equals("tuple")){
			list = type2.getTupleTypes();
			// System.out.println("entre a apuntar tipos tupla " +list.size());
			for (int i = 0; i<list.size();i++)
				apuntarVariables(list.get(i),"("+i+")",type1.getInvolvedIDs());
		}
	}
	
	
	//devuelve el tipo más específico, y CAMBIA los valores de los tipos para que sean iguales. 
	//de no haber compatibilidad, devuelve null
	private Attrs tipoMasEspecifico(Attrs type1, Attrs type2){
		String t1,t2;
		ArrayList listT1,listT2,result;
		Attrs tResult;
		t1 = type1.getType();
		t2 = type2.getType();
		// System.out.println("entra veron con " + t1 +" y "+ t2);
		if ((esTipoSimple(type1)) && (esTipoSimple(type2)) && t1.equals(t2)){
		//si ambos son tipos simples o iguales, todo OK
			// System.out.println("entro a tipo simple ");
			return type1;
		}
		else{
			if (t1.equals(t2)){ //los tipo de t1 y 2 son iguales, pero no son tipos basicos
				if (t1.equals("tuple")){
					//ambos son tuplas
					if (type1.getTupleLenght()==type2.getTupleLenght()){
					//ambos son tuplas de la misma longitud
						listT1 = type1.getTupleTypes();
						listT2 = type2.getTupleTypes();
						result = new ArrayList();
						for (int i=0;i<listT1.size();i++){
							tResult = tipoMasEspecifico((Attrs) listT1.get(i),(Attrs) listT2.get(i));
							if (tResult!=null)
								result.add(tResult);
							else
								return null;
						}
						type2.setTupleTypes(result);
						type1.setTupleTypes(result);
						return type1;
					}
					//ambas son tuplas, pero las longitudes no coindicen
					return null;
				}
				else if (t1.equals("list")){
					//ambas son listas
					tResult = tipoMasEspecifico(type1.getListType(),type2.getListType());
					if (tResult!=null){
						type1.setListType(tResult);
						type2.setListType(tResult);
						return type1;
					}
					else
						return null;
				}
				//ambos son el mismo tipo de politipo
				else if (t1.equals("politipo") || t1.equals("politipo con igualdad") || t1.equals("politipo numerico")){
					clonarTipos(type2,type1);
					return type1;
				}
				else if (t1.equals("fun")){
					type1.setDomain(tipoMasEspecifico(type1.getDomain(),type2.getDomain()));
					type1.setRange(tipoMasEspecifico(type1.getRange(),type2.getRange()));
					clonarTipos(type2,type1);
					return type1;
				}
				else
					return null;
			}else{ //los tipos de t1 y 2 son distintos
				if (t1.equals("politipo") || t1.equals("politipo con igualdad")){
					//si uno de los tipos es un politipo, lo clonamos al otro
					
					/////////////////////////////
					if (localST!=null) //solo apunto si estoy en ambiente de fun
						apuntarTipos(type1,type2);
					////////////////////////////
					
					clonarTipos(type1,type2); //puede ser necesario borrar las listas
					return type2;
				}
				else if (t2.equals("politipo") || t2.equals("politipo con igualdad")){
					//si uno de los tipos es un politipo, lo clonamos al otro
					
					/////////////////////////////
					if (localST!=null) //solo apunto si estoy en ambiente de fun
						apuntarTipos(type2,type1);
					////////////////////////////
					
					clonarTipos(type2,type1); //puede ser necesario borrar las listas
					return type1;
				}
				else if (t1.equals("politipo numerico" )){
					//si uno es un politipo numerico, y el otro es int o real, asignamos el politipo
					if (t2.equals("int") || t2.equals("real")){
						clonarTipos(type1,type2); //puede ser necesario borrar las listas
						
						return type2;
					}
					else 
						return null;
				}
				else if (t2.equals("politipo numerico" )){
					//si uno es un politipo numerico, y el otro es int o real, asignamos el politipo
					if (t1.equals("int") || t1.equals("real")){
						clonarTipos(type2,type1);
						return type1; //puede ser necesario borrar las listas
					}
					else 
						return null;
				}
				else // si no es ningun politipo, y son distintos, se rompio
					return null;
			}
		}
	}
:}

parser code 
{:
	
	public static void main(String args[]) throws Exception //le puse esto para que dejara de decir "null" cuando hay un pete y que tire un error mas copado
	{
		InputStream in = null;
		// imprimirPrompt();
		System.out.print("MLOR> ");
		try{
			if (args.length==1){
				in = new FileInputStream(args[0]);
				// archivo = true;
			}
			else
				in = System.in;
		}
		catch (FileNotFoundException e){
			System.err.println("File not found");
			System.exit(1);
		}
		try
		{
			new parser(new Yylex(in)).parse();
		}
		catch (Exception e)
		{
			System.err.println("Error: " + e.getMessage());
		}
		
	}
	
	
:}

terminal Token PUNTO, PTOCOMA, IGUAL, COMA, OPREL, CONS, OPADD, ORELSE, CONCAT, MUL, DIVREAL, DIVINT, MOD, ANDALSO, NOT, MINUS, PARABRE, PARCIERRA, CORABRE, CORCIERRA, NIL, FUN, VAL, ID, INT, REAL, STRING, DISTINTO;

non terminal Programa, Lista_sentencias;

non terminal Attrs Sentencia, MatchingFunc, CurryingList, TuplePattern, TuplePattern2, Exp_Rel, Exp_cons, Exp_add, Exp_mul, Exp_un, Exp_fun, Exp_atom, Tuple, Tuple2, List, List2;

Programa ::= 	{: 	
					st=new Hashtable(); 
					politipos = new Hashtable();
					Attrs b = new Attrs ("boolean");
					st.put("true",b);
					st.put("false",b);
					
				:} 
				Lista_sentencias 
				{: 	
					System.out.println("Succesfully parsed! Press CTRL+C to exit.");
				:}
				PUNTO	
				;

Lista_sentencias ::= 	Lista_sentencias 
						Sentencia 
						{:imprimirPrompt();:}
						PTOCOMA 
						
						| 
						Sentencia 
						{:imprimirPrompt();:}
						PTOCOMA
						
						;

Sentencia ::= 	VAL
				ID:id	
				IGUAL 
				Exp_Rel:exp 
				{:
					st.put(id.getLexeme(),exp);
					System.out.print("val "+id.getLexeme()+": ");
					imprimirTipo(exp);
					System.out.println("");
					// System.out.print("MLOR> ");
					charPolitipo = 'a'; //reinicio el contador de politipos
				:}
				| 
				Exp_Rel:exp
				{: 	st.put("it",exp);
					System.out.print("val it: ");
					imprimirTipo(exp);
					System.out.println("");
					
					charPolitipo = 'a'; //reinicio el contador de politipos
				:}
				| 
				FUN 
				{: 
					localST = new Hashtable(); 
					// System.out.print("MLOR> ");
				:}
				MatchingFunc
				{: 
					localST = null; 
					// System.out.print("MLOR> ");
				:}
				;

MatchingFunc ::= ID:f ID:param {:putLocalID(param.getLexeme());:} //pone el parametro con un politipo
				CurryingList:list  
					{:Attrs aux = new Attrs("fun",(Attrs)localST.get(param.getLexeme()), list);
					  corregirPolitiposNum();
					  st.put(f.getLexeme(),aux); 
					  System.out.print("val "+ f.getLexeme()+": ");
					  // politipos = new Hashtable();
					  imprimirTipo(aux);
					  politipos = new Hashtable();
					  charPolitipo = 'a'; //reinicio el contador de politipos
					  System.out.println(" = fn;");
					:}
				|  
				ID:f
				TuplePattern:tuple
				IGUAL
				Exp_Rel:exp 
				{:
					corregirTupla(tuple);
					corregirPolitiposNum();
					Attrs aux = new Attrs("fun",tuple,exp);
					st.put(f.getLexeme(), aux);
					System.out.print("val "+ f.getLexeme()+": ");
					imprimirTipo(aux);
					politipos = new Hashtable();
					charPolitipo = 'a'; //reinicio el contador de politipos
					System.out.println(" = fn;");
				:};

CurryingList ::= ID:id {:putLocalID(id.getLexeme());:}
				CurryingList:list {:RESULT = new Attrs("fun",(Attrs)localST.get(id.getLexeme()),list);:}
				| IGUAL Exp_Rel:exp {:RESULT = exp;:};

TuplePattern ::= PARABRE TuplePattern2:tp PARCIERRA{:RESULT = tp; :};

TuplePattern2 ::= TuplePattern2:t COMA ID:id 
					{:
						putLocalID(id.getLexeme());
						Attrs aux = crearPolitipo("politipo");
						aux.agregarID(id.getLexeme());
						t.addTupleTypeFinal(aux);
						RESULT = t;
					:}
					| 
					ID:id 
					{:
						putLocalID(id.getLexeme());
						Attrs t = new Attrs("tuple", new ArrayList());
						Attrs aux = crearPolitipo("politipo");
						aux.agregarID(id.getLexeme());
						t.addTupleTypeFinal(aux);
						RESULT = t;
					:};

Exp_Rel  	::= Exp_Rel:e1 OPREL Exp_cons:e2
				{:
					Attrs t = tipoMasEspecifico(e1,e2);
					if (t!=null){
						if (esTipoTextOrNum(t)){
							RESULT = new Attrs("boolean");
						}else{
							throw new Exception("String or num expected.");
						}
					}else{
						throw new Exception("String or num expected.");
					}
				:}
				| 
				Exp_Rel:e1 DISTINTO Exp_cons:e2
				{:
					Attrs t = tipoMasEspecifico(e1,e2);
					if (t!=null){
						t = tipoMasEspecifico(t,crearPolitipo("politipo con igualdad"));
						if (t!=null && !t.getType().equals("fun")){
							RESULT = new Attrs("boolean");
						}else{
							throw new Exception("Function does not admit equality.");
						}
					}else{
						throw new Exception("Types are not compatibles.");
					}
				:}
				| 
				Exp_Rel:e1 IGUAL Exp_cons:e2
				{:
					Attrs t = tipoMasEspecifico(e1,e2);
					if (t!=null){
						t = tipoMasEspecifico(t,crearPolitipo("politipo con igualdad"));
						if (t!=null && !t.getType().equals("fun")){
							RESULT= new Attrs("boolean");
						}
						else{
							throw new Exception("Function does not admit equality.");
						}
					}else{
						throw new Exception("Types are not compatibles.");
					}
				:}
				|
				Exp_cons:e {: RESULT = e; :};
				
Exp_cons 	::=	Exp_add:e1 CONS Exp_cons:e2
				{:
					Attrs t = tipoMasEspecifico(new Attrs("list",e1),e2);
					if (t!=null){
						RESULT = t;
					}
					else{
						throw new Exception("The list has elements of different types.");
					}
				:}
				|
				Exp_add:e {: RESULT = e; :};

Exp_add  	::=	Exp_add:e1 OPADD Exp_mul:e2
				{:
					Attrs t = tipoMasEspecifico(e1,e2);
					if (t!=null){
						t = tipoMasEspecifico(t,crearPolitipo("politipo numerico"));
						if (t!=null){
							RESULT = t;
						}else{
							throw new Exception("Integer or real expected.");//lo cambio... estaba en "Integer or real expected."
						}
					}else{
						throw new Exception("Incompatible types.");
					}
				:}
				| 
				Exp_add:e1 ORELSE Exp_mul:e2
				{:
					Attrs t = tipoMasEspecifico(e1,e2);
					if (t!=null){
						t = tipoMasEspecifico(t,new Attrs ("boolean"));
						if (t!=null){
							RESULT = t;
						}else{
							throw new Exception("Boolean expected.");
						}
					}else{
						throw new Exception("Boolean expected.");
					}
				:}
				| 
				Exp_add:e1 CONCAT Exp_mul:e2
				
				{:
					Attrs t = tipoMasEspecifico(e1,e2);
					if (t!=null){
						t = tipoMasEspecifico(t,new Attrs ("string"));
						if (t!=null){
							RESULT = t;
						}else{
							throw new Exception("String expected.");
						}
					}else{
						throw new Exception("String expected.");
					}
				:}
				|
				Exp_mul:e {: RESULT = e; :};

Exp_mul  	::=	Exp_mul:e1 MUL Exp_un:e2
				{:
					Attrs t = tipoMasEspecifico(e1,e2);
					if (t!=null){
						t = tipoMasEspecifico(t,crearPolitipo("politipo numerico"));
						if (t!=null){
							RESULT = t;
						}else{
							throw new Exception("Integer or real expected.");
						}
					}else{
						throw new Exception("Incompatible types.");
					}
				:}
				| 
				Exp_mul:e1 DIVREAL Exp_un:e2
				{:
				Attrs t = tipoMasEspecifico(e1,e2);
					if (t!=null){
						t = tipoMasEspecifico(t,new Attrs("real"));
						if (t!=null){
							RESULT = t;
						}else{
							throw new Exception("Real expected.");
						}
					}else{
						throw new Exception("Real expected.");
					}
				:}
				|
				Exp_mul:e1 DIVINT Exp_un:e2
				{:
				Attrs t = tipoMasEspecifico(e1,e2);
					if (t!=null){
						t = tipoMasEspecifico(t,new Attrs("int"));
						if (t!=null){
							RESULT = t;
						}else{
							throw new Exception("Integer expected.");
						}
					}else{
						throw new Exception("Integer expected.");
					}
				:}
				|
				Exp_mul:e1 MOD Exp_un:e2
				{:
				Attrs t = tipoMasEspecifico(e1,e2);
					if (t!=null){
						t = tipoMasEspecifico(t,new Attrs("int"));
						if (t!=null){
							RESULT = t;
						}else{
							throw new Exception("Integer expected.");
						}
					}else{
						throw new Exception("Integer expected.");
					}
				:}
				| 
				Exp_mul:e1 ANDALSO Exp_un:e2
				{:
				Attrs t = tipoMasEspecifico(e1,e2);
					if (t!=null){
						t = tipoMasEspecifico(t,new Attrs("boolean"));
						if (t!=null){
							RESULT = t;
						}else{
							throw new Exception("Boolean expected.");
						}
					}else{
						throw new Exception("Boolean expected.");
					}
				:}
				|
				Exp_un:e {: RESULT = e; :};

Exp_un   	::=	NOT Exp_fun:fun 
				{: 	Attrs t = tipoMasEspecifico(fun, new Attrs("boolean"));
					if (t!=null){
						RESULT = t;
					}else{
						throw new Exception("Boolean expected.");
					}
				:}
				| 
				MINUS Exp_fun:fun 
				{: 	
					Attrs t = tipoMasEspecifico(fun, new Attrs("politipo numerico"));
					if (t != null){
						RESULT = t;
					}else{
						throw new Exception("~ operator can only be applied to integer and real values.");//lo cambie! era "Integer or real expected"
					}
				:}
				| 
				Exp_fun:e {: RESULT = e; :};

Exp_fun  	::= Exp_fun:f Exp_atom:atom
				{:
					Attrs aux = tipoMasEspecifico(f,new Attrs("fun",atom,crearPolitipo("politipo")));
					if (aux!=null){
						RESULT = aux.getRange();
					}
					else{
						throw new Exception("Not a valid function.");
					}
				:}
				| 
				Exp_atom:atom {: RESULT = atom; :};

Exp_atom	::=	INT {: RESULT = new Attrs("int"); :}
				| 
				REAL {: RESULT = new Attrs("real") ;:} 
				| 
				STRING {: RESULT = new Attrs("string") ;:}
				| 
				ID:id {:Attrs aux = obtenerTipo(id.getLexeme());
						if (aux!=null){
							if (!esTipoSimple(aux)){ //agrego a la lista de ids involucrados cualquier cosa que no tenga su tipo definido
								aux.agregarID(id.getLexeme());
							}
							RESULT = aux;
						}
						else
							throw new Exception("Undeclared identifier (" + id.getLexeme() +")");
					  :}
				| 
				NIL {: RESULT = new Attrs("list",crearPolitipo("politipo")) ;:}
				| 
				PARABRE 
				Exp_Rel:e {:// e.deleteInvolvedIDs(); // se supone que los tipos de los id estan resueltos
							 RESULT = e; :}
				PARCIERRA 
				| 
				Tuple:t {:RESULT = t; :} 
				| 
				List:l {:RESULT = l; :};

Tuple 	::= PARABRE Exp_Rel:e COMA Tuple2:t2 PARCIERRA {:
														t2.addTupleTypeBegin(e);
														
														corregirTupla(t2); 
														RESULT = t2; 
													   :}; 

Tuple2 	::= Tuple2:t COMA Exp_Rel:e 
			{:
				t.addTupleTypeFinal(e);
				RESULT = t;
			:}
			| 
			Exp_Rel:e {: 
						Attrs t = new Attrs("tuple", new ArrayList());
						t.addTupleTypeFinal(e);
						RESULT = t;
					  :};

List 		::= CORABRE List2:l CORCIERRA {:RESULT = l;:};

List2 	::= List2:list COMA Exp_Rel:exp {:
											Attrs t = tipoMasEspecifico(list.getListType(),exp);
											if (t!=null)											
												RESULT = tipoMasEspecifico(list,new Attrs("list",t));
											else
												throw new Exception("The list has elements of different types.");
										:}
			| 
			Exp_Rel:exp {:RESULT = new Attrs("list",exp);:};