コード例 #1
0
        static void Main(string[] args)
        {
            #region Tokenizar
            string ElString = string.Empty;
            Expression AST = null;

            //Introducir datos
            Console.WriteLine("Por favor introduzca la operación a calcular :3\nUsted puede sumar y restar.");

            Console.Write("\nOperación: ");
            ElString = Console.ReadLine();
            Tokenizer(ConvertirInfixAPostfix(ElString));
            #endregion

            #region ConstruirAST
            Stack<Expression> LaPila = new Stack<Expression>();

            foreach (Token ElToken in LaLista)
            {
                //El token es numero o variable
                if (ElToken.Tipo == TipoToken.NUM || ElToken.Tipo == TipoToken.VAR)
                {
                    LaPila.Push(new UnaryExpression(ElToken));
                }

                //El token es operador o signo de igual
                else
                {
                    Expression Pop1 = LaPila.Pop();
                    Expression Pop2 = LaPila.Pop();
                    Expression NuevoArbol = new BinaryExpression(ElToken, Pop2, Pop1);
                    LaPila.Push(NuevoArbol);
                }
            }
            AST = LaPila.Pop();
            Console.WriteLine("\nEl resultado es: " + AST.eval());
            Console.ReadKey(true);
            #endregion
        }
コード例 #2
0
        static void Main(string[] args)
        {
            #region Tokenizar
            //Introducir datos
            Console.Write("Cadena: ");
            Tokenizer(Console.ReadLine());
            #endregion

            #region NFA
            foreach (var ElToken in LaLista)
            {
                CurrentString = new LinkedList<char>();
                foreach (var item in ElToken.Valor)
                {
                    CurrentString.AddLast(item);
                }
                //Estado 0: Estado inicial
                if (State == 0)
                {
                    handle_state0(CurrentString.First);
                }

                //Estado 1: Ciclo para verificar si es numerico
                if (State == 1)
                {
                    if (handle_state1(CurrentString))
                    {
                        LaLista.Find(ElToken).Value.Tipo = TipoToken.NUM;
                    }
                }

                //Estado 2: Verificar si es la f de un IF
                if (State == 2)
                {
                    if (handle_state2(CurrentString))
                    {
                        LaLista.Find(ElToken).Value.Tipo = TipoToken.IF;
                        State = 3;
                    }

                    else
                    {
                        State = 20;
                    }
                }

                //Estado 3: Verificar lo que sigue despues del IF
                if (State == 3)
                {
                    if (handle_state3(CurrentString) == 1)
                    {
                        LaLista.Find(ElToken).Value.Tipo = TipoToken.VAR;
                    }

                    else if (handle_state3(CurrentString) == 2)
                    {
                        LaLista.Find(ElToken).Value.Tipo = TipoToken.NULL;
                    }
                }

                //Estado 4: Verificar si es la h de un WHILE
                if (State == 4)
                {
                    if (handle_state4(CurrentString))
                    {
                        State = 5;
                    }
                }

                //Estado 5: Verificar si es la i de un WHILE
                if (State == 5)
                {
                    if (handle_state5(CurrentString))
                    {
                        State = 6;
                    }
                }

                //Estado 6: Verificar si es la l de un WHILE
                if (State == 6)
                {
                    if (handle_state6(CurrentString))
                    {
                        State = 7;
                    }
                }

                //Estado 7: Verificar si es la e de un WHILE
                if (State == 7)
                {
                    if (handle_state7(CurrentString))
                    {
                        LaLista.Find(ElToken).Value.Tipo = TipoToken.WHILE;
                        State = 8;
                    }

                    else
                    {
                        State = 20;
                    }
                }

                //Estado 8: Verificar lo que sigue despues del WHILE
                if (State == 8)
                {
                    if (handle_state8(CurrentString) == 1)
                    {
                        LaLista.Find(ElToken).Value.Tipo = TipoToken.VAR;
                    }

                    else if (handle_state8(CurrentString) == 2)
                    {
                        LaLista.Find(ElToken).Value.Tipo = TipoToken.NULL;
                    }
                }

                //Estado 9: Verificar si es la l de un ELSE
                if (State == 9)
                {
                    if (handle_state9(CurrentString))
                    {
                        State = 10;
                    }
                }

                //Estado 10: Verificar si es la s de un ELSE
                if (State == 10)
                {
                    if (handle_state10(CurrentString))
                    {
                        State = 11;
                    }
                }

                //Estado 11: Verificar si es la e de un ELSE
                if (State == 11)
                {
                    if (handle_state11(CurrentString))
                    {
                        LaLista.Find(ElToken).Value.Tipo = TipoToken.ELSE;
                        State = 12;
                    }

                    else
                    {
                        State = 20;
                    }
                }

                //Estado 12: Verificar lo que sigue despues del ELSE
                if (State == 12)
                {
                    if (handle_state12(CurrentString) == 1)
                    {
                        LaLista.Find(ElToken).Value.Tipo = TipoToken.VAR;
                    }

                    else if (handle_state12(CurrentString) == 2)
                    {
                        LaLista.Find(ElToken).Value.Tipo = TipoToken.NULL;
                    }
                }

                //Estado 13: Verificar lo que sigue despues de un operador + - * /
                if (State == 13)
                {
                    if (handle_state13(CurrentString))
                    {
                        LaLista.Find(ElToken).Value.Tipo = TipoToken.OP;
                    }
                }

                //Estado 14: Verificar lo que sigue despues de un simbolo de =
                if (State == 14)
                {
                    if (handle_state14(CurrentString))
                    {
                        LaLista.Find(ElToken).Value.Tipo = TipoToken.ASSIGN;
                    }
                }

                //Estado 15: Verificar lo que sigue despues de un simbolo de abrir parentesis
                if (State == 15)
                {
                    if (handle_state15(CurrentString))
                    {
                        LaLista.Find(ElToken).Value.Tipo = TipoToken.OPEN_PARENS;
                    }
                }

                //Estado 16: Verificar lo que sigue despues de un simbolo de cerrar parentesis
                if (State == 16)
                {
                    if (handle_state16(CurrentString))
                    {
                        LaLista.Find(ElToken).Value.Tipo = TipoToken.CLOSE_PARENS;
                    }
                }

                //Estado 17: Verificar lo que sigue despues de un simbolo de menor que
                if (State == 17)
                {
                    if (handle_state17(CurrentString))
                    {
                        LaLista.Find(ElToken).Value.Tipo = TipoToken.LTHAN;
                    }
                }

                //Estado 18: Verificar lo que sigue despues de un simbolo de mayor que
                if (State == 18)
                {
                    if (handle_state18(CurrentString))
                    {
                        LaLista.Find(ElToken).Value.Tipo = TipoToken.GTHAN;
                    }
                }

                //Estado 19: Verificar lo que sigue despues de un simbolo de comparacion
                if (State == 19)
                {
                    if (handle_state18(CurrentString))
                    {
                        LaLista.Find(ElToken).Value.Tipo = TipoToken.COMPARSION;
                    }
                }

                //Estado 20: Verificar lo que sigue despues de un simbolo alfanumerico excepto i, w o e
                if (State == 20)
                {
                    if (handle_state20(CurrentString))
                    {
                        LaLista.Find(ElToken).Value.Tipo = TipoToken.VAR;
                    }
                }

                //Estado 21: Verificar lo que sigue despues de un simbolo de abrir llaves
                if (State == 21)
                {
                    if (handle_state15(CurrentString))
                    {
                        LaLista.Find(ElToken).Value.Tipo = TipoToken.OPEN_BRACES;
                    }
                }

                //Estado 22: Verificar lo que sigue despues de un simbolo de cerrar llaves
                if (State == 22)
                {
                    if (handle_state16(CurrentString))
                    {
                        LaLista.Find(ElToken).Value.Tipo = TipoToken.CLOSE_BRACES;
                    }
                }

                State = 0;
            }
            #endregion

            #region ConstruirAST
            Stack<Expression> LaPila = new Stack<Expression>();

            foreach (Token ElToken in LaLista)
            {
                //El token es numero
                if (ElToken.Tipo == TipoToken.NUM || ElToken.Tipo == TipoToken.VAR)
                {
                    LaPila.Push(new UnaryExpression(ElToken));
                }

                //El token es operador
                else
                {
                    Expression Pop1 = LaPila.Pop();
                    Expression Pop2 = LaPila.Pop();
                    Expression NuevoArbol = new BinaryExpression(ElToken, Pop2, Pop1);
                    LaPila.Push(NuevoArbol);
                }
            }
            AST = LaPila.Pop();
            Console.WriteLine("\nEl resultado es: " + AST.eval());
            Console.ReadKey(true);
            #endregion
        }
コード例 #3
0
ファイル: Program.cs プロジェクト: JavierTMC/Compiladores
        static void Main(string[] args)
        {
            Console.WriteLine("Calculador Postfix");

            string input = string.Empty;
            //Introducir datos
            Console.Write("\nOperación: ");
            input = Console.ReadLine();

            Tokenizer(input);

            string postfix = expr().Replace(" ", string.Empty);
            LaLista.Clear();

            Tokenizer(postfix);

            #region ConstruirAST
            Expression AST = null;

            Stack<Expression> LaPila = new Stack<Expression>();

            foreach (Token ElToken in LaLista)
            {
                //El token es numero
                if (ElToken.Tipo == TipoToken.NUM)
                {
                    LaPila.Push(new UnaryExpression(ElToken));
                }

                //El token es operador
                else if (ElToken.Tipo == TipoToken.OP)
                {
                    Expression Pop1 = LaPila.Pop();
                    Expression Pop2 = LaPila.Pop();
                    Expression NuevoArbol = new BinaryExpression(ElToken, Pop2, Pop1);
                    LaPila.Push(NuevoArbol);
                }
            }
            AST = LaPila.Pop();
            Console.WriteLine("\nEl resultado es: " + AST.eval());
            #endregion

            Console.ReadKey(true);
        }