예제 #1
0
 public CBuscarConcordancia()
 {
     //
     // TODO: agregar aquí la lógica del constructor
     //
     objCCompoLex = new CCompoLex();
 }
예제 #2
0
        /// <summary>
        /// Extrae un lexema de la cadena de entrada dado el Token correspondiente
        /// </summary>
        /// <param name="sToken"></param>
        /// <returns></returns>
        public static string extraerLexema(string sToken)
        {
            int       iIndiceTabla   = 0;
            int       iPosicionTabla = 0;
            CCompoLex objCCompoLex   = new CCompoLex();
            string    sLexema        = string.Empty;

            iIndiceTabla   = int.Parse(sToken[1].ToString());
            iPosicionTabla = int.Parse(sToken[3].ToString());

            switch (iIndiceTabla)
            {
            case 1:
                sLexema = objCCompoLex.sPalReservadas[iPosicionTabla];
                break;

            case 2:
                sLexema = objCCompoLex.sOpAritmeticos[iPosicionTabla];
                break;

            case 3:
                sLexema = objCCompoLex.sOpRelacionales[iPosicionTabla];
                break;

            case 4:
                sLexema = objCCompoLex.sOpLogicos[iPosicionTabla];
                break;

            case 5:
                sLexema = objCCompoLex.sParCircular[iPosicionTabla];
                break;

            case 6:
                sLexema = objCCompoLex.sParCuadrado[iPosicionTabla];
                break;

            case 7:
                sLexema = objCCompoLex.sLlaves[iPosicionTabla];
                break;

            case 8:
                sLexema = CCompoLex.iIdentificador[iPosicionTabla].ToString();
                break;

            case 9:
                sLexema = CCompoLex.NumerosEnteros[iPosicionTabla].ToString();
                break;

            case 10:
                sLexema = CCompoLex.NumerosFlotantes[iPosicionTabla].ToString();
                break;

            case 11:
                sLexema = CCompoLex.NumerosNotacionCientifica[iPosicionTabla].ToString();
                break;
            }

            return(sLexema);
        }
예제 #3
0
 private void Form1_Load(object sender, System.EventArgs e)
 {
     objCCompoLex                        = new CCompoLex();
     CCompoLex.iIdentificador            = new ArrayList();
     CCompoLex.NumerosEnteros            = new  ArrayList();
     CCompoLex.NumerosFlotantes          = new ArrayList();
     CCompoLex.NumerosNotacionCientifica = new ArrayList();
 }
예제 #4
0
        /// <summary>
        /// Determina si el Lexema mandado como parametro pertenece a la tabla de "Palabras Reservadas"
        /// </summary>
        /// <param name="parsLexema">Lexema a identificar</param>
        /// <returns>TRUE cuando pertenece, en caso contrario FALSE</returns>
        public bool IsPalabraReservada(string parsLexema)
        {
            CCompoLex objCCompoLex = new CCompoLex();
            string    sLexema      = parsLexema;
            int       i            = 0;

            for (; i < objCCompoLex.sPalReservadas.Length; i++)
            {
                if (sLexema.Equals(objCCompoLex.sPalReservadas[i]))
                {
                    return(true);
                }
            }
            return(false);
        }
예제 #5
0
        /// <summary>
        /// Permite identificar si el caracter leido pertenece a la tabla del CDigitos
        /// </summary>
        /// <param name="parCar">Caracter leido desde la cadena de entrada</param>
        /// <returns>True Si encontro digito False si no lo encontro</returns>
        public static bool IsDigito(char parCar)
        {
            CCompoLex objCCompoLex = new CCompoLex();
            int       i            = 0;
            char      cCar         = parCar;


            for (; i < objCCompoLex.iDigitos.Length; i++)
            {
                if (cCar == objCCompoLex.iDigitos[i])
                {
                    return(true);
                }
            }
            return(false);
        }
예제 #6
0
 private void Form2_Load(object sender, System.EventArgs e)
 {
     lexema = new CCompoLex();
 }
예제 #7
0
        /// <summary>
        /// Token Lexema General
        /// </summary>
        /// <param name="parsCadEntrada">Cadena de entrada dada por el usuario</param>
        /// <param name="parsLexema">Lexema extraido de la cadena de entrada</param>
        /// <param name="iAf">Apuntador Fijo</param>
        /// <param name="iAm">Apuntador Movil</param>
        /// <returns></returns>
        public string tokenLexema(string parsCadEntrada, string parsLexema, ref int iAf, ref int iAm)
        {
            string              sLexema                = parsLexema;
            string              sToken                 = string.Empty;
            string              sCadEntrada            = parsCadEntrada;
            char                cCar                   = sLexema[0];
            int                 i                      = 0;
            CCompoLex           objCCompoLex           = new CCompoLex();
            CBuscarConcordancia objCBuscarConcordancia = new CBuscarConcordancia();


            for ( ; i <= objCCompoLex.sPalReservadas.Length - 1; i++)
            {
                if (sLexema.Equals(objCCompoLex.sPalReservadas[i]))
                {
                    return("(1," + i.ToString() + ")");
                }
                else
                {
                    continue;
                }
            }

            for (i = 0; i <= objCCompoLex.sOpAritmeticos.Length - 1; i++)
            {
                if (sLexema.Equals(objCCompoLex.sOpAritmeticos[i]))
                {
                    return("(2," + i.ToString() + ")");
                }
                else
                {
                    continue;
                }
            }

            for (i = 0; i <= objCCompoLex.sOpRelacionales.Length - 1; i++)
            {
                if (sLexema.Equals(objCCompoLex.sOpRelacionales[i]))
                {
                    return("(3," + i.ToString() + ")");
                }
                else
                {
                    continue;
                }
            }

            for (i = 0; i <= objCCompoLex.sOpLogicos.Length - 1; i++)
            {
                if (sLexema.Equals(objCCompoLex.sOpLogicos[i]))
                {
                    return("(4," + i.ToString() + ")");
                }
            }

            for (i = 0; i <= objCCompoLex.sParCircular.Length - 1; i++)
            {
                if (sLexema.Equals(objCCompoLex.sParCircular[i]))
                {
                    return("(5," + i.ToString() + ")");
                }
            }

            for (i = 0; i <= objCCompoLex.sParCuadrado.Length - 1; i++)
            {
                if (sLexema.Equals(objCCompoLex.sParCuadrado[i]))
                {
                    return("(6," + i.ToString() + ")");
                }
            }

            for (i = 0; i <= objCCompoLex.sLlaves.Length - 1; i++)
            {
                if (sLexema.Equals(objCCompoLex.sLlaves[i]))
                {
                    return("(7," + i.ToString() + ")");
                }
            }

            if (sLexema.Equals("="))
            {
                return("(12,1)");
            }
            else
            {
                return("");
            }
        }