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 }