Se muestra el analisis de una opcion a seguir cuando se desea realizar un analizador sintactico. Este manual sencillo se baso en el libro: ======================================================== VER EL LIBRO COMPLETO Y DESCARGA http://www.scribd.com/doc/153507389/Compiladores-Principios-Tecnicas-y-Herramientas-Dragon-Book ====================================================

1. Análisis y Realización de Analizador Sintáctico [ NO PROGRAMACION ]
Conceptos:
Análisis del Programa Fuente
Fases de un compilador

2. En esta guía solo nos enfocaremos en la realización de la parte de analizado sintáctico.
En la compilación el análisis consta de tres fases:
1. Análisis lineal: en el que la cadena de caracteres que constituye el programa fuente se lee
de izquierda a derecha y se agrupa en componentes léxicos, que son secuencias de
caracteres que tienen un significado colectivo.
2. Análisis jerárquico: en el que los caracteres o los componentes léxicos se agrupan
jerárquicamente en colecciones anidadas con un significado colectivo.
3. Análisis semántico: en el que se realizan ciertas revisiones para asegurar que los
componentes de un programa se ajustan de un modo significativo.
Análisis léxico
En un compilador, el análisis lineal se llama análisis léxico. Por ejemplo, en el análisis léxico los
caracteres de la proposición de asignación:
posición := inicial + velocidad * 60 )
el analizado léxico se encarga de identificar las cadenas e identificarlas como componentes léxicos
o cadenas erróneas lexicalmente construyendo una tabla de simbolos, el analizado léxico para la
sentencia anterior arrojaría los siguiente información:
NOTA*: Los valores numéricos son ejemplo de lo que un analizador léxico le arroja al analizador
sintáctico:
Valor Numérico Ejemplo
(Lo arroja el analizador lexico)
Lexema
(Cadena que representa al
token)
Gramema
(Significado de la cadena o token
identificado)
100 Posición Identificador
150 := Operador asignación
100 inicial Identificador
151 + Operador aritmético suma
100 Velocidad Identificador
152 * Operador aritmético multiplicación
101 60 Cadena numérica
165 ) Operador “Paréntesis que cierra”
Se preguntaran ¿para qué el analizador léxico define números para las sentencias que lee?
Bueno tienes varias razones pero la principal razón que es más óptimo trabajar con números que

3. con cadenas. Esto no queda muy claro ahorita pero cuando veamos el análisis sintáctico
observaremos con mayor claridad la razón de esto.
Ahora se preguntaran que la sentencia que se analizó está mal, porque no debe de llevar un
paréntesis que cierra si no existe un paréntesis que abre anterior al que cierra. La respuesta es
sencilla estamos de hablando de análisis léxico, lo que nos importa es identificar si es o no un
token. Por ejemplo:
posición:=&&inicial+/
No existen errores léxicos, porque todo es identificado como se ve a continuación:
Valor Numérico Ejemplo
(Lo arroja el analizador lexico)
Lexema
(Cadena que representa al
token)
Gramema
(Significado de la cadena o token
identificado)
100 posición Identificador
150 := Operador asignación
157 && Operador lógico AND
100 inicial identificador
100 + Operador aritmético suma
152 / Operador aritmético multiplicación
Pero en cambio sí realizamos el análisis sintáctico, nos dirá que es sintácticamente incorrecto, por
que como el analizador sintáctico se encarga de verificar que los tokens estén agrupados y
ubicados según la definición del lenguaje, y como en nuestro lenguaje no hemos definido aún una
estructura sintáctica similar a la del ejemplo por lo que esta sintácticamente mal.
Ahora lo que vamos a definir es la estructura sintáctica del lenguaje, como ya tenemos definidos
los tokens que nuestro programa utilizara, ahora vamos a definir que estructura tendrán, para
esto vamos a realizar las reglas de producción ayudándonos de diagramas de sintaxis.

4.
Estructuras sintácticas de un lenguaje de las cuales vamos a definir la sintaxis del lenguaje:

6. Ahora en cada diagrama verificamos si hay recursividad o ambigüedad, en caso de existir alguna
de las características anteriores eliminarla de dicho diagrama, para esto utilizamos elementos no
terminales que nos ayuden a eliminar dichas características. El resultado eliminando recursividad y
ambigüedad es el siguiente:

8. Observaran que son los mismos diagramas, pero destacando los elementos no terminales por
recuadros rojos, además hay anotaciones hechas con lápiz que significa que existe un elemento no
terminal, es decir como en el ejemplo del 3 diagrama de las imágenes, es <DECLARACIONES> = {
variable , < L_I_A > } , es decir que todo < L_I_A > es un elemento no terminal que por
consiguiente, < L_I_A > = { < LISTA DE IDENTIFICADORES > , : < TIPOS > , ; , < L_IDEN > } , en este
caso agregamos este elemento no terminal y el bloque < L_I_A > , realizando estas modificaciones
observamos que se elimina la ambigüedad y la recursividad.
Para comprender mejor lo que se explicó anteriormente realizaremos las reglas de producción,
que surgen a partir de los diagramas de sintaxis anteriormente mostrados:
0. < MODULO > → Programa id ; < CUERPO > .
1. < CUERPO > → < DECLARACIONES > < PRINCIPAL >
2. < DECLARACIONES > → Variable < L_I_A >
3. < L_I_A > → < LISTA DE IDENTIFICADORES > : < TIPOS > ; < L_I_A_AUX >
4. < L_I_A_AUX > → 
5. < L_I_A_AUX > → < L_I_A >
6. < LISTA DE IDENTIFICADORES > → id < Id_AUX >
7. < Id_AUX > → 
8. < Id_AUX > → , < LISTA DE IDENTIFICADORES >
9. < TIPOS > → < ESTANDAR >
10. < TIPOS > → < VECTORES >
11. < ESTANDAR > → enteros
12. < ESTANDAR > → Real
13. < ESTANDAR > → cadena
14. < ESTANDAR > → Booleano
15. < ESTANDAR > → Caracter
16. < ESTANDAR > → Byte
17. < VECTORES > → Arreglo [ < C_E_A > ] de < ESTANDAR >
18. < C_E_A > → cte. entera .. cte. entera < C_E_A_AUX >
19. < C_E_A_AUX > → 
20. < C_E_A_AUX > → , < C_E_A >
21. < PRINCIPAL > → { < ESTATUTOS > }
22. < ESTATUTOS > → < ESTATUTOS > ; < E_AUX >
23. < E_AUX > → 
24. < E_AUX > → < ESTATUTOS >
25. < ESTATUTO > → < ASIGNACION >

9. 26. < ESTATUTO > → < CICLO PARA >
27. < ESTATUTO > → < CICLO_MIENTRAS >
28. < ESTATUTO > → < CICLO REPETIR >
29. < ESTATUTO > → < ENTRADA >
30. < ESTATUTO > → < SALIDA >
31. < ESTATUTO > → < CONDICIONAL SI >
32. < ASIGANACION > → < VARIABLE > := < EXPRESION >
33. < VARIABLE > → id < Id_V_AUX >
34. < Id_V_AUX > → 
35. < Id_V_AUX > → [ < E_A > ]
36. < E_A > → < EXPRESION > < E_A_AUX >
37. < E_A_AUX > → 
38. < E_A_AUX > → , < E_A >
39. < EXPRESION > → < EXP > < EXP_AUX >
40. < EXP_AUX > → 
41. < EXP_AUX > → < RELACIONAL > < EXP >
42. < RELACIONAL > → =
43. < RELACIONAL > → <
44. < RELACIONAL > → >
45. < RELACIONAL > → <=
46. < RELACIONAL > → >=
47. < RELACIONAL > → <>
48. < EXP > → < TERMINO > < T_AUX >
49. < T_AUX > → 
50. < T_AUX > → + < EXP >
51. < T_AUX > → ‐ < EXP >
52. < T_AUX > → || < EXP >
53. < TERMINO > → < FACTOR > < F_AUX >
54. < F_AUX > → 
55. < F_AUX > → * < TERMINO >
56. < F_AUX > → / < TERMINO >
57. < F_AUX > → && < TERMINO >
58. < FACTOR > → ( < EXPRESION > )
59. < FACTOR > → < VARIABLE >

10. 60. < FACTOR > → verdadero
61. < FACTOR > → falso
62. < FACTOR > → cte. entera
63. < FACTOR > → cte. real
64. < FACTOR > → cte. cadena
65. < FACTOR > → ¡ < EXPRESION >
66. < CICLO PARA > → para < CONTADOR > hacer { < ESTATUTOS > }
67. < CONTADOR > → id := < EXPRESION > hasta < EXPRESION >
68. < CICLO_MIENTRAS > → mientras < EXPRESION > hacer { < ESTATUTOS > }
69. < CICLO REPETIR > → Repetir < ESTATUROS > hasta < EXPRESION >
70. < ESNTRADA > → leer ( < V_A > )
71. < V_A > → < VARIABLE > < V_AUX >
72. < V_AUX > → 
73. < V_AUX > → , < V_A >
74. < SALIDA > → escribir ( < EX_A > )
75. < EX_A > → < EXPRESION > < EX_A_AUX >
76. < EX_A_AUX > → 
77. < EX_A_AUX > → , < EX_A >
78. < CONDICIONAL SI > → si < EXPRESION > entonces { < ESTATUTOS > } < ESTA_A >
79. < ESTA_A > → 
80. < ESTA_A > → { < ESTATUTOS > }

11. Ahora vamos a determinar primeros (FIRST) y siguientes(FOLLOW), ustedes se
preguntaran para que sirven los PRIMEROS y los SIGUIENTES si ya tengo las reglas
de producción, el motivo es que son necesarios para realizar la matriz predictiva, la
cual nos ayudara a definir la sintaxis del lenguaje, vamos a iniciar con los primeros:
Como ejemplo utilizaremos las primeras 11 reglas de sintaxis:
0. < MODULO > → Programa id ; < CUERPO > .
1. < CUERPO > → < DECLARACIONES > < PRINCIPAL >
2. < DECLARACIONES > → Variable < L_I_A >
3. < L_I_A > → < LISTA DE IDENTIFICADORES > : < TIPOS > ; < L_I_A_AUX >
4. < L_I_A_AUX > → 
5. < L_I_A_AUX > → < L_I_A >
6. < LISTA DE IDENTIFICADORES > → id < Id_AUX >
7. < Id_AUX > → 
8. < Id_AUX > → , < LISTA DE IDENTIFICADORES >
9. < TIPOS > → < ESTANDAR >
10. < TIPOS > → < VECTORES >
Solo nos vamos a enfocar en los elementos no terminales de la izquierda (son los que están < >):
< MODULO > → Programa id ; < CUERPO > .
Ahora deducimos cual es el primer elemento que define < MODULO >, en este caso es:
< MODULO > → Programa id ; < CUERPO > .
Entonces el FIRST de < MODULO > es Programa, y lo definimos:
F(< MODULO >) = { Programa }
Ahora en la siguiente regla:
< CUERPO > → < DECLARACIONES > < PRINCIPAL >
Observamos que el primer elemento que define < CUERPO > es un elemento no terminal:
< CUERPO > → < DECLARACIONES > < PRINCIPAL >
Entonces en este caso buscamos el primer elemento que define < DECLARACIONES >:

12. < DECLARACIONES > → Variable < L_I_A >
Entonces el FIRST de < CUERPO > es Variable, y lo definimos:
F(< CUERPO >) = { Variable }
Continuamos con la siguiente regla:
< DECLARACIONES > → Variable < L_I_A >
Ahora deducimos cual es el primer elemento que define < DECLARACIONES >, es un elemento
terminal por lo tanto:
F(< DECLARACIONES >) = { Variable }
Continuamos con la siguiente regla:
< L_I_A > → < LISTA DE IDENTIFICADORES > : < TIPOS > ; < L_I_A_AUX >
Observamos que el primer elemento que define < L_I_A > es un elemento no terminal:
< L_I_A > → < LISTA DE IDENTIFICADORES > : < TIPOS > ; < L_I_A_AUX >
Entonces en este caso buscamos el primer elemento que define < LISTA DE IDENTIFICADORES > :
< LISTA DE IDENTIFICADORES > → id < Id_AUX >
Entonces el FIRST de < L_I_a > es id, y lo definimos:
F(< L_I_A >) = { id }
Continuamos con la siguiente regla, observamos que una misma regla deriva dos elementos:
< L_I_A_AUX > → 
< L_I_A_AUX > → < L_I_A >
Deducimos que el primer elemento de la primera regla en vacío, y de la segunda regla es el FIRST
de < L_I_A > que es id, entonces definimos:
F(< L_I_A_AUX >) = {  , id }
Ahora como practica elaborar los FISRT de las reglas de sintaxis.
Yo se lo recomendó para que no se les dificulten los follows.

13. PRIMEROS:
F(< MODULO >) = { Programa }
F(< CUERPO >) = { Variable }
F(< DECLARACIONES >) = { Variable }
F(< L_I_A >) = { id }
F(< L_I_A_AUX >) = {  , id }
F(< LISTA DE IDENTIFICADORES >) = { id }
F(< Id_AUX >) = {  , , }
F(< TIPOS >) = { enteros , Real , cadena , Booleano , Caracter , Byte , Arreglo }
F(< ESTANDAR >) = { enteros , Real , cadena , Booleano , Caracter , Byte , Arreglo }
F(< VECTORES >) = { Arreglo }
F(< C_E_A >) = { cte. entera }
F(< C_E_A_AUX >) = {  , , }
F(< PRINCIPAL >) = { { }
F(< ESTATUTOS >) = { id , para , mientras , Repetir , leer , escribir , si }
F(< E_AUX >) = { id , para , mientras , Repetir , leer , escribir , si }
F(< ESTATUTO >) = { id , para , mientras , Repetir , leer , escribir , si }
F(< ASIGANACION >) = { id }
F(< VARIABLE >) = { id }
F(< Id_V_AUX >) = {  , [ }
F(< E_A >) = { id , ( , verdadero , falso , cte. entera , cte. real , cte. cadena , ¡ }
F(< E_A_AUX >) = {  , , }
F(< EXPRESION >) = { id , ( , verdadero , falso , cte. entera , cte. real , cte. cadena , ¡ }
F(< EXP_AUX >) = {  , = , < , > , <= , >= , <> }
F(< RELACIONAL >) = { = , < , > , <= , >= , <> }

14. F(< EXP >) = { id , ( , verdadero , falso , cte. entera , cte. real , cte. cadena , ¡ }
F(< T_AUX >) = {  , || , + , ‐ }
F(< TERMINO >) = { id , ( , verdadero , falso , cte. entera , cte. real , cte. cadena , ¡ }
F(< F_AUX >) = {  , * , / , && }
F(< FACTOR >) = { id , ( , verdadero , falso , cte. entera , cte. real , cte. cadena , ¡ }
F(< CICLO PARA >) = { para }
F(< CONTADOR >) = { id }
F(< CICLO_MIENTRAS >) = { mientras }
F(< CICLO REPETIR >) = { Repetir }
F(< ENTRADA >) = { leer }
F(< V_A >) = { id }
F(< V_AUX >) = {  , , }
F(< SALIDA >) = { escribir }
F(< EX_A >) = { id , ( , verdadero , falso , cte. entera , cte. real , cte. cadena , ¡ }
F(< EX_A_AUX >) = {  , , }
F(< CONDICIONAL SI >) = { si }
F(< ESTA_A >) = {  , { }

15. Una vez elaborados los PRIMEROS, vamos a realizar los SIGUIENTES:
Como ejemplo utilizaremos las primeras 11 reglas de sintaxis:
0. < MODULO > → Programa id ; < CUERPO > .
1. < CUERPO > → < DECLARACIONES > < PRINCIPAL >
2. < DECLARACIONES > → Variable < L_I_A >
3. < L_I_A > → < LISTA DE IDENTIFICADORES > : < TIPOS > ; < L_I_A_AUX >
4. < L_I_A_AUX > → 
5. < L_I_A_AUX > → < L_I_A >
6. < LISTA DE IDENTIFICADORES > → id < Id_AUX >
7. < Id_AUX > → 
8. < Id_AUX > → , < LISTA DE IDENTIFICADORES >
9. < TIPOS > → < ESTANDAR >
10. < TIPOS > → < VECTORES >
Solo nos vamos a enfocar en los elementos no terminales de la izquierda (son los que están < >):
< MODULO > → Programa id ; < CUERPO > .
Ahora buscamos < MODULO > que es el símbolo inicial en el lado derecho de las reglas de
producción, observamos que en ninguna de las 80 reglas de producción existe este elemento no
terminal en el lado derecho por lo cual, deducimos que:
FO(< MODULO >) = { $ }
El SIGUIENTE de < MODULO > es fin de archivo representado por $, por la deducción anterior y por
definición:

16. Ahora en la siguiente regla:
< CUERPO > → < DECLARACIONES > < PRINCIPAL >
Buscamos en la parte derecha de cada regla de producción < CUERPO >, y la encontramos en la
regla de producción 0:
< MODULO > → Programa id ; < CUERPO > .
Y el SIGUIENTE de < CUERPO > es :
< MODULO > → Programa id ; < CUERPO > .
Entonces el SIGUIENTE de < CUERPO > es . se define:
FO(< CUERPO >) = { . }
Continuando con la siguiente regla:
< DECLARACIONES > → Variable < L_I_A >
Buscamos en la parte derecha de cada regla de producción < DECLARACIONES >, y la encontramos
en la regla de producción 1:
< CUERPO > → < DECLARACIONES > < PRINCIPAL >
Observamos que al lado derecho de < DECLARACIONES >, esta < PRINCIPAL >, entonces el
SIGUIENTE de < DECLARACIONES > es el PRIMERO de < PRINCIPAL >, que es { , entonces:
FO(< DECLARACIONES >) = { { }
Continuando con la siguiente regla:
< L_I_A > → < LISTA DE IDENTIFICADORES > : < TIPOS > ; < L_I_A_AUX >
Buscamos en la parte derecha de cada regla de producción < L_I_A >, y la encontramos en las
reglas de producción 2 y 5:
2. < DECLARACIONES > → Variable < L_I_A >
5. < L_I_A_AUX > → < L_I_A >
Observamos que en la regla de producción 2 al lado derecho de < L_I_A >, no hay nada entonces el
SIGUIENTE de < L_I_A > en la regla 2 es el SIGUIENTE de < DECLARACIONES >, que es { . Ahora
observamos que es el mismo caso en la regla de producción 5, no hay nada entonces el SIGUIENTE

17. de < L_I_A > en la regla 5 es el SIGUIENTE de < L_I_A_AUX >, ahora buscamos < L_I_A_AUX > en la
parte derecha de cada regla de producción, y la encontramos en:
4. < L_I_A > → < LISTA DE IDENTIFICADORES > : < TIPOS > ; < L_I_A_AUX >
Observamos que no existe nada después de < L_I_A_AUX >, por lo que es el SIGUIENTE de < L_I_A
>, y como estamos buscando los SIGUIENTE de < L_I_A >, se anula. Entonces el SIGUIENTE de <
L_I_A > es:
FO(< L_I_A >) = { { }
Continuando con la siguiente regla:
5. < L_I_A_AUX > → 
6. < L_I_A_AUX > → < L_I_A >
No importa que se repitan solo vamos a considerar < L_I_A_AUX >, ahora lo buscamos del lado
derecho de las reglas de producción y lo encontramos en:
4. < L_I_A > → < LISTA DE IDENTIFICADORES > : < TIPOS > ; < L_I_A_AUX >
Observamos que no existe nada del lado derecho de < L_I_A_AUX > por lo que el SIGUIENTE de <
L_I_A_AUX >, es el SIGUIENTE de < L_I_A > y como ya lo realizamos entonces:
FO(< L_I_A_AUX >) = { { }
Continuando con la siguiente regla:
7. < LISTA DE IDENTIFICADORES > → id < Id_AUX >
Ahora lo buscamos del lado derecho de las reglas de producción y encontramos en:
4. < L_I_A > → < LISTA DE IDENTIFICADORES > : < TIPOS > ; < L_I_A_AUX >
Observamos que el SIGUIENTE de < LISTA DE IDENTIFICADORES > es : , entonces:
FO(< LISTA DE IDENTIFICADORES >) = { : }

18. Continuando con la siguiente regla:
8. < Id_AUX > → 
9. < Id_AUX > → , < LISTA DE IDENTIFICADORES >
Buscamos en el lado derecho de las reglas de producción y lo encontramos en:
7. < LISTA DE IDENTIFICADORES > → id < Id_AUX >
Observamos que no tiene elementos después de < Id_AUX > entonces, el SIGUIENTE de < Id_AUX
>, es el SIGUIENTE de < LISTA DE IDENTIFICADORES >. Y como ya lo realizamos, entonces:
FO(< Id_AUX >) = { : }
Las siguientes reglas:
10. < TIPOS > → < ESTANDAR >
11. < TIPOS > → < VECTORES >
Buscamos en el lado derecho de las reglas de producción y lo encontramos en:
4. < L_I_A > → < LISTA DE IDENTIFICADORES > : < TIPOS > ; < L_I_A_AUX >
Observamos que el SIGUIENTE de < TIPOS > es ; , entonces:
FO(< TIPOS >) = { ; }
Las siguientes reglas:
12. < ESTANDAR > → enteros
13. < ESTANDAR > → Real
14. < ESTANDAR > → cadena
15. < ESTANDAR > → Booleano
16. < ESTANDAR > → Caracter
17. < ESTANDAR > → Byte
Buscamos en el lado derecho de las reglas de producción y lo encontramos en:
18. < VECTORES > → Arreglo [ < C_E_A > ] de < ESTANDAR >
Deducimos que el SIGUIENTE de < ESTANDAR > es el SIGUIENTE de < VECTORES >, buscamos y
encontramos:

19. 10. < TIPOS > → < VECTORES >
Entonces el SIGUIENTE de < VECTORES > es el SIGUIENTE de < TIPOS > , entonces:
FO(< ESTANDAR >) = { ; }
Ahora como practica elaborar los FOLLOW de las reglas de
sintaxis.

20. FO(< MODULO >) = { $ }
FO(< CUERPO >) = { . }
FO(< DECLARACIONES >) = { { }
FO(< L_I_A >) = { { }
FO(< L_I_A_AUX >) = { { }
FO(< LISTA DE IDENTIFICADORES >) = { : }
FO(< Id_AUX >) = { : }
FO(< TIPOS >) = { ; }
FO(< ESTANDAR >) = { ; }
FO(< VECTORES >) = { ; }
FO(< C_E_A >) = { ] }
FO(< C_E_A_AUX >) = { ] }
FO(< PRINCIPAL >) = { . }
FO(< ESTATUTOS >) = { } , hasta }
FO(< E_AUX >) = { } , hasta }
FO(< ESTATUTO >) = { ; }
FO(< ASIGANACION >) = { ; }
FO(< VARIABLE >) = { := , * , / , && , + , ‐ , || , = , < , > , <= , >= , <> , , , ] , ) , ; , hasta , hacer ,
entonces }
FO(< Id_V_AUX >) = { := , * , / , && , + , ‐ , || , = , < , > , <= , >= , <> , , , ] , ) , ; , hasta , hacer ,
entonces }
FO(< E_A >) = { ] }
FO(< E_A_AUX >) = { ] }
FO(< EXPRESION >) = { := , * , / , && , + , ‐ , || , = , < , > , <= , >= , <> , , , ] , ) , ; , hasta , hacer ,
entonces }
FO(< EXP_AUX >) = { := , * , / , && , + , ‐ , || , = , < , > , <= , >= , <> , , , ] , ) , ; , hasta , hacer ,
entonces }

21. FO(< RELACIONAL >) = { id , verdadero , falso , cte. entera , cte. real , cte. cadena , ¡ }
FO(< EXP >) = { , , ] , ; , ) , * , / , && , + , ‐ , || , hasta , hacer , entonces , = , < , > , <= , >= , <> }
FO(< T_AUX >) = { , , ] , ; , ) , * , / , && , + , ‐ , || , hasta , hacer , entonces , = , < , > , <= , >= , <> }
FO(< TERMINO >) = { , , ] , ; , ) , * , / , && , + , ‐ , || , hasta , hacer , entonces , = , < , > , <= , >= , <> }
FO(< F_AUX >) = { , , ] , ; , ) , * , / , && , + , ‐ , || , hasta , hacer , entonces , = , < , > , <= , >= , <> }
FO(< FACTOR >) = { , , ] , ; , ) , * , / , && , + , ‐ , || , hasta , hacer , entonces , = , < , > , <= , >= , <> }
FO(< CICLO PARA >) = { ; }
FO(< CONTADOR >) = { hacer }
FO(< CICLO_MIENTRAS >) = { ; }
FO(< CICLO REPETIR >) = { ; }
FO(< ENTRADA >) = { ; }
FO(< V_A >) = { ) }
FO(< V_AUX >) = { ) }
FO(< SALIDA >) = { ; }
FO(< EX_A >) = { ) }
FO(< EX_A_AUX >) = { ) }
FO(< CONDICIONAL SI >) = { ; }
FO(< ESTA_A >) = { ; }

22. Una vez realizados los PRIMEROS y SIGUIENTES vamos a elaborar la matriz de sintaxis, la cual es
bastante importante, ya que a través de esta se realiza el análisis sintáctico.
Para realizar la matriz de sintaxis en la primera columna de la izquierda definimos los elementos
no terminales, y en la primera fila superior definimos los elementos terminales. La tabla que se
presentara a continuación está incompleta, y no se mostrara la tabla completa, con el fin de
practicar y ayudar en la comprensión del análisis sintáctico.
Ahora se explicara cómo se realiza el llenado de la matriz de sintaxis a través de ejemplos:
1. Observamos el primer elemento no terminal de la primera columna de la izquierda, es
“MODULO”, entonces deducimos que los PRIMEROS de “MODULO” es Programa.
2. Ahora hay que verificar de que regla de producción se originaron los PRIMEROS de
“MODULO”. Es decir buscamos en la parte izquierda de las reglas de producción y
buscamos a MODULO.
3. Observamos que en la regla 0 se encuentra MODULO, entonces se pone el valor 0 en
la intersección entre MODULO y Programa. (Observar la tabla).
Ahora proseguimos con CUERPO, verificamos los PRIMEROS de CUERPO es Variable, entonces hay
que corroborar de que regla de producción se derivó los PRIMEROS de CUERPO, y encontramos
que es de la regla de producción 1. Entonces en la intersección entre CUERPO y Variable poner un
1.(Observar tabla).
Ahora proseguimos con DECLARACIONES, verificamos los PRIMEROS de DECLARACIONES es
Variable, entonces hay que corroborar de que regla de producción se derivó los PRIMEROS de
DECLARACIONES, y encontramos que es de la regla de producción 2. Entonces en la intersección
entre DECLARACIONES y Variable poner un 2.(Observar tabla).
Ahora proseguimos con L_I_A, verificamos los PRIMEROS de L_I_A es id, entonces hay que
corroborar de que regla de producción se derivó los PRIMEROS de L_I_A y encontramos que es de
la regla de producción 3. Entonces en la intersección entre L_I_A y id poner un 3.(Observar tabla).
Ahora proseguimos con L_I_A_AUX, verificamos los PRIMEROS de L_I_A_AUX es  (vacío), e id,
observar que en la tabla no tenemos un elemento terminal vacío, entonces vamos a buscar los
SIGUIENTES de L_I_A_AUX que es { , ahora hay que corroborar de que regla de producción se
derivó el SIGUIENTE de L_I_A_AUX y encontramos que es de la regla de producción 4. Entonces en
la intersección entre L_I_A_AUX y { poner un 4.(Observar tabla).
Pero aún falta el elemento terminal id, entonces solo buscamos de que regla de producción se
derivó los PRIMEROS de L_I_A_AUX y encontramos que es de la regla 5. Entonces en la
intersección entre L_I_A_AUX e id poner un 5.(Observar tabla).
Ahora proseguimos con LISTA DE IDENTIFICADORES, verificamos los PRIMEROS de LISTA DE
IDENTIFICADORES, que es id, entonces hay que corroborar de que regla de producción se derivó
los PRIMEROS de LISTA DE IDENTIFICADORES y encontramos que es de la regla de producción 6.
Entonces en la intersección entre LISTA DE IDENTIFICADORES e id poner un 6.(Observar tabla).

24. Ahora proseguimos con Id_AUX, verificamos los PRIMEROS de Id_AUX, que es  (vacio), , (coma).
Observar que en la tabla no tenemos un elemento terminal vacío, entonces vamos a buscar los
SIGUIENTES de Id_AUX que es : , ahora hay que corroborar de que regla de producción se derivó el
SIGUIENTE de Id_AUX y encontramos que es de la regla de producción 7. Entonces en la
intersección entre Id_AUX y : poner un 7.(Observar tabla).
Pero aún falta el elemento terminal , (coma), entonces solo buscamos de que regla de producción
se derivó los PRIMEROS de Id_AUX y encontramos que es de la regla 8. Entonces en la intersección
entre Id_AUX y , poner un 8.(Observar tabla).
Ahora proseguimos con TIPOS, verificamos los PRIMEROS de TIPOS son enteros , Real , cadena ,
Booleano , Caracter , Byte , Arreglo, entonces hay que corroborar de que regla de producción se
derivó los PRIMEROS de DECLARACIONES, y encontramos que es de la regla de producción 9 se
derivó Real , cadena , Booleano , Caracter , Byte y de la regla de producción 10 se derivó Arreglo.
Porque los PRIMEROS de TIPOS son los PRIMEROS de ESTANDAR y VECTORES, y los PRIMEROS de
ESTANDAR son Real , cadena , Booleano , Caracter , Byte. Y los PRIMEROS de VECTORES es Arreglo.
Entonces en la intersecciones entre TIPOS y enteros , Real , cadena , Booleano , Caracter , Byte
poner un 9.(Observar tabla). Ahora en la intersección entre TIPOS y Arreglo poner un 10.(Observar
tabla).
Ahora como practica llenar la Matriz de Sintaxis.

25. Para comprobar que estamos realizando correctamente nuestra matriz analizar el siguiente
código, a través de una corrida de escritorio:
programa hola_mundo;
variable
oks_3s:enteros;
{
wer:=sdfsd23;
}.
Si analizamos este código en nuestro analizador léxico arrojara lo siguiente:
Valor Numérico Ejemplo
(Lo arroja el analizador lexico y
lo define el programador)
Lexema
(Cadena que representa al
token)
Gramema
(Significado de la cadena o token
identificado)
140 programa Palabra reservada
100 Hola_mundo Identificador
128 ; Delimitador punto y coma
141 variable Palabra reservada
100 oks_3s Identificador
106 : Delimitador dos punto
142 enteros Palabra reservada
128 ; Delimitador punto y coma
124 { Delimitador corchete que abre
125 } Delimitador corchete que cierra
127 . Delimitador punto
Lo que nos interesa del análisis léxico es solo el valor numérico, el lexema y gramema ya
no nos son útiles.
Corrida de escritorio
Yo según mi experiencia organice de la siguiente
forma la corrida de escritorio. Antes de iniciar
enumeramos los elementos no terminales de la
primera columna de la izquierda de la matriz
sintáctica.

26. Ahora ponemos el primer elemento de nuestro lenguaje del cual se deriva todo, ahora verificamos en la tabla de sintaxis, y deducimos < MODULO > con programa, buscamos en la tabla y encontramos un 0, es decir vamos
a la regla de producción 0 y la ponemos:
NOTA*: Ahora vamos a sustituir < MODULO > por Programa id ; < CUERPO > . pero al revés:
Pila Sintáctica Pila sintáctica convertida numéricamente Sentencias Sentencias convertidas numericamente Reglas de producción precedida por la tabla de sintaxis
$ < MODULO > $ 1 programa hola_mundo; 140 100 128 0.‐ < MODULO > → Programa id ; < CUERPO > .
Pila Sintáctica Pila sintáctica convertida numéricamente Sentencias Sentencias convertidas numéricamente Reglas de producción
$ < MODULO > $ 0 programa hola_mundo; 140 100 128 0.‐ < MODULO > → Programa id ; < CUERPO > .
$ . < CUERPO > ; id Programa $ 127 1 128 100 140 programa 140 ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Se eliminan 140 con 140
$ . < CUERPO > ; id $ 127 1 128 100 hola_mundo; 100 128 ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Se eliminan 100 con 100
$ . < CUERPO > ; $ 127 1 128 ; 128 ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Se eliminan 128 con 128
$ . < CUERPO > $ 127 1 variable 141 1.< CUERPO > → < DECLARACIONES > < PRINCIPAL >
$ . < PRINCIPAL > < DECLARACIONES > $ 127 12 2 variable 141 2.< DECLARACIONES > → Variable < L_I_A >
$ . < PRINCIPAL > < L_I_A > Variable $ 127 12 3 141 variable 141 ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Se eliminan 141 con 141
$ . < PRINCIPAL > < L_I_A > $ 127 12 3 oks_3s:enteros; 100 106 142 128 3.< L_I_A > → < LISTA DE IDENTIFICADORES > : < TIPOS > ; < L_I_A_AUX >
$ . < PRINCIPAL > < L_I_A_AUX > ; < TIPOS > : < LISTA DE IDENTIFICADORES > $ 127 12 4 128 7 106 5 oks_3s 100 6.< LISTA DE IDENTIFICADORES > → id < Id_AUX >
$ . < PRINCIPAL > < L_I_A_AUX > ; < TIPOS > : < Id_AUX > Id $ 127 12 4 128 7 106 6 100 oks_3s 100 ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Se eliminan 100 con 100
$ . < PRINCIPAL > < L_I_A_AUX > ; < TIPOS > : < Id_AUX > $ 127 12 4 128 7 106 6 : 106
7.< Id_AUX > →  en este caso salió vacío entonces solo quitamos < Id_AUX >
de la pila sintáctica
$ . < PRINCIPAL > < L_I_A_AUX > ; < TIPOS > : $ 127 12 4 128 7 106 : 106 ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Se eliminan 106 con 106
$ . < PRINCIPAL > < L_I_A_AUX > ; < TIPOS > $ 127 12 4 128 7 enteros 142 9.< TIPOS > → < ESTANDAR >
$ . < PRINCIPAL > < L_I_A_AUX > ; < ESTANDAR > $ 127 12 4 128 8 enteros 142 11.< ESTANDAR > → enteros
$ . < PRINCIPAL > < L_I_A_AUX > ; enteros $ 127 12 4 128 142 enteros 142 ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Se eliminan 142 con 142
$ . < PRINCIPAL > < L_I_A_AUX > ; $ 127 12 4 128 ; 128 ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Se eliminan 128 con 128
$ . < PRINCIPAL > < L_I_A_AUX > $ 127 12 4 { 124 4. < L_I_A_AUX > → 
$ . < PRINCIPAL > $ 127 12 { 124 21. < PRINCIPAL > → { < ESTATUTOS > }
$ . } < ESTATUTOS > { $ 127 125 13 124 { 124 ‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐ Se eliminan 124 con 124
$ . } < ESTATUTOS > $ 127 125 13 wer:=sdfsd23; 125
¿ Observando la matriz sintáctica, que numero de producción debemos
de utilizar?