Upload
satan-trismegisto
View
46
Download
2
Embed Size (px)
Citation preview
1
Análisis Sintáctico
AnalizadorSintáctico
Cadena detokens
ÁrbolSintáctico
En realidad...
Árbol sintáctico
AnalizadorLéxico
AnalizadorSintáctico
Tabla deSímbolos
Componente léxico
Obtén otro
componente léxico
2
Análisis Sintáctico. Procesadores de Lenguaje I
Análisis SintácticoFunciones
Comprobar que la secuencia de componentes léxicos cumple las reglas de la gramáticaGenerar el árbol sintáctico
Ventajas de utilizar gramáticasSon especificaciones sintácticas y precisas de lenguajesSe puede generar automáticamente un analizadorEl proceso de construcción puede llevar a descubrir ambigüedadesImparte estructura al lenguaje de programación, siendo más fácil generar código y detectar erroresEs más fácil ampliar y modificar el lenguaje
Análisis Sintáctico. Procesadores de Lenguaje I
Analizador Sintáctico, TiposTres tipos generales de analizadores sintácticos:
Métodos Universales: Cocke-Younger-Kasami y EarleySirven para cualquier gramáticaMuy ineficientes
Descendentes (top-down)Construyen el árbol de análisis sintáctico desde arriba (raíz, axioma) hasta abajo (hojas, terminales)
Analizadores Descendentes RecursivosAnalizadores LL(1) con tabla
Ascendentes (bottom-up)Construyen el árbol de análisis sintáctico desde abajo hacia arriba
Analizadores de Precedencia de OperadorAnalizadores LR(1)
3
Análisis Sintáctico. Procesadores de Lenguaje I
Analizador SintácticoTanto para el análisis descendente como para el ascendente:
La entrada se examina de izquierda a derecha, un símbolo cada vezTrabajan con subclases de gramáticas
En general las gramáticas serán LL y LRLR(k) ⊃ LL(k)En la práctica solo se utilizan LR(1) y LL(1)
Muchos compiladores se llaman “parser-driven” debido a que el analizador sintáctico es el que llama al léxicoExisten herramientas para generar automáticamente analizadores sintácticos (YACC, Bison)
Análisis Sintáctico. Procesadores de Lenguaje I
Analizador SintácticoÁrbol sintáctico
Ejemplo: Id.*.Id.+.Id
Expresión
Expresión Término
IdTérmino
Id
+
*Expresión
Término
Id
Gramática:Expresión::=Expresión.*.Término| Expresión.+.Término| TérminoTérmino ::= Id| Número
4
Análisis Sintáctico. Procesadores de Lenguaje I
Análisis Sintáctico DescendenteAlgoritmo1. Poner el axioma como raíz del árbol de derivación2. Hasta que solo haya símbolos terminales, derivar más a la
izquierda
EjemploEntrada: Id.*.Id.+.IdGramática:Expresión::=Expresión.*.Término | Expresión.+.Término |
TérminoTérmino ::= Id | Número
Derivación:Expresión → Expresión.+.Término →Expresión.*.Término.+.Término →Término.*.Término.+.Término →Id.*.Término.+.Término →Id.*.Id.+.Término → Id.*.Id.+.Id
Análisis Sintáctico. Procesadores de Lenguaje I
Análisis Sintáctico AscendenteDefinición: Pivote
Secuencia más larga de símbolos (ΣT y ΣN) en la parte más izquierda de la entrada que se puede encontrar en la parte derecha de una producción y tal que todos los símbolos a su derecha son terminalesEjemplo:
Si entrada es: Expresión.*.Término.+.Idel pivote es: Expresión.*.Término
Algoritmo1. Empezar con la cadena de entrada2. Intentar llegar hasta el axioma, encontrando el pivote y
reduciéndolo con la producción correspondiente
EjemploId.*.Id.+.Id → Término.*.Id.+.Id → Expresión.*.Id.+.Id →Expresión.*.Término.+.Id → Expresión.+.Id →Expresión.+.Término → Expresión
5
Análisis Sintáctico. Procesadores de Lenguaje I
Analizadores Sintácticos, Problemas
DescendentesMas de una opción: A::= α | β
RetrocesoAnalizar los siguientes elementos de la entrada
Recursividad izquierdaEliminación de la recursividad
AmbigüedadFactorización por la izquierda
AscendentesMás de una opción: A::= α y α es el pivote
OtrosProblemas semánticos
Análisis Sintáctico. Procesadores de Lenguaje I
Análisis Sintáctico PredictivoNo necesita realizar retroceso para analizar bien las sentencias del lenguajeSólo con ver el siguiente carácter de la entrada puede decidir cuál va a ser la siguiente producción a emplearCondiciones
Diseñar bien la gramáticaEliminar la recursividad izquierdaFactorizar por la izquierda
No está asegurado el tener una gramática predictivaLas gramáticas son difíciles de leerPara las partes de las gramáticas que no son predictivas se pueden utilizar otros analizadores
6
Análisis Sintáctico. Procesadores de Lenguaje I
Análisis Sintáctico Predictivo:Descendente RecursivoSe ejecuta un conjunto de procedimientos recursivos para procesar la entradaA cada NO Terminal de una gramática se le asocia un procedimiento
Decide la producción que utilizará analizando el símbolo de preanálisis,
si está en PRIMERO(α) entonces se usa la producción con lado derecho αsi no está en ningún PRIMERO entonces se usa una producción λ
Usa una producción imitando al lado derechono terminal da como resultado una llamada a otro procedimientoterminal (que coincide con el símbolo de preanálisis) produce otra lectura de otro token. Si el token no coincide entonces Error
La secuencia de procedimientos llamados para procesar la entrada define implícitamente un árbol de análisis sintáctico
Análisis Sintáctico. Procesadores de Lenguaje I
Análisis Sintáctico Predictivo:Descendente Recursivo
Ejemplo:S → if B then S | write B | i := BB → i = i | i <> i | true | false
Procedure S(){if (car== if)
{ scan();B();if (car== then) {scan();} else error();S();
}else if (car==write) {scan();B();
}else if (car== i){ scan();
if (car == asig) {scan();} else error();B();
}else error()
}
Procedure B(){
if (car= i) { scan();
if (car in [igual, noigual]) scan(); else error();if (car == i) then scan else error;
}elseif (car in [true, false])
scan();else
error();}
7
Análisis Sintáctico. Procesadores de Lenguaje I
Análisis Sintáctico Predictivo, DEFINICIONES: PRIMERO
Si α es una cadena de símbolos gramaticales, PRIMERO(α) es el conjunto de terminales que inician las cadenas derivadas de α.
PRIMERO(α)={x | (α →* xβ), (x ∈ ΣT ∪ {λ}), (α, β ∈Σ*)}Conjunto PRIMERO(X) para todos los símbolos gramaticales X1. Repetir hasta que no se puedan añadir más terminales o λ a
ningún conjunto PRIMERO2. Si X ∈ ΣT ⇒ PRIMERO(X) es { X }3. Si X → λ ⇒ añadir λ a PRIMERO(X)4. Si X ∈ ΣN y X →Y1Y2...YKY ⇒ a ∈ PRIMERO(X) si a ∈ PRIMERO(Yi)
y λ ∈ PRIMERO(Y1), PRIMERO(Y2),..., PRIMERO(Yi-1)Si Y1 deriva a λ ⇒ se añade PRIMERO(Y2)Si Y1 no deriva a λ ⇒ no se añade más a PRIMERO(X)
Análisis Sintáctico. Procesadores de Lenguaje I
Análisis Sintáctico Predictivo, DEFINICIONES: PRIMERO
PRIMERO(α), Ejemplo:E ::= T.E’E’ ::= +.T.E’ | λT ::= F.T’T’ ::= *.F.T’ | λF ::= (.E.) | Id
PRIMERO(E) = { (, Id } PRIMERO(T.*.Id) = { (, Id }
PRIMERO(T) = { (, Id } PRIMERO(Id.+.Id) = { Id }
PRIMERO(F) = { (, Id } PRIMERO(Id) = { Id }
PRIMERO(E’) = { +, λ } PRIMERO(T’) = { *, λ }
8
Análisis Sintáctico. Procesadores de Lenguaje I
Análisis Sintáctico Predictivo, DEFINICIONES: SIGUIENTE
Conjunto SIGUIENTE(A)SIGUIENTE(A)={x|(S→*α·A·β), (A∈ΣN), (α∈Σ*), (β∈Σ+),
(x∈PRIMERO(β)-{λ})}Conjunto de terminales que pueden aparecer inmediatamente a la derecha de A en alguna forma sentencial, si A es el último símbolo entonces se incluye el separador $
Algoritmo1. SIGUIENTE(S)={$}2. La regla A→αBβ ⇒
SIGUIENTE(B) = (PRIMERO(β)-{λ}) ∪SIGUIENTE(B)
3. La regla A→αBβ | β=λ, β→*λ (λ ∈PRIMERO(β)) ⇒SIGUIENTE(B) = SIGUIENTE(A) ∪ SIGUIENTE(B)
4. Repetir hasta que no cambie ningún conjunto SIGUIENTE
Análisis Sintáctico. Procesadores de Lenguaje I
Análisis Sintáctico Predictivo, DEFINICIONES: SIGUIENTE
SIGUIENTE(A), Ejemplo:E ::= T.E’E’ ::= +.T.E’ | λT ::= F.T’T’ ::= *.F.T’ | λF ::= (.E.) | Id
ΣN SIGUIENTEE $, )E’ $, )F $, *, ), +T $, +, )T’ $, +, )
9
Análisis Sintáctico. Procesadores de Lenguaje I
Análisis Sintáctico Predictivo:Condiciones
Pregunta: ¿Que debe cumplir una gramática para que pueda ser reconocida sin retroceso, con solo mirar el siguiente elemento de la entrada, de forma descendente?
Respuesta:Si A::= α | β ⇒
PRIMERO(α) ∩ PRIMERO(β) = ∅. para ningún terminal atanto α y β derivan a la vez cadenas que comiencen con aNo puede ocurrir que α →*λ y β →*λSi β →*λ, entonces α no deriva ninguna cadena que comience con un terminal en SIGUIENTE(A)
Condición LL(1)
Análisis Sintáctico. Procesadores de Lenguaje I
Análisis Sintáctico Predictivo:Condiciones
Condición LL(1)No puede haber conflictos PRIMERO/PRIMERO
∀N∈ΣN, el conjunto PRIMERO de todas sus alternativas debe ser disjunto
No puede haber múltiples alternativas nulas∀N∈ΣN, solo pueden tener una producción N→*λ
No puede haber conflictos PRIMERO/SIGUIENTE∀N∈ΣN, con una alternativa nula, SIGUIENTE(N) debe ser disjunto de los conjuntos PRIMERO de todas sus alternativas
No puede haber entradas con definiciones múltiples en la tabla de análisis
10
Análisis Sintáctico. Procesadores de Lenguaje I
Análisis Sintáctico Predictivo:Tabla de Análisis Sintáctico
FuncionamientoSea A→α con a∈ΣT | a∈PRIMERO(α). El analizador sintáctico expandirá A por α cuando el símbolo actual de la entrada sea a
AlgoritmoForAll (A::= α) ∈ Ρ do
ForAll a ∈ PRIMERO(α) dotabla(A,a)= α
Si λ ∈ PRIMERO(α)Entonces ForAll b ∈ SIGUIENTE(A) do
tabla(A,b)= αForAll A∈ΣN y c∈ΣT do
If tabla(A,c)= ∅Then tabla(A,c)= error
Análisis Sintáctico. Procesadores de Lenguaje I
Análisis Sintáctico Predictivo:Tabla de Análisis Sintáctico
EjemploE ::= T.E’E’ ::= +.T.E’ | λT ::= F.T’T’ ::= *.F.T’ | λF ::= (.E.) | Id
Id + * ( ) $E T.E’ T.E’E’ +.T.E’ λ λT F.T’ F.T’T’ λ *.F.T’ λ λF Id (.E.)
11
Análisis Sintáctico. Procesadores de Lenguaje I
Análisis Sintáctico PredictivoNo Recursivo; LL(1)
Modelo de analizador sintáctico predictivo no recursivo
Tabla de AnálisisSintáctico M
a + b $ENTRADA
X
YZ
$
Programa deAnálisis Sintáctico
PredictivoSALIDA
PILA
Análisis Sintáctico. Procesadores de Lenguaje I
Análisis Sintáctico PredictivoNo Recursivo; LL(1)
Los símbolos de la entrada actual “a” y cima de la pila “X” determinan la acción del analizadorHay tres posibilidades:
X=a=$, el analizador se detiene y anuncia el éxito del análisisX=a≠$, el analizador saca X de la pila y mueve el apuntador de la entrada al siguiente símbolo de entradaX∈ΣN, el programa consulta la entrada M[X,a]
Si M[X,a]=UVW, se sustituye la X de la pila por WVU (U queda como cima de la pila)Si M[X,a]= error, se llama a la rutina de recuperación de error
12
Análisis Sintáctico. Procesadores de Lenguaje I
Análisis Sintáctico LL(1)Algoritmo:pila =$;meter$ al final de la entrada;a:= GetToken;Push S;Repeat
If X ∈ΣT or X=$ thenIf X=a then
Pop;a:= GetToken;
Elseerror;
ElseIf M[X,a]=X→Y1Y2..Yk then
Pop;Push Yk,Yk-1,...,Y1Emitir la producción X
elseerror();
until X=$
If X=$ and a=$ thenAceptar;
elseerror();
Análisis Sintáctico. Procesadores de Lenguaje I
Análisis Sintáctico LL(1)Ejemplo:
Pila Entrada Producción$ ⋅ E Id ⋅ * ⋅ Id ⋅ + ⋅ Id ⋅ $ E::= T ⋅ E’$ ⋅ E’ ⋅ T Id ⋅ * ⋅ Id ⋅ + ⋅ Id ⋅ $ T::= F ⋅ T’$ ⋅ E’ ⋅ T’ ⋅ F Id ⋅ * ⋅ Id ⋅ + ⋅ Id ⋅ $ F::= Id$ ⋅ E’ ⋅ T’ ⋅ Id Id ⋅ * ⋅ Id ⋅ + ⋅ Id ⋅ $$ ⋅ E’ ⋅ T’ * ⋅ Id ⋅ + ⋅ Id ⋅ $ T’::= * ⋅ F ⋅ T’$ ⋅ E’ ⋅ T’ ⋅ F ⋅ * * ⋅ Id ⋅ + ⋅ Id ⋅ $$ ⋅ E’ ⋅ T’ ⋅ F Id ⋅ + ⋅ Id ⋅ $ F::= Id$ ⋅ E’ ⋅ T’ ⋅ Id Id ⋅ + ⋅ Id ⋅ $$ ⋅ E’ ⋅ T’ + ⋅ Id ⋅ $ T’::= λ$ ⋅ E’ + ⋅ Id ⋅ $ E’::= + ⋅ T ⋅ E’$ ⋅ E’ ⋅ T ⋅ + + ⋅ Id ⋅ $$ ⋅ E’ ⋅ T Id ⋅ $ T::= F ⋅ T’$ ⋅ E’ ⋅ T’ ⋅ F Id ⋅ $ F::= Id$ ⋅ E’ ⋅ T’ ⋅ Id Id ⋅ $$ ⋅ E’ ⋅ T’ $ T’::= λ$ ⋅ E’ $ E’::= λ$ $
13
Análisis Sintáctico. Procesadores de Lenguaje I
Análisis Sintáctico AscendenteAnálisis por desplazamiento y reducción
Por precedencia de operadoresLR
Construir un árbol de análisis sintáctico para una cadena de entrada que comienza por las hojas y avanza hacia la raíz. Reducir una cadena de entrada w al símbolo inicial de la gramática (axioma)En cada paso de reducción se sustituye una subcadena que concuerde con el lado derecho de una producción por el símbolo del lado izquierdo, se traza una derivación por la derecha en sentido inverso
Análisis Sintáctico. Procesadores de Lenguaje I
Análisis Sintáctico Ascendente:Gramática de Operadores
Para una pequeña clase de gramáticas se puede construir con facilidad, a mano, eficientes analizadores sintácticos por desplazamiento y reducciónGramática de operadores
No tiene reglas de producción del tipo A::=λNo tiene dos no terminales adyacentes A::=α·B·C·β | A,B,C ∈ΣN
Ejemplo
No es G. de operadores Si es G. de operadores
E→EAE | (E) | -E | id E→E+E | E-E | E*E | E/E | (E) | -E | idA→+ | - | * | /
14
Análisis Sintáctico. Procesadores de Lenguaje I
Precedencia de Operador:Relaciones de Precedencia
Se definen tres relaciones de precedencia disjuntas
a<•b si a tiene menos precedencia que ba=b si a tiene igual precedencia que ba•>b si a tiene más precedencia que b
AlgoritmoSustituir todos los símbolos no terminales por un único símboloInsertar $ al principio y al final de la cadena de entradaInsertar las relaciones de precedencia en la cadena de entradaMientras entrada≠$S$ hacer
Recorrer entrada desde la izquierda hasta encontrar •>Buscar a la izquierda, a partir de ese punto, el primer <•Reducir el pivote que se encuentra en el medioReinsertar las relaciones de precedencia, ignorando los no terminales
Análisis Sintáctico. Procesadores de Lenguaje I
Entrada: $·(·Id·+·Id·)·$
Gramática: E::= E·+·E | E·*·E | (·E·) | Id
Tabla de precedencia:( Id * + ) $
) •> •> •> •>Id •> •> •> •>* <• <• •> •> •> •>+ <• <• <• •> •> •>( <• <• <• <• =$ <• <• <• <• =
Análisis Entrada Derivación$ <• ( <• Id •> + <• Id •> ) •>$ $·(·E·+·Id·)·$$ <• ( <• E + <• Id •> ) •> $ $·(·E·+·E·)·$$ <• ( <• E + E •> ) •> $ $·(·E·)·$$ <• ( E = ) •> $ $·E·$
Precedencia de Operador: Ejemplo
15
Análisis Sintáctico. Procesadores de Lenguaje I
Precedencia de Operador: Evaluador de Expresiones
El análisis recorre la entrada de izquierda a derecha y se encuentra en dos posibles estados:
Esperando un operando (variables o constantes)Esperando un operador (resto de terminales)
El análisis mantiene dos pilasPila de OperadoresPila de Operandos
Cuando un operador en la cima de su pila es de más precedencia que el siguiente leído, entonces arranca la reducción del pivote, hasta encontrar la relación de precedencia mayor. Cada operador extraído se aplica a los operandos más arriba de la pila de operandos
Análisis Sintáctico. Procesadores de Lenguaje I
Evaluación de ExpresionesAlgoritmo de evaluación de expresiones:pilaOperadores = $;poner $ al final de la entrada;a:= GetToken;repeat
if a=$ y cimaOperadores=$ then returnif a es Operando then PushOperando (a); a:=GetToken;else
if (cimaOperandos <. a) o (cimaOperandos =. a) thenPushOperador (a); a: =GetToken;
elserepeat
opAnterior= PopOperadoraplicar opAnterior a pilaOperandos
until (cimaOperadores <. opAnterior)else Error
until true
16
Análisis Sintáctico. Procesadores de Lenguaje I
Análisis Sintáctico Ascendente:Precedencia de Operador
Entrada:Id·+·Id·*·Id
GramáticaE:=E·+·E | E·*·E | (·E·) | Id
La gramática es ambigua pero este tipo de análisis proporciona una única derivaciónEntrada Pila Operadores Pila OperandosIda·+·Idb·*·Idc$ $ ∅+·Idb·*·Idc$ $ Ida
Idb·*·Idc$ $ + Ida
*·Idc$ $ + Ida, Idb
Idc$ $ + * Ida, Idb
$ $ + * Ida, Idb, Idc
$ $ + Ida , Idb*Idc
$ $ Ida+Idb* Idd
Análisis Sintáctico. Procesadores de Lenguaje I
Análisis Sintáctico Ascendente:Precedencia de Operador
Entrada Pila Operadores Pila OperandosIda.*.(Idb·+·Idc.*. Idd)$ $ ∅.*.(Idb·+·Idc .*.Idd)$ $ Ida
(Idb·+·Idc .*.Idd)$ $ * Ida
Idb·+·Idc .*.Idd)$ $ * ( Ida
·+·Idc .*.Idd)$ $ * ( Ida, Idb
Idc .*.Idd)$ $ * ( + Ida, Idb
.*.Idd)$ $ * ( + Ida, Idb , Idc
Idd)$ $ * ( + * Ida, Idb , Idc
)$ $ * ( + * Ida, Idb , Idc, Idd
)$ $ * ( + Ida, Idb , Idc*Idd
)$ $ * ( Ida, Idb+Idc*Idd
$ $ * ( ) Ida, Idb+Idc*Idd
$ $ Ida*(Idb+Idc*Idd)
Entrada: Id*(Id+Id*Id)
17
Análisis Sintáctico. Procesadores de Lenguaje I
Análisis Sintáctico Ascendente:Precedencia de Operador
Entrada Pila Operadores Pila Operandos
Ida.*.(Idb·+·Idc).+. Idd$ $ Ida
.*.(Idb·+·Idc).+. Idd$ $ Ida
(Idb·+·Idc).+. Idd$ $ * Ida
Idb·+·Idc).+. Idd$ $ * ( Ida
.+·Idc).+. Idd$ $ * ( IdaIdb
Idc).+. Idd$ $ * ( + IdaIdb
).+. Idd$ $ * ( + IdaIdbIdc
).+. Idd$ $ * ( IdaIdb+Idc
.+. Idd$ $ * ( ) IdaIdb+Idc
.+. Idd$ $ * IdaIdb+Idc
.+. Idd$ $ Ida*(idb+Idc)Idd$ $ + Ida*(idb+Idc)$ $ + Ida*(idb+Idc) Idd
$ $ Ida*(idb+Idc)+Idd
Entrada: Id*(Id+Id)+Id
Análisis Sintáctico. Procesadores de Lenguaje I
Precedencia de Operador: Construir la Tabla de Precedencia
Si el operador θ1 tiene mayor precedencia que θ2
entonces hacer θ1 •>θ2 y θ2 <• θ1
Si los operadores θ1 y θ2 son de igual precedencia (por ejemplo el mismo operador), entonces hacer:
θ1 •>θ2 y θ2 •> θ1 si son asociativos por la izquierda
θ1 <•θ2 y θ2 <• θ1 si son asociativos por la derecha
Resto:θ<•(, (<•θ, )•>θ, θ•>)
(=), (<• (, )•>)
(<•Id, θ<•Id, Id•>), Id•>θ
$<• θ, $<• (, $<•Id, θ•>$, Id•>$, )•>$
18
Análisis Sintáctico. Procesadores de Lenguaje I
Precedencia de Operador: Operadores Unarios (¬)
Manejo de Operadores Unarios (¬)Operador Unario que no es además Binario
θ <• ¬ ∀ θ¬ •> θ ∀ θ si ¬ tiene mayor precedencia que θ¬ <• θ ∀ θ si ¬ tiene menor precedencia que θ
Operador Unario que además es BinarioMediante la tabla de precedencia no puede analizarse correctamente cadenas como: Id*-IdSolución: Utilizar el analizador léxico para devolver dos componentes léxicos distintos, recordando el componente léxico anterior debe distinguir uno de otro.Ejemplo: Es el menos unario si antes el componente léxico leído era un operador, un paréntesis izquierdo, una coma o un símbolo de asignación
Análisis Sintáctico. Procesadores de Lenguaje I
Obtención de las relaciones de precedencia (cálculo)
x ± y sii existe:A →...xBy... B∈{N ∪ λ}
x <• y sii existe:A →...xB... B →+ Cy... C∈{N ∪ λ}
x •> y sii existe:A →...By... B →+...xC C∈{N ∪ λ}
19
Análisis Sintáctico. Procesadores de Lenguaje I
Precedencia de Operador: Calcular la Tabla de Precedencia
Definiciones:Cabecera(A) = { x | (A→* α·x·β)
∧ (x ∈ ΣT) ∧ (A ∈ ΣN) ∧ (α ∈ ΣN*) ∧ (β ∈ Σ*)}
Último(A) = { x | (A→* α·x·β) ∧ (x ∈ ΣT) ∧ (A ∈ ΣN) ∧ (α ∈ Σ*) ∧ (β ∈ ΣN
*)}
Ejemplo:E::=E·+·T | T Cabecera(E)={+, *, (, Id}T::=T·*·F | F Último(E)={+, *, ), Id}F::=(·E·) | Id
Propiedad:∀(A::= α·B·a·C·β) ∈ P, a ∈ ΣT, A, B, C ∈ ΣN, α, β ∈ Σ*, a siempre aparece en un nivel superior a los símbolos terminales de Cabecera(C) y Último(B) en el árbol de derivación
Análisis Sintáctico. Procesadores de Lenguaje I
Precedencia de Operador: Calcular la Tabla de Precedencia
Reglas: (A::= α·B·a·C·β) ∈ P, a ∈ ΣT, A, B, C ∈ ΣN, α, β ∈ Σ*
1. ∀c ∈ Cabecera(C), a <• c2. ∀b ∈ Último(B), b •> a3. ∀ (A::= α·a·β·b·γ) ∈ P, a, b ∈ ΣT, a=b , β ∈ Σ*
Si existe más de una relación de precedencia entre dos símbolos terminales, no es una gramática de precedenciaAlgoritmo
ForAll (A::= α·B·a·C·β) ∈ P doCalcular Cabecera(C)Calcular Último(B)Calcular las precedencias usando las reglas 1, 2 y 3
ForAll a ∈ Cabecera(S) do $ <• aForAll a ∈ Último(S) do a •> $
20
Análisis Sintáctico. Procesadores de Lenguaje I
Ejemplo Calculo de Tabla de Precedencia
GramáticaE::=E·+·T | TT::=T·*·F | FF::=(·E·) | Id
Cabecera y ÚltimoΣN Cabecera ÚltimoE +, *, (, Id +, *, ), IdT *, (, Id *, ), IdF (, Id ), Id
TablaRegla Precedencias(R2) Precedencias (R1)E::=E+T +, *, ), Id •> + + <• *, (, IdT::=T*F *, ), Id •> * * <• (, Id
Análisis Sintáctico. Procesadores de Lenguaje I
Precedencia de Operador: Funciones de Precedencia
La tabla de precedencia se puede simplificar, con el objetivo de ahorrar memoria y aumentar la velocidad de proceso, mediante dos funciones f y gTransforman los símbolos terminales en enterosTienen que cumplir que ∀a,b ∈ΣT
si a <• b, f(a) < g(b)si a = b, f(a) = g(b)si a •> b, f(a) > g(b)
Para encontrar la relación de precedencia entre a y b se realiza una comparación entre f(a) y g(b)No todas las relaciones de precedencia tienen funciones de precedencia
21
Análisis Sintáctico. Procesadores de Lenguaje I
Precedencia de Operador: Funciones de Precedencia
Construcción de las Funciones de Precedencia1. Crear los símbolos fa y ga ∀ a∈ΣT ∪ {$}2. Se dividen los fa y ga en tantos grupos como sea posible:
Si a=b entonces fa y gb están en el mismo grupo
3. Crear un grafo dirigido cuyos nodos son los grupos encontrados en el paso 2, los arcos se etiquetan:
si a<•b, gb → fasi a•>b, fa → gb
4. Ciclos en el grafo:Respuesta SI, entonces no existen funciones de precedenciaRespuesta NO, entonces f(a) y g(a) son los caminos más largos que comienzan en fa y ga
Análisis Sintáctico. Procesadores de Lenguaje I
Precedencia de Operador: Funciones de Precedencia
EjemploId + * $
Id •> •> •>+ <• •> <• •>* <• •> •> •>$ <• <• <•
Cada símbolo está solo en un grupogId
fId
g*
f*
g+
f+
g$
f$
22
Análisis Sintáctico. Procesadores de Lenguaje I
Precedencia de Operador: Funciones de Precedencia
No hay ciclos, entonces existen las funciones de precedencia.Como las funciones de $ no tienen arcos entonces f($)=g($)=0El camino más largo desde g+ tiene longitud 1, entonces g(+)=1El camino más largo desde gId a f* a g* a f+ a f$por tanto g(id)=5
Id + * $f 4 2 4 0g 5 1 3 0
Análisis Sintáctico. Procesadores de Lenguaje I
Análisis Sintáctico Ascendente:Precedencia de Operador
InconvenientesEs difícil de manejar componentes léxicos con dos precedencias distintas, como el signo menos (unario y binario)No se puede tener la seguridad de que el analizador acepta exactamente el lenguaje deseadoSólo una pequeña clase de gramáticas puede analizarse
VentajasSencillezSe pueden establecer relaciones de precedencia (* precede a +)
Se aplican con otros analizadores para la parte que no son de operador
23
Análisis Sintáctico. Procesadores de Lenguaje I
Análisis Ascendente LRLR(k): Left-to-right, rightmost derivation, k símbolos de entrada son necesarios para tomar las decisiones de análisis sintáctico
VentajasEs el método de análisis por desplazamiento y reducción sin retroceso más general, a pesar de esto es igual de eficienteLa clase de gramáticas que pueden analizarse es un supraconjunto de la clase de gramáticas que pueden analizarse con analizadores sintácticos predictivosDetectan los errores sintácticos tan pronto como es posible en un examen de izquierda a derecha de la entradaSe pueden reconocer prácticamente todas las construcciones de los lenguajes de programación descritos por una gramática G2
InconvenientesLa construcción “a mano” requiere mucho trabajo
Análisis Sintáctico. Procesadores de Lenguaje I
Tipos de Análizadores LRLR simple (SLR)
Fácil de implementarMenos poderoso, hay algunas gramáticas que los otros métodos pueden analizar y este no puede
LR canónicoEs muy costoso de implementarEl más potente
LALR (LR con símbolo de preanálisis)Intermedio entre los dos métodos anteriores
24
Análisis Sintáctico. Procesadores de Lenguaje I
Modelo de un Analizador LR
ENTRADA
sm
Programa deAnálisis Sintáctico
LRSALIDA
Acción Ir_a
a1 a1 an... $...
Tabla de AnálisisSintáctico LR
Pila
Xm
sm-1
Xm-1
...
s0
Análisis Sintáctico. Procesadores de Lenguaje I
Modelo de Analizador LREl programa es el mismo para todos los analizadores LRXi es un símbolo gramatical y cada si es un símbolo llamado estadoSe utiliza el símbolo de estado y el símbolo de la entrada para indexar la tabla y determinar la acción siguienteLa tabla de análisis sintácticos tiene dos partes:
Acción[sm, ai]=Error: error de sintaxisAceptar: acepta la entrada, el análisis sintáctico finalizaDesplazar: introduce en la pila el símbolo ai y el estado smReducción: extrae símbolos de la pila, ejecuta la acción
semántica correspondiente a una producciónIr_a[sm, Xi]= sk
25
Análisis Sintáctico. Procesadores de Lenguaje I
Modelo de Analizador LRConfiguración de un analizador sintáctico LR
Tupla con el contenido de la pila y la entrada que resta por procesar(s0 X1 s1 X2 s2 ... Xm sm, ai ai+1 ... an$)
Acción[sm, ai] = desplazar s(s0 X1 s1 X2 s2 ... Xm sm ai s, ai+1 ... an$)
Acción[sm, ai] = reducir A → β(s0 X1 s1 X2 s2 ... Xm-r sm-r A s, ai ai+1 ... an$)
donde s=Ir_a[sm-r, A] y r=|β| (se extraen rsímbolos no terminales y r símbolos de estados de la pila)
Análisis Sintáctico. Procesadores de Lenguaje I
Algoritmo de Análisis LRapuntar ae al primer símbolo de w$ (s está en la cima y ae apunta al símbolo a)repetir
case Acción[s, a] Desplazar s’
push apush s’leer en la entrada
Reducir A → βpop 2*|β| símboloss’ símbolo en la cima de la pilas= Ir_a[s’, A]push Apush s
AceptarError
fincasohasta Aceptar o Error
26
Análisis Sintáctico. Procesadores de Lenguaje I
Ejemplo de Análisis LRGramática
1. E::= E·+·T2. E::= T3. T::= T·*·F4. T::= F5. F::= (·E·)6. F::= Id
Tabla de análisis sintácticoAcción Ir_a
Estado Id + * ( ) $ E T F0 d5 d4 1 2 31 d6 ACP2 r2 d7 r2 r2 3 r4 r4 r4 r44 d5 d4 8 2 35 r6 r6 r6 r66 d5 d4 9 37 d5 d4 108 d6 d119 r1 d7 r1 r1
10 r3 r3 r3 r311 r5 r5 r5 r5
Análisis Sintáctico. Procesadores de Lenguaje I
Ejemplo de Análisis LRPila Entrada Acción
0 Id·*·Id·+·Id·$ d50 Id 5 *·Id·+·Id·$ r60 F 3 *·Id·+·Id·$ r40 T 2 *·Id·+·Id·$ d70 T 2 * 7 Id·+·Id·$ d50 T 2 * 7 Id 5 +·Id·$ r60 T 2 * 7 F 10 +·Id·$ r30 T 2 +·Id·$ r20 E 1 +·Id·$ d60 E 1 + 6 Id·$ d50 E 1 + 6 Id 5 $ r60 E 1 + 6 F 3 $ r40 E 1 + 6 T 9 $ r10 E 1 $ ACP
27
Análisis Sintáctico. Procesadores de Lenguaje I
Construcción de Tabla de Análisis SLR
Definiciones:Elemento del análisis sintáctico LR(0) de una gramática G (elemento, ítem)
Producción de G con un “punto” en alguna posición del lado derechoEl punto indica hasta donde se ha visto la producción en un momento del análisis
Ejemplo: La producción A→XYZ tiene cuatro elementos:A→•XYZA→X•YZA→XY•ZA→XYZ•Pregunta:
¿Qué elemento genera laproducción A→λ?
Análisis Sintáctico. Procesadores de Lenguaje I
Construcción de Tabla de Análisis SLR
Definiciones:Prefijo viableItem válido para prefijo viable:
A→β1•β2 es item válido de αβ1 sii:S →* αAw→*αβ1β2w (A∈ΣN,, α,β1,β2∈Σ*, w∈Σ*
T)rm rm
EstadoConjunto de ítemsDan lugar a los estados del analizador sintáctico SLREl conjunto de estados: colección canónica LR(0)
Los ítems son los estados de un AF que reconoce los prefijos viablesLos estados son las agrupaciones de estados, (¡La minimización del AF!)
28
Análisis Sintáctico. Procesadores de Lenguaje I
Algoritmo: crear conjunto canónico LR(0)
Entrada:Gramática ampliada G’Función cierre(I) (clausura o cerradura), I≡ítem+
Función goto(I, X) (ir_a), X∈(ΣT ∪ ΣN)
SalidaConjunto canónico LR(0)
Gramática ampliada G’ de GAñadir S’, ΣN= (ΣN ∪ S’ ’) | S’ es el axiomaAñadir S’→ S, P= (P ∪ S’→ S)
Análisis Sintáctico. Procesadores de Lenguaje I
Construir el conjunto canónico LR(0)
Función cierre(I)function cierre(I);begin
J:=I;repeat
for ∀ Ji (A → α•Bβ) ∈ J , ∀ p (B → γ) ∈ P | (B → • γ) ∉ Jdo J := J ∪ (B → • γ) ;
until no pueden añadirse ítems a J ;return J
end
A→ • BB → • id | • C num | •( D )C → • + D
¿ cierre(A→ • B) ?A→ BB → id | C num | ( D )C → + DD → id | num
• Ejemplo:
29
Análisis Sintáctico. Procesadores de Lenguaje I
Construir el conjunto canónico LR(0)
Función goto(I, X)Si I son items válidos de γ, goto(I, X) son los items válidos de γX
function goto(I, X);begin
J:=∅;∀ Ii | (B → α•X β) ∈ I, J := J ∪ cierre(B → α X • β) ;return J
end
B → (•D ) D → • idD → • num
I = {B→ • id, B→ • ( D )} ¿ goto {I, ( }?
A→ BB → id | C num | ( D )C → + DD → id | num
• Ejemplo:
Análisis Sintáctico. Procesadores de Lenguaje I
Algoritmo: crear conjunto canónico LR(0)
La función elementos proporciona la colección canónica de conjuntos de elementos de LR(0)function elementos(G’);begin
C:=cierre(S’ → • S);repeat
for ∀ I ∈ C , ∀ X | goto(I, X) ≠ ∅, goto(I, X) ∉ Cdo C := C ∪ goto(I, X);
until no pueden añadirse más conjuntos de ítems a C;
return Cend
30
Análisis Sintáctico. Procesadores de Lenguaje I
Construir el conjunto canónico LR(0)Ejemplo:
• G1. S → A B end2. A → tipo3. A → id A4. B → begin C5. C → código
• G’1. S’ → S2. S → A B end3. A → tipo4. A → id A5. B → begin C6. C → código
I4: A → id•A
A → •tipoA → •id A
I5: S → A B•end
I6: B → begin•C
C → •código
I7: A → id A•
I8: S → A B end•
I9: B → begin C•
I10: C → código•
items LR(0):I0: S’ → •S
S → •A B endA → •tipoA → •id A
I1: S’ → S•
I2: S → A•B end
B → •begin C
I3: A → tipo•
Análisis Sintáctico. Procesadores de Lenguaje I
Construir el conjunto canónico LR(0)
El conjunto canónico define un AFD que reconoce los prefijos viables de G, con I0 estado inicial e Ij ∀j ≠ 0 estados finales
Para cada prefijo alcanzado, Ii define sus prefijos viables!
I0 I1
I2
I3
I4
I5
I6
I7
I8
I9
I10
S
A
tipo
id
B
begin
Atipo
id
end
C
código
31
Análisis Sintáctico. Procesadores de Lenguaje I
Construir la tabla SLR (por fin)Entrada:
Gramática aumentada G’
SalidaTabla SLR, funciones de acción e ir_a
Algoritmo1. Construir C={I0, I1, ..., In} LR(0) de G’2. El estado i se construye a partir de Ii, poner las
operaciones adecuadas del analizador sintáctico3. Las entradas no definidas son ERROR4. El estado inicial es el del conjunto con [S’→•S]
Análisis Sintáctico. Procesadores de Lenguaje I
Construir la tabla SLROperaciones asociadas a los ítems
DesplazarSi [A→α•aβ] ∈ Ii , a ∈ ΣT, goto(Ii, a) = Ij ⇒ acción[i, a] = desplazar j
ReducirSi [A→α•] ∈ Ii , A ≠ S’ ⇒ ∀ a ∈ SIGUIENTE(A), acción[i, a] = reducir A→α
AceptarSi [S’→S•] ∈ Ii ⇒ acción[i,$] = aceptar
Ir_aSi goto(Ii, A) = Ij, A ∈ ΣN ⇒ ir_a[i, A] = j
32
Análisis Sintáctico. Procesadores de Lenguaje I
Construir la tabla SLRccLR(0)
I0:S’ → •S ir_a[0,S]=1S → •A B end ir_a[0,A]=2A → •tipo acción[0,tipo]=d3A → •id A acción[0,id]=d4
I1:S’ → S• acción[1,$]=aceptar
I2:S → A•B end ir_a[2,B]=5B → •begin C acción[2,begin]=d6
I3:A → tipo• acción[3,begin]=r(A → tipo)
I4:A → id•A ir_a[4,A]=7A → •tipo acción[4,tipo]=d3A → •id A acción[4,id]=d4
I5:S → A B•end acción[5,end]=d8
I6:B → begin•C ir_a[6,C]=9C → •código acción[6,código]=d10
I7:A → id A• acción[7,begin]=r(A → id)
I8:S → A B end• acción[8,$]=r(S → A B end)
I9:B → begin C• acción[9,end]=r(B → begin C)
I10:C → código• acción[10,end]=r(C → código)
ΣN SiguienteS $A beginB endC end
Análisis Sintáctico. Procesadores de Lenguaje I
Tabla SLR Resultanteacción ir_a
tipo id begin código $ end S A B C
0 d3 d4 1 2 1 ACP2 d6 53 r(A → tipo)4 d3 d4 75 d86 d10 9 7 r(A → id)8 r(S →AB end)9 r(B →begin C)
10 r(C →código)
33
Análisis Sintáctico. Procesadores de Lenguaje I
ResumenEl análisis sintáctico LR
El análisis ascendente sin retroceso más generalUtiliza una pila y una tabla de análisisDesplazamiento/ReducciónLa tabla SLR se obtiene haciendo el conjunto canónico LR(0)
Análisis Sintáctico. Procesadores de Lenguaje I
Analizador canónico LRMotivación
Tabla SLR tiene info insuficiente y pueden aparecer conflictos desplazamiento/reducciónSi el estado Ii contiene [A->β•] No es adecuada siempre la reducción A->a para todos los terminales en Siguiente(A)
Dado prefijo viable αβ con items válidos en Ii puede ser que no existan formas sentenciales αAa, con a∈Siguiente(A)
Ejemplo:S → L=RS → RL → *RL → idR → L
34
Análisis Sintáctico. Procesadores de Lenguaje I
Conjunto LR(0)Ejemplo:
• G1. S → L=R2. S → R3. L → *R4. L → id5. R → L
• G’1. S → L=R2. S → R3. L → *R4. L → id5. R → L6. S’ → S
I4: L → * • R
R → •LL → •*RL → •id
I5: L → id •
I6: S → L = •R
R → •LL → •*RL → •id
I7: L → * R •
I8: R → L•
I9: S → L = R•
items LR(0):I0: S’→ •S
S → • L=R S → •RR → •LL → •*RL → •id
I1: S’ → S•
I2: S → L • =R
R → L •
I3: S → R•
Análisis Sintáctico. Procesadores de Lenguaje I
Tabla de análisis LR(0)
I0 I1
I2
I3
I4
I6
I7
I8
I9
S
L
R
*
=
L
R
id
R
I5
id
*
35
Análisis Sintáctico. Procesadores de Lenguaje I
Conflicto en la tabla SLR!ccLR(0) acción
....I2: S → L • =R acción[2,=]=d6
R → L • acción[2,=]=r5...
ΣN Siguiente
S $L $, =R $, =
$ está en Siguiente(R) pero no hay ninguna derivación donde reducir L por R seguido de $Esta información de contexto no se usa en el analizador SLR
Análisis Sintáctico. Procesadores de Lenguaje I
Items en LR(1)Ítems: estados de AF que reconoce los prefijos viables junto a símbolos posibles tras pivote
Elementos con más información:[A→β1•β2, a] con A→β1•β2∈P, a∈ΣT
Definición:[A→β1•β2, a] es item válido de γ=αβ1 sii:- S →* αAw→αβ1β2w
rm rm
- a es el primer símbolo de w (o si w es λ, a es $)
Estado: Conjunto de estados: colección canónica LR(1)Se aumentan los estados LR(0)
36
Análisis Sintáctico. Procesadores de Lenguaje I
Items en LR(1)Construcción: varía la función cierre(I)
[A→α•Bβ, a]∈I[A→α•Bβ, a] es item válido de γ=δα:S →* δAax→δαΒβax=γΒβax
rm
Para cada item B→η:S →* γηby, ∀b|b∈Primero(βa)
rm
[B→ • η, b] ∈ cierre(I)
Análisis Sintáctico. Procesadores de Lenguaje I
Construir el conjunto canónico LR(1)
Función cierre(I)function cierre(I);begin
J:=I;repeat
for ∀ Ji [A → α•Bβ,a] ∈ J , ∀ p (B → γ) ∈ P , ∀ b∈Primero(βa) | [B → • γ, b] ∉ J
do J := J ∪ [B → • γ, b] ;until no pueden añadirse ítems a J ;return J
end
[S’→ •S,$][S→ •CC,$][C→ •cC,c/d][C→ •d,c/d]
¿ cierre([S’→ •S,$])?S’→ SS → CCC → cC | d
Ejemplo: Primero
$ $C$ c, d
37
Análisis Sintáctico. Procesadores de Lenguaje I
Construir el conjunto canónico LR(1)
Función goto(I, X)Si I son items válidos de γ, goto(I, X) son los itemsválidos de γX
function goto(I, X);begin
J:=∅;∀ Ii | [B → α•X β, a] ∈ I, J := J ∪ cierre([B → α X • β, a]) ;return J
end
[C→ c•C,c/d][C→ •cC,c/d][C→ •d,c/d]
¿ goto([C→ •cC,c/d],c)?S’→ SS → CCC → cC | d
Ejemplo: Primero
(λ) c c(λ) d d
Análisis Sintáctico. Procesadores de Lenguaje I
Algoritmo: crear conjunto canónico LR(1)
La función elementos proporciona la colección canónica de conjuntos de elementos de LR(1)function elementos(G’);begin
C:=cierre([S’ → • S, $]);repeat
for ∀ I ∈ C , ∀ X | goto(I, X) ≠ ∅, goto(I, X) ∉ Cdo C := C ∪ goto(I, X);
until no pueden añadirse más conjuntos de ítems a C;
return Cend
38
Análisis Sintáctico. Procesadores de Lenguaje I
Conj. LR(1)• G’1. S → L=R2. S → R3. L → *R4. L → id5. R → L6. S’ → S
I7: [L → *R•,=|$]
I8: [R → L•,=|$]
I9: [S → L = R•,$]
I10: [R → L•,$]
I11: [L → id•,$]
I12: [L → * • R,$]
[R → •L,$][L → •*R, $][L → •id, $]
I13: [L → *R•,$]
I1: [S’ → S•,$]
I2: [S → L• =R,$]
[R → L•,$]
I3: [S → R•,$]
I4: [L → * • R,=|$]
[R → •L,=|$][L → •*R,=|$][L → •id, =|$]
I5: [L → id•,=|$]
I6: [S →L=•R,$]
[R →•L,$][L →•*R,$][L →•id, $]
items LR(1):I0: [S’→•S,$]
[S →•L=R,$] [S →•R,$][L → •*R,=|$][L → •id,=|$][R →•L,$]
Análisis Sintáctico. Procesadores de Lenguaje I
Estados de analizador canónico LR(1)
I0 I1
I2
I3
I4
I6
I7
I8
I9S
L
R
*
=
L
R
id
R
I5
id
*
I11
I12
I10
I13
L
id
*R
L
39
Análisis Sintáctico. Procesadores de Lenguaje I
Construir la tabla canónica LREntrada:
Gramática aumentada G’
SalidaTabla LR, funciones de acción e ir_a
Algoritmo1. Construir C={I0, I1, ..., In} LR(1) de G’2. El estado i se construye a partir de Ii, poner las
operaciones adecuadas del analizador sintáctico3. Las entradas no definidas son ERROR4. El estado inicial es el del conjunto con [S’→•S, $]
Análisis Sintáctico. Procesadores de Lenguaje I
Construir la tabla canónica LRaccLR(1)
I0: [S’→•S,$] ir_a(0,S)=1[S →•L=R,$] ir_a(0,L)=2[S →•R,$] ir_a(0,R)=3[L → •*R,=] acc(0,*) =d4[L → •id,=] acc(0,id)=d5[R →•L,$]
I1: [S’ → S•,$] acc(1,$)=ACPI2: [S → L• =R,$] acc(2,=)=d6
[R → L•,$] acc(2,$)=r(R→L)I3: [S → R•,$] acc(3,$)=r(S→R)I4: [L → * • R,=] ir_a(4, R)=7
[R → •L,=] ir_a(4, L)=8[L → •*R,=] acc(4,*)=d4[L → •id, =] acc(4,id)=d5
I5: [L → id•,=] acc(5,=)=r(L→id)
I6: [S →L=•R,$] ir_a(6,R)=9[R →•L,$] ir_a(6,L)=10[L →•*R,$] acc(6,*)= d12[L →•id, $] acc(6,id)=d11
I7: [L →*R•,=] acc(7,=)=r(L →*R)I8: [R → L•,=] acc(8,=)=r(R →L)I9: [S → L = R•,$] acc(9,$)=r(S→L=R)I10: [R →L •,$] acc(10,$)=r(R→L)I11: [L → id•,$] acc(11,$)=r(L→id)I12: [L → * • R,$] ir_a(12,R)=13
[R → •L,$] ir_a(12,L)=10[L → •*R, $] acc(12,*)=d12[L → •id, $] acc(12,id)=d11
I13: [L → *R•,$] acc(13,$)=r(L →*R)
40
Análisis Sintáctico. Procesadores de Lenguaje I
Analizador LALRMotivación
Utilizado en la práctica al reducir el número de estados del analizador canónico LR (mismo número que SLR)
Forma estados a partir de la unión de estados deLR(1) con el mismo núcleo
Si estado Ii contiene [A->α • β, α], estado Ij contiene [A->α • β, b] forma estado unión Iij con [A->α • β, a/b]
Las gramáticas LALR(1) son un subconjunto de LR(1).
Pueden inducirse conflictos reducción/reducción pero nunca desplazamiento/reducciónAlgunos errores se manifiestan más tarde
Análisis Sintáctico. Procesadores de Lenguaje I
Analizador LALRDos principios del analizador LALR(1)
El núcleo de cualquier estado del AFD LR(1) es un estado del AFD LR(0)Si dos estados de LR(1), (s1, s2) tienen el mismo núcleo
Si goto(x1, X)=t1 ⇒ ∃ t2,| goto(x2,X)=t2 y (t1,t2) mismo núcleo
Corolario: el número de estados del AFD del analizador LALR(1) coincide con el AFD LR(0)
41
Análisis Sintáctico. Procesadores de Lenguaje I
Construir la tabla LALRAlgoritmo
1. Construir C={I0, I1, ..., In} LR(1) de G’2. Para cada núcleo en el conjunto de items LR(1),
buscar todos los conjuntos con ese núcleo y reemplazarlos por su estado unión
3. C’={J0, J1, ..., Jm} pasan a ser los nuevos estados. Hacer transiciones. Las acciones se generan igual que en el analizador LR. Si hay conflictos, la gramática no es LALR(1)
4. La tabla ir_a se forma sobre los conjuntos resultantes de efectuar las uniones de elementos LR(1) con el mismo núcleo
Análisis Sintáctico. Procesadores de Lenguaje I
EjemploUnir estados:
4,128,105,117,13
I6: [S →L=•R,$]
[R →•L,$][L →•*R,$][L →•id, $]
I7_13:[L → *R•,=/$]
I8_10:[R → L•,=/$]
I9: [S → L = R•,$]
I1: [S’ → S•,$]
I2: [S → L• =R,$]
[R → L•,$]
I3: [S → R•,$]
I4_12:[L → * • R,=/$]
[R → •L,=/$][L → •*R,=/$][L → •id, =/$]
I5_11:
[L → id•,=/$]
estados LALR(1):
I0: [S’→•S,$]
[S →•L=R,$] [S →•R,$][L → •*R,=][L → •id,=][R →•L,$]
42
Análisis Sintáctico. Procesadores de Lenguaje I
Estados de analizador LALR(1)
I0 I1
I2
I3
I4
I6
I7
I8
I9S
L
R
*
=
L
R
id
R
I5
id
*
L
id
*
a I5
a I4
a I8
10 estados, igual que SLR(1)
Análisis Sintáctico. Procesadores de Lenguaje I
Construir la tabla LALRaccLR(1)
I0: [S’→•S,$] ir_a(0,S)=1[S →•L=R,$] ir_a(0,L)=2[S →•R,$] ir_a(0,R)=3[L → •*R,=] acc(0,*) =d4[L → •id,=] acc(0,id)=d5[R →•L,$]
I1: [S’ → S•,$] acc(1,$)=ACPI2: [S → L• =R,$] acc(2,=)=d6
[R → L•,$] acc(2,$)=r(R→L)I3: [S → R•,$] acc(3,$)=r(S→R)I4: [L → * • R,=/$] ir_a(4, R)=7
[R → •L,=/$] ir_a(4, L)=8[L → •*R,=/$] acc(4,*)=d4[L → •id, =/$] acc(4,id)=d5
I5: [L → id•,=/$] acc(5,=)=r(L→id)acc(5,$)=r(L→id)
I6: [S →L=•R,$] ir_a(6,R)=9[R →•L,$] ir_a(6,L)=10[L →•*R,$] acc(6,*)= d12[L →•id, $] acc(6,id)=d11
I7: [L →*R•,=/$] acc(7,=)=r(L →R)acc(7,$)=r(L →R)
I8: [R → L•,=/$] acc(8,=)=r(R →L)acc(8,$)=r(R→L)
I9: [S → L = R•,$] acc(9,$)=r(S→L=R)
43
Análisis Sintáctico. Procesadores de Lenguaje I
Uso de gramáticas ambiguasUna gramática ambigua nunca puede ser LR A veces es útil emplear una gramática ambigua:
Construcciones más naturales y concisasAislar casos particulares que puede ser útil tenerlos separados
Una gramática ambigua puede generar lenguaje con reglas para “deshacer la ambigüedad”
Idea similar a las reglas de prioridad en gramáticas de operadorLas gramáticas ambiguas sólo deben usarse de forma escasa y controlada, para asegurar qué lenguaje se reconoce
Análisis Sintáctico. Procesadores de Lenguaje I
Ejemplo 1ª gramática ambigua
Sintaxis de condicional:S→ if E then S else SS→ if E then S S→ other
Gramática ambigua. Versión no Ambigua:S→ S_emparejada | S_no_emparejadaS_emparejada→ if E then S_emparejada else S_emparejadaS_emparejada→ otherS_no_emparejada→ if E then SS_no_emparejada→ if E then S_emparejada else S_no_emparejada
44
Análisis Sintáctico. Procesadores de Lenguaje I
Conj. LR(0)• G’1. S → iSeS2. S → iS3. S → a4. S’ → S
I4: [S → iS•eS]
[S → i S•]
I5: [S → iSe•S]
[S → •iSeS][S → •iS]
[S → •a]
I6: [S → iSeS •]
items LR(0):I0: [S’ → •S]
[S → •iSeS][S → •iS][S → •a]
I1: [S’ → S•]
I2: [S → i •SeS]
[S → i •S][S → •iSeS][S → •iS]
[S → •a]
I3: [S → a •]
Análisis Sintáctico. Procesadores de Lenguaje I
I4: [S → iS•eS] acc(4,e)=d5[S → i S•] acc(4,e)=r2
acc(4,$)=r2
I5: [S → iSe•S]
[S → •iSeS] acc(5,i)=d2[S → •iS]
[S → •a] acc(5,i)=d3
I6: [S → iSeS •] acc(6,e)=r1acc(6,$)=r1
Acciones analizador SLR(1)
I0: [S’ → •S]
[S → •iSeS] acc(0,i)=d2[S → •iS][S → •a] acc(0,a)=d3
I1: [S’ → S•] acc(1,$)=ACP
I2: [S → i •SeS]
[S → i •S][S → •iSeS] acc(2,i)=d2[S → •iS][S → •a] acc(2,a)=d3
I3: [S → a •] acc(3,$)=r3acc(3,e)=r3
ΣN Siguiente
S $,e
Items LR(0)-acciones SLR (1):
45
Análisis Sintáctico. Procesadores de Lenguaje I
Tabla SLR sin conflictos
acción ir_a
i e a $ S
0 d2 d3 1
1 ACP2 d2 d3 4 3 r3 r34 d5 r2 5 d2 d3 6 r1 r1 6
Resolución conflicto: en estado 4, desplazamiento sobre “else” (prioridad para if más anidado)
G:1. S → iSeS2. S → iS3. S → a
Análisis Sintáctico. Procesadores de Lenguaje I
Ejemplo 2ª gramática ambigua
Gramática de expresiones con sumas y productos:E::=E·+·T | TT::=T·*·F | FF::=(·E·) | Id
Versión ambigua: E:=E·+·E | E·*·E | (·E·) | Id
Dos ventajas:Más intuitivaAnalizador más rápido al evitar reducciones F→Id, T→F
Deshacer la ambigüedad con LR equivale aquí a fijar externamente la tabla de precedencia con analizador de precedencia
46
Análisis Sintáctico. Procesadores de Lenguaje I
Conj. LR(0)• G’1. E→ E+E 2. E→E * E3. E→(E)4. E →Id5. E’→E
I6: [E→(E •)]
[E→E•+ E] [E→E• * E]
I7: [E→E+E•]
[E→E•+ E] [E→E• * E]
I8: [E→E *E •]
[E→E•+ E] [E→E•* E]
I9: [E→(E) •]
I2: [E→(•E)]
[E→•E+ E] [E→•E * E][E→• (E)][E →•Id]
I3: [E→Id•]
I4: [E→E+•E]
[E→•E+ E] [E→•E * E][E→•(E)][E→•Id]
I5: [E→E *•E]
[E→•E+ E] [E→•E * E][E→•(E)][E→•Id]
I0: [E’→•E][E→•E+ E] [E→•E * E][E→• (E)][E →•Id]
I1: [E’→E•][E→E•+ E] [E→E•* E]
Análisis Sintáctico. Procesadores de Lenguaje I
Conflictos en analizador SLR• G’1. E→ E+E 2. E→E * E3. E→(E)4. E →Id5. E’→E
I7: [E→E+E•] acc(7,$)=r1
acc(7,+)=r1acc(7,*)=r1acc(7,))=r1
[E→E•+ E] acc(7,+)=d4[E→E• * E] acc(7,*)=d5
I8: [E→E*E•] acc(8,$)=r2
acc(8,+)=r2acc(8,*)=r2acc(8,))=r2
[E→E•+ E] acc(8,+)=d4[E→E• * E] acc(8,*)=d5
ΣN Siguiente
S $,+,*,)
47
Análisis Sintáctico. Procesadores de Lenguaje I
Tabla SLR sin conflictosResolución conflictos (desplaz/reducción) sobre +,*
{+,*} asociativos por la izquierda“*” más prioridad que “+”• estado I7:
• acc(7,+)=r1 (“+” es asociativo por izda)• acc(7,*)=d5 (“*” mayor prioridad que “+”)
• estado I8: • acc(8,+)=r2 (“*” mayor prioridad que “+”)• acc(8,*)=r2 (“*” es asociativo por izda)
Análisis Sintáctico. Procesadores de Lenguaje I
Tabla SLR sin conflictos
G:1. E→ E+E 2. E→E * E3. E→(E)4. E →Id
acción ir_aid + * ( ) $ E
0 d3 d2 1 1 d4 d5 ACP2 d3 d2 63 r4 r4 r4 r44 d3 d2 75 d3 d2 86 d4 d5 d9 7 r1 d5 r1 r1 8 r2 r2 r2 r2 9 r3 r3 r3 r3
48
Análisis Sintáctico. Procesadores de Lenguaje I
Ejemplo 3ª gramática ambiguaGramática de EQN, editor gráfico de ecuaciones:
E::=E·sub·E ·sup·EE::=E·sub·EE::=E·sup·EE::={·E ·}E::=c
Gramática intencionadamente ambigua por doble motivo:“sub” y “sup” tendrán conflictos desp/reducción: se resuelve conasociatividad (a derecha)
Justificado por simplicidad en la gramática y eficiencia en el análisisLa primera producción entra en conflicto desp/reducción con la segunda
Justificación de producción “extra” porque tiene sentido semántico:
E sub a sup b representa , en lugar de Eabb
aE