Introducción al Análisis Sintáctico Gramáticas de Contexto Libre, Arboles de Parseo y Derivaciones

Oscar Bonilla 2 Universidad Galileo Resumen Overview del análisis léxico Qué es análisis sintáctico Gramáticas libres de contexto Derivaciones y árboles de parseo Top-down vs. Bottom-up Parsing Grámaticas Ambiguas Implementando un Parser Oscar Bonilla 2 Universidad Galileo

Anatomia de un Compilador Programa (character stream) Analizador Léxico (Scanner) Token Stream Analizador Sintáctico (Parser) Arbol de Parseo Generador de Código Intermedio Representación Intermedia Optimizador Representación Intermedia Optimizada Generador de Código Código en Assembler Oscar Bonilla 3 Universidad Galileo

Resumen de Análisis Léxico El analizador léxico crea tokens a partir de un character stream Los tokens se definen usando expresiones regulares Oscar Bonilla 4 Universidad Galileo

Expresiones Regulares, Gramáticas y Lenguajes Una expresión regular puede ser escrita usando: Caracteres en el alfabeto Operadores de expresiones regulares: ‘*’ ‘·’ ‘|’ ‘+’ ‘?’ ‘(‘ ‘)’ Ejemplo: (-| ε) ·(0|1|2|3|4|5|6|7|8|9)+ · (. ·(0|1|2|3|4|5|6|7|8|9)*)? Un lenguaje regular es un lenguaje definido por una expresión regular Oscar Bonilla 5 Universidad Galileo

Expresiones Regulares, Gramáticas y Lenguajes Qué hay acerca de las variables simbólicas? Ejemplo: num = 0|1|2|3|4|5|6|7|8|9 posint = num · num* int = (ε | -) · posint real = int · (ε | (. · posint)) Sólo son una abreviación, llamada “syntactic sugar” Ejemplo: (-| ε) ·(0|1|2|3|4|5|6|7|8|9)+ · (. ·(0|1|2|3|4|5|6|7|8|9)*)? Oscar Bonilla 6 Universidad Galileo

Resumen de Análisis Léxico El analizador léxico crea tokens a partir de un character stream Los tokens se definen usando expresiones regulares Las expresiones regulares pueden mapearse a un Automaton Finito No Determinístico (NFA) Por construcción simple NFA se transforma a un DFA Algoritmo de transformación Ejecutar un DFA es fácil Oscar Bonilla 7 Universidad Galileo

Oscar Bonilla 8 Universidad Galileo Resumen Overview del análisis léxico Qúe es análisis sintáctico Gramáticas libres de contexto Derivación y Arboles de Parseo Top-down vs. Bottom-up Parsing Gramáticas Ambiguas Implementando un Parser Oscar Bonilla 8 Universidad Galileo

Sintaxis y Semántica de un Lenguaje de Programación? Como se ve un programa Representación textual o estructura Es posible una definición matemática precisa Semántica Cuál es el significado de un programa Es más difícil dar una definición matemática Oscar Bonilla 9 Universidad Galileo

Por qué hacer análisis sintáctico? Podemos proveer una definición precisa y fácil de entender Una gramática apropiada imparte estructura a un lenguaje de programación Podemos construir automáticamente un parser que determine si el programa es sintácticamente correcto Ayuda en el proceso de traducción Fácil modificar/añadir al lenguaje Oscar Bonilla 10 Universidad Galileo

Anatomia de un Compilador Programa (character stream) Analizador Léxico (Scanner) Token Stream Analizador Sintáctico (Parser) Arbol de Parseo Generador de Código Intermedio Representación Intermedia Optimizador de Código Representación Intermedia Optimizada Generador de Código Código en Assembler Oscar Bonilla 11 Universidad Galileo

Entrada y Salida de un Parser Token Stream Arbol de Parseo minus_op - ( left_paren_op Analizador Sintáctico (Parser) num(123.3) 123.3 ) plus_op num(23.6) + 23.6 right_paren_op Oscar Bonilla 12 Universidad Galileo

Definición de la Sintaxis Tenemos que proveer una definición precisa y fácil de entender de la sintaxis del lenguaje de programación Podemos usar expresiones regulares? Podemos usar un lenguaje regular para definir un lenguaje de programación? Oscar Bonilla 13 Universidad Galileo

Ejemplo: Scope Jerárquico Procedure foo(integer m, integer n, integer j) { for i = 1 to n do { if (i == j) { j = j + 1; m = i*j; } for k = i to n { m = m + k; Oscar Bonilla 14 Universidad Galileo

Ejemplo: Scope Jerárquico Procedure foo(integer m, integer n, integer j) { for i = 1 to n do { if (i == j) { j = j + 1; m = i*j; } for k = i to n { m = m + k; Problema de los paréntesis balanceados Ejemplo: {{}{{{}{{}}}}} Oscar Bonilla 15 Universidad Galileo

Problema de los paréntesis balanceados Podemos definir esto usando una expresión regular? Oscar Bonilla 16 Universidad Galileo

Problema de los paréntesis balanceados Podemos definir esto usando una expresión regular? NO! Oscar Bonilla 17 Universidad Galileo

Problema de los paréntesis balanceados Podemos definir esto usando una expresión regular? NO! Intuición Número de paréntesis abiertos debe ser igual a número de paréntesis cerrados Necesitamos mantener un conteo o necesitamos recursión Además: NFA’s y DFA’s no pueden ejecutar conteo sin límites Oscar Bonilla 18 Universidad Galileo

Problema de los paréntesis balanceados Hay alguna gramática que defina esto? <S>  ( <S> ) <S> | ε La definición es recursiva Esta es una gramática libre de contexto Es más expresiva que las expresiones regulares Oscar Bonilla 19 Universidad Galileo

Oscar Bonilla 20 Universidad Galileo Resumen Overview del análisis léxico Qué es análisis sintáctico? Gramáticas libres de contexto Derivación y Arboles de Parseo Top-down vs. Bottom-up Parsing Gramáticas Ambiguas Implementando un Parser Oscar Bonilla 20 Universidad Galileo

Definiendo Context-Free Grammars (CFGs) Terminales Símbolos para strings o tokens No terminales Variables sintácticas Símbolo de Inicio Un no-terminal especial es designado Producciones La forma en que los terminales y no-terminales son combinados para formar strings Un no-terminal en el lado izquierdo (LHS) y un string de terminales y no-terminales en el lado derecho (RHS) Oscar Bonilla 21 Universidad Galileo

Oscar Bonilla 22 Universidad Galileo Ejemplo de una CFG <S>  ( <S> ) <S> | ε Oscar Bonilla 22 Universidad Galileo

Oscar Bonilla 23 Universidad Galileo Ejemplo de una CFG <S>  ( <S> ) <S> <S>  ε Oscar Bonilla 23 Universidad Galileo

Oscar Bonilla 24 Universidad Galileo Ejemplo de una CFG <S>  ( <S> ) <S> <S>  ε Terminales Oscar Bonilla 24 Universidad Galileo

Oscar Bonilla 25 Universidad Galileo Ejemplo de una CFG <S>  ( <S> ) <S> <S>  ε No-terminales Oscar Bonilla 25 Universidad Galileo

Oscar Bonilla 26 Universidad Galileo Ejemplo de una CFG <S>  ( <S> ) <S> <S>  ε Símbolo de Inicio: <S> Oscar Bonilla 26 Universidad Galileo

Oscar Bonilla 27 Universidad Galileo Ejemplo de una CFG <S>  ( <S> ) <S> <S>  ε Producciones Oscar Bonilla 27 Universidad Galileo

Oscar Bonilla 28 Universidad Galileo Los lenguajes regulares son un subconjunto de los lenguajes libres de contexto Expresión Regular Gramática libre de contexto a <A>  a Si p y q son expresiones regulares, usando CFGs <P> y <Q> p · q <S>  <P> <Q> p | q <S>  <P> <S>  <Q> p * <S>  <S> <P> <S>  ε Oscar Bonilla 28 Universidad Galileo

Oscar Bonilla 29 Universidad Galileo Los lenguajes regulares son un subconjunto de los lenguajes libres de contexto Expresión Regular Gramática libre de contexto Si p es una expresión regular, usando una CFG <P>, Qué es? <S>  <S> <P> <S>  <P> ??? P? ??? Oscar Bonilla 29 Universidad Galileo

Entonces por qué usar expresiones regulares? Separar el análisis sintáctico en partes léxica y no-léxica es una buena modularización Las reglas léxicas son simples y pueden ser expresadas usando expresiones regulares Las expresiones regulares son más concisas Las implementaciones de analizadores léxicos para expresiones regulares son más eficientes Oscar Bonilla 30 Universidad Galileo

Oscar Bonilla 31 Universidad Galileo Creando una CFG Tenemos que crear una CFG a partir de las definiciones del lenguaje Hay muchas cosas involucradas Vamos a ver algunas de ellas en clase Veamos un lenguaje simple Oscar Bonilla 31 Universidad Galileo

Ejemplo: Una CFG para expresiones Expresiones aritméticas simples con + y * 8.2 + 35.6 8.32 + 86 * 45.3 (6.001 + 6.004) * (6.035 * -(6.042 + 6.046)) Terminales (o tokens) num para todos los números plus_op (‘+’), minus_op (‘-’), times_op(‘*’), left_paren_op(‘(‘), right_paren_op(‘)’) Cuál es la gramática para todas las expresiones posibles? Oscar Bonilla 32 Universidad Galileo

Ejemplo: Una CFG para expresiones <expr>  <expr> <op> <expr> <expr>  ( <expr> ) <expr>  - <expr> <expr>  num <op>  + <op>  * Oscar Bonilla 33 Universidad Galileo

Ejemplo: Una CFG para expresiones <expr>  <expr> <op> <expr> <expr>  ( <expr> ) <expr>  - <expr> <expr>  num <op>  + <op>  * Terminales Oscar Bonilla 34 Universidad Galileo

Ejemplo: Una CFG para expresiones <expr>  <expr> <op> <expr> <expr>  ( <expr> ) <expr>  - <expr> <expr>  num <op>  + <op>  * Terminales Oscar Bonilla 35 Universidad Galileo

Ejemplo: Una CFG para expresiones <expr>  <expr> <op> <expr> <expr>  ( <expr> ) <expr>  - <expr> <expr>  num <op>  + <op>  * No-terminales Oscar Bonilla 36 Universidad Galileo

Ejemplo: Una CFG para expresiones <expr>  <expr> <op> <expr> <expr>  ( <expr> ) <expr>  - <expr> <expr>  num <op>  + <op>  * No-terminales Oscar Bonilla 37 Universidad Galileo

Ejemplo: Una CFG para expresiones <expr>  <expr> <op> <expr> <expr>  ( <expr> ) <expr>  - <expr> <expr>  num <op>  + <op>  * Símbolo de Inicio: <expr> Oscar Bonilla 38 Universidad Galileo

Ejemplo: Una CFG para expresiones <expr>  <expr> <op> <expr> <expr>  ( <expr> ) <expr>  - <expr> <expr>  num <op>  + <op>  * Producciones Oscar Bonilla 39 Universidad Galileo

Ejemplo: Una CFG para expresiones <expr>  <expr> <op> <expr> <expr>  ( <expr> ) <expr>  - <expr> <expr>  num <op>  + <op>  * Oscar Bonilla 40 Universidad Galileo

Ejemplo: Una CFG para expresiones <expr>  <expr> <op> <expr> | ( <expr> ) | - <expr> | num <op>  + | * Oscar Bonilla 41 Universidad Galileo

Pregunta: Cuál es el lenguaje definido por esta CFG? <S>  a<S>a | aa Oscar Bonilla 42 Universidad Galileo

Oscar Bonilla 43 Universidad Galileo Resumen Overview de análisis léxico Qué es análisis sintáctico? Gramáticas libres de contexto Derivaciones y Arboles de Parseo Top-down vs. Bottom-up Parsing Gramáticas Ambiguas Implementando un Parser Oscar Bonilla 43 Universidad Galileo

Oscar Bonilla 44 Universidad Galileo Derivaciones Cómo mostramos que una secuencia de tokens es aceptada por una CFG? Una producción es usada para derivar una secuencia de tokens a partir del símbolo de inicio Dados los strings , y  y una producción A   Un solo paso de la derivación es A   Oscar Bonilla 44 Universidad Galileo

Oscar Bonilla 45 Universidad Galileo Ejemplo de Derivación Gramática <expr>  <expr><op><expr> | (<expr>) | -<expr> | num <op>  + | * Entrada 36 * ( 8 + 23.4) Token Stream num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 45 Universidad Galileo

Oscar Bonilla 46 Universidad Galileo Ejemplo de Derivación <expr> num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 46 Universidad Galileo

Oscar Bonilla 47 Universidad Galileo Ejemplo de Derivación <expr> num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 47 Universidad Galileo

Oscar Bonilla 48 Universidad Galileo Ejemplo de Derivación <expr>  <expr><op><expr> <expr> num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 48 Universidad Galileo

Oscar Bonilla 49 Universidad Galileo Ejemplo de Derivación <expr>  <expr><op><expr> <expr>  <expr> <op> <expr> num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 49 Universidad Galileo

Oscar Bonilla 50 Universidad Galileo Ejemplo de Derivación <expr>  <expr> <op> <expr> num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 50 Universidad Galileo

Oscar Bonilla 51 Universidad Galileo Ejemplo de Derivación <expr>  <expr> <op> <expr> num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 51 Universidad Galileo

Oscar Bonilla 52 Universidad Galileo Ejemplo de Derivación <expr>  num <expr>  <expr> <op> <expr> num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 52 Universidad Galileo

Oscar Bonilla 53 Universidad Galileo Ejemplo de Derivación <expr>  num <expr>  <expr> <op> <expr>  num <op> <expr> num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 53 Universidad Galileo

Oscar Bonilla 54 Universidad Galileo Ejemplo de Derivación <expr>  <expr> <op> <expr>  num <op> <expr> num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 54 Universidad Galileo

Oscar Bonilla 55 Universidad Galileo Ejemplo de Derivación <expr>  <expr> <op> <expr>  num <op> <expr> num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 55 Universidad Galileo

Oscar Bonilla 56 Universidad Galileo Ejemplo de Derivación <op>  * <expr>  <expr> <op> <expr>  num <op> <expr> num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 56 Universidad Galileo

Oscar Bonilla 57 Universidad Galileo Ejemplo de Derivación <op>  * <expr>  <expr> <op> <expr>  num <op> <expr>  num ‘*’ <expr> num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 57 Universidad Galileo

Oscar Bonilla 58 Universidad Galileo Ejemplo de Derivación <expr>  <expr> <op> <expr>  num <op> <expr>  num ‘*’ <expr> num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 58 Universidad Galileo

Oscar Bonilla 59 Universidad Galileo Ejemplo de Derivación <expr>  <expr> <op> <expr>  num <op> <expr>  num ‘*’ <expr> num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 59 Universidad Galileo

Oscar Bonilla 60 Universidad Galileo Ejemplo de Derivación <expr>  (<expr>) <expr>  <expr> <op> <expr>  num <op> <expr>  num ‘*’ <expr> num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 60 Universidad Galileo

Oscar Bonilla 61 Universidad Galileo Ejemplo de Derivación <expr>  (<expr>) <expr>  <expr> <op> <expr>  num <op> <expr>  num ‘*’ <expr>  num ‘*’ ‘(‘ <expr> ‘)’ num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 61 Universidad Galileo

Oscar Bonilla 62 Universidad Galileo Ejemplo de Derivación <expr>  <expr> <op> <expr>  num <op> <expr>  num ‘*’ <expr>  num ‘*’ ‘(‘ <expr> ‘)’ num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 62 Universidad Galileo

Oscar Bonilla 63 Universidad Galileo Ejemplo de Derivación <expr>  <expr> <op> <expr>  num <op> <expr>  num ‘*’ <expr>  num ‘*’ ‘(‘ <expr> ‘)’ num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 63 Universidad Galileo

Oscar Bonilla 64 Universidad Galileo Ejemplo de Derivación <expr>  <expr><op><expr> <expr>  <expr> <op> <expr>  num <op> <expr>  num ‘*’ <expr>  num ‘*’ ‘(‘ <expr> ‘)’ num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 64 Universidad Galileo

Oscar Bonilla 65 Universidad Galileo Ejemplo de Derivación <expr>  <expr><op><expr> <expr>  <expr> <op> <expr>  num <op> <expr>  num ‘*’ <expr>  num ‘*’ ‘(‘ <expr> ‘)’  num ‘*’ ‘(‘ <expr> <op> <expr> ‘)’ num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 65 Universidad Galileo

Oscar Bonilla 66 Universidad Galileo Ejemplo de Derivación <expr>  <expr> <op> <expr>  num <op> <expr>  num ‘*’ <expr>  num ‘*’ ‘(‘ <expr> ‘)’  num ‘*’ ‘(‘ <expr> <op> <expr> ‘)’ num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 66 Universidad Galileo

Oscar Bonilla 67 Universidad Galileo Ejemplo de Derivación <expr>  <expr> <op> <expr>  num <op> <expr>  num ‘*’ <expr>  num ‘*’ ‘(‘ <expr> ‘)’  num ‘*’ ‘(‘ <expr> <op> <expr> ‘)’ num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 67 Universidad Galileo

Oscar Bonilla 68 Universidad Galileo Ejemplo de Derivación <expr>  num <expr>  <expr> <op> <expr>  num <op> <expr>  num ‘*’ <expr>  num ‘*’ ‘(‘ <expr> ‘)’  num ‘*’ ‘(‘ <expr> <op> <expr> ‘)’ num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 68 Universidad Galileo

Oscar Bonilla 69 Universidad Galileo Ejemplo de Derivación <expr>  num <expr>  <expr> <op> <expr>  num <op> <expr>  num ‘*’ <expr>  num ‘*’ ‘(‘ <expr> ‘)’  num ‘*’ ‘(‘ <expr> <op> <expr> ‘)’  num ‘*’ ‘(‘ num <op> <expr> ‘)’ num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 69 Universidad Galileo

Oscar Bonilla 70 Universidad Galileo Ejemplo de Derivación <expr>  <expr> <op> <expr>  num <op> <expr>  num ‘*’ <expr>  num ‘*’ ‘(‘ <expr> ‘)’  num ‘*’ ‘(‘ <expr> <op> <expr> ‘)’  num ‘*’ ‘(‘ num <op> <expr> ‘)’ num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 70 Universidad Galileo

Oscar Bonilla 71 Universidad Galileo Ejemplo de Derivación <expr>  <expr> <op> <expr>  num <op> <expr>  num ‘*’ <expr>  num ‘*’ ‘(‘ <expr> ‘)’  num ‘*’ ‘(‘ <expr> <op> <expr> ‘)’  num ‘*’ ‘(‘ num <op> <expr> ‘)’ num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 71 Universidad Galileo

Oscar Bonilla 72 Universidad Galileo Ejemplo de Derivación <op>  + <expr>  <expr> <op> <expr>  num <op> <expr>  num ‘*’ <expr>  num ‘*’ ‘(‘ <expr> ‘)’  num ‘*’ ‘(‘ <expr> <op> <expr> ‘)’  num ‘*’ ‘(‘ num <op> <expr> ‘)’ num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 72 Universidad Galileo

Oscar Bonilla 73 Universidad Galileo Ejemplo de Derivación <op>  + <expr>  <expr> <op> <expr>  num <op> <expr>  num ‘*’ <expr>  num ‘*’ ‘(‘ <expr> ‘)’  num ‘*’ ‘(‘ <expr> <op> <expr> ‘)’  num ‘*’ ‘(‘ num <op> <expr> ‘)’  num ‘*’ ‘(‘ num ‘+’ <expr> ‘)’ num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 73 Universidad Galileo

Oscar Bonilla 74 Universidad Galileo Ejemplo de Derivación <expr>  <expr> <op> <expr>  num <op> <expr>  num ‘*’ <expr>  num ‘*’ ‘(‘ <expr> ‘)’  num ‘*’ ‘(‘ <expr> <op> <expr> ‘)’  num ‘*’ ‘(‘ num <op> <expr> ‘)’  num ‘*’ ‘(‘ num ‘+’ <expr> ‘)’ num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 74 Universidad Galileo

Oscar Bonilla 75 Universidad Galileo Ejemplo de Derivación <expr>  <expr> <op> <expr>  num <op> <expr>  num ‘*’ <expr>  num ‘*’ ‘(‘ <expr> ‘)’  num ‘*’ ‘(‘ <expr> <op> <expr> ‘)’  num ‘*’ ‘(‘ num <op> <expr> ‘)’  num ‘*’ ‘(‘ num ‘+’ <expr> ‘)’ num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 75 Universidad Galileo

Oscar Bonilla 76 Universidad Galileo Ejemplo de Derivación <expr>  num <expr>  <expr> <op> <expr>  num <op> <expr>  num ‘*’ <expr>  num ‘*’ ‘(‘ <expr> ‘)’  num ‘*’ ‘(‘ <expr> <op> <expr> ‘)’  num ‘*’ ‘(‘ num <op> <expr> ‘)’  num ‘*’ ‘(‘ num ‘+’ <expr> ‘)’ num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 76 Universidad Galileo

Oscar Bonilla 77 Universidad Galileo Ejemplo de Derivación <expr>  num <expr>  <expr> <op> <expr>  num <op> <expr>  num ‘*’ <expr>  num ‘*’ ‘(‘ <expr> ‘)’  num ‘*’ ‘(‘ <expr> <op> <expr> ‘)’  num ‘*’ ‘(‘ num <op> <expr> ‘)’  num ‘*’ ‘(‘ num ‘+’ <expr> ‘)’  num ‘*’ ‘(‘ num ‘+’ num ‘)’ num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 77 Universidad Galileo

Oscar Bonilla 78 Universidad Galileo Ejemplo de Derivación <expr>  <expr> <op> <expr>  num <op> <expr>  num ‘*’ <expr>  num ‘*’ ‘(‘ <expr> ‘)’  num ‘*’ ‘(‘ <expr> <op> <expr> ‘)’  num ‘*’ ‘(‘ num <op> <expr> ‘)’  num ‘*’ ‘(‘ num ‘+’ <expr> ‘)’  num ‘*’ ‘(‘ num ‘+’ num ‘)’ num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 78 Universidad Galileo

Oscar Bonilla 79 Universidad Galileo Arbol de Parseo Representación gráfica de la estructura parseada Muestra la secuencia de derivaciones efectuada Nodos internos son no-terminales Hojas son terminales Cada nodo padre es el lado izquierdo (LHS) y los hijos son el lado derecho (RHS) de una producción Oscar Bonilla 79 Universidad Galileo

Ejemplo de Arbol de Parseo <expr> Oscar Bonilla 80 Universidad Galileo

Ejemplo de Arbol de Parseo <expr>  <expr> <op> <expr> <expr> <expr> <op> <expr> Oscar Bonilla 81 Universidad Galileo

Ejemplo de Arbol de Parseo <expr>  num <expr> <expr> <op> <expr> num Oscar Bonilla 82 Universidad Galileo

Ejemplo de Arbol de Parseo <op>  ‘*’ <expr> <expr> <op> <expr> num * Oscar Bonilla 83 Universidad Galileo

Ejemplo de Arbol de Parseo <expr>  ‘(‘ <expr> ‘)’ <expr> <expr> <op> <expr> <expr> num * ( ) Oscar Bonilla 84 Universidad Galileo

Ejemplo de Arbol de Parseo <expr>  <expr> <op> <expr> <expr> <expr> <op> <expr> <expr> num * ( ) <expr> <op> <expr> Oscar Bonilla 85 Universidad Galileo

Ejemplo de Arbol de Parseo <expr>  num <expr> <expr> <op> <expr> <expr> num * ( ) <expr> <op> <expr> num Oscar Bonilla 86 Universidad Galileo

Ejemplo de Arbol de Parseo <op>  ‘+’ <expr> <expr> <op> <expr> <expr> num * ( ) <expr> <op> <expr> num + Oscar Bonilla 87 Universidad Galileo

Ejemplo de Arbol de Parseo <expr>  num <expr> <expr> <op> <expr> <expr> num * ( ) <expr> <op> <expr> num num + Oscar Bonilla 88 Universidad Galileo

Ejemplo de Arbol de Parseo num ‘*’ ‘(‘ num ‘+’ num ‘)’ <expr> <expr> <op> <expr> <expr> num * ( ) <expr> <op> <expr> num num + Oscar Bonilla 89 Universidad Galileo

Oscar Bonilla 90 Universidad Galileo Resumen Overview del análisis léxico Qué es análisis sintáctico? Gramáticas libres de contexto Derivaciones y Arboles de Parseo Top-down vs. Bottom-up Parsing Gramáticas Ambiguas Implementando un Parser Oscar Bonilla 90 Universidad Galileo

Derivaciones left-most vs. right-most Leftmost derivation En el string, encontramos el no-terminal de más a la izquierda y le aplicamos una producción El ejemplo anterior fue de una leftmos derivation Rightmost derivation Encontramos el no-terminal de más a la derecha y le aplicamos una producción Oscar Bonilla 91 Universidad Galileo

Ejemplo de Right-Derivation Producción: String: <expr> <expr> Oscar Bonilla 92 Universidad Galileo

Ejemplo de Right-Derivation Producción: <expr>  <expr> <op> <expr> String: <expr> <op> <expr> <expr> <expr> <op> <expr> Oscar Bonilla 93 Universidad Galileo

Ejemplo de Right-Derivation Producción: <expr>  ‘(‘ <expr> ‘)’ String: <expr> <op> ‘(‘ <expr> ‘)’ <expr> <expr> <op> <expr> <expr> ( ) Oscar Bonilla 94 Universidad Galileo

Ejemplo de Right-Derivation Producción: <expr>  <expr> <op> <expr> String: <expr> <op> ‘(‘ <expr> <op> <expr> ‘)’ <expr> <expr> <op> <expr> <expr> ( ) <expr> <op> <expr> Oscar Bonilla 95 Universidad Galileo

Ejemplo de Right-Derivation Producción: <expr>  num String: <expr> <op> ‘(‘ <expr> <op> num ‘)’ <expr> <expr> <op> <expr> <expr> ( ) <expr> <op> <expr> num Oscar Bonilla 96 Universidad Galileo

Ejemplo de Right-Derivation Producción: <op>  ‘+’ String: <expr> <op> ‘(‘ <expr> ‘+’ num ‘)’ <expr> <expr> <op> <expr> <expr> ( ) <expr> <op> <expr> num + Oscar Bonilla 97 Universidad Galileo

Ejemplo de Right-Derivation Producción: <expr>  num String: <expr> <op> ‘(‘ num ‘+’ num ‘)’ <expr> <expr> <op> <expr> <expr> ( ) <expr> <op> <expr> num num + Oscar Bonilla 98 Universidad Galileo

Ejemplo de Right-Derivation Producción: <op>  ‘*’ String: <expr> ‘*’ ‘(‘ num ‘+’ num ‘)’ <expr> <expr> <op> <expr> <expr> * ( ) <expr> <op> <expr> num num + Oscar Bonilla 99 Universidad Galileo

Ejemplo de Right-Derivation Producción: <expr>  num String: num ‘*’ ‘(‘ num ‘+’ num ‘)’ <expr> <expr> <op> <expr> <expr> num * ( ) <expr> <op> <expr> num num + Oscar Bonilla 100 Universidad Galileo

Ejemplo de Right-Derivation String: num ‘*’ ‘(‘ num ‘+’ num ‘)’ <expr> <expr> <op> <expr> <expr> num * ( ) <expr> <op> <expr> num num + Oscar Bonilla 101 Universidad Galileo

Ejemplo de Right-Derivation  <expr>  <expr> <op> <expr>  <expr> <op> ‘(‘ <expr> ‘)’  <expr> <op> ‘(‘ <expr> <op> <expr> ‘)’  <expr> <op> ‘(‘ <expr> <op> num ‘)’  <expr> <op> ‘(‘ <expr> ‘+’ num ‘)’’  <expr> <op> ‘(‘ num ‘+’ num ‘)’  <expr> ‘*’ ‘(‘ num ‘+’ num ‘)’  num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 102 Universidad Galileo

Top-down vs. Bottom-up Parsing Normalmente escaneamos de izquierda a derecha Left-most derivation refleja top-down parsing Comenzamos con el símbolo inicial Terminamos con el string de tokens Oscar Bonilla 103 Universidad Galileo

Oscar Bonilla 104 Universidad Galileo Top-down Parsing Left-most derivation  <expr>  <expr> <op> <expr>  num <op> <expr>  num ‘*’ <expr>  num ‘*’ ‘(‘ <expr> ‘)’  num ‘*’ ‘(‘ <expr> <op> <expr> ‘)’  num ‘*’ ‘(‘ num <op> <expr> ‘)’  num ‘*’ ‘(‘ num ‘+’ <expr> ‘)’  num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 104 Universidad Galileo

Top-down vs. Bottom-up Parsing Normalmente escaneamos de izquierda a derecha Left-most derivation refleja top-down parsing Comenzamos con el símbolo inicial Terminamos con el string de tokens Right-most derivation refleja bottom-up parsing Comenzamos con el string de tokens Terminamos con el símbolo inicial Oscar Bonilla 105 Universidad Galileo

Oscar Bonilla 106 Universidad Galileo Bottom-up Parsing Right-most derivation  <expr>  <expr> <op> <expr>  <expr> <op> ‘(‘ <expr> ‘)’  <expr> <op> ‘(‘ <expr> <op> <expr> ‘)’  <expr> <op> ‘(‘ <expr> <op> num ‘)’  <expr> <op> ‘(‘ <expr> ‘+’ num ‘)’’  <expr> <op> ‘(‘ num ‘+’ num ‘)’  <expr> ‘*’ ‘(‘ num ‘+’ num ‘)’  num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 106 Universidad Galileo

Oscar Bonilla 107 Universidad Galileo Bottom-up Parsing Right-most derivation  <expr>  <expr> <op> <expr>  <expr> <op> ‘(‘ <expr> ‘)’  <expr> <op> ‘(‘ <expr> <op> <expr> ‘)’  <expr> <op> ‘(‘ <expr> <op> num ‘)’  <expr> <op> ‘(‘ <expr> ‘+’ num ‘)’’  <expr> <op> ‘(‘ num ‘+’ num ‘)’  <expr> ‘*’ ‘(‘ num ‘+’ num ‘)’  num ‘*’ ‘(‘ num ‘+’ num ‘)’ Oscar Bonilla 107 Universidad Galileo

Oscar Bonilla 108 Universidad Galileo Bottom-up Parsing Right-most derivation  num ‘*’ ‘(‘ num ‘+’ num ‘)’  <expr> ‘*’ ‘(‘ num ‘+’ num ‘)’  <expr> <op> ‘(‘ num ‘+’ num ‘)’  <expr> <op> ‘(‘ <expr> ‘+’ num ‘)’  <expr> <op> ‘(‘ <expr> <op> num ‘)’  <expr> <op> ‘(‘ <expr> <op> <expr> ‘)’  <expr> <op> ‘(‘ <expr> ‘)’  <expr> <op> <expr>  <expr> Oscar Bonilla 108 Universidad Galileo

Oscar Bonilla 109 Universidad Galileo Resumen Overview de análisis léxico Qué es análisis sintáctico? Gramáticas libres de contexto Derivaciones y Arboles de Parseo Top-down vs. Bottom-up Parsing Gramáticas Ambiguas Implementando un Parser Oscar Bonilla 109 Universidad Galileo

Oscar Bonilla 110 Universidad Galileo Otro Ejemplo Entrada: 124 + 23.5 * 86 Token Stream: num ‘+’ num ‘*’ num Oscar Bonilla 110 Universidad Galileo

Oscar Bonilla 111 Universidad Galileo Otro Ejemplo Producción: String: <expr> <expr> Oscar Bonilla 111 Universidad Galileo

Oscar Bonilla 112 Universidad Galileo Otro Ejemplo Producción: <expr>  <expr> <op> <expr> String: <expr> <op> <expr> <expr> <expr> <op> <expr> Oscar Bonilla 112 Universidad Galileo

Oscar Bonilla 113 Universidad Galileo Otro Ejemplo Producción: <expr>  <num> String: num <op> <expr> <expr> <expr> <op> <expr> num Oscar Bonilla 113 Universidad Galileo

Oscar Bonilla 114 Universidad Galileo Otro Ejemplo Producción: <op>  ‘+’ String: num ‘+’ <expr> <expr> <expr> <op> <expr> num + Oscar Bonilla 114 Universidad Galileo

Oscar Bonilla 115 Universidad Galileo Otro Ejemplo Producción: <expr>  <expr> <op> <expr> String: num ‘+’ <expr> <op> <expr> <expr> <expr> <op> <expr> <expr> <expr> num + <op> Oscar Bonilla 115 Universidad Galileo

Oscar Bonilla 116 Universidad Galileo Otro Ejemplo Producción: <expr>  num String: num ‘+’ num <op> <expr> <expr> <expr> <op> <expr> <expr> <expr> num + <op> num Oscar Bonilla 116 Universidad Galileo

Oscar Bonilla 117 Universidad Galileo Otro Ejemplo Producción: <op>  ‘*’ String: num ‘+’ num ‘*’ <expr> <expr> <expr> <op> <expr> <expr> <expr> num + <op> num * Oscar Bonilla 117 Universidad Galileo

Oscar Bonilla 118 Universidad Galileo Otro Ejemplo Producción: <expr>  num String: num ‘+’ num ‘*’ num <expr> <expr> <op> <expr> <expr> <expr> num + <op> num * num Oscar Bonilla 118 Universidad Galileo

Oscar Bonilla 119 Universidad Galileo Otro Ejemplo String: num ‘+’ num ‘*’ num num + <expr> <op> * Oscar Bonilla 119 Universidad Galileo

Oscar Bonilla 120 Universidad Galileo Otro Ejemplo String: num ‘+’ num ‘*’ num Hay otro orden de derivación? Oscar Bonilla 120 Universidad Galileo

Oscar Bonilla 121 Universidad Galileo Otro Ejemplo String: <expr> <expr> Oscar Bonilla 121 Universidad Galileo

Oscar Bonilla 122 Universidad Galileo Otro Ejemplo Producción: <expr>  <expr> <op> <expr> String: <expr> <op> <expr> <expr> <expr> <op> <expr> Oscar Bonilla 122 Universidad Galileo

Oscar Bonilla 123 Universidad Galileo Otro Ejemplo Producción: <expr>  <num> String: num <op> <expr> <expr> <expr> <op> <expr> num Oscar Bonilla 123 Universidad Galileo

Oscar Bonilla 124 Universidad Galileo Otro Ejemplo Producción: <expr>  <num> String: num <op> <expr> <expr> <expr> <op> <expr> num Pero también podemos usar esta producción <expr>  <expr> <op> <expr> Oscar Bonilla 124 Universidad Galileo

Oscar Bonilla 125 Universidad Galileo Otro Ejemplo Producción: String: <expr> <op> <expr> <expr> <expr> <op> <expr> Pero también podemos usar esta producción <expr>  <expr> <op> <expr> Oscar Bonilla 125 Universidad Galileo

Oscar Bonilla 126 Universidad Galileo Otro Ejemplo Producción: <expr>  <expr> <op> <expr> String: <expr> <op> <expr> <op> <expr> <expr> <expr> <op> <expr> <expr> <expr> <op> Oscar Bonilla 126 Universidad Galileo

Oscar Bonilla 127 Universidad Galileo Otro Ejemplo Producción: <expr>  <num> String: num <op> <expr> <op> <expr> <expr> <expr> <op> <expr> <expr> <expr> <op> num Oscar Bonilla 127 Universidad Galileo

Oscar Bonilla 128 Universidad Galileo Otro Ejemplo Producción: <op>  <+> String: num ‘+’ <expr> <op> <expr> <expr> <expr> <op> <expr> <expr> <expr> <op> num + Oscar Bonilla 128 Universidad Galileo

Oscar Bonilla 129 Universidad Galileo Otro Ejemplo Producción: <expr>  <num> String: num ‘+’ num <op> <expr> <expr> <expr> <op> <expr> <expr> <expr> <op> num + num Oscar Bonilla 129 Universidad Galileo

Oscar Bonilla 130 Universidad Galileo Otro Ejemplo Producción: <op>  ‘*’ String: num ‘+’ num ‘*’ <expr> <expr> <expr> <op> <expr> <expr> <expr> <op> * num + num Oscar Bonilla 130 Universidad Galileo

Oscar Bonilla 131 Universidad Galileo Otro Ejemplo Producción: <expr>  <num> String: num ‘+’ num ‘*’ num <expr> <expr> <op> <expr> <expr> <expr> <op> * num num + num Oscar Bonilla 131 Universidad Galileo

Oscar Bonilla 132 Universidad Galileo Otro Ejemplo String: num ‘+’ num ‘*’ num <expr> <expr> <op> <expr> <expr> <expr> <op> * num num + num Oscar Bonilla 132 Universidad Galileo

Mismo string – Dos derivaciones num ‘+’ num ‘*’ num num + <expr> <op> * num * <expr> <op> + 124 + (23.5 * 86) = 2145 (124 + 23.5) * 86 = 12685 Oscar Bonilla 133 Universidad Galileo

La Gramática es Ambigua Aplicar diferentes ordenes de derivación produce árboles de parseo diferentes Esto no es bueno! Lleva a resultados ambiguos Muy probablemente va a producir resultados inesperados Algunas veces el reescribir la gramática con más no-terminales va a eliminar la ambiguedad Oscar Bonilla 134 Universidad Galileo

Oscar Bonilla 135 Universidad Galileo La Gramática Ambigua <expr>  <expr> <op> <expr> <expr>  ( <expr> ) <expr>  - <expr> <expr>  num <op>  + <op>  * Oscar Bonilla 135 Universidad Galileo

Eliminando la Ambiguedad <expr>  <expr> + <term> <expr>  <term> <term>  <term> * <unit> <term>  <unit> <unit>  num <unit>  ( <expr> ) <expr>  <expr> <op> <expr> <expr>  ( <expr> ) <expr>  - <expr> <expr>  num <op>  + <op>  * Oscar Bonilla 136 Universidad Galileo

Eliminando la Ambiguedad String: num ‘+’ num ‘*’ num <expr> <expr> + <term> <term> <term> <unit> * <unit> <unit> num num num Oscar Bonilla 137 Universidad Galileo

Primer ejemplo en la nueva gramática <expr> num ‘*’ ‘(‘ num ‘+’ num ‘)’ <term> <term> <unit> * <unit> ( <expr> ) num <expr> <term> + <unit> <term> num <unit> num Oscar Bonilla 138 Universidad Galileo

Pregunta: Es esta gramática ambigua? <stmt>  if <expr> then <stlist> <stmt>  if <expr> then <stlist> else <stlist> Oscar Bonilla 139 Universidad Galileo

Pregunta: Cómo la hacemos no ambigua? <stmt>  if <expr> then <stlist> <stmt>  if <expr> then <stlist> else <stlist> Oscar Bonilla 140 Universidad Galileo

Oscar Bonilla 141 Universidad Galileo Resumen Overview de análisis léxico Qué es análisis sintáctico? Gramáticas libres de contexto Derivaciones y Arboles de Parseo Top-down vs. Bottom-up Parsing Gramáticas Ambiguas Implementando un Parser Oscar Bonilla 141 Universidad Galileo

Implementando un Parser La implementación de un parser para algunas CFG’s puede ser muy difícil Tenemos que ver el input y elegir una producción No podemos elegir la producción correcta sin ver que viene en el input (looking ahead) Oscar Bonilla 142 Universidad Galileo

Oscar Bonilla 143 Universidad Galileo Ejemplo de look ahead Gramática <stmt>  a <long> b <stmt>  a <long> c <long>  x <long> | x Input string “axxxxxxxxxxxxxxxxx…….” Puede que tengamos que ver un montón de símbolos del input antes de decidirnos por una producción Oscar Bonilla 143 Universidad Galileo

Implementando un Parser Implementar un parser para algunas CFG’s puede ser muy difícil Tenemos que ver el input y elegir una producción No podemos elegir una producción sin look ahead Hay varias técnicas Cada una puede manejar algunas CFG’s Categorización de las técnicas Oscar Bonilla 144 Universidad Galileo

Implementando un Parser Implementar un parser para algunas CFG’s puede ser muy difícil Tenemos que ver el input y elegir una producción No podemos elegir una producción sin look ahead Hay varias técnicas Cada una puede manejar algunas CFG’s Categorización de las técnicas ( ) Oscar Bonilla 145 Universidad Galileo

Implementando un Parser Implementar un parser para algunas CFG’s puede ser muy difícil Tenemos que ver el input y elegir una producción No podemos elegir una producción sin look ahead Hay varias técnicas Cada una puede manejar algunas CFG’s Categorización de las técnicas ( ) L - parsear de izquierda a derecha R – parsear de derecha a izquierda Oscar Bonilla 146 Universidad Galileo

Implementando un Parser Implementar un parser para algunas CFG’s puede ser muy difícil Tenemos que ver el input y elegir una producción No podemos elegir una producción sin look ahead Hay varias técnicas Cada una puede manejar algunas CFG’s Categorización de las técnicas ( ) L - leftmost derivation R - rightmost derivation Oscar Bonilla 147 Universidad Galileo

Implementando un Parser Implementar un parser para algunas CFG’s puede ser muy difícil Tenemos que ver el input y elegir una producción No podemos elegir una producción sin look ahead Hay varias técnicas Cada una puede manejar algunas CFG’s Categorización de las técnicas ( ) Número de caracteres de lookahead Oscar Bonilla 148 Universidad Galileo

Implementando un Parser Implementar un parser para algunas CFG’s puede ser muy difícil Tenemos que ver el input y elegir una producción No podemos elegir una producción sin look ahead Hay varias técnicas Cada una puede manejar algunas CFG’s Categorización de las técnicas Ejemplos: LL(0), LR(1) ( ) Oscar Bonilla 149 Universidad Galileo

Oscar Bonilla 150 Universidad Galileo Siguiente Clase Cómo implementar un Parser Cómo construir un parser engine para un parser shift-reduce Vamos a ver LR(0) LR(1) LALR(1) Parser Engine Oscar Bonilla 150 Universidad Galileo

Oscar Bonilla 151 Universidad Galileo Resumen Qué es análisis sintáctico? Diferencia entre análisis léxico y análisis sintáctico Gramáticas libres de contexto Arboles de Parseo Derivaciones left-most y right-most Top-down and bottom-up parsing Gramáticas Ambiguas Implementación de Parsers Oscar Bonilla 151 Universidad Galileo

Oscar Bonilla 152 Universidad Galileo Grupos Ya tienen que tener grupos Si no tienen grupo todavía, hagánlo! Los listados de grupos van a estar en el Web Si no están en un grupo en el Web hablen con Andreaq Oscar Bonilla 152 Universidad Galileo