compiladores introducción al análisis sintáctico gramáticas de contexto libre, arboles de parseo...

CompiladoresIntroducció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


Anatomia de un Compilador

Optimizador

Generador de Código

Representación Intermedia Optimizada

Código en Assembler

Generador de Código Intermedio

Representación Intermedia

Analizador Léxico (Scanner)

Analizador Sintáctico (Parser)

Token Stream

Arbol de Parseo

Programa (character stream)


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


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


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|9posint = 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)*)?


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


Resumen


• Qúe es análisis sintáctico


• Derivación y Arboles de Parseo


• Gramáticas Ambiguas



Sintaxis y Semántica de un Lenguaje de Programación?

• Sintaxis – 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


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


Anatomia de un Compilador

Optimizador de Código

Generador de Código

Representación Intermedia Optimizada

Código en Assembler

Generador de Código Intermedio

Representación Intermedia

Analizador Léxico (Scanner)

Analizador Sintáctico (Parser)

Token Stream

Arbol de Parseo

Programa (character stream)


Entrada y Salida de un Parser

-

( )

123.3 23.6+

minus_op

left_paren_op

num(123.3)

plus_op

num(23.6)

right_paren_op

Token Stream Arbol de Parseo

Entrada: - (123.3 + 23.6)

Ana

liza

dor

Sin

táct

ico

(Par

ser)


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?


Ejemplo: Scope JerárquicoProcedure 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;

} }}


Ejemplo: Scope JerárquicoProcedure 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: {{}{{{}{{}}}}}


Problema de los paréntesis balanceados

• Podemos definir esto usando una expresión regular?



• Podemos definir esto usando una expresión regular?

NO!



• 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

• 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


Resumen


• Qué es análisis sintáctico?


• Derivación y Arboles de Parseo





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)

Ejemplo de una CFG

<S> ( <S> ) <S> | ε

Ejemplo de una CFG

<S> ( <S> ) <S>

<S> ε

Ejemplo de una CFG

<S> ( <S> ) <S>

<S> ε Terminales

Ejemplo de una CFG

<S> ( <S> ) <S>

<S> ε No-terminales

Ejemplo de una CFG

<S> ( <S> ) <S>

<S> ε Símbolo de Inicio: <S>

Ejemplo de una CFG

<S> ( <S> ) <S>

<S> ε Producciones

Los lenguajes regulares son un subconjunto de los lenguajes libres de contexto

a

Expresión Regular Gramática libre de contexto

<A> a

p · q <S> <Q>Si p y q son expresiones regulares, usando CFGs y <Q>

p | q <S> <S> <Q>

p * <S> <S> <S> ε

Los lenguajes regulares son un subconjunto de los lenguajes libres de contexto

??? <S> <S> <S> 

Si p es una expresión regular, usando una CFG ,

Qué es?

Expresión Regular Gramática libre de contexto

P? ???


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


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


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?

<expr> <expr> <op> <expr>

<expr> ( <expr> )

<expr> - <expr>

<expr> num

<op> +

<op> *

<expr> ( <expr> )

<expr> - <expr>

<expr> num

<op> +

<op> *

Terminales

<expr> ( <expr> )

<expr> - <expr>

<expr> num

<op> +

<op> *

No-terminales

<expr> ( <expr> )

<expr> - <expr>

<expr> num

<op> +

<op> *

Símbolo de Inicio:<expr>

<expr> ( <expr> )

<expr> - <expr>

<expr> num

<op> +

<op> *

Producciones

<expr> ( <expr> )

<expr> - <expr>

<expr> num

<op> +

<op> *

<expr> <expr> <op> <expr> | ( <expr> )

| - <expr> | num

<op> + | *

Pregunta: Cuál es el lenguaje definido por esta CFG?

<S> a<S>a | aa


Resumen

• Overview de análisis léxico



• Derivaciones y Arboles de Parseo





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

Ejemplo de Derivación

• Gramática<expr> <expr><op><expr> | (<expr>) | -<expr> | num

<op> + | *

• Entrada 36 * ( 8 + 23.4)

• Token Streamnum ‘*’ ‘(‘ num ‘+’ num ‘)’

<expr>

num ‘*’ ‘(‘ num ‘+’ num ‘)’




num ‘*’ ‘(‘ num ‘+’ num ‘)’


num ‘*’ ‘(‘ num ‘+’ num ‘)’

<expr> num

<expr> <expr> <op> <expr> num <op> <expr>

num ‘*’ ‘(‘ num ‘+’ num ‘)’

<expr> num




num ‘*’ ‘(‘ num ‘+’ num ‘)’

num ‘*’ ‘(‘ num ‘+’ num ‘)’

<op> *

<expr> <expr> <op> <expr> num <op> <expr> num ‘*’ <expr>

num ‘*’ ‘(‘ num ‘+’ num ‘)’

<op> *




num ‘*’ ‘(‘ num ‘+’ num ‘)’

num ‘*’ ‘(‘ num ‘+’ num ‘)’

<expr> (<expr>)

<expr> <expr> <op> <expr> num <op> <expr> num ‘*’ <expr> num ‘*’ ‘(‘ <expr> ‘)’

num ‘*’ ‘(‘ num ‘+’ num ‘)’

<expr> (<expr>)




num ‘*’ ‘(‘ num ‘+’ num ‘)’

<expr> <expr> <op> <expr> num <op> <expr> num ‘*’ <expr> num ‘*’ ‘(‘ <expr> ‘)’ num ‘*’ ‘(‘ <expr> <op> <expr>

‘)’

num ‘*’ ‘(‘ num ‘+’ num ‘)’




‘)’

num ‘*’ ‘(‘ num ‘+’ num ‘)’

‘)’

num ‘*’ ‘(‘ num ‘+’ num ‘)’

<expr> num

‘)’ num ‘*’ ‘(‘ num <op> <expr> ‘)’

num ‘*’ ‘(‘ num ‘+’ num ‘)’

<expr> num

<expr> <expr> <op> <expr> num <op> <expr> num ‘*’ <expr> num ‘*’ ‘(‘ <expr> ‘)’ num ‘*’ ‘(‘ <expr> <op> <expr> ‘)’ num ‘*’ ‘(‘ num <op> <expr> ‘)’

num ‘*’ ‘(‘ num ‘+’ num ‘)’

‘)’ num ‘*’ ‘(‘ num <op> <expr> ‘)’

num ‘*’ ‘(‘ num ‘+’ num ‘)’

‘)’ num ‘*’ ‘(‘ num <op> <expr> ‘)’

num ‘*’ ‘(‘ num ‘+’ num ‘)’

<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 ‘)’

<op> +




num ‘*’ ‘(‘ num ‘+’ num ‘)’

num ‘*’ ‘(‘ num ‘+’ num ‘)’

<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 ‘)’

<expr> num




num ‘*’ ‘(‘ num ‘+’ num ‘)’


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

Ejemplo de Arbol de Parseo

<expr>

( )*num

<expr>

<expr><expr>

<expr>

<expr>

<expr>

<op>

<op>

num num+

( )*num

<expr>

<expr><expr>

<expr>

<expr>

<expr>

<op>

<op>

num ‘*’ ‘(‘ num ‘+’ num ‘)’


Resumen









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

Ejemplo de Right-Derivation

<expr>

Producción: String: <expr>

<expr>

<expr><expr> <op>

Producción: <expr> <expr> <op> <expr>

String: <expr> <op> <expr>

( )

<expr>

<expr><expr>

<expr>

<op>

Producción: <expr> ‘(‘ <expr> ‘)’

String: <expr> <op> ‘(‘ <expr> ‘)’

( )

<expr>

<expr><expr>

<expr>

<expr>

<expr>

<op>

<op>

Producción: <expr> <expr> <op> <expr>

String: <expr> <op> ‘(‘ <expr> <op> <expr> ‘)’

num

( )

<expr>

<expr><expr>

<expr>

<expr>

<expr>

<op>

<op>

Producción: <expr> num

String: <expr> <op> ‘(‘ <expr> <op> num ‘)’

num+

( )

<expr>

<expr><expr>

<expr>

<expr>

<expr>

<op>

<op>

Producción: <op> ‘+’

String: <expr> <op> ‘(‘ <expr> ‘+’ num ‘)’

num num+

( )

<expr>

<expr><expr>

<expr>

<expr>

<expr>

<op>

<op>


String: <expr> <op> ‘(‘ num ‘+’ num ‘)’

num num+

( )*

<expr>

<expr><expr>

<expr>

<expr>

<expr>

<op>

<op>

Producción: <op> ‘*’

String: <expr> ‘*’ ‘(‘ num ‘+’ num ‘)’

num num+

( )*num

<expr>

<expr><expr>

<expr>

<expr>

<expr>

<op>

<op>


String: num ‘*’ ‘(‘ num ‘+’ num ‘)’

num num+

( )*num

<expr>

<expr><expr>

<expr>

<expr>

<expr>

<op>

<op>

String: num ‘*’ ‘(‘ num ‘+’ num ‘)’

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 ‘)’


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


Top-down Parsing• Left-most derivation



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

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 ‘)’

<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 ‘)’

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>


Resumen









Otro Ejemplo

• Entrada:124 + 23.5 * 86

• Token Stream: num ‘+’ num ‘*’ num

Otro Ejemplo

<expr>

Producción:String: <expr>

Otro Ejemplo

<expr>

<expr><expr> <op>

Producción: <expr> <expr> <op> <expr>String: <expr> <op> <expr>

Otro Ejemplo

num

<expr>

<expr><expr> <op>

Producción: <expr> <num>String: num <op> <expr>

Otro Ejemplo

+num

<expr>

<expr><expr> <op>

Producción: <op> ‘+’String: num ‘+’ <expr>

Otro Ejemplo

Producción: <expr> <expr> <op> <expr>String: num ‘+’ <expr> <op> <expr>

+num

<expr>

<expr><expr>

<expr> <expr>

<op>

<op>

Otro Ejemplo

Producción: <expr> num String: num ‘+’ num <op> <expr>

num

+num

<expr>

<expr><expr>

<expr> <expr>

<op>

<op>

Otro Ejemplo

num

+num

<expr>

<expr><expr>

<expr> <expr>

<op>

Producción: <op> ‘*’ String: num ‘+’ num ‘*’ <expr>

*

<op>

Otro Ejemplo

num num

+num

<expr>

<expr><expr>

<expr> <expr>

<op>

Producción: <expr> num String: num ‘+’ num ‘*’ num

*

<op>

Otro Ejemplo

String: num ‘+’ num ‘*’ num

num num

+num

<expr>

<expr><expr>

<expr> <expr>

<op>

*

<op>


Otro Ejemplo


• Hay otro orden de derivación?

Otro Ejemplo

<expr>

String: <expr>

Otro Ejemplo

<expr>

<expr> <expr><op>

Producción: <expr> <expr> <op> <expr> String: <expr> <op> <expr>

Otro Ejemplo

num

<expr>

<expr><expr> <op>

Otro Ejemplo

num

<expr>

<expr><expr> <op>


Pero también podemos usar esta producción <expr> <expr> <op> <expr>

Otro Ejemplo

<expr>

<expr><expr> <op>

Producción: String: <expr> <op> <expr>

Pero también podemos usar esta producción<expr> <expr> <op> <expr>

Otro Ejemplo

<expr>

<expr> <expr>

<expr> <expr>

<op>

Producción: <expr> <expr> <op> <expr> String: <expr> <op> <expr> <op> <expr>

<op>

Otro Ejemplo

num

<expr>

<expr> <expr>

<expr> <expr>

<op>

Producción: <expr> <num> String: num <op> <expr> <op> <expr>

<op>

Otro Ejemplo

num

<expr>

<expr> <expr>

<expr> <expr>

<op>

Producción: <op> <+> String: num ‘+’ <expr> <op> <expr>

+

<op>

Otro Ejemplo

num num

<expr>

<expr> <expr>

<expr> <expr>

<op>

Producción: <expr> <num> String: num ‘+’ num <op> <expr>

+

<op>

Otro Ejemplo

num num

*

<expr>

<expr> <expr>

<expr> <expr>

<op>

Producción: <op> ‘*’ String: num ‘+’ num ‘*’ <expr>

+

<op>

Otro Ejemplo

num num

* num

<expr>

<expr> <expr>

<expr> <expr>

<op>

Producción: <expr> <num> String: num ‘+’ num ‘*’ num

+

<op>

Otro Ejemplo

num num

* num

<expr>

<expr> <expr>

<expr> <expr>

<op>


+

<op>

Mismo string – Dos derivaciones num ‘+’ num ‘*’ num

num num

* num

<expr>

<expr> <expr>

<expr> <expr>

<op>

+

<op>

num num

+num

<expr>

<expr><expr>

<expr> <expr>

<op>

*

<op>

124 + (23.5 * 86) = 2145 (124 + 23.5) * 86 = 12685


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

La Gramática Ambigua


<expr> ( <expr> )

<expr> - <expr>

<expr> num

<op> +

<op> *

Eliminando la Ambiguedad

<expr> <expr> + <term>

<expr> <term>

<term> <term> * <unit>

<term> <unit>

<unit> num

<unit> ( <expr> )


<expr> ( <expr> )

<expr> - <expr>

<expr> num

<op> +

<op> *

Eliminando la Ambiguedad


num

+

<expr>

<term><expr>

<term> <unit>*

num

<unit>

<term>

num

<unit>

Primer ejemplo en la nueva gramática

+

( )

*

num

<term>

<unit><term>

<expr>

<expr>

<term>

num ‘*’ ‘(‘ num ‘+’ num ‘)’<expr>

<unit>

num

<term>

<unit> num

<unit>

Pregunta: Es esta gramática ambigua?

<stmt> if <expr> then <stlist>

<stmt> if <expr> then <stlist> else <stlist>

Pregunta: Cómo la hacemos no ambigua?

<stmt> if <expr> then <stlist>

<stmt> if <expr> then <stlist> else <stlist>


Resumen









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)

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



• 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





( )L - leftmost derivation

R - rightmost derivation





( )Número de caracteres de lookahead





– Ejemplos: LL(0), LR(1)

( )


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)

ParserEngine


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


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

compiladores introducción al análisis sintáctico gramáticas de contexto libre, arboles de parseo...

Documents