Пример #1
0
        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);
        }
Пример #2
0
        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);
        }
Пример #3
0
        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);
        }
Пример #4
0
        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);
        }
Пример #5
0
        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);
        }