advertisement

Análisis y realización de analizador sintáctico [no programacion]

43 %
57 %
advertisement
Information about Análisis y realización de analizador sintáctico [no programacion]
Education

Published on August 14, 2013

Author: jhonsoomelol

Source: slideshare.net

Description

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
====================================================
advertisement

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

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 

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.                 

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

                           

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:   

 

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 > 

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 > 

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 >  }                 

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 >: 

< 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. 

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 >) = { = , < , > , <= , >= , <> } 

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 >) = {  , { }                 

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:     

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 

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 >) = { : }       

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: 

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.                                       

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 } 

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 >) = { ; }               

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).

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.       

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.      

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? 

Add a comment

Related presentations

Related pages

Analizador sintáctico - Linguakit

Analizador sintáctico. ... y tendrás un completo análisis de las relaciones sintácticas que se establecen ... qué palabra es nuclear y cuál ...
Read more

Analizador y desambiguador morfosintáctico | Stilus

El analizador morfosintáctico de Stilus le devolverá las descripciones morfológicas de cada palabra junto con un árbol sintáctico ... Stilus Gold y ...
Read more

lenguaespanola - Analizadores sintácticos

Prácticas de análisis sintáctico de oraciones simples y compuestas: Ejercicio 1; ... Analizador de oraciones simples y compuestas (Secundaria)
Read more

Comentarios en: Herramienta análisis- Analizador ...

... Herramienta análisis- Analizador Sintáctico y Morfológico de frases ... Análisis Morfosintáctico […] Por: 512 Expresiones en Latín | @lfon ...
Read more

Análisis sintáctico - Aplicaciones de Android en Google Play

En cada ejercicio se muestran las distintas etapas del análisis sintáctico y se tiene la posibilidad de escribir o señalar ... Analizador sintáctico LK ...
Read more

Análisis de oraciones simples y subordinadas ...

Analizador sintáctico del Grupo de Estructuras de Datos de la ULPGC. 2.2 ... diferencias entre un análisis sintáctico y morfológico. 1. TEORÍA.
Read more

Analizador Morfosintáctico

Categorías gramaticales . Funciones sintácticas . Funciones sintácticas
Read more

Analizador Lexico y Sintactico Prueba Compiladores - YouTube

Analizador Lexico y Sintactico Prueba ... Analizador Lexico y Sintactico Prueba Compiladores YouTube; ... COMPILADORES ANALISIS LEXICO ...
Read more

El análisis sintáctico de una oración - YouTube

El análisis sintáctico de una oración es el análisis de las funciones sintácticas o ... Oraciones bimembres y unimembres Lengua ...
Read more