Exemple #1
0
        /// <summary>
        ///  Ejecuta el diagrama de transicion de estados para reconocer solamente
        /// Numeros Notacion Cientifica Normalizada
        /// </summary>
        /// <param name="parCadEntrada">Cadena de entrada dada por el usuario</param>
        /// <param name="parCar">Caracter de entrada al diagrama de transicion</param>
        /// <param name="iAm">Apuntador Movil</param>
        /// <returns>TRUE si logra una concordancia, FALSE en caso contrario</returns>
        public bool IsNumNotacionCientificaNormalizada(string parCadEntrada, char parCar, ref int iAm)
        {
            char   cCar        = parCar;
            string sCadEntrada = parCadEntrada;

            CAnalizadorLexico objAnalizadorLexico = new CAnalizadorLexico();

            int  iEstado      = 1;
            bool bError       = false;
            bool bEstadoFinal = false;

            while (!bEstadoFinal)
            {
                switch (iEstado)
                {
                case 1:
                    if (cCar == '0')
                    {
                        iEstado = 2;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else
                    {
                        bError       = true;
                        bEstadoFinal = true;
                    }
                    break;

                case 2:
                    if (cCar == '.')
                    {
                        iEstado = 3;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else
                    {
                        bError       = true;
                        bEstadoFinal = true;
                    }
                    break;

                case 3:
                    if (IsDigito(cCar) == true)
                    {
                        iEstado = 4;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else
                    {
                        bError       = true;
                        bEstadoFinal = true;
                    }
                    break;

                case 4:
                    if (IsDigito(cCar) == true)
                    {
                        iEstado = 4;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else if (cCar == 'e' || cCar == 'E')
                    {
                        iEstado = 6;
                    }
                    else
                    {
                        bError       = true;
                        bEstadoFinal = true;
                    }
                    break;

                case 6:
                    if (cCar == '+' || cCar == '-')
                    {
                        iEstado = 7;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else if (IsDigito(cCar) == true)
                    {
                        iEstado = 8;
                    }
                    else
                    {
                        bError       = true;
                        bEstadoFinal = true;
                    }
                    break;

                case 7:
                    if (IsDigito(cCar) == true)
                    {
                        iEstado = 8;
                    }
                    else
                    {
                        bError       = true;
                        bEstadoFinal = true;
                    }
                    break;

                case 8:
                    if (IsDigito(cCar) == true)
                    {
                        iEstado = 8;
                    }
                    else
                    {
                        iEstado = 9;
                    }
                    break;

                case 9:
                    bEstadoFinal = true;
                    break;

                default:
                    break;
                }
            }            //Fin while

            if (bError == false)
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
Exemple #2
0
        public string analizadorLexico()
        {
            int    iAm           = 0;
            int    iAf           = 0;
            bool   bConcordancia = false;
            string sCadEntrada   = this.txtCadena.Text;
            string sLexema       = string.Empty;
            string sToken        = string.Empty;
            string sRes          = string.Empty;
            string sRes2         = string.Empty;

            CBuscarConcordancia objCBuscarConcordancia = new CBuscarConcordancia();
            CAnalizadorLexico   objAnalizadorLexico    = new CAnalizadorLexico();

            lstvInfo.Items.Clear();

            if (this.txtCadena.Text != string.Empty)
            {
                while (sRes != "EOF")
                {
                    bConcordancia = objAnalizadorLexico.buscarConcordancia(sCadEntrada + "\x0", ref iAf, ref iAm, out sRes, out sRes2);

                    if (bConcordancia)
                    {
                        sLexema = string.Empty;
                        sLexema = CAnalizadorLexico.extraerLexema(sCadEntrada, ref iAf, ref iAm);

                        switch (sRes)
                        {
                        //Token Lexema Numeros
                        case "Numero":
                            sToken = objAnalizadorLexico.tokenLexema(sLexema, sRes, sRes2, "Numeros");
                            break;

                        //Token Lexema Identificador
                        case "Identificador":
                            sToken = objAnalizadorLexico.tokenLexema(sLexema, "Identificador");
                            break;

                        default:
                            sToken = "";
                            break;
                        }

                        if (sToken == string.Empty)
                        {
                            sToken = objAnalizadorLexico.tokenLexema(sCadEntrada, sLexema, ref iAf, ref iAm);
                            //Token de un Simbolo Reconocido
                            mostrarTokenLexema(lstvInfo, sLexema, sToken);
                        }
                        else
                        {
                            //Token de un Simbolo Reconocido
                            mostrarTokenLexema(lstvInfo, sLexema, sToken);
                        }
                        bConcordancia = true;
                        iAf           = iAm;              //Igualar la posicion de los dos apuntadores
                    }
                    else
                    {
                    }
                }                //Fin While

                //Regresar Token Fin de Archivo
                mostrarTokenLexema(lstvInfo, "EOF", "(0,0)");
            }
            else
            {
                MessageBox.Show("Cadena Vacia intentelo otra vez");
            }

            sToken = "Cadena Vacia";
            return(sToken);
        }
Exemple #3
0
        /// <summary>
        /// Ejecuta el diagrama de transicion correspondiente para identificar
        /// Numeros Enteros, Numeros Reales o Exp. Cientifica
        /// <param name="parCar">Caracter de entrada al diagrama de transicion</param>
        /// <param name="parAf">Apuntador Fijo</param>
        /// <param name="parAm">Apuntador Movil</param>
        /// <returns>True si encutra un estado terminal, False en caso contrario</returns>
        public bool IsNumero(string parCadEntrada, char parCar, ref int iAm, out string sRes)
        {
            char   cCar        = parCar;
            string sCadEntrada = parCadEntrada;

            sRes = string.Empty;

            CAnalizadorLexico objAnalizadorLexico = new CAnalizadorLexico();

            int  iEstado      = 0;
            bool bError       = false;
            bool bEstadoFinal = false;


            while (!bEstadoFinal)
            {
                switch (iEstado)
                {
                case 0:
                    if (IsDigito(cCar) == true)
                    {
                        iEstado = 1;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else
                    {
                        bError       = true;
                        bEstadoFinal = true;
                    }
                    break;

                case 1:
                    if (IsDigito(cCar) == true)
                    {
                        iEstado = 1;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else if (cCar == '.')
                    {
                        iEstado = 3;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else
                    {
                        iEstado = 2;
                    }
                    break;

                case 2:
                    bEstadoFinal = true;
                    sRes         = "NumEntero";
                    break;

                case 3:
                    if (IsDigito(cCar) == true)
                    {
                        iEstado = 4;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else
                    {
                        bError       = true;
                        bEstadoFinal = true;
                    }
                    break;

                case 4:
                    if (IsDigito(cCar) == true)
                    {
                        iEstado = 4;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else if (cCar == 'e' || cCar == 'E')
                    {
                        iEstado = 6;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else
                    {
                        iEstado = 5;
                    }
                    break;

                case 5:
                    bEstadoFinal = true;
                    sRes         = "NumReal";
                    break;

                case 6:
                    if (cCar == '+' || cCar == '-')
                    {
                        iEstado = 7;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else if (IsDigito(cCar) == true)
                    {
                        iEstado = 8;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else
                    {
                        bError       = true;
                        bEstadoFinal = true;
                    }
                    break;

                case 7:
                    if (IsDigito(cCar) == true)
                    {
                        iEstado = 8;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else
                    {
                        bError       = true;
                        bEstadoFinal = true;
                    }
                    break;

                case 8:
                    if (IsDigito(cCar) == true)
                    {
                        iEstado = 8;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else
                    {
                        iEstado = 9;
                    }
                    break;

                case 9:
                    bEstadoFinal = true;
                    sRes         = "NumExpCientifica";
                    break;

                default:
                    break;
                }
            }            //Fin while

            if (bError == false)
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
Exemple #4
0
        /// <summary>
        /// Ejecuta el diagrama de transicion de estados para reconocer solamente
        /// Numeros Reales
        /// </summary>
        /// <param name="parCadEntrada">Cadena de entrada dada por el usuario</param>
        /// <param name="parCar">Caracter de entrada al diagrama de transicion</param>
        /// <param name="iAf">Apuntador Fijo</param>
        /// <param name="iAm">Apuntador Movil</param>
        /// <returns>TRUE si logra una concordancia, FALSE en caso contrario</returns>
        public bool IsNumReal(string parCadEntrada, char parCar, ref int iAf, ref int iAm)
        {
            char   cCar        = parCar;
            string sCadEntrada = parCadEntrada;

            CAnalizadorLexico objAnalizadorLexico = new CAnalizadorLexico();

            int  iEstado      = 1;
            bool bError       = false;
            bool bEstadoFinal = false;

            while (!bEstadoFinal)
            {
                switch (iEstado)
                {
                case 1:
                    if (cCar == '.')
                    {
                        iEstado = 3;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else
                    {
                        bError       = true;
                        bEstadoFinal = true;
                    }
                    break;

                case 3:
                    if (IsDigito(cCar) == true)
                    {
                        iEstado = 4;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else
                    {
                        bError       = true;
                        bEstadoFinal = true;
                    }
                    break;

                case 4:
                    if (IsDigito(cCar) == true)
                    {
                        iEstado = 4;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else if (cCar == 'e' || cCar == 'E')
                    {
                        cCar         = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                        bEstadoFinal = true;
                        bError       = true;
                    }
                    else
                    {
                        iEstado = 5;
                    }
                    break;

                case 5:
                    bEstadoFinal = true;
                    break;

                default:
                    break;
                }
            }

            if (bError == false)
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
Exemple #5
0
        /// <summary>
        /// Ejecuta el diagrama de transicion correspondiente para identificar
        /// Operadores Aritmeticos
        /// <param name="parCar">Caracter de entrada al diagrama de transicion</param>
        /// <param name="parAf">Apuntador Fijo</param>
        /// <param name="parAm">Apuntador Movil</param>
        /// <returns>True su encutra una concordancia, False en caso contrario</returns>
        public bool IsEstadoTerminalOpAritmetico(string parCadEntrada, char parCar, ref int iAf, ref int iAm)
        {
            char   cCar        = parCar;
            string sCadEntrada = parCadEntrada;

            CAnalizadorLexico objAnalizadorLexico = new CAnalizadorLexico();

            int  iEstado      = 1;
            bool bError       = false;
            bool bEstadoFinal = false;

            while (!bEstadoFinal)
            {
                switch (iEstado)
                {
                case 1:
                    if (cCar == '*' || cCar == '/')
                    {
                        iEstado = 2;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else if (cCar == '+')
                    {
                        iEstado = 5;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else if (cCar == '-')
                    {
                        iEstado = 7;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else
                    {
                        bError       = true;
                        bEstadoFinal = true;
                    }
                    break;

                case 2:
                    if (cCar == '=')
                    {
                        iEstado = 4;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else
                    {
                        iEstado = 3;
                    }
                    break;

                case 3:
                    bEstadoFinal = true;
                    break;

                case 4:
                    bEstadoFinal = true;
                    break;

                case 5:
                    if (cCar == '=')
                    {
                        iEstado = 11;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else if (cCar == '+')
                    {
                        iEstado = 6;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else
                    {
                        iEstado = 10;
                    }
                    break;

                case 6:
                    bEstadoFinal = true;
                    break;

                case 7:
                    if (cCar == '-')
                    {
                        iEstado = 8;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else if (cCar == '=')
                    {
                        iEstado = 12;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else
                    {
                        iEstado = 9;
                    }
                    break;

                case 8:
                    bEstadoFinal = true;
                    break;

                case 9:
                    bEstadoFinal = true;
                    break;

                case 10:
                    bEstadoFinal = true;
                    break;

                case 11:
                    bEstadoFinal = true;
                    break;

                case 12:
                    bEstadoFinal = true;
                    break;

                default:
                    break;
                }        //switch
            }            //Fin while

            if (bError == false)
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
Exemple #6
0
        /// <summary>
        /// Ejecuta el diagrama de transicion correspondiente para identificar
        /// Palabras Reservadas o Identificadores
        /// </summary>
        /// <param name="parCar">Caracter de entrada al diagrama de transicion</param>
        /// <param name="parAf">Apuntador Fijo</param>
        /// <param name="parAm">Apuntador Movil</param>
        /// <returns>True si encuetra una concordancia, False en caso contrario</returns>
        public bool IsEstadoTerminalPalabraReservada(string parCadEntrada, char parCar, ref int iAm)
        {
            char   cCar        = parCar;
            string sCadEntrada = parCadEntrada;

            CAnalizadorLexico objAnalizadorLexico = new CAnalizadorLexico();

            int  iEstado      = 0;
            bool bError       = false;
            bool bEstadoFinal = false;
            CBuscarConcordancia objCBuscarConcordancia = new CBuscarConcordancia();

            while (!bEstadoFinal)
            {
                switch (iEstado)
                {
                case 0:
                    if (objCBuscarConcordancia.IsCaracterMin(cCar) == true)
                    {
                        iEstado = 1;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else if (objCBuscarConcordancia.IsCaracterMay(cCar) == true)
                    {
                        iEstado = 2;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else
                    {
                        bError       = true;
                        bEstadoFinal = true;
                    }
                    break;

                case 1:
                    if (objCBuscarConcordancia.IsCaracterMin(cCar) == true)
                    {
                        iEstado = 1;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else if (IsDigito(cCar) == true)
                    {
                        iEstado = 2;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else if (objCBuscarConcordancia.IsCaracterMay(cCar) == true)
                    {
                        iEstado = 2;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else
                    {
                        iEstado = 4;
                    }
                    break;

                case 2:
                    if (IsDigito(cCar) == true)
                    {
                        iEstado = 2;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else if (objCBuscarConcordancia.IsCaracterMin(cCar) == true)
                    {
                        iEstado = 2;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else if (objCBuscarConcordancia.IsCaracterMay(cCar) == true)
                    {
                        iEstado = 2;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else
                    {
                        iEstado = 3;
                    }
                    break;

                case 3:
                    bEstadoFinal = true;
                    break;

                case 4:
                    bEstadoFinal = true;
                    break;

                default:
                    break;
                }
            }            //Fin while

            if (bError == false)
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
Exemple #7
0
        /// <summary>
        /// Metodo que implemente el diagrama de trancision de estados para
        /// identificar Operadores Relacionales
        /// </summary>
        /// <param name="parCar">Caracter de entrada al diagrama</param>
        /// <param name="Af">Apuntador Fijo</param>
        /// <param name="Am">Apuntador Movil</param>
        ///<returns>True si encutra un estado terminal, False en caso contrario</returns>
        public bool IsEstadoTerminalOpRelacional(string parCadEntrada, char parCar, ref int iAf, ref int iAm)
        {
            char   cCar        = parCar;
            string sCadEntrada = parCadEntrada;

            CAnalizadorLexico objAnalizadorLexico = new CAnalizadorLexico();

            int  iEstado      = 0;
            bool bError       = false;
            bool bEstadoFinal = false;

            while (!bEstadoFinal)
            {
                switch (iEstado)
                {
                case 0:
                    if (cCar == '>' || cCar == '<')
                    {
                        iEstado = 1;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else if (cCar == '=')
                    {
                        iEstado = 5;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else if (cCar == '!')
                    {
                        iEstado = 3;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else
                    {
                        bError       = true;
                        bEstadoFinal = true;
                    }
                    break;

                case 1:
                    if (cCar == '=')
                    {
                        iEstado = 2;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else
                    {
                        iEstado = 7;
                    }
                    break;

                case 2:
                    bEstadoFinal = true;
                    break;

                case 3:
                    if (cCar == '=')
                    {
                        iEstado = 4;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else
                    {
                        bError       = true;
                        bEstadoFinal = true;
                        CAnalizadorLexico.retrocedeApuntador(ref cCar, sCadEntrada, ref iAm);
                    }
                    break;

                case 4:
                    bEstadoFinal = true;
                    break;

                case 5:
                    if (cCar == '=')
                    {
                        iEstado = 6;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else
                    {
                        bError       = true;
                        bEstadoFinal = true;
                        CAnalizadorLexico.retrocedeApuntador(ref cCar, sCadEntrada, ref iAm);
                    }
                    break;

                case 6:
                    bEstadoFinal = true;
                    break;

                case 7:
                    bEstadoFinal = true;
                    break;

                default:
                    break;
                }
            }            //Fin while

            if (bError == false)
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
Exemple #8
0
        /// <summary>
        /// Ejecuta el diagrama de transicion correspondiente para identificar
        /// Operadores Logicos
        /// <param name="parCar">Caracter de entrada al diagrama de transicion</param>
        /// <param name="parAf">Apuntador Fijo</param>
        /// <param name="parAm">Apuntador Movil</param>
        /// <returns>True si encutra un estado terminal, False en caso contrario</returns>
        public bool IsEstadoTerminalOpLogico(string parCadEntrada, char parCar, ref int iAf, ref int iAm)
        {
            char   cCar        = parCar;
            string sCadEntrada = parCadEntrada;

            CAnalizadorLexico objAnalizadorLexico = new CAnalizadorLexico();

            int  iEstado      = 0;
            bool bError       = false;
            bool bEstadoFinal = false;

            while (!bEstadoFinal)
            {
                switch (iEstado)
                {
                case 0:
                    if (cCar == '&')
                    {
                        iEstado = 1;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else if (cCar == '|')
                    {
                        iEstado = 2;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else if (cCar == '!')
                    {
                        iEstado = 3;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else
                    {
                        bError       = true;
                        bEstadoFinal = true;
                    }
                    break;

                case 1:
                    if (cCar == '&')
                    {
                        iEstado = 4;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else
                    {
                        iEstado = 4;
                    }
                    break;

                case 2:
                    if (cCar == '|')
                    {
                        iEstado = 5;
                        cCar    = objAnalizadorLexico.sgteCar(sCadEntrada, ref iAm);
                    }
                    else
                    {
                        iEstado = 5;
                    }
                    break;

                case 3:
                    bEstadoFinal = true;
                    break;

                case 4:
                    bEstadoFinal = true;
                    break;

                case 5:
                    bEstadoFinal = true;
                    break;

                default:
                    break;
                }
            }            //Fin while

            if (bError == false)
            {
                return(true);
            }
            else
            {
                return(false);
            }
        }
Exemple #9
0
        /// <summary>
        /// Identifica cual es el patron de concordancia con el que encaja la cadena leida
        /// de la cadena de entrada
        /// </summary>
        /// <param name="parCadena">Cadena de Entrada proporcionada por el usuario</param>
        /// <param name="iAf">Apuntador Fijo en la cadena de entrada</param>
        /// <param name="iAm">Apuntador Movil en la cadena de entrada</param>
        /// <param name="sRes">Variable de control entre funciones</param>
        /// <param name="sRes2">Variable de control entre funciones</param>
        /// <returns>True si encontro una concordancia, FALSE en caso contrario</returns>
        public bool buscarConcordancia(string parCadena, ref int iAf, ref int iAm, out string sRes, out string sRes2)
        {
            string sCadena       = parCadena;
            string sLexema       = string.Empty;
            bool   bConcordancia = false;

            sRes  = string.Empty;
            sRes2 = string.Empty;
            char cCar = sCadena[iAm];

            CBuscarConcordancia objCBuscarConcordancia = new CBuscarConcordancia();
            CAnalizadorLexico   objCAnalizadorLexico   = new CAnalizadorLexico();

            //Espacios
            if (cCar == ' ')
            {
                cCar          = objCAnalizadorLexico.sgteCar(sCadena, ref iAm);
                bConcordancia = true;
            }            //Identificadores,Palabras Reservadas
            else if (objCBuscarConcordancia.IsEstadoTerminalPalabraReservada(sCadena, cCar, ref iAm) == true)
            {
                sLexema = CAnalizadorLexico.extraerLexema(sCadena, ref iAf, ref iAm);
                if (objCBuscarConcordancia.IsPalabraReservada(sLexema) == false)
                {
                    //Verificar si el Identificador ya existe para no agregarlo
                    if (objCBuscarConcordancia.IsExistsIdentificador(sLexema) == true)
                    {
                        sRes = "Identificador";
                    }                    //Identificador Nuevo
                    else
                    {
                        CCompoLex.iIdentificador.Add(sLexema);
                        sRes = "Identificador";
                    }
                }
                bConcordancia = true;
            }
            else if (objCBuscarConcordancia.IsNumero(sCadena, cCar, ref iAm, out sRes))
            {
                switch (sRes)
                {
                case "NumEntero":
                    bConcordancia = true;
                    //Agregar simbolo a la tabla
                    sLexema = extraerLexema(sCadena, ref iAf, ref iAm);
                    CCompoLex.NumerosEnteros.Add(sLexema);
                    sRes  = "Numero";
                    sRes2 = "Entero";
                    break;

                case "NumReal":
                    bConcordancia = true;
                    //Agregar simbolo a la tabla
                    sLexema = extraerLexema(sCadena, ref iAf, ref iAm);
                    CCompoLex.NumerosFlotantes.Add(sLexema);
                    sRes  = "Numero";
                    sRes2 = "Real";
                    break;

                case "NumExpCientifica":
                    bConcordancia = true;
                    //Agregar simbolo a la tabla
                    sLexema = extraerLexema(sCadena, ref iAf, ref iAm);
                    CCompoLex.NumerosNotacionCientifica.Add(sLexema);
                    sRes  = "Numero";
                    sRes2 = "NotacionCientifica";
                    break;

                default:
                    sRes  = "";
                    sRes2 = "";
                    break;
                }
            }
            //Operador Aritmetico
            else if (objCBuscarConcordancia.IsEstadoTerminalOpAritmetico(sCadena, cCar, ref iAf, ref iAm) == true)
            {
                bConcordancia = true;
            }            //Operador Logico
            else if (objCBuscarConcordancia.IsEstadoTerminalOpLogico(sCadena, cCar, ref iAf, ref iAm) == true)
            {
                bConcordancia = true;
            }            //Operador Relacional
            else if (objCBuscarConcordancia.IsEstadoTerminalOpRelacional(sCadena, cCar, ref iAf, ref iAm) == true)
            {
                bConcordancia = true;
            }            //Operador Asignacion
            else if (objCBuscarConcordancia.IsopAsignacion(cCar) == true)
            {
                bConcordancia = true;
                cCar          = objCAnalizadorLexico.sgteCar(sCadena, ref iAm);
            }            //Parentesis Circular
            else if (objCBuscarConcordancia.IsParentesisCircular(cCar) == true)
            {
                bConcordancia = true;
                cCar          = objCAnalizadorLexico.sgteCar(sCadena, ref iAm);
            }            //Parentesis Cuadrado
            else if (objCBuscarConcordancia.IsParentesisCuadrado(cCar) == true)
            {
                bConcordancia = true;
                cCar          = objCAnalizadorLexico.sgteCar(sCadena, ref iAm);
            }            //Llaves
            else if (objCBuscarConcordancia.IsLlaves(cCar) == true)
            {
                bConcordancia = true;
                cCar          = objCAnalizadorLexico.sgteCar(sCadena, ref iAm);
            }            //Algun otro caracter especial
            else if (objCBuscarConcordancia.IsCaracterEspecial(cCar))
            {
                bConcordancia = true;
                cCar          = objCAnalizadorLexico.sgteCar(sCadena, ref iAm);
            }            //Fin de Linea
            else if (cCar == '\n')
            {
                bConcordancia = true;
                cCar          = objCAnalizadorLexico.sgteCar(sCadena, ref iAm);
            }            //Fin de Archivo
            else if (cCar == '\x0')
            {
                bConcordancia = false;
                sRes          = "EOF";
            }            //Simbolo no reconocido
            else
            {
                bConcordancia = true;
                cCar          = objCAnalizadorLexico.sgteCar(sCadena, ref iAm);
            }
            return(bConcordancia);
        }