//------------------------------------- QUE NO SE TE OLVIDE ------------------------

        // hacer la llamada a el ambito mas cercano
        void GuardarClaseEnAmbito(Clase Metodo)
        {
            if (!RegistroDeAmbitos[PilaDeAmbitos.Peek()].Variables.ContainsKey(Metodo.Nombre))
            {
                RegistroDeAmbitos[PilaDeAmbitos.Peek()].Clases.Add(Metodo.Nombre, Metodo);
            }
            else
            {
                Console.WriteLine($"Una variable ya fue declarada con el nobre \"{Metodo.Nombre}\" en el ambito {PilaDeAmbitos.Peek()}");
            }
        }
        bool IdentificarDeclaracion(string Sentencia)
        {
            if (RgxSimples.IsMatch(Sentencia))
            {
                //variables simples
                var VariableAGuardar = new Variables();
                var arreglo          = Sentencia.Split();
                var tipo             = arreglo[0];

                if (arreglo[1] == "[]")
                {
                    VariableAGuardar.Nombre = arreglo[2];
                    VariableAGuardar.Array  = true;
                }
                else
                {
                    VariableAGuardar.Nombre = arreglo[1];
                    VariableAGuardar.Array  = false;
                }
                VariableAGuardar.tipo = tipo;

                //validar arreglo
                //agrega
                VariableAGuardar.Ambito   = PilaDeAmbitos.Peek();
                VariableAGuardar.val      = null;
                VariableAGuardar.Estatica = false;
                GuardarVariableEnAmbito(VariableAGuardar);
                return(true);
            }
            else if (RgxEstaticas.IsMatch(Sentencia))
            {
                //variable estatica
                var arreglo          = Sentencia.Split();
                var tipo             = arreglo[1];
                var nombre           = arreglo[2];
                var VariableAGuardar = new Variables();
                VariableAGuardar.tipo     = tipo;
                VariableAGuardar.Nombre   = nombre;
                VariableAGuardar.Ambito   = PilaDeAmbitos.Peek();
                VariableAGuardar.val      = null;
                VariableAGuardar.Estatica = true;
                GuardarVariableEnAmbito(VariableAGuardar);
                return(true);
            }
            else if (RgxClases.IsMatch(Sentencia))
            {            //CLASES
                var clases  = new Clase();
                var splited = Sentencia.Replace(" , ", " ").Split(' ');
                clases.Nombre = splited[1];
                clases.Ambito = PilaDeAmbitos.Peek();
                if (Sentencia.Contains("extends"))
                {
                    clases.HeredaDe = splited[3];
                }
                if (Sentencia.Contains("implements"))
                {
                    var inicio         = Sentencia.IndexOf("implements");
                    var parteAEliminar = "";
                    for (int i = 0; i < inicio; i++)
                    {
                        parteAEliminar += Sentencia[i];
                    }
                    var saux = Sentencia.Replace(parteAEliminar, "").Replace("implements ", "").Split(',');

                    for (int i = 0; i < saux.Length; i++)
                    {
                        clases.Interfaces.Add(saux[i].Trim());
                    }

                    var stop = 0;
                }
                //GuardarClase(clases);
                GuardarClaseEnAmbito(clases);
                AbrirUnAmbito(clases.Nombre);
                PilaDeTipoDeSentencia.Push("Clase");
                return(true);
            }
            else if (RgxMetodos.IsMatch(Sentencia))
            {            //METODOS
                var MetodoActual = new Metodo()
                {
                    Tipo   = Sentencia.Split(' ')[0],
                    Nombre = Sentencia.Split(' ')[1],
                    Ambito = PilaDeAmbitos.Peek()
                };
                MetodoActual.Ambito = PilaDeAmbitos.Peek();
                var ParametrosDeMetodo = Sentencia.Remove(0, Sentencia.IndexOf('(')).Trim().Replace("(", "").Replace(")", "").Replace(" , ", ",").Split(',');
                //diccionario clases[clase actual].metodos.add(nombre defuncion);
                //metodos generales.add[nombre, clase funcion]
                foreach (var item in ParametrosDeMetodo)
                {
                    var ParametroActual = new Variables()
                    {
                        tipo   = item.Trim().Split(' ')[0],
                        Ambito = MetodoActual.Nombre
                    };
                    if (item.Trim().Contains("[]"))
                    {                    //es un parametro tipo array
                        ParametroActual.Array  = true;
                        ParametroActual.Nombre = item.Trim().Split(' ')[2];
                    }
                    else
                    {                    //es un parametro normal
                        ParametroActual.Nombre = item.Trim().Split(' ')[1];
                    }

                    if (MetodoActual.Parametros.ContainsKey(ParametroActual.Nombre))
                    {                    //parametro de nombre repetido
                    }
                    else
                    {
                        MetodoActual.Parametros.Add(ParametroActual.Nombre, ParametroActual);
                    }
                }
                GuardarMetodo(MetodoActual);
                if (PilaDeTipoDeSentencia.Peek() == "Interfaz")
                {
                }
                else
                {
                    //AbrirUnAmbito(MetodoActual.Nombre);
                    //PilaDeTipoDeSentencia.Push("Metodo");
                }

                return(true);
            }
            else if (RgxInterfaz.IsMatch(Sentencia))
            {
                var InterfazActual = new Interfaz()
                {
                    Nombre = Sentencia.Trim().Split(' ')[1], Ambito = PilaDeAmbitos.Peek()
                };

                if (AbrirUnAmbito(InterfazActual.Nombre))
                {
                    GuardarInterfazEnAmbito(InterfazActual);
                    PilaDeTipoDeSentencia.Push("Interfaz");
                }
                else
                {                //Error en Apertura de Ambito por que ya existia en el actual
                }

                return(true);
            }
            else
            {
                if (Asignacion.IsMatch(Sentencia))
                {
                    var SimboloAAsignar    = Sentencia.Split('=')[0].Trim();
                    var VariableResultante = BuscarVariables(SimboloAAsignar);
                    if (VariableResultante == null)
                    {
                        Console.WriteLine($"La instruccion no se ejecuto por que la variable \"{SimboloAAsignar}\" no existe en ningun ambito.");
                        return(true);
                    }
                    else
                    {                    // ComprobarTipos
                        var Operacion = Sentencia.Split('=')[1].Trim();
                        var TipoGeneralDeLaOperacion = ComprobarTiposParaAsignacion(VariableResultante, Operacion);

                        if (VariableResultante.tipo == TipoGeneralDeLaOperacion.Key)
                        {
                            //operar
                            RegistroDeAmbitos[VariableResultante.Ambito].Variables[VariableResultante.Nombre].val = TipoGeneralDeLaOperacion.Value;
                        }
                        else
                        {
                            //tipos diferentes
                            Console.WriteLine($"La instruccion no se ejecuto por que la variable \"{VariableResultante.Nombre}\" es tipo {VariableResultante.tipo} y no hay convercion hacia tipo {TipoGeneralDeLaOperacion.Key} para {TipoGeneralDeLaOperacion.Value}.");
                        }
                    }
                }
                else if (RgxStmts.IsMatch(Sentencia))
                {
                    var StmtTipo   = Sentencia.Substring(0, Sentencia.IndexOf("(")).Trim();
                    var parametros = Sentencia.Remove(0, Sentencia.IndexOf("(")).Trim();

                    var resultado = VerificarParametrosDeSTMT(parametros);
                    if (resultado.Key != null)
                    {
                        Console.WriteLine($"El simbolo \"{resultado.Key}\" es tipo {resultado.Value} y no hay convercion hacia tipos diferentes dentro de las sentencias.");
                    }
                    else
                    {
                    }
                }
                else if (RgxClaseMetodoCall.IsMatch(Sentencia))
                {
                    var aux = Sentencia.Remove(0, Sentencia.IndexOf('.') + 1).Trim();
                    //obtencion de info de parametros
                    if (!RegistroDeAmbitos.ContainsKey(aux.Substring(0, aux.IndexOf("(")).Trim()))
                    {
                        Console.WriteLine($"El metodo no existe en ningun ambito{aux.Substring(0, aux.IndexOf("(")).Trim()}");
                        return(false);
                    }
                    else
                    {
                        var ParametrosDeInstancia = RegistroDeAmbitos[aux.Substring(0, aux.IndexOf("(")).Trim()].Metodos[aux.Substring(0, aux.IndexOf("(")).Trim()].Parametros;
                        var ParametrosEnviados    = aux.Remove(0, aux.IndexOf("(")).Trim().Replace("(", "").Replace(")", "").Replace(" , ", ",").Split(',');
                        var listaDeTipos          = new List <string>();
                        foreach (var item in ParametrosEnviados)
                        {
                            if (Number.IsMatch(item.Trim()))
                            {
                                listaDeTipos.Add("int");
                            }
                            else if (item.Contains("▄"))
                            {
                                listaDeTipos.Add("string");
                            }
                            else if (Boolean.IsMatch(item.Trim()))
                            {
                                listaDeTipos.Add("boolean");
                            }
                            else
                            {                            //es un tipo abstracto y tenemos que ir a traerlo
                                var encontrado = BuscarVariables(item.Trim());
                                if (encontrado == null)
                                {
                                    encontrado = BuscarEnParametros(item.Trim());
                                }
                            }
                        }
                        if (listaDeTipos.Count != ParametrosDeInstancia.Count)
                        {
                            Console.WriteLine($"No se enviaron los mismos parametros para la instancia {Sentencia}");
                        }
                        else
                        {
                            for (int i = 0; i < listaDeTipos.Count; i++)
                            {
                                if (listaDeTipos[i] != ParametrosDeInstancia.ElementAt(i).Value.tipo)
                                {
                                    Console.WriteLine($"Se envio como parametrop un {listaDeTipos[i]} y se esperaba un {ParametrosDeInstancia.ElementAt(i).Value.tipo}");
                                }
                            }
                        }
                        return(true);
                    }
                }
                else if (RgxMetodoCall.IsMatch(Sentencia))
                {
                    var aux = Sentencia;
                    //obtencion de info de parametros
                    if (!RegistroDeAmbitos.ContainsKey(aux.Substring(0, aux.IndexOf("(")).Trim()))
                    {
                        Console.WriteLine($"El metodo no existe en ningun ambito{aux.Substring(0, aux.IndexOf("(")).Trim()}");
                        return(false);
                    }
                    else
                    {
                        var ParametrosDeInstancia = RegistroDeAmbitos[aux.Substring(0, aux.IndexOf("(")).Trim()].Metodos[aux.Substring(0, aux.IndexOf("(")).Trim()].Parametros;
                        var ParametrosEnviados    = aux.Remove(0, aux.IndexOf("(")).Trim().Replace("(", "").Replace(")", "").Replace(" , ", ",").Split(',');
                        var listaDeTipos          = new List <string>();
                        foreach (var item in ParametrosEnviados)
                        {
                            if (Number.IsMatch(item.Trim()))
                            {
                                listaDeTipos.Add("int");
                            }
                            else if (item.Contains("▄"))
                            {
                                listaDeTipos.Add("string");
                            }
                            else if (Boolean.IsMatch(item.Trim()))
                            {
                                listaDeTipos.Add("boolean");
                            }
                            else
                            {                            //es un tipo abstracto y tenemos que ir a traerlo
                                var encontrado = BuscarVariables(item.Trim());
                                if (encontrado == null)
                                {
                                    encontrado = BuscarEnParametros(item.Trim());
                                }
                            }
                        }
                        if (listaDeTipos.Count != ParametrosDeInstancia.Count)
                        {
                            Console.WriteLine($"No se enviaron los mismos parametros para la instancia {Sentencia}");
                        }
                        else
                        {
                            for (int i = 0; i < listaDeTipos.Count; i++)
                            {
                                if (listaDeTipos[i] != ParametrosDeInstancia.ElementAt(i).Value.tipo)
                                {
                                    Console.WriteLine($"Se envio como parametrop un {listaDeTipos[i]} y se esperaba un {ParametrosDeInstancia.ElementAt(i).Value.tipo}");
                                }
                            }
                        }
                        return(true);
                    }
                }

                return(false);
            }
        }