06 Analisis Sintactico

Compiladores
Introduccin al Anlisis Sintctico

Gramticas de Contexto Libre,
Arboles de Parseo y Derivaciones
Oscar Bonilla 2 Universidad Galileo
Resumen
Overview del anlisis lxico
Qu es anlisis sintctico
Gramticas libres de contexto
Derivaciones y rboles de parseo
Top-down vs. Bottom-up Parsing
Grmaticas Ambiguas
Implementando un Parser

Anatomia de un Compilador
Optimizador
Generador de Cdigo
Representacin Intermedia Optimizada
Cdigo en Assembler
Generador de Cdigo Intermedio
Representacin Intermedia
Analizador Lxico (Scanner)
Analizador Sintctico (Parser)
Token Stream
Arbol de Parseo
Programa (character stream)
Resumen de Anlisis Lxico
El analizador lxico crea tokens a partir de un
character stream
Los tokens se definen usando expresiones
regulares
Expresiones Regulares,
Gramticas y Lenguajes
Una expresin 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 expresin regular
Expresiones Regulares,
Gramticas y Lenguajes
Qu hay acerca de las variables simblicas?
Ejemplo:
num = 0|1|2|3|4|5|6|7|8|9
posint = num num*
int = ( | -) posint
real = int ( | (. posint))
Slo son una abreviacin, 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 Anlisis Lxico
El analizador lxico 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 Determinstico (NFA)
Por construccin simple
NFA se transforma a un DFA
Algoritmo de transformacin
Ejecutar un DFA es fcil
Resumen
Qe es anlisis sintctico
Derivacin y Arboles de Parseo
Gramticas Ambiguas
Sintaxis y Semntica de un
Lenguaje de Programacin?
Sintaxis
Como se ve un programa
Representacin textual o estructura
Es posible una definicin matemtica precisa

Semntica
Cul es el significado de un programa
Es ms difcil dar una definicin matemtica
Por qu hacer anlisis sintctico?
Podemos proveer una definicin precisa y fcil
de entender
Una gramtica apropiada imparte estructura a
un lenguaje de programacin
Podemos construir automticamente un parser
que determine si el programa es sintcticamente
correcto
Ayuda en el proceso de traduccin
Fcil modificar/aadir al lenguaje
Anatomia de un Compilador
Optimizador de Cdigo
Generador de Cdigo
Representacin Intermedia Optimizada
Cdigo en Assembler
Generador de Cdigo Intermedio
Representacin Intermedia
Analizador Lxico (Scanner)
Analizador Sintctico (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)
A
n
a
l
i
z
a
d
o
r

S
i
n
t
c
t
i
c
o

(
P
a
r
s
e
r
)

Definicin de la Sintaxis
Tenemos que proveer una definicin precisa y
fcil de entender de la sintaxis del lenguaje de
programacin

Podemos usar expresiones regulares?
Podemos usar un lenguaje regular para definir un
lenguaje de programacin?
Ejemplo: Scope Jerrquico
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;
}
}
}

Ejemplo: Scope Jerrquico
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 parntesis balanceados
Ejemplo: {{}{{{}{{}}}}}
Problema de los parntesis
balanceados
Podemos definir esto usando una expresin regular?
balanceados
NO!
balanceados
NO!
Intuicin
Nmero de parntesis abiertos debe ser igual a
nmero de parntesis cerrados
Necesitamos mantener un conteo o necesitamos
recursin
Adems: NFAs y DFAs no pueden ejecutar conteo
sin lmites
balanceados
Hay alguna gramtica que defina esto?

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

La definicin es recursiva
Esta es una gramtica libre de contexto
Es ms expresiva que las expresiones regulares
Resumen
Qu es anlisis sintctico?
Derivacin y Arboles de Parseo
Gramticas Ambiguas
Definiendo Context-Free Grammars
(CFGs)
Terminales
Smbolos para strings o tokens
No terminales
Variables sintcticas
Smbolo 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>

Smbolo 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
Expresin Regular Gramtica 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 expresin regular, usando una CFG ,

Qu es?
Expresin Regular Gramtica libre de contexto
P?
???
Entonces por qu usar expresiones
regulares?
Separar el anlisis sintctico en partes lxica y no-
lxica es una buena modularizacin

Las reglas lxicas son simples y pueden ser expresadas
usando expresiones regulares

Las expresiones regulares son ms concisas

Las implementaciones de analizadores lxicos para
expresiones regulares son ms 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 aritmticas 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 nmeros
plus_op (+), minus_op (-), times_op(*),
left_paren_op((), right_paren_op())
Cul es la gramtica 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> *
Terminales
<expr> ( <expr> )
<expr> - <expr>
<expr> num
<op> +
<op> *
No-terminales
<expr> ( <expr> )
<expr> - <expr>
<expr> num
<op> +
<op> *
No-terminales
<expr> ( <expr> )
<expr> - <expr>
<expr> num
<op> +
<op> *
Smbolo 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: Cul es el lenguaje
definido por esta CFG?

<S> a<S>a | aa

Resumen
Overview de anlisis lxico
Derivaciones y Arboles de Parseo
Gramticas Ambiguas
Derivaciones
Cmo mostramos que una secuencia de tokens
es aceptada por una CFG?
Una produccin es usada para derivar una
secuencia de tokens a partir del smbolo de
inicio
Dados los strings , y
y una produccin A
Un solo paso de la derivacin es
A
Ejemplo de Derivacin
Gramtica
<expr> <expr><op><expr> | (<expr>) | -<expr> | num
<op> + | *

Entrada
36 * ( 8 + 23.4)

Token Stream
num * ( num + num )

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

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

num * ( num + num )

num * ( num + num )

num * ( num + num )

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

num * ( num + num )
<expr> num
num <op> <expr>
num * <expr>
num * ( <expr> )
num * ( num + num )
num * ( num + num )
<expr> num
num <op> <expr>
num * <expr>
num * ( <expr> )
num * ( num + num )
num * ( num + num )
Arbol de Parseo

Representacin grfica 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 produccin
Ejemplo de Arbol de Parseo
<expr>

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

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

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

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

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

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

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

num num
+
( ) *
num
<expr>
<expr> <expr>
<expr>
<expr>
<expr>
<op>
<op>
num * ( num + num )
Resumen
Gramticas Ambiguas
Derivaciones left-most vs. right-most
Leftmost derivation
En el string, encontramos el no-terminal de ms a la
izquierda y le aplicamos una produccin
El ejemplo anterior fue de una leftmos derivation

Rightmost derivation
Encontramos el no-terminal de ms a la derecha y le
aplicamos una produccin
Ejemplo de Right-Derivation

<expr>
Produccin:
String: <expr>

<expr>
<expr> <expr> <op>
Produccin: <expr> <expr> <op> <expr>
String: <expr> <op> <expr>

( )
<expr>
<expr> <expr>
<expr>
<op>
Produccin: <expr> ( <expr> )
String: <expr> <op> ( <expr> )

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

num
( )
<expr>
<expr> <expr>
<expr>
<expr>
<expr>
<op>
<op>
Produccin: <expr> num
String: <expr> <op> ( <expr> <op> num )

num
+
( )
<expr>
<expr> <expr>
<expr>
<expr>
<expr>
<op>
<op>
Produccin: <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>
Produccin: <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 )
<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 )

Normalmente escaneamos de izquierda a
derecha

Left-most derivation refleja top-down parsing
Comenzamos con el smbolo inicial
Terminamos con el string de tokens

Top-down Parsing
Left-most derivation
<expr>
<expr> <op> <expr>
num <op> <expr>
num * <expr>
num * ( <expr> )
num * ( num + num )
Normalmente escaneamos de izquierda a
derecha

Left-most derivation refleja top-down parsing
Comenzamos con el smbolo inicial
Terminamos con el string de tokens

Right-most derivation refleja bottom-up parsing
Comenzamos con el string de tokens
Terminamos con el smbolo inicial
Bottom-up Parsing
Right-most derivation
<expr>
<expr> <op> <expr>
num * ( num + num )

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

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

Resumen
Gramticas Ambiguas
Otro Ejemplo

Entrada:
124 + 23.5 * 86

Token Stream:
num + num * num
Otro Ejemplo

<expr>
Produccin:
String: <expr>
Otro Ejemplo

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

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

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

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

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

num
+
num
<expr>
<expr> <expr>
<expr> <expr>
<op>
Produccin: <op> *
String: num + num * <expr>
*
<op>
Otro Ejemplo

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

num num
+
num
<expr>
<expr> <expr>
<expr> <expr>
<op>
*
<op>
Otro Ejemplo


Hay otro orden de derivacin?
Otro Ejemplo

<expr>

String: <expr>
Otro Ejemplo

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

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

num
<expr>
<expr> <expr> <op>
Pero tambin podemos usar esta produccin
Otro Ejemplo

<expr>
<expr> <expr> <op>
Produccin:
Pero tambin podemos usar esta produccin
Otro Ejemplo

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

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

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

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

num num
*
<expr>
<expr>
<expr>
<expr> <expr>
<op>
Produccin: <op> *
String: num + num * <expr>
+
<op>
Otro Ejemplo

num num
*
num
<expr>
<expr>
<expr>
<expr> <expr>
<op>
+
<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 Gramtica es Ambigua
Aplicar diferentes ordenes de derivacin
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 gramtica con
ms no-terminales va a eliminar la ambiguedad
La Gramtica 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 gramtica

+
( )
*
num
<term>
<unit> <term>
<expr>
<expr>
<term>
num * ( num + num )
<expr>
<unit>
num
<term>
<unit>
num
<unit>
Pregunta: Es esta gramtica
ambigua?

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

Pregunta: Cmo la hacemos no
ambigua?

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

Resumen
Gramticas Ambiguas
La implementacin de un parser para algunas
CFGs puede ser muy difcil
Tenemos que ver el input y elegir una produccin
No podemos elegir la produccin correcta sin ver
que viene en el input (looking ahead)
Ejemplo de look ahead
Gramtica
<stmt> a <long> b
<stmt> a <long> c
<long> x <long> | x

Input string axxxxxxxxxxxxxxxxx.

Puede que tengamos que ver un montn
de smbolos del input antes de decidirnos
por una produccin

Implementar un parser para algunas CFGs
puede ser muy difcil
No podemos elegir una produccin sin look ahead
Hay varias tcnicas
Cada una puede manejar algunas CFGs
Categorizacin de las tcnicas
Hay varias tcnicas
( )
Hay varias tcnicas

( )
L - parsear de izquierda a derecha
R parsear de derecha a izquierda
Hay varias tcnicas

( )
L - leftmost derivation
R - rightmost derivation
Hay varias tcnicas
( )
Nmero de caracteres de lookahead
Hay varias tcnicas

Ejemplos: LL(0), LR(1)
( )
Siguiente Clase
Cmo implementar un Parser
Cmo construir un parser engine
para un parser shift-reduce
Vamos a ver
LR(0)
LR(1)
LALR(1)
Parser
Engine
Resumen
Diferencia entre anlisis lxico y anlisis
sintctico
Arboles de Parseo
Derivaciones left-most y right-most
Top-down and bottom-up parsing
Gramticas Ambiguas
Implementacin de Parsers
Grupos
Ya tienen que tener grupos
Si no tienen grupo todava, hagnlo!
Los listados de grupos van a estar en el Web

Si no estn en un grupo en el Web hablen con
Andreaq

06 Analisis Sintactico

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

06 Analisis Sintactico

Încărcat de

Drepturi de autor:

Formate disponibile

Compiladores

Introduccin al Anlisis Sintctico

S-ar putea să vă placă și