Post on 22-Jan-2016
Lenguajes Libres de Contexto
Preparado por
Manuel E. Bermúdez, Ph.D.Profesor Asociado
University of Florida
Curso de Compiladores
Gramáticas Libres de Contexto
• Definición: Una gramática libre de contexto (GLC) es una tupla G = (, , P, S), donde todas las producciones son de la forma
A , donde A y (u )*.
• Derivación Izquierda: En cada paso, el símbolo no-terminal más a la izquierda es el que se re-escribe.
• Derivación Derecha: En cada paso, el símbolo no-terminal más a la derecha es el que se re-escribe.
Árboles de Derivación
Un árbol de derivación describe las re-escrituras, en forma independiente del orden (izquierdo o derecho).
• Cada rama del árbol corresponde a una producción en la gramática.
Árboles de Derivación
Notas:
1) Hojas en el árbol son símbolos terminales.2) El “contorno” inferior es la sentencia.3) Recursividad izquierda causa ramificación a
la izquierda.4) Recursividad derecha causa ramificación a
la derecha.
Metas del Análisis Sintáctico
• Examinar la hilera de entrada , y determinar si es legal o no en el lenguaje, i.e. si S =>* .
• Esto es equivalente a (intentar) construir el árbol de derivación.
• Beneficio adicional: si el inento es exitoso, el árbol refleja la estructura sintáctica de la hilera de entrada.
• Por lo tanto, el árbol debiera ser único (para una hilera dada).
Ambigüedad en Gramáticas
• Definición: Una GLC es ambigua si existen dos derivaciones derechas (o izquierdas, pero no ambas) para alguna sentencia z.
• Definición (equivalente) : Una GLC es ambigua si existen dos árboles de derivación diferentes, para alguna sentencia z.
Ambigüedad en Gramáticas
Dos ambigüedades clásicas (al menos en lenguajes de programación):
– Recursividad simultánea izquierda/derecha:
E → E + E
– Problema del “else colgante”: S → if E then S → if E then S else S
Reducción de Gramáticas
¿ Qué lenguaje genera esta gramática ?
S → a D → EDBCA → BCDEF E → CBAB → ASDFA F → SC → DDCF
Respuesta: L(G) = {a}
Problema: Algunos no-terminales (y producciones) son “inútiles”: no se pueden usar en la generación de ninguna sentencia.
Reducción de Gramáticas
Definición: Una GLC es reducida sii para todo A Ф,
a) S =>* αAβ, para algunos α, β V*, (decimos que A es generable), y
b) A =>* z, para algún z Σ* (decimos que A es terminable)
G es reducida sii todo símbolo no-terminal A es generable y también terminable.
Reducción de Gramáticas
Ejemplo: S → BB A → aAB → bB → a
B no es terminable, porque B =>* z, para ningún z Σ*.
A no es generable, porque S =>* αAβ, para ningunos α,βV*.
Reducción de Gramáticas
Para encontrar cuáles no-terminales son generables:
1. Construir el grafo (Ф, δ), donde (A, B) δ siiA → αBβ es una producción.
2. Verificar que todos los nodos son alcanzables desde S.
Reducción de Gramáticas
Ejemplo: S → BB A → aAB → bB → a
A no es generable, porque no es alcanzable desde S.
S B
A
Reducción de Gramáticas
Algoritmo 1: Calcular no-terminales generables
Generable := {S}
while(Generable cambia) do
para cada A → Bβ do if A Generable then
Generable := Generable U {B}od
{ Ahora, Generable contiene los
no-terminales que son generables
}
Reducción de Gramáticas
Para encontrar cuáles no-terminales son terminables:
1. Construir el grafo (2Ф, δ), donde(N, N U {A}) δ sii
A → X1 … Xn es una producción, y para todo i,
Xi Σ o bien Xi N.
2. Verificar que el nodo Ф (todos los no-terminales) es alcanzable desde el nodo ø (vacío).
Reducción de GramáticasEjemplo: S → BBA → aA
B → bB → a
{A, S, B} no es alcanzable desde ø ! Solo {A} es alcanzable desde ø. Conclusión: S y B no son terminables.
{A,B}{B}
{B,S}{S}
ø
{A}
{A,S} {A,S,B}
Reducción de GramáticasAlgoritmo 2: Calcular no-terminales terminables:
Terminable := { };while (Terminable cambia) do
para cada A → X1…Xn do if todo no-terminal entre los X’s
está en Terminable then Terminable := Terminable U {A}
od{ Ahora, Terminable contiene los
no-terminales que son terminables.}
Reducción de Gramáticas
Algorithmo 3: Reducción de una gramática:
1. Encontrar todos los no-terminales generables.
2. Encontrar todos los no-terminales terminables.
3. Eliminar cualquier producción A → X1 … Xn
si a) A is not generable o si b) algún Xi no es terminable.
4. Si la nueva gramática no es reducida, repetir el proceso.
Reducción de Gramáticas
Ejemplo: E → E + T F → not F → T Q → P / QT → F * T P → (E) → P → i
Generable: {E, T, F, P}, no Generable: {Q}
Terminable: {P, T, E}, no Terminable: {F,Q}
Entonces, se elimina toda producción para Q, y toda producción cuya parte derecha contiene F ó Q.
Reducción de Gramáticas
Nueva Gramática: E → E + T
→ T T → P
P → (E) → i
Generable: {E , T, P} Ahora, la gramática Terminable: {P, T, E} está reducida.
Reducción de GramáticasEjemplo: Resultado:
S → AB S → a → a B → bA → aAB → b Generable:{S} Terminable:{S,B}Generable:{S,A,B}no Terminable:{A} Se elimina B → b Se elimina toda producción Resultado final:que contiene A. S → a
Precedencia y Asociatividad de Operadores
• Construyamos una GLC (gramática libre de contexto) para expresiones, que consista de:
• El identificador i. • + , - (operadores binarios) con baja
precedencia y asociativos por la izquierda.• * , / (operadores binarios) con precedencia
media, y asociativos por la derecha.• + y - (operadores unarios) con la más alta
precedencia, y asociativos por la derecha.
Gramática para Expresiones E → E + T
→ E - T→ T
T → F * T → F / T→ F
F → - F→ + F→ P
P → ( E )→ i
E consiste de T's, separados por –’s y +'s,asociativos a la izquierda,con precedencia baja.
T consiste de F's,separados por *'s y /'s,asociativos a la derecha,con precedencia media.
F consiste de un solo P,precedido por +'s y -'s, asociativos a la derecha,con precedencia alta.
P consiste de una E entre paréntesis, o una i .
Precedencia y Asociatividad de Operadores
• Precedencia:– Cuanto más abajo en la gramática, más
alta la precedencia.• Asociatividad:
– Recursividad izquierda en la gramática, causa asociatividad izquierda del operador, y causa ramificación izquierda en el árbol.
– Recursividad derecha en la gramática cause asociatividad derecha del operador, y causa ramificación derecha en el árbol.
Árboles de Derivación
Hilera de Entrada: - + i - i * ( i + i ) / i + i
• Construcción (humana) del árbol de derivación:
• Método Ascendente.• En cada pasada se procesan los operadores
de mayor precedencia.• Los operadores de baja precedencia son los
últimos, en la parte superior del árbol.
Precedencia y Asociatividad de Operadores
Ejercicio: Escribir una gramática para expresiones:
• El identificador i. • ‘&’, ‘¢’, ‘*’ (operadores binarios) con baja
precedencia y asociativos por la izquierda.• ‘%’, ‘#’ (operadores binarios) con precedencia
media, y asociativos por la derecha.• ‘@’, ‘!’ (operadores binarios) con la más alta
precedencia, y asociativos por la izquierda.• Paréntesis sobrellevan la precedencia y la
associatividad.
Precedencia y Asociatividad de Operadores
Gramática: E0 → E0 & E1 → E0 ¢ E1 → E0 * E1 → E1E1 → E2 % E1 → E2 # E1 → E2E2 → E2 @ E3 → E2 ! E3 → E3E3 → (E0) → i
Precedencia y Asociatividad de Operadores
Ejemplo: Construir el árbol de derivación para:
i & i @ i # i ¢ ( i * i & i ! i) % ( i & i ) # i @ i
Árbol de Derivación
Gramáticas de Traducción
Definición: Una gramática de traducción (o esquema de traducción dirigido por sintaxis) es como una GLC, pero con la siguiente generalización:
Cada producción es una tupla (A, β, ω) Ф x V* x V*, llamada una regla de traducción, denotada
A → β => ω, donde A es la parte izquierda, β es la parte derecha, y ω es la parte de traducción.
Gramáticas de Traducción
Ejemplo: Traducción de infijo a postfijo para expresiones.
E → E + T => E T + → T => TT → P * T => P T * → P => PP → (E) => E Nota: ()’s se
eliminan → i => i
La parte de traducción describe cómo se genera la salida, conforme se deriva la entrada.
Gramáticas de Traducción
Se deriva un par (, β), donde y β son las formas sentenciales de la entrada y salida.
( E, E )
=> ( E + T, E T + )
=> ( T + T, T T + )
=> ( P + T, P T + )
=> ( i + T, i T + )
=> ( i + P * T, i P T * + )
=> ( i + i * T, i i T * + )
=> ( i + i * i, i i i * + )
Traducción de Hileras a ÁrbolesNotación: < N t1 … tn > denota
Gramática de traducción de hileras a árboles:
E → E + T => < + E T > → T => TT → P * T => < * P T > → P => PP → (E) => E → i => i
t1 … tn
N
Traducción de Hileras a Árboles
Ejemplo: (E, E)
=> (E + T, < + E T >)
=> (T + T, < + T T >)
=> (P + T, < + P T >)
=> (i + T, < + i T >)
=> (i + P * T, < + i < * P T > >)
=> (i + i * T, < + i < * i T > >)
=> (i + i * P, < + i < * i P > >)
=> (i + i * i, < + i < * i i > >)
i
+
i
*
i
Gramáticas de Traducción
Definición: Una gramática de traducción es simple si para cada regla A → => β, la secuencia de no-terminales en es idéntica a la secuencia que aparece en β.
Ejemplo: E → E + T => < + E T > → T => TT → P * T => < * P T > → P => PP → (E) => E → i => i
Traducción de Hileras a Árboles
Si la gramática es simple, eliminamos los no-terminales y la notación de árboles en las partes de traducción:
E → E + T => + → TT → P * T => * → PP → (E) → i => i Suena familiar ?
Notación del TWS
Árboles de Sintaxis Abstracta
• ASA es una versión condensada del árbol de derivación.
• Sin “ruido” (nodos intermedios).• Es el resultado de usar una gramática de
traducción de hilera-a-árbol.• Reglas de la forma A → ω => 's'. • Se construye un nodo 's', con un hijo por cada
símbolo no-terminal en ω.• Traducimos del vocabulario de entrada
(símbolos en ω), al vocabulario de nombres de nodos del árbol (e.g. ‘s’)
Ejemplo de ASAEntrada:: - + i - i * ( i + i ) / i + i
Árbol de Derivación
G:
ASA:
El Juego de Dominó Sintáctico
• La gramática:
E → E+T T → P*T P → (E) → T → P → i
• Las piezas de juego: Una cantidad ilimitada de cada pieza. Una pieza por cada regla en la gramática.
• El tablero de juego:• El dominó inicial arriba.• Los dominós abajo son la hilera de entrada.
El Juego de Dominó Sintáctico
• Reglas del juego: – Se agregan piezas al tablero.– Deben coincidir las partes planas, y los
símbolos.– Las líneas son infinitamente elásticas, pero
no se pueden cruzar.
• Objetivo del juego:– Conectar el dominó de inicio con los
dominós de entrada.– Que no sobren partes.
Estrategias de Análisis Sintáctico
• Las mismas que para el juego de dominó sintáctico.– Descendente (“top-down”): se comienza
con el dominó inicial, se trabaja hacia la hilera de entrada.
– Ascendente (“bottom-up”): se comienza con la hilera de entrada, se trabaja hacia el dominó inicial.
• En ambas estrategias, se puede procesar la entrada de izquierda-a-derecha , o de derecha-a-izquierda .
Análisis Sintáctico Descendente
• Se intenta una derivación izquierda, prediciendo la regla que hará coincidir lo que queda de la hilera de entrada.
• Se usa una hilera (una pila, en realidad) de la cual se pretende derivar la hilera de entrada.
Análisis Sintáctico Descendente• Se comienza con S en la pila.• A cada paso, dos alternativas:
1) (la pila) comienza con un símbolo terminal t. Debe coincidir con el siguiente símbolo de entrada.
2) comienza con un símbolo no-terminal A. Se consulta con un oráculo FOP (Función Omnisciente de Parsing) para determinar cuál producción de A llevaría a coincidir con el siguiente símbolo de entrada.
• La FOP es la parte “predictiva” del analizador.
Algoritmo Clásico de Análisis Sintáctico Descendente
Push (Stack, S);while not Empty (Stack) do
if Top(Stack) then if Top(Stack) = Head(input)
then input := tail(input)Pop(Stack)
else error (Stack, input)else P:= OPF (Stack, input)
Push (Pop(Stack), RHS(P))od
if (not empty(input)) then error
Análisis Sintáctico Descendente
• La mayoría de los métodos imponen cotas al número de símbolos de la pila y de la hilera de entrada, que se usan para escoger la producción. Para los lenguajes de programación, la escogencia común es (1,1).
• Debemos definir FOP (A,t), donde A es el primer símbolo en la pila, y t es el primer símbolo de la entrada.
• Requerimientos de almacenamiento: O(n2), donde n es el tamaño del vocabulario de la gramática, ≈ O(1002).
Análisis Sintáctico Descendente
FOP (A, t) = A → ω si1. ω =>* t, para algún ,2. ω =>* ε, y S =>* At, para algunos , , donde =>* ε.
ω
t …
ó
A …
Análisis Sintáctico Descendente
Ejemplo S → A B → b(ilustrando 1): A → BAd C → c
→ C
FOP b c d
B B → b B → b B → bC C → c C → c C → cS S → A S → A S → AA A → BAd A → C ???
OPF (A, b) = A → BAd porque BAd =>* bAdOPF (A, c) = A → C porque C =>* ci.e., B comienza con b, y C comienza con c.
Elementos de color café son opcionales. También el elemento ???
Análisis Sintáctico Descendente
Ejemplo (ilustrando 2): S → A A → bAd →
OPF b d
S S → A S → AA A → bAd A → A →
OPF (S, b) = S → A , porque A =>* bAdOPF (S, d) = -------- , porque S =>* αSdβOPF (S, ) = S → A , porque S es legalOPF (A, b) = A → bAd , porque A =>* bAdOPF (A, d) = A → , porque S =>* bAdOPF (A, ) = A → , porque S =>*A
Análisis Sintáctico Descendente
Definición:First (A) = {t / A =>* t, para algún }Follow (A) = {t / S =>* Atβ, para algún , β}
Cálculo de Conjuntos First:1. Construir grafo (Ф, δ), donde (A,B) δ si
B → A, =>* ε (i.e. First(A) First(B))2. Agregar a cada nodo un conjunto vacío de
terminales.3. Agregar t a First(A) si A → t, =>* ε.4. Propagar los elementos de los conjuntos a lo
largo de las aristas del grafo.
Análisis Sintáctico Descendente
Ejemplo:S → ABCD A → CDA C → AB → BC → a D → AC → b →
Anulables = {A, C, D}
S B
A C
D
{a, b}
{a} {a}
{b}
Paso 3: Agregar t
{a} Paso 4: Propagar
Paso 1: Grafo
Paso 2: Conjuntos { }
Análisis Sintáctico Descendente
Cálculo de Conjuntos Follow:1. Construir grafo (Ф, δ), donde (A,B) δ si
A → B, =>* ε.
Follow(A) Follow(B), porque cualquier símbolo X que sigue después de A, también sigue después de B, porque A puede terminar en B.
A X
B α
ε
Análisis Sintáctico Descendente
2. Agregar a cada nodo un conjunto vacío de terminales. Agregar a Follow(S).
3. Agregar First(X) a Follow(A) siB → AX, =>* ε.
Nota: First(t)={t}.
4. Propagar los elementos de los conjuntos a lo largo de las aristas del grafo.
Análisis Sintáctico Descendente
Ejemplo:S → ABCD A → CDA C → AB → BC → a D → AC → b →
Nullable = {A, C, D} First(S) = {a, b}First(C) = {a}First(A) = {a}First(D) = {a}First(B) = {b}
S B
A C
D
}
{a,b, {a }
{a
┴
┴┴{
}
, }
,b,
{a }, ┴ Café: Paso 4
┴
b,
Blanco: Paso 3
Análisis Sintáctico Descendente
Resumiendo,
Follow(S) = {}
Follow(A) = Follow(C) = Follow(D) = {a, b, }
Follow(B) = {a, }
Análisis Sintáctico Descendente
Regresando al análisis sintáctico …Deseamos que OPF(A, t) = A → ω si
1. t First(ω),i.e. ω =>* tβ
ó2. ω =>* ε and t Follow(A),
i.e. S =>* A => *Atβ
ω
t β
A α
t β
A αω
ε
Análisis Sintáctico Descendente
Definición: Select (A→ ω) = First(ω) U
if ω =>* ε then Follow(A) else ø
Así, PT(A, t) = A → ω si t Select(A → ω)
“Parse Table” (PT), en lugar de FOP, porque ya no es omnisciente.
Análisis Sintáctico DescendenteEjemplo: First (S) = {a, b} Follow (S) = { }
First (A) = {a} Follow(A) = {a, b, }First (B) = {b} Follow(B) = {a, }First (C) = {a} Follow (C) = {a, b, }First (D) = {a} Follow(D) = {a, b, }
Gramática Conjuntos Select S → ABCD {a, b}
B → BC{b} → b {b}A → CDA {a, b, } → a {a} → {a, b, }C → A {a, b, }D → AC {a, b, }
No disjuntos
No disjuntos por parejas
Gramática NO es LL(1)
Análisis Sintáctico Descendente
a b ┴S S → ABCD S → ABCDA A → CDA, A→ a, A → A → CDA, A → A → CDA,A → B B → BC, B → bC C → A C → A C → AD D → AC D → AC D → AC
Gramática no-LL(1): elementos múltiples en PT. S → ABCD {a, b} C → A {a, b, }
B → BC {b} D → AC {a, b, } → b {b}A → CDA {a, b, } → a {a} → {a, b, }
Gramáticas LL(1)
• Definición: Una GLC G es LL(1)( Left-to-right, Left-most, (1)-symbol lookahead) sii pata todo A Ф, y para todo par de
producciones A→, A → con ,
Select (A → ) ∩ Select (A → ) =
• Ejemplo previo: gramática no es LL(1).• Qué hacer ? Más tarde.
Ejemplo de gramática LL(1)
S → A {b,}A → bAd {b} → {d, }
Disjuntos!
Gramática es LL(1) !
d b
S S → A S → A
A A → A → bAd A →
A lo sumo una producción en cada posición de la tabla.
Ejemplo
• Construir la tabla de análisis sintáctico para la siguiente gramática.
S → begin SL end {begin} → id := E; {id}SL → SL S {begin,id} → S {begin,id}E → E+T {(, id}
→ T {(, id}T → P*T {(, id}
→ P {(, id}P → (E) {(}
→ id {id}
*
*
*
* No es LL(1)
Ejemplo (cont’d)
• Lemma: Rescursividad izquierda siempre produce una gramática no-LL(1)(e.g., SL, E)
• Prueba: Considere A → A First () or
Follow (A) → First () Follow (A)
Problemas con nuestra Gramática
1. SL tiene recursividad izquierda.
2. E tiene recursividad izquierda.
3. T → P * T comienzan con una → P secuencia en común (P).
Solución al Problema 3
• Cambiar: T → P * T { (, id } → P { (, id }
• a: T → P X { (, id }X → * T { * } → { +, ; , ) }
Follow(X) Follow(T) porque T → P X Follow(E) porque E → E+T , E → T= { +, ;, ) } porque E → E+T, S → id := E ; y P → (E)
Disjuntos!
Solución al Problema 3 (cont’d)
• En general, cambiar A → 1
→ 2
. . . → n
a A → X X → 1
. . . → n
Con suerte, todos los ’s comienzan con símbolos distintos
Solución a los Problemas 1 y 2
• Queremos (…((( T + T) + T) + T)…)• En su lugar, (T) (+T) (+T) … (+T)
Cambiar: E → E + T { (, id } → T { (, id }
a: E → T Y { (, id }Y → + T Y { + } → { ; , ) }
Follow(Y) Follow(E) = { ; , ) }
Ya no contiene ‘+’, porque eliminamos la producción E → E + T
Solución a los Problemas 1 and 2 (cont’d)
• En general,
Cambiar: A → A1 A → 1
. . . . . . → An → m
a A → 1 X X → 1 X . . . . . . → m X → n X
→
Solución a los Problemas 1 and 2 (cont’d)
• En nuestro ejemplo,
Cambiar: SL → SL S { begin, id } → S { begin, id }
a: SL → S Z { begin, id } Z → S Z { begin, id }
→ { end }
Gramática Modificada
S → begin SL end {begin} → id := E ; {id}SL → S Z {begin,id} Z → S Z {begin,id}
→ {end}E → T Y (,id}Y → + T Y {+}
→ {;,)}T → P X {(,id}X → * T {*}
→ {;,+,)}P → (E) {(}
→ id {id}
Disjuntos.
La gramática es LL(1)
Parsing de Descenso Recursivo
• Estrategia descendente, apropiada para geramáticas LL(1).
• Una rutina por cada no-terminal.• Contenido de pila embebido en la
secuencia de llamadas recursivas.• Cada rutina escoge y recorre una
producción, basado en el siguiente símbolo de entrada, y los conjuntos Select.
• Buena técnica para escribir un analizador sintáctico a mano.
Parsing de Descenso Recursivo
proc S; {S → begin SL end → id := E; }
case Next_Token ofT_begin : Read(T_begin);
SL;Read (T_end);
T_id : Read(T_id);Read (T_:=);E;Read (T_;);
otherwise Error;end
end;
“Read (T_X)” verifica que el siguiente token es X, y lo consume.
“Next_Token” es el siguiente token.
Parsing de Descenso Recursivo
proc SL; {SL → SZ}S;Z;
end;
proc E; {E → TY}T;Y;
end;
Técnicamente, debimos insistir que Next_Token fuera T_begin o T_id, pero S hará eso de todas maneras. Revisión temprana ayuda en la recuperación de errores.
Lo mismo para T_( y T_id.
Parsing de Descenso Recursivo
proc Z;{Z → SZ→ }
case Next Token ofT_begin, T_id: S;Z;
T_end: ;otherwise Error;
endend;
Parsing de Descenso Recursivo
proc Y; {Y → +TY → }
if Next Token = T_+ thenRead (T_+)T;Y;
end;
proc T; {T → PX}P;X
end;
Se puede usar un ‘case’
Se pudo haber insistido que Next_Token fuera T_( o T_id.
Parsing de Descenso Recursivo
proc X;{X → *T→ }
if Next Token = T_* thenRead (T_*);T;
end;
Parsing de Descenso Recursivo
proc P; {P →(E) → id }
case Next Token ofT_(: Read (T_();
E;Read (T_));
T_id: Read (T_id);otherwise Error;
endend;
Traducción hilera-a-árbol
• Podemos obtener el árbol de derivación o el ASA.
• El árbol puede ser generado en forma ascendente o descendente.
• Mostraremos cómo obtener1. Árbol de derivación en forma
descendente.2. ASA para la gramática original, en
forma ascendente.
Generación Descendente del AD
• En cada rutina, y para cada alternativa, escribir la producción escogida EN CUANTO HAYA SIDO ESCOGIDA.
Generación Descendente del ADproc S; {S → begin SL end
→ id := E; }case Next_Token of
T_begin : Write(S → begin SL end);Read(T_begin);SL;Read(T_end);
T_id : Write(S → id :=E;); Read(T_id);Read (T_:=);E;Read (T_;);
otherwise Errorend
end;
Generación Descendente del AD
proc SL; {SL → SZ}Write(SL → SZ);S;Z;
end;
proc E; {E → TY}Write(E → TY);T;Y;
end;
Generación Descendente del AD
proc Z; {Z → SZ → }
case Next_Token of T_begin, T_id: Write(Z → SZ);
S; Z;
T_end: Write(Z → );otherwise Error;
endend;
Generación Descendente del ADproc Y; {Y → +TY
→ }if Next_Token = T_+ then
Write (Y → +TY);Read (T_+);T;Y;
else Write (Y → );end;
proc T; {T → PX}Write (T → PX);
P; Xend;
Generación Descendente del AD
proc X;{X → *T
→ }
if Next_Token = T_* then
Write (X → *T);
Read (T_*);T;
else Write (X → );
end;
Generación Descendente del AD
proc P;{P → (E)→ id }
case Next_Token ofT_(: Write (P → (E));
Read (T_(); E; Read (T_));
T_id: Write (P → id);
Read (T_id);otherwise Error;
end;
Notas
• La colocación de las instrucciones Write es obvia precisamente porque la gramática es LL(1).
• El árbol puede ser construido conforme procede el algoritmo, o puede ser construido por un post-procesador.
S → begin SL endSL → SZS → id :=E;E → TYT → PXP → (E)E → TYT → PXP → idX →Y → +TYT → PXP → idX → Y → X → *TT → PXP → idX → Y → Z →
Generación Ascendente del AD
• Pudimos haber colocado las instrucciones Write al FINAL de cada frase, en lugar del principio. De ser así, generamos el árbol en forma ascendente.
• En cada rutina, y para cada alternativa, escribimos la producción escogida A → DESPUÉS de reconocer .
Generación Ascendente del AD
proc S;{S → begin SL end → id := E; }
case Next_Token ofT_begin: Read (T_begin);
SL;Read (T_end);
Write (S → begin SL end);
T_id: Read (T_id); Read (T_:=);
E;Read (T_;);Write (S → id:=E;);
otherwise Error;end;
Generación Ascendente del AD
proc SL; {SL → SZ}S;Z;Write(SL → SZ);
end;
proc E; {E → TY}T;Y;Write(E → TY);
end;
Generación Ascendente del AD
proc Z; {Z → SZ → }
case Next_Token of T_begin, T_id: S;
Z; Write(Z → SZ);
T_end: Write(Z → );otherwise Error;
endend;
Generación Ascendente del AD
proc Y; {Y → +TY → }
if Next_Token = T_+ thenRead (T_+);T;Y;Write (Y → +TY);
else Write (Y → );end;
Generación Ascendente del AD
proc T; {T → PX }P;X;
Write (T → PX)end;
proc X;{X → *T
→ }if Next_Token = T_* then
Read (T_*);T;
Write (X → *T);
else Write (X → );end
Generación Ascendente del AD
proc P;{P → (E)→ id }
case Next_Token ofT_(: Read (T_();
E; Read (T_));
Write (P → (E));T_id: Read (T_id);
Write (P → id);otherwise Error;
end;
Notas
• La colocación de las instrucciones Write sigue siendo obvia.
• Las producciones se emiten conforme las rutinas terminan, en lugar de hacerlo al empezar.
• Las producciones son emitidas en orden inverso, i.e., la secuencia de producciones debe ser utilizada en orden inverso para producir una derivación derecha.
• Nuevamente, el árbol puede ser construido conforme procede el algoritmo (usando una pila de árboles), o puede ser construido por un post-procesador.
Ejemplo
• Hilera de Entrada: begin id := (id + id) * id; end• Salida:
P → idX →T → P XP → idX →T → P XY → Y → +T YE → T YP → ( E )
P → idX → T → PXX → *TT → PXY → E → TYS → id:=E; Z → SL → SZS → begin SL end
P → idX →T → P XP → idX →T → P XY → Y → + T YE → T YP → ( E )P → idX → T → P XX → * TT → P XY → E → T YS → id := E; Z → SL → S ZS → begin SL end
Recursividad vs. Iteración
• No todos los símbolos no-terminales son necesarios.
• La recursividad de SL, X, Y y Z se puede reemplazar con iteración.
Recursividad vs. Iteración
proc S; {S → begin SL end→ id := E;
case Next_Token ofT_begin : Read(T_begin);
repeat S;until Next_Token {T_begin,T_id};Read(T_end);
T_id : Read(T_id);Read (T_:=);E;Read (T_;);
otherwise Error;end
end;
Reemplaza recursividad de Z, porque L(Z)=S*
Reemplaza llamado a SL.
SLSL → S Z Z → S Z → }
Recursividad vs. Iteración
proc E; {E → TYY → +TY → }
T;while Next_Token = T_+ do Read (T_+); T;
odend;
Reemplaza recursividad de Y, porque L(Y)=(+T)*.
Recursividad vs. Iteración
proc T; {T → PXX → *T → }
P;if Next_Token = T_*
then Read (T_*);T;
end;Reemplaza llamado a X,porque L(X)=(*T)?No hay iteración, porqueX no es recursivo.
Recursividad vs. Iteración
proc P;{P → (E)→ id }
case Next_Token ofT_(: Read (T_();
E; Read (T_));
T_id: Read (T_id);otherwise Error;end
end;
Construcción Ascendente del AD, para la gramática original
proc S; { (1)S → begin SL end (2)S → begin SL end → id := E; → id := E;
SL → SZ SL → SL S Z → SZ → S
→ }
case Next_Token ofT_begin: Read(T_begin); S; Write(SL → S);
while Next_Token in {T_begin,T_id} doS; Write(SL → SL S);
od Read(T_end); Write(S → begin SL end);
T_id: Read(T_id);Read (T_:=);E;Read (T_;); Write(S → id :=E;);
otherwise Error;end
end;
Construcción Ascendente del AD, para la gramática original
proc E; {(1)E → TY (2) E → E+T Y → +TY → T → }
T;Write (E → T);while Next_Token = T_+ do
Read (T_+);T;Write (E → E+T);
odend while, porque Y es
recursivo
Construcción Ascendente del AD, para la gramática original
proc T; {(1)T → PX (2) T → P*T X → *T → P →
}P; if Next_Token = T_*
then Read (T_*);T;Write (T → P*T)
else Write (T → P);end;
if, porque X no es recursivo
Construcción Ascendente del AD, para la gramática original
proc P;{(1)P → (E) (2)P → (E) → id → id
}
// IGUAL QUE ANTESend;
P → idT → PE → TP → idT → PE → E+TP → (E)P → idT → P
T → P*TE → TS → id:=E;SL→ SS → begin SL end
T → P*TE → TS → id:=E;SL→ SS → begin SL end
Generación ascendente del ASA, para la gramática original proc S; { S → begin S+ end 'block'
→ id := E; 'assign'var N:integer;
case Next_Token ofT_begin : Read(T_begin);
S;N:=1;while Next_Token in {T_begin,T_id} do
S;N:=N+1;
odRead(T_end);Build Tree ('block',N);
T_id : Read(T_id);Read (T_:=);E;Read (T_;);Build Tree ('assign',2);
otherwise Errorend
end;
Asumimos que se construye un nodo.
Build Tree (‘x’,n) saca n árboles de la pila, construye un nodo ‘x’ como su padre, y entra el árbol resultante en la pila.
Generación ascendente del ASA, para la gramática original proc E; {E → E+T '+'
→ T }T;while Next_Token = T_+ do
Read (T_+)T;Build Tree ('+',2);
odend;
Ramificación izquierda en el árbol !
Generación ascendente del ASA, para la gramática original
proc T; {T → P*T '*' → P }
P;if Next_Token = T_*
then Read (T_*)T;Build Tree ('*',2);
end;
Ramificación derecha en el árbol !
Generación ascendente del ASA, para la gramática original
proc P;{P → (E)→ id }
// IGUAL QUE ANTES, // i.e.,no se construye árbol // encima de E o id.end;
Ejemplo
• Hilera de Entrada:
begin id1 := (id2 + id3) * id4; end
• Secuencia de eventos:
id1
id2
id3
id4
BT('+',2)
BT('*',2)
BT('assign',2)
BT('block',1)
Resumen
• Construcción ascendente o descendente del árbol deseado.
• Gramática original o modificada.• Árbol de derivación, o árbol de sintaxis
abstracta.
• Técnica de escogencia:– Parser de descenso recursivo,– Construcción ascendente del ASA,
para la gramática original.
Parsing LR
•Las rutinas en el parser de descenso recursivo pueden ser “anotadas” con “items”.•Item: una producción con un marcador “.” en la parte derecha.•Podemos usar los “items” para describir la operación del parser de descenso recursivo.•Existe un NFA (un estado por cada item) que describe todas las secuencias de llamadas en el código de descenso recursivo.
Parser de Descenso Recursivo con itemsEjemplo:
proc E; {E → .E + T, E →.T}
T; {E → E. + T, E → T.} while Next_Token = T_+ do
{E → E. + T}Read(T_+); {E → E + .T }T; {E → E + T.}
od{E → E + T. E → T.}
end;
TT
+
T
NFA que conecta items
NFA: M = (PP, V, , S’ → .S, { S’ → S.})PP: conjunto de todos los items posibles (PP: producciones con punto), y se define tal que
simula un llamado a B
simula la ejecución de la rutina X,si X es no-terminal, oRead(X), si X es un terminal.
1 A → α.Bβ B → . ω
2 A → α.Xβ A→X.βX
T → . (E)
Ejemplo:E → E + T T → i S → E → T T → (E)
E → T .
NFA que conecta items
S → . E S → E .S → E .
E → . T
T → . i T → i .
T → (E) .
T → (E.)
T → (.E)
E → .E + T E → E. + T E → E +. T E → E + T.
ε
εε
ε
E
εε
E +
ε
E
ε
T
ε
ε(
i
T
)
┴
NFA que conecta items
• Hay que usar esta máquina con una pila (la secuencia de llamadas recursivas).
• Para “regresar” de A → ω., retrocedemos |ω| + 1 estados, y avanzamos sobre A.
• Problema de esta máquina: es no-determnística.
No problem. Be happy . Transformémosla a una DFA !
DFA que conecta items
ESTE ES UN AUTÓMATA LR(0)
S → . E ┴ S → E .┴S → E . ┴
E → . T
E → T .
T → . iT → i .T → . (E)
T → (E) .T → (E.)T → (.E)
E → .E + T E → E. + T
E → E +. T E → E + T.
E
T
(
i
T
┴
E → .E + T
T → .iE → .T
T → .(E)
E → E. + T
T → .iT → .(E)
i
i
E
+
(
T
)(
+
Parsing LR
• LR significa “Left-to-Right, Right-most Derivation”.
• Necesitamos una pila de estados para operar el parser.
• Se requieren 0 símbolos de “look-ahead”, por lo que se denomina LR(0).
• El DFA describe todas las posiciones posibles en el código de descenso recursivo.
• Una vez construido el automáta, se pueden descartar los items (como siempre con NFA →DFA).
Parsing LR
Operación de un parser LR
Dos movimientos: “shift” y “reduce”.
• Shift: Avanzar desde el estado actual sobre Next_Token, y agregar el estado nuevo a la pila.
• Reduce: (sobre A → ω). Remover |ω| estados de la pila. Avanzar desde el nuevo estado, sobre A.
Pila Entrada Árbol deDerivación
1 i + (i + i) ┴ i + ( i + i )
14 + (i + i) ┴
13 + (i + i) ┴
12 + (i + i) ┴
127 (i + i) ┴
1275 i + i) ┴
12754 + i) ┴
12753 + i)┴
12758 + i) ┴
127587 i) ┴
1275874 ) ┴
1275879 ) ┴
12758 ) ┴
12758 10 ┴
1279 ┴
12 ┴
126 ---------
E
Parsing LR
1 3
2 4 5
6 7 8
9 10
E
E
ii
i (
(
)
+
+┴
T
T
E → E+T T → (E)
E → T
(
T
T→i
T
E
T
TE
T
E
Parsing LR
Representación de Parsers LR
Dos Tablas:• Acción: indexada por estado y símbolo terminal.
Contiene los movimientos “shift” y “reduce”.
• GOTO: indexada por estado y símbolo no-terminal. Contiene las transiciones sobre símbolos no-terminales.
Parsing LR
Ejemplo:
1 3
2 4 5
6 7 8
9 10
E
E
i
i
i (
(
)
+
+┴
T
T
E → E+T
E → T
(
T
1 S/4 S/5 2 3
2 S/7 S/6
3 R/E→T R/E→T R/E→T R/E→T R/E→T
4 R/T→ i R/T→ i R/T→ i R/T→ i R/T→ i
5 S/4 S/5 8 3
6 Accept Accept Accept Accept Accept
7 S/4 S/5 9
8 S/7 S/10
9 R/E →E+T
R/E →E+T
R/E →E+T
R/E →E+T
R/E →E+T
10
R/T → (E)
R/T → (E)
R/T → (E)
R/T → (E)
R/T → (E)
ACCIÓN GOTO
i + ( )
E T
┴
T → (E)
T→i
Parsing LR
Algoritmo Driver_LR:
Push(Start_State, S);while ACTION (Top(S), ) ≠ Accept do
case ACTION (Top(S), Next_Token) ofShift/r: Read(Next_Token); Push(r, S)Reduce/A → ω: Pop(S) |ω| veces;
Push(GOTO (Top(S), A), S);empty: Error;
end;end;
Parsing LR
Construcción Directa del Autómata LR(0):
• PT(G) = Closure({S’ → .S }) U {Closure(P) | P Successors(P’), P’
PT(G)}
• Closure(P) = P U {A → .w | B → α.Aβ Closure(P)}
• Successors(P) = {Nucleus(P, X) | X V}
• Nucleus(P, X) = {A → αX .β | A → α.Xβ P}
Parsing LR
Construcción Directa del Autómata LR(0) previo
S → .E E → .E + TE → .TT → .iT → .(E)
S → E . E → E. + T
E → T.
T → i.
T → (.E)E → .E + TE → .TT → .iT → .(E)
S → E.
E → E + .TT → .iT → .(E)
┴ T → (E.)E → E. + TE → E + T.
T → (E).
1
2
3
4
┴
5
6
7
8
9
10
E 2E 2
T 3i 4
( 5
6+ 7
┴
E 8E 8
T 3i 4
( 5
T 9i 4
( 5
) 10+ 7
E → E + T T → i S → E → T T → (E)
Parsing LR
Notas:
• Esta gramática es LR(0) porque no tiene “conflictos”.
• Un conflicto ocurre cuando un estado contienea. Conflicto shift-reduce: un item final (A →
ω.) y un item no-final (A → α.β), o
b. Conflicto reduce-reduce: Dos o más items finales (A → ω. y B → ω.).
Parsing LR
Ejemplo:E → E + T T → P * T P → i → T → P P → (E)
S → .E E → .E + TE → .TT → .P * TT → .PP → .iP → .(E)S → E . E → E. + TE → T.
T → P. * TT → P.
P → (.E)E → .E + TE → .TT → .P * TT → .PP →. iP → .(E)S → E .E → E + .TT → .P * TT → .PP → .iP → .(E)
┴ T → P * .TT → .P * TT → .PP → .iP → .(E)P → (E.)E → E. + TE → E + T.
1
2
3
4
┴
5
6
78
9
10
E 2E 2
T 3P 4
7+ 8
┴
E 10E 10
T 3P 4
P 4
T 11P 4
( 6
T 12P 4
P 4i 5
( 6
* 9
P →i.
i 5( 6
┴
P 4i 5
P 4i 5
(6
) 13+ 8
11
12 T → P * T .
13 P → (E).
La gramática no es LR(0).
Parsing LR
El conflicto aparece en la table ACCIÓN, como entradas múltiples.
+ * i ( )
1 S/5 S/62 S/8 S/73 R/E→T45 R/P→i6 S/5 S/67 Accept8 S/5 S/69 S/5 S/610 S/8 S/1311 R/E→E+T12 R/T→P*T13 R/P→(E)
ACCIÓN
┴
R/T→P S/9,R/T→P R/T→P
Parsing LR
Solución: Utilizar “lookahead”, tomando en cuenta el siguiente símbolo de entrada en la decisión de parsing.
• En LL(1), lookahead se usa al principio de la producción.
• En LR(1), lookahead se usa al final de la producción.
Usaremos: SLR(1) – Simple LR(1)LALR(1) – LookAhead LR(1)
Parsing LR
SLR(1):Calculamos Follow(A) para cada producción A →ω que
causa un conflicto. Luego, se coloca “R/A → ω” en ACCIÓN[p,t] solo si t Follow(A).
Aquí, Follow(T) Follow(E) = {+, ), }.
+ * i ( ) ┴
4 (antes) R/T→P S/9,R/T→P R/T→P R/T→P R/T→P R/T→P 4 (después) R/T→P S/9 R/T→P
R/T→P
Problema resuelto. La gramática es SLR(1)
Parsing LR
Ejemplo: S → aSb {anbn/ n > 0} →
S’ → .S S → .aSbS → .S’ → S . S → a.SbS → .aSbS → .S’ → S .
1
2
3
4
5
S 2a 3
4
S 5
┴
a 3
S → aS.b
┴
┴
┴
6 S → aSb.
b 6
1 2S 4
3 5a 6
┴
S b
S →
S →
a b S
1 S/3R/S→ R/S→ R/S→
2
2 S/4
3 S/3R/S→ R/S→ R/S→
5
4 Accept Accept Accept
5 S/6
6 R/S→aSbLa gramática no es LR(0)
a
S → aSb
4
Parsing LR
Análisis SLR(1):Estado 1: Follow(S)={b, }. Ya que a Follow(S),
el conflicto shift/reduce queda resuelto.
Estado 3: La misma historia.
Las filas 1 y 3 resultantes:a b ┴ S
1 S/3 R/S → R/S → 23 S/3 R/S → R/S → 5
Conflictos resueltos. La gramática es SLR(1).
Parsing LR
Gramáticas LALR(1)Ejemplo: S → AbAa A → a
→ Ba B → a
AutómataLR(0):
1 2S 6
3 7A 10b a A → a
4 8B a
A → AbAa9 11A a
5a
S → Ba
A → aB → a Conflicto reduce-reduce.
La gramática no es LR(0).
Análisis SLR(1): Follow(A)={a,b}, No disjuntos. Follow(B)={a} Conflicto no resuelto.
a b ┴ 5 R/A→a,R/B→a R/A→a La gramática no es SLR(1).
Parsing LRAnálisis LR(0):
a b ┴ 5 R/A→a,R/B→a R/A→a,R/B→a R/A→a,R/B→a La gramática no es LR(0).
Parsing LR
Técnica LALR(1):I. Para cada reducción conflictiva A → ω en cada estado inconsistent q, hayar todas las transiciones no-terminales (pi, A) tales que
II. Calcular Follow(pi, A) (ver abajo), para todo i, y unir los resultados. El conjunto que resulta es el conjunto de “lookahead” LALR(1) para la reducción A → ω en q.
p1A
q
Apn
A → ω
ω
ω
Cálculo de Follow(p, A):Es el cálculo ordinario Follow, en otra gramática,
llamada G’. Para cada transición (p, A), y cada producción A→w1 w2…wn, tenemos
En esta situación, G’ contiene esta producción:(p, A) → (p, w1)(p2, w2)…(pn, wn)
G’: Consiste de las transiciones en el autómata LR(0). Refleja la estructura de G, y la del autómata LR(0).
Parsing LR
p A
p2 A → w1…wn…w2Wn-1
w1
p3 pn
Wn
Parsing LR
En nuestro ejemplo: G: S → AbAa A → a → Ba B → a
G’: (1, S) → (1, A)(3, b)(7, A)(9, a)
→ (1, B)(4, a) (1, A) → (1, a) (7, A) → (7, A)
(1, B) → (1, a)
Estos se separaron !
1 2S 6
3 7A 10b a A → a
4 8B a
A → AbAa9 11A a
5a
S → Ba
A → aB → a
Parsing LR
Para el conflicto en el estado 5, necesitamosFollow(1, A) = {(3, b)}Follow(1, B) = {(4, a)}. Se extraen los símbolos terminales:
a b ┴
5 R/B → a R/A → a Conflicto resuelto.
La gramática es LALR(1).
5aA → a {b}B → a {a}
Parsing LREjemplo:S → bBb B → A
→ aBa A → c → acb
AutómataLR(0):
La gramática no es LR(0)
1 2S 5
8
11b
A → c
7
4
63
a
S → bBb
S → aBa12
10
9
A
Aa
cB
Bc
B → A
b 13 S → acb
b
A → cEstado 10 es inconsistente (conflicto shift-reduce).
Parsing LRAnálisis SLR(1), estado 10: Follow(A) Follow(B) ={a, b}.
La gramática no es SLR(1).
Análisis LALR(1): Se necesita Follow(4, A).
G’: (1,S) → (1, b)(3, B)(6, b) (3, B) → (3, A) → (1, a)(4, B)(9, a) (4, B) → (4, A) → (1, a)(4, c)(10, b) (3, B) → (3, c)
(4, A) → (4, c)
Así, Follow(4, A) Follow(4, B) = {(9, a)}.El conjunto lookahead es {a}. La gramática es LALR(1).
Resumen de Parsing
Parsing Descendente (top-down):• Escrito a mano o dirigido por tabla: LL(1)
S
w
β
Parte conocida
pila
Parte por predecir
Parte conocida
Entrada por procesarEntrada procesada
α
Resumen de Parsing
Parsing Ascendente (bottom-up): • Dirigida por tabla: LR(0), SLR(1), LALR(1).
S
w
β
Parte desconocidapila
Parte conocida
Parte conocida
Entrada por procesarEntrada procesada
α
Lenguajes Libres de Contexto
Preparado por
Manuel E. Bermúdez, Ph.D.Profesor Asociado
University of Florida
Curso de Compiladores