06 Analisis Sintactico

Compiladores
Introducción al Análisis Sintáctico
Gramáticas de Contexto Libre,

Arboles de Parseo y Derivaciones
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
Analizador SintácticoStream
(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
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|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)*)?

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
Programa (character stream)
Analizador Léxico (Scanner)
Token
Analizador SintácticoStream
(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
Entrada y Salida de un Parser
Entrada: - (123.3 + 23.6)
Token Stream Arbol de Parseo
Analizador Sintáctico (Parser)

minus_op
left_paren_op
-
num(123.3)
plus_op
( )
num(23.6)
right_paren_op
123.3 23.6
+

Creando una CFG

Resumen
• Overview de análisis léxico
• Qué es análisis sintáctico?
• 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γ ⇒ α β γ
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>

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

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

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

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

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

<expr> ⇒ num
<expr>
<expr> <op> <expr>
<expr>
num * ( )
<expr> <op> <expr>
num
<op> ⇒ ‘+’
<expr>
<expr> <op> <expr>
<expr>
num * ( )
<expr> <op> <expr>
num +
<expr> ⇒ num
<expr>
<expr> <op> <expr>
<expr>
num * ( )
<expr> <op> <expr>
num + num
num ‘*’ ‘(‘ num ‘+’ num ‘)’
<expr>
<expr> <op> <expr>
<expr>
num * ( )
<expr> <op> <expr>
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
Producción:
String: <expr>
<expr>

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

Producción: <expr> ⇒ ‘(‘ <expr> ‘)’
String: <expr> <op> ‘(‘ <expr> ‘)’
<expr>
<expr> <op> <expr>
<expr>
( )

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

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

<expr>
<expr> <op> <expr>
<expr>
num * ( )
<expr> <op> <expr>
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 ‘)’

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
⇒ <expr>
⇒ num <op> <expr>
⇒ num ‘*’ <expr>
⇒ num ‘*’ ‘(‘ <expr> ‘)’
⇒ num ‘*’ ‘(‘ <expr> <op> <expr> ‘)’
⇒ num ‘*’ ‘(‘ num <op> <expr> ‘)’
⇒ num ‘*’ ‘(‘ num ‘+’ <expr> ‘)’
⇒ 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
• 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> ‘+’ num ‘)’’
⇒ <expr> <op> ‘(‘ num ‘+’ num ‘)’
⇒ <expr> ‘*’ ‘(‘ num ‘+’ num ‘)’
⇒ num ‘*’ ‘(‘ num ‘+’ num ‘)’

Bottom-up Parsing
⇒ <expr>
⇒ <expr> <op> ‘(‘ <expr> ‘)’
⇒ <expr> <op> ‘(‘ <expr> ‘+’ num ‘)’’
⇒ <expr> <op> ‘(‘ num ‘+’ num ‘)’
⇒ <expr> ‘*’ ‘(‘ num ‘+’ num ‘)’
⇒ num ‘*’ ‘(‘ num ‘+’ num ‘)’

Bottom-up Parsing
⇒ num ‘*’ ‘(‘ num ‘+’ num ‘)’
⇒ <expr> ‘*’ ‘(‘ num ‘+’ num ‘)’
⇒ <expr> <op> ‘(‘ num ‘+’ num ‘)’
⇒ <expr> <op> ‘(‘ <expr> ‘+’ num ‘)’
⇒ <expr> <op> ‘(‘ <expr> ‘)’
⇒ <expr>

Resumen

Otro Ejemplo
• Entrada:
124 + 23.5 * 86
• Token Stream:
num ‘+’ num ‘*’ num

Otro Ejemplo
Producción:
String: <expr>
<expr>

Otro Ejemplo
<expr>
<expr> <op> <expr>

Otro Ejemplo
Producción: <expr> ⇒ <num>
String: num <op> <expr>
<expr>
<expr> <op> <expr>
num

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

Otro Ejemplo
String: num ‘+’ <expr> <op> <expr>
<expr>
<expr> <op> <expr>
<expr> <op> <expr>

num +

Otro Ejemplo
String: num ‘+’ num <op> <expr>
<expr>
<expr> <op> <expr>
<expr> <op> <expr>

num +
num

Otro Ejemplo
String: num ‘+’ num ‘*’ <expr>
<expr>
<expr> <op> <expr>
<expr> <op> <expr>

num +
num *

Otro Ejemplo
String: num ‘+’ num ‘*’ num
<expr>
<expr> <op> <expr>
<expr> <op> <expr>

num +
num * num

Otro Ejemplo

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

num +
num * num

Otro Ejemplo
• Hay otro orden de derivación?

Otro Ejemplo
String: <expr>
<expr>

Otro Ejemplo
<expr>
<expr> <op> <expr>

Otro Ejemplo
<expr>
<expr> <op> <expr>
num

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

Otro Ejemplo
Producción:
<expr>
<expr> <op> <expr>
Pero también podemos usar esta producción

Otro Ejemplo
String: <expr> <op> <expr> <op> <expr>
<expr>
<expr> <op> <expr>
<expr> <op> <expr>

Otro Ejemplo
String: num <op> <expr> <op> <expr>
<expr>
<expr> <op> <expr>
<expr> <op> <expr>
num

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

Otro Ejemplo
String: num ‘+’ num <op> <expr>
<expr>
<expr> <op> <expr>
<expr> <op> <expr>
num + num

Otro Ejemplo
String: num ‘+’ num ‘*’ <expr>
<expr>
<expr> <op> <expr>
<expr> <op> <expr>

*
num + num

Otro Ejemplo
<expr>
<expr> <op> <expr>
<expr> <op> <expr>

* num
num + num

Otro Ejemplo

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

* num
num + num

Mismo string – Dos derivaciones
num ‘+’ num ‘*’ num
<expr> <expr>
<expr> <op> <expr> <expr> <op> <expr>
<expr> <op> <expr> <expr> <op> <expr>

num + * num
num * num num + num
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> <op> <expr>
<expr> → ( <expr> )
<expr> → - <expr>
<expr> → num
<op> → +
<op> → *

Eliminando la Ambiguedad
<expr> → <expr> + <term>
<expr> → <term>
<term> → <term> * <unit>
<term> → <unit>
<unit> → num <expr> → <expr> <op> <expr>
<expr> → ( <expr> )
<unit> → ( <expr> ) <expr> → - <expr>
<expr> → num
<op> → +
<op> → *
Eliminando la Ambiguedad

<expr>
<expr> <term>
+
<term> <term> <unit>
*
<unit> <unit>
num
num num
Primer ejemplo en la nueva gramática
<expr>
num ‘*’ ‘(‘ num ‘+’ num ‘)’
<term>
<term> <unit>
*
<unit> ( <expr> )
num <expr> <term>
+
<term> <unit>
<unit> num
num
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
– 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) Parser
Engine
– LR(1)
– LALR(1)

Resumen
• Diferencia entre análisis léxico y análisis
sintáctico
• Arboles de Parseo
• Derivaciones left-most y right-most
• Top-down and bottom-up parsing
• 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

06 Analisis Sintactico

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

06 Analisis Sintactico

Transféré par

Droits d'auteur :

Formats disponibles

Compiladores

Introducción al Análisis Sintáctico

Gramáticas de Contexto Libre,

Oscar Bonilla 2 Universidad Galileo

Oscar Bonilla 4 Universidad Galileo

• Un lenguaje regular es un lenguaje definido por

Oscar Bonilla 5 Universidad Galileo

Oscar Bonilla 6 Universidad Galileo

Oscar Bonilla 8 Universidad Galileo

Oscar Bonilla 9 Universidad Galileo

Token Stream Arbol de Parseo

Analizador Sintáctico (Parser)

Oscar Bonilla 12 Universidad Galileo

Oscar Bonilla 13 Universidad Galileo

Oscar Bonilla 14 Universidad Galileo

• Representación gráfica de la estructura

• Muestra la secuencia de derivaciones efectuada

Oscar Bonilla 17 Universidad Galileo

<expr> <op> <expr>

Oscar Bonilla 18 Universidad Galileo

<expr> <op> <expr>

Oscar Bonilla 19 Universidad Galileo

<expr> <op> <expr>

Oscar Bonilla 20 Universidad Galileo

<expr> <op> <expr>

Oscar Bonilla 21 Universidad Galileo

<expr> <op> <expr>

Oscar Bonilla 22 Universidad Galileo

<expr> <op> <expr>

<expr> <op> <expr>

<expr> <op> <expr>

<expr> <op> <expr>

Oscar Bonilla 27 Universidad Galileo

Oscar Bonilla 28 Universidad Galileo

Oscar Bonilla 29 Universidad Galileo

<expr> <op> <expr>

Oscar Bonilla 30 Universidad Galileo

<expr> <op> <expr>

Oscar Bonilla 31 Universidad Galileo

<expr> <op> <expr>

Oscar Bonilla 32 Universidad Galileo

<expr> <op> <expr>

<expr> <op> <expr>

<expr> <op> <expr>

<expr> <op> <expr>

<expr> <op> <expr>

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

<expr> <op> <expr>

Oscar Bonilla 39 Universidad Galileo

• Left-most derivation refleja top-down parsing

Oscar Bonilla 40 Universidad Galileo

Oscar Bonilla 41 Universidad Galileo

• Left-most derivation refleja top-down parsing

• Right-most derivation refleja bottom-up parsing

Oscar Bonilla 42 Universidad Galileo

Oscar Bonilla 43 Universidad Galileo

Oscar Bonilla 44 Universidad Galileo

Oscar Bonilla 45 Universidad Galileo

Oscar Bonilla 46 Universidad Galileo

Oscar Bonilla 47 Universidad Galileo

Oscar Bonilla 48 Universidad Galileo

<expr> <op> <expr>

Oscar Bonilla 49 Universidad Galileo