public static NodoVariable ObtenerVariableMetodo(string variable, string metodo, NodoClase claseActual, int linea)
{
NodoMetodo nodoBusqueda = new NodoMetodo();
NodoVariable variableBuscada = new NodoVariable();
nodoBusqueda = ObtenerMetodo(metodo, claseActual.Lexema);
if (nodoBusqueda.TSV.ContainsKey(variable))
{
variableBuscada = nodoBusqueda.TSV.FirstOrDefault(x => x.Key == variable).Value;
if (variableBuscada.Valor.Count == 0)
{
ERRORES.Mensaje("Codigo: 602 Linea:" + linea + " La variable no ha sido inicializada.");
return(null);
}
else
{
return(variableBuscada);
}
}
else
{
ERRORES.Mensaje("Codigo: 602 Linea:" + linea + " La variable no existe en el contexto actual.");
return(null);
}
}
public static NodoVariable ObtenerVariableSobrecarga(string variable, string metodo, NodoClase claseActual, int linea)
{
int cont = 0;
NodoMetodo nodoBusqueda = new NodoMetodo();
NodoSobrecarga metodoEnSobrecarga = new NodoSobrecarga();
NodoVariable variableBuscada = new NodoVariable();
nodoBusqueda = ObtenerMetodo(metodo, claseActual.Lexema);
cont = nodoBusqueda.Sobrecarga.Count();
metodoEnSobrecarga = nodoBusqueda.Sobrecarga.ElementAt(cont - 1);
variableBuscada = metodoEnSobrecarga.TSV.FirstOrDefault(x => x.Key == variable).Value;
if (variableBuscada == null)
{
ERRORES.Mensaje("Codigo: 602 Linea:" + linea + " La variable no existe en el contexto actual.");
return(null);
}
else
{
if (variableBuscada.Valor.Count == 0)
{
ERRORES.Mensaje("Codigo: 602 Linea:" + linea + " La variable no ha sido inicializada.");
return(null);
}
else
{
return(variableBuscada);
}
}
}
public static void InsertarParametroMetodo(NodoVariable parametro, NodoMetodo metodoActual)
{
if (!metodoActual.TSV.ContainsKey(parametro.Lexema))
{
metodoActual.TSV.Add(parametro.Lexema, parametro);
}
else
{
ERRORES.Mensaje("Codigo: 602 Linea:" + parametro.RenglonDec + " El parametro ya existe en el contexto actual");
}
}
public static NodoSobrecarga LlenarMetodoSobrecarga(NodoMetodo metodoActual)
{
NodoSobrecarga nuevoNodo = new NodoSobrecarga();
nuevoNodo.LineaDec = metodoActual.LineaDec;
nuevoNodo.Lexema = metodoActual.Lexema;
nuevoNodo.MiRegreso = metodoActual.MiRegreso;
nuevoNodo.MiAlcance = metodoActual.MiAlcance;
return(nuevoNodo);
}
public static void InsertarVariableMetodo(NodoClase claseActual, NodoMetodo metodoActual, NodoVariable nuevaVariable)
{
if (claseActual.TSM.ContainsKey(metodoActual.Lexema))
{
if (!metodoActual.TSV.ContainsKey(nuevaVariable.Lexema))
{
metodoActual.TSV.Add(nuevaVariable.Lexema, nuevaVariable);
}
else
{
ERRORES.Mensaje("Codigo: 602 Linea:" + nuevaVariable.RenglonDec + " La variable ya existe en el metodo actual.");
}
}
}
public static void VariableNoReferenciada()
{
NodoClase clase = new NodoClase();
NodoMetodo metodo = new NodoMetodo();
NodoSobrecarga sobrecarga = new NodoSobrecarga();
NodoVariable variable = new NodoVariable();
bool conSobrecarga = false;
for (int contClase = 0; contClase < TSC.Count; contClase++)
{
clase = TSC.Values.ElementAt(contClase);
for (int contMetodo = 0; contMetodo < clase.TSM.Count; contMetodo++)
{
metodo = clase.TSM.Values.ElementAt(contMetodo);
conSobrecarga = metodo.Sobrecarga.Any();
for (int contVar = 0; contVar < metodo.TSV.Count; contVar++)
{
variable = metodo.TSV.Values.ElementAt(contVar);
if (variable.Referencias.Count == 0 && variable.EsParametro == false)
{
ERRORES.Mensaje("Codigo: 602 Linea:" + variable.RenglonDec + " La variable nunca es utilizada.");
}
}
if (conSobrecarga)
{
for (int contSob = 0; contSob < metodo.Sobrecarga.Count; contSob++)
{
sobrecarga = metodo.Sobrecarga.ElementAt(contSob);
for (int varSob = 0; varSob < sobrecarga.TSV.Count; varSob++)
{
variable = sobrecarga.TSV.Values.ElementAt(varSob);
if (variable.Referencias.Count == 0 && variable.EsParametro == false)
{
ERRORES.Mensaje("Codigo: 602 Linea:" + variable.RenglonDec + " La variable nunca es utilizada.");
}
}
}
}
}
}
}
public static void InsertarVariableSobrecarga(NodoClase claseActual, string metodo, NodoVariable nuevaVariable)
{
int contador = 0;
NodoSobrecarga sobrecarga = new NodoSobrecarga();
if (claseActual.TSM.ContainsKey(metodo))
{
NodoMetodo metodoActual = ObtenerMetodo(metodo, claseActual.Lexema);
contador = metodoActual.Sobrecarga.Count();
sobrecarga = metodoActual.Sobrecarga.ElementAt(contador - 1);
if (!sobrecarga.TSV.ContainsKey(nuevaVariable.Lexema))
{
sobrecarga.TSV.Add(nuevaVariable.Lexema, nuevaVariable);
}
else
{
ERRORES.Mensaje("Codigo: 602 Linea:" + nuevaVariable.RenglonDec + " La variable ya existe en el contexto actual.");
}
}
}
//------------------------------------------------------Metodos para metodos----------------------------------------------------------------------------------------
#region Metodos
public static void InsertarMetodo(NodoMetodo nuevoMetodo, NodoClase claseActual, List <NodoVariable> Parametros)
{
List <NodoAtributo> listaExistente = new List <NodoAtributo>();
List <NodoAtributo> listaNuevo = new List <NodoAtributo>();
bool IngresarNodo = true;
#region Metodo sin sobrecarga
if (claseActual.Lexema != nuevoMetodo.Lexema)
{
if (!claseActual.TSM.ContainsKey(nuevoMetodo.Lexema))
{
foreach (var item in Parametros)
{
InsertarParametroMetodo(item, nuevoMetodo);
}
claseActual.TSM.Add(nuevoMetodo.Lexema, nuevoMetodo);
}
#endregion
#region Sobrecarga de metodos
else
{
int enteros = 0;
int strings = 0;
int booleanos = 0;
int decimales = 0;
int enteros2 = 0;
int strings2 = 0;
int booleanos2 = 0;
int decimales2 = 0;
int enteros3 = 0;
int strings3 = 0;
int booleanos3 = 0;
int decimales3 = 0;
NodoMetodo metodoExistente = ObtenerMetodo(nuevoMetodo.Lexema, claseActual.Lexema);
NodoSobrecarga metodoSobrecarga = new NodoSobrecarga();
bool nodosEnLista = metodoExistente.Sobrecarga.Any();
if (nodosEnLista)
{
int contador = metodoExistente.sobrecarga.Count;
for (int a = 0; a < metodoExistente.TSV.Count; a++)
{
NodoVariable parExistente = metodoExistente.TSV.ElementAt(a).Value;
switch (parExistente.MiTipo)
{
case "int":
enteros++;
break;
case "string":
strings++;
break;
case "double":
decimales++;
break;
}
}
for (int a = 0; a < Parametros.Count; a++)
{
NodoVariable parNuevo = Parametros.ElementAt(a);
switch (parNuevo.MiTipo)
{
case "int":
enteros2++;
break;
case "string":
strings2++;
break;
case "double":
decimales2++;
break;
}
}
for (int g = 0; g < contador; g++)
{
NodoVariable parExistente = new NodoVariable();
NodoSobrecarga nuevoSobrecarga = metodoExistente.sobrecarga.ElementAt(g);
enteros3 = 0;
strings3 = 0;
booleanos3 = 0;
decimales3 = 0;
for (int h = 0; h < nuevoSobrecarga.TSV.Count; h++)
{
parExistente = nuevoSobrecarga.TSV.ElementAt(h).Value;
switch (parExistente.MiTipo)
{
case "int":
enteros3++;
break;
case "string":
strings3++;
break;
case "double":
decimales3++;
break;
}
}//
if (enteros == enteros2 && enteros > 0 && Parametros.Count == metodoExistente.TSV.Count || enteros == enteros2 && enteros2 > 0 && Parametros.Count == metodoExistente.TSV.Count || strings == strings2 && strings > 0 && Parametros.Count == metodoExistente.TSV.Count || strings == strings2 && strings2 > 0 && Parametros.Count == metodoExistente.TSV.Count || decimales == decimales2 && decimales > 0 && Parametros.Count == metodoExistente.TSV.Count || decimales == decimales2 && decimales2 > 0 && Parametros.Count == metodoExistente.TSV.Count)
{
IngresarNodo = false;
ERRORES.Mensaje("Codigo: 602 Linea:" + metodoExistente.LineaDec + " El metodo ya existe en el contexto actual");
enteros = 0;
strings = 0;
booleanos = 0;
decimales = 0;
enteros2 = 0;
strings2 = 0;
booleanos2 = 0;
decimales2 = 0;
enteros3 = 0;
strings3 = 0;
booleanos3 = 0;
decimales3 = 0;
}
if (enteros == enteros3 && enteros > 0 && Parametros.Count == metodoExistente.TSV.Count || enteros == enteros3 && enteros3 > 0 && Parametros.Count == metodoExistente.TSV.Count || strings == strings3 && strings > 0 && Parametros.Count == metodoExistente.TSV.Count || strings == strings3 && strings3 > 0 && Parametros.Count == metodoExistente.TSV.Count || decimales == decimales3 && decimales > 0 && Parametros.Count == metodoExistente.TSV.Count || decimales == decimales3 && decimales3 > 0 && Parametros.Count == metodoExistente.TSV.Count)
{
IngresarNodo = false;
ERRORES.Mensaje("Codigo: 602 Linea:" + metodoExistente.LineaDec + " El metodo ya existe en el contexto actual");
enteros = 0;
strings = 0;
booleanos = 0;
decimales = 0;
enteros2 = 0;
strings2 = 0;
booleanos2 = 0;
decimales2 = 0;
enteros3 = 0;
strings3 = 0;
booleanos3 = 0;
decimales3 = 0;
}
if (Parametros.Count == nuevoSobrecarga.TSV.Count && enteros3 == enteros2 && strings3 == strings2 && decimales3 == decimales2)
{
ERRORES.Mensaje("Codigo: 602 Linea:" + metodoExistente.LineaDec + " El metodo ya existe en el contexto actual");
IngresarNodo = false;
enteros = 0;
strings = 0;
booleanos = 0;
decimales = 0;
enteros2 = 0;
strings2 = 0;
booleanos2 = 0;
decimales2 = 0;
enteros3 = 0;
strings3 = 0;
booleanos3 = 0;
decimales3 = 0;
}
}
#endregion
#region IngresarNodo es true
if (IngresarNodo)
{
NodoSobrecarga metodoCarga = LlenarMetodoSobrecarga(nuevoMetodo);
foreach (var item in Parametros)
{
InsertarParametroSobrecarga(item, metodoCarga);
}
metodoExistente.Sobrecarga.Add(metodoCarga);
enteros = 0;
strings = 0;
booleanos = 0;
decimales = 0;
enteros2 = 0;
strings2 = 0;
booleanos2 = 0;
decimales2 = 0;
enteros3 = 0;
strings3 = 0;
booleanos3 = 0;
decimales3 = 0;
}
#endregion
#region Comparar solo dos metodos, el actual y el entrante sin sobrecarga
}
else if (metodoExistente.TSV.Count == 0 && Parametros.Count == 0)
{
ERRORES.Mensaje("Codigo: 602 Linea:" + 0 + " El metodo ya existe en el contexto actual");
}
else if (metodoExistente.TSV.Count == Parametros.Count)
{
for (int a = 0; a < metodoExistente.TSV.Count; a++)
{
NodoVariable parExistente = metodoExistente.TSV.ElementAt(a).Value;
switch (parExistente.MiTipo)
{
case "int":
enteros++;
break;
case "string":
strings++;
break;
case "double":
decimales++;
break;
}
}
for (int a = 0; a < Parametros.Count; a++)
{
NodoVariable parNuevo = Parametros.ElementAt(a);
switch (parNuevo.MiTipo)
{
case "int":
enteros2++;
break;
case "string":
strings2++;
break;
case "double":
decimales2++;
break;
}
}
if (enteros == enteros2 && enteros > 0 && Parametros.Count == metodoExistente.TSV.Count || enteros == enteros2 && enteros2 > 0 && Parametros.Count == metodoExistente.TSV.Count || strings == strings2 && strings > 0 && Parametros.Count == metodoExistente.TSV.Count || strings == strings2 && strings2 > 0 && Parametros.Count == metodoExistente.TSV.Count || decimales == decimales2 && decimales > 0 && Parametros.Count == metodoExistente.TSV.Count || decimales == decimales2 && decimales2 > 0 && Parametros.Count == metodoExistente.TSV.Count)
{
ERRORES.Mensaje("Codigo: 602 Linea:" + 0 + " El metodo ya existe en el contexto actual");
MessageBox.Show("El metodo ya existe en el contexto actual");
enteros = 0;
strings = 0;
booleanos = 0;
decimales = 0;
enteros2 = 0;
strings2 = 0;
booleanos2 = 0;
decimales2 = 0;
}
else
{
NodoSobrecarga metodoCarga = LlenarMetodoSobrecarga(nuevoMetodo);
foreach (var item in Parametros)
{
InsertarParametroSobrecarga(item, metodoCarga);
}
metodoExistente.Sobrecarga.Add(metodoCarga);
enteros = 0;
strings = 0;
booleanos = 0;
decimales = 0;
enteros2 = 0;
strings2 = 0;
booleanos2 = 0;
decimales2 = 0;
}
}
else
{
NodoSobrecarga metodoCarga = LlenarMetodoSobrecarga(nuevoMetodo);
foreach (var item in Parametros)
{
InsertarParametroSobrecarga(item, metodoCarga);
}
metodoExistente.Sobrecarga.Add(metodoCarga);
}
}
}
else
{
ERRORES.Mensaje("Codigo: 602 Linea:" + 0 + " El metodo no puede llamarse igual que la clase.");
}
#endregion
}