Пример #1
0
        //TODO: validar tipos

        public override Objeto execute(Entorno entorno)
        {
            Simbolo simbolo = retornar_asignacion(entorno);

            No_constante(simbolo);

            Objeto valor = retornar_valor_nuevo(entorno);

            Validar_tipos(simbolo.getValor(), valor);

            simbolo.setValor(valor);

            return(simbolo.getValor());
        }
Пример #2
0
        public override Objeto executar_funcion_usuario(Entorno entorno)
        {
            Simbolo simbolo_retorno = new Simbolo(base.getNombre(), this.retorno, base.getLinea(), base.getColumna());

            entorno.addSimbolo(simbolo_retorno, base.getNombre());

            foreach (Nodo instruccion in this.instrucciones)
            {
                if (instruccion != null)
                {
                    try
                    {
                        Objeto retorno = instruccion.execute(entorno);
                        if (retorno != null)
                        {
                            if (retorno.getTipo() == Objeto.TipoObjeto.CONTINUE)
                            {
                                Sentencia_transferencia tem = (Sentencia_transferencia)retorno;
                                Error error = new Error(tem.linea, tem.columna, Error.Errores.Semantico,
                                                        "Sentencia continue debe estar dentro de un ciclo");
                                Captura_error(error);
                            }
                            else if (retorno.getTipo() == Objeto.TipoObjeto.BREAK)
                            {
                                Sentencia_transferencia tem = (Sentencia_transferencia)retorno;
                                Error error = new Error(tem.linea, tem.columna, Error.Errores.Semantico,
                                                        "Sentencia break debe estar dentro de un ciclo o case");
                                Captura_error(error);
                            }
                            else if (retorno.getTipo() == Objeto.TipoObjeto.NULO)
                            {
                                Sentencia_transferencia tem = (Sentencia_transferencia)retorno;
                                if (tem.valor != null)
                                {
                                    Validar_retorno(tem.valor, instruccion);
                                    return(tem.valor);
                                }
                                else
                                {
                                    Error error = new Error(tem.linea, tem.columna, Error.Errores.Semantico,
                                                            "La sentencia de exit en funcion debe de retornar un valor");
                                    Captura_error(error);
                                }
                            }
                        }
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine(e.ToString());
                        //throw new Exception(e.ToString());
                    }
                }
            }

            Simbolo aux = entorno.GetSimbolo(base.getNombre());

            return(aux.getValor());
        }
Пример #3
0
        public Simbolo retornar_simbolo(Entorno entorno)
        {
            if (this.llamada_anterior == null)
            {
                Simbolo simbolo_retorno = entorno.GetSimbolo(this.nombre_variable);
                if (simbolo_retorno == null)
                {
                    Error error = new Error(base.getLinea(), base.getColumna(), Error.Errores.Semantico,
                                            "Error el simbolo: " + this.nombre_variable + " no se encontro");
                    Maestra.getInstancia.addError(error);
                    throw new Exception("Error el simbolo: " + this.nombre_variable + " no se encontro");
                }

                if (simbolo_retorno.getValor().getTipo() == Objeto.TipoObjeto.ARRAY)
                {
                    return(Recorrer_array(entorno, simbolo_retorno));
                }

                return(simbolo_retorno);
            }
            else
            {
                Simbolo simbolo_retorno = llamada_anterior.retornar_simbolo(entorno);

                if (simbolo_retorno.getValor().getTipo() == Objeto.TipoObjeto.ARRAY)
                {
                    simbolo_retorno = Recorrer_array(entorno, simbolo_retorno);
                }

                Validar_Nivel(simbolo_retorno);

                Simbolo atributo_objeto = simbolo_retorno.getValor().get_atributo(this.nombre_variable);
                if (atributo_objeto == null)
                {
                    Error error = new Error(base.getLinea(), base.getColumna(), Error.Errores.Semantico,
                                            "Error el simbolo: " + this.nombre_variable + " no se encontro");
                    Maestra.getInstancia.addError(error);
                    throw new Exception("Error el simbolo: " + this.nombre_variable + " no se encontro");
                }

                return(atributo_objeto);
            }
        }
Пример #4
0
 public void Validar_Nivel(Simbolo simbolo)
 {
     if (simbolo.getValor().getTipo() != Objeto.TipoObjeto.OBJECTS)
     {
         Error error = new Error(base.getLinea(), base.getColumna(), Error.Errores.Semantico,
                                 "El simbolo: " + this.nombre_variable + "no es de tipo objeto");
         Maestra.getInstancia.addError(error);
         throw new Exception("El simbolo: " + this.nombre_variable + "no es de tipo objeto");
     }
 }
Пример #5
0
        public Simbolo Recorrer_array(Entorno entorno, Simbolo array)
        {
            if (this.dimensiones == null)
            {
                return(array);
            }
            foreach (Nodo exp in this.dimensiones)
            {
                if (array.getValor().getTipo() == Objeto.TipoObjeto.ARRAY)
                {
                    Objeto valor = exp.execute(entorno);
                    Validar_Entero(valor);

                    int valor_intero = int.Parse(valor.getValor().ToString());

                    try
                    {
                        array = array.getValor().get_posicion(valor_intero);
                    }
                    catch (Exception e)
                    {
                        Error error = new Error(base.getLinea(), base.getColumna(), Error.Errores.Semantico,
                                                e.ToString() + this.nombre_variable);
                        Maestra.getInstancia.addError(error);
                        throw new Exception(e.ToString());
                    }
                }
                else
                {
                    Error error = new Error(base.getLinea(), base.getColumna(), Error.Errores.Semantico,
                                            "El simbolo definido: " + this.nombre_variable + " no es un arreglo o las dimensiones no son las correctas");
                    Maestra.getInstancia.addError(error);
                    throw new Exception("Dimensiones incorrectas");
                }
            }
            return(array);
        }
Пример #6
0
        public override Objeto execute(Entorno entorno)
        {
            //TODO: implementar asignacion, validar que sea integer

            Simbolo inicio = this.condicion.execute_for(entorno);

            validar_integer(inicio.getValor());

            Objeto final = obtener_expresion(entorno);

            validar_integer(final);

            int b = Int16.Parse(final.getValor().ToString());

            // Asignacion se debe agregar aca
            int a = Int16.Parse(inicio.getValor().getValor().ToString());

            if (comportamiento)
            {
                for (int i = a; i >= b; i--)
                {
                    Primitivo pr = new Primitivo(Objeto.TipoObjeto.INTEGER, i);
                    inicio.setValor(pr);
                    foreach (Nodo instruccion in this.instrucciones)
                    {
                        if (instruccion != null)
                        {
                            try
                            {
                                Objeto retorno = instruccion.execute(entorno);

                                if (retorno != null)
                                {
                                    if (retorno.getTipo() == Objeto.TipoObjeto.CONTINUE)
                                    {
                                        break;
                                    }
                                    else if (retorno.getTipo() == Objeto.TipoObjeto.BREAK)
                                    {
                                        return(null);
                                    }
                                    else if (retorno.getTipo() == Objeto.TipoObjeto.NULO)
                                    {
                                        return(retorno);
                                    }
                                }
                            }
                            catch (Exception e)
                            {
                                Console.WriteLine(e);
                            }
                        }
                    }
                }
            }
            else
            {
                for (int i = a; i <= b; i++)
                {
                    Primitivo pr = new Primitivo(Objeto.TipoObjeto.INTEGER, i);
                    inicio.setValor(pr);
                    foreach (Nodo instruccion in this.instrucciones)
                    {
                        if (instruccion != null)
                        {
                            try
                            {
                                //validar los retornos
                                Objeto retorno = instruccion.execute(entorno);

                                if (retorno != null)
                                {
                                    if (retorno.getTipo() == Objeto.TipoObjeto.CONTINUE)
                                    {
                                        break;
                                    }
                                    else if (retorno.getTipo() == Objeto.TipoObjeto.BREAK)
                                    {
                                        return(null);
                                    }
                                    else if (retorno.getTipo() == Objeto.TipoObjeto.NULO)
                                    {
                                        return(retorno);
                                    }
                                }
                            }
                            catch (Exception e)
                            {
                                Console.WriteLine(e);
                            }
                        }
                    }
                }
            }



            return(null);
        }
Пример #7
0
        //ejecuta
        public Objeto Ejecutar_Funcion_usuario(Entorno entorno, Funcion llamada)
        {
            // Se procede a copiar la lista de parametros a un arreglo
            Parametro[] auxiliar = new Parametro[llamada.getParametros().Count];
            llamada.getParametros().CopyTo(auxiliar, 0);
            //Se procede a validar el total de parametros con el total enviados
            Validar_total_parametros(llamada);

            // enlaza los entornos, con el entorno global del programa
            Entorno nuevo_entorno = new Entorno(entorno.getGlobal(), llamada.getNombre());

            int contador = 0;

            foreach (Nodo node in this.parametros)
            {
                if (node != null)
                {
                    try
                    {
                        if (auxiliar[contador].GetTipo_Parametro() == Parametro.Tipo_Parametro.VALOR)
                        {
                            // obtiene lo que viene por valor
                            Objeto salida = node.execute(entorno);
                            Match_Parametro(auxiliar[contador], salida);

                            Simbolo simbolo = new Simbolo(auxiliar[contador].getNombreParametro(), salida, Simbolo.Tipo_variable.VAR, llamada.getLinea(), llamada.getColumna());
                            nuevo_entorno.addSimbolo(simbolo, auxiliar[contador].getNombreParametro());
                        }
                        else
                        {
                            //obtiene lo que se manda por referencia y se guarda ese mismo simbolo
                            if (node is Acceso aux)
                            {
                                Simbolo salida = aux.execute_no_clonador(entorno);
                                Match_Parametro(auxiliar[contador], salida.getValor());
                                nuevo_entorno.addSimbolo(salida, auxiliar[contador].getNombreParametro());
                            }
                            else
                            {
                                Error error = new Error(node.getLinea(), node.getColumna(), Error.Errores.Semantico,
                                                        "se esperaba un identificador de variable");
                                Maestra.getInstancia.addError(error);
                                throw new Exception("se esperaba un identificador de variable");
                            }
                        }
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine(e.ToString());
                        throw new Exception(e.ToString());
                    }
                }
                contador++;
            }


            // TODO: verificar el cambio de esto
            //llamada.setLinea(base.getLinea());
            //llamada.setColumna(base.getColumna());
            auxiliar = null;

            Objeto retorno = llamada.executar_funcion_usuario(nuevo_entorno);

            return(retorno);
        }
Пример #8
0
        public override Objeto execute(Entorno entorno)
        {
            Simbolo valor = this.retornar_simbolo(entorno);

            return(valor.getValor().Clonar_Objeto());
        }