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);
}
