public object GetValor(Entorno e)
{
Tipos tipoNuevo = GetTipo(e);
if (tipoNuevo.Equals(Tipos.NULL))
{
Console.WriteLine("No se pudo operar el casta entre los tipos " + tipoPrincipal + " y " + tipoaAsignar);
return(null);
}
//Si es un cast valido
if (valor == null)
{
Console.WriteLine("No se puede convertir un valor null a ningun otro tipo");
return(null);
}
if (tipoNuevo.Equals(Tipos.INT))
{
return(Convert.ToInt32(valor));
}
if (tipoNuevo.Equals(Tipos.DOUBLE))
{
return(Convert.ToDouble(valor));
}
return(null);
}
public void Ejecutar(Entorno e)
{
if (ids == null)
{
Console.WriteLine("Error, no existen identificadores validos para crear la collection Set");
return;
}
SetCollection set = null;
//Creo la lista
foreach (string id in ids)
{
if (e.Obtener(id) != null)
{
Console.WriteLine("No se puede declarar el Set con id " + id + " porque ya existe una variable con ese nombre en este entorno");
continue;
}
//Si traen un tipo
if (!tipo.Equals(Tipos.NULL))
{
set = new SetCollection(id, tipo);
e.InsertarSet(id, set);
}
//Si no se trae el tipo
else
{
if (valores != null)
{
tipo = valores.First.Value.GetTipo(e);
set = new SetCollection(id, tipo);
e.InsertarSet(id, set);
}
}
}
if (valores == null)
{
return;
}
//Si trae los valores
foreach (IExpresion expresion in valores)
{
object valor = expresion.GetValor(e);
Tipos t = expresion.GetTipo(e);
if (!t.Equals(tipo))
{
Console.WriteLine("No se puede insertar un tipo " + t + " en una collection Set tipo " + tipo);
continue;
}
//Si es un objeto
if (valor is Entorno atributos && t.Equals(Tipos.OBJETO))
{
//Solo lo inserto si no esta en la lista
if (set.Contains(atributos))
{
Console.WriteLine("No se pueden insertar elementos duplicados en el set " + set.identificador);
return;
}
set.Insert(new Objeto("", atributos));
}
public void Insert(object valor)
{
valores.Add(valor);
if (!tipoLista.Equals(Tipos.OBJETO))
{
valores.Sort();
}
}
public void Ejecutar(Entorno e)
{
Simbolo simb = e.Obtener(id);
if (simb == null)
{
Console.WriteLine("No se puede asigar un valor al identificador " + id + " ya que no se encuentra en este entorno");
return;
}
//Si encontramos el simbolo validamos tipos
Tipos tipo_asignacion = simb.tipo;
Tipos tipo_a_asignar = valor.GetTipo(e);
object val = valor.GetValor(e);
if (!tipo_asignacion.Equals(tipo_a_asignar))
{
//Intento realizar un casteo
Casteo cast = new Casteo(tipo_asignacion, tipo_a_asignar, val);
Tipos tipoNuevo = cast.GetTipo(e);
if (!tipoNuevo.Equals(Tipos.NULL))
{
object nuevoValor = cast.GetValor(e);
if (nuevoValor == null)
{
Console.WriteLine("Ocurrio un error al ejecutar el cast");
return;
}
//Si se obtuvo un valor valido del cast
simb.valor = nuevoValor;
}
//Si no se puede realizar el casteo
else
{
Console.WriteLine("No se puede asigar un tipo " + tipo_a_asignar + " al identificador " + id + " de tipo " + tipo_asignacion);
}
return;
}
//Si los tipos son iguales
if (val == null)
{
Console.WriteLine("No se realizo la asignacion al identificador " + id + " ya que al calcular el valor de su expresion retorno null");
return;
}
//Si se capturo un valor valido
if (simb is Objeto objeto && val is Entorno atributos)
{
objeto.atributos = atributos;
return;
}
if (simb is ListCollection list && val is List <object> valores)
{
list.valores = valores;
return;
}
simb.valor = val;
}
public Tipos GetTipo(Entorno e)
{
//Tipo principal INT
if (tipoPrincipal.Equals(Tipos.INT))
{
//Tipo a asignar double
if (tipoaAsignar.Equals(Tipos.DOUBLE))
{
return(Tipos.INT);
}
}
//Tipo principal DOUBLE
if (tipoPrincipal.Equals(Tipos.DOUBLE))
{
//Tipo a asinar int
if (tipoaAsignar.Equals(Tipos.INT))
{
return(Tipos.DOUBLE);
}
}
return(Tipos.NULL);
}
public void Ejecutar(Entorno e)
{
Simbolo encontrado = e.Obtener(id);
if (encontrado == null)
{
Console.WriteLine("No se encontro la collection: " + id + " para poder realizar la insercion");
return;
}
//Si es un map
if (encontrado is MapCollection map)
{
//La lista solo puede tener dos valores: clave y valor
if (valores.Count != 2)
{
Console.WriteLine("Error, para insertar en el map: " + id + " solo se requiere una clave y un valor");
return;
}
Object clave = valores.First.Value.GetValor(e);
if (map.TieneLaClave(clave))
{
Console.WriteLine("No se puede insertar al map: " + map.identificador + " con la clave: " + clave + " porque ya tiene un valor ingresado con la misma clave");
return;
}
Object valor = valores.Last.Value.GetValor(e);
Tipos tipoValor = valores.Last.Value.GetTipo(e);
map.Insertar(clave, valor, tipoValor);
}
//Si es una List
else if (encontrado is ListCollection list)
{
//La lista solo puede tener un parametro
if (valores.Count != 1)
{
Console.WriteLine("Error, para insertar en la list " + id + " solo se requiere un valor como parametro");
return;
}
object valor = valores.First.Value.GetValor(e);
Tipos tipo = valores.First.Value.GetTipo(e);
//Si es un objeto
if (valor is Entorno atributos && tipo.Equals(Tipos.OBJETO))
{
list.Insert(new Objeto("", atributos));
}
//Si es un primitivo
else
{
list.Insert(valor);
}
}
public Tipos GetTipo(Entorno e)
{
Tipos tipo1 = opIzq.GetTipo(e);
//Operaciones binarias
if (opDer != null)
{
Tipos tipo2 = opDer.GetTipo(e);
if (tipo1.Equals(Tipos.STRING) || tipo2.Equals(Tipos.STRING))
{
return(Tipos.STRING);
}
if (tipo1.Equals(Tipos.BOOLEAN) || tipo2.Equals(Tipos.BOOLEAN))
{
return(Tipos.NULL);
}
if (tipo1.Equals(Tipos.DOUBLE) || tipo2.Equals(Tipos.DOUBLE))
{
return(Tipos.DOUBLE);
}
if (tipo1.Equals(Tipos.INT) || tipo2.Equals(Tipos.INT))
{
return(Tipos.INT);
}
}
//Operaciones unarias
if (tipo1.Equals(Tipos.DOUBLE))
{
return(Tipos.DOUBLE);
}
if (tipo1.Equals(Tipos.INT))
{
return(Tipos.INT);
}
//Operaciones invalidas
return(Tipos.NULL);
}
public bool IsStruct()
{
return(tipo.Equals(Tipos.STRUCT));
}
public void Ejecutar(Entorno e)
{
//Adicion de identificadores al entorno
foreach (string identificador in identificadores)
{
e.Insertar(new Simbolo(identificador, tipo));
}
if (asignacion == null)
{
return;
}
//Si es una asignacion
string id = identificadores.Last.Value;
Simbolo s = e.Obtener(id);
if (s == null)
{
Console.WriteLine("No se encontro el simbolo " + id + " en este entorno");
return;
}
//Si se tiene un simbolo valido
Tipos tipoaAsignar = asignacion.GetTipo(e);
object valor = asignacion.GetValor(e);
if (!tipoaAsignar.Equals(s.tipo))
{
//Intento realizar un casteo
Casteo cast = new Casteo(s.tipo, tipoaAsignar, valor);
Tipos tipoNuevo = cast.GetTipo(e);
if (!tipoNuevo.Equals(Tipos.NULL))
{
object nuevoValor = cast.GetValor(e);
if (nuevoValor == null)
{
Console.WriteLine("Ocurrio un error al ejecutar el cast");
return;
}
//Si se obtuvo un valor valido del cast
s.valor = nuevoValor;
}
//Si no se puede realizar el casteo
else
{
Console.WriteLine("No se puede asigar un tipo difrente a " + s.tipo + " al identificador: " + id);
}
return;
}
//Si el tipo de asignacion y del simbolo son iguales
if (valor == null)
{
Console.WriteLine("El valor calculado en la asignacion del id " + id + " es null");
return;
}
//Si es un objeto
if (s is Objeto objeto && valor is Entorno atributos)
{
objeto.atributos = atributos;
return;
}
//Si es una List
if (s is ListCollection list && valor is List <object> valores)
{
list.valores = valores;
return;
}
//Si el valor calculado es valido
s.valor = valor;
}
public object GetValor(Entorno e)
{
object val1 = opIzq?.GetValor(e);
object val2 = opDer?.GetValor(e);
if (val1 != null && val2 != null)
{
Tipos superTipo = GetTipo(e);
Tipos t1 = opIzq.GetTipo(e);
Tipos t2 = opDer.GetTipo(e);
switch (operacion)
{
case Operaciones.SUMA:
if (superTipo.Equals(Tipos.STRING))
{
return(val1.ToString() + val2.ToString());
}
if (superTipo.Equals(Tipos.DOUBLE))
{
return(Convert.ToDouble(val1) + Convert.ToDouble(val2));
}
if (superTipo.Equals(Tipos.INT))
{
return(Convert.ToInt32(val1) + Convert.ToInt32(val2));
}
Console.WriteLine("Error al sumar los tipos " + t1 + " y " + t2);
break;
case Operaciones.RESTA:
if (superTipo.Equals(Tipos.DOUBLE))
{
return(Convert.ToDouble(val1) - Convert.ToDouble(val2));
}
if (superTipo.Equals(Tipos.INT))
{
return(Convert.ToInt32(val1) - Convert.ToInt32(val2));
}
Console.WriteLine("Error al restar los tipos " + t1 + " y " + t2);
break;
case Operaciones.MULTIPLICACION:
if (superTipo.Equals(Tipos.DOUBLE))
{
return(Convert.ToDouble(val1) * Convert.ToDouble(val2));
}
if (superTipo.Equals(Tipos.INT))
{
return(Convert.ToInt32(val1) * Convert.ToInt32(val2));
}
Console.WriteLine("Error al multiplicar los tipos " + t1 + " y " + t2);
break;
case Operaciones.DIVISION:
if (superTipo.Equals(Tipos.DOUBLE))
{
double divisor = Convert.ToDouble(val2);
if (divisor == 0.0)
{
Console.WriteLine("No se permite la division entre 0");
break;
}
return(Convert.ToDouble(val1) / divisor);
}
if (superTipo.Equals(Tipos.INT))
{
int divisor = Convert.ToInt32(val2);
if (divisor == 0)
{
Console.Write("No se permite la division entre 0");
break;
}
return(Convert.ToInt32(val1) / divisor);
}
Console.WriteLine("Error al multiplicar los tipos " + t1 + " y " + t2);
break;
}
}
return(null);
}
