Exemple #1
0
        public Arboles SimpleExpresion()
        {
            Arboles nodoRaiz = Termino();

            while (miListaTokenTemporal[puntero].lexema.Equals("+") ||
                   miListaTokenTemporal[puntero].lexema.Equals("-"))
            {
                Arboles nodoTemp = NuevoNodoExpresion(TipoExpresion.Operador);
                nodoTemp.HijoIzquierdo = nodoRaiz;
                nodoTemp.soyOperacion  =
                    miListaTokenTemporal[puntero].lexema.Equals("+")
                    ? Operaciones.Suma
                    : Operaciones.Resta;
                nodoTemp.codigoP =
                    miListaTokenTemporal[puntero].lexema.Equals("+")
                    ? "add"
                    : "sbi";
                nodoTemp.lexema = miListaTokenTemporal[puntero].lexema;
                nodoRaiz        = nodoTemp;
                puntero++;
                nodoRaiz.HijoDerecho = Termino();
            }

            return(nodoRaiz);
        }
Exemple #2
0
        public Arboles Termino()
        {
            Arboles t = Factor();

            while (miListaTokenTemporal[puntero].lexema.Equals("*") ||
                   miListaTokenTemporal[puntero].lexema.Equals("/"))
            {
                Arboles p = NuevoNodoExpresion(TipoExpresion.Operador);
                p.HijoIzquierdo = t;
                p.soyOperacion  = miListaTokenTemporal[puntero].lexema.Equals("*")
                    ? Operaciones.Multiplicacion
                    : Operaciones.Division;
                p.lexema = miListaTokenTemporal[puntero].lexema.Equals("*")
                    ? "*"
                    : "/";
                p.codigoP = miListaTokenTemporal[puntero].lexema.Equals("*")
                    ? "mpi"
                    : "div";
                //t.lexema = miListaTokenTemporal[puntero].Lexema;
                t = p;
                puntero++;
                t.HijoDerecho = Factor();
            }
            return(t);
        }
Exemple #3
0
        private Arboles Sentencia()
        {
            Arboles nodoRaiz  = new Arboles();
            bool    secuencia = true;

            switch (miListaTokenTemporal[puntero].estado)
            {
            case -124:
                nodoRaiz = SentenciaIf();
                break;

            case -121:
                nodoRaiz = SenteciaFor();
                break;

            case -158:
                nodoRaiz = SentenciaWrite(true);
                break;
            }
            if (puntero < miListaTokenTemporal.Count - 1 && miListaTokenTemporal[puntero + 1].estado == -4)
            {
                puntero++;

                nodoRaiz = SentenciaAsignacion();
            }
            if (puntero < miListaTokenTemporal.Count - 1 && miListaTokenTemporal[puntero].estado == -4)
            {
                nodoRaiz = SentenciaAsignacion();
            }
            return(nodoRaiz);
        }
Exemple #4
0
        public Arboles insertarNodo(Arboles padre, Arboles hijo)
        {
            Arboles q = padre;

            if (q.Hermano == null)
            {
                q.Hermano = hijo;
            }
            else
            {
                bool insertado = false;
                while (!insertado)
                {
                    Arboles n = q.Hermano;

                    if (n.Hermano == null)
                    {
                        n.Hermano = hijo;
                        insertado = true;
                    }
                    q = n;
                }
            }

            return(padre);
        }
Exemple #5
0
        public Arboles SecuenciaSentencias()
        {
            Arboles t = Sentencia();

            puntero++;
            while (puntero < miListaTokenTemporal.Count - 1)
            {
                t = insertarNodo(t, Sentencia());
                puntero++;
            }
            return(t);
        }
Exemple #6
0
        public Arboles NuevoNodoExpresion(TipoExpresion tipo)
        {
            Arboles t = new Arboles();

            t.ts                     = ts;
            t.claseActiva            = this.claseActiva;
            t.metodoActivo           = this.metodoActivo;
            t.soyExpresionTipo       = tipo;
            t.soyTipoNodo            = TipoNodoArbol.Expresion;
            t.soySentenciaTipo       = TipoSentencia.Nada;
            t.soyValorTipo           = TipoValorNodo.Nada;
            t.tipoValorHijoDerecho   = TipoValorNodo.Nada;
            t.tipoValorHijoIzquierdo = TipoValorNodo.Nada;
            t.soyOperacion           = Operaciones.Nada;
            return(t);
        }
Exemple #7
0
        public Arboles Factor()
        {
            Arboles t = new Arboles();

            t.ts           = ts;
            t.claseActiva  = this.claseActiva;
            t.metodoActivo = this.metodoActivo;

            if (miListaTokenTemporal[puntero].estado == -1)
            {
                t              = NuevoNodoExpresion(TipoExpresion.Constante);
                t.codigoP      = "ldc " + miListaTokenTemporal[puntero].lexema;
                t.soyValorTipo = TipoValorNodo.Entero;
                t.lexema       = miListaTokenTemporal[puntero].lexema;
                puntero++;
            }
            if (miListaTokenTemporal[puntero].estado == -2)
            {
                t              = NuevoNodoExpresion(TipoExpresion.Constante);
                t.codigoP      = "ldc " + miListaTokenTemporal[puntero].lexema;
                t.lexema       = miListaTokenTemporal[puntero].lexema;
                t.soyValorTipo = TipoValorNodo.Flotante;
                puntero++;
            }
            if (miListaTokenTemporal[puntero].estado == -5)
            {
                t = NuevoNodoExpresion(TipoExpresion.Constante);

                t.lexema       = miListaTokenTemporal[puntero].lexema;
                t.codigoP      = "ldc " + miListaTokenTemporal[puntero].lexema;
                t.soyValorTipo = TipoValorNodo.Cadena;
                puntero       += 2;
            }
            else if (miListaTokenTemporal[puntero].estado == -4)
            {
                t         = NuevoNodoExpresion(TipoExpresion.Identificador);
                t.lexema  = miListaTokenTemporal[puntero].lexema;
                t.codigoP = "lod " + miListaTokenTemporal[puntero].lexema;
                //Crear metodos ObtenerNodoClase y ObtenerNodoVariable en Semantico
                t.soyValorTipo = ConversionTipoDatoTipoValorNodo(ts.TipoNodoVariable(ts.ObtenerNodoClase(claseActiva), metodoActivo, t.lexema));
                var valor = ts.ObtenerNodoVariable(t.lexema, metodoActivo, ts.ObtenerNodoClase(claseActiva));
                if (valor == null)
                {
                    //checar
                    //MessageBox.Show("Variable'" + t.lexema + "' no ha sido definida previamente", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    //Application.Exit();
                }
                else
                {
                    t.valorNodo = ts.ObtenerNodoVariable(t.lexema, metodoActivo, ts.ObtenerNodoClase(claseActiva)).Valor;
                }
                puntero++;
            }
            else if (miListaTokenTemporal[puntero].lexema.Equals("("))
            {
                puntero++;
                t = SimpleExpresion();
                puntero++;
            }
            return(t);
        }
Exemple #8
0
        public Arboles SentenciaAsignacion(bool soloAtributo)
        {
            var sentenciaAsignacion = NuevoNodoSentencia(TipoSentencia.Asignacion);

            if (miListaTokenTemporal[puntero + 1].lexema == "++" || miListaTokenTemporal[puntero + 1].lexema == "--")
            {
                sentenciaAsignacion.lexema   = miListaTokenTemporal[puntero].lexema;
                sentenciaAsignacion.codigoP  = "lda " + miListaTokenTemporal[puntero].lexema;
                sentenciaAsignacion.codigoP2 = "sto";

                Arboles i = NuevoNodoExpresion(TipoExpresion.Identificador);
                i.soyValorTipo = TipoValorNodo.Objeto;
                i.lexema       = miListaTokenTemporal[puntero].lexema;

                Arboles d = NuevoNodoExpresion(TipoExpresion.Constante);
                d.soyValorTipo = TipoValorNodo.Entero;
                d.lexema       = "1";

                Arboles op = NuevoNodoExpresion(TipoExpresion.Operador);
                if (miListaTokenTemporal[puntero + 1].lexema.Substring(0, 1) == "+")
                {
                    op.lexema       = "+";
                    op.soyOperacion = Operaciones.Suma;
                }
                else
                {
                    op.lexema       = "-";
                    op.soyOperacion = Operaciones.Resta;
                }

                op.HijoIzquierdo = i;
                op.HijoDerecho   = d;

                sentenciaAsignacion.HijoIzquierdo = op;
                return(sentenciaAsignacion);
            }
            else if (new[] { -103, -107, -120, -126, -160 }.Contains(miListaTokenTemporal[puntero].estado))
            {
                Arboles variable = new Arboles();
                variable.soyExpresionTipo       = TipoExpresion.Nada;
                variable.soyOperacion           = Operaciones.Nada;
                variable.soySentenciaTipo       = TipoSentencia.Nada;
                variable.soyValorTipo           = conversionLexemaTipo(miListaTokenTemporal[puntero].lexema);
                variable.tipoValorHijoDerecho   = TipoValorNodo.Nada;
                variable.tipoValorHijoIzquierdo = TipoValorNodo.Nada;
                variable.lexema = miListaTokenTemporal[puntero + 1].lexema;
                return(variable);
            }
            else
            {
                sentenciaAsignacion.lexema   = miListaTokenTemporal[puntero].lexema;
                sentenciaAsignacion.codigoP  = "lda " + miListaTokenTemporal[puntero].lexema;
                sentenciaAsignacion.codigoP2 = "sto";

                puntero += 2;
                if (miListaTokenTemporal[puntero].lexema == "read")
                {
                    sentenciaAsignacion.HijoIzquierdo = SentenciaRead(sentenciaAsignacion.lexema);
                }
                else
                {
                    sentenciaAsignacion.HijoIzquierdo = SimpleExpresion();
                }
                return(sentenciaAsignacion);
            }
        }
Exemple #9
0
        public Arboles SentenciaAsignacion()
        {
            var sentenciaAsignacion = NuevoNodoSentencia(TipoSentencia.Asignacion);

            if (miListaTokenTemporal[puntero + 1].lexema == "++" || miListaTokenTemporal[puntero + 1].lexema == "--")
            {
                sentenciaAsignacion.lexema   = miListaTokenTemporal[puntero].lexema;
                sentenciaAsignacion.codigoP  = "lda " + miListaTokenTemporal[puntero].lexema;
                sentenciaAsignacion.codigoP2 = "sto";
                Arboles i = NuevoNodoExpresion(TipoExpresion.Identificador);
                i.soyValorTipo = TipoValorNodo.Objeto;
                i.lexema       = miListaTokenTemporal[puntero].lexema;

                Arboles d = NuevoNodoExpresion(TipoExpresion.Constante);
                d.soyValorTipo = TipoValorNodo.Entero;
                d.lexema       = "1";

                Arboles op = NuevoNodoExpresion(TipoExpresion.Operador);
                if (miListaTokenTemporal[puntero + 1].lexema.Substring(0, 1) == "+")
                {
                    op.lexema       = "+";
                    op.soyOperacion = Operaciones.Suma;
                }
                else
                {
                    op.lexema       = "-";
                    op.soyOperacion = Operaciones.Resta;
                }

                op.HijoIzquierdo = i;
                op.HijoDerecho   = d;

                sentenciaAsignacion.HijoIzquierdo = op;
                return(sentenciaAsignacion);
            }
            else
            {
                if (puntero != 0 && new[] { -103, -107, -120, -126, -160 }.Contains(miListaTokenTemporal[puntero - 1].estado))
                {
                    //insertar variable en tabla de simbolos
                    NodoVariables miVariable = new NodoVariables();
                    miVariable.Lexema       = miListaTokenTemporal[puntero].lexema;
                    miVariable.MiTipo       = TipoDato.Int;
                    miVariable.TipoVariable = TipoVariable.Primitive;

                    Estado estadoMetodo = ts.InsertarNodoVariable(miVariable, ts.ObtenerNodoClase(this.claseActiva), this.metodoActivo);
                    if (estadoMetodo == Estado.Duplicado)
                    {
                        //MessageBox.Show("Variable duplicada:'" + miListaTokenTemporal[puntero].lexema + "'. ", "Error  ", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        //Application.Exit();
                    }
                }

                sentenciaAsignacion.lexema   = miListaTokenTemporal[puntero].lexema;
                sentenciaAsignacion.codigoP  = "lda " + miListaTokenTemporal[puntero].lexema;
                sentenciaAsignacion.codigoP2 = "sto";

                puntero += 2;
                if (miListaTokenTemporal[puntero].lexema == "cin")
                {
                    sentenciaAsignacion.HijoIzquierdo = sentenciaAsignacion.SentenciaRead(sentenciaAsignacion.lexema);
                }
                else
                {
                    sentenciaAsignacion.HijoIzquierdo = SimpleExpresion();
                }

                return(sentenciaAsignacion);
            }
        }