public itemValor opMenorQue(String ambito, elementoEntorno elem)
{
MayorIgualQue mayorIgualQue = new MayorIgualQue(hijo1, hijo2, tabla, signo);
itemValor retorno = mayorIgualQue.opMayorIgualQue(ambito, elem);
if (retorno.isTypeBooleano())
{
if (retorno.getBooleano())
{
retorno.setValue(false);
return(retorno);
}
else
{
retorno.setValue(true);
return(retorno);
}
}
else
{
tabla.tablaErrores.insertErrorSemantic("No se recibió un booleano en" + ambito, signo);
return(retorno);
}
}
public itemValor opDiferenciacion(String ambito, elementoEntorno elem)
{
IgualQue dif = new IgualQue(hijo1, hijo2, tabla, signo);
itemValor retorno = dif.opIgualacion(ambito, elem);
if (retorno.isTypeBooleano())
{
if (retorno.getBooleano())
{
retorno.setValue(false);
return(retorno);
}
else
{
retorno.setValue(true);
return(retorno);
}
}
else
{
tabla.tablaErrores.insertErrorSemantic("No se recibió un booleano en" + ambito, signo);
return(retorno);
}
}
public List <int> getLstInt(elementoEntorno tablaEntor, token nombreVar)
{
List <int> retorno = new List <int>();
foreach (nodoModelo temp in hijos)
{
//tiene que ser de dimensión cero prro
if (hayErrores())
{
return(retorno);
}
_PAR_CORCHETES_VAL par = (_PAR_CORCHETES_VAL)temp;
itemValor te = par.getValor(tablaEntor, nombreVar);
if (te.isTypeBooleano())
{
if (te.getBooleano())
{
retorno.Add(1);
}
else
{
retorno.Add(0);
}
}
else if (te.isTypeDecimal())
{
int valor = Convert.ToInt32(te.getDecimal());
if (valor >= 0)
{
retorno.Add(valor);
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede crear una matriz con tamaño negativo", nombreVar);
return(retorno);
}
}
else if (te.isTypeEntero())
{
if (te.getEntero() >= 0)
{
// println("Agreando:" + te.getEntero());
retorno.Add(te.getEntero());
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede crear una matriz con tamaño negativo", nombreVar);
return(retorno);
}
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede crear una matriz con tamaño de tipo : " + te.getTipo(), nombreVar);
return(retorno);
}
}
return(retorno);
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public itemValor opIgualacion(itemValor val1, itemValor val2, String ambito, elementoEntorno elem)
{
itemValor retorno = new itemValor();
if (val1 == null)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmetica]" + ambito + "Hijo1 es null", new token("--"));
return(retorno);
}
if (val2 == null)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmetica]" + ambito + " Hijo1 es null", new token("--"));
return(retorno);
}
println("----al principio---");
println("val1->" + val1.getTipo());
println("val2->" + val2.getTipo());
try
{
/*
|--------------------------------------------------------------------------
| Booleano
|--------------------------------------------------------------------------
*/
/*
* Booleano == Booleano
*/
if (val1.isTypeBooleano() && val2.isTypeBooleano())
{
if (val1.getBooleano() == val2.getBooleano())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Booleano == Entero
*/
else if (val1.isTypeBooleano() && val2.isTypeEntero())
{
int entero1 = 0;
if (val1.getBooleano())
{
entero1 = 1;
}
else
{
entero1 = 0;
}
if (entero1 == val2.getEntero())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Booleano == Decimal
*/
else if (val1.isTypeBooleano() && val2.isTypeDecimal())
{
Double entero1 = 0.0;
if (val1.getBooleano())
{
entero1 = 1.0;
}
else
{
entero1 = 0.0;
}
if (entero1 == val2.getDecimal())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Booleano == Cadena
*/
else if (val1.isTypeBooleano() && val2.isTypeCadena())
{
int entero1 = 0;
if (val1.getBooleano())
{
entero1 = 1;
}
else
{
entero1 = 0;
}
if (entero1 == val2.getCadena().Length)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
|--------------------------------------------------------------------------
| Entero
|--------------------------------------------------------------------------
*/
/*
* Entero == Booleano
*/
else if (val1.isTypeEntero() && val2.isTypeBooleano())
{
int entero2 = 0;
if (val2.getBooleano())
{
entero2 = 1;
}
else
{
entero2 = 0;
}
if (val1.getEntero() == entero2)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Entero == Entero
*/
else if (val1.isTypeEntero() && val2.isTypeEntero())
{
if (val1.getEntero() == val2.getEntero())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Entero == Decimal
*/
else if (val1.isTypeEntero() && val2.isTypeDecimal())
{
Double num2 = val2.getDecimal();
int valInt2 = (int)Math.Truncate(num2);
if (val1.getEntero() == valInt2)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Entero == Cadena
*
*/
else if (val1.isTypeEntero() && val2.isTypeCadena())
{
if (val1.getEntero() == val2.getCadena().Length)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
|--------------------------------------------------------------------------
| Cadena
|--------------------------------------------------------------------------
*/
/*
* Cadena * Booleano = Cadena
*/
else if (val1.isTypeCadena() && val2.isTypeBooleano())
{
int entero2 = 0;
if (val2.getBooleano())
{
entero2 = 1;
}
else
{
entero2 = 0;
}
if (val1.getCadena().Length == entero2)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Cadena == Numerico
*/
else if (val1.isTypeCadena() && val2.isTypeEntero())
{
if (val1.getCadena().Length == val2.getEntero())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Cadena == Decimal
*/
else if (val1.isTypeCadena() && val2.isTypeDecimal())
{
if (val1.getCadena().Length == val2.getDecimal())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Cadena == Cadena
*/
else if (val1.isTypeCadena() && val2.isTypeCadena())
{
if (val1.getCadena().Equals(val2.getCadena()))
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
|--------------------------------------------------------------------------
| Decimal
|--------------------------------------------------------------------------
*/
/*
* Decimal == Booleano
*/
else if (val1.isTypeDecimal() && val2.isTypeBooleano())
{
Double entero2 = 0.0;
if (val2.getBooleano())
{
entero2 = 1.0;
}
else
{
entero2 = 0.0;
}
if (val1.getDecimal() == entero2)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Decimal == Numerico
*/
else if (val1.isTypeDecimal() && val2.isTypeEntero())
{
int valInt1 = (int)Math.Truncate(val1.getDecimal());
if (valInt1 == val2.getEntero())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Decimal == Cadena
*/
else if (val1.isTypeDecimal() && val2.isTypeCadena())
{
if (val1.getDecimal() == val2.getCadena().Length)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Decimal == Decimal
*/
else if (val1.isTypeDecimal() && val2.isTypeDecimal())
{
if (val1.getDecimal() == val2.getDecimal())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
|--------------------------------------------------------------------------
| Comparando tipo date
|--------------------------------------------------------------------------
*/
/*
* FechaHora == Fecha
*/
else if ((val1.isTypeFechaHora() || val1.isTypeFecha() || val1.isTypeHora()) && (val2.isTypeFechaHora() || val2.isTypeFecha() || val2.isTypeHora()))
{
if (val1.getFechaHora() == val2.getFechaHora())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
|--------------------------------------------------------------------------
| NULO
|--------------------------------------------------------------------------
*/
/*
* Nulo == Nulo
*/
else if (val1.isTypeNulo() && val2.isTypeNulo())
{
retorno.setValue(true);
println("Si se recoocieron los tipos");
println("val1->" + val1.getTipo());
println("val2->" + val2.getTipo());
return(retorno);
}
else
{
println("No se recoocieron los tipos");
println("val1->" + val1.getTipo());
println("val2->" + val2.getTipo());
if (val1.valor.Equals(val2.valor))
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
//tabla.tablaErrores.insertErrorSemantic("No se pueden operar [" + ambito + "] " + val1.getTipo() + " con " + val2.getTipo(), signo);
}
}
catch (Exception)
{
tabla.tablaErrores.insertErrorSemantic("[opRelacional]No se pudo efectuar [" + ambito + " ]", signo);
}
return(retorno);
}
public itemValor opMayorQue(String ambito, elementoEntorno elem)
{
itemValor retorno = new itemValor();
itemValor val1 = hijo1.getValor(elem);
itemValor val2 = hijo2.getValor(elem);
if (val1 == null)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmetica]" + ambito + "Hijo1 es null", new token("--"));
return(retorno);
}
if (val2 == null)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmetica]" + ambito + " Hijo1 es null", new token("--"));
return(retorno);
}
try
{
/*
|--------------------------------------------------------------------------
| Booleano
|--------------------------------------------------------------------------
*/
/*
* Booleano > Booleano
*/
if (val1.isTypeBooleano() && val2.isTypeBooleano())
{
tabla.tablaErrores.insertErrorSemantic("No se pueden comparar valores booleanos [" + ambito + "] " + val1.getTipo() + " == " + val2.getTipo(), signo);
return(retorno);
}
/*
* Booleano > Entero
*/
else if (val1.isTypeBooleano() && val2.isTypeEntero())
{
int entero1 = 0;
if (val1.getBooleano())
{
entero1 = 1;
}
else
{
entero1 = 0;
}
if (entero1 > val2.getEntero())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Booleano > Decimal
*/
else if (val1.isTypeBooleano() && val2.isTypeDecimal())
{
Double entero1 = 0.0;
if (val1.getBooleano())
{
entero1 = 1.0;
}
else
{
entero1 = 0.0;
}
if (entero1 > val2.getDecimal())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Booleano > Cadena
*/
else if (val1.isTypeBooleano() && val2.isTypeCadena())
{
int entero1 = 0;
if (val1.getBooleano())
{
entero1 = 1;
}
else
{
entero1 = 0;
}
if (entero1 > val2.getCadena().Length)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
|--------------------------------------------------------------------------
| Entero
|--------------------------------------------------------------------------
*/
/*
* Entero > Booleano
*/
else if (val1.isTypeEntero() && val2.isTypeBooleano())
{
int entero2 = 0;
if (val2.getBooleano())
{
entero2 = 1;
}
else
{
entero2 = 0;
}
if (val1.getEntero() > entero2)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Entero > Entero
*/
else if (val1.isTypeEntero() && val2.isTypeEntero())
{
if (val1.getEntero() > val2.getEntero())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Entero > Decimal
*/
else if (val1.isTypeEntero() && val2.isTypeDecimal())
{
Double num2 = val2.getDecimal();
int valInt2 = (int)Math.Truncate(num2);
if (val1.getEntero() > valInt2)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Entero > Cadena
*
*/
else if (val1.isTypeEntero() && val2.isTypeCadena())
{
if (val1.getEntero() > val2.getCadena().Length)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
|--------------------------------------------------------------------------
| Cadena
|--------------------------------------------------------------------------
*/
/*
* Cadena * Booleano = Cadena
*/
else if (val1.isTypeCadena() && val2.isTypeBooleano())
{
int entero2 = 0;
if (val2.getBooleano())
{
entero2 = 1;
}
else
{
entero2 = 0;
}
if (val1.getCadena().Length > entero2)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Cadena > Numerico
*/
else if (val1.isTypeCadena() && val2.isTypeEntero())
{
if (val1.getCadena().Length > val2.getEntero())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Cadena > Decimal
*/
else if (val1.isTypeCadena() && val2.isTypeDecimal())
{
if (val1.getCadena().Length > val2.getDecimal())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Cadena > Cadena
*/
else if (val1.isTypeCadena() && val2.isTypeCadena())
{
if (val1.getCadena().Length > val2.getCadena().Length)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
|--------------------------------------------------------------------------
| Decimal
|--------------------------------------------------------------------------
*/
/*
* Decimal > Booleano
*/
else if (val1.isTypeDecimal() && val2.isTypeBooleano())
{
Double entero2 = 0.0;
if (val2.getBooleano())
{
entero2 = 1.0;
}
else
{
entero2 = 0.0;
}
if (val1.getDecimal() > entero2)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Decimal > Numerico
*/
else if (val1.isTypeDecimal() && val2.isTypeEntero())
{
int valInt1 = (int)Math.Truncate(val1.getDecimal());
if (valInt1 > val2.getEntero())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Decimal > Cadena
*/
else if (val1.isTypeDecimal() && val2.isTypeCadena())
{
if (val1.getDecimal() > val2.getCadena().Length)
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
* Decimal > Decimal
*/
else if (val1.isTypeDecimal() && val2.isTypeDecimal())
{
if (val1.getDecimal() > val2.getDecimal())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
/*
|--------------------------------------------------------------------------
| Comparando tipo date
|--------------------------------------------------------------------------
*/
/*
* FechaHora > Fecha
*/
else if ((val1.isTypeFechaHora() || val1.isTypeFecha() || val1.isTypeHora()) && (val2.isTypeFechaHora() || val2.isTypeFecha() || val2.isTypeHora()))
{
if (val1.getFechaHora() > val2.getFechaHora())
{
retorno.setValue(true);
}
else
{
retorno.setValue(false);
}
return(retorno);
}
else
{
tabla.tablaErrores.insertErrorSemantic("No se pueden operar [" + ambito + "] " + val1.getTipo() + " con " + val2.getTipo(), signo);
}
}
catch (Exception)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmeticaSuma]No se pudo efectuar [" + ambito + " ]", signo);
}
return(retorno);
}
public itemValor opPotencia(elementoEntorno elem)
{
itemValor retorno = new itemValor();
itemValor val1 = hijo1.getValor(elem);
itemValor val2 = hijo2.getValor(elem);
if (val1 == null)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmetica]opSuma Hijo1 es null", new token("--"));
return(retorno);
}
if (val2 == null)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmetica]opSuma Hijo1 es null", new token("--"));
return(retorno);
}
try
{
/*
|--------------------------------------------------------------------------
| Booleano
|--------------------------------------------------------------------------
*/
/*
* Booleano ^ Booleano = Booleano
*/
/*
* Booleano ^ Entero = Entero
*/
if (val1.isTypeBooleano() && val2.isTypeEntero())
{
Double entero1 = 0.0;
if (val1.getBooleano())
{
entero1 = 1.0;
}
else
{
entero1 = 0.0;
}
retorno.setTypeDecimal();
retorno.valor = Math.Pow(entero1, (Double)val2.getEntero());
}
/*
* Booleano ^ Decimal = Decimal
*/
else if (val1.isTypeBooleano() && val2.isTypeDecimal())
{
Double entero1 = 0.0;
if (val1.getBooleano())
{
entero1 = 1.0;
}
else
{
entero1 = 0.0;
}
retorno.setTypeDecimal();
retorno.valor = Math.Pow(entero1, val2.getDecimal());
}
/*
* Booleano^ Cadena = Cadena
*/
/*
|--------------------------------------------------------------------------
| Entero
|--------------------------------------------------------------------------
*/
/*
* Entero ^ Booleano = Entero
*/
else if (val1.isTypeEntero() && val2.isTypeBooleano())
{
Double entero2 = 0.0;
if (val2.getBooleano())
{
entero2 = 1.0;
}
else
{
entero2 = 0.0;
}
retorno.setTypeDecimal();
retorno.valor = Math.Pow((Double)val1.getEntero(), entero2);
}
/*
* Entero / Entero = Entero
*/
else if (val1.isTypeEntero() && val2.isTypeEntero())
{
retorno.setTypeDecimal();
retorno.valor = Math.Pow((Double)val1.getEntero(), (Double)val2.getEntero());
}
/*
* Entero / Decimal = Decimal
*/
else if (val1.isTypeEntero() && val2.isTypeDecimal())
{
retorno.setTypeDecimal();
retorno.valor = Math.Pow((Double)val1.getEntero(), val2.getDecimal());
}
/*
* Entero / Cadena = Cadena
*/
/*
|--------------------------------------------------------------------------
| Cadena
|--------------------------------------------------------------------------
*/
/*
* Cadena / Booleano = Cadena
*/
/*
* Cadena / Numerico = Cadena
*/
/*
* Cadena / Decimal = Cadena
*/
/*
* Cadena / Cadena = Cadena
*/
/*
|--------------------------------------------------------------------------
| Decimal
|--------------------------------------------------------------------------
*/
/*
* Decimal / Booleano = Decimal
*/
else if (val1.isTypeDecimal() && val2.isTypeBooleano())
{
Double entero2 = 0.0;
if (val2.getBooleano())
{
entero2 = 1.0;
}
else
{
entero2 = 0.0;
}
retorno.setTypeDecimal();
retorno.valor = Math.Pow(val1.getDecimal(), entero2);
}
/*
* Decimal / Numerico = Decimal
*/
else if (val1.isTypeDecimal() && val2.isTypeEntero())
{
retorno.setTypeDecimal();
retorno.valor = Math.Pow(val1.getDecimal(), (Double)val2.getEntero());
}
/*
* Decimal / Cadena = Cadena
*/
/*
* Decimal / Decimal = Decimal
*/
else if (val1.isTypeDecimal() && val2.isTypeDecimal())
{
if (val2.getDecimal() == 0.0)
{
tabla.tablaErrores.insertErrorSemantic("No puede haber denominador cero", signo);
return(retorno);
}
retorno.setTypeDecimal();
retorno.valor = Math.Pow(val1.getDecimal(), val2.getDecimal());
}
else
{
tabla.tablaErrores.insertErrorSemantic("No se pueden operar la [Potencia] " + val1.getTipo() + " elevado a " + val2.getTipo(), signo);
}
//aquí hay que parsear los objetos
}
catch (Exception e)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmeticaSuma]No se pudo efectuar la potencia", signo);
}
return(retorno);
}
public itemValor opNot(String ambito, elementoEntorno elem)
{
itemValor retorno = new itemValor();
itemValor val1 = hijo1.getValor(elem);
if (val1 == null)
{
tabla.tablaErrores.insertErrorSemantic("[opLogica]" + ambito + "Hijo1 es null", new token("--"));
return(retorno);
}
try
{
/*
|--------------------------------------------------------------------------
| Booleano
|--------------------------------------------------------------------------
*/
/*
* Booleano
*/
if (val1.isTypeBooleano())
{
retorno.setValue(!val1.getBooleano());
return(retorno);
}
/*
|--------------------------------------------------------------------------
| Entero
|--------------------------------------------------------------------------
*/
/*
* Entero
*/
else if (val1.isTypeEntero())
{
int bool1 = 0;
int val1R = val1.getEntero();
if (val1R == 0)
{
bool1 = 1;
}
else if (val1R == 1)
{
bool1 = 0;
}
else
{
tabla.tablaErrores.insertErrorSemantic("El entero: " + val1R + " no se puede parsear a un valor booleano", signo);
return(retorno);
}
retorno.setValue(bool1);
return(retorno);
}
/*
|--------------------------------------------------------------------------
| Decimal
|--------------------------------------------------------------------------
*/
/*
* Decimal
*/
else if (val1.isTypeDecimal())
{
double bool1 = 0.0;
double val1R = val1.getDecimal();
if (val1R == 0.0)
{
bool1 = 1.0;
}
else if (val1R == 1.0)
{
bool1 = 0.0;
}
else
{
tabla.tablaErrores.insertErrorSemantic("El decimal: " + val1R + " no se puede parsear a un valor booleano", signo);
return(retorno);
}
retorno.setValue(bool1);
return(retorno);
}
else
{
tabla.tablaErrores.insertErrorSemantic("No se pueden operar [" + ambito + "] " + val1.getTipo(), signo);
}
}
catch (Exception)
{
tabla.tablaErrores.insertErrorSemantic("[opLogica]No se pudo efectuar [" + ambito + " ]", signo);
}
return(retorno);
}
public itemValor opMultiplicacion(elementoEntorno elem)
{
itemValor retorno = new itemValor();
itemValor val1 = hijo1.getValor(elem);
itemValor val2 = hijo2.getValor(elem);
if (val1 == null)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmetica]opSuma Hijo1 es null", new token("--"));
return(retorno);
}
if (val2 == null)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmetica]opSuma Hijo1 es null", new token("--"));
return(retorno);
}
try
{
/*
|--------------------------------------------------------------------------
| Booleano
|--------------------------------------------------------------------------
*/
/*
* Booleano * Booleano = Booleano
*/
if (val1.isTypeBooleano() && val2.isTypeBooleano())
{
retorno.setTypeBooleano();
retorno.valor = val1.getBooleano() && val2.getBooleano();
}
/*
* Booleano * Entero = Entero
*/
else if (val1.isTypeBooleano() && val2.isTypeEntero())
{
int entero1 = 0;
if (val1.getBooleano())
{
entero1 = 1;
}
else
{
entero1 = 0;
}
retorno.setTypeEntero();
retorno.valor = entero1 * val2.getEntero();
}
/*
* Booleano * Decimal = Decimal
*/
else if (val1.isTypeBooleano() && val2.isTypeDecimal())
{
Double entero1 = 0.0;
if (val1.getBooleano())
{
entero1 = 1.0;
}
else
{
entero1 = 0.0;
}
retorno.setTypeDecimal();
retorno.valor = entero1 * val2.getDecimal();
}
/*
* Booleano * Cadena = Cadena
*/
/*
|--------------------------------------------------------------------------
| Entero
|--------------------------------------------------------------------------
*/
/*
* Entero * Booleano = Entero
*/
else if (val1.isTypeEntero() && val2.isTypeBooleano())
{
int entero2 = 0;
if (val2.getBooleano())
{
entero2 = 1;
}
else
{
entero2 = 0;
}
retorno.setTypeEntero();
retorno.valor = val1.getEntero() * entero2;
}
/*
* Entero * Entero = Entero
*/
else if (val1.isTypeEntero() && val2.isTypeEntero())
{
retorno.setTypeEntero();
retorno.valor = val1.getEntero() * val2.getEntero();
}
/*
* Entero * Decimal = Decimal
*/
else if (val1.isTypeEntero() && val2.isTypeDecimal())
{
retorno.setTypeDecimal();
retorno.valor = (Double)val1.getEntero() * val2.getDecimal();
}
/*
* Entero * Cadena = Cadena
*/
/*
|--------------------------------------------------------------------------
| Cadena
|--------------------------------------------------------------------------
*/
/*
* Cadena * Booleano = Cadena
*/
/*
* Cadena * Numerico = Cadena
*/
/*
* Cadena * Decimal = Cadena
*/
/*
* Cadena * Cadena = Cadena
*/
/*
|--------------------------------------------------------------------------
| Decimal
|--------------------------------------------------------------------------
*/
/*
* Decimal * Booleano = Decimal
*/
else if (val1.isTypeDecimal() && val2.isTypeBooleano())
{
Double entero2 = 0.0;
if (val2.getBooleano())
{
entero2 = 1.0;
}
else
{
entero2 = 0.0;
}
retorno.setTypeDecimal();
retorno.valor = val1.getDecimal() * entero2;
}
/*
* Decimal * Numerico = Decimal
*/
else if (val1.isTypeDecimal() && val2.isTypeEntero())
{
retorno.setTypeDecimal();
retorno.valor = val1.getDecimal() * (Double)val2.getEntero();
}
/*
* Decimal * Cadena = Cadena
*/
/*
* Decimal * Decimal = Decimal
*/
else if (val1.isTypeDecimal() && val2.isTypeDecimal())
{
retorno.setTypeDecimal();
retorno.valor = val1.getDecimal() * val2.getDecimal();
}
else
{
tabla.tablaErrores.insertErrorSemantic("No se pueden operar [MULTIPLICACIÓN] " + val1.getTipo() + " por " + val2.getTipo(), signo);
}
//aquí hay que parsear los objetos
}
catch (Exception)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmeticaSuma]No se pudo efectuar la multiplicacion ", signo);
}
return(retorno);
}
public itemValor opAnd(String ambito, elementoEntorno elem)
{
itemValor retorno = new itemValor();
itemValor val1 = hijo1.getValor(elem);
itemValor val2 = hijo2.getValor(elem);
if (val1 == null)
{
tabla.tablaErrores.insertErrorSemantic("[opLogica]" + ambito + "Hijo1 es null", new token("--"));
return(retorno);
}
if (val2 == null)
{
tabla.tablaErrores.insertErrorSemantic("[opLogica]" + ambito + " Hijo1 es null", new token("--"));
return(retorno);
}
try
{
/*
|--------------------------------------------------------------------------
| Booleano
|--------------------------------------------------------------------------
*/
/*
* Booleano * Booleano = Booleano
*/
if (val1.isTypeBooleano() && val2.isTypeBooleano())
{
retorno.setValue(val1.getBooleano() && val2.getBooleano());
return(retorno);
}
/*
* Booleano * Entero = Entero
*/
else if (val1.isTypeBooleano() && val2.isTypeEntero())
{
Boolean bool2 = false;
int val2R = val2.getEntero();
if (val2R == 0)
{
bool2 = false;
}
else if (val2R == 1)
{
bool2 = true;
}
else
{
tabla.tablaErrores.insertErrorSemantic("El numero " + val2R + " no se puede parsear a un valor booleano", signo);
return(retorno);
}
retorno.setValue(val1.getBooleano() && bool2);
return(retorno);
}
/*
* Booleano * Decimal = Decimal
*/
else if (val1.isTypeBooleano() && val2.isTypeDecimal())
{
Boolean bool2 = false;
Double val2R = val2.getDecimal();
if (val2R == 0.0)
{
bool2 = false;
}
else if (val2R == 1.0)
{
bool2 = true;
}
else
{
tabla.tablaErrores.insertErrorSemantic("El decimal: " + val2R + " no se puede parsear a un valor booleano", signo);
return(retorno);
}
retorno.setValue(val1.getBooleano() && bool2);
return(retorno);
}
/*
* Booleano * Cadena = Cadena
*/
/*
|--------------------------------------------------------------------------
| Entero
|--------------------------------------------------------------------------
*/
/*
* Entero * Booleano = Entero
*/
else if (val1.isTypeEntero() && val2.isTypeBooleano())
{
Boolean bool1 = false;
int val1R = val1.getEntero();
if (val1R == 0)
{
bool1 = false;
}
else if (val1R == 1)
{
bool1 = true;
}
else
{
tabla.tablaErrores.insertErrorSemantic("El entero: " + val1R + " no se puede parsear a un valor booleano", signo);
return(retorno);
}
retorno.setValue(bool1 && val2.getBooleano());
return(retorno);
}
/*
* Entero * Entero = Entero
*/
else if (val1.isTypeEntero() && val2.isTypeEntero())
{
Boolean bool1 = false;
int val1R = val1.getEntero();
if (val1R == 0)
{
bool1 = false;
}
else if (val1R == 1)
{
bool1 = true;
}
else
{
tabla.tablaErrores.insertErrorSemantic("El entero: " + val1R + " no se puede parsear a un valor booleano", signo);
return(retorno);
}
Boolean bool2 = false;
int val2R = val2.getEntero();
if (val2R == 0)
{
bool2 = false;
}
else if (val2R == 1)
{
bool2 = true;
}
else
{
tabla.tablaErrores.insertErrorSemantic("El entero: " + val2R + " no se puede parsear a un valor booleano", signo);
return(retorno);
}
retorno.setValue(bool1 && bool2);
return(retorno);
}
/*
* Entero * Decimal = Decimal
*/
else if (val1.isTypeEntero() && val2.isTypeDecimal())
{
Boolean bool1 = false;
int val1R = val1.getEntero();
if (val1R == 0)
{
bool1 = false;
}
else if (val1R == 1)
{
bool1 = true;
}
else
{
tabla.tablaErrores.insertErrorSemantic("El entero: " + val1R + " no se puede parsear a un valor booleano", signo);
return(retorno);
}
Boolean bool2 = false;
Double val2R = val2.getDecimal();
if (val2R == 0.0)
{
bool2 = false;
}
else if (val2R == 1.0)
{
bool2 = true;
}
else
{
tabla.tablaErrores.insertErrorSemantic("El decimal: " + val2R + " no se puede parsear a un valor booleano", signo);
return(retorno);
}
retorno.setValue(bool1 && bool2);
return(retorno);
}
/*
* Entero * Cadena = Cadena
*/
/*
|--------------------------------------------------------------------------
| Cadena
|--------------------------------------------------------------------------
*/
/*
* Cadena * Booleano = Cadena
*/
/*
* Cadena * Numerico = Cadena
*/
/*
* Cadena * Decimal = Cadena
*/
/*
* Cadena * Cadena = Cadena
*/
/*
|--------------------------------------------------------------------------
| Decimal
|--------------------------------------------------------------------------
*/
/*
* Decimal * Booleano = Decimal
*/
else if (val1.isTypeDecimal() && val2.isTypeBooleano())
{
Boolean bool1 = false;
double val1R = val1.getDecimal();
if (val1R == 0.0)
{
bool1 = false;
}
else if (val1R == 1.0)
{
bool1 = true;
}
else
{
tabla.tablaErrores.insertErrorSemantic("El decimal: " + val1R + " no se puede parsear a un valor booleano", signo);
return(retorno);
}
retorno.setValue(bool1 && val2.getBooleano());
return(retorno);
}
/*
* Decimal * Numerico = Decimal
*/
else if (val1.isTypeDecimal() && val2.isTypeEntero())
{
Boolean bool1 = false;
double val1R = val1.getDecimal();
if (val1R == 0.0)
{
bool1 = false;
}
else if (val1R == 1.0)
{
bool1 = true;
}
else
{
tabla.tablaErrores.insertErrorSemantic("El decimal: " + val1R + " no se puede parsear a un valor booleano", signo);
return(retorno);
}
Boolean bool2 = false;
int val2R = val2.getEntero();
if (val2R == 0)
{
bool2 = false;
}
else if (val2R == 1)
{
bool2 = true;
}
else
{
tabla.tablaErrores.insertErrorSemantic("El entero: " + val2R + " no se puede parsear a un valor booleano", signo);
return(retorno);
}
retorno.setValue(bool1 && bool2);
return(retorno);
}
/*
* Decimal * Cadena = Cadena
*/
/*
* Decimal * Decimal = Decimal
*/
else if (val1.isTypeDecimal() && val2.isTypeDecimal())
{
Boolean bool1 = false;
double val1R = val1.getDecimal();
if (val1R == 0.0)
{
bool1 = false;
}
else if (val1R == 1.0)
{
bool1 = true;
}
else
{
tabla.tablaErrores.insertErrorSemantic("El decimal: " + val1R + " no se puede parsear a un valor booleano", signo);
return(retorno);
}
Boolean bool2 = false;
Double val2R = val2.getDecimal();
if (val2R == 0.0)
{
bool2 = false;
}
else if (val2R == 1.0)
{
bool2 = true;
}
else
{
tabla.tablaErrores.insertErrorSemantic("El decimal: " + val2R + " no se puede parsear a un valor booleano", signo);
return(retorno);
}
retorno.setValue(bool1 && bool2);
return(retorno);
}
else
{
tabla.tablaErrores.insertErrorSemantic("No se pueden operar [" + ambito + "] " + val1.getTipo() + " con " + val2.getTipo(), signo);
}
}
catch (Exception)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmeticaSuma]No se pudo efectuar [" + ambito + " ]", signo);
}
return(retorno);
}
public itemValor opRestaExterna(elementoEntorno elem, itemValor val1, itemValor val2)
{
itemValor retorno = new itemValor();
if (val1 == null)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmetica]opSuma Hijo1 es null", new token("--"));
return(retorno);
}
if (val2 == null)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmetica]opSuma Hijo1 es null", new token("--"));
return(retorno);
}
try
{
/*
|--------------------------------------------------------------------------
| Booleano
|--------------------------------------------------------------------------
*/
/*
* Booleano - Booleano = Booleano
*/
/*
* Booleano - Entero = Entero
*/
if (val1.isTypeBooleano() && val2.isTypeEntero())
{
int entero1 = 0;
if (val1.getBooleano())
{
entero1 = 1;
}
else
{
entero1 = 0;
}
retorno.setTypeEntero();
retorno.valor = entero1 - val2.getEntero();
}
/*
* Booleano - Decimal = Decimal
*/
else if (val1.isTypeBooleano() && val2.isTypeDecimal())
{
Double entero1 = 0.0;
if (val1.getBooleano())
{
entero1 = 1.0;
}
else
{
entero1 = 0.0;
}
retorno.setTypeDecimal();
retorno.valor = entero1 - val2.getDecimal();
}
/*
* Booleano + Cadena = Cadena
*/
/*
|--------------------------------------------------------------------------
| Entero
|--------------------------------------------------------------------------
*/
/*
* Entero - Booleano = Entero
*/
else if (val1.isTypeEntero() && val2.isTypeBooleano())
{
int entero2 = 0;
if (val2.getBooleano())
{
entero2 = 1;
}
else
{
entero2 = 0;
}
retorno.setTypeEntero();
retorno.valor = val1.getEntero() - entero2;
}
/*
* Entero - Entero = Entero
*/
else if (val1.isTypeEntero() && val2.isTypeEntero())
{
retorno.setTypeEntero();
retorno.valor = val1.getEntero() - val2.getEntero();
}
/*
* Entero - Decimal = Decimal
*/
else if (val1.isTypeEntero() && val2.isTypeDecimal())
{
retorno.setTypeDecimal();
retorno.valor = (Double)val1.getEntero() - val2.getDecimal();
}
/*
* Entero - Cadena = Cadena
*/
/*
|--------------------------------------------------------------------------
| Cadena
|--------------------------------------------------------------------------
*/
/*
* Cadena + Booleano = Cadena
*/
/*
* Cadena + Numerico = Cadena
*/
/*
* Cadena + Decimal = Cadena
*/
/*
* Cadena + Cadena = Cadena
*/
/*
|--------------------------------------------------------------------------
| Decimal
|--------------------------------------------------------------------------
*/
/*
* Decimal - Booleano = Decimal
*/
else if (val1.isTypeDecimal() && val2.isTypeBooleano())
{
Double entero2 = 0.0;
if (val2.getBooleano())
{
entero2 = 1.0;
}
else
{
entero2 = 0.0;
}
retorno.setTypeDecimal();
retorno.valor = val1.getDecimal() - entero2;
}
/*
* Decimal - Numerico = Decimal
*/
else if (val1.isTypeDecimal() && val2.isTypeEntero())
{
retorno.setTypeDecimal();
retorno.valor = val1.getDecimal() - (Double)val2.getEntero();
}
/*
* Decimal - Cadena = Cadena
*/
/*
* Decimal - Decimal = Decimal
*/
else if (val1.isTypeDecimal() && val2.isTypeDecimal())
{
retorno.setTypeDecimal();
retorno.valor = val1.getDecimal() - val2.getDecimal();
}
else
{
tabla.tablaErrores.insertErrorSemantic("No se pueden operar [RESTA] " + val1.getTipo() + " menos " + val2.getTipo(), signo);
}
//aquí hay que parsear los objetos
}
catch (Exception e)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmeticaSuma]No se pudo efectuar la resta", signo);
}
return(retorno);
}
public itemValor opSuma(elementoEntorno elem)
{
itemValor retorno = new itemValor();
itemValor val1 = hijo1.getValor(elem);
itemValor val2 = hijo2.getValor(elem);
if (val1 == null)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmetica]opSuma Hijo1 es null", new token("--"));
return(retorno);
}
if (val2 == null)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmetica]opSuma Hijo1 es null", new token("--"));
return(retorno);
}
try
{
/*
|--------------------------------------------------------------------------
| Booleano
|--------------------------------------------------------------------------
*/
/*
* Booleano + Booleano = Booleano
*/
if (val1.isTypeBooleano() && val2.isTypeBooleano())
{
retorno.setTypeBooleano();
retorno.valor = val1.getBooleano() || val2.getBooleano();
}
/*
* Booleano + Entero = Entero
*/
else if (val1.isTypeBooleano() && val2.isTypeEntero())
{
int entero1 = 0;
if (val1.getBooleano())
{
entero1 = 1;
}
else
{
entero1 = 0;
}
retorno.setTypeEntero();
retorno.valor = entero1 + val2.getEntero();
}
/*
* Booleano + Decimal = Decimal
*/
else if (val1.isTypeBooleano() && val2.isTypeDecimal())
{
Double entero1 = 0.0;
if (val1.getBooleano())
{
entero1 = 1.0;
}
else
{
entero1 = 0.0;
}
retorno.setTypeDecimal();
retorno.valor = entero1 + val2.getDecimal();
}
/*
* Booleano + Cadena = Cadena
*/
else if (val1.isTypeBooleano() && val2.isTypeCadena())
{
retorno.setTypeCadena();
retorno.valor = val1.getBooleano().ToString() + val2.getCadena();
}
/*
|--------------------------------------------------------------------------
| Entero
|--------------------------------------------------------------------------
*/
/*
* Entero + Booleano = Entero
*/
else if (val1.isTypeEntero() && val2.isTypeBooleano())
{
int entero2 = 0;
if (val2.getBooleano())
{
entero2 = 1;
}
else
{
entero2 = 0;
}
retorno.setTypeEntero();
retorno.valor = val1.getEntero() + entero2;
}
/*
* Entero + Entero = Entero
*/
else if (val1.isTypeEntero() && val2.isTypeEntero())
{
retorno.setTypeEntero();
retorno.valor = val1.getEntero() + val2.getEntero();
}
/*
* Entero + Decimal = Decimal
*/
else if (val1.isTypeEntero() && val2.isTypeDecimal())
{
retorno.setTypeDecimal();
retorno.valor = (Double)val1.getEntero() + val2.getDecimal();
}
/*
* Entero + Cadena = Cadena
*/
else if (val1.isTypeEntero() && val2.isTypeCadena())
{
retorno.setTypeCadena();
retorno.valor = val1.getEntero().ToString() + val2.getCadena();
}
/*
|--------------------------------------------------------------------------
| Cadena
|--------------------------------------------------------------------------
*/
/*
* Cadena + Booleano = Cadena
*/
else if (val1.isTypeCadena() && val2.isTypeBooleano())
{
retorno.setTypeCadena();
retorno.valor = val1.getCadena() + val2.getBooleano().ToString();
}
/*
* Cadena + Numerico = Cadena
*/
else if (val1.isTypeCadena() && val2.isTypeEntero())
{
retorno.setTypeCadena();
retorno.valor = val1.getCadena() + val2.getEntero().ToString();
}
/*
* Cadena + Decimal = Cadena
*/
else if (val1.isTypeCadena() && val2.isTypeDecimal())
{
retorno.setTypeCadena();
retorno.valor = val1.getCadena() + val2.getDecimal().ToString();
}
/*
* Cadena + Cadena = Cadena
*/
else if (val1.isTypeCadena() && val2.isTypeCadena())
{
retorno.setTypeCadena();
retorno.valor = val1.getCadena() + val2.getCadena();
}
/*
|--------------------------------------------------------------------------
| Decimal
|--------------------------------------------------------------------------
*/
/*
* Decimal + Booleano = Decimal
*/
else if (val1.isTypeDecimal() && val2.isTypeBooleano())
{
Double entero2 = 0.0;
if (val2.getBooleano())
{
entero2 = 1.0;
}
else
{
entero2 = 0.0;
}
retorno.setTypeDecimal();
retorno.valor = val1.getDecimal() + entero2;
}
/*
* Decimal + Numerico = Decimal
*/
else if (val1.isTypeDecimal() && val2.isTypeEntero())
{
retorno.setTypeDecimal();
retorno.valor = val1.getDecimal() + (Double)val2.getEntero();
}
/*
* Decimal + Cadena = Cadena
*/
else if (val1.isTypeDecimal() && val2.isTypeCadena())
{
retorno.setTypeCadena();
retorno.valor = val1.getDecimal().ToString() + val2.getCadena();
}
/*
* Decimal + Decimal = Decimal
*/
else if (val1.isTypeDecimal() && val2.isTypeDecimal())
{
retorno.setTypeDecimal();
retorno.valor = val1.getDecimal() + val2.getDecimal();
}
else
{
tabla.tablaErrores.insertErrorSemantic("No se pueden operar [SUMA] " + val1.getTipo() + " con " + val2.getTipo(), signo);
}
//aquí hay que parsear los objetos
}
catch (Exception e)
{
tabla.tablaErrores.insertErrorSemantic("[opAritmeticaSuma]No se pudo efectuar la suma", signo);
}
return(retorno);
}
