internal Estado InsertarNodoAtributo(NodoAtributo nodo, NodoClase nodoClaseActiva)
{
if (nodoClaseActiva.LexemaC != nodo.Lexema)
{
if (!nodoClaseActiva.TSA.ContainsKey(nodo.Lexema))
{
nodoClaseActiva.TSA.Add(nodo.Lexema, nodo);
return(Estado.Insertado);
}
else
{
//Mandar error atributo duplicado
return(Estado.Duplicado);
}
}
else
{
return(Estado.DuplicadoAtributoConClase);
//Mandar error de nombre del atributo igual al nombre de su clase
}
}
public Estado InsertarNodoVariable(NodoVariables nodo, NodoClase nodoClaseActiva, string nombreMetodoActivo)
{
if (nodoClaseActiva.TSM.ContainsKey(nombreMetodoActivo))
{
var metodos = nodoClaseActiva.TSM;
NodoMetodo nodoMetodo = new NodoMetodo();
foreach (var metodo in metodos)
{
if (metodo.Key.ToString() == nombreMetodoActivo)
{
nodoMetodo = metodo.Value;
}
}
if (!nodoMetodo.TSV.ContainsKey(nodo.Lexema))
{
if (nodoClaseActiva.TSA.ContainsKey(nodo.Lexema))
{
return(Estado.DuplicadoVariableConAtributo);
}
else
{
nodoMetodo.TSV.Add(nodo.Lexema, nodo);
return(Estado.Insertado);
}
}
else
{
//se manda el error para el atributo duplicado
return(Estado.Duplicado);
}
}
else
{
//error de atributo duplicado con clase
return(Estado.DuplicadoAtributoConClase);
}
}
public Tuple <Estado, string> InsertarNodoMetodo(NodoMetodo nodo, List <NodoVariables> misParametros, NodoClase nodoClaseActiva)
{
if (nodoClaseActiva.LexemaC != nodo.Lexema)
{
//Checar que no existe un nombre de atributo igual al nombre del metodo
if (!nodoClaseActiva.TSM.ContainsKey(nodo.Lexema))
{
if (misParametros != null)
{
//Checar que el nombre del parametro no exista
foreach (var item in misParametros)
{
int iguales = 0;
foreach (var parametro in misParametros)
{
if (parametro.Lexema == item.Lexema)
{
iguales++;
if (iguales > 1)
{
return(Tuple.Create(Estado.DuplicadoVariableMetodo, nodo.Lexema));
}
}
}
nodo.TSV.Add(item.Lexema, item);
}
nodoClaseActiva.TSM.Add(nodo.Lexema, nodo);
return(Tuple.Create(Estado.Insertado, nodo.Lexema));
}
return(Tuple.Create(Estado.Insertado, nodo.Lexema));
}
else
{
// sobrecarga de metodos
List <NodoVariables> listaParametros = ObtenerParametrosMetodo(nodo.Lexema, nodoClaseActiva, true);
if (listaParametros.Count != misParametros.Count)
{
if (misParametros.Count != 0)
{
//Checar que el nombre del parametro no exista
foreach (var item in misParametros)
{
int iguales = 0;
foreach (var parametro in misParametros)
{
if (parametro.Lexema == item.Lexema)
{
iguales++;
if (iguales > 1)
{
return(Tuple.Create(Estado.DuplicadoVariableMetodo, "null"));
}
}
}
nodo.TSV.Add(item.Lexema, item);
}
Random randomNumber = new Random();
string nombreMetodo = nodo.Lexema + "@" + randomNumber.Next(10000, 99999);
nodo.Lexema = nombreMetodo;
nodoClaseActiva.TSM.Add(nombreMetodo, nodo);
return(Tuple.Create(Estado.Insertado, nombreMetodo));
}
else
{
if (listaParametros.Count == 0)
{
return(Tuple.Create(Estado.DuplicadoVariableMetodo, "null"));
}
else
{
Random randomNum = new Random();
string nombreM = nodo.Lexema + "@" + randomNum.Next(10000, 99999);
nodo.Lexema = nombreM;
nodoClaseActiva.TSM.Add(nombreM, nodo);
return(Tuple.Create(Estado.Insertado, nombreM));
}
}
}
Boolean duplicado = true;
for (int i = 0; i < misParametros.Count; i++)
{
if (misParametros[i].Lexema != listaParametros[i].Lexema || misParametros[i].MiTipo != listaParametros[i].MiTipo)
{
duplicado = false;
}
}
if (duplicado)
{
return(Tuple.Create(Estado.Duplicado, "null"));
}
if (misParametros != null)
{
//Checa que el nombre del parametro no exite
foreach (var item in misParametros)
{
int iguales = 0;
foreach (var parametro in misParametros)
{
if (parametro.Lexema == item.Lexema)
{
iguales++;
if (iguales > 1)
{
return(Tuple.Create(Estado.DuplicadoVariableMetodo, "null"));
}
}
}
nodo.TSV.Add(item.Lexema, item);
}
}
sobrecargas++;
string nombre = nodo.Lexema + "@" + sobrecargas;
nodo.Lexema = nombre;
nodoClaseActiva.TSM.Add(nombre, nodo);
return(Tuple.Create(Estado.Insertado, nombre));
}
}
else
{
return(Tuple.Create(Estado.DuplicadoMetodoConClase, ""));
}
}
public Boolean InvocacionValida(NodoClase nodoClaseActiva, string metodoActual, string metodoInvocado, List <string> listaParametros)
{
List <NodoMetodo> listaMetodos = ObtenerParametrosMetodos(metodoInvocado, nodoClaseActiva);
List <NodoVariables> listaVariables = ObtenerParametrosMetodo(metodoInvocado, nodoClaseActiva, true);
if (listaMetodos.Count == 1)
{
if (listaVariables.Count != listaParametros.Count)
{
return(false);
}
for (int i = 0; i < listaParametros.Count; i++)
{
if (listaParametros[i] == "STRING.")
{
if (TipoDato.String != listaVariables[i].MiTipo)
{
return(false);
}
continue;
}
if (TipoNodoVariable(nodoClaseActiva, metodoActual, listaParametros[i]) == TipoDato.Float && (listaVariables[i].MiTipo == TipoDato.Float))
{
continue;
}
if (TipoNodoVariable(nodoClaseActiva, metodoActual, listaParametros[i]) != listaVariables[i].MiTipo)
{
return(false);
}
}
return(true);
}
else
{
foreach (var metodo in listaMetodos)
{
if (metodo.TSV.Count != listaParametros.Count)
{
continue;
}
else if ((metodo.TSV.Count == 0 && listaParametros.Count == 0))
{
return(true);
}
List <NodoVariables> listaVariables2 = ObtenerParametrosMetodo(metodo.Lexema, nodoClaseActiva, true);
Boolean salto = false;
for (int i = 0; i < listaParametros.Count; i++)
{
TipoDato dato = stringTipoDato(listaParametros[i]);
if (dato != listaVariables2[i].MiTipo && (dato == TipoDato.Float))
{
if (!(listaParametros[i] == "STRING." && listaVariables2[i].MiTipo == TipoDato.String))
{
salto = true;
}
}
if (i == listaParametros.Count - 1 && salto == false)
{
return(true);
}
}
if (salto)
{
continue;
salto = false;
}
}
return(false);
}
}
public NodoVariables ObtenerNodoVariable(string nombreVariable, string nombreMetodo, NodoClase nodoClaseActiva)
{
var metodos = nodoClaseActiva.TSM.Values;
foreach (var metodo in metodos)
{
if (metodo.Lexema == nombreMetodo)
{
foreach (var variable in metodo.TSV.Values)
{
if (variable.Lexema == nombreVariable)
{
return(variable);
}
}
return(null);
}
}
return(null);
}
