public ComponenteLexico Analizar()
        {
            ComponenteLexico componenteLexico = new ComponenteLexico();

            LimpiarLexema();
            int  estadoActual      = 0;
            bool continuarAnalisis = true;

            while (continuarAnalisis)
            {
            }
            if (componenteLexico.Equals("@EOF@"))
            {
                //TablaMaestra.ObtenerTablaMaestra().Sincronizar(componente);
                TablaMaestra.SincronizarSimbolo(componenteLexico);
            }

            return(componenteLexico);
        }
Exemple #2
0
        public ComponenteLexico Analizar()
        {
            ComponenteLexico componenteLexico = new ComponenteLexico();

            limpiarLexema();
            int  estadoActual      = 0;
            bool continuarAnalisis = true;

            while (continuarAnalisis)
            {
                if (estadoActual == 0)
                {
                    LeerSiguienteCaracter();
                    DevorarEspaciosBlanco();
                    if (CaracterActual == "0" || CaracterActual == "1")
                    {
                        estadoActual = 1;
                        concatenarLexema();
                    }
                    else if (CaracterActual == "#")
                    {
                        estadoActual = 6;
                        concatenarLexema();
                    }
                    else if (CaracterActual == "K")
                    {
                        estadoActual = 60;
                        concatenarLexema();
                    }
                    else if (CaracterActual == "C")
                    {
                        estadoActual = 58;
                        concatenarLexema();
                    }
                    else if (CaracterActual == "I")
                    {
                        estadoActual = 7;
                        concatenarLexema();
                    }
                    else if (CaracterActual == "O")
                    {
                        estadoActual = 9;
                        concatenarLexema();
                    }
                    else if (CaracterActual == "U")
                    {
                        estadoActual = 15;
                        concatenarLexema();
                    }
                    else if (CaracterActual == "D")
                    {
                        estadoActual = 17;
                        concatenarLexema();
                    }
                    else if (CaracterActual == "G")
                    {
                        estadoActual = 21;
                        concatenarLexema();
                    }
                    else if (CaracterActual == "S")
                    {
                        estadoActual = 24;
                        concatenarLexema();
                    }
                    else if (CaracterActual == "R")
                    {
                        estadoActual = 46;
                        concatenarLexema();
                    }
                    else if (CaracterActual == "F")
                    {
                        estadoActual = 54;
                        concatenarLexema();
                    }
                    else if (CaracterActual == "@FL@")
                    {
                        estadoActual = 61;
                    }
                    else if (CaracterActual == "@EOF@")
                    {
                        estadoActual = 62;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 63;
                    }
                }
                else if (estadoActual == 1)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "0" || CaracterActual == "1")
                    {
                        estadoActual = 2;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 96;
                    }
                }

                else if (estadoActual == 2)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "0" || CaracterActual == "1")
                    {
                        estadoActual = 3;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 96;
                    }
                }
                else if (estadoActual == 3)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "0" || CaracterActual == "1")
                    {
                        estadoActual = 4;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 5;
                    }
                }
                else if (estadoActual == 4)
                {
                    estadoActual = 64;
                }

                else if (estadoActual == 5)
                {
                    DevolverPuntero();
                    continuarAnalisis = false;
                    componenteLexico  = ComponenteLexico.crear(lexema, Categoria.VALOR_ENVIO, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 6)
                {
                    estadoActual = 65;
                }

                else if (estadoActual == 7)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "N")
                    {
                        estadoActual = 8;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 83;
                    }
                }
                else if (estadoActual == 8)
                {
                    estadoActual = 78;
                }
                else if (estadoActual == 9)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "U")
                    {
                        estadoActual = 10;
                        concatenarLexema();
                    }
                    else if (CaracterActual == "N")
                    {
                        estadoActual = 12;
                        concatenarLexema();
                    }
                    else if (CaracterActual == "F")
                    {
                        estadoActual = 13;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 63;
                    }
                }
                else if (estadoActual == 10)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "T")
                    {
                        estadoActual = 11;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 85;
                    }
                }
                else if (estadoActual == 11)
                {
                    estadoActual = 66;
                }
                else if (estadoActual == 12)
                {
                    estadoActual = 67;
                }
                else if (estadoActual == 13)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "F")
                    {
                        estadoActual = 14;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 86;
                    }
                }
                else if (estadoActual == 14)
                {
                    estadoActual = 68;
                }
                else if (estadoActual == 15)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "P")
                    {
                        estadoActual = 16;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 88;
                    }
                }
                else if (estadoActual == 16)
                {
                    estadoActual = 69;
                }
                else if (estadoActual == 17)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "O")
                    {
                        estadoActual = 18;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 89;
                    }
                }
                else if (estadoActual == 18)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "W")
                    {
                        estadoActual = 19;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 89;
                    }
                }
                else if (estadoActual == 19)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "N")
                    {
                        estadoActual = 20;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 89;
                    }
                }
                else if (estadoActual == 20)
                {
                    estadoActual = 70;
                }
                else if (estadoActual == 21)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "E")
                    {
                        estadoActual = 22;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 90;
                    }
                }
                else if (estadoActual == 22)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "T")
                    {
                        estadoActual = 23;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 90;
                    }
                }
                else if (estadoActual == 23)
                {
                    estadoActual = 71;
                }
                else if (estadoActual == 24)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "T")
                    {
                        estadoActual = 25;
                        concatenarLexema();
                    }
                    else if (CaracterActual == "H")
                    {
                        estadoActual = 32;
                        concatenarLexema();
                    }
                    else if (CaracterActual == "U")
                    {
                        estadoActual = 40;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 63;
                    }
                }
                else if (estadoActual == 25)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "A")
                    {
                        estadoActual = 26;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 63;
                    }
                }
                else if (estadoActual == 26)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "R")
                    {
                        estadoActual = 27;
                        concatenarLexema();
                    }
                    else if (CaracterActual == "T")
                    {
                        estadoActual = 29;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 63;
                    }
                }
                else if (estadoActual == 27)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "T")
                    {
                        estadoActual = 28;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 92;
                    }
                }
                else if (estadoActual == 28)
                {
                    estadoActual = 79;
                }
                else if (estadoActual == 29)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "U")
                    {
                        estadoActual = 30;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 93;
                    }
                }
                else if (estadoActual == 30)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "S")
                    {
                        estadoActual = 31;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 93;
                    }
                }
                else if (estadoActual == 31)
                {
                    estadoActual = 72;
                }
                else if (estadoActual == 32)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "U")
                    {
                        estadoActual = 33;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 94;
                    }
                }
                else if (estadoActual == 33)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "T")
                    {
                        estadoActual = 34;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 94;
                    }
                }
                else if (estadoActual == 34)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "D")
                    {
                        estadoActual = 35;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 94;
                    }
                }
                else if (estadoActual == 35)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "O")
                    {
                        estadoActual = 36;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 94;
                    }
                }
                else if (estadoActual == 36)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "W")
                    {
                        estadoActual = 37;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 94;
                    }
                }
                else if (estadoActual == 37)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "N")
                    {
                        estadoActual = 38;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 94;
                    }
                }
                else if (estadoActual == 38)
                {
                    estadoActual = 80;
                }

                else if (estadoActual == 39)
                {
                    DevolverPuntero();
                    continuarAnalisis = false;
                    componenteLexico  = ComponenteLexico.crear(lexema, Categoria.FARENHEIT, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 40)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "C")
                    {
                        estadoActual = 41;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 95;
                    }
                }
                else if (estadoActual == 41)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "C")
                    {
                        estadoActual = 42;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 95;
                    }
                }
                else if (estadoActual == 42)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "E")
                    {
                        estadoActual = 43;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 95;
                    }
                }
                else if (estadoActual == 43)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "S")
                    {
                        estadoActual = 44;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 95;
                    }
                }
                else if (estadoActual == 44)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "S")
                    {
                        estadoActual = 45;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 95;
                    }
                }
                else if (estadoActual == 45)
                {
                    estadoActual = 73;
                }

                else if (estadoActual == 46)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "E")
                    {
                        estadoActual = 47;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 53;
                    }
                }
                else if (estadoActual == 47)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "S")
                    {
                        estadoActual = 48;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 87;
                    }
                }
                else if (estadoActual == 48)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "T")
                    {
                        estadoActual = 49;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 87;
                    }
                }
                else if (estadoActual == 49)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "A")
                    {
                        estadoActual = 50;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 87;
                    }
                }
                else if (estadoActual == 50)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "R")
                    {
                        estadoActual = 51;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 87;
                    }
                }
                else if (estadoActual == 51)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "T")
                    {
                        estadoActual = 52;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 87;
                    }
                }
                else if (estadoActual == 52)
                {
                    estadoActual = 74;
                }
                else if (estadoActual == 53)
                {
                    DevolverPuntero();
                    continuarAnalisis = false;
                    componenteLexico  = ComponenteLexico.crear(lexema, Categoria.RANKINE, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }

                else if (estadoActual == 54)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "A")
                    {
                        estadoActual = 55;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 39;
                    }
                }
                else if (estadoActual == 55)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "I")
                    {
                        estadoActual = 56;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 91;
                    }
                }
                else if (estadoActual == 56)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual == "L")
                    {
                        estadoActual = 57;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 91;
                    }
                }
                else if (estadoActual == 57)
                {
                    estadoActual = 75;
                }
                else if (estadoActual == 58)
                {
                    estadoActual = 76;
                }
                else if (estadoActual == 59)
                {
                    continuarAnalisis = false;
                    componenteLexico  = ComponenteLexico.crear(lexema, Categoria.KELVIN, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 60)
                {
                    estadoActual = 59;
                }
                else if (estadoActual == 61)
                {
                    CargarNuevaLinea();
                    limpiarLexema();
                    estadoActual = 0;
                }
                else if (estadoActual == 62)
                {
                    estadoActual = 77;
                }
                else if (estadoActual == 64)
                {
                    continuarAnalisis = false;
                    componenteLexico  = ComponenteLexico.crear(lexema, Categoria.VALOR_RETORNO, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 65)
                {
                    continuarAnalisis = false;
                    componenteLexico  = ComponenteLexico.crear(lexema, Categoria.SEPARADOR, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 66)
                {
                    continuarAnalisis = false;
                    componenteLexico  = ComponenteLexico.crear(lexema, Categoria.OUT, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 72)
                {
                    continuarAnalisis = false;
                    componenteLexico  = ComponenteLexico.crear(lexema, Categoria.STATUS, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 73)
                {
                    continuarAnalisis = false;
                    componenteLexico  = ComponenteLexico.crear(lexema, Categoria.SUCCESS, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 74)
                {
                    continuarAnalisis = false;
                    componenteLexico  = ComponenteLexico.crear(lexema, Categoria.RESTART, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                //eof
                else if (estadoActual == 77)
                {
                    continuarAnalisis = false;
                    componenteLexico  = ComponenteLexico.crear(lexema, Categoria.EOF, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    limpiarLexema();
                }
                else if (estadoActual == 78)
                {
                    continuarAnalisis = false;
                    componenteLexico  = ComponenteLexico.crear(lexema, Categoria.IN, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 67)
                {
                    continuarAnalisis = false;
                    componenteLexico  = ComponenteLexico.crear(lexema, Categoria.ON, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 68)
                {
                    continuarAnalisis = false;
                    componenteLexico  = ComponenteLexico.crear(lexema, Categoria.OFF, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 69)
                {
                    continuarAnalisis = false;
                    componenteLexico  = ComponenteLexico.crear(lexema, Categoria.UP, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 70)
                {
                    continuarAnalisis = false;
                    componenteLexico  = ComponenteLexico.crear(lexema, Categoria.DOWN, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 71)
                {
                    continuarAnalisis = false;
                    componenteLexico  = ComponenteLexico.crear(lexema, Categoria.GET, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 75)
                {
                    continuarAnalisis = false;
                    componenteLexico  = ComponenteLexico.crear(lexema, Categoria.FAIL, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 76)
                {
                    continuarAnalisis = false;;
                    componenteLexico  = ComponenteLexico.crear(lexema, Categoria.CENTIGRADOS, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 79)
                {
                    continuarAnalisis = false;
                    componenteLexico  = ComponenteLexico.crear(lexema, Categoria.START, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 80)
                {
                    continuarAnalisis = false;
                    componenteLexico  = ComponenteLexico.crear(lexema, Categoria.SHUTDOWN, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }

                //stopper
                else if (estadoActual == 63)
                {
                    Error error = Error.CrearErrorLexico(
                        CaracterActual,
                        Categoria.CARACTER_NO_VALIDO, NumeroLineaActual,
                        Puntero - lexema.Length, Puntero - 1,
                        "Caracter no reconocido", "Leí " + CaracterActual,
                        "Asegurese que el caracter sera valido");

                    GestorErrores.Reportar(error);

                    throw new Exception("Se ha presentado un error de tipo STOPPER durante el análisis lexico. Por favor verifique la consola de errores");
                }
                else if (estadoActual == 83)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();

                    Error error = Error.CrearErrorLexico(
                        lexema,
                        Categoria.IN, NumeroLineaActual,
                        Puntero - lexema.Length, Puntero - 1,
                        "IN no válido",
                        "Leí " + lexema + " y se esperaba un IN",
                        "asegurese de que la instrucción esté escrita correctamente");

                    GestorErrores.Reportar(error);
                    componenteLexico      = ComponenteLexico.crear("IN", Categoria.IN, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.DUMMY;
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 85)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();

                    Error error = Error.CrearErrorLexico(
                        lexema,
                        Categoria.OUT, NumeroLineaActual,
                        Puntero - lexema.Length, Puntero - 1,
                        "OUT no válido",
                        "Leí " + lexema + " y se esperaba un OUT",
                        "asegurese de que la instrucción esté escrita correctamente");

                    GestorErrores.Reportar(error);
                    componenteLexico      = ComponenteLexico.crear("OUT", Categoria.OUT, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.DUMMY;
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 86)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();

                    Error error = Error.CrearErrorLexico(
                        lexema,
                        Categoria.OFF, NumeroLineaActual,
                        Puntero - lexema.Length, Puntero - 1,
                        "OFF no válido",
                        "Leí " + lexema + " y se esperaba un OFF",
                        "asegurese de que la instrucción esté escrita correctamente");

                    GestorErrores.Reportar(error);
                    componenteLexico      = ComponenteLexico.crear("OFF", Categoria.OFF, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.DUMMY;
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 88)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();

                    Error error = Error.CrearErrorLexico(
                        lexema,
                        Categoria.UP, NumeroLineaActual,
                        Puntero - lexema.Length, Puntero - 1,
                        "UP no válido",
                        "Leí " + lexema + " y se esperaba un UP",
                        "asegurese de que la instrucción esté escrita correctamente");

                    GestorErrores.Reportar(error);
                    componenteLexico      = ComponenteLexico.crear("UP", Categoria.UP, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.DUMMY;
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 89)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();

                    Error error = Error.CrearErrorLexico(
                        lexema,
                        Categoria.DOWN, NumeroLineaActual,
                        Puntero - lexema.Length, Puntero - 1,
                        "DOWN no válido",
                        "Leí " + lexema + " y se esperaba un DOWN",
                        "asegurese de que la instrucción esté escrita correctamente");

                    GestorErrores.Reportar(error);
                    componenteLexico      = ComponenteLexico.crear("DOWN", Categoria.DOWN, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.DUMMY;
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 90)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();

                    Error error = Error.CrearErrorLexico(
                        lexema,
                        Categoria.GET, NumeroLineaActual,
                        Puntero - lexema.Length, Puntero - 1,
                        "GET no válido",
                        "Leí " + lexema + " y se esperaba un GET",
                        "asegurese de que la instrucción esté escrita correctamente");

                    GestorErrores.Reportar(error);
                    componenteLexico      = ComponenteLexico.crear("GET", Categoria.GET, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.DUMMY;
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 92)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();

                    Error error = Error.CrearErrorLexico(
                        lexema,
                        Categoria.START, NumeroLineaActual,
                        Puntero - lexema.Length, Puntero - 1,
                        "START no válido",
                        "Leí " + lexema + " y se esperaba un START",
                        "asegurese de que la instrucción esté escrita correctamente");

                    GestorErrores.Reportar(error);
                    componenteLexico      = ComponenteLexico.crear("START", Categoria.START, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.DUMMY;
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 93)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();

                    Error error = Error.CrearErrorLexico(
                        lexema,
                        Categoria.STATUS, NumeroLineaActual,
                        Puntero - lexema.Length, Puntero - 1,
                        "STATUS no válido",
                        "Leí " + lexema + " y se esperaba un STATUS",
                        "asegurese de que la instrucción esté escrita correctamente");

                    GestorErrores.Reportar(error);
                    componenteLexico      = ComponenteLexico.crear("STATUS", Categoria.STATUS, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.DUMMY;
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 94)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();

                    Error error = Error.CrearErrorLexico(
                        lexema,
                        Categoria.SHUTDOWN, NumeroLineaActual,
                        Puntero - lexema.Length, Puntero - 1,
                        "SHUTDOWN no válido",
                        "Leí " + lexema + " y se esperaba un SHUTDOWN",
                        "asegurese de que la instrucción esté escrita correctamente");

                    GestorErrores.Reportar(error);
                    componenteLexico      = ComponenteLexico.crear("SHUTDOWN", Categoria.SHUTDOWN, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.DUMMY;
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 95)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();

                    Error error = Error.CrearErrorLexico(
                        lexema,
                        Categoria.SUCCESS, NumeroLineaActual,
                        Puntero - lexema.Length, Puntero - 1,
                        "SUCCESS no válido",
                        "Leí " + lexema + " y se esperaba un SUCCESS",
                        "asegurese de que la instrucción esté escrita correctamente");

                    GestorErrores.Reportar(error);
                    componenteLexico      = ComponenteLexico.crear("SUCCESS", Categoria.SUCCESS, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.DUMMY;
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 87)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();

                    Error error = Error.CrearErrorLexico(
                        lexema,
                        Categoria.RESTART, NumeroLineaActual,
                        Puntero - lexema.Length, Puntero - 1,
                        "RESTART no válido",
                        "Leí " + lexema + " y se esperaba un RESTART",
                        "asegurese de que la instrucción esté escrita correctamente");

                    GestorErrores.Reportar(error);
                    componenteLexico      = ComponenteLexico.crear("RESTART", Categoria.RESTART, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.DUMMY;
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 91)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();

                    Error error = Error.CrearErrorLexico(
                        lexema,
                        Categoria.FAIL, NumeroLineaActual,
                        Puntero - lexema.Length, Puntero - 1,
                        "FAIL no válido",
                        "Leí " + lexema + " y se esperaba un FAIL",
                        "asegurese de que la instrucción esté escrita correctamente");

                    GestorErrores.Reportar(error);
                    componenteLexico      = ComponenteLexico.crear("FAIL", Categoria.FAIL, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.DUMMY;
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 96)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();

                    Error error = Error.CrearErrorLexico(
                        lexema,
                        Categoria.VALOR_ENVIO, NumeroLineaActual,
                        Puntero - lexema.Length, Puntero - 1,
                        "VALOR_ENVIO no válido",
                        "Leí " + lexema + " y se esperaba un VALOR_ENVIO",
                        "asegurese de que la instrucción esté escrita correctamente");

                    GestorErrores.Reportar(error);
                    componenteLexico      = ComponenteLexico.crear("000", Categoria.VALOR_ENVIO, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.DUMMY;
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
            }

            return(componenteLexico);
        }
Exemple #3
0
        public ComponenteLexico Analizar()
        {
            ComponenteLexico componenteLexico = new ComponenteLexico();

            limpiarLexema();
            int  estadoActual      = 0;
            bool continuarAnalisis = true;

            while (continuarAnalisis)
            {
                if (estadoActual == 0)
                {
                    LeerSiguienteCaracter();
                    DevorarEspaciosBlanco();

                    if (EsLetra(CaracterActual) || CaracterActual.Equals("$") || CaracterActual.Equals("_"))
                    {
                        estadoActual = 4;
                        concatenarLexema();
                    }
                    else if (EsDigito(CaracterActual))
                    {
                        estadoActual = 1;
                        concatenarLexema();
                    }
                    else if (CaracterActual.Equals("+"))
                    {
                        estadoActual = 5;
                        concatenarLexema();
                    }
                    else if (CaracterActual.Equals("-"))
                    {
                        estadoActual = 6;
                        concatenarLexema();
                    }
                    else if (CaracterActual.Equals("*"))
                    {
                        estadoActual = 7;
                        concatenarLexema();
                    }
                    else if (CaracterActual.Equals("/"))
                    {
                        estadoActual = 8;
                        concatenarLexema();
                    }
                    else if (CaracterActual.Equals("("))
                    {
                        estadoActual = 10;
                        concatenarLexema();
                    }
                    else if (CaracterActual.Equals(")"))
                    {
                        estadoActual = 11;
                        concatenarLexema();
                    }
                    else if (CaracterActual.Equals("@EOF@"))
                    {
                        estadoActual = 12;
                        concatenarLexema();
                    }
                    else if (CaracterActual.Equals("="))
                    {
                        estadoActual = 19;
                        concatenarLexema();
                    }
                    else if (CaracterActual.Equals("<"))
                    {
                        estadoActual = 20;
                        concatenarLexema();
                    }
                    else if (CaracterActual.Equals(">"))
                    {
                        estadoActual = 21;
                        concatenarLexema();
                    }
                    else if (CaracterActual.Equals(":"))
                    {
                        estadoActual = 22;
                        concatenarLexema();
                    }
                    else if (CaracterActual.Equals("!"))
                    {
                        estadoActual = 30;
                        concatenarLexema();
                    }
                    else if (CaracterActual.Equals("@FL@"))
                    {
                        estadoActual = 13;
                    }
                    else
                    {
                        estadoActual = 18;
                    }
                }
                else if (estadoActual == 1)
                {
                    LeerSiguienteCaracter();

                    if (EsDigito(CaracterActual))
                    {
                        estadoActual = 1;
                        concatenarLexema();
                    }
                    else if (CaracterActual.Equals(","))
                    {
                        estadoActual = 2;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 14;
                    }
                }
                else if (estadoActual == 2)
                {
                    LeerSiguienteCaracter();
                    if (EsDigito(CaracterActual))
                    {
                        estadoActual = 3;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 17;
                    }
                }
                else if (estadoActual == 3)
                {
                    LeerSiguienteCaracter();
                    if (EsDigito(CaracterActual))
                    {
                        estadoActual = 3;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 15;
                    }
                }
                else if (estadoActual == 4)
                {
                    LeerSiguienteCaracter();
                    if (EsLetraODigito(CaracterActual) || CaracterActual.Equals("$") || CaracterActual.Equals("_"))
                    {
                        estadoActual = 4;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 16;
                    }
                }
                else if (estadoActual == 5)
                {
                    continuarAnalisis     = false;
                    componenteLexico      = ComponenteLexico.crear(lexema, Categoria.SUMA, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.SIMBOLO;
                    MensajeRetorno(componenteLexico);
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 6)
                {
                    continuarAnalisis     = false;
                    componenteLexico      = ComponenteLexico.crear(lexema, Categoria.RESTA, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.SIMBOLO;
                    MensajeRetorno(componenteLexico);
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 7)
                {
                    continuarAnalisis     = false;
                    componenteLexico      = ComponenteLexico.crear(lexema, Categoria.MULTIPLICACION, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.SIMBOLO;
                    MensajeRetorno(componenteLexico);
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 8)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual.Equals("*"))
                    {
                        estadoActual = 34;
                        concatenarLexema();
                    }
                    else if (CaracterActual.Equals("/"))
                    {
                        estadoActual = 36;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 33;
                    }
                }
                else if (estadoActual == 9)
                {
                    continuarAnalisis     = false;
                    componenteLexico      = ComponenteLexico.crear(lexema, Categoria.MODULO, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.SIMBOLO;
                    MensajeRetorno(componenteLexico);
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 10)
                {
                    continuarAnalisis     = false;
                    componenteLexico      = ComponenteLexico.crear(lexema, Categoria.PARENTESIS_ABRE, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.SIMBOLO;
                    MensajeRetorno(componenteLexico);
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 11)
                {
                    continuarAnalisis     = false;
                    componenteLexico      = ComponenteLexico.crear(lexema, Categoria.PARENTESIS_CIERRA, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.SIMBOLO;
                    MensajeRetorno(componenteLexico);
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                //fin de archivo
                else if (estadoActual == 12)
                {
                    continuarAnalisis     = false;
                    componenteLexico      = ComponenteLexico.crear(lexema, Categoria.EOF, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.SIMBOLO;
                    //TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                //cargar nueva linea
                else if (estadoActual == 13)
                {
                    CargarNuevaLinea();
                    limpiarLexema();
                    estadoActual = 0;
                }

                else if (estadoActual == 14)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();
                    componenteLexico      = ComponenteLexico.crear(lexema, Categoria.ENTERO, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.SIMBOLO;
                    MensajeRetorno(componenteLexico);
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 15)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();
                    componenteLexico      = ComponenteLexico.crear(lexema, Categoria.NUMERO_DECIMAL, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.SIMBOLO;
                    MensajeRetorno(componenteLexico);
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 16)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();
                    componenteLexico      = ComponenteLexico.crear(lexema, Categoria.IDENTIFICADOR, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.SIMBOLO;
                    MensajeRetorno(componenteLexico);
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                //estado de error
                else if (estadoActual == 17)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();

                    Error error = Error.CrearErrorLexico(
                        lexema,
                        Categoria.NUMERO_DECIMAL, NumeroLineaActual,
                        Puntero - lexema.Length, Puntero - 1,
                        "Numero decimal no válido", "Leí" + CaracterActual + "y esperaba un digito del cero al 9",
                        "asegurese que el caracter que reciba sea un caracter del 0 al 9");

                    GestorErrores.Reportar(error);

                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.NUMERO_DECIMAL;
                    componenteLexico.Lexema          = lexema + "0";
                    componenteLexico.NumeroLinea     = NumeroLineaActual;
                    componenteLexico.PosicionInicial = Puntero - lexema.Length;
                    componenteLexico.PosicionFinal   = Puntero - 1;
                    componenteLexico.Tipo            = TipoComponente.DUMMY;
                    MensajeRetorno(componenteLexico);

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                //estado de error
                else if (estadoActual == 18)
                {
                    Error error = Error.CrearErrorLexico(
                        CaracterActual,
                        Categoria.CARACTER_NO_VALIDO, NumeroLineaActual,
                        Puntero - 1, Puntero - 1,
                        "Caracter no reconocido", "Leí" + CaracterActual,
                        "Asegurese que el caracter sera valido");

                    GestorErrores.Reportar(error);

                    throw new Exception("Se ha presentado un error de tipo STOPPER durante el analisis lexico. Por favor verifique la consola de errores");
                }
                else if (estadoActual == 19)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();
                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.IGUAL_QUE;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = NumeroLineaActual;
                    componenteLexico.PosicionInicial = Puntero - lexema.Length;
                    componenteLexico.PosicionFinal   = Puntero - 1;
                    MensajeRetorno(componenteLexico);
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 20)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual.Equals(">"))
                    {
                        estadoActual = 23;
                        concatenarLexema();
                    }
                    else if (CaracterActual.Equals("="))
                    {
                        estadoActual = 24;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 24;
                    }
                }
                else if (estadoActual == 21)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual.Equals("="))
                    {
                        estadoActual = 26;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 27;
                    }
                }
                else if (estadoActual == 22)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual.Equals("="))
                    {
                        estadoActual = 28;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 29;
                    }
                }
                else if (estadoActual == 23)
                {
                    continuarAnalisis     = false;
                    componenteLexico      = ComponenteLexico.crear(lexema, Categoria.DIFERENTE_QUE, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.SIMBOLO;
                    MensajeRetorno(componenteLexico);
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 24)
                {
                    continuarAnalisis     = false;
                    componenteLexico      = ComponenteLexico.crear(lexema, Categoria.MENOR_IGUAL_QUE, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.SIMBOLO;
                    MensajeRetorno(componenteLexico);
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 25)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();
                    componenteLexico      = ComponenteLexico.crear(lexema, Categoria.MENOR_QUE, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.SIMBOLO;
                    MensajeRetorno(componenteLexico);
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 26)
                {
                    continuarAnalisis     = false;
                    componenteLexico      = ComponenteLexico.crear(lexema, Categoria.MAYOR_IGUAL_QUE, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.SIMBOLO;
                    MensajeRetorno(componenteLexico);
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 27)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();
                    componenteLexico      = ComponenteLexico.crear(lexema, Categoria.MAYOR_QUE, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.SIMBOLO;
                    MensajeRetorno(componenteLexico);
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                else if (estadoActual == 28)
                {
                    continuarAnalisis     = false;
                    componenteLexico      = ComponenteLexico.crear(lexema, Categoria.ASIGNACION, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.SIMBOLO;
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    MensajeRetorno(componenteLexico);
                    limpiarLexema();
                }
                //estado de error
                else if (estadoActual == 29)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();

                    Error error = Error.CrearErrorLexico(
                        lexema,
                        Categoria.NUMERO_DECIMAL, NumeroLineaActual,
                        Puntero - lexema.Length, Puntero - 1,
                        "Asignación no válida", "Leí" + CaracterActual + " y esperaba =",
                        "asegurese que el caracter que reciba sea =");

                    GestorErrores.Reportar(error);
                }
                else if (estadoActual == 30)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual.Equals("="))
                    {
                        estadoActual = 31;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 32;
                    }
                }
                else if (estadoActual == 31)
                {
                    continuarAnalisis     = false;
                    componenteLexico      = ComponenteLexico.crear(lexema, Categoria.DIFERENTE_QUE, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.SIMBOLO;
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    MensajeRetorno(componenteLexico);
                    limpiarLexema();
                }
                //estado de error
                else if (estadoActual == 32)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();

                    Error error = Error.CrearErrorLexico(
                        lexema,
                        Categoria.NUMERO_DECIMAL, NumeroLineaActual,
                        Puntero - lexema.Length, Puntero - 1,
                        "Asignación no válida", "Leí" + CaracterActual + " y esperaba *",
                        "asegurese que el caracter que reciba sea *");

                    GestorErrores.Reportar(error);
                }
                else if (estadoActual == 33)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();
                    componenteLexico      = ComponenteLexico.crear(lexema, Categoria.DIVISION, NumeroLineaActual, Puntero - lexema.Length, Puntero - 1);
                    componenteLexico.Tipo = TipoComponente.SIMBOLO;
                    MensajeRetorno(componenteLexico);
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                    limpiarLexema();
                }
                //revisar
                else if (estadoActual == 34)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual.Equals("@FL@"))
                    {
                        estadoActual = 37;
                        CargarNuevaLinea();
                    }
                    else if (CaracterActual.Equals("*"))
                    {
                        estadoActual = 35;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 34;
                        concatenarLexema();
                    }
                }
                else if (estadoActual == 35)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual.Equals("*"))
                    {
                        estadoActual = 35;
                        concatenarLexema();
                    }
                    else if (CaracterActual.Equals("/"))
                    {
                        estadoActual = 0;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 34;
                        concatenarLexema();
                    }
                }
                else if (estadoActual == 36)
                {
                    LeerSiguienteCaracter();
                    if (CaracterActual.Equals("@FL@"))
                    {
                        estadoActual = 13;
                    }
                    else
                    {
                        estadoActual = 36;
                    }
                }
                //estado para arreglar
                else if (estadoActual == 37)
                {
                    CargarNuevaLinea();

                    if (CaracterActual.Equals("@FL@"))
                    {
                        estadoActual = 34;
                    }
                }
            }

            return(componenteLexico);
        }
        public ComponenteLexico Analizar()
        {
            ComponenteLexico componenteLexico = new ComponenteLexico();

            LimpiarLexema();
            int  estadoActual      = 0;
            bool continuarAnalisis = true;

            while (continuarAnalisis)
            {
                if (estadoActual == 0)
                {
                    LeerSiguienteCaracter();
                    DevorarEspaciosBlanco();

                    if (EsLetra(caracterActual) || caracterActual.Equals("$") || caracterActual.Equals("_"))
                    {
                        estadoActual = 4;
                        concatenarLexema();
                    }
                    else if (EsDigito(caracterActual))
                    {
                        estadoActual = 1;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals("+"))
                    {
                        estadoActual = 5;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals("-"))
                    {
                        estadoActual = 6;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals("*"))
                    {
                        estadoActual = 7;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals("/"))
                    {
                        estadoActual = 8;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals("%"))
                    {
                        estadoActual = 9;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals("("))
                    {
                        estadoActual = 10;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals(")"))
                    {
                        estadoActual = 11;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals("@EOF@"))
                    {
                        estadoActual = 12;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals("="))
                    {
                        estadoActual = 19;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals("<"))
                    {
                        estadoActual = 20;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals(">"))
                    {
                        estadoActual = 21;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals(":"))
                    {
                        estadoActual = 22;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals("!"))
                    {
                        estadoActual = 30;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals("@FL@"))
                    {
                        estadoActual = 13;
                    }
                    else
                    {
                        estadoActual = 18;
                    }
                }
                else if (estadoActual == 1)
                {
                    LeerSiguienteCaracter();

                    if (EsDigito(caracterActual))
                    {
                        estadoActual = 1;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals(","))
                    {
                        estadoActual = 2;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 14;
                    }
                }
                else if (estadoActual == 2)
                {
                    LeerSiguienteCaracter();

                    if (EsDigito(caracterActual))
                    {
                        estadoActual = 3;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 17;
                    }
                }
                else if (estadoActual == 3)
                {
                    LeerSiguienteCaracter();
                    if (EsDigito(caracterActual))
                    {
                        estadoActual = 3;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 15;
                    }
                }
                else if (estadoActual == 4)
                {
                    LeerSiguienteCaracter();
                    if (EsLetraODigito(caracterActual) || caracterActual.Equals("$") || caracterActual.Equals("_"))
                    {
                        estadoActual = 4; concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 16;
                    }
                }
                else if (estadoActual == 5)
                {
                    continuarAnalisis = false;

                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.SUMA;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length;
                    componenteLexico.PosicionFinal   = puntero - 1;
                    componenteLexico.Tipo            = TipoComponente.SIMBOLO;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }
                else if (estadoActual == 6)
                {
                    continuarAnalisis = false;

                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.RESTA;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length;
                    componenteLexico.PosicionFinal   = puntero - 1;
                    componenteLexico.Tipo            = TipoComponente.SIMBOLO;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }
                else if (estadoActual == 7)
                {
                    continuarAnalisis = false;

                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.MULTIPLICACION;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length;
                    componenteLexico.PosicionFinal   = puntero - 1;
                    componenteLexico.Tipo            = TipoComponente.SIMBOLO;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }
                else if (estadoActual == 8)
                {
                    LeerSiguienteCaracter();

                    if (caracterActual.Equals("*"))
                    {
                        estadoActual = 34;
                        concatenarLexema();

                        LeerSiguienteCaracter();

                        if (caracterActual != "*" && caracterActual != "@FL@")
                        {
                            estadoActual = 34;
                            concatenarLexema();
                        }
                        else if (caracterActual.Equals("*"))
                        {
                            estadoActual = 35;
                            concatenarLexema();
                        }
                        else if (caracterActual.Equals("*"))
                        {
                            estadoActual = 35;
                            concatenarLexema();
                        }
                        else if (caracterActual != "*" && caracterActual != "/")
                        {
                            estadoActual = 34;
                            concatenarLexema();
                        }
                        else if (caracterActual.Equals("@FL@"))
                        {
                            estadoActual = 37;
                            concatenarLexema();
                        }
                        //else if (caracterActual.Equals("CNL"))
                        //{
                        //    estadoActual = 34;
                        //    concatenarLexema();
                        //}
                    }
                    else if (caracterActual.Equals("/"))
                    {
                        estadoActual = 36;
                        concatenarLexema();

                        LeerSiguienteCaracter();

                        if (caracterActual != "@FL@")
                        {
                            estadoActual = 36;
                            concatenarLexema();
                        }
                        else if (caracterActual.Equals("@FL@"))
                        {
                            estadoActual = 13;
                            concatenarLexema();
                        }
                    }
                    else
                    {
                        estadoActual = 33;
                    }
                }//****
                else if (estadoActual == 9)
                {
                    continuarAnalisis = false;

                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.MODULO;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length;
                    componenteLexico.PosicionFinal   = puntero - 1;
                    componenteLexico.Tipo            = TipoComponente.SIMBOLO;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }
                else if (estadoActual == 10)
                {
                    continuarAnalisis = false;

                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.PARENTESIS_ABRE;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length;
                    componenteLexico.PosicionFinal   = puntero - 1;
                    componenteLexico.Tipo            = TipoComponente.SIMBOLO;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }
                else if (estadoActual == 11)
                {
                    continuarAnalisis = false;

                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.PARENTESIS_CIERRA;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length;
                    componenteLexico.PosicionFinal   = puntero - 1;
                    componenteLexico.Tipo            = TipoComponente.SIMBOLO;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }
                else if (estadoActual == 12)
                {
                    continuarAnalisis = false;

                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.EOF;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length;
                    componenteLexico.PosicionFinal   = puntero - 1;
                    //componenteLexico.Tipo = TipoComponente.SIMBOLO;

                    //TablaMaestra.SincronizarSimbolo(componenteLexico);
                }
                else if (estadoActual == 13)
                {
                    CargarNuevaLinea();
                    estadoActual = 0;
                }
                else if (estadoActual == 14)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();

                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.ENTERO;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length;
                    componenteLexico.PosicionFinal   = puntero - 1;
                    componenteLexico.Tipo            = TipoComponente.SIMBOLO;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }
                else if (estadoActual == 15)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();

                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.DECIMAL;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length;
                    componenteLexico.PosicionFinal   = puntero - 1;
                    componenteLexico.Tipo            = TipoComponente.SIMBOLO;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }
                else if (estadoActual == 16)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();

                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.IDENTIFICADOR;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length;
                    componenteLexico.PosicionFinal   = puntero - 1;
                    componenteLexico.Tipo            = TipoComponente.SIMBOLO;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }
                else if (estadoActual == 17)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();

                    Error error = Error.CrearErrorLexico(lexema, Categoria.DECIMAL,
                                                         numeroLineaActual, puntero - lexema.Length, puntero - 1,
                                                         "Numero decimal no válido",
                                                         "Lei \"" + caracterActual + "\" y esperaba un digito del 0 al 9",
                                                         "Asegurese que el caracter que se reciba sea un digito del 0 al 9");

                    GestorErrores.Reportar(error);

                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.DECIMAL;
                    componenteLexico.Lexema          = lexema + "0"; //Comodin
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length;
                    componenteLexico.PosicionFinal   = puntero - 1;
                    componenteLexico.Tipo            = TipoComponente.DUMMY;//Lo tuvo que crear para recuperarse del problema

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }
                else if (estadoActual == 18)
                {
                    Error error = Error.CrearErrorLexico(caracterActual, Categoria.CARACTER_NO_VALIDO,
                                                         numeroLineaActual, puntero - 1, puntero - 1,
                                                         "Carcater no reconocido por el lenguaje",
                                                         "Lei \"" + caracterActual + "\"",
                                                         "Asegurese que el caracter que se reciba sea valido dentro del lenguaje");

                    GestorErrores.Reportar(error);

                    throw new Exception("Se ha presentado un error de tipo stopper durante el " +
                                        "analisis léxico. Por favor verifique la consola de errores...");
                }
                else if (estadoActual == 19)
                {
                    continuarAnalisis = false;

                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.IGUAL_QUE;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length;
                    componenteLexico.PosicionFinal   = puntero - 1;
                    componenteLexico.Tipo            = TipoComponente.SIMBOLO;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }
                else if (estadoActual == 20)
                {
                    LeerSiguienteCaracter();

                    if (caracterActual.Equals(">"))
                    {
                        estadoActual = 23;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals("="))
                    {
                        estadoActual = 24;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 25;
                    }
                }
                else if (estadoActual == 21)
                {
                    LeerSiguienteCaracter();

                    if (caracterActual.Equals(">"))
                    {
                        estadoActual = 26;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 27;
                    }
                }
                else if (estadoActual == 22)
                {
                    LeerSiguienteCaracter();

                    if (caracterActual.Equals("="))
                    {
                        estadoActual = 28;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 29;
                    }
                }
                else if (estadoActual == 23)
                {
                    continuarAnalisis = false;

                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.DIFERENTE_QUE;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length;
                    componenteLexico.PosicionFinal   = puntero - 1;
                    componenteLexico.Tipo            = TipoComponente.SIMBOLO;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }
                else if (estadoActual == 24)
                {
                    continuarAnalisis = false;

                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.MENOR_O_IGUAL_QUE;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length;
                    componenteLexico.PosicionFinal   = puntero - 1;
                    componenteLexico.Tipo            = TipoComponente.SIMBOLO;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }
                else if (estadoActual == 25)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();

                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.MENOR_QUE;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length;
                    componenteLexico.PosicionFinal   = puntero - 1;
                    componenteLexico.Tipo            = TipoComponente.SIMBOLO;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }
                else if (estadoActual == 26)
                {
                    continuarAnalisis = false;

                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.MAYOR_O_IGUAL_QUE;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length;
                    componenteLexico.PosicionFinal   = puntero - 1;
                    componenteLexico.Tipo            = TipoComponente.SIMBOLO;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }
                else if (estadoActual == 27)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();

                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.MAYOR_QUE;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length;
                    componenteLexico.PosicionFinal   = puntero - 1;
                    componenteLexico.Tipo            = TipoComponente.SIMBOLO;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }
                else if (estadoActual == 28)
                {
                    continuarAnalisis = false;

                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.ASIGNACION;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length;
                    componenteLexico.PosicionFinal   = puntero - 1;
                    componenteLexico.Tipo            = TipoComponente.SIMBOLO;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }
                else if (estadoActual == 29)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();

                    Error error = Error.CrearErrorLexico(lexema, Categoria.ASIGNACION,
                                                         numeroLineaActual, puntero - lexema.Length, puntero - 1,
                                                         "Caracter no válido",
                                                         "Lei \"" + caracterActual + "\" y esperaba un =",
                                                         "Asegurese que la estructura ASIGNACION sea la adecuada");

                    GestorErrores.Reportar(error);

                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.ASIGNACION;
                    componenteLexico.Lexema          = lexema + "0"; //Comodin
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length;
                    componenteLexico.PosicionFinal   = puntero - 1;
                    componenteLexico.Tipo            = TipoComponente.DUMMY;//Lo tuvo que crear para recuperarse del problema

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }
                else if (estadoActual == 30)
                {
                    LeerSiguienteCaracter();

                    if (caracterActual.Equals("="))
                    {
                        estadoActual = 31;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 32;
                    }
                }
                else if (estadoActual == 31)
                {
                    continuarAnalisis = false;

                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.DIFERENTE_QUE;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length;
                    componenteLexico.PosicionFinal   = puntero - 1;
                    componenteLexico.Tipo            = TipoComponente.SIMBOLO;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }
                else if (estadoActual == 32)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();

                    Error error = Error.CrearErrorLexico(lexema, Categoria.DIFERENTE_QUE,
                                                         numeroLineaActual, puntero - lexema.Length, puntero - 1,
                                                         "Caracter no válido",
                                                         "Lei \"" + caracterActual + "\" y esperaba un =",
                                                         "Asegurese que la estructura DIFERENTE QUE sea la adecuada");

                    GestorErrores.Reportar(error);

                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.DIFERENTE_QUE;
                    componenteLexico.Lexema          = lexema + "0"; //Comodin
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length;
                    componenteLexico.PosicionFinal   = puntero - 1;
                    componenteLexico.Tipo            = TipoComponente.DUMMY;//Lo tuvo que crear para recuperarse del problema

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }
                else if (estadoActual == 33)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();

                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.DIVISION;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length;
                    componenteLexico.PosicionFinal   = puntero - 1;
                    componenteLexico.Tipo            = TipoComponente.SIMBOLO;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }
                else if (estadoActual == 34)
                {
                    LeerSiguienteCaracter();

                    if (caracterActual.Equals("*"))
                    {
                        estadoActual = 35;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals("@FL@"))
                    {
                        estadoActual = 37;
                    }
                    else
                    {
                        estadoActual = 34;
                        concatenarLexema();
                    }
                }
                else if (estadoActual == 35)
                {
                    LeerSiguienteCaracter();

                    if (caracterActual.Equals("/"))
                    {
                        estadoActual = 0;
                    }
                    else if (caracterActual.Equals("*"))
                    {
                        estadoActual = 35;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 34;
                        concatenarLexema();
                    }
                }
                else if (estadoActual == 36)
                {
                    LeerSiguienteCaracter();

                    if (caracterActual.Equals("@FL@"))
                    {
                        estadoActual = 13;
                    }
                    else
                    {
                        estadoActual = 36;
                        concatenarLexema();
                    }
                }
                else if (estadoActual == 37)
                {
                    CargarNuevaLinea();
                    estadoActual = 34;
                }
            }
            if (componenteLexico.Equals("@EOF@"))
            {
                //TablaMaestra.ObtenerTablaMaestra().Sincronizar(componente);
                TablaMaestra.SincronizarSimbolo(componenteLexico);
            }
            return(componenteLexico);
        }
Exemple #5
0
        public ComponenteLexico Analizar()
        {
            ComponenteLexico componenteLexico = new ComponenteLexico();

            limpiarLexema();
            int  estadoActual      = 0;
            bool continuarAnalisis = true;

            while (continuarAnalisis)
            {
                if (estadoActual == 0)
                {
                    LeerSiguienteCaracter();
                    DevorarEspaciosBlanco();

                    if (EsLetra(caracterActual) || EsCaracterEspecial(caracterActual))
                    {
                        estadoActual = 4;
                        concatenarLexema();
                    }
                    else if (EsDigito(caracterActual))
                    {
                        estadoActual = 1;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals("+"))
                    {
                        estadoActual = 5;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals("-"))
                    {
                        estadoActual = 6;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals("*"))
                    {
                        estadoActual = 7;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals("/"))
                    {
                        estadoActual = 8;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals("%"))
                    {
                        estadoActual = 9;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals("("))
                    {
                        estadoActual = 10;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals(")"))
                    {
                        estadoActual = 11;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals("@EOF@"))
                    {
                        estadoActual = 12;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals("="))
                    {
                        estadoActual = 19;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals("<"))
                    {
                        estadoActual = 20;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals(">"))
                    {
                        estadoActual = 21;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals(":"))
                    {
                        estadoActual = 22;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals("!"))
                    {
                        estadoActual = 30;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals("@FL@"))
                    {
                        estadoActual = 13;
                    }
                    else
                    {
                        estadoActual = 18;
                    }
                }
                else if (estadoActual == 1)
                {
                    LeerSiguienteCaracter();
                    if (EsDigito(caracterActual))
                    {
                        estadoActual = 1;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals(","))
                    {
                        estadoActual = 2;
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 14;
                    }
                }
                else if (estadoActual == 2)
                {
                    LeerSiguienteCaracter();

                    if (EsDigito(caracterActual))
                    {
                        estadoActual = 3;
                        concatenarLexema();
                    }
                    else
                    {
                        concatenarLexema();
                        estadoActual = 17;
                    }
                }
                else if (estadoActual == 14)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();
                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.ENTERO;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length + 1;
                    componenteLexico.PosicionFinal   = puntero;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }

                else if (estadoActual == 3)
                {
                    LeerSiguienteCaracter();
                    if (EsDigito(caracterActual))
                    {
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 15;
                    }
                }

                else if (estadoActual == 15)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();
                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.DECIMAL;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length + 1;
                    componenteLexico.PosicionFinal   = puntero;
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }

                else if (estadoActual == 4)
                {
                    LeerSiguienteCaracter();

                    if (EsLetra(caracterActual) || EsCaracterEspecial(caracterActual))
                    {
                        concatenarLexema();
                    }
                    else
                    {
                        estadoActual = 16;
                    }
                }

                else if (estadoActual == 5)
                {
                    continuarAnalisis                = false;
                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.SUMA;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length + 1;
                    componenteLexico.PosicionFinal   = puntero;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }

                else if (estadoActual == 6)
                {
                    continuarAnalisis                = false;
                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.RESTA;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length + 1;
                    componenteLexico.PosicionFinal   = puntero;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }

                else if (estadoActual == 7)
                {
                    continuarAnalisis                = false;
                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.MULTIPLICACION;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length + 1;
                    componenteLexico.PosicionFinal   = puntero;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }

                else if (estadoActual == 9)
                {
                    continuarAnalisis                = false;
                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.MODULO;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length + 1;
                    componenteLexico.PosicionFinal   = puntero;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }

                else if (estadoActual == 10)
                {
                    continuarAnalisis                = false;
                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.PARENTESIS_ABRE;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length + 1;
                    componenteLexico.PosicionFinal   = puntero;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }

                else if (estadoActual == 11)
                {
                    continuarAnalisis                = false;
                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.PARENTESIS_CIERRA;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length + 1;
                    componenteLexico.PosicionFinal   = puntero;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }


                else if (estadoActual == 16)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();
                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.IDENTIFICADOR;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length + 1;
                    componenteLexico.PosicionFinal   = puntero;
                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }

                else if (estadoActual == 8)
                {
                    LeerSiguienteCaracter();
                    if (caracterActual.Equals("*"))
                    {
                        estadoActual = 34;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals("/"))
                    {
                        concatenarLexema();
                        estadoActual = 36;
                    }
                    else
                    {
                        estadoActual = 33;
                    }
                }

                else if (estadoActual == 33)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();
                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.DIVISION;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length + 1;
                    componenteLexico.PosicionFinal   = puntero + 1;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }
                else if (estadoActual == 34)
                {
                    LeerSiguienteCaracter();
                    if (caracterActual.Equals("*"))
                    {
                        concatenarLexema();
                        estadoActual = 35;
                    }
                    else if (caracterActual.Equals("@FL@"))
                    {
                        estadoActual = 37;
                    }

                    /*  else if (caracterActual.Equals("@EOF@"))
                     * {
                     *    limpiarLexema();
                     * }*/
                    else
                    {
                        concatenarLexema();
                    }
                }
                else if (estadoActual == 35)
                {
                    LeerSiguienteCaracter();
                    if (caracterActual.Equals("*"))
                    {
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals("/"))
                    {
                        concatenarLexema();
                        comentario = lexema;
                        limpiarLexema();
                        estadoActual = 0;
                    }
                    else
                    {
                        estadoActual = 34;
                        concatenarLexema();
                    }
                }

                else if (estadoActual == 37)
                {
                    CargarNuevaLinea();
                    estadoActual = 34;

                    //concatenarLexema();
                }

                else if (estadoActual == 36)
                {
                    LeerSiguienteCaracter();
                    if (caracterActual.Equals("@FL@"))
                    {
                        estadoActual = 13;
                        comentario   = lexema;
                        limpiarLexema();
                    }
                    else
                    {
                        concatenarLexema();
                    }
                }

                else if (estadoActual == 13)
                {
                    CargarNuevaLinea();
                    estadoActual = 0;
                }

                else if (estadoActual == 20)
                {
                    LeerSiguienteCaracter();
                    if (caracterActual.Equals(">"))
                    {
                        estadoActual = 23;
                        concatenarLexema();
                    }
                    else if (caracterActual.Equals("="))
                    {
                        concatenarLexema();
                        estadoActual = 24;
                    }
                    else
                    {
                        estadoActual = 25;
                    }
                }

                else if (estadoActual == 23)
                {
                    continuarAnalisis                = false;
                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.DIFERENTE;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length + 1;
                    componenteLexico.PosicionFinal   = puntero;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }

                else if (estadoActual == 24)
                {
                    continuarAnalisis                = false;
                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.MAYOR_O_IGUAL_QUE;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length + 1;
                    componenteLexico.PosicionFinal   = puntero;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }

                else if (estadoActual == 25)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();
                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.MENOR_QUE;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length + 1;
                    componenteLexico.PosicionFinal   = puntero;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }

                else if (estadoActual == 21)
                {
                    LeerSiguienteCaracter();
                    if (caracterActual.Equals("="))
                    {
                        concatenarLexema();
                        estadoActual = 26;
                    }
                    else
                    {
                        estadoActual = 27;
                    }
                }
                else if (estadoActual == 26)
                {
                    continuarAnalisis                = false;
                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.MAYOR_O_IGUAL_QUE;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length + 1;
                    componenteLexico.PosicionFinal   = puntero;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }

                else if (estadoActual == 27)
                {
                    continuarAnalisis = false;
                    DevolverPuntero();
                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.MAYOR_QUE;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length + 1;
                    componenteLexico.PosicionFinal   = puntero;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }

                else if (estadoActual == 22)
                {
                    LeerSiguienteCaracter();
                    if (caracterActual.Equals("="))
                    {
                        concatenarLexema();
                        estadoActual = 28;
                    }
                    else
                    {
                        concatenarLexema();
                        estadoActual = 29;
                    }
                }

                else if (estadoActual == 28)
                {
                    continuarAnalisis                = false;
                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.ASIGNACION;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length + 1;
                    componenteLexico.PosicionFinal   = puntero;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }

                else if (estadoActual == 19)
                {
                    continuarAnalisis                = false;
                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.IGUAL_QUE;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length + 1;
                    componenteLexico.PosicionFinal   = puntero;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }

                else if (estadoActual == 30)
                {
                    LeerSiguienteCaracter();
                    if (caracterActual.Equals("="))
                    {
                        concatenarLexema();
                        estadoActual = 31;
                    }
                    else
                    {
                        concatenarLexema();
                        estadoActual = 32;
                    }
                }

                else if (estadoActual == 31)
                {
                    continuarAnalisis                = false;
                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.DIFERENTE;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero - lexema.Length + 1;
                    componenteLexico.PosicionFinal   = puntero;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }

                else if (estadoActual == 32)
                {
                    DevolverPuntero();
                    continuarAnalisis = false;

                    Error error = Error.CrearErrorLexico(lexema, Categoria.DECIMAL, numeroLineaActual,
                                                         puntero + 2 - lexema.Length, puntero + 1,
                                                         "Caracter no valido",
                                                         "Leí \"" + caracterActual + "\" y esperaba un '='",
                                                         "Asegúrese que el caracter que se reciba despues de ! sea un =");

                    GestorErrores.Reportar(error);

                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.DECIMAL;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero + 2 - lexema.Length;
                    componenteLexico.PosicionFinal   = puntero + 1;
                    componenteLexico.Tipo            = TipoComponente.DUMMY;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }

                else if (estadoActual == 29)
                {
                    DevolverPuntero();
                    continuarAnalisis = false;

                    Error error = Error.CrearErrorLexico(lexema, Categoria.CARACTER_NO_VALIDO, numeroLineaActual,
                                                         puntero + 2 - lexema.Length, puntero + 1,
                                                         "Caracter no valido",
                                                         "Leí \"" + caracterActual + "\" y esperaba un '='",
                                                         "Asegúrese que el caracter que se reciba despues de ! sea un =");

                    GestorErrores.Reportar(error);

                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.DECIMAL;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero + 2 - lexema.Length;
                    componenteLexico.PosicionFinal   = puntero + 1;
                    componenteLexico.Tipo            = TipoComponente.DUMMY;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }

                else if (estadoActual == 17)
                {
                    DevolverPuntero();
                    continuarAnalisis = false;

                    Error error = Error.CrearErrorLexico(lexema, Categoria.DECIMAL, numeroLineaActual,
                                                         puntero + 2 - lexema.Length, puntero + 1,
                                                         "Número decimal no valido",
                                                         "Leí \"" + caracterActual + "\" y esperaba un digíto del 0 al 9",
                                                         "Asegúrese que el caracter que se reciba sea un dígito del 0 al 9");

                    GestorErrores.Reportar(error);

                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.DECIMAL;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero + 2 - lexema.Length;
                    componenteLexico.PosicionFinal   = puntero + 1;
                    componenteLexico.Tipo            = TipoComponente.DUMMY;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }

                else if (estadoActual == 18)
                {
                    Error error = Error.CrearErrorLexico(caracterActual, Categoria.CARACTER_NO_VALIDO, numeroLineaActual,
                                                         puntero, puntero,
                                                         "Caracter no reconocido por el lenguaje",
                                                         "Leí \"" + caracterActual + "\"",
                                                         "Asegúrese que el caracter que se reciba sea valido dentro del lenguaje");

                    GestorErrores.Reportar(error);


                    throw new Exception("Se ha presentado un error de tipo stopper durante" +
                                        "el analisis léxico. Por favor verifique la consola de errores...");
                }

                else if (estadoActual == 12)
                {
                    continuarAnalisis = false;

                    componenteLexico                 = new ComponenteLexico();
                    componenteLexico.Categoria       = Categoria.FIN_ARCHIVO;
                    componenteLexico.Lexema          = lexema;
                    componenteLexico.NumeroLinea     = numeroLineaActual;
                    componenteLexico.PosicionInicial = puntero;
                    componenteLexico.PosicionFinal   = puntero;

                    TablaMaestra.SincronizarSimbolo(componenteLexico);
                }
            }

            return(componenteLexico);
        }