public override TypeReturn CheckSemantics(List <Scope> scope_list, List <Error> errors)
{
TypeReturn typeOfValue = Value.CheckSemantics(scope_list, errors);
TypeReturn actual = typeOfValue;
bool found;
foreach (var access in Access_list)
{
found = false;
if (access is AccessPto) //pregunto si es un acceso a un record
{
AccessPto aux = access as AccessPto;
if (actual is ReturnRecord)
{
ReturnRecord temp = actual as ReturnRecord;
typesList.Add(temp); //anado el record a mi lista de record
//ver si el record tiene el campo .id
foreach (var field in temp.Fields)
{
if (field.Item1.Equals(aux.Name)) //busco el campo igual al .id
{
actual = field.Item2; //guardo el tipo ese campo para la proxima iteracion
found = true;
break;
}
}
if (!found) //si no encontro el campo
{
errors.Add(new Error(access.Line, access.Column, "El record no tiene ningun campo llamado " + aux.Name));
}
}
else //si el tipo al que se quiere hacer el . no es un record
{
errors.Add(new Error(access.Line, access.Column, "El tipo no es un record"));
}
}
else
{
//es un acceso a un array
AccessIndex aux = access as AccessIndex;
if (actual is ReturnArray)
{
TypeReturn typeOfIndex = aux.Arg.CheckSemantics(scope_list, errors); //hago el chequeo semantico a [exp]
if (!(typeOfIndex is ReturnInt)) //pregunto si es entera
{
errors.Add(new Error(access.Line, access.Column, "La expresion de indexer debe devolver un entero"));
}
ReturnArray temp = actual as ReturnArray;
typesList.Add(temp);
actual = temp.Type_Of_Elements; //el tipo del acceso es el mismo para todo los elementos del array
}
else
{
errors.Add(new Error(access.Line, access.Column, "El tipo que se desea indexar no es un array"));
}
}
}
return(actual);
}
public override bool Equals(object obj)
{
ReturnArray r = obj as ReturnArray;
if (r == null || r.Array_name != Array_name)
{
return(false);
}
return(true);
}
public override TypeReturn CheckSemantics(List <Scope> scope_list, List <Error> errors)
{
//chequeamos si el tipo del array ya se definio anteriormente
TypeReturn typeOfArray = Utils.FindType(scope_list, Name);
if (typeOfArray == null)
{
errors.Add(new Error(line, column, "El tipo " + this.Name + "no se ha delcarado todavia"));
}
//verificamos que la expresion de inicializacion devuelva algun valor(puede ser nil)
TypeReturn typeOfInitial = Initial.CheckSemantics(scope_list, errors);
if (typeOfInitial is ReturnNotValue || typeOfInitial == null) //pregunto por null porque si hubo un error devuelvo null
{
errors.Add(new Error(line, column, "La expresion de la inicializacion del array debe devolver algun valor"));
}
if (!(typeOfArray is ReturnArray)) //el tipo no es un array
{
errors.Add(new Error(line, column, "El tipo " + "'" + this.Name + "'" + " no es de tipo array"));
}
else
{
if (typeOfInitial is ReturnNil) //si es nil no pueden ser int los valores del array
{
if ((typeOfArray as ReturnArray).Type_Of_Elements is ReturnInt)
{
errors.Add(new Error(line, column, "El array no permite 'nil' porque los valores del array son 'int'"));
}
}
else if (((ReturnArray)typeOfArray).Type_Of_Elements.ToString() != typeOfInitial.ToString())
{
errors.Add(new Error(line, column, "Los elementos del array son de tipo '" + ((ReturnArray)typeOfArray).Type_Of_Elements.ToString() + "' y no de tipo '" + typeOfInitial.ToString() + "'"));
}
}
//verificamos que el size es un entero
TypeReturn typeOfSize = Size.CheckSemantics(scope_list, errors);
if (!(typeOfSize is ReturnInt))
{
errors.Add(new Error(line, column, "La expresion del tamaño del array no devuelve un entero"));
}
Array = typeOfArray as ReturnArray; //para usarlo en la generacion de codigo
return((typeOfArray != null) ? typeOfArray : new ReturnArray(this.Name, typeOfInitial)); //retorno el array
}