NodeLR GetTerm()
    {
        NodeLR factor = GetFactor();

        //if(tokenList[index].tokenType != TokenType.MULT || tokenList[index].tokenType != TokenType.REAL_DIV)
        // Advance();
        if (tokenList[index].tokenType.Equals(TokenType.MULT))
        {
            NodeLR mult = new NodeLR(factor, TokenType.MULT, GetTerm());
            mult.OperateLeftRight();
            return(mult);
        }
        else if (tokenList[index].tokenType.Equals(TokenType.REAL_DIV))
        {
            NodeLR div = new NodeLR(factor, TokenType.REAL_DIV, GetTerm());
            div.OperateLeftRight();
            return(div);
        }
        else if (tokenList[index].tokenType.Equals(TokenType.LPAR))
        {
            NodeLR div = new NodeLR(factor, TokenType.MULT, GetExpretion());
            div.OperateLeftRight();
            return(div);
        }

        return(factor);
    }
    /// <summary>
    /// Obtener la expresión que se encuentra dentro de una línea de texto, dicha expresión nos permitirá asignarle un valor a una variable global
    /// </summary>
    /// <returns></returns>
    NodeLR GetExpretion()
    {
        NodeLR term = null;

        while (tokenList[index].tokenType != TokenType.SEMI && tokenList[index].tokenType != TokenType.RPAR)
        {
            term = GetTerm();
            //if(tokenList[index].tokenType != TokenType.PLUS || tokenList[index].tokenType != TokenType.MINUS)
            //    Advance();
            if (tokenList[index].tokenType.Equals(TokenType.PLUS))
            {
                NodeLR add = new NodeLR(term, TokenType.PLUS, GetExpretion());
                add.OperateLeftRight();
                return(add);
            }
            else if (tokenList[index].tokenType.Equals(TokenType.MINUS))
            {
                NodeLR resta = new NodeLR(term, TokenType.MINUS, GetExpretion());
                resta.OperateLeftRight();
                return(resta);
            }
            //Advance();
        }
        return(term);
    }
    /// <summary>
    /// Se asignan valores a las variables que se encuentran dentro de las variables globales
    /// </summary>
    void Assign()
    {
        ///Avanzar hasta que sea diferente de end, por lo que esta sección se terminaría
        while (tokenList[index].tokenType != TokenType.END)
        {
            if (tokenList[index].tokenType != TokenType.ID)
            {
                Advance();
            }

            if (tokenList[index].tokenType.Equals(TokenType.ID))
            {
                Variables var = GetVariableFromList(tokenList[index].lexeme);
                if (tokenList[index].tokenType != TokenType.ASSIGN)
                {
                    Advance();
                }
                if (tokenList[index].tokenType.Equals(TokenType.ASSIGN))
                {
                    NodeLR nlr = GetExpretion();
                    var.SetValue(nlr.value);
                    ChangeVariableFromList(var);
                }
            }
            else
            {
            }

            ///Crear nodos donde se pregunta si el elemento actual es un número o un signo de operación binaria / unaria
        }
    }
    /// <summary>
    /// Obtenemos todas las variables que se encuentran dentro de la sección de VARS
    /// </summary>
    void GetVars()
    {
        ///Se crea una lista de ids para que así se puedan crear nodos dependiendo del nombre y tipo
        List <string> ids = new List <string>();

        ///Avanzamos hasta que dejen de haber variables en esta línea del texto
        while (tokenList[index].tokenType == TokenType.ID)
        {
            ids.Add(tokenList[index].lexeme); ///Se añaden a la lista de strings
            Advance();                        //Avanza uno el index
        }

        ///Si el elemento actual dentro de la lista de tokens es igual a un entero, entra aquí
        if (tokenList[index].tokenType.Equals(TokenType.INTEGER))
        {
            ///Por cada uno de los strings dentro de la lista de strings, avanza
            foreach (string id in ids)
            {
                ///Crea una variable de entero con el nombre de este string y con tipo entero
                VariablesInt vI = new VariablesInt(id, TokenType.INTEGER);

                ///Cre un nuevo nodo con esta variable
                NodeLR nodo = new NodeLR(vI);

                ///Añade este nodo a las variables globales
                VARIABLES.Add(vI);
            }
        }
        else if (tokenList[index].tokenType.Equals(TokenType.REAL))
        { ///El elemento actual es un número real
            ///Por cada uno de los strings, avanza
            foreach (string id in ids)
            {
                ///Crea una variable flotante con este string
                VariablesFloat vI = new VariablesFloat(id, TokenType.REAL);

                ///Crea un nodo con esta variable
                NodeLR nodo = new NodeLR(vI);

                VARIABLES.Add(vI); ///Añade esta variable a las variables globales
            }
        }
        ids.Clear(); ///Libera la lista de strings

        Advance();
    }
    /// <summary>
    /// Se crea un nodo que regresa un entero o flotante y si hay un paréntesis, crea un while hasta que se cierre el paréntesis
    /// </summary>
    /// <returns></returns>
    NodeLR GetFactor()
    {
        NodeLR toReturn = null;

        Advance();
        if (tokenList[index].tokenType != TokenType.LPAR /*&& tokenList[index].tokenType != TokenType.RPAR*/)
        {
            //toReturn = CheckUnarySigns();
            return(CheckUnarySigns());
        }
        else
        {
            toReturn = GetExpretion();
            Advance();
            //return GetExpretion();
        }

        return(toReturn);
    }
 /// <summary>
 /// Obtiene un nodo en la parte izquierda, un token y un nodo a la derecha. Dependiendo del token se puede realizar: suma, resta, multiplicación o división
 /// </summary>
 /// <param name="left"></param>
 /// <param name="type"></param>
 /// <param name="right"></param>
 public NodeLR(NodeLR left, TokenType type, NodeLR right)
 {
     this.left  = left;
     this.token = type;
     this.right = right;
 }