/// <summary>
/// Realiza una copia de la clase específicada
/// </summary>
/// <param name="original">Clase a copiar</param>
/// <returns></returns>
public static Clase Copiar(Clase original)
{
Clase prueba = new Clase();
///Copia los simbolos
foreach (var lst01 in original.ClaseSym)
{
Simbolo symPrueba = new Simbolo
{
Arr = lst01.Value.Arr,
Dato = lst01.Value.Dato,
EsPrivado = lst01.Value.EsPrivado,
Oper = lst01.Value.Oper,
TipoDato = lst01.Value.TipoDato
};
if (lst01.Value.Arreglo != null)
{
Arreglo arr = new Arreglo
{
Dimension = lst01.Value.Arreglo.Dimension,
SizeBi = lst01.Value.Arreglo.SizeBi,
SizeUni = lst01.Value.Arreglo.SizeUni,
SizeTri = lst01.Value.Arreglo.SizeTri
};
symPrueba.Arreglo = arr;
}
if (lst01.Value.Posicion != null)
{
Posicion pos = new Posicion(lst01.Value.Posicion.Fila, lst01.Value.Posicion.Columna);
symPrueba.Posicion = pos;
}
prueba.ClaseSym.Add(lst01.Key.ToString(), symPrueba);
}
///Copia los nombre de las clases importadas
foreach (var lst01 in original.ClaseImpNames)
{
prueba.ClaseImpNames.AddLast(lst01.ToString());
}
///Copia las funciones de la clase
foreach (var lst01 in original.ClaseEnt)
{
Funcion funcion = Funcion.Copiar(lst01.Value);
funcion.ClaseEnt = prueba.ClaseEnt;
funcion.ClaseImp = prueba.ClaseImp;
funcion.ClaseImpNames = prueba.ClaseImpNames;
funcion.ClaseSym = prueba.ClaseSym;
prueba.ClaseEnt.Add(lst01.Key, funcion);
}
///Copia las clases importadas
foreach (var lst01 in original.ClaseImp)
{
prueba.ClaseImp.Add(lst01.Key.ToString(), Copiar(lst01.Value));
}
return(prueba);
}
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);
}
