static void Main(string[] args)
{
/*Uso de ref con multiplicacion */
Multiplicar m = new Multiplicar();
int x = 4;
m.multi(ref x);
Console.WriteLine(x);
/*Uso de out con division*/
int y = 2;
int z = 2;
int r;
division(y, z, out r);
Console.WriteLine(division(y, z));
/*Uso de in con resta*/
resta res = new resta();
int i = 10;
i = i - 8;
res.re(in i);
Console.WriteLine(i);
}
private void button2_Click(object sender, EventArgs e)
{
ingreso2 = new resta();
ingreso2.R1 = double.Parse(textBox1.Text);
ingreso2.R2 = double.Parse(textBox2.Text);
label3.Text = ingreso2.calcular().ToString();
}
private void button1_Click(object sender, EventArgs e)
{
if (this.checkBox1.Checked == true)
{
obj1 = new suma();
obj1.S1 = double.Parse(textBox1.Text);
obj1.S2 = double.Parse(textBox2.Text);
textBox3.Text = obj1.calcular().ToString();
}
else if (this.checkBox2.Checked == true)
{
obj2 = new resta();
obj2.R1 = double.Parse(textBox1.Text);
obj2.R2 = double.Parse(textBox2.Text);
textBox3.Text = obj2.calcular().ToString();
}
else if (this.checkBox3.Checked == true)
{
obj3 = new multiplicacion();
obj3.M1 = double.Parse(textBox1.Text);
obj3.M2 = double.Parse(textBox2.Text);
textBox3.Text = obj3.calcular().ToString();
}
else if (this.checkBox4.Checked == true)
{
obj4 = new division();
obj4.D1 = double.Parse(textBox1.Text);
obj4.D2 = double.Parse(textBox2.Text);
textBox3.Text = obj4.calcular().ToString();
}
}
/*menu 2
* 1.sumar
* 2.restar
* 3.multiplicar
* 4.dividir
* 5.raiz cuadrada
* Default mensaje error y vuelta al menu2*/
public static void menuCalc(string IdSesion)
{
Console.Clear();
var salida2 = false;
while (!salida2)
{
opcionesCalcular();
switch (seleccionar())
{
case ("1"):
{
Console.Clear();
var sumadores = SolicitarValores("sumar");
try
{
var sumadoresDoub = convertirDouble(sumadores);
var sumador = new suma(sumadoresDoub);
var streamS = new MemoryStream();
var conversor = new DataContractJsonSerializer(typeof(suma));
conversor.WriteObject(streamS, sumador);
var JsonFinal = serializador(conversor, streamS);
var res = new respuesta();
var salida = res.responder($"{servidor}/Calculator/Add", JsonFinal, IdSesion);
Console.Clear();
var Respuesta = deserializeResponse.DeserializeSuma(salida);
Console.WriteLine(Respuesta.ToString());
continuar();
}
catch (Exception)
{
}
break;
}
case ("2"):
{
Console.Clear();
Console.WriteLine("Escriba el minuendo");
try
{
var minuendo = Convert.ToDouble(Console.ReadLine());
var sustraendos = SolicitarValores("restar");
var sustraendosDoub = convertirDouble(sustraendos);
var restador = new resta(minuendo, sustraendosDoub);
var streamS = new MemoryStream();
var conversor = new DataContractJsonSerializer(typeof(resta));
conversor.WriteObject(streamS, restador);
var JsonFinal = serializador(conversor, streamS);
var res = new respuesta();
Console.Clear();
var salida = res.responder($"{servidor}/Calculator/Sub", JsonFinal, IdSesion);
var Respuesta = deserializeResponse.DeserializeResta(salida);
Console.WriteLine(Respuesta);
continuar();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
break;
}
case ("3"):
{
Console.Clear();
var multiplicadores = SolicitarValores("multiplicar");
try
{
var multiplicadoresDoub = convertirDouble(multiplicadores);
var multiplicador = new multiplicacion(multiplicadoresDoub);
var streamS = new MemoryStream();
var conversor = new DataContractJsonSerializer(typeof(multiplicacion));
conversor.WriteObject(streamS, multiplicador);
var JsonFinal = serializador(conversor, streamS);
Console.Clear();
var res = new respuesta();
var salida = res.responder($"{servidor}/Calculator/Mult", JsonFinal, IdSesion);
var Respuesta = deserializeResponse.DeserializeMult(salida);
Console.WriteLine(Respuesta);
continuar();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
break;
}
case ("4"):
{
Console.Clear();
Console.WriteLine("Escriba el dividendo");
try
{
var dividendo = Convert.ToDouble(Console.ReadLine());
var divisores = convertirDouble(SolicitarValores("dividir"));
var dividir = new division(dividendo, divisores);
var streamS = new MemoryStream();
var conversor = new DataContractJsonSerializer(typeof(division));
conversor.WriteObject(streamS, dividir);
var JsonFinal = serializador(conversor, streamS);
var res = new respuesta();
Console.Clear();
var salida = res.responder($"{servidor}/Calculator/Div", JsonFinal, IdSesion);
var Respuesta = deserializeResponse.DeserializeDiv(salida);
Console.WriteLine(Respuesta);
continuar();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
break;
}
case ("5"):
{
Console.Clear();
Console.WriteLine("Escriba el numero para realizar la raiz cuadrada");
try
{
var numeroRaiz = Convert.ToDouble(Console.ReadLine());
var raiz = new raizCuadrada(numeroRaiz);
var streamS = new MemoryStream();
var conversor = new DataContractJsonSerializer(typeof(raizCuadrada));
conversor.WriteObject(streamS, raiz);
var JsonFinal = serializador(conversor, streamS);
var res = new respuesta();
var salida = res.responder($"{servidor}/Calculator/Sqrt", JsonFinal, IdSesion);
if (salida != "")
{
var ObjRes = deserializeResponse.DeserializeSqrt(salida);
Console.Clear();
Console.WriteLine($"El resultado es : {ObjRes.square}");
}
continuar();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
break;
}
case ("6"):
{
salida2 = true;
break;
}
default:
{
Console.Clear();
Console.WriteLine("Opcion invalida");
break;
}
}
}
}
/*
|-------------------------------------------------------------------------------------------------------------------
| EJECUCIÓN FINAL
|-------------------------------------------------------------------------------------------------------------------
|
*/
public override itemRetorno ejecutar(elementoEntorno tablaEntornos)
/*
|----------------------------
| EJECUTAR
|----------------------------
| 0= normal
| 1 = return;
| 2 = break
| 3 = continue
| 4 = errores
*/
{
itemRetorno retorno = new itemRetorno(0);
if (hayErrores())
{
return(retorno);
}
if (hijos.Count == 2)
/*
|----------------------------
| ID_VAR_FUNC + VAL
*/
{
//PUNTERO DONDE VOY A GUARDAR EL VALOR
_ID_VAR_FUNC nodoFunc = (_ID_VAR_FUNC)getNodo("ID_VAR_FUNC");
itemEntorno destino = nodoFunc.getDestino(tablaEntornos);
//AHORA OBTENGO EL VALOR
_VAL nodoVal = (_VAL)getNodo("VAL");
if (nodoVal != null)
{
if (destino != null)
{
itemValor valor = nodoVal.getValor(tablaEntornos, destino.tipo);
if (destino.lstDimensionesAcceso.Count > 0)
//viene la posición de un arreglo
{
asignarValorMatriz(destino, valor);
}
else
{
asignarValor(destino, valor);
}
}
else
{
println("Me retorno un itemEntorno vacio, no podré asignar la variable prro");
}
}
else
{
println("no tiene nodo VAl");
}
}
else if (hijos.Count == 1)
{
if (lstAtributos.getToken(0).valLower.Equals("+"))
/*
|----------------------------
| ID_VAR_FUNC + sMas + sMas
*/
{
if (hayErrores())
{
return(retorno);
}
_ID_VAR_FUNC nodoFunc = (_ID_VAR_FUNC)getNodo("ID_VAR_FUNC");
itemEntorno destino = nodoFunc.getDestino(tablaEntornos);
if (destino.lstDimensionesAcceso.Count > 0)
//viene la posición de un arreglo
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede incrementar la matriz " + destino.nombre.val + " de tipo: " + destino.tipo.valLower, destino.nombre);
}
else
{
itemValor valor = nodoFunc.getValor(tablaEntornos);
itemValor valor2 = new itemValor();
valor2.setValue(1);
suma sumatoria = new suma(new _E("hijo1", tablaSimbolos), new _E("hijo2", tablaSimbolos), tablaSimbolos, lstAtributos.getToken(0));
itemValor resultado = sumatoria.opSumaExterna(tablaEntornos, valor, valor2);
Object ObjParseado = resultado.getValorParseado(destino.tipo.valLower);
if (ObjParseado != null)
{
destino.valor.valor = ObjParseado;
return(retorno);
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede asignar un tipo :" + sumatoria.GetType() + " a la variable " + destino.nombre.val + " de tipo: " + destino.tipo.valLower, destino.nombre);
return(retorno);
}
}
}
else
/*
|----------------------------
| ID_VAR_FUNC + smenos + smenos
*/
{
if (hayErrores())
{
return(retorno);
}
_ID_VAR_FUNC nodoFunc = (_ID_VAR_FUNC)getNodo("ID_VAR_FUNC");
itemEntorno destino = nodoFunc.getDestino(tablaEntornos);
if (destino.lstDimensionesAcceso.Count > 0)
//viene la posición de un arreglo
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede incrementar la matriz " + destino.nombre.val + " de tipo: " + destino.tipo.valLower, destino.nombre);
}
else
{
itemValor valor = nodoFunc.getValor(tablaEntornos);
itemValor valor2 = new itemValor();
valor2.setValue(1);
resta sumatoria = new resta(new _E("hijo1", tablaSimbolos), new _E("hijo2", tablaSimbolos), tablaSimbolos, lstAtributos.getToken(0));
itemValor resultado = sumatoria.opRestaExterna(tablaEntornos, valor, valor2);
Object ObjParseado = resultado.getValorParseado(destino.tipo.valLower);
if (ObjParseado != null)
{
destino.valor.valor = ObjParseado;
return(retorno);
}
else
{
tablaSimbolos.tablaErrores.insertErrorSemantic("No se puede asignar un tipo :" + sumatoria.GetType() + " a la variable " + destino.nombre.val + " de tipo: " + destino.tipo.valLower, destino.nombre);
return(retorno);
}
}
}
}
return(retorno);
}
public itemValor getValor(elementoEntorno elmen)
{
itemValor ob = new itemValor();
ob.setTypeNulo();
if (hayErrores())
{
return(ob);
}
switch (hijos.Count)
{
case 0:
if (lstAtributos.listaAtributos.Count > 0)
{
return(parseandoDato(lstAtributos.listaAtributos[0]));
}
else
{
tablaSimbolos.tablaErrores.insertErrorSyntax("[E] Se esperaba un valor ", new token());
return(ob);
//hay un error
}
case 1:
if (hijos[0].nombre.Equals("OPE_ARITME"))
{
return(hijos[0].ope_tipo(elmen));
}
else if (hijos[0].nombre.Equals("OPE_TIPO"))
{
return(hijos[0].ope_tipo(elmen));
}
else if (hijos[0].nombre.Equals("SI_SIMPLIFICADO"))
{
_SI_SIMPLIFICADO simplif = (_SI_SIMPLIFICADO)hijos[0];
return(simplif.getValor(elmen));
}
else if (hijos[0].nombre.Equals("LEN"))
{
_LEN len = (_LEN)hijos[0];
return(len.getValor(elmen));
}
//operador unario
else if (lstAtributos.listaAtributos.Count > 0)
{
String signo = lstAtributos.getValItem(0);
switch (signo)
{
//Logico
case "-":
negativo opNeg = new negativo(hijos[0], tablaSimbolos, lstAtributos.getToken(0));
return(opNeg.opNot(" Asignando valor Negativo", elmen));
case "!":
Not opeNot = new Not(hijos[0], tablaSimbolos, lstAtributos.getToken(0));
return(opeNot.opNot("Not", elmen));
case "(":
_E ope = (_E)hijos[0];
itemValor te = ope.getValor(elmen);
return(te);
default:
tablaSimbolos.tablaErrores.insertErrorSyntax("[E]No se reconoció el signo", lstAtributos.getToken(0));
return(ob);
}
}
else
//ID_VAR_FUNC
{
nodoModelo busq = getNodo("ID_VAR_FUNC");
if (busq != null)
{
_ID_VAR_FUNC idFunc = (_ID_VAR_FUNC)busq;
return(idFunc.getValor(elmen));
}
tablaSimbolos.tablaErrores.insertErrorSyntax("[E]Se esperaba un signo para operación unaria", new token());
return(ob);
}
case 2:
//operador binario
if (lstAtributos.listaAtributos.Count > 0)
{
String signo = lstAtributos.getValItem(0);
switch (signo)
{
//Aritmetica
case "+":
suma ope = new suma(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(ope.opSuma(elmen));
case "-":
resta opeRes = new resta(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(opeRes.opResta(elmen));
case "*":
multiplicacion opeMul = new multiplicacion(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(opeMul.opMultiplicacion(elmen));
case "/":
division opeDiv = new division(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(opeDiv.opDivision(elmen));
case "^":
potencia opePot = new potencia(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(opePot.opPotencia(elmen));
case "%":
modulo opeModulo = new modulo(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(opeModulo.opModulo(elmen));
//Relacional
case "==":
IgualQue opeIgualacion = new IgualQue(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(opeIgualacion.opIgualacion("Igualación", elmen));
case "!=":
DiferenteQue opeDiferenciacion = new DiferenteQue(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(opeDiferenciacion.opDiferenciacion("Diferenciación", elmen));
case ">":
MayorQue opeMayor = new MayorQue(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(opeMayor.opMayorQue("Mayor Que", elmen));
case ">=":
MayorIgualQue opeMayorIgual = new MayorIgualQue(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(opeMayorIgual.opMayorIgualQue("Mayor o Igual Que", elmen));
case "<":
MenorQue opeMenor = new MenorQue(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(opeMenor.opMenorQue("Menor Que", elmen));
case "<=":
MenorIgualQue opeMenorIgual = new MenorIgualQue(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(opeMenorIgual.opMenorIgualQue("Menor o Igual Que", elmen));
//logicas
case "&&":
And opeAnd = new And(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(opeAnd.opAnd("And", elmen));
case "||":
Or opeOr = new Or(hijos[0], hijos[1], tablaSimbolos, lstAtributos.getToken(0));
return(opeOr.opOr("Or", elmen));
default:
tablaSimbolos.tablaErrores.insertErrorSyntax("[E]No se reconoció el sigono", lstAtributos.getToken(0));
return(ob);
}
}
else
{
tablaSimbolos.tablaErrores.insertErrorSyntax("[E]Se esperaba un signo para operación binaria", new token());
return(ob);
}
default:
return(ob);
}
}
