/// <summary>
/// Busca en el diccionario de Funciones de la clase y en las funciones de las clases importadas
/// </summary>
/// <param name="nombreFuncion">Nombre de la Función buscada</param>
/// <returns></returns>
public Funcion BuscarFuncion(string nombreFuncion)
{
///Busca en el diccionario local
if (ClaseEnt.ContainsKey(nombreFuncion))
{
return(ClaseEnt[nombreFuncion]);
}
//Recorre el diccionario de clases importadas
//en busca de una coincidencia
foreach (var flagClass in ClaseImp)
{
//Utiliza recursion para buscar la función
Funcion ret = flagClass.Value.BuscarFuncion(nombreFuncion);
//Verifica que no sea nulo lo que se devolvió
if (ret != null)
{
//Si no es nulo retorna el valor
return(ret);
}
}
//No encontró ninguna coincidencia, retorna un null
return(null);
}
public bool Ejecutar()
{
Operar operar = new Operar(this, this);
//Ejecutará las OPER y ARR de los simbolos
foreach (var symClass in ClaseSym)
{
//Se recupera el tipo de simbolo
var symClasType = symClass.Value.TipoDato;
//Si no es null opera el DIMENSIONLST
if (symClass.Value.Arr != null)
{
var symClassArr = operar.Interpretar(symClass.Value.Arr);
symClass.Value.Arreglo = symClassArr.Arreglo;
}
//Si no es null opera el OPER
if (symClass.Value.Oper != null)
{
var symClassOper = operar.Interpretar(symClass.Value.Oper);
//Determina si los tipos son los mismo
if (symClassOper.TipoDato != symClass.Value.TipoDato)
{
Main.Imprimir(String.Format("Los tipos no coinciden {0} -> {1} : ({2},{3})", symClassOper.TipoDato, symClass.Value.TipoDato, symClass.Value.Posicion.Fila, symClass.Value.Posicion.Columna));
return(true);
}
//Los tipos coinciden
//Se debe determinar si es un arreglo
if (symClassOper.TipoDato > Tipo.CLASE)
{
if (symClassOper.Arreglo.Dimension != symClass.Value.Arreglo.Dimension)
{
Main.Imprimir(String.Format("Las dimensiones de {0} no coincide con {1} : ({2},{3})", symClassOper.TipoDato, symClass.Value.TipoDato, symClassOper.Posicion != null ? symClassOper.Posicion.Fila : 0, symClassOper.Posicion != null ? symClassOper.Posicion.Columna : 0));
return(true);
}
//Es un arreglo, debe asegurarse que las dimensiones coincidan
if (symClassOper.Arreglo.SizeUni != symClass.Value.Arreglo.SizeUni)
{
Main.Imprimir(String.Format("El arreglo unidemensional de {0} no coincide con {1} : ({2},{3})", symClassOper.TipoDato, symClass.Value.TipoDato, symClassOper.Posicion != null ? symClassOper.Posicion.Fila : 0, symClassOper.Posicion != null ? symClassOper.Posicion.Columna : 0));
return(true);
}
if (symClassOper.Arreglo.SizeBi != symClass.Value.Arreglo.SizeBi)
{
Main.Imprimir(String.Format("El arreglo bidemensional de {0} no coincide con {1} : ({2},{3})", symClassOper.TipoDato, symClass.Value.TipoDato, symClassOper.Posicion != null ? symClassOper.Posicion.Fila : 0, symClassOper.Posicion != null ? symClassOper.Posicion.Columna : 0));
return(true);
}
if (symClassOper.Arreglo.SizeTri != symClass.Value.Arreglo.SizeTri)
{
Main.Imprimir(String.Format("El arreglo tridemensional de {0} no coincide con {1} : ({2},{3})", symClassOper.TipoDato, symClass.Value.TipoDato, symClassOper.Posicion != null ? symClassOper.Posicion.Fila : 0, symClassOper.Posicion != null ? symClassOper.Posicion.Columna : 0));
return(true);
}
}
//Asigna el valor de symClassOpera al dato del diccionar de clases actual
symClass.Value.Dato = symClassOper.Dato;
}
//Si es un arreglo se asegurará de inicializar el arreglo
else if (symClass.Value.TipoDato > Tipo.CLASE)
{
//Inicializa el dato
object arrDato = null;
var dimArrSym = symClass.Value;
//Según las dimensiones
switch (dimArrSym.Arreglo.Dimension)
{
case TipoArreglo.UNI:
switch (dimArrSym.TipoDato)
{
case Tipo.INTARR:
arrDato = new int[dimArrSym.Arreglo.SizeUni];
break;
case Tipo.STRINGARR:
arrDato = new string[dimArrSym.Arreglo.SizeUni];
break;
case Tipo.DOUBLEARR:
arrDato = new double[dimArrSym.Arreglo.SizeUni];
break;
case Tipo.CHARARR:
arrDato = new char[dimArrSym.Arreglo.SizeUni];
break;
case Tipo.BOOLEANARR:
arrDato = new bool[dimArrSym.Arreglo.SizeUni];
break;
case Tipo.CLASEARR:
arrDato = new Clase[dimArrSym.Arreglo.SizeUni];
break;
}
break;
case TipoArreglo.BI:
switch (dimArrSym.TipoDato)
{
case Tipo.INTARR:
arrDato = new int[dimArrSym.Arreglo.SizeBi][];
//recorre el arreglo inicializando el arreglo
for (int i = 0; i < (arrDato as int[][]).Length; i++)
{
(arrDato as int[][])[i] = new int[dimArrSym.Arreglo.SizeUni];
}
break;
case Tipo.STRINGARR:
arrDato = new string[dimArrSym.Arreglo.SizeBi][];
for (int i = 0; i < (arrDato as string[][]).Length; i++)
{
(arrDato as string[][])[i] = new string[dimArrSym.Arreglo.SizeUni];
}
break;
case Tipo.DOUBLEARR:
arrDato = new double[dimArrSym.Arreglo.SizeBi][];
for (int i = 0; i < (arrDato as double[][]).Length; i++)
{
(arrDato as double[][])[i] = new double[dimArrSym.Arreglo.SizeUni];
}
break;
case Tipo.CHARARR:
arrDato = new char[dimArrSym.Arreglo.SizeBi][];
for (int i = 0; i < (arrDato as char[][]).Length; i++)
{
(arrDato as char[][])[i] = new char[dimArrSym.Arreglo.SizeUni];
}
break;
case Tipo.BOOLEANARR:
arrDato = new bool[dimArrSym.Arreglo.SizeBi][];
for (int i = 0; i < (arrDato as bool[][]).Length; i++)
{
(arrDato as bool[][])[i] = new bool[dimArrSym.Arreglo.SizeUni];
}
break;
case Tipo.CLASEARR:
arrDato = new Clase[dimArrSym.Arreglo.SizeBi][];
for (int i = 0; i < (arrDato as Clase[][]).Length; i++)
{
(arrDato as Clase[][])[i] = new Clase[dimArrSym.Arreglo.SizeUni];
}
break;
}
break;
case TipoArreglo.TRI:
switch (dimArrSym.TipoDato)
{
case Tipo.INTARR:
arrDato = new int[dimArrSym.Arreglo.SizeTri][][];
for (int i = 0; i < dimArrSym.Arreglo.SizeTri; i++)
{
(arrDato as int[][][])[i] = new int[dimArrSym.Arreglo.SizeBi][];
for (int j = 0; j < dimArrSym.Arreglo.SizeBi; i++)
{
(arrDato as int[][][])[i][j] = new int[dimArrSym.Arreglo.SizeUni];
}
}
break;
case Tipo.STRINGARR:
arrDato = new string[dimArrSym.Arreglo.SizeTri][][];
for (int i = 0; i < dimArrSym.Arreglo.SizeTri; i++)
{
(arrDato as string[][][])[i] = new string[dimArrSym.Arreglo.SizeBi][];
for (int j = 0; j < dimArrSym.Arreglo.SizeBi; i++)
{
(arrDato as string[][][])[i][j] = new string[dimArrSym.Arreglo.SizeUni];
}
}
break;
case Tipo.DOUBLEARR:
arrDato = new double[dimArrSym.Arreglo.SizeTri][][];
for (int i = 0; i < dimArrSym.Arreglo.SizeTri; i++)
{
(arrDato as double[][][])[i] = new double[dimArrSym.Arreglo.SizeBi][];
for (int j = 0; j < dimArrSym.Arreglo.SizeBi; i++)
{
(arrDato as double[][][])[i][j] = new double[dimArrSym.Arreglo.SizeUni];
}
}
break;
case Tipo.CHARARR:
arrDato = new char[dimArrSym.Arreglo.SizeTri][][];
for (int i = 0; i < dimArrSym.Arreglo.SizeTri; i++)
{
(arrDato as char[][][])[i] = new char[dimArrSym.Arreglo.SizeBi][];
for (int j = 0; j < dimArrSym.Arreglo.SizeBi; i++)
{
(arrDato as char[][][])[i][j] = new char[dimArrSym.Arreglo.SizeUni];
}
}
break;
case Tipo.BOOLEANARR:
arrDato = new bool[dimArrSym.Arreglo.SizeTri][][];
for (int i = 0; i < dimArrSym.Arreglo.SizeTri; i++)
{
(arrDato as bool[][][])[i] = new bool[dimArrSym.Arreglo.SizeBi][];
for (int j = 0; j < dimArrSym.Arreglo.SizeBi; i++)
{
(arrDato as bool[][][])[i][j] = new bool[dimArrSym.Arreglo.SizeUni];
}
}
break;
case Tipo.CLASEARR:
arrDato = new Clase[dimArrSym.Arreglo.SizeTri][][];
for (int i = 0; i < dimArrSym.Arreglo.SizeTri; i++)
{
(arrDato as Clase[][][])[i] = new Clase[dimArrSym.Arreglo.SizeBi][];
for (int j = 0; j < dimArrSym.Arreglo.SizeBi; i++)
{
(arrDato as Clase[][][])[i][j] = new Clase[dimArrSym.Arreglo.SizeUni];
}
}
break;
}
break;
}
//asigna el dato al symClass
symClass.Value.Dato = arrDato;
}
}
//Importar clases
foreach (var impNameClass in ClaseImpNames)
{
//Buscará coincidencias en el diccionario de clases
if (Recorrido.Clases.ContainsKey(impNameClass))
{
ClaseImp.Add(impNameClass, Clase.Copiar(Recorrido.Clases[impNameClass]));
}
else
{
Main.Imprimir(String.Format("No se encontró la importación : {0}", impNameClass));
return(true);
}
}
//Verificará que las funciones marcadas como override existan en alguna clase importada
bool flagOverride = false;
foreach (var funClass in ClaseEnt)
{
if (funClass.Value.Override)
{
//Es una sobrecarga, lo que obliga que exista una función con el mismo nombre en
//el listado de entornos de clases importadas
foreach (var impClass in ClaseImp)
{
//Buscará en sus entornos un nombre igual
if (impClass.Value.ClaseEnt.ContainsKey(funClass.Key))
{
flagOverride = true;
break;
}
}
//No encontró ninguna coinciden, se termina la operación
if (!flagOverride)
{
Main.Imprimir(String.Format("La función {0} no permite sobrecarga", funClass.Key));
return(true);
}
}
}
//Buscará una ocurrencia del main
if (ClaseEnt.ContainsKey("main"))
{
//Recupera dicha ocurrencia
Funcion func = ClaseEnt["main"];
//Ejecuta la ocurrencia
Nativa.Print(String.Format("El main terminó en : {0}", func.Ejecutar()));
}
//Al finalizar copia las variables que se encuentran en el diccionario de simbolos local
foreach (var locSym in ClaseSym)
{
Main.AgregarSimbolo(locSym.Key, locSym.Value, this.ToString());
}
return(false);
}
