Matehuala S.L.P.

a 27/11/2020

INGENIERIA EN SISTEMAS
COMPUTACIONALES

Analizador Léxico

ALUMNOS: Luis Fernando Hiracheta Soto, Jesús

Guadalupe Jiménez Martínez, Erick Martín López Sifuentes
DOCENTE: Thelma Carrillo López
MODULO: Lenguajes y Autómatas ll
11vo Semestre
Matehuala S.L.P. a 27/11/2020

Descripción del compilador.

Se verá un analizador léxico realizado en C++, en el cual recibe una cadena,
programa fuente, para repartir cada palabra en tokens, los tokens pueden ser
identificadores, en el programa se podrá ver y verificar que cada token sea
válido conforme a las reglas de la sintaxis en el cuál todo identificador debe
empezar con un "_" o una letra, todo identificador debe estar formado por
dígitos, letras o "_" No otros caracteres fuera de estos, ningún número puede
contener una letra ni puede empezar con un "." o terminar con el mismo. Del
usuario le corresponde ingresar una línea de programa fuente con varias
palabras, entre ellas ingresa las palabras reservadas en minúsculas, para poner
a trabajar el programa, es importante que el usuario siempre deje espacio entre
los bucles, condicionales y sus paréntesis.

ANALISIS LÉXICO

Símbolos que aceptara.

Palabras reservadas
Identificador Identificador
Variable Variable
si si
Imprime imprime
Entero 0,1,2,3,…,9
SUMARar +
Restar -
Multiplicar *
Dividir /
Operador <,>,=,<=,>=,==
Matehuala S.L.P. a 27/11/2020

Expresiones regulares
Exprecion regular descricion
!= sirve para diferencia los datos
\B No hay limite de palabras
\d Un digito
\D No es un digito
\n Salto de línea
\r Carácter de retorno
\t tabulador
*p!= Espacio en blanco
*p== Palabra reservada
+== identificador
%s expresión

Autómatas
Matehuala S.L.P. a 27/11/2020

Autómatas.

Palabras "si","entonces","sino","entero","decimal","logico",
reservadas "texto","char","mientras","haga","repita","hasta","
var","como","verdadero","falso","declare","inicie",
"termine","lea","imprima","rompa","nop"
Identificador Identificador
Variable Variable
si si
Imprime imprime
Entero 0,1,2,3,…,9
SUMARar +
Restar -
Multiplicar *
Dividir /
Operador <,>,=,<=,>=,==
Simbolos ‘ ‘, ‘,’, ’;’, ‘”’, ‘(‘, ‘)’, ‘+’, ‘-‘, ‘*’, ‘/’, ‘#’, ‘<’, ‘>’, ‘=’
Matehuala S.L.P. a 27/11/2020

TABLA DE SIMBOLOS
operador Significado
= Igual
[] Corchetes cuadrados
() Paréntesis
“” Comillas dobles
‘’ Comillas simples
+ suma
== Igual igual
!= Diferente o igual
* multiplicación
++ Mas mas
|| or
\ No identificado
{} corchetes
&& and
// Dialogo(comentario)
; Fin de la instrucción
< Menor que
> Mayor que
% token
# evaluador

PROGRAMACIÓN.
El lenguaje que se utilizó para este programa fue C++ ya que es más fácil de
realizar el programa ya que es un lenguaje muy versátil para la resolución de
estos problemas.

Manejo de Errores.
Los errores sintácticos por una expresión son dados aritmética o paréntesis no
equilibrados. El manejo de errores de sintaxis es el más complicado desde el
punto de vista de la creación de compiladores. Nos interesa que cuando el
compilador encuentre un error, se recupere y siga buscando errores. Por lo
tanto, el manejador de errores de un analizador sintáctico tiene como
objetivos:
Matehuala S.L.P. a 27/11/2020

• Indicar los errores de forma clara y precisa. Aclarar el tipo de error y su

localización.
• Recuperarse del error, para poder seguir examinando la entrada.
• No ralentizar significativamente la compilación
Manejo de Errores.

Resultados del análisis léxico.

Matehuala S.L.P. a 27/11/2020
Matehuala S.L.P. a 27/11/2020

ANALISIS SINTÁCTICO
Gramatica libre de contexto.
En sus reglas aparece a la izquierda un único símbolo no terminal, y a la derecha cualquier
combinación de símbolos terminales y no terminales, o la palabra vacía.
- Derivaciones: árboles que se pueden leer de diferentes formas.
• Derivación por la derecha: siempre se aplican las reglas de reescritura al símbolo no terminal
más a la derecha de la cadena de derivación.
• Derivación por la izquierda: siempre se aplican las reglas de reescritura al símbolo no terminal
más a la derecha de la cadena de derivación.
• Ejemplo:
1. S → AB
2. S → A
3. A → aAa
4. A → λ
5. B → Bb
6. B → b

Derivación por la izquierda: S ⇒ AB ⇒ aAaB ⇒ aaB ⇒ aaBb ⇒ aaBbb ⇒ aabbb Derivación por la
derecha: S ⇒ AB ⇒ ABb ⇒ ABbb ⇒ Abbb ⇒ aAabbb ⇒ aabbb
Matehuala S.L.P. a 27/11/2020

Teorema 2.2 Para cada gramática independiente del contexto G(V,Σ,Ax,R) existe un autómata de pila
M(S,Σ,Γ,T,i,F) tal que L(G) = L(M).
DEMOSTRACIÓN
Dada una gramática G(V,Σ, Ax,R) independiente del contexto, se crea un autómata de pila
M(S,Σ,Γ,T,i,F) de la manera siguiente:
• El conjunto de símbolos de entrada de M coincide con los símbolos terminales de G, mientras que
Γ=Σ∪V∪{#}
• El conjunto de estados de M será S={i,p,q,f}
• F={f}
• Se introduce la transición (i,λ,λ;p,#)
• Se introduce la transición (p,λ,λ;q,Ax), siendo Ax el axioma de la gramática.
• Para cada regla de reescritura N→w de la gramática se introduce una transición de la forma
(q,λ,N;q,w).
• Para cada símbolo terminal de G se introduce una transición (q,x,x;q,λ).
• Introducir la transición (q,λ,#;f,λ).
G={VT,VN,S,R}
• VT= Valores Terminales
• VN= Valores no Terminales
• S= inicio
• R= Reglas
Ejemplo: (5-8/2˄2+3π)
• VT= {(,),+,-,*,/,˄,ᴇ,.,=, num}
• VN={EXP, DIV, B,A,C AP,CP,}
• S= EXP
Reglas S=EXP
• EXP= AP EXP+A π CP CP | DIV
• DIV=DIV-B | DIV-B|num
• B=DIV/C|num
• C=B˄B
Matehuala S.L.P. a 27/11/2020

Prueba de derivación con la gramática.

La labor de comprobación de tipos consiste en conferir a las construcciones sintácticas del

lenguaje la semántica de tipificación y en realizar todo
tipo de comprobaciones de dicha índole. Por su naturaleza, sin embargo, ésta se encuentra
repartida entre la fase de análisis semántico y la generación de código
intermedio.
•Comprobaciones estáticas
Las comprobaciones estáticas recogen el compendio de todas aquellas tareas de carácter
semántico que, por su naturaleza,
pueden ser realizadas directamente durante la fase de compilación mediante el uso de los
artefactos y mecanismos propios de dicha fase.
Este tipo de comprobaciones son beneficiosas puesto que confieren seguridad a la ejecución del
programa.
Características
-Diferente de la dinámica en runtime.
-Ejemplo: comprobación de tipos, flujo de control, unicidad.
•Comprobaciones dinámicas
Las comprobaciones dinámicas son aquellas que no se realizan durante la fase de compilación
y se delegan al momento de la ejecución del programa.
Ello requiere generar código ejecutable específicamente diseñado para realizar tales
comprobaciones.
Los lenguajes con una carga excesiva de comprobaciones dinámicas generan programas más
largos, lentos e inseguros en ejecución.
Matehuala S.L.P. a 27/11/2020

Realizar el árbol sintáctico

Matehuala S.L.P. a 27/11/2020

Tabla de símbolos:

operdaor significado
= Igual
[] Corchetes cuadrados
() Paréntesis
“” Comillas dobles
‘’ Comillas simples
+ suma
== Igual igual
!= Diferente o igual
* multiplicación
++ Mas mas
|| or
\ No identificado
{} corchetes
&& and
// Dialogo(comentario)
; Fin de la instrucción
< Menor que
> Mayor que
% token
# evaluador

Programación de la parte sintáctica

//Variables auxiliares para guardar en Tokens

int auxTR=0;
int auxTI=0;
int auxTN=0;
int auxTNV=0;

//Los diferentes procedimientos que se desarrollaran en el programa

y llamaran en su momento desde el metodo main()
bool verificarNumero(char palabra[]);
bool verificarIdentificador(char palabra[]);
bool verificarReservada(char palabra[]);
void imprimirTokenNumeros();
void imprimirTokenSimbolos();
void imprimirTokenReservadas();
void imprimirTokenIdentificadores();
void imprimirIdentificadoresNoValidos();

main()
{
Matehuala S.L.P. a 27/11/2020

system("COLOR 0A");
unsigned char entrada[MAX];
char *p = entrada;
printf("Ingrese la primera linea del lenguaje: ");
fflush(stdin);
gets(entrada);
fflush(stdin);
clrscr();
system("COLOR 0B");

char palabra[MAX]; //Esta variable es muy importante, pues

guardara caracter por caracter formando asi una palabra y termina de
guardar cuando detecta un espacio.
int indexPalabra=0;
int indexSimbolos = 0;

//Ciclos para Iniciar diferentes arreglos.

for(int i=0;i<MAX;i++){tokenReservadas[i] = "";} // Fin del ciclo

for(int i=0;i<MAX;i++){tokensNoValidos[i] = "";}

for(int i=0;i<MAX;i++){
palabra[i] = '\0';
}

//Este bucle es el que recorre cada caracter de la

entrada(programa fuente) que ingreso el usuario, el procedimiento
dentro del bucle es para formar los tokens necesarios.
while(*p!='\0')
{
if((*p != ' ') && (*p !=',')) //Primero revisa que sea
distinto de un espacio ' ' y una coma ','
{
if((*p== ';') || (*p=='"') || (*p=='(') || (*p==')') ||
(*p=='+') || (*p=='-') || (*p=='*') || (*p=='/') || (*p=='#') ||
(*p=='<') || (*p=='>') || (*p=='='))
{
tokenSimbolos[indexSimbolos] = *p;
indexSimbolos++;
}
else
{
palabra[indexPalabra] = *p;
auxWord[indexPalabra] = *p; //La razon de usar este
arreglo es para mandar como parametro al metodo verificarNumero()...
debido a un problema de programacion.
indexPalabra++;
}
}
else if((*p ==' ') || (*p ==','))
{
Matehuala S.L.P. a 27/11/2020

// Guarda la palabra en los respectivos tokens segun las

funciones hayan examinado la palabra.
if(verificarReservada(palabra) == true){
tokenReservadas[auxTR] = palabra;
auxTR++;
}else if(verificarIdentificador(palabra) == true){
tokenIdentificadores[auxTI] = palabra;
auxTI++;
}else if(verificarNumero(auxWord)==true){
tokenNumeros[auxTN] = auxWord;
auxTN++;
}
for(int i=0;i<MAX;i++){palabra[i]='\0';} //Para vaciar
el arreglo de la palabra
for(int i=0;i<MAX;i++){auxWord[i]='\0';} //Para vaciar
el arreglo del arreglo auxiliar
indexPalabra=0;
}
p++;
}

//Esto es para revisar la ultima palabra formada que no se pudo

examinar en el bucle while anterior
if(verificarReservada(palabra) == true){
tokenReservadas[auxTR] = palabra;
auxTR++;
}else if(verificarIdentificador(palabra) == true){
tokenIdentificadores[auxTI] = palabra;
auxTI++;
}else if(verificarNumero(auxWord)==true){
tokenNumeros[auxTN] = auxWord;
auxTN++;
}
Matehuala S.L.P. a 27/11/2020

Manejo de errores:
El manejo de errores se emplea en la impresión de los tokens o cadenas no
válidas para ser corregidas por el usuario y se implementa en las siguientes
instrucciones del código fuente.
Ciclo para la revision de los tokens identificar los validos y no
validos:

for(int i=0;i<MAX;i++){tokenReservadas[i] = "";} // Fin del ciclo

for(int i=0;i<MAX;i++){tokensNoValidos[i] = "";}

for(int i=0;i<MAX;i++){
palabra[i] = '\0';
}

void imprimirIdentificadoresNoValidos(){
puts(" ");
printf("********************************* MENSAJES
*********************************\n");
if(auxTNV == 0){
printf("\t\t 0 Errores, programa fuente exitoso...");
}else{
for(int i=0;i<auxTNV;i++)
{
printf("\t\tERROR: No es Valido el Token: %s
\n",tokensNoValidos[i]);
}
}
}
Matehuala S.L.P. a 27/11/2020

Resultados

Se muestran los resultados de la expresión, se separan la cadena en tokens

reservados, tokens identificadores, tokens símbolos y tokens numéricos.

Resultado con números:

Matehuala S.L.P. a 27/11/2020

Validando codenas con números.

Validando cadenas no válidas, para obtener errores:

Matehuala S.L.P. a 27/11/2020

Resultado: