ANALISIS SINTACTICO

Asignatura: 5-12-2013

Lenguajes y Autómatas I

Carrera: Ingeniería En Sistemas Computacionales Integrantes Del Equipo: Martin Emmanuel Herrera Zavala. Juan Alfredo Maldonado Alamilla. Manuel Armando Hernández Moguel. Sergio Iván Yam Dzul. Semestre: 5° Grupo “A” Docente: Ing. Antonia Guadalupe Castillo Coronado

“Investigación”

Contenido  ANALISIS SINTACTICO

................................. .................................................. .................................. ................................. ................................. ..............................2 .............2

GRAMATICA LIBRE DEL CONTEXTO (GLC)  ÁRBOL DE DERIVACION DIAGRAMA DE SINTAXIS

................................. ................................................. ................................. .................................. .................................. ...........................4 ..........4 ............................... ................................................ .................................. .................................. .................................. ...........................5 ..........5

ELIMINACIÓN DE LA AMBIGÜEDAD  AMBIGÜEDAD:

................................ ................................................. .................................. ...........................3 ..........3

................................. ................................................. ................................. ................................. ........................6 ........6

............................... ................................................ .................................. ................................. ................................. ................................. ..............................6 ..............6

TIPOS DE AMBIGÜEDAD:

.................................. .................................................. ................................. ................................. ................................. .........................6 ........6

 AMBIGÜEDAD INHERENTE:

................................. ................................................. ................................. ................................. ................................. ......................7 .....7

 AMBIGÜEDAD TRANSITORIA: TRANSITORIA:

............................... ................................................ .................................. ................................. ................................. ...................7 ..7

GENERACIÓN DE MATRIZ PREDICTIVA PREDICTIVA (CÁLCULO FIRST Y FOLLOW) .........................8 .........................8 TIPOS DE ANALIZADORES SINTÁCTIC S INTÁCTICOS OS

............................... ................................................ .................................. ..............................9 .............9

 ANALIZADOR SINTÁCTICO SINTÁCTICO ASCENDENTE

................................. .................................................. .................................. ...........................9 ..........9

CARÁCTERISTICAS

................................. ................................................. ................................. .................................. ................................. ................................. ...................9 ..9

...........................................11 ............11  ANÁLISIS SINTÁCTICO DESCENDENTE DESCENDENTE CON RETROCESO. RETROCESO. ............................... ........................................11 .........11  ANÁLISIS SINTÁCTICO DESCENDENTE DESCENDENTE PREDICTIVO PREDICTIVO (ASDP) ...............................

 ANALIZADOR SINTÁCTICO SINTÁCTICO ASCENDENTE MANEJO DE ERRORES

................................. .................................................. .................................. .........................12 ........12

................................ ................................................. .................................. ................................. ................................. ............................14 ...........14

GENERADOR DE ANALIZADOR A NALIZADOR SINTÁCTICO

............................... ............................................... ................................. .......................16 ......16

CONCLUSIONES

................................. ................................................. ................................. .................................. .................................. ................................. ......................17 ......17

BIBLIOGRAFÍAS:

................................. ................................................. ................................. .................................. .................................. ................................. ......................20 ......20

1

 ANALISIS SINTACTICO Todo lenguaje de programación tiene reglas que describen la estructura sintáctica de programas bien formados. En Pascal, por ejemplo, e jemplo, un programa se compone de bloques, un bloque de proposiciones, una proposición de expresiones, una expresión de componentes léxicos, y así sucesivamente. Se puede describir la sintaxis de las construcciones de los lenguajes de programación por medio de gramáticas de contexto libre o notación BNF ( Backus-Naur Form). Las gramáticas ofrecen ventajas significativas a los diseñadores de lenguajes y a los desarrolladores de compiladores. 

Las gramáticas son especificaciones sintácticas y precisas de lenguajes lenguajes de programación.



A partir de una gramática se puede generar automáticamente un un analizador sintáctico.



El proceso proceso de construcción puede llevar a descubrir ambigüedades.



Una gramática proporciona una estructura a un lenguaje lenguaje de programación, siendo más fácil generar código y detectar errores.



Es más fácil ampliar/modificar el lenguaje si está descrito con una gramática.



La mayor parte de este tema está dedicada a los métodos métodos de análisis análisis sintáctico de uso típico en compiladores. Primero se introducen los conceptos básicos, después las técnicas adecuadas para la aplicación manual. Además como los programas pueden contener errores sintácticos, los métodos de análisis sintáctico se pueden ampliar para que se recuperen de los errores sintácticos más frecuentes.

2

GRAMATICA LIBRE DEL CONTEXTO (GLC) Estas gramáticas, conocidas también como gramáticas de tipo 2 o gramáticas independientes del contexto, son las que generan los lenguajes libres o independientes del contexto. Los lenguajes libres del contexto son aquellos que pueden ser reconocidos por un autómata a utómata de pila determinístico o no determinístico. Como toda gramática se definen mediante una cuádrupla G = (N, T, P, S), siendo - N es un conjunto finito de símbolos no terminales - T es un conjunto finito de símbolos terminales - P es un conjunto finito de producciones - S es el símbolo distinguido o axioma En una gramática libre del contexto, cada producción de P tiene la forma

Es decir, que en el lado izquierdo de una producción pueden aparecer el símbolo distinguido o un símbolo no terminal y en el lado derecho de una producción cualquier cadena de símbolos terminales y/o no terminales de longitud mayor o igual que 1. La gramá quiere generar contiene la cadena vacía. Los ejemplos mostrados a continuación corresponden a los lenguajes libres del contexto que fueron introducidos en los ejemplos 1, 2 y 3 del apunte de autómatas de pila. La siguiente gramática genera las cadenas del lenguaje Contiene las siguientes producciones 3

 ÁRBOL DE DERIVACION Un árbol de derivación permite mostrar gráficamente cómo se puede derivar cualquier cadena de un lenguaje a partir del símbolo distinguido de una gramática que genera ese lenguaje. Un árbol es un conjunto de puntos, llamados nodos, unidos por líneas, llamadas arcos. Un arco conecta dos nodos distintos. Para ser se r un árbol un conjunto de nodos y arcos debe satisfacer ciertas propiedades: - hay un único nodo distinguido, llamado raíz (se di buja en la parte superior) que no tiene arcos incidentes. - todo nodo c excepto el nodo raíz está conectado con un arco a otro nodo k, llamado el padre de c (c es el hijo de k). El padre de un nodo, se dibuja por encima del nodo. - todos los nodos están conectados al nodo raíz mediante un único camino. - los nodos que no tienen hijos se denominan hojas, el resto de los nodos se denominan nodos interiores. El árbol de derivación tiene las siguientes propiedades: - el nodo raíz está rotulado con el símbolo distinguido de la gramática; - cada hoja corresponde a un símbolo terminal o un símbolo no terminal; - cada nodo interior corresponde a un símbolo no terminal.

Para cada cadena del lenguaje generado por una gramática es posible construir (al menos) un árbol de derivación, en el cual cada hoja tiene como rótulo uno de los símbolos de la cadena.

4

DIAGRAMA DE SINTAXIS Los diagramas de sintaxis son grafos dirigidos donde los elementos no terminales de la gramática aparecen como rectángulos y los terminales como círculos o elipses.Todo diagrama de sintaxis se supone que tiene un origen y un destino aunque no se dibujan. Correspondencia entre la notación BNF y los diagramas de sintaxis.

5

ELIMINACIÓN DE LA AMBIGÜEDAD Una gramática ambigua permite más de una derivación para la misma forma de sentencia por lo que también habrá más de un [árbol de derivación] para la misma. Por ello basta con encontrar dos [árboles derivación] distintos para la misma forma de sentencia para demostrar que una gramática es ambigua.  A continuación se presentan conceptos importantes dentro del estudio de las características de las gramáticas:

 AMBIGÜEDAD: Sea G = { N , T , P , S } una gramática libre de contexto y sea L(G) el lenguaje generado por esa gramática. Si existe un string w (donde w oe L(G) ) para el cual existen dos ó más formas de realizar la derivación de más a la iz quierda (S ˘ w) ó existen dos ó más formas de realizar la derivación de más a la derecha (S ¿ w), entonces se dice que: G es una gramática ambigua.

TIPOS DE AMBIGÜEDAD: Dentro del estudio de gramáticas existen dos tipos fundamentales de ambigüedad, los cuales son:

6

 AMBIGÜEDAD INHERENTE: Las gramáticas que presentan este tipo de ambigüedad no pueden utilizarse para lenguajes de programación, ya que por más transformaciones que se realicen sobre ellas, NUNCA se podrá eliminar completamente la ambigüedad que presentan.

 AMBIGÜEDAD TRANSITORIA: TRANSITORIA: Este tipo de ambigüedad puede llegar a ser eliminada realizando una serie de transformaciones sobre la gramática original. Una vez que se logra lo anterior, la gramática queda lista para ser reconocida por la mayor parte de los analizadores sintácticos. (Se le considera "ambigüedad" porque existen métodos para realizar análisis sintáctico que no aceptan gramáticas con estas características) Dónde se presenta la Ambigüedad Transitoria: Generalmente la ambigüedad se presenta cuando existen producciones con factores comunes (distintas alternativas para un símbolo no-terminal que inician de la misma forma); ó cuando existen producciones que son recursivas izquierdas (producciones para un símbolo no-terminal en las cuales el primer símbolo de su forma sentencia es ese mismo símbolo no-terminal). no-ter minal).

7

GENERACIÓN DE MATRIZ PREDICTIVA (CÁLCULO FIRST Y FOLLOW)



FIRST:

Sea G := (V; ∑; Q0; P) una gramática libre de contexto. Para cada

forma sentencial α Є (V U ∑)* y para cada k Є N definiremos la función.

En otras palabras, el operador F IRST k asocia a cada forma sentencial los primeros k símbolos de cualquier forma terminal alcanzable desde α mediante derivaciones “masa la izquierda".



FOLLOW: Con

las mismas notaciones anteriores, para cada forma de

sentencia α Є (V U ∑)* definiremos la función FOLLOWG GK (α) del modo siguiente.

De nuevo nos ocuparemos solamente de FOLLOW: = FOLLOW1. Obsérvese que FOLLOW k (α)

⊂

∑* y que para cada x Є FOLLOW (α), Ixl ≤ k. Obsé rvese que para

cada variable A Є V, FOLLOW(A) son todos los símbolos terminales que pueden

aparecer a la derecha de A en alguna forma de sentencia de la gramática. 8

TIPOS DE ANALIZADORES SINTÁCTICOS  ANALIZADOR SINTÁCTICO ASCENDENTE ASCENDENTE En éste analizador las entradas son de izquierda a derecha, y construcciones de derivaciones por la izquierda de una sentencia o enunciado.

CARÁCTERISTICAS El análisis sintáctico descendente (ASD) intenta encontrar entre las producciones de la gramática la derivación por la izquierda del símbolo sí mbolo inicial para una cadena de entrada. Parte del axioma de la gramática. Procesa la entrada de izquierda a derecha. Escoge reglas gramaticales. Bueno primeramente para trabajar el análisis sintáctico descendente se debe realizar primeramente algunas operaciones para que la gramática sea LL1 las cuales son:



ELIMINAR AMBIGUEDAD: Para eliminar eliminar la ambigüedad se debe reescribir la gramática.



ELIMINAR RECURSIVIDAD POR LA IZQUIERDA: Una gramática es recursiva por la izquierda si tiene un nodo Terminal a tal ta l que existe una derivación A- >Aα para alguna cadena . Es decir por simple observación podemos identificar.

9

Para eliminar la recursividad por la izquierda se utiliza la siguiente formula.

Factorizar: Se trata de rescribir las producciones de la gramática con igual comienzo para retrasar la decisión hasta haber visto lo suficiente de la entrada como para elegir la opción correcta.

Ejemplo:

10

 ANÁLISIS SINTÁCTICO DESCENDENTE DESCENDENTE CON RETROCESO. El método parte del axioma inicial y aplica todas las posibles reglas al no terminal más a la izquierda. Se usa el retroceso para resolver la incertidumbre.Sencillo de implementar. Muy eficiente. Ejemplo:

 ANÁLISIS SINTÁCTICO DESCENDENTE PREDICTIVO PREDICTIVO (ASDP) El analizador debe realizar la previsión de la regla a aplicar sólo con ver el primer símbolo que produce para que el algoritmo tenga una complejidad lineal. Las gramáticas que son susceptibles de ser analizadas sintácticamente de forma descendente mediante un análisis predictivo y consultando un únicamente un símbolo de entrada pertenecen al grupo LL(1).  A partir de gramáticas LL(1) se pueden construir analizadores sintácticos descendentes predictivos (ASDP), que son ASD sin retroceso.

11

Ejemplo:

 ANALIZADOR SINTÁCTICO ASCENDENTE El objetivo de un análisis ascendente consiste en construir el árbol sintáctico desde abajo hacia arriba, esto es, desde los tokens hacia el axioma inicial, lo cual disminuye el número de reglas mal aplicadas con respecto al caso descendente (si hablamos del caso con retroceso) o amplía el número de gramáticas susceptibles de ser analizadas (si hablamos del caso LL(1)).  Análisis ascendente con retroceso  Al igual que ocurría con el caso descendente, este tipo de análisis intenta probar todas las posibles operaciones (reducciones y desplazamientos) mediante un método de fuerza bruta, hasta llegar al árbol sintáctico, o bien agotar todas las opciones, en cuyo caso la cadena se rechaza. En el análisis con retroceso no se permiten per miten las reglas ԑ, puesto que estas se s e podrán

aplicar de forma indefinida.  Análisis Ascendente sin Retroceso El análisis ascendente sin retroceso busca una derivación derecha de la cadena de entrada de forma determinista. Este se sustenta en su aplicación a las gramáticas LR(K). La L viene de la lectura de la cadena de entrada de izquierda a derecha. La R de producir un árbol de derivación derecho.

12

La k indica el número de símbolos que es necesario leer a la entrada para tomar la decisión de qué producción emplear. Un parser del tipo shift-reduce puede verse como un autómata de pila determinista extendido que realiza el análisis de abajo hacia arriba. Dada una cadena de entrada w, simula una derivación más a la derecha.

¿Cuál es su diferencia? En el análisis sintáctico descendente: se construye el árbol sintáctico arriba hacia abajo y se utiliza más reglas. En el análisis sintáctico ascendente: se construye constru ye el árbol sintáctico de abajo hacia arriba, lo cual disminuye el número de reglas mal aplicadas con respecto al caso descendente.

13

MANEJO DE ERRORES Si un compilador tuviera que procesar sólo programas correctos, su diseño e implantación se simplificarían mucho. Pero los programadores a menudo escriben programas incorrectos, y un buen compilador debería ayudar al programador a identificar y localizar errores. Es más, considerar desde el principio el manejo de errores puede simplificar la estructura de un compilador y mejorar su respuesta a los errores. Los errores en la programación pueden ser de los siguientes tipos: • Léxicos, producidos al escribir m al un identificador, una palabra clave o un

operador. • Sintácticos, por una expresión aritmética o paréntesis no equilibrados. • Semánticos, como un operador aplicado a un operando incompatible. • Lógicos, puede ser una llamada infinitamente recursiva.

El manejo de errores de sintaxis es el más complicado desde el punto de v ista 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 debe tener como objetivos: • 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.

Un buen compilador debe hacerse siempre teniendo también en mente los errores que se pueden producir; con ello se consigue: • Simplificar la estructura del compilador. • Mejorar la respuesta ante los errores.

Tenemos varias estrategias para corregir errores, una vez detectados: • Ignorar el problema (Panic mode )  : Consiste en ignorar el resto de la entrada hasta

llegar a una condición de seguridad. Una condición tal se produce cuando nos

14

encontramos un token especial (por ejemplo ej emplo un ‘;’ o un ‘END’).A partir de est e punto

se sigue analizando normalmente. Ejemplo:

•

Recuperación a nivel de frase: Intenta recuperar el error una vez descubierto. En el caso anterior, por ejemplo, podría haber sido lo suficientemente inteligente como para insertar el t oken ‘;’ . Hay  que tener cuidado con este método, pues puede dar

lugar a recuperaciones infinitas. •

Reglas de producción adicionales para el control de errores : La gramática se puede aumentar con las reglas que reconocen los errores más comunes. En el caso anterior, se podría haber puesto algo como:

Lo cual nos da mayor control en ciertas circunstancias • Corrección Global: Dada una secuencia completa de tokens a ser reconocida, si

hay algún error por el que no se puede reconocer, consiste en encontrar la secuencia completa más parecida que sí se pueda reconocer. Es decir, el analizador sintáctico le pide toda la secuencia de tokens al léxico, y lo que hace es devolver lo más parecido a la cadena de entrada pero sin errores, así como el árbol que lo reconoce. 15

GENERADOR DE ANALIZADOR SINTÁCTICO  Ascendente

Descendentes

16

CONCLUSIONES SERGIO IVÁN YAM DZUL  A lo largo del curso hemos conocido y analizados términos aplicables a los compiladores e intérpretes, los cuales nos permiten traducir o trasladar un lenguaje de programación a un lenguaje de la computadora. Durante el procedimiento se han detallado las etapas y los componentes que interviene, así como también se han presentado elementos que interactúan tal co mo lo hacen las reglas idiomáticas, procurando una sintaxis adecuada y respetando reglas sintácticas. Observando a cada elemento por separado y luego analizando su integración. De esta manera podemos entender el proceso interno para traducción del lenguajes, así también es posible obtener por fuera de un editor, es decir usar una aplicación como el JLEX en basic. En última instancia observamos diversas técnicas para la implementación y/o creación de los autómatas, en los cuales se observaron sus características y funcionamiento. Se comprendió la manera en la que estos tratan a los errores y así como también se informa a la usuario, clasificando los errores (en opinión personal) de sintaxis y lógicos, los primeros corresponden a errores de escritura por parte del progr amador quien por omisión o descuido olvido agregar un componente de la sintaxis, el segundo igual por error del programador que ha utilizado de manera inadecuada las herramientas del lenguaje. Los compiladores deberán analizar el componente faltante y ubicar su posición exacta dándole al programador una muy clara descripción del error, mencionado que el pasado esto no era posible pues si un error se origina el programador debía revisar línea por linar hasta hallar el error. Estas herramientas han proporcionado al programador un ¿elemento de suma valía para su efectuar su trabajo, y esto puede derivar en crear lenguajes y aplicación más potentes y avanzadas 17

MANUEL ARMANDO HERNANDEZ MOGUEL En conclusión tenemos que mientras estuvimos viendo la materia de lenguajes y autómatas hemos aprendido y entendido cuales son las funciones que realiza un compilador ya que vimos cómo se van ligando con sus procesos y funciones en el lenguaje de programación que se tengo o utilice.  Ahora sabemos igual como poder reconocer los errores que se tiene tiene en la gramática del GLC que tiene un árbol de derivación y que pueden hacerse de esta misma forma(árbol) igual vimos el tipo de gramática llamada ambigua que es la que se obtiene de más de un árbol de derivación y de varias maneras más. Al igual ya sabemos que tenemos que tener cuidado porque no existe ningún tipo de manera de saber mediante un software si un algoritmo es ambiguo o no pero aun así existen técnicas para saber si tenemos ambigüedad o no en nuestra gramática También vimos cómo crear un lenguaje de programación y si nuestros arboles tiene alguna ambigüedad etc. Y así poder corregirla.

MARTIN EMMANUEL HERRERA ZAVALA Tras concluir con esta unidad podemos decir que el tema de los analizadores sintácticos, analizadores léxicos, entre otros son partes fundamentales dentro de lo compiladores de lenguaje o bien dicho, dentro de los programas que nos permiten realizar aplicaciones mediante lenguajes de programación, ay que permiten detectar la sintaxis que hemos creado y si por alguna razón existe un error dentro de la gramática, este nos avisa y a su vez no permite detectar y señalar en donde se encuentra el error, bien ahora se puede observar desde otro punto de vista los proceso que se realizan tras compilar un lenguaje de programación en una aplicación que nos permite desarrollar software. De igual manera tras haber También podemos saber que no ha y manera de detectar si algún algoritmo que nosotros creemos pueda ser ambiguo, aunque existen algunas técnicas para saber si existe la ambigüedad dentro de nuestra gramática. 18

JUAN ALFREDO MALDONADO ALAMILLA Durante el transcurso de la materia de autómatas vimos temas relacionados a las bases para poder crear o poder entender lo que hace un compilador e interprete en alguna plataforma de programación. Hemos visto los procesos que hace una pequeña porción de programa que en conjunto hacen el trabajo del compilador y esta parte no es visible al programador. En esta unidad vimos como poder reconocer los errores de gramática a través del GLC (gramáticas libres de contexto) que tiene como conceptos el árbol de derivación que nos dice que las derivaciones pueden hacerse de forma de árbol, la gramática ambigua (w se denomina ambigua si puede obtenerse por más de un árbol de derivación), entre otros. La ambigüedad es muy importante ya que si la gramática presenta alguna alguna ambigüedad puede no ser apto para usarse en algún lenguaje de programación dependiendo del tipo de ambigüedad que tenga. No existe ningún algoritmo que nos indique si un GLC es ambiguo por lo que hay que tener cuidado con este punto. Para las construcciones construcciones de los los lenguajes de programación comunes existen técnicas técnicas para la eliminación eliminación de la ambigüedad. Para concluir en esta unidad, vimos las formas de cómo crear un lenguaje de programación, tanto como detectar si los arboles presentan alguna ambigüedad y como poder corregirla para poder implementarlo en un lenguaje de programación que se quiera crear, esto complementa las demás unidades ya que en las anteriores vimos cómo se conforma y como trabaja el compilador y el intérprete y estos elementos a su vez pertenecen a un lenguaje de programación.

19

BIBLIOGRAFÍAS: http://www.lcc.uma.es/~galvez/ftp/tci/tictema3.pdf  http://www.dia.fi.upm.es/~jgarcia/it/MaterialDidactico_ficheros/Practicas/FormasNo rmales.pdf  http://www.exa.unicen.edu.ar/catedras/ccomp1/Apunte5.pdf  http://sycg.wordpress.com/2010/12/14/analizador-sintactico-ascendente-ydescendente/ http://www.giaa.inf.uc3m.es/docencia/ITIG/sintactico.pdf 

20