public override string ToString() { if (Operation == '=') { return(Operation + Op1.ToString()); } return(Op1.ToString() + Operation + Op2.ToString()); }
public double Compute(params double[] value) { if (Op1.Compute(value) == 0 || (Op1.Compute(value) < 0 && Math.Abs(Op2.Compute(value) % 1) > (double.Epsilon * 100))) { return(1); } else { return(Math.Pow(Op1.Compute(value), Op2.Compute(value))); } }
public override object GetValor(Entorno e, LinkedList <Salida> log, LinkedList <Error> errores) { object valOp1 = Op1.GetValor(e, log, errores); if (valOp1 != null) { if (valOp1 is Throw) { return(valOp1); } if (Op != Operador.NOT) { object valOp2 = Op2.GetValor(e, log, errores); if (valOp2 != null) { if (valOp2 is Throw) { return(valOp2); } Tipo = new Tipo(Type.BOOLEAN); if (Op1.Tipo.IsBoolean() && Op2.Tipo.IsBoolean()) { switch (Op) { case Operador.OR: return((bool)valOp1 || (bool)valOp2); case Operador.AND: return((bool)valOp1 && (bool)valOp2); case Operador.XOR: return((bool)valOp1 ^ (bool)valOp2); } } errores.AddLast(new Error("Semántico", "No se pudo realizar la operación lógica.", Linea, Columna)); } } else { Tipo = new Tipo(Type.BOOLEAN); if (Op1.Tipo.IsBoolean()) { return(!(bool)valOp1); } errores.AddLast(new Error("Semántico", "No se pudo realizar la operación lógica.", Linea, Columna)); } } return(null); }
public int Calculate() { if (Operator == "PLUS") { return(Op1.Calculate() + Op2.Calculate()); } if (Operator == "TIMES") { return(Op1.Calculate() * Op2.Calculate()); } throw new ArgumentException(); }
// Use this for initialization void Start() { cubes = cubeContainer.GetComponentsInChildren <Cube>(); // Get the graphical numbers to use op1 = questionContainer.GetComponentInChildren <Op1>(); // Get access to the script of the 1st operand op2 = questionContainer.GetComponentInChildren <Op2>(); // Get access to the script of the 2nd operand op3 = questionContainer.GetComponentInChildren <Op3>(); // Get access to the script of the 3rd operand audio = GetComponent <AudioSource>(); // Get the audio component // Assign numbers to the variables and cubes for (int i = 0; i < 9; i++) { cubes[i].num = i + 1; cubes[i].numText.text = "" + (i + 1); cubes[i + 9].num = i + 1; cubes[i + 9].numText.text = "" + (i + 1); } // Store original positions of number graphics originalPosition = new Vector3[cubes.Length]; for (int i = 0; i < cubes.Length; i++) { originalPosition[i] = new Vector3(cubes[i].transform.position.x, cubes[i].transform.position.y, cubes[i].transform.position.z); } if (isMultiplicationGame) { ResetGameMult(); SetQuestionMult(); } else if (isAdditionGame) { LoadLevel(); } else if (is2OperatorGame) { level = 15.0f; LoadLevel(); } }
public override String ToString() { String str = ""; switch (CmdName) { case "park": str = "Парковать"; break; case "push": str = "Положить в ячейку " + Op2.ToString(); break; case "take": str = "Взять из ячейки " + Op1.ToString(); break; case "trans": str = "Переместить из ячейки " + Op1.ToString() + " в ячейку " + Op2.ToString(); break; } return(str); }
public override string ToString() { switch (OperationType) { case ArthmeticOperationType.Add: return($"({Op1.ToString()}) + ({Op2.ToString()})"); case ArthmeticOperationType.Div: return($"({Op1.ToString()}) / ({Op2.ToString()})"); case ArthmeticOperationType.Mod: return($"({Op1.ToString()}) % ({Op2.ToString()})"); case ArthmeticOperationType.Mult: return($"({Op1.ToString()}) * ({Op2.ToString()})"); case ArthmeticOperationType.Sub: return($"({Op1.ToString()}) - ({Op2.ToString()})"); default: throw new InvalidEnumArgumentException(nameof(OperationType)); } }
public override double Solve(IDictionary <Variable, Operation> values) { switch (OperationType) { case ArthmeticOperationType.Add: return(Op1.Solve(values) + Op2.Solve(values)); case ArthmeticOperationType.Div: return(Op1.Solve(values) / Op2.Solve(values)); case ArthmeticOperationType.Mod: return(Op1.Solve(values) % Op2.Solve(values)); case ArthmeticOperationType.Mult: return(Op1.Solve(values) * Op2.Solve(values)); case ArthmeticOperationType.Sub: return(Op1.Solve(values) - Op2.Solve(values)); default: throw new InvalidEnumArgumentException(nameof(OperationType)); } }
public override Expression Solve() { switch (OperationType) { case ArthmeticOperationType.Add: return(Op1.Solve() + Op2.Solve()); case ArthmeticOperationType.Div: return(Op1.Solve() / Op2.Solve()); case ArthmeticOperationType.Mod: return(Op1.Solve() % Op2.Solve()); case ArthmeticOperationType.Mult: return(Op1.Solve() * Op2.Solve()); case ArthmeticOperationType.Sub: return(Op1.Solve() - Op2.Solve()); default: throw new InvalidEnumArgumentException(nameof(OperationType)); } }
public void UdtData() { var q0 = new FreeQubit(0) as Qubit; var q1 = new FreeQubit(1) as Qubit; var q2 = new FreeQubit(2) as Qubit; var q3 = new FreeQubit(3) as Qubit; var q4 = new FreeQubit(4) as Qubit; var q5 = new FreeQubit(5) as Qubit; var q6 = new FreeQubit(6) as Qubit; var op = new Op1(null) as IUnitary; var f1 = new F1(null); var qubits = new QArray <Qubit>(q2, q4, q6); var dataA = (1L, Pauli.PauliY, q1, (q4, 3L, q5)); var dataB = ((1L, 2L), (q6, (3L, (q4, q6)), 3.5)); var dataC = (q5, new TupleB(dataB)); var dataD = new QArray <Qubit>(q1, q2, q3, q4, q6); var dataE = (4L, (IQArray <Qubit>)qubits); var dataF = op; var dataG = (q3, new TupleF(dataF), new TupleC(dataC), new TupleD(dataD)); var dataQ = ((1L, 2L), (q1, (3L, (q2, q3)), 3.5)); var dataH = (new TupleD(dataD), new TupleG(dataG)); var dataI = f1; AssertOneData(dataQ, typeof(QTuple <((Int64, Int64), (Qubit, (Int64, (Qubit, Qubit)), Double))>)); AssertOneData(((ICallable)null), typeof(QTuple <ICallable>)); AssertOneData(q3, typeof(Q)); AssertOneData(dataA, typeof(TupleA)); AssertOneData(dataB, typeof(TupleB)); AssertOneData(dataC, typeof(TupleC)); AssertOneData(dataD, typeof(TupleD)); AssertOneData(dataE, typeof(TupleE)); AssertOneData(dataF, typeof(TupleF)); AssertOneData(dataG, typeof(TupleG)); AssertOneData(dataH, typeof(TupleH)); AssertOneData(dataI, typeof(TupleI)); }
static void Main(string[] args) { //lambda statement Op1 fact = n => { int ans = 1; for (int i = 1; i <= n; i++) { ans = ans * i; } return(ans); }; //lambda expression Op2 even = n => n % 2 == 0; Console.WriteLine(fact(4)); if (even(6)) { Console.WriteLine("Number is even"); } Console.ReadKey(); }
public bool IsValidFormat() => Op1?.IsValidFormat() == true && Op2?.IsValidFormat() == true && Metadata?.IsValidFormat() == true;
public override StackEntry Duplicate() { return(new IndirectEntry(Op1.Duplicate(), Kind, ExactSize, Offset)); }
public override StackEntry Duplicate() { return(new StoreIndEntry(Addr, Op1.Duplicate(), TargetType, FieldOffset, ExactSize)); }
public override object GetValor(Entorno e, LinkedList <Salida> log, LinkedList <Error> errores) { if (Op == Operador.AUMENTO || Op == Operador.DECREMENTO) { Simbolo sim = Op1.GetSimbolo(e); if (sim != null) { if (sim.Tipo.IsNumeric()) { Operador op = Op == Operador.AUMENTO ? Operador.SUMA : Operador.RESTA; Aritmetica arit = new Aritmetica(new Literal(sim.Tipo, sim.Valor, Linea, Columna), new Literal(new Tipo(Type.INT), 1, Linea, Columna), op, Linea, Columna); object valAnt = sim.Valor; object valArit = arit.GetValor(e, log, errores); if (valArit != null) { if (valArit is Throw) { return(valArit); } sim.Valor = valArit; Tipo = sim.Tipo; return(valAnt); } return(null); } errores.AddLast(new Error("Semántico", "El operando no es numérico.", Linea, Columna)); return(null); } if (Op1.GetId() != null) { errores.AddLast(new Error("Semántico", "No hay una variabla declarada con el id: " + Op1.GetId() + ".", Linea, Columna)); } else { errores.AddLast(new Error("Semántico", "El operando no es una variable.", Linea, Columna)); } } else { Object valOp1 = Op1.GetValor(e, log, errores); if (valOp1 != null) { if (valOp1 is Throw) { return(valOp1); } if (Op1.Tipo.IsNumeric()) { object factor = Op == Operador.SUMA ? 1 : -1; Aritmetica arit = new Aritmetica(new Literal(Op1.Tipo, valOp1, Linea, Columna), new Literal(new Tipo(Type.INT), factor, Linea, Columna), Operador.MULTIPLICACION, Linea, Columna); object valor = arit.GetValor(e, log, errores); Tipo = arit.Tipo; return(valor); } errores.AddLast(new Error("Semántico", "El operando no es numérico.", Linea, Columna)); } } return(null); }
public override object GetValor(Entorno e, LinkedList <Salida> log, LinkedList <Error> errores) { object valOp1 = Op1.GetValor(e, log, errores); object valOp2 = Op2.GetValor(e, log, errores); if (valOp1 != null && valOp2 != null) { if (valOp1 is Throw) { return(valOp1); } if (valOp2 is Throw) { return(valOp2); } Tipo = new Tipo(Type.BOOLEAN); if (Op1.Tipo.IsNumeric() && Op2.Tipo.IsNumeric()) { double op1 = Convert.ToDouble(valOp1); double op2 = Convert.ToDouble(valOp2); switch (Op) { case Operador.MAYORQUE: return(op1 > op2); case Operador.MENORQUE: return(op1 < op2); case Operador.IGUAL: return(op1 == op2); case Operador.MENORIGUAL: return(op1 <= op2); case Operador.MAYORIGUAL: return(op1 >= op2); case Operador.DIFERENTE: return(op1 != op2); } } else if (Op1.Tipo.IsDate() && Op2.Tipo.IsDate()) { Date op1 = (Date)valOp1; Date op2 = (Date)valOp2; int res = op1.CompareTo(op2); switch (Op) { case Operador.MAYORQUE: return(res == 1); case Operador.MENORQUE: return(res == -1); case Operador.IGUAL: return(res == 0); case Operador.MENORIGUAL: return(res == -1 || res == 0); case Operador.MAYORIGUAL: return(res == 1 || res == 0); case Operador.DIFERENTE: return(!(res == 0)); } } else if (Op1.Tipo.IsTime() && Op2.Tipo.IsTime()) { Time op1 = (Time)valOp1; Time op2 = (Time)valOp2; int res = op1.CompareTo(op2); switch (Op) { case Operador.MAYORQUE: return(res == 1); case Operador.MENORQUE: return(res == -1); case Operador.IGUAL: return(res == 0); case Operador.MENORIGUAL: return(res == -1 || res == 0); case Operador.MAYORIGUAL: return(res == 1 || res == 0); case Operador.DIFERENTE: return(!(res == 0)); } } else if ((Op1.Tipo.IsBoolean() && Op2.Tipo.IsBoolean()) || (Op1.Tipo.IsString() && Op2.Tipo.IsString())) { if (Op == Operador.IGUAL) { return(valOp1.ToString().Equals(valOp2.ToString())); } else if (Op == Operador.DIFERENTE) { return(!valOp1.ToString().Equals(valOp2.ToString())); } errores.AddLast(new Error("Semántico", "Con " + Op1.Tipo.Type + " solo se puede operar el igual y diferente.", Linea, Columna)); return(null); } else if (Op1.Tipo.IsNull() || Op2.Tipo.IsNull()) { if (Op1.Tipo.IsNull() && Op2.Tipo.IsNullable()) { if (Op == Operador.IGUAL) { return(valOp2 is Null); } else if (Op == Operador.DIFERENTE) { return(!(valOp2 is Null)); } errores.AddLast(new Error("Semántico", "Con Null solo se puede operar el igual y diferente.", Linea, Columna)); return(null); } else if (Op2.Tipo.IsNull() && Op1.Tipo.IsNullable()) { if (Op == Operador.IGUAL) { return(valOp1 is Null); } else if (Op == Operador.DIFERENTE) { return(!(valOp1 is Null)); } errores.AddLast(new Error("Semántico", "Con Null solo se puede operar el igual y diferente.", Linea, Columna)); return(null); } } errores.AddLast(new Error("Semántico", "No se pudo realizar la operación relacional.", Linea, Columna)); } return(null); }
public override object GetValor(Entorno e, LinkedList <Salida> log, LinkedList <Error> errores) { object valOp1 = Op1.GetValor(e, log, errores); object valOp2 = Op2.GetValor(e, log, errores); if (valOp1 != null && valOp2 != null) { if (valOp1 is Throw) { return(valOp1); } if (valOp2 is Throw) { return(valOp2); } TipoDominante(errores); if (Tipo != null) { switch (Tipo.Type) { case Type.STRING: Cadena cad = new Cadena { Valor = valOp1.ToString() + valOp2.ToString() }; return(cad); case Type.DOUBLE: switch (Op) { case Operador.SUMA: return(Convert.ToDouble(valOp1) + Convert.ToDouble(valOp2)); case Operador.RESTA: return(Convert.ToDouble(valOp1) - Convert.ToDouble(valOp2)); case Operador.MULTIPLICACION: return(Convert.ToDouble(valOp1) * Convert.ToDouble(valOp2)); case Operador.POTENCIA: return(Math.Pow(Convert.ToDouble(valOp1), Convert.ToDouble(valOp2))); case Operador.MODULO: return(Convert.ToDouble(valOp1) % Convert.ToDouble(valOp2)); case Operador.DIVISION: if (Convert.ToDouble(valOp2) != 0) { return(Convert.ToDouble(valOp1) / Convert.ToDouble(valOp2)); } //errores.AddLast(new Error("Semántico", "División entre 0.", Linea, Columna)); return(new Throw("ArithmeticException", Linea, Columna)); } break; case Type.INT: switch (Op) { case Operador.SUMA: return(Convert.ToInt32(valOp1) + Convert.ToInt32(valOp2)); case Operador.RESTA: return(Convert.ToInt32(valOp1) - Convert.ToInt32(valOp2)); case Operador.MULTIPLICACION: return(Convert.ToInt32(valOp1) * Convert.ToInt32(valOp2)); case Operador.POTENCIA: return(Math.Pow(Convert.ToInt32(valOp1), Convert.ToInt32(valOp2))); case Operador.MODULO: return(Convert.ToInt32(valOp1) % Convert.ToInt32(valOp2)); case Operador.DIVISION: if (Convert.ToInt32(valOp2) != 0) { return(Convert.ToInt32(valOp1) / Convert.ToInt32(valOp2)); } //errores.AddLast(new Error("Semántico", "División entre 0.", Linea, Columna)); return(new Throw("ArithmeticException", Linea, Columna)); } break; case Type.MAP: if (valOp1 is Null) { return(new Throw("NullPointerException", Linea, Columna)); } if (valOp2 is Null) { return(new Throw("NullPointerException", Linea, Columna)); } Collection map1 = (Collection)valOp1; Collection map2 = (Collection)valOp2; foreach (CollectionValue value in map2.Valores) { if (Op == Operador.SUMA) { if (map1.Tipo.Clave.Equals(map2.Tipo.Clave) && map1.Tipo.Valor.Equals(map2.Tipo.Valor)) { if (map1.Get(value.Clave) == null) { map1.Insert(value.Clave, value.Valor); } else { map1.Set(value.Clave, value.Valor); //errores.AddLast(new Error("Semántico", "Ya existe un valor con la clave: " + value.Clave.ToString() + " en Map.", Linea, Columna)); } } else { Casteo cast1 = new Casteo(map1.Tipo.Clave, new Literal(map2.Tipo.Clave, value.Clave, 0, 0), 0, 0) { Mostrar = false }; Casteo cast2 = new Casteo(map1.Tipo.Valor, new Literal(map2.Tipo.Valor, value.Valor, 0, 0), 0, 0) { Mostrar = false }; object clave = cast1.GetValor(e, log, errores); object valor = cast2.GetValor(e, log, errores); if (clave != null && valor != null) { if (clave is Throw) { return(clave); } if (valor is Throw) { return(valor); } if (map1.Get(clave) == null) { map1.Insert(clave, valor); } else { map1.Set(clave, valor); //errores.AddLast(new Error("Semántico", "Ya existe un valor con la clave: " + clave.ToString() + " en Map.", Linea, Columna)); } continue; } errores.AddLast(new Error("Semántico", "Los tipos de los parametros no coinciden con la clave:valor del Map.", Linea, Columna)); return(null); } } else if (Op == Operador.RESTA) { if (map1.Tipo.Clave.Equals(map2.Tipo.Valor)) { if (!map1.Remove(value.Valor)) { errores.AddLast(new Error("Semántico", "No existe un valor con la clave: " + value.Valor.ToString() + " en Map.", Linea, Columna)); } } else { Casteo cast = new Casteo(map1.Tipo.Clave, new Literal(map2.Tipo.Valor, value.Valor, 0, 0), 0, 0) { Mostrar = false }; object clave = cast.GetValor(e, log, errores); if (clave != null) { if (!map1.Remove(clave)) { errores.AddLast(new Error("Semántico", "No existe un valor con la clave: " + clave.ToString() + " en Map.", Linea, Columna)); } } } } else { return(new Throw("ArithmeticException", Linea, Columna)); } } return(map1); case Type.LIST: case Type.SET: if (valOp1 is Null) { return(new Throw("NullPointerException", Linea, Columna)); } if (valOp2 is Null) { return(new Throw("NullPointerException", Linea, Columna)); } Collection set1 = (Collection)valOp1; Collection set2 = (Collection)valOp2; foreach (CollectionValue value in set2.Valores) { if (Op == Operador.SUMA) { if (set1.Tipo.Valor.Equals(set2.Tipo.Valor)) { set1.Insert(set1.Posicion++, value.Valor); } else { Casteo cast = new Casteo(set1.Tipo.Valor, new Literal(set2.Tipo.Valor, value.Valor, 0, 0), 0, 0) { Mostrar = false }; object valor = cast.GetValor(e, log, errores); if (valor != null) { if (valor is Throw) { return(valor); } set1.Insert(set1.Posicion++, valor); continue; } errores.AddLast(new Error("Semántico", "El tipo del parametro no coinciden con el valor de la Collection.", Linea, Columna)); return(null); } } else if (Op == Operador.RESTA) { if (set1.Tipo.Valor.Equals(set2.Tipo.Valor)) { if (!set1.RemoveValor(value.Valor)) { errores.AddLast(new Error("Semántico", "No existe un valor: " + value.Valor.ToString() + " en Collection.", Linea, Columna)); } } else { Casteo cast = new Casteo(set1.Tipo.Valor, new Literal(set2.Tipo.Valor, value.Valor, 0, 0), 0, 0) { Mostrar = false }; object valor = cast.GetValor(e, log, errores); if (valor != null) { if (valor is Throw) { return(valor); } if (!set1.RemoveValor(valor)) { errores.AddLast(new Error("Semántico", "No existe un valor: " + valor.ToString() + " en Collection.", Linea, Columna)); } continue; } errores.AddLast(new Error("Semántico", "El tipo del parametro no coinciden con el valor de la Collection.", Linea, Columna)); return(null); } } else { return(new Throw("ArithmeticException", Linea, Columna)); } } return(set1); } } return(new Throw("ArithmeticException", Linea, Columna)); } return(null); }
public override StackEntry Duplicate() { return(new BinaryOperator(Operation, IsComparison, Op1.Duplicate(), Op2.Duplicate(), Kind)); }
public double Compute(params double[] value) { return(Op2.Compute(value) == 0 ? 1 : Op1.Compute(value) / Op2.Compute(value)); }
public override Result GetC3D(Ent e, bool funcion, bool ciclo, bool isObjeto, LinkedList <Error> errores) { Result result = new Result(); if (Op1 is Relacional) { ((Relacional)Op1).Cortocircuito = true; } else if (Op1 is Logica) { ((Logica)Op1).Evaluar = true; } Result rsOp1 = Op1.GetC3D(e, funcion, ciclo, isObjeto, errores); if (Op2 != null) { if (Op2 is Relacional) { ((Relacional)Op2).Cortocircuito = true; } else if (Op2 is Logica) { ((Logica)Op2).Evaluar = true; } Result rsOp2 = Op2.GetC3D(e, funcion, ciclo, isObjeto, errores); TipoResultante(Op1.GetTipo(), Op2.GetTipo()); if (!Tipo.IsIndefinido()) { if (Tipo.IsBoolean()) /*Si los dos son booleanos*/ { if (Op1 is Literal) { rsOp1.EtiquetaV = NuevaEtiqueta(); rsOp1.EtiquetaF = NuevaEtiqueta(); rsOp1.Codigo += "ifFalse (" + rsOp1.Valor + " == 1) goto " + rsOp1.EtiquetaV + ";\n"; rsOp1.Codigo += "goto " + rsOp1.EtiquetaF + ";\n"; rsOp1.EtiquetaV += ":\n"; rsOp1.EtiquetaF += ":\n"; } if (Op2 is Literal) { rsOp2.EtiquetaV = NuevaEtiqueta(); rsOp2.EtiquetaF = NuevaEtiqueta(); rsOp2.Codigo += "ifFalse (" + rsOp2.Valor + " == 1) goto " + rsOp2.EtiquetaV + ";\n"; rsOp2.Codigo += "goto " + rsOp2.EtiquetaF + ";\n"; rsOp2.EtiquetaV += ":\n"; rsOp2.EtiquetaF += ":\n"; } if (Op == Operador.AND) { result.Codigo += rsOp1.Codigo; if (Op1 is Relacional || Op1 is Literal) { result.Codigo += rsOp1.EtiquetaF; rsOp1.EtiquetaF = rsOp1.EtiquetaV; rsOp1.EtiquetaV = null; } else if (Op1 is Logica) { result.Codigo += rsOp1.EtiquetaV; rsOp1.EtiquetaV = null; } result.Codigo += rsOp2.Codigo; if (Op2 is Relacional || Op2 is Literal) { string copy = rsOp2.EtiquetaV; rsOp2.EtiquetaV = rsOp2.EtiquetaF; rsOp2.EtiquetaF = copy; } /* * if(Op2 is Relacional) * result.Codigo += rsOp2.EtiquetaF;*/ if (!Evaluar) { result.Valor = NuevoTemporal(); string etiquetaS = NuevaEtiqueta(); if (rsOp1.EtiquetaV != null) { result.Codigo += rsOp1.EtiquetaV; } if (rsOp2.EtiquetaV != null) { result.Codigo += rsOp2.EtiquetaV; } result.Codigo += result.Valor + " = 1;\n"; result.Codigo += "goto " + etiquetaS + ";\n"; if (rsOp1.EtiquetaF != null) { result.Codigo += rsOp1.EtiquetaF; } if (rsOp2.EtiquetaF != null) { result.Codigo += rsOp2.EtiquetaF; } result.Codigo += result.Valor + " = 0;\n"; result.Codigo += etiquetaS + ":\n"; } else { if (rsOp1.EtiquetaV != null) { result.EtiquetaV += rsOp1.EtiquetaV; } if (rsOp1.EtiquetaF != null) { result.EtiquetaF += rsOp1.EtiquetaF; } if (rsOp2.EtiquetaV != null) { result.EtiquetaV += rsOp2.EtiquetaV; } if (rsOp2.EtiquetaF != null) { result.EtiquetaF += rsOp2.EtiquetaF; } } } else { result.Codigo += rsOp1.Codigo; if (Op1 is Relacional || Op1 is Literal) { result.Codigo += rsOp1.EtiquetaV; rsOp1.EtiquetaV = rsOp1.EtiquetaF; rsOp1.EtiquetaF = null; } else if (Op1 is Logica) { result.Codigo += rsOp1.EtiquetaF; rsOp1.EtiquetaF = null; } result.Codigo += rsOp2.Codigo; if (Op2 is Relacional || Op2 is Literal) { string copy = rsOp2.EtiquetaV; rsOp2.EtiquetaV = rsOp2.EtiquetaF; rsOp2.EtiquetaF = copy; } if (!Evaluar) { result.Valor = NuevoTemporal(); string etiquetaS = NuevaEtiqueta(); if (rsOp1.EtiquetaV != null) { result.Codigo += rsOp1.EtiquetaV; } if (rsOp2.EtiquetaV != null) { result.Codigo += rsOp2.EtiquetaV; } result.Codigo += result.Valor + " = 1;\n"; result.Codigo += "goto " + etiquetaS + ";\n"; if (rsOp1.EtiquetaF != null) { result.Codigo += rsOp1.EtiquetaF; } if (rsOp2.EtiquetaF != null) { result.Codigo += rsOp2.EtiquetaF; } result.Codigo += result.Valor + " = 0;\n"; result.Codigo += etiquetaS + ":\n"; } else { if (rsOp1.EtiquetaV != null) { result.EtiquetaV += rsOp1.EtiquetaV; } if (rsOp1.EtiquetaF != null) { result.EtiquetaF += rsOp1.EtiquetaF; } if (rsOp2.EtiquetaV != null) { result.EtiquetaV += rsOp2.EtiquetaV; } if (rsOp2.EtiquetaF != null) { result.EtiquetaF += rsOp2.EtiquetaF; } } } } else { if (Op == Operador.AND) { if (Op2 is Literal && !Op2.GetTipo().IsNone()) { result.Valor = NuevoTemporal(); result.Codigo += result.Valor + " = " + rsOp2.Valor + ";\n"; } else { result.Codigo += rsOp2.Codigo; result.Valor = rsOp2.Valor; if (Op2 is Relacional || Op2 is Logica) { if (!Evaluar) { result.Valor = NuevoTemporal(); string etiquetaS = NuevaEtiqueta(); if (rsOp2.EtiquetaV != null) { result.Codigo += rsOp2.EtiquetaV; } result.Codigo += result.Valor + " = 1;\n"; result.Codigo += "goto " + etiquetaS + ";\n"; if (rsOp2.EtiquetaF != null) { result.Codigo += rsOp2.EtiquetaF; } result.Codigo += result.Valor + " = 0;\n"; result.Codigo += etiquetaS + ":\n"; } else { result.EtiquetaV = rsOp2.EtiquetaV; result.EtiquetaF = rsOp2.EtiquetaF; } } } Tipo = Op2.GetTipo(); } else { if (Op1 is Literal && !Op1.GetTipo().IsNone()) { result.Valor = NuevoTemporal(); result.Codigo += result.Valor + " = " + rsOp1.Valor + ";\n"; } else { result.Codigo += rsOp1.Codigo; result.Valor = rsOp1.Valor; if (Op1 is Relacional || Op1 is Logica) { if (!Evaluar) { result.Valor = NuevoTemporal(); string etiquetaS = NuevaEtiqueta(); if (rsOp1.EtiquetaV != null) { result.Codigo += rsOp1.EtiquetaV; } result.Codigo += result.Valor + " = 1;\n"; result.Codigo += "goto " + etiquetaS + ";\n"; if (rsOp1.EtiquetaF != null) { result.Codigo += rsOp1.EtiquetaF; } result.Codigo += result.Valor + " = 0;\n"; result.Codigo += etiquetaS + ":\n"; } else { result.EtiquetaV = rsOp1.EtiquetaV; result.EtiquetaF = rsOp1.EtiquetaF; } } } Tipo = Op1.GetTipo(); } } } else { errores.AddLast(new Error("Semántico", "Error de tipos en operación lógica.", Linea, Columna)); } } else /*NOT*/ { Tipo.Tip = Tipo.Type.BOOLEAN; if (Op1.GetTipo().IsBoolean()) /*Boolean, exp logica y relacional*/ { if (Op1 is Literal) { rsOp1.EtiquetaV = NuevaEtiqueta(); rsOp1.EtiquetaF = NuevaEtiqueta(); rsOp1.Codigo += "ifFalse (" + rsOp1.Valor + " == 1) goto " + rsOp1.EtiquetaV + ";\n"; rsOp1.Codigo += "goto " + rsOp1.EtiquetaF + ";\n"; rsOp1.EtiquetaV += ":\n"; rsOp1.EtiquetaF += ":\n"; } result.Codigo += rsOp1.Codigo; if (!Evaluar) { result.Valor = NuevoTemporal(); string etiquetaS = NuevaEtiqueta(); if (rsOp1.EtiquetaV != null) { result.Codigo += rsOp1.EtiquetaV; } result.Codigo += result.Valor + " = 1;\n"; result.Codigo += "goto " + etiquetaS + ";\n"; if (rsOp1.EtiquetaF != null) { result.Codigo += rsOp1.EtiquetaF; } result.Codigo += result.Valor + " = 0;\n"; result.Codigo += etiquetaS + ":\n"; } else { if (rsOp1.EtiquetaV != null) { result.EtiquetaF = rsOp1.EtiquetaV; } if (rsOp1.EtiquetaF != null) { result.EtiquetaV = rsOp1.EtiquetaF; } } } else { if (Op1 is Literal) { string tmp = NuevoTemporal(); rsOp1.Codigo += tmp + " = " + rsOp1.Valor + ";\n"; rsOp1.Valor = tmp; } if (Op1.GetTipo().IsString()) { rsOp1.Codigo += rsOp1.Valor + " = 0 - 1;\n"; } result.Codigo += rsOp1.Codigo; if (!Evaluar) { result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); result.Valor = NuevoTemporal(); result.Codigo += result.Valor + " = 0;\n"; result.Codigo += "ifFalse (" + rsOp1.Valor + " == 0) goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.Codigo += result.EtiquetaF + ":\n"; result.Codigo += result.Valor + " = 1;\n"; result.Codigo += result.EtiquetaV + ":\n"; } else { result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); result.Codigo += "ifFalse (" + rsOp1.Valor + " == 0) goto " + result.EtiquetaF + ";\n"; result.Codigo += "goto " + result.EtiquetaV + ";\n"; result.EtiquetaV += ":\n"; result.EtiquetaF += ":\n"; } } } return(result); }
public override StackEntry Duplicate() { return(new UnaryOperator(Operation, Op1.Duplicate())); }
public override Result GetC3D(Ent e, bool funcion, bool ciclo, bool isObjeto, LinkedList <Error> errores) { Result result = new Result(); if (Op != Operador.IS && Op != Operador.ISNOT) { Result rsOp1 = Op1.GetC3D(e, funcion, ciclo, isObjeto, errores); Result rsOp2 = Op2.GetC3D(e, funcion, ciclo, isObjeto, errores); TipoResultante(Op1.GetTipo(), Op2.GetTipo()); if (!Tipo.IsIndefinido()) { if (!Op1.GetTipo().IsObject() && !Op2.GetTipo().IsObject()) /*si los dos no son objetos*/ { /* * if (Op == Operador.IGUAL) * { * if (Op1.GetTipo() != Op2.GetTipo()) * { * result.Codigo += rsOp1.Codigo; * result.Codigo += rsOp2.Codigo; * result.Valor = NuevoTemporal(); * result.Codigo += result.Valor + " = 0;\n"; * return result; * } * } * * if (Op == Operador.DIFERENTE) * { * if (Op1.GetTipo() != Op2.GetTipo()) * { * result.Codigo += rsOp1.Codigo; * result.Codigo += rsOp2.Codigo; * result.Valor = NuevoTemporal(); * result.Codigo += result.Valor + " = 1;\n"; * return result; * } * } */ if (Op1.GetTipo().IsNumeric() || Op1.GetTipo().IsString() || Op1.GetTipo().IsBoolean()) { if (Op2.GetTipo().IsNumeric() || Op2.GetTipo().IsString() || Op2.GetTipo().IsBoolean()) { result.Codigo += rsOp1.Codigo; result.Codigo += rsOp2.Codigo; if (Op1.GetTipo().IsString()) { ObtenerValor(rsOp1, result); } if (Op2.GetTipo().IsString()) { ObtenerValor(rsOp2, result); } result.Valor = NuevoTemporal(); string op = ""; switch (Op) { case Operador.MAYORQUE: op = ">"; break; case Operador.MENORQUE: op = "<"; break; case Operador.MAYORIGUALQUE: op = ">="; break; case Operador.MENORIGUALQUE: op = "<="; break; case Operador.IGUAL: op = "=="; break; case Operador.DIFERENTE: op = "!="; break; } result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); if (!Cortocircuito) { result.Codigo += "if (" + rsOp1.Valor + " " + op + " " + rsOp2.Valor + ") goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; string etiquetaS = NuevaEtiqueta(); result.Codigo += result.EtiquetaV + ":\n"; result.Codigo += result.Valor + " = 1;\n"; result.Codigo += "goto " + etiquetaS + ";\n"; result.Codigo += result.EtiquetaF + ":\n"; result.Codigo += result.Valor + " = 0;\n"; result.Codigo += etiquetaS + ":\n"; } else { result.Codigo += "ifFalse (" + rsOp1.Valor + " " + op + " " + rsOp2.Valor + ") goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.EtiquetaV += ":\n"; result.EtiquetaF += ":\n"; } } else { errores.AddLast(new Error("Semántico", "Error de tipos en operación relacional.", Linea, Columna)); } } else { errores.AddLast(new Error("Semántico", "Error de tipos en operación relacional.", Linea, Columna)); } } else { if (Op == Operador.IGUAL || Op == Operador.DIFERENTE) /*con objetos solo se puede == !=*/ { result.Codigo += rsOp1.Codigo; result.Codigo += rsOp2.Codigo; result.Valor = NuevoTemporal(); if (Op == Operador.IGUAL) { if (Op1.GetTipo().Tip == Op2.GetTipo().Tip) { /*comparar objetos*/ } else { result.Codigo += result.Valor + " = 0;\n"; } } else { if (Op1.GetTipo().Tip == Op2.GetTipo().Tip) { /*comparar objetos*/ } else { result.Codigo += result.Valor + " = 1;\n"; } } } else { errores.AddLast(new Error("Semántico", "Error de tipos en operación relacional.", Linea, Columna)); } } } else { errores.AddLast(new Error("Semántico", "Error de tipos en operación relacional.", Linea, Columna)); } } else { if (Op1 is Identificador objeto) { if (Op2 is Identificador c) { Sim sim = e.GetGlobal(objeto.Id); if (sim != null) { if (sim.Tipo.IsObject()) { Sim clase = e.GetClase(c.Id); if (clase != null) { Tipo.Tip = Tipo.Type.BOOLEAN; if (sim.Tipo.Objeto.Equals(c.Id)) { if (Op == Operador.IS) { result.Valor = "1"; } else { result.Valor = "0"; } } else { if (Op == Operador.IS) { result.Valor = "0"; } else { result.Valor = "1"; } } result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); result.Codigo += "ifFalse (" + result.Valor + " == 1) goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.EtiquetaV += ":\n"; result.EtiquetaF += ":\n"; return(result); } } } } } errores.AddLast(new Error("Semántico", "Error de tipos en operación relacional.", Linea, Columna)); } return(result); }
public override Result GetC3D(Ent e, bool funcion, bool ciclo, bool isObjeto, LinkedList <Error> errores) { Result result = new Result(); Result rsOp1 = Op1.GetC3D(e, funcion, ciclo, isObjeto, errores); if (Op2 != null) { Result rsOp2 = Op2.GetC3D(e, funcion, ciclo, isObjeto, errores); TipoDominante(Op1.GetTipo(), Op2.GetTipo()); if (!Tipo.IsIndefinido()) { result.Codigo += rsOp1.Codigo; result.Codigo += rsOp2.Codigo; if (Tipo.IsString()) { if (!Op1.GetTipo().IsString()) { ConvertirString(Op1, rsOp1, result); } if (!Op2.GetTipo().IsString()) { ConvertirString(Op2, rsOp2, result); } result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); string etqCiclo = NuevaEtiqueta(); string tmpCiclo = NuevoTemporal(); result.Valor = NuevoTemporal(); result.Codigo += result.Valor + " = H;\n"; result.Codigo += tmpCiclo + " = heap[" + rsOp1.Valor + "];\n"; result.Codigo += etqCiclo + ":\n"; result.Codigo += "if (" + tmpCiclo + " == 0) goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.Codigo += result.EtiquetaF + ":\n"; result.Codigo += "heap[H] = " + tmpCiclo + ";\n"; result.Codigo += "H = H + 1;\n"; result.Codigo += rsOp1.Valor + " = " + rsOp1.Valor + " + 1;\n"; result.Codigo += tmpCiclo + " = heap[" + rsOp1.Valor + "];\n"; result.Codigo += "goto " + etqCiclo + ";\n"; result.Codigo += result.EtiquetaV + ":\n"; result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); etqCiclo = NuevaEtiqueta(); tmpCiclo = NuevoTemporal(); result.Codigo += tmpCiclo + " = heap[" + rsOp2.Valor + "];\n"; result.Codigo += etqCiclo + ":\n"; result.Codigo += "if (" + tmpCiclo + " == 0) goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.Codigo += result.EtiquetaF + ":\n"; result.Codigo += "heap[H] = " + tmpCiclo + ";\n"; result.Codigo += "H = H + 1;\n"; result.Codigo += rsOp2.Valor + " = " + rsOp2.Valor + " + 1;\n"; result.Codigo += tmpCiclo + " = heap[" + rsOp2.Valor + "];\n"; result.Codigo += "goto " + etqCiclo + ";\n"; result.Codigo += result.EtiquetaV + ":\n"; result.Codigo += "heap[H] = 0;\n"; result.Codigo += "H = H + 1;\n"; } else { switch (Op) { case Operador.SUMA: result.Valor = NuevoTemporal(); result.Codigo += result.Valor + " = " + rsOp1.Valor + " + " + rsOp2.Valor + ";\n"; break; case Operador.RESTA: result.Valor = NuevoTemporal(); result.Codigo += result.Valor + " = " + rsOp1.Valor + " - " + rsOp2.Valor + ";\n"; break; case Operador.MULTIPLICACION: result.Valor = NuevoTemporal(); result.Codigo += result.Valor + " = " + rsOp1.Valor + " * " + rsOp2.Valor + ";\n"; break; case Operador.DIVISION: result.Valor = NuevoTemporal(); result.Codigo += result.Valor + " = " + rsOp1.Valor + " / " + rsOp2.Valor + ";\n"; break; case Operador.MODULO: result.Valor = NuevoTemporal(); result.Codigo += result.Valor + " = " + rsOp1.Valor + " % " + rsOp2.Valor + ";\n"; break; case Operador.FLOOR: result.EtiquetaV = NuevaEtiqueta(); string etqSalida = NuevaEtiqueta(); if (Op1 is Literal) { string tmpOp1 = NuevoTemporal(); result.Codigo += tmpOp1 + " = " + rsOp1.Valor + ";\n"; rsOp1.Valor = tmpOp1; } if (Op2 is Literal) { string tmpOp2 = NuevoTemporal(); result.Codigo += tmpOp2 + " = " + rsOp2.Valor + ";\n"; rsOp2.Valor = tmpOp2; } result.Valor = NuevoTemporal(); result.Codigo += "if (" + rsOp2.Valor + " != 0) goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + etqSalida + ";\n"; result.Codigo += result.EtiquetaV + ":\n"; string tmpCond = NuevoTemporal(); result.Codigo += tmpCond + " = 0;\n"; result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); result.Codigo += "if (" + rsOp2.Valor + " > 0) goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.Codigo += result.EtiquetaF + ":\n"; result.Codigo += tmpCond + " = 1;\n"; string menos = NuevoTemporal(); result.Codigo += menos + " = 0 - 1;\n"; result.Codigo += rsOp2.Valor + " = " + rsOp2.Valor + " * " + menos + ";\n"; result.Codigo += result.EtiquetaV + ":\n"; string tmpCond2 = NuevoTemporal(); result.Codigo += tmpCond2 + " = 0;\n"; result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); result.Codigo += "if (" + rsOp1.Valor + " >= 0) goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.Codigo += result.EtiquetaF + ":\n"; result.Codigo += tmpCond2 + " = 1;\n"; menos = NuevoTemporal(); result.Codigo += menos + " = 0 - 1;\n"; result.Codigo += rsOp1.Valor + " = " + rsOp1.Valor + " * " + menos + ";\n"; result.Codigo += result.EtiquetaV + ":\n"; result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); result.Codigo += result.Valor + " = 1;\n"; result.Codigo += "if (" + rsOp2.Valor + " > " + rsOp1.Valor + ") goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.Codigo += result.EtiquetaV + ":\n"; result.Codigo += result.Valor + " = 0;\n"; result.Codigo += result.EtiquetaF + ":\n"; result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); string etqCiclo = NuevaEtiqueta(); string tmp = NuevoTemporal(); result.Codigo += tmp + " = " + rsOp1.Valor + " - " + rsOp2.Valor + ";\n"; result.Codigo += etqCiclo + ":\n"; result.Codigo += tmp + " = " + tmp + " - " + rsOp2.Valor + ";\n"; result.Codigo += "if (" + tmp + " >= 0) goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.Codigo += result.EtiquetaV + ":\n"; result.Codigo += result.Valor + " = " + result.Valor + " + 1;\n"; result.Codigo += "goto " + etqCiclo + ";\n"; result.Codigo += result.EtiquetaF + ":\n"; result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); result.Codigo += "if (" + tmpCond + " == 0) goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.Codigo += result.EtiquetaF + ":\n"; string etqVerd = result.EtiquetaV; result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); result.Codigo += "if (" + tmpCond2 + " == 1) goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.Codigo += result.EtiquetaF + ":\n"; result.Codigo += result.Valor + " = " + result.Valor + " + 1;\n"; menos = NuevoTemporal(); result.Codigo += menos + " = 0 - 1;\n"; result.Codigo += result.Valor + " = " + result.Valor + " * " + menos + ";\n"; result.Codigo += etqVerd + ":\n"; result.Codigo += result.EtiquetaV + ":\n"; result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); result.Codigo += "if (" + tmpCond2 + " == 0) goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.Codigo += result.EtiquetaF + ":\n"; etqVerd = result.EtiquetaV; result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); result.Codigo += "if (" + tmpCond + " == 1) goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.Codigo += result.EtiquetaF + ":\n"; result.Codigo += result.Valor + " = " + result.Valor + " + 1;\n"; menos = NuevoTemporal(); result.Codigo += menos + " = 0 - 1;\n"; result.Codigo += result.Valor + " = " + result.Valor + " * " + menos + ";\n"; result.Codigo += etqVerd + ":\n"; result.Codigo += result.EtiquetaV + ":\n"; result.Codigo += etqSalida + ":\n"; break; case Operador.POTENCIA: if (Op1 is Literal) { string tmpOp1 = NuevoTemporal(); result.Codigo += tmpOp1 + " = " + rsOp1.Valor + ";\n"; rsOp1.Valor = tmpOp1; } if (Op2 is Literal) { string tmpOp2 = NuevoTemporal(); result.Codigo += tmpOp2 + " = " + rsOp2.Valor + ";\n"; rsOp2.Valor = tmpOp2; } else if (Op2 is Aritmetica) { if (((Aritmetica)Op2).Op2 == null && ((Aritmetica)Op2).Op == Operador.RESTA) { Tipo.Tip = Tipo.Type.DOUBLE; } } result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); string factorNeg = NuevoTemporal(); string nuevoValor = NuevoTemporal(); string etqSalida2 = NuevaEtiqueta(); //string etqError = NuevaEtiqueta(); result.Codigo += "if (" + rsOp2.Valor + " >= 0) goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.Codigo += result.EtiquetaF + ":\n"; result.Codigo += factorNeg + " = 0 - 1;\n"; result.Codigo += rsOp2.Valor + " = " + rsOp2.Valor + " * " + factorNeg + ";\n"; //result.Codigo += "if (" + rsOp1.Valor + " == 0) goto " + etqError + ";\n";/*0**-num*/ result.Codigo += nuevoValor + " = 1.0 / " + rsOp1.Valor + ";\n"; result.Codigo += "goto " + etqSalida2 + ";\n"; result.Codigo += result.EtiquetaV + ":\n"; result.Codigo += nuevoValor + " = " + rsOp1.Valor + ";\n"; result.Codigo += etqSalida2 + ":\n"; result.EtiquetaV = NuevaEtiqueta(); result.EtiquetaF = NuevaEtiqueta(); string etqCiclo2 = NuevaEtiqueta(); result.Valor = NuevoTemporal(); result.Codigo += result.Valor + " = 1;\n"; result.Codigo += etqCiclo2 + ":\n"; result.Codigo += "if (" + rsOp2.Valor + " <= 0) goto " + result.EtiquetaV + ";\n"; result.Codigo += "goto " + result.EtiquetaF + ";\n"; result.Codigo += result.EtiquetaF + ":\n"; result.Codigo += result.Valor + " = " + result.Valor + " * " + nuevoValor + ";\n"; result.Codigo += rsOp2.Valor + " = " + rsOp2.Valor + " - 1;\n"; result.Codigo += "goto " + etqCiclo2 + ";\n"; result.Codigo += result.EtiquetaV + ":\n"; break; } } } else { errores.AddLast(new Error("Semántico", "Error de tipos en operación aritmética.", Linea, Columna)); } } else { Tipo tipOp1 = Op1.GetTipo(); if (tipOp1.IsNumeric() || tipOp1.IsBoolean()) { if (tipOp1.IsNumeric()) { Tipo = Op1.GetTipo(); } else { Tipo = new Tipo(Tipo.Type.INT); } result.Codigo += rsOp1.Codigo; result.Valor = NuevoTemporal(); switch (Op) { case Operador.SUMA: result.Codigo += result.Valor + " = " + rsOp1.Valor + " * 1;\n"; break; case Operador.RESTA: result.Codigo += result.Valor + " = 0 - 1;\n"; string tmp = result.Valor; result.Valor = NuevoTemporal(); result.Codigo += result.Valor + " = " + rsOp1.Valor + " * " + tmp + ";\n"; break; } } else { errores.AddLast(new Error("Semántico", "Error de tipos en operación aritmética.", Linea, Columna)); } } return(result); }
public override Operation Substitute(Variable variable, Operation operation) { return(new Arthmetic(Op1.Substitute(variable, operation), Op2.Substitute(variable, operation), OperationType)); }
public double Compute(params double[] value) { return(Op1.Compute(value) * Op2.Compute(value)); }
public override FieldAddressEntry Duplicate() { return(new FieldAddressEntry(Name, Op1.Duplicate(), Offset)); }
public override Tipo GetTipo(Entorno e) { if (!(Op1 is Operacion) && !(Op2 is Operacion)) { Tipo tip1 = Op1.GetTipo(e); Tipo tip2 = Op2.GetTipo(e); if (tip1 != Tipo.NULL && tip2 != Tipo.NULL) { if ((tip1 == Tipo.DECIMAL || tip1 == Tipo.ENTERO) && (tip2 == Tipo.DECIMAL || tip2 == Tipo.ENTERO)) { try { if (tip1 == Tipo.DECIMAL || tip2 == Tipo.DECIMAL) { double val1 = Convert.ToDouble(Op1.GetValor()); double val2 = Convert.ToDouble(Op2.GetValor()); switch (Op) { case Operador.MENORQUE: valor = val1 < val2 ? 1 : 0; return(Tipo.DECIMAL); case Operador.MAYORQUE: valor = val1 > val2 ? 1 : 0; return(Tipo.DECIMAL); case Operador.MENORIGUAL: valor = val1 <= val2 ? 1 : 0; return(Tipo.DECIMAL); case Operador.MAYORIGUAL: valor = val1 >= val2 ? 1 : 0; return(Tipo.DECIMAL); case Operador.IGUAL: valor = val1 == val2 ? 1 : 0; return(Tipo.DECIMAL); case Operador.DIFERENTE: valor = val1 != val2 ? 1 : 0; return(Tipo.DECIMAL); } } else { int val1 = Convert.ToInt32(Op1.GetValor()); int val2 = Convert.ToInt32(Op2.GetValor()); switch (Op) { case Operador.MENORQUE: valor = val1 < val2 ? 1 : 0; return(Tipo.ENTERO); case Operador.MAYORQUE: valor = val1 > val2 ? 1 : 0; return(Tipo.ENTERO); case Operador.MENORIGUAL: valor = val1 <= val2 ? 1 : 0; return(Tipo.ENTERO); case Operador.MAYORIGUAL: valor = val1 >= val2 ? 1 : 0; return(Tipo.ENTERO); case Operador.IGUAL: valor = val1 == val2 ? 1 : 0; return(Tipo.ENTERO); case Operador.DIFERENTE: valor = val1 != val2 ? 1 : 0; return(Tipo.ENTERO); } } } catch (Exception) { Console.WriteLine("Error, no se puede realizar la operación relacional. Línea: " + Linea); } } else { Console.WriteLine("Error, no se puede realizar la operación relacional. Línea: " + Linea); } } } else { Console.WriteLine("Error, se esta usando más de 3 direcciones. Línea: " + Linea); } return(Tipo.NULL); }
public override StackEntry Duplicate() { return(new StoreLocalVariableEntry(LocalNumber, IsParameter, Op1.Duplicate())); }
public override Tipo GetTipo(Entorno e) { if (!(Op1 is Operacion) && !(Op2 is Operacion)) { Tipo tip1 = Op1.GetTipo(e); Tipo tip2 = Op2.GetTipo(e); if (tip1 != Tipo.NULL && tip2 != Tipo.NULL) { if ((tip1 == Tipo.ENTERO || tip1 == Tipo.DECIMAL) && (tip2 == Tipo.ENTERO || tip2 == Tipo.DECIMAL)) { Object val1 = Op1.GetValor(); Object val2 = Op2.GetValor(); try { switch (Op) { case Operador.MAS: if (tip1 == Tipo.DECIMAL || tip2 == Tipo.DECIMAL) { valor = Convert.ToDouble(val1) + Convert.ToDouble(val2); return(Tipo.DECIMAL); } else { int val = Convert.ToInt32(val1) + Convert.ToInt32(val2); valor = val; return(Tipo.ENTERO); } case Operador.MENOS: if (tip1 == Tipo.DECIMAL || tip2 == Tipo.DECIMAL) { valor = Convert.ToDouble(val1) - Convert.ToDouble(val2); return(Tipo.DECIMAL); } else { int val = Convert.ToInt32(val1) - Convert.ToInt32(val2); valor = val; return(Tipo.ENTERO); } case Operador.POR: if (tip1 == Tipo.DECIMAL || tip2 == Tipo.DECIMAL) { valor = Convert.ToDouble(val1) * Convert.ToDouble(val2); return(Tipo.DECIMAL); } else { int val = Convert.ToInt32(val1) * Convert.ToInt32(val2); valor = val; return(Tipo.ENTERO); } case Operador.DIVIDIO: if (Convert.ToInt32(val2) != 0) { if (tip1 == Tipo.DECIMAL || tip2 == Tipo.DECIMAL) { valor = Convert.ToDouble(val1) / Convert.ToDouble(val2); return(Tipo.DECIMAL); } else { double val = Convert.ToDouble(val1) / Convert.ToDouble(val2); valor = Math.Truncate(val); return(Tipo.ENTERO); } } else { Console.WriteLine("Division entre 0-> linea: " + Op2.Linea + " columna: " + Op2.Columna); return(Tipo.NULL); } case Operador.MODULO: if (tip1 == Tipo.DECIMAL || tip2 == Tipo.DECIMAL) { valor = Math.Truncate(Convert.ToDouble(val1) % Convert.ToDouble(val2)); return(Tipo.DECIMAL); } else { double val = Convert.ToDouble(val1) % Convert.ToDouble(val2); valor = Math.Truncate(val); return(Tipo.ENTERO); } } } catch (Exception) { Console.WriteLine("Error, no se puede realizar la operación aritmética. Línea: " + Linea); } } else { Console.WriteLine("Error, no se puede realizar la operación aritmética. Línea: " + Linea); } } } else { Console.WriteLine("Error, se esta usando más de 3 direcciones. Línea: " + Linea); } return(Tipo.NULL); }