public override TiposBases ValidateSemantic()
        {
            var izquierdo = OperadorDerecho.ValidateSemantic();
            var derecho   = OperadorIzquierdo.ValidateSemantic();

            return(null);
        }
Esempio n. 2
0
        public override TiposBases ValidateSemantic()
        {
            var expresion2 = OperadorDerecho.ValidateSemantic();

            if (OperadorIzquierdo == null)
            {
                return(expresion2);
            }
            var expresion1 = OperadorIzquierdo.ValidateSemantic();

            if ((expresion1 is IntTipo || expresion1 is FloatTipo) && (expresion2 is FloatTipo || expresion2 is IntTipo))
            {
                if (expresion1.GetType() == expresion2.GetType())
                {
                    return(expresion1);
                }
            }
            if (expresion1 is FloatTipo || expresion2 is FloatTipo)
            {
                return(new IntTipo());
            }
            if (expresion1 is IntTipo && expresion2 is IntTipo)
            {
                return(new IntTipo());
            }
            throw new SemanticoException("no se puede multiplicar " + expresion1 + " con " + expresion2 + "fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
        }
Esempio n. 3
0
        public override TiposBases ValidateSemantic()
        {
            var expresion2 = OperadorDerecho.ValidateSemantic();

            if (OperadorIzquierdo == null)
            {
                return(expresion2);
            }
            if (!(OperadorIzquierdo is IdentificadorNode))
            {
                throw new SemanticoException("no se puede asignar literales  fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
            }
            var expresion1 = OperadorIzquierdo.ValidateSemantic();

            if ((expresion1 is IntTipo || expresion1 is FloatTipo) && (expresion2 is FloatTipo || expresion2 is IntTipo))
            {
                if (expresion1.GetType() == expresion2.GetType())
                {
                    return(expresion1);
                }
            }
            if (expresion1 is FloatTipo || expresion2 is FloatTipo)
            {
                return(new IntTipo());
            }
            if (expresion1 is IntTipo && expresion1 is IntTipo)
            {
                return(new IntTipo());
            }
            throw new SemanticoException("no se puede obtener residuo de esta division " + expresion1 + " con " + expresion2 + "fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
        }
Esempio n. 4
0
        public override TiposBases ValidateSemantic()
        {
            var expresion1 = OperadorDerecho.ValidateSemantic();

            if (OperadorIzquierdo == null)
            {
                return(expresion1);
            }
            if (!(OperadorIzquierdo is IdentificadorNode))
            {
                throw new SemanticoException("no se puede asignar literales  fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
            }
            var expresion2 = OperadorIzquierdo.ValidateSemantic();

            if (expresion1 is IntTipo && expresion2 is FloatTipo)
            {
                return(new FloatTipo());
            }
            if (expresion1 is FloatTipo && expresion2 is IntTipo)
            {
                return(new FloatTipo());
            }
            if (expresion1 is FloatTipo && expresion2 is FloatTipo)
            {
                return(new FloatTipo());
            }
            if (expresion1 is IntTipo && expresion2 is IntTipo)
            {
                return(new IntTipo());
            }



            throw new SemanticoException("No se puede dividir" + expresion1 + " con " + expresion2 + " fila" + _TOKEN.Fila + " columna " + _TOKEN.Columna);
        }
        public override TiposBases ValidateSemantic()
        {
            var expresion1 = OperadorIzquierdo.ValidateSemantic();
            var expresion2 = OperadorDerecho.ValidateSemantic();

            if (expresion1 is StructTipo || expresion2 is StructTipo || expresion1 is VoidTipo || expresion2 is VoidTipo)
            {
                throw new SemanticoException("no se puede sumar" + expresion1 + " con " + expresion2 + "fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
            }

            if (expresion1 is StringTipo || expresion2 is StringTipo)
            {
                if (!(expresion2 is EnumTipo) && !(expresion1 is EnumTipo))
                {
                    if (!(expresion2 is DateTipo) && !(expresion1 is DateTipo))
                    {
                        if (!(expresion2 is VoidTipo) && !(expresion1 is VoidTipo))
                        {
                            return(new StringTipo());
                        }
                    }
                }
            }

            if (expresion1 is CharTipo && expresion2 is CharTipo)
            {
                return(new StringTipo());
            }
            if (expresion1.GetType() == expresion2.GetType())
            {
                return(expresion1);
            }
            if ((expresion1 is IntTipo && expresion2 is FloatTipo) || (expresion2 is IntTipo && expresion1 is FloatTipo))
            {
                return(new FloatTipo());
            }
            if (expresion1 is IntTipo && expresion2 is DateTipo)
            {
                return(new IntTipo());
            }
            if (expresion2 is IntTipo && expresion1 is DateTipo)
            {
                return(new DateTipo());
            }
            if ((expresion1 is CharTipo && expresion2 is IntTipo) || (expresion2 is CharTipo && expresion1 is IntTipo))
            {
                return(new IntTipo());
            }
            if ((expresion1 is BooleanTipo && expresion2 is IntTipo) || (expresion2 is BooleanTipo && expresion1 is IntTipo))
            {
                return(new IntTipo());
            }


            throw new SemanticoException("no se puede sumar" + expresion1 + " con " + expresion2 + "fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
        }
        public override TiposBases ValidateSemantic()
        {
            var Derecho   = OperadorDerecho.ValidateSemantic();
            var Izquierdo = OperadorIzquierdo.ValidateSemantic();

            if (Derecho is StructTipo || Izquierdo is StructTipo || Derecho is EnumTipo || Izquierdo is EnumTipo || Derecho is VoidTipo || Izquierdo is VoidTipo)
            {
                throw new SemanticoException(" No se pude compara " + Derecho + " con " + Izquierdo + "fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
            }
            return(new BooleanTipo());
        }
Esempio n. 7
0
        public override TiposBases ValidateSemantic()
        {
            var expresion1 = OperadorDerecho.ValidateSemantic();
            var expresion2 = OperadorIzquierdo.ValidateSemantic();

            if (expresion1 is BooleanTipo && expresion2 is BooleanTipo)
            {
                return(new BooleanTipo());
            }
            throw new Sintactico.SintanticoException(" las expresiones tiene que ser booleanas " + "fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
        }
Esempio n. 8
0
        public override TiposBases ValidateSemantic()
        {
            var expresion1 = OperadorDerecho.ValidateSemantic();
            var expresion2 = OperadorIzquierdo.ValidateSemantic();

            if (expresion1 is BooleanTipo && expresion2 is BooleanTipo)
            {
                return(expresion1);
            }
            if ((expresion1 is BooleanTipo || expresion2 is IntTipo) && (expresion2 is BooleanTipo || expresion1 is IntTipo))
            {
                return(new IntTipo());
            }
            throw new SemanticoException("no se puede auto operacion o logico no se puede  " + expresion1 + " con " + expresion2 + "fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
        }
        public override TiposBases ValidateSemantic()
        {
            var expresion1 = OperadorDerecho.ValidateSemantic();
            var expresion2 = OperadorIzquierdo.ValidateSemantic();

            if (!(expresion1 is IntTipo))
            {
                throw new Sintactico.SintanticoException(" la expresion debe ser de tipo Int " + "fila " + OperadorDerecho._TOKEN.Fila + " columna " + OperadorDerecho._TOKEN.Columna);
            }
            if (expresion2 is IntTipo || expresion2 is CharTipo)
            {
                return(new IntTipo());
            }
            throw new Sintactico.SintanticoException(" no se puede hacer corrimiento de tipos " + expresion2 + "fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
        }
      public override TiposBases ValidateSemantic()
      {
          var Izquierdo = OperadorIzquierdo.ValidateSemantic();
          var Derecho = OperadorDerecho.ValidateSemantic();
 
          if (OperadorIzquierdo == null)
              return Derecho;
          if (!(OperadorIzquierdo is IdentificadorNode))
              throw new SemanticoException("no se puede asignar literales  fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
          if (!(Derecho is IntTipo))
              throw new SemanticoException(" El incremeto debe ser de tipo int" + OperadorDerecho._TOKEN.Fila + " columna +" + OperadorDerecho._TOKEN.Columna);
          if (Izquierdo is IntTipo || Izquierdo is StringTipo || Izquierdo is CharTipo)
              return Izquierdo;
          throw new SemanticoException("El tipo de dato no puede hacerse corrimiento Izquierda" + _TOKEN.Fila + " columna " + _TOKEN.Columna);
      }
Esempio n. 11
0
        public override TiposBases ValidateSemantic()
        {
            var Izquierdo = OperadorIzquierdo.ValidateSemantic();
            var Derecho   = OperadorDerecho.ValidateSemantic();

            if (!(Derecho is IntTipo))
            {
                throw new SemanticoException(" El incremeto debe ser de tipo int fila " + OperadorDerecho._TOKEN.Fila + " columna +" + OperadorDerecho._TOKEN.Columna);
            }
            if (Izquierdo is IntTipo || Izquierdo is StringTipo || Izquierdo is CharTipo)
            {
                return(Izquierdo);
            }
            throw new SemanticoException("El tipo de dato no puede hacerse corrimiento Derecha  fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
        }
Esempio n. 12
0
        public override TiposBases ValidateSemantic()
        {
            var expresion1 = OperadorDerecho.ValidateSemantic();
            var expresion2 = OperadorIzquierdo.ValidateSemantic();

            if (!(expresion1 is IntTipo))
            {
                throw new Sintactico.SintanticoException(" la expresion debe ser de tipo Int ");
            }
            if (expresion2 is IntTipo || expresion2 is StringTipo)
            {
                return(expresion2);
            }
            throw new Sintactico.SintanticoException(" no se puede hacer corrimiento de tipos " + expresion2);
        }
Esempio n. 13
0
        public override TiposBases ValidateSemantic()
        {
            var expresion2 = OperadorDerecho.ValidateSemantic();

            if (OperadorIzquierdo == null)
            {
                return(expresion2);
            }
            var expresion1 = OperadorIzquierdo.ValidateSemantic();

            if (expresion1.GetType() == expresion2.GetType())
            {
                return(expresion2);
            }

            throw new SemanticoException("no se puede asignar" + expresion1 + " con " + expresion2 + " fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
        }
Esempio n. 14
0
        public override TiposBases ValidateSemantic()
        {
            var expresion1 = OperadorIzquierdo.ValidateSemantic();
            var expresion2 = OperadorDerecho.ValidateSemantic();

            if ((expresion1 is IntTipo || expresion1 is FloatTipo) && (expresion2 is FloatTipo || expresion2 is IntTipo))
            {
                if (expresion1 is FloatTipo || expresion2 is FloatTipo)
                {
                    return(new FloatTipo());
                }
                if (expresion1 is IntTipo || expresion2 is IntTipo)
                {
                    return(new IntTipo());
                }
            }
            throw new SemanticoException("no se puede dividir" + expresion1 + " con " + expresion2 + "fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
        }
        public override TiposBases ValidateSemantic()
        {
            var Derecho = OperadorDerecho.ValidateSemantic();

            if (OperadorIzquierdo == null)
            {
                return(Derecho);
            }
            var Izquierdo = OperadorIzquierdo.ValidateSemantic();

            if (Izquierdo is BooleanTipo || Izquierdo is EnumTipo || Izquierdo is StructTipo ||
                Derecho is BooleanTipo || Derecho is EnumTipo || Derecho is StructTipo)
            {
                throw new SemanticoException("El tipo no puede ser divido fila" + OperadorDerecho._TOKEN.Fila);
            }

            throw new SemanticoException("No se puede dividir" + Izquierdo + " con " + Derecho + " fila" + _TOKEN.Fila + " columna " + _TOKEN.Columna);
        }
        public override TiposBases ValidateSemantic()
        {
            var expresion2 = OperadorDerecho.ValidateSemantic();

            if (OperadorIzquierdo == null)
            {
                return(OperadorDerecho.ValidateSemantic());
            }
            if (!(OperadorIzquierdo is IdentificadorNode))
            {
                throw new SemanticoException("no se puede asignar literales  fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
            }
            var expresion1 = OperadorIzquierdo.ValidateSemantic();

            if (expresion1 is StructTipo || expresion2 is StructTipo || expresion1 is VoidTipo || expresion2 is VoidTipo ||
                expresion1 is EnumTipo || expresion2 is EnumTipo || expresion1 is DateTipo || expresion2 is DateTipo)
            {
                throw new SemanticoException("no se puede sumar" + expresion1 + " con " + expresion2 + "fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
            }

            if (expresion1 is StringTipo || expresion2 is StringTipo)
            {
                return(new StringTipo());
            }
            if (expresion1 == expresion2)
            {
                return(expresion1);
            }
            if ((expresion1 is IntTipo && expresion2 is FloatTipo) || (expresion2 is IntTipo && expresion1 is FloatTipo))
            {
                return(new FloatTipo());
            }
            if ((expresion1 is CharTipo && expresion2 is IntTipo) || (expresion2 is CharTipo && expresion1 is IntTipo))
            {
                return(new IntTipo());
            }


            throw new SemanticoException("no se puede sumar" + expresion1 + " con " + expresion2 + "fila " + _TOKEN.Fila + " columna " + _TOKEN.Columna);
        }
        public override TiposBases ValidateSemantic()
        {
            var expresion1 = OperadorIzquierdo.ValidateSemantic();
            var expresion2 = OperadorDerecho.ValidateSemantic();

            if ((expresion1 is IntTipo || expresion1 is FloatTipo) && (expresion2 is FloatTipo || expresion2 is IntTipo))
            {
                if (expresion1.GetType() == expresion2.GetType())
                {
                    return(expresion1);
                }
            }
            if (expresion1 is FloatTipo || expresion2 is FloatTipo)
            {
                return(new IntTipo());
            }
            if (expresion1 is IntTipo && expresion2 is IntTipo)
            {
                return(new IntTipo());
            }
            throw new SemanticoException("no se puede restar" + expresion1 + " con " + expresion2);
        }