void GuardarMetodo(Metodo MetodoAGuardar_)
{
if (RegistroDeAmbitos[PilaDeAmbitos.Peek()].Metodos.ContainsKey(MetodoAGuardar_.Nombre))
{
Console.WriteLine($"El Metodo ya fue declarada con el nobre \"{MetodoAGuardar_.Nombre}\" en el ambito {MetodoAGuardar_.Ambito}");
}
else
{
if (PilaDeTipoDeSentencia.Peek() == "Interfaz")
{ //en lugar de cuardarlo en el diccionario principal se guarda en la lista de prototipos
if (RegistroDeAmbitos[PilaDeAmbitos.Peek()].Metodos.ContainsKey(MetodoAGuardar_.Nombre))
{
Console.WriteLine($"Un Prototipo de la Interfaz {RegistroDeAmbitos[PilaDeAmbitos.Peek()].Interfaces[MetodoAGuardar_.Ambito].Nombre} ya fue declarada con el nobre \"{MetodoAGuardar_.Nombre}\" en el ambito {MetodoAGuardar_.Ambito}");
}
else
{ //al ambito de la interfaz le agregamos la 0
RegistroDeAmbitos[PilaDeAmbitos.Peek()].Metodos.Add(MetodoAGuardar_.Nombre, MetodoAGuardar_);
}
}
else
{
if (AbrirUnAmbito(MetodoAGuardar_.Nombre))
{
RegistroDeAmbitos[PilaDeAmbitos.Peek()].Metodos.Add(MetodoAGuardar_.Nombre, MetodoAGuardar_);
PilaDeTipoDeSentencia.Push("Metodo");
}
else
{
}
}
}
}
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);
}
}
