public void GraficarConcatenacion(tokens a, tokens b)
        {
            if (a.final == 0 && b.inicial == 0)
            {
                inicial = estado;
                file.WriteLine(estado + "->{" + (estado + 1) + "}[label=" + a.lexema + "]");
                estado++;
                file.WriteLine(estado + "->{" + (estado + 1) + "}[label=\"" + b.lexema + "\"]");
                estado++;
                final = estado;
            }
            else if (a.final == 0 && b.final != 0 && a.inicial == 0)
            {
                inicial = b.final + 1;
                file.WriteLine((estado) + "->{" + b.inicial + "}[label=" + a.lexema + "]");
                final = b.final;
            }
            else if (a.final != 0 && b.final == 0)
            {
                inicial = a.inicial;
                file.WriteLine(a.final + "->{" + estado + "}[label=" + b.lexema + "]");
                final = b.final;
            }
            else if (a.inicial != 0 && b.final != 0)
            {
                inicial = a.inicial;
                file.WriteLine(a.final + "->{" + b.inicial + "}[label=\"E\"]");
                final = b.final;
            }

            else
            {
                inicial = a.inicial;
                file.WriteLine(a.final + "->{" + b.inicial + "}[label=\"E\"]");
                final = b.final;
            }
        }
Beispiel #2
0
        public void Concatenacion(tokens a, tokens b)
        {
            if (a.arbol == null && b.arbol == null)
            {
                inicio.lexema = a.lexema;
                setInicio(estado);

                estado++;
                nodo nuevo = new nodo(estado, b.lexema);
                inicio.der = nuevo;
                estado++;
                nodo nuevo1 = new nodo(estado);
                nuevo.der = nuevo1;
                setFinal(estado);
                if (final != null)
                {
                    final.der = nuevo1;
                }
                final = nuevo1;
                if (inicio == null)
                {
                    inicio = nuevo;
                }
            }
            else if (a.arbol != null && b.arbol == null)
            {
                if (inicio == null)
                {
                    inicio = a.arbol.inicio;
                }
                inicio.lexema = a.lexema;
                setInicio(a.arbol.eInicio);
                setFinal(a.arbol.eFinal + 1);
                a.arbol.final.lexema = b.lexema;
                nodo nuevo = new nodo(eFinal);
                a.arbol.final.der = nuevo;
                if (final != null)
                {
                    final.der = inicio;
                }
                final = nuevo;
            }
            else if (a.arbol == null && b.arbol != null)
            {
                setInicio(estado);
                nodo nuevo = new nodo(estado, a.lexema);
                nuevo.der = b.arbol.inicio;
                setFinal(b.arbol.eFinal);
                if (inicio == null)
                {
                    inicio = nuevo;
                }
                if (final != null)
                {
                    final.der = nuevo;
                }
                final = b.arbol.final;
            }
            else
            {
                if (inicio == null)
                {
                    inicio = a.arbol.inicio;
                }
                setInicio(estado);
                setFinal(b.arbol.eFinal);
                a.arbol.eFinal = b.arbol.eInicio;
                if (final != null)
                {
                    final.der = inicio;
                }
                final = b.arbol.final;
            }
        }
Beispiel #3
0
 public void Disyuncion(tokens a, tokens b)
 {
     if (a.arbol == null && b.arbol == null)
     {
         setInicio(estado);
         nodo nuevo1 = new nodo(estado, "E");
         if (final != null)
         {
             final.der = nuevo1;
         }
         estado++;
         nodo nuevo2 = new nodo(estado, a.lexema);
         estado++;
         nodo nuevo3 = new nodo(estado, b.lexema);
         nuevo1.der = nuevo2;
         nuevo1.izq = nuevo3;
         estado++;
         nodo nuevo4 = new nodo(estado, "E");
         estado++;
         nodo nuevo5 = new nodo(estado, "E");
         nuevo2.der = nuevo4;
         nuevo3.der = nuevo5;
         estado++;
         nodo nuevo6 = new nodo(estado);
         nuevo4.der = nuevo6;
         nuevo5.der = nuevo6;
         setFinal(estado);
         if (inicio == null)
         {
             inicio = nuevo1;
         }
         if (final != null)
         {
             final.der = nuevo1;
         }
         final = nuevo6;
     }
     else if (a.arbol != null && b.arbol == null)
     {
         setInicio(a.arbol.eInicio - 1);
         nodo nuevo1 = new nodo(estado, "E");
         nuevo1.der = a.arbol.inicio;
         estado++;
         nodo nuevo2 = new nodo(estado, b.lexema);
         nuevo1.der = nuevo2;
         estado++;
         nodo nuevo3 = new nodo(estado, "E");
         nuevo2.der = nuevo3;
         nodo nuevo4 = new nodo(eInicio);
         a.arbol.final.lexema = "E";
         a.arbol.final        = nuevo4;
         nuevo3.der           = nuevo4;
         if (inicio == null)
         {
             inicio = nuevo1;
         }
         if (final != null)
         {
             final.der = nuevo1;
         }
         final = nuevo4;
     }
     else if (a.arbol == null && b.arbol != null)
     {
         setInicio(estado);
         nodo nuevo = new nodo(estado, "E");
         estado++;
         nodo nuevo1 = new nodo(estado, a.lexema);
         nuevo.der = nuevo1;
         nuevo.izq = b.arbol.inicio;
         estado++;
         nodo nuevo2 = new nodo(estado, "E");
         nuevo1.der           = nuevo2;
         b.arbol.final.lexema = "E";
         estado++;
         nodo nuevo3 = new nodo(estado);
         nuevo2.der        = nuevo3;
         b.arbol.final.der = nuevo3;
         if (inicio == null)
         {
             inicio = nuevo;
         }
         if (final != null)
         {
             final.der = nuevo;
         }
         final = nuevo3;
     }
     else
     {
         setInicio(estado);
         nodo nuevo = new nodo(estado, "E");
         if (inicio == null)
         {
             inicio = nuevo;
         }
         nuevo.der = a.arbol.inicio;
         nuevo.izq = b.arbol.inicio;
         estado++;
         a.arbol.final.lexema = "E";
         b.arbol.final.lexema = "E";
         nodo nuevo1 = new nodo(estado);
         a.arbol.final.der = nuevo1;
         b.arbol.final.der = nuevo1;
         if (final != null)
         {
             final.der = nuevo;
         }
         final = nuevo1;
     }
 }
Beispiel #4
0
        public void Conjuntos()
        {
            Conjuntos conj = new Conjuntos();

            actual = tokens.ElementAt(i);
            if (actual.codigo.Equals(17))
            {
                i++;
                ID(conj);
                actual = tokens.ElementAt(i);
                if (actual.codigo.Equals(27))
                {
                    i++;
                    actual = tokens.ElementAt(i);
                    if (actual.codigo.Equals(26))
                    {
                        i++;
                        RANGO();
                        actual = tokens.ElementAt(i);
                        if (actual.codigo.Equals(16))
                        {
                            conjuntos.Add(conj);
                            rango = "";
                            i++;
                            actual = tokens.ElementAt(i);
                            if (actual.codigo.Equals(21))
                            {
                                i++;
                                Conjuntos();
                            }
                            else if (actual.codigo.Equals(5) || actual.codigo.Equals(6))
                            {
                                i++;
                                actual = tokens.ElementAt(i);
                                while (actual.codigo.Equals(5) || actual.codigo.Equals(6))
                                {
                                    i++;
                                    actual = tokens.ElementAt(i);
                                }
                                if (actual.codigo.Equals(21))
                                {
                                    i++;
                                    Conjuntos();
                                }
                                else if (actual.codigo.Equals(7))
                                {
                                    AFND = new GenerarAFND(i, tokens, SIGNOS, conjuntos);
                                    AFND.Expresion();
                                    i = tokens.Count;
                                }
                            }
                            else if (actual.codigo.Equals(25))
                            {
                                i++;
                                actual = tokens.ElementAt(i);
                                if (actual.codigo.Equals(25))
                                {
                                    i++;
                                    AFND.Expresion();//4 porcentajes
                                }
                                else
                                {
                                    Error(actual);
                                }
                            }
                            else
                            {
                                Error(actual);
                            }
                        }
                        else
                        {
                            Error(actual);
                        }
                    }
                    else
                    {
                        Error(actual);
                    }
                }
                else
                {
                    Error(actual);
                }
            }
            else
            {
                Error(actual);
            }
        }
Beispiel #5
0
        public void Error(tokens tok)
        {
            tokens token = new tokens(tok.lexema, "Error sintáctico", 20);

            tokens.Add(token);
        }
Beispiel #6
0
 public void RANGO()
 {
     actual = tokens.ElementAt(i);
     if (actual.codigo.Equals(7))
     {
         rango += actual.lexema;
         i++;
         actual = tokens.ElementAt(i);
         if (actual.codigo.Equals(22))
         {
             rango += actual.lexema;
             i++;
             actual = tokens.ElementAt(i);
             if (actual.codigo.Equals(7))
             {
                 rango += actual.lexema;
                 i++;
             }
             else
             {
                 Error(actual);
             }
         }
         else if (actual.codigo.Equals(24))
         {
             rango += actual.lexema;
             i++;
             RANGO();
         }
     }
     else if (actual.codigo.Equals(18))
     {
         rango += actual.lexema;
         i++;
         actual = tokens.ElementAt(i);
         if (actual.codigo.Equals(22))
         {
             rango += actual.lexema;
             i++;
             actual = tokens.ElementAt(i);
             if (actual.codigo.Equals(18))
             {
                 rango += actual.lexema;
                 i++;
             }
             else if (actual.codigo.Equals(24))
             {
                 rango += actual.lexema;
                 i++;
                 RANGO();
             }
             else
             {
                 Error(actual);
             }
         }
         else
         {
             Error(actual);
         }
     }
     else
     {
         Error(actual);
     }
 }
        public void Analizar()
        {
            char[] caracteres = texto.ToCharArray();
            char   caracter;
            String cadena = "";
            String error  = "";
            int    ascii;
            int    estado = 0;

            for (int i = 0; i < caracteres.Length; i++)
            {
                caracter = caracteres[i];
                ascii    = (int)caracter;
                switch (estado)
                {
                case 0:
                    if (ascii == 47)
                    {    //slash
                        cadena += (char)ascii;
                        estado  = 1;
                    }
                    else if (ascii == 60)    //<
                    {
                        cadena += (char)ascii;
                        estado  = 8;
                    }
                    else if (ascii >= 65 && ascii <= 90 || (ascii >= 97 && ascii <= 122))
                    {
                        cadena += (char)ascii;
                        estado  = 12;
                    }
                    else if (ascii == 124)    //|
                    {
                        cadena += (char)ascii;
                        tokens token = new tokens(cadena, "Operacion", 8);

                        cadena = "";
                        estado = 0;
                        Token.Add(token);
                    }
                    else if (ascii == 126)
                    {
                        cadena += (char)ascii;
                        tokens token = new tokens(cadena, "Virgulilla", 22);
                        cadena = "";
                        Token.Add(token);
                    }
                    else if (ascii == 95)
                    {
                        cadena += (char)ascii;
                        tokens token = new tokens(cadena, "guion bajo", 23);
                        cadena = "";
                        Token.Add(token);
                    }
                    else if (ascii == 45)
                    {
                        cadena += (char)ascii;
                        tokens token = new tokens(cadena, "Guión", 27);
                        cadena = "";
                        Token.Add(token);
                    }
                    else if (ascii == 62)
                    {
                        cadena += (char)ascii;
                        tokens token = new tokens(cadena, "Mayor que", 26);
                        cadena = "";
                        Token.Add(token);
                    }
                    else if (ascii == 37)
                    {
                        cadena += (char)ascii;
                        estado  = 19;
                    }
                    else if (ascii == 44)
                    {
                        cadena += (char)ascii;
                        tokens token = new tokens(cadena, "Coma", 24);
                        cadena = "";
                        Token.Add(token);
                    }
                    else if (ascii == 46)    //.
                    {
                        cadena += (char)ascii;
                        tokens token = new tokens(cadena, "Operacion", 9);
                        cadena = "";
                        estado = 0;
                        Token.Add(token);
                    }
                    else if (ascii == 63)    //?
                    {
                        cadena += (char)ascii;
                        tokens token = new tokens(cadena, "Operacion", 10);
                        cadena = "";
                        estado = 0;
                        Token.Add(token);
                    }
                    else if (ascii == 43)    //+
                    {
                        cadena += (char)ascii;
                        tokens token = new tokens(cadena, "Operacion", 11);
                        cadena = "";
                        estado = 0;
                        Token.Add(token);
                    }
                    else if (ascii == 42)    //*
                    {
                        cadena += (char)ascii;
                        tokens token = new tokens(cadena, "Operacion", 12);
                        cadena = "";
                        estado = 0;
                        Token.Add(token);
                    }
                    else if (ascii == 91)    //[
                    {
                        cadena += (char)ascii;
                        estado  = 13;
                    }
                    else if (ascii == 123)    //{
                    {
                        cadena += (char)ascii;
                        tokens token = new tokens(cadena, "Llave abierta", 14);
                        cadena = "";
                        estado = 0;
                        Token.Add(token);
                    }
                    else if (ascii == 125)    //}
                    {
                        cadena += (char)ascii;
                        tokens token = new tokens(cadena, "Llave cerrada", 15);
                        cadena = "";
                        estado = 0;
                        Token.Add(token);
                    }
                    else if (ascii == 59)    //
                    {
                        cadena += (char)ascii;
                        tokens token = new tokens(cadena, "Punto y coma", 16);
                        cadena = "";
                        estado = 0;
                        Token.Add(token);
                    }
                    else if (ascii == 58)    //
                    {
                        cadena += (char)ascii;
                        tokens token = new tokens(cadena, "Dos puntos", 17);
                        cadena = "";
                        estado = 0;
                        Token.Add(token);
                    }
                    else if (ascii >= 48 && ascii <= 57)    //
                    {
                        cadena += (char)ascii;
                        estado  = 17;
                    }
                    else if (ascii == 34)    //
                    {
                        cadena += (char)ascii;
                        estado  = 18;
                    }
                    else if (ascii != 10 && ascii != 32 && ascii != 13)
                    {
                        cadena += (char)ascii;
                        tokens tk = new tokens(cadena, "Error", 20);
                        Token.Add(tk);
                    }
                    break;

                case 1:
                    if (ascii == 47)    //
                    {
                        cadena += (char)ascii;
                        estado  = 7;
                    }
                    break;

                case 7:
                    if (ascii == 10)
                    {
                        cadena += (char)ascii;
                        tokens token = new tokens(cadena, "Comentario", 5);
                        cadena = "";
                        estado = 0;
                        Token.Add(token);
                    }
                    else
                    {
                        cadena += (char)ascii;
                    }
                    break;

                case 8:
                    if (ascii == 33)    //
                    {
                        cadena += (char)ascii;
                        estado  = 9;
                    }
                    break;

                case 9:
                    if (ascii == 33)
                    {
                        cadena += (char)ascii;
                        estado  = 10;
                    }
                    else
                    {
                        cadena += (char)ascii;
                    }
                    break;

                case 10:
                    if (ascii == 62)
                    {
                        cadena += (char)ascii;
                        tokens token = new tokens(cadena, "Comentario Multilínea", 6);
                        cadena = "";
                        estado = 0;
                        Token.Add(token);
                    }
                    else
                    {
                        error += (char)ascii;
                        tokens token = new tokens(error, "Error", 20);
                        error  = "";
                        cadena = "";
                        Token.Add(token);
                    }
                    break;

                case 12:
                    if ((ascii >= 65 && ascii <= 90) || (ascii >= 97 && ascii <= 122) || (ascii >= 48 && ascii <= 57))
                    {
                        cadena += (char)ascii;
                    }
                    else
                    {
                        if (cadena == "CONJ")
                        {
                            tokens token = new tokens(cadena, "Reservada", 21);
                            cadena = "";
                            estado = 0;
                            Token.Add(token);
                            i--;
                        }
                        else
                        {
                            tokens token = new tokens(cadena, "Id", 7);
                            cadena = "";
                            estado = 0;
                            Token.Add(token);
                            i--;
                        }
                    }

                    break;

                case 13:
                    if (ascii == 58)
                    {
                        cadena += (char)ascii;
                        estado  = 14;
                    }

                    /*else
                     * {
                     *  error += (char)ascii;
                     *  tokens token = new tokens(error, "Error", 20);
                     *  error = "";
                     *  cadena = "";
                     * }*/
                    break;

                case 14:
                    if (ascii == 58)
                    {
                        cadena += (char)ascii;
                        estado  = 15;
                    }
                    else
                    {
                        cadena += (char)ascii;
                    }
                    break;

                case 15:
                    if (ascii == 93)
                    {
                        cadena += (char)ascii;
                        tokens token = new tokens(cadena, "Cualquiera", 13);
                        cadena = "";
                        estado = 0;
                        Token.Add(token);
                    }
                    break;

                case 17:
                    if (ascii >= 48 && ascii <= 57)
                    {
                        cadena += (char)ascii;
                    }
                    else if (ascii == 32 || ascii == 58 || ascii == 59 || ascii == 123 || ascii == 125 || ascii == 126)
                    {
                        tokens token = new tokens(cadena, "Digito", 18);

                        cadena = "";
                        estado = 0;
                        Token.Add(token);

                        i--;
                    }
                    break;

                case 18:
                    if (ascii == 34)
                    {
                        cadena += (char)ascii;
                        tokens token = new tokens(cadena, "Cadena", 19);
                        cadena = "";
                        estado = 0;
                        Token.Add(token);
                    }
                    else
                    {
                        cadena += (char)ascii;
                    }
                    break;

                case 19:
                    if (ascii == 37)
                    {
                        cadena += (char)ascii;
                        tokens token = new tokens(cadena, "Porcentaje", 25);
                        cadena = "";
                        estado = 0;
                        Token.Add(token);
                    }

                    break;
                }
            }
            foreach (tokens tok in Token)
            {
                Console.WriteLine(tok.codigo + "|" + tok.lexema + "|" + tok.tipo + "|");
            }
        }
Beispiel #8
0
 public nodoP(tokens actual)
 {
     this.actual = actual;
 }
        public void ElegirOp(nodoP aux)
        {
            pila.Pop();
            nodoP b = aux;

            aux = pila.peek();
            if (aux.actual.codigo.Equals(8))
            {
                pila.Pop();
            }
            else if (aux.actual.codigo.Equals(9))
            {
            }
            else if (aux.actual.codigo.Equals(10))
            {
                //arbol.G0oUnaVez(b.actual);
                Graficar0oUnaVez(b.actual);
                if (pila.Pop() != false)
                {
                    tokens tokenP = new tokens(aux.actual, b.actual, inicial, final, 10);
                    //tokens tokenP = new tokens(arbol, arbol.eInicio, arbol.eFinal);
                    pila.Push(tokenP);
                }
            }
            else if (aux.actual.codigo.Equals(11))
            {
                //arbol.G1oMasVeces(b.actual);
                Graficar1oMasVeces(b.actual);
                if (pila.Pop() != false)
                {
                    tokens tokenP = new tokens(aux.actual, b.actual, inicial, final, 11);
                    //tokens tokenP = new tokens(arbol, arbol.eInicio, arbol.eFinal);
                    pila.Push(tokenP);
                }
            }
            else if (aux.actual.codigo.Equals(12))
            {
                //arbol.kleene(b.actual);
                GraficarKleene(b.actual);
                if (pila.Pop() != false)
                {
                    tokens tokenP = new tokens(aux.actual, b.actual, inicial, final, 12);
                    //tokens tokenP = new tokens(arbol, arbol.eInicio, arbol.eFinal);
                    pila.Push(tokenP);
                }
            }

            else if (aux.actual.codigo.Equals(28))
            {
                nodoP a = aux;
                pila.Pop();
                aux = pila.peek();
                if (aux.actual.codigo.Equals(8))
                {
                    //arbol.Disyuncion(a.actual, b.actual);
                    GraficarDisyuncion(a.actual, b.actual);
                    if (pila.Pop() != false)
                    {
                        tokens tokenP = new tokens(a.actual, b.actual, inicial, final, 8);
                        //tokens tokenP = new tokens(arbol, arbol.eInicio, arbol.eFinal);
                        pila.Push(tokenP);
                    }
                }
                else if (aux.actual.codigo.Equals(9))
                {
                    //arbol.Concatenacion(a.actual, b.actual);
                    GraficarConcatenacion(a.actual, b.actual);
                    if (pila.Pop() != false)
                    {
                        tokens tokenP = new tokens(a.actual, b.actual, inicial, final, 9);
                        //tokens tokenP = new tokens(arbol, arbol.eInicio, arbol.eFinal);
                        pila.Push(tokenP);
                    }
                }
                else if (aux.actual.codigo.Equals(11))
                {
                    //arbol.G1oMasVeces(a.actual);
                    Graficar1oMasVeces(a.actual);
                    if (pila.Pop() != false)
                    {
                        tokens tokenP = new tokens(a.actual, b.actual, inicial, final, 11);
                        //tokens tokenP = new tokens(arbol, arbol.eInicio, arbol.eFinal);
                        pila.Push(tokenP);
                    }
                }
                else if (aux.actual.codigo.Equals(10))
                {
                    //arbol.G0oUnaVez(a.actual);
                    Graficar0oUnaVez(a.actual);
                    if (pila.Pop() != false)
                    {
                        tokens tokenP = new tokens(aux.actual, a.actual, inicial, final, 10);
                        //tokens tokenP = new tokens(arbol, arbol.eInicio, arbol.eFinal);
                        pila.Push(tokenP);
                        pila.Push(b.actual);
                    }
                }
            }
            else if (aux.actual.codigo.Equals(19))
            {
                pila.Pop();
                nodoP c = aux;
                aux = pila.peek();
                Graph1(c.actual, b.actual);
            }
            else if (aux.actual.codigo.Equals(7))
            {
                pila.Pop();
                nodoP c = aux;
                aux = pila.peek();
                Graph1(c.actual, b.actual);
            }
        }
        public void Expresion()
        {
            actual = tokens.ElementAt(i);
            path   = actual.lexema + ".dot";
            file   = File.CreateText(path);
            file.WriteLine("digraph G{");
            file.WriteLine("node[shape=circle, style=filled, color= Gray70];");
            file.WriteLine("edge[color=black]");
            i++;
            actual = tokens.ElementAt(i);
            if (actual.codigo.Equals(27))
            {
                i++;
                actual = tokens.ElementAt(i);
                if (actual.codigo.Equals(26))
                {
                    //arbol = new Arbol(estado);
                    i++;
                    actual = tokens.ElementAt(i);
                    tokens Opaux = null;
                    while (actual.codigo != 16)
                    {
                        if (actual.tipo.Equals("Operacion"))
                        {
                            Opaux = actual;
                            pila.Push(actual);

                            i++;
                            actual = tokens.ElementAt(i);
                        }
                        else if (actual.codigo.Equals(14) || actual.codigo.Equals(15))
                        {
                            i++;
                            actual = tokens.ElementAt(i);
                        }
                        else
                        {
                            Graph(Opaux);
                            Opaux = null;
                            i++;

                            actual = tokens.ElementAt(i);
                        }
                        while (Verificar() == true)
                        {
                            nodoP auxiliar = pila.peek();
                            GraphnodoP(auxiliar);
                        }
                    }
                    while (pila.primero != null)
                    {
                        nodoP aux = pila.peek();
                        GraphnodoP(aux);
                    }
                    estado = 0;
                    file.WriteLine("}");
                    file.Close();
                    arbol.reporte(path);
                    i++;
                    actual = tokens.ElementAt(i);
                    while (actual.codigo.Equals(5) || actual.codigo.Equals(6))
                    {
                        i++;
                        actual = tokens.ElementAt(i);
                    }
                    if (actual.codigo.Equals(7))
                    {
                        Expresion();
                    }
                    while (actual.codigo.Equals(5) || actual.codigo.Equals(6))
                    {
                        i++;
                        actual = tokens.ElementAt(i);
                    }
                    ValidarExpresiones valExpr = new ValidarExpresiones(i, tokens, SIGNOS, conjuntos);
                    valExpr.Validar();
                }
            }
        }
        public void Graph(tokens Opaux)
        {
            nodoP aux = pila.peek();

            if (Opaux == null)
            {
                pila.Push(actual);
            }
            else if (Opaux.codigo.Equals(8))
            {
                if (aux.actual.tipo != "Operacion")
                {
                    //arbol.Disyuncion(aux.actual, actual);
                    GraficarDisyuncion(aux.actual, actual);
                    pila.Pop();
                    pila.Pop();
                    tokens tokenP = new tokens(aux.actual, actual, inicial, final, 8);

                    //tokens tokenP = new tokens(arbol, arbol.eInicio, arbol.eFinal);
                    pila.Push(tokenP);
                }
                else
                {
                    pila.Push(actual);
                }
            }
            else if (Opaux.codigo.Equals(9))
            {
                if (aux.actual.tipo != "Operacion")
                {
                    //arbol.Concatenacion(aux.actual, actual);
                    GraficarConcatenacion(aux.actual, actual);
                    pila.Pop();
                    pila.Pop();
                    tokens tokenP = new tokens(aux.actual, actual, inicial, final, 9);
                    //tokens tokenP = new tokens(arbol, arbol.eInicio, arbol.eFinal);
                    pila.Push(tokenP);
                }
                else
                {
                    pila.Push(actual);
                }
            }
            else if (Opaux.codigo.Equals(10))
            {
                pila.Pop();

                Graficar0oUnaVez(actual);
                tokens tokenP = new tokens(aux.actual, actual, inicial, final, 10);

                /*arbol.G0oUnaVez(actual);
                 * tokens tokenP = new tokens(arbol, arbol.eInicio, arbol.eFinal);*/
                pila.Push(tokenP);
            }
            else if (Opaux.codigo.Equals(11))
            {
                pila.Pop();
                //arbol.G1oMasVeces(actual);
                Graficar1oMasVeces(actual);
                tokens tokenP = new tokens(aux.actual, actual, inicial, final, 11);
                //tokens tokenP = new tokens(arbol, arbol.eInicio, arbol.eFinal);
                pila.Push(tokenP);
            }
            else if (Opaux.codigo.Equals(12))
            {
                pila.Pop();
                //arbol.kleene(actual);
                GraficarKleene(actual);
                tokens tokenP = new tokens(aux.actual, actual, inicial, final, 12);
                //tokens tokenP = new tokens(arbol, arbol.eInicio, arbol.eFinal);
                pila.Push(tokenP);
            }
        }