예제 #1
0
        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);
        }
예제 #2
0
        public override bool Equals(object obj)
        {
            ReturnArray r = obj as ReturnArray;

            if (r == null || r.Array_name != Array_name)
            {
                return(false);
            }
            return(true);
        }
예제 #3
0
        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
        }