Análisis Sintáctico: Conceptos y Tipos

Anlisis Sintctico
Cadena de Analizador Sintctico rbol Sintctico
tokens
En realidad...
Componente lxico
Analizador Lxico
Obtn otro componente lxico
Analizador Sintctico
rbol sintctico
Tabla de Smbolos
Anlisis Sintctico. Procesadores de Lenguaje I
Anlisis Sintctico
Funciones
Comprobar que la secuencia de componentes lxicos cumple las reglas de la gramtica Generar el rbol sintctico Son especificaciones sintcticas y precisas de lenguajes Se puede generar automticamente un analizador El proceso de construccin puede llevar a descubrir ambigedades Imparte estructura al lenguaje de programacin, siendo ms fcil generar cdigo y detectar errores Es ms fcil ampliar y modificar el lenguaje
Ventajas de utilizar gramticas
Analizador Sintctico, Tipos

Tres tipos generales de analizadores sintcticos:
Mtodos Universales: Cocke-Younger-Kasami y Earley

Sirven para cualquier gramtica Muy ineficientes
Descendentes (top-down)
Construyen el rbol de anlisis sintctico desde arriba (raz,
axioma) hasta abajo (hojas, terminales) Analizadores Descendentes Recursivos Analizadores LL(1) con tabla
Ascendentes (bottom-up)
Construyen el rbol de anlisis sintctico desde abajo hacia
arriba Analizadores de Precedencia de Operador Analizadores LR(1)
Tanto para el anlisis descendente como para el ascendente:
La entrada se examina de izquierda a derecha, un smbolo cada vez Trabajan con subclases de gramticas LR(k) LL(k) En la prctica solo se utilizan LR(1) y LL(1)
En general las gramticas sern LL y LR

Muchos compiladores se llaman parser-driven debido a que el analizador sintctico es el que llama al lxico Existen herramientas para generar automticamente analizadores sintcticos (YACC, Bison)
rbol sintctico
Ejemplo: Id.*.Id.+.Id
Expresin
Gramtica: Expresin::= Expresin.*.Trmino | Expresin.+.Trmino | Trmino Trmino ::= Id | Nmero
Expresin
Trmino
Expresin
Trmino
Id
Trmino
Id
Id
Anlisis Sintctico Descendente

Algoritmo
1. 2.
Poner el axioma como raz del rbol de derivacin Hasta que solo haya smbolos terminales, derivar ms a la izquierda Entrada: Id.*.Id.+.Id Gramtica:
Expresin::=Expresin.*.Trmino | Expresin.+.Trmino | Trmino Trmino ::= Id | Nmero
Ejemplo

Derivacin:
Expresin Expresin.+.Trmino Expresin.*.Trmino.+.Trmino Trmino.*.Trmino.+.Trmino Id.*.Trmino.+.Trmino Id.*.Id.+.Trmino Id.*.Id.+.Id
Anlisis Sintctico Ascendente

Definicin: Pivote
Secuencia ms larga de smbolos (T y N) en la parte ms izquierda de la entrada que se puede encontrar en la parte derecha de una produccin y tal que todos los smbolos a su derecha son terminales Ejemplo: Si entrada es: Expresin.*.Trmino.+.Id el pivote es: Expresin.*.Trmino Empezar con la cadena de entrada Intentar llegar hasta el axioma, encontrando el pivote y reducindolo con la produccin correspondiente
Algoritmo
1. 2.
Ejemplo
Id.*.Id.+.Id Trmino.*.Id.+.Id Expresin.*.Id.+.Id Expresin.*.Trmino.+.Id Expresin.+.Id Expresin.+.Trmino Expresin
Analizadores Sintcticos, Problemas

Descendentes
Mas de una opcin: A::= |

Retroceso Analizar los siguientes elementos de la entrada
Recursividad izquierda
Eliminacin de la recursividad
Ambigedad
Factorizacin por la izquierda
Ascendentes
Ms de una opcin: A::= y es el pivote Problemas semnticos
Otros
Anlisis Sintctico Predictivo

No necesita realizar retroceso para analizar bien las sentencias del lenguaje Slo con ver el siguiente carcter de la entrada puede decidir cul va a ser la siguiente produccin a emplear Condiciones

Disear bien la gramtica Eliminar la recursividad izquierda Factorizar por la izquierda
No est asegurado el tener una gramtica predictiva Las gramticas son difciles de leer Para las partes de las gramticas que no son predictivas se pueden utilizar otros analizadores
Anlisis Sintctico Predictivo: Descendente Recursivo
Se ejecuta un conjunto de procedimientos recursivos para procesar la entrada A cada NO Terminal de una gramtica se le asocia un procedimiento
Decide la produccin que utilizar analizando el smbolo de preanlisis,

si est en PRIMERO() entonces se usa la produccin con lado derecho si no est en ningn PRIMERO entonces se usa una produccin
Usa una produccin imitando al lado derecho

no terminal da como resultado una llamada a otro procedimiento terminal (que coincide con el smbolo de preanlisis) produce otra lectura
de otro token. Si el token no coincide entonces Error
La secuencia de procedimientos llamados para procesar la entrada define implcitamente un rbol de anlisis sintctico
Anlisis Sintctico Predictivo: Descendente Recursivo

Ejemplo:
S if B then S | write B | i := B B 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(); }
Anlisis Sintctico Predictivo, DEFINICIONES: PRIMERO
Si es una cadena de smbolos gramaticales, PRIMERO() es el conjunto de terminales que inician las cadenas derivadas de .
Conjunto PRIMERO(X) para todos los smbolos gramaticales X

1. 2. 3. 4.
PRIMERO()={x | ( * x), (x T {}), (, *)}
Repetir hasta que no se puedan aadir ms terminales o a ningn conjunto PRIMERO Si X T PRIMERO(X) es { X } Si X aadir a PRIMERO(X) 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 aade PRIMERO(Y2) Si Y1 no deriva a no se aade ms a PRIMERO(X)
Anlisis Sintctico 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 } PRIMERO(F) = { (, Id } PRIMERO(E) = { +, }
PRIMERO(T.*.Id) = { (, Id } PRIMERO(Id.+.Id) = { Id } PRIMERO(Id) = { Id } PRIMERO(T) = { *, }
Anlisis Sintctico Predictivo, DEFINICIONES: SIGUIENTE

Conjunto SIGUIENTE(A)

SIGUIENTE(A)={x|(S*A), (AN), (*), (+), (xPRIMERO()-{})} Conjunto de terminales que pueden aparecer inmediatamente a la derecha de A en alguna forma sentencial, si A es el ltimo smbolo entonces se incluye el separador $ SIGUIENTE(S)={$} La regla AB SIGUIENTE(B) = (PRIMERO()-{}) SIGUIENTE(B) La regla AB | =, * ( PRIMERO()) SIGUIENTE(B) = SIGUIENTE(A) SIGUIENTE(B) Repetir hasta que no cambie ningn conjunto SIGUIENTE
Algoritmo
1. 2.
3.
4.
Anlisis Sintctico Predictivo, DEFINICIONES: SIGUIENTE

SIGUIENTE(A), Ejemplo:
E ::= T.E E ::= +.T.E | T ::= F.T T ::= *.F.T | F ::= (.E.) | Id N E E F T T SIGUIENTE $, ) $, ) $, *, ), + $, +, ) $, +, )
Anlisis Sintctico Predictivo: Condiciones

Pregunta:
Que debe cumplir una gramtica para que pueda ser reconocida sin retroceso, con solo mirar el siguiente elemento de la entrada, de forma descendente? Si A::= | PRIMERO() PRIMERO() = . para ningn terminal a tanto y derivan a la vez cadenas que comiencen con a No puede ocurrir que * y * Si *, entonces no deriva ninguna cadena que comience con un terminal en SIGUIENTE(A)
Respuesta:
Condicin LL(1)
Anlisis Sintctico Predictivo: Condiciones

Condicin LL(1)
No puede haber conflictos PRIMERO/PRIMERO

NN, el conjunto PRIMERO de todas sus alternativas debe
ser disjunto
No puede haber mltiples alternativas nulas

NN, solo pueden tener una produccin N*
No puede haber conflictos PRIMERO/SIGUIENTE

NN, con una alternativa nula, SIGUIENTE(N) debe ser
disjunto de los conjuntos PRIMERO de todas sus alternativas
No puede haber entradas con definiciones mltiples en la tabla de anlisis
Anlisis Sintctico Predictivo: Tabla de Anlisis Sintctico

Funcionamiento
Sea A con aT | aPRIMERO(). El analizador sintctico expandir A por cuando el smbolo actual de la entrada sea a
Algoritmo
ForAll (A::= ) do ForAll a PRIMERO() do tabla(A,a)= Si PRIMERO() Entonces ForAll b SIGUIENTE(A) do tabla(A,b)= ForAll AN y cT do If tabla(A,c)= Then tabla(A,c)= error
Anlisis Sintctico Predictivo: Tabla de Anlisis Sintctico

Ejemplo
E ::= T.E E ::= +.T.E | T ::= F.T T ::= *.F.T | F ::= (.E.) | Id
Id T.E F.T Id *.F.T (.E.) + +.T.E F.T * ( T.E )
E E T T F
Anlisis Sintctico Predictivo No Recursivo; LL(1)
Modelo de analizador sintctico predictivo no recursivo

ENTRADA PILA X Y Z $ a + b $
Programa de Anlisis Sintctico Predictivo
SALIDA
Tabla de Anlisis Sintctico M
Anlisis Sintctico Predictivo No Recursivo; LL(1)
Los smbolos de la entrada actual a y cima de la pila X determinan la accin del analizador Hay tres posibilidades:
X=a=$, el analizador se detiene y anuncia el xito del anlisis X=a$, el analizador saca X de la pila y mueve el apuntador de la entrada al siguiente smbolo de entrada XN, 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 recuperacin de error
Anlisis Sintctico LL(1)

Algoritmo:
pila =$; meter$ al final de la entrada; a:= GetToken; Push S; Repeat X=$ then If X T or If X=a then Pop; a:= GetToken; Else error; Else If M[X,a]=XY1Y2..Yk then Pop; Push Yk,Yk-1,...,Y1 Emitir la produccin X else error(); until X=$ If X=$ and a=$ then Aceptar; else error();
Anlisis Sintctico LL(1)

Ejemplo:
Pila $E $ E $ E $ E $ E $ E $ E $ E $ E $ E $ E $ E $ E $ E $ E $ E $ T T T T T T T T F Id F* F Id Entrada Id * Id + Id * Id + Id * Id + Id * Id + * Id + Id * Id + Id Id + Id $ Id + Id $ + Id $ + Id $ + Id $ Id $ Id $ Id $ $ $ $ Id Id Id Id $ $ $ $ $ $ Produccin E::= T E T::= F T F::= Id T::= * F T F::= Id T::= E::= + T E T::= F T F::= Id T::= E::=
T+ T T F T Id T
Anlisis Sintctico Ascendente

Anlisis por desplazamiento y reduccin

Por precedencia de operadores LR
Construir un rbol de anlisis sintctico para una cadena de entrada que comienza por las hojas y avanza hacia la raz. Reducir una cadena de entrada w al smbolo inicial de la gramtica (axioma) En cada paso de reduccin se sustituye una subcadena que concuerde con el lado derecho de una produccin por el smbolo del lado izquierdo, se traza una derivacin por la derecha en sentido inverso
Anlisis Sintctico Ascendente: Gramtica de Operadores
Para una pequea clase de gramticas se puede construir con facilidad, a mano, eficientes analizadores sintcticos por desplazamiento y reduccin Gramtica de operadores

No tiene reglas de produccin del tipo A::= No tiene dos no terminales adyacentes A::=BC | A,B,C N
Ejemplo
No es G. de operadores
EEAE | (E) | -E | id A+ | - | * | /
Si es G. de operadores
EE+E | E-E | E*E | E/E | (E) | -E | id
Precedencia de Operador: Relaciones de Precedencia

Se definen tres relaciones de precedencia disjuntas

a<b si a tiene menos precedencia que b a=b si a tiene igual precedencia que b a>b si a tiene ms precedencia que b
Algoritmo
Sustituir todos los smbolos no terminales por un nico smbolo Insertar $ al principio y al final de la cadena de entrada Insertar las relaciones de precedencia en la cadena de entrada Mientras 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 medio Reinsertar las relaciones de precedencia, ignorando los no terminales
Precedencia de Operador: Ejemplo
Entrada: $(Id+Id)$ Gramtica: E::= E+E | E*E | (E) | Id Tabla de precedencia:

( ) Id * + ( $ Anlisis Id * > > > < < < + > > > > < < ) > > > > = $ > > > > = Derivacin
$(E+Id)$ $(E+E)$ $(E)$ $E$
< < < < < < < < Entrada

$ $ $ $ < < < < ( ( ( (
< Id > + < Id > ) >$ < E + < Id > ) > $ < E + E > ) > $ E = ) > $
Precedencia de Operador: Evaluador de Expresiones

El anlisis 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) Pila de Operadores Pila de Operandos
El anlisis mantiene dos pilas

Cuando un operador en la cima de su pila es de ms precedencia que el siguiente ledo, entonces arranca la reduccin del pivote, hasta encontrar la relacin de precedencia mayor. Cada operador extrado se aplica a los operandos ms arriba de la pila de operandos
Evaluacin de Expresiones
Algoritmo de evaluacin de expresiones:
pilaOperadores = $; poner $ al final de la entrada; a:= GetToken; repeat if a=$ y cimaOperadores=$ then return if a es Operando then PushOperando (a); a:=GetToken; else if (cimaOperandos <. a) o (cimaOperandos =. a) then PushOperador (a); a: =GetToken; else repeat opAnterior= PopOperador aplicar opAnterior a pilaOperandos until (cimaOperadores <. opAnterior) else Error until true
Anlisis Sintctico Ascendente: Precedencia de Operador

Entrada:
Id+Id*Id E:=E+E | E*E | (E) | Id
Gramtica
La gramtica es ambigua pero este tipo de anlisis proporciona una nica derivacin
Entrada Ida+Idb*Idc$ +Idb*Idc$ Idb*Idc$ *Idc$ Idc$ $ $ $ Pila Operadores $ $ $+ $+ $+* $+* $+ $ Pila Operandos Ida Ida Ida, Idb Ida, Idb Ida, Idb, Idc Ida , Idb*Idc Ida+Idb* Idd

Entrada: Id*(Id+Id*Id)
Entrada Pila Operadores Ida.*.(Idb+Idc.*. Idd)$ $ .*.(Idb+Idc .*.Idd)$ $ (Idb+Idc .*.Idd)$ $* Idb+Idc .*.Idd)$ $*( +Idc .*.Idd)$ $*( Idc .*.Idd)$ $*(+ .*.Idd)$ $*(+ Idd)$ $*(+* )$ $*(+* )$ $*(+ )$ $*( $ $*() $ $
Pila Operandos Ida Ida Ida Ida, Idb Ida, Idb Ida, Idb , Idc 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
Entrada
Ida.*.(Idb+Idc).+. Idd$ .*.(Idb+Idc).+. Idd$ (Idb+Idc).+. Idd$ Idb+Idc).+. Idd$ .+Idc).+. Idd$ Idc).+. Idd$ ).+. Idd$ ).+. Idd$ .+. Idd$ .+. Idd$ .+. Idd$ Idd$ $ $
Pila Operadores
$ $ $ $ $ $ $ $ $ $ $ $ $ $ * * * * * * * * + +
Pila Operandos
Ida Ida Ida Ida IdaIdb IdaIdb IdaIdbIdc IdaIdb+Idc IdaIdb+Idc IdaIdb+Idc Ida*(idb+Idc) Ida*(idb+Idc) Ida*(idb+Idc) Idd Ida*(idb+Idc)+Idd
( ( (+ (+ ( ()
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>$, )>$
Precedencia de Operador: Operadores Unarios ()
Manejo de Operadores Unarios ()

Operador Unario que no es adems Binario
<
> si tiene mayor precedencia que < si tiene menor precedencia que
Operador Unario que adems es Binario

Mediante la tabla de precedencia no puede analizarse
correctamente cadenas como: Id*-Id Solucin: Utilizar el analizador lxico para devolver dos componentes lxicos distintos, recordando el componente lxico anterior debe distinguir uno de otro. Ejemplo: Es el menos unario si antes el componente lxico ledo era un operador, un parntesis izquierdo, una coma o un smbolo de asignacin
Obtencin de las relaciones de precedencia (clculo)

xy
sii existe: sii existe:
A ...xBy... B{N } A ...xB... B + Cy... C{N }
x < y

x > y

sii existe:
A ...By... B +...xC C{N }
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*)}

E::=E+T | T T::=T*F | F F::=(E) | Id Cabecera(E)={+, *, (, Id} ltimo(E)={+, *, ), Id}
Ejemplo:
Propiedad:
(A::= BaC) P, a T, A, B, C N, , *, a siempre aparece en un nivel superior a los smbolos terminales de Cabecera(C) y ltimo(B) en el rbol de derivacin
Precedencia de Operador: Calcular la Tabla de Precedencia

Reglas:
1. 2. 3.
(A::= BaC) P, a T, A, B, C N, , *
c Cabecera(C), a < c b ltimo(B), b > a (A::= ab) P, a, b T, a=b , *
Si existe ms de una relacin de precedencia entre dos smbolos terminales, no es una gramtica de precedencia Algoritmo
ForAll (A::= BaC) P do Calcular Cabecera(C) Calcular ltimo(B) Calcular las precedencias usando las reglas 1, 2 y 3 ForAll a Cabecera(S) do $ < a ForAll a ltimo(S) do a > $
Ejemplo Calculo de Tabla de Precedencia

Gramtica
E::=E+T | T T::=T*F | F F::=(E) | Id
Cabecera y ltimo
N E T F Cabecera +, *, (, Id *, (, Id (, Id Precedencias(R2) +, *, ), Id > + *, ), Id > * ltimo +, *, ), Id *, ), Id ), Id Precedencias (R1) + < *, (, Id * < (, Id
Tabla
Regla E::=E+T T::=T*F
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 g Transforman los smbolos terminales en enteros Tienen 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 relacin de precedencia entre a y b se realiza una comparacin entre f(a) y g(b) No todas las relaciones de precedencia tienen funciones de precedencia

1. 2.
Construccin de las Funciones de Precedencia

Crear los smbolos fa y ga aT {$} Se dividen los fa y ga en tantos grupos como sea posible:
3.
Si a=b entonces fa y gb estn en el mismo grupo
Crear un grafo dirigido cuyos nodos son los grupos encontrados en el paso 2, los arcos se etiquetan:

si a<b, gb fa si a>b, fa gb Respuesta SI, entonces no existen funciones de precedencia Respuesta NO, entonces f(a) y g(a) son los caminos ms largos que comienzan en fa y ga
4.
Ciclos en el grafo:


Ejemplo
Id Id + * $
gId g*
< < <
+ > > > <

g+
* > < > <

g$
$ > > >
Cada smbolo est solo en un grupo
fId
f*
f+
f$
No hay ciclos, entonces existen las funciones de precedencia. Como las funciones de $ no tienen arcos entonces f($)=g($)=0 El camino ms largo desde g+ tiene longitud 1, entonces g(+)=1 El camino ms largo desde gId a f* a g* a f+ a f$ por tanto g(id)=5
f g
Id 4 5 + 2 1 * 4 3 $ 0 0

Inconvenientes
Es difcil de manejar componentes lxicos 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 deseado Slo una pequea clase de gramticas puede analizarse Sencillez Se pueden establecer relaciones de precedencia (* precede a +)
Ventajas

Se aplican con otros analizadores para la parte que no son de operador
Anlisis Ascendente LR
LR(k): Left-to-right, rightmost derivation, k smbolos de entrada son necesarios para tomar las decisiones de anlisis sintctico
Ventajas
Es el mtodo de anlisis por desplazamiento y reduccin sin
retroceso ms general, a pesar de esto es igual de eficiente
La clase de gramticas que pueden analizarse es un
supraconjunto de la clase de gramticas que pueden analizarse con analizadores sintcticos predictivos Detectan los errores sintcticos tan pronto como es posible en un examen de izquierda a derecha de la entrada Se pueden reconocer prcticamente todas las construcciones de los lenguajes de programacin descritos por una gramtica G2
Inconvenientes
La construccin a mano requiere mucho trabajo
Tipos de Anlizadores LR
LR simple (SLR)

Fcil de implementar Menos poderoso, hay algunas gramticas que los otros mtodos pueden analizar y este no puede Es muy costoso de implementar El ms potente Intermedio entre los dos mtodos anteriores
LR cannico

LALR (LR con smbolo de preanlisis)
Modelo de un Analizador LR
ENTRADA
Pila
a1 ... a1 ... an $
sm Xm sm-1 Xm-1 ... s0
Programa de Anlisis Sintctico LR
SALIDA
Accin Ir_a
Tabla de Anlisis Sintctico LR
Modelo de Analizador LR
El programa es el mismo para todos los analizadores LR Xi es un smbolo gramatical y cada si es un smbolo llamado estado Se utiliza el smbolo de estado y el smbolo de la entrada para indexar la tabla y determinar la accin siguiente La tabla de anlisis sintcticos tiene dos partes:
Accin[sm, ai]=

Error: Aceptar: Desplazar: Reduccin:
error de sintaxis acepta la entrada, el anlisis sintctico finaliza introduce en la pila el smbolo ai y el estado sm extrae smbolos de la pila, ejecuta la accin semntica correspondiente a una produccin
Ir_a[sm, Xi]= sk
Modelo de Analizador LR
Configuracin de un analizador sintctico 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$) (s0 X1 s1 X2 s2 ... Xm sm ai s, ai+1 ... an$)
Accin[sm, ai] = desplazar s
Accin[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 r smbolos no terminales y r smbolos de estados de la pila)
Algoritmo de Anlisis LR
apuntar ae al primer smbolo de w$ (s est en la cima y ae apunta al smbolo a) repetir case Accin[s, a] Desplazar s push a push s leer en la entrada Reducir A pop 2*|| smbolos s smbolo en la cima de la pila s= Ir_a[s, A] push A push s Aceptar Error fincaso hasta Aceptar o Error
Ejemplo de Anlisis LR
Gramtica
1. 2. 3. 4. 5. 6. E::= E+T E::= T T::= T*F T::= F F::= (E) F::= Id Tabla de anlisis sintctico
Estado 0 1 2 3 4 5 6 7 8 9 10 11 Accin Id + d5 d6 r2 r4 d5 r6 d5 d5 d6 r1 r3 r5 * ( d4 ) $ ACP r2 r4 8 r6 d4 d4 d7 r3 r5 d11 r1 r1 r3 r3 r5 r5 r6 9 3 10 2 3 Ir_a E T 1 2 F 3
d7 r4 d4 r6
r2 r4
Ejemplo de Anlisis LR
Pila
0 0 0 0 0 0 0 0 0 0 0 0 0 0 Id 5 F3 T2 T2*7 T 2 * 7 Id 5 T 2 * 7 F 10 T2 E1 E1+6 E 1 + 6 Id 5 E1+6F3 E1+6T9 E1
Entrada
Id*Id+Id$ *Id+Id$ *Id+Id$ *Id+Id$ Id+Id$ +Id$ +Id$ +Id$ +Id$ Id$ $ $ $ $
Accin
d5 r6 r4 d7 d5 r6 r3 r2 d6 d5 r6 r4 r1 ACP
Construccin de Tabla de Anlisis SLR

Definiciones:
Elemento del anlisis sintctico LR(0) de una gramtica G (elemento, tem)

Produccin de G con un punto en alguna posicin del lado
derecho El punto indica hasta donde se ha visto la produccin en un momento del anlisis
Ejemplo: La produccin AXYZ tiene cuatro elementos: AXYZ AXYZ AXYZ AXYZ
Pregunta: Qu elemento genera la produccin A?
Construccin de Tabla de Anlisis SLR

Definiciones:

Prefijo viable Item vlido para prefijo viable:

A12 es item vlido de 1 sii: S * Aw*12w (AN,, ,1,2*, w*T)
rm rm
Estado
Conjunto de tems Dan lugar a los estados del analizador sintctico SLR El conjunto de estados: coleccin cannica LR(0)
Los tems son los estados de un AF que reconoce los prefijos viables Los estados son las agrupaciones de estados, (La minimizacin del AF!)
Algoritmo: crear conjunto cannico LR(0)

Entrada:

Gramtica ampliada G Funcin cierre(I) (clausura o cerradura), Item+ Funcin goto(I, X) (ir_a), X(T N) Conjunto cannico LR(0) Aadir S, N= (N S ) | S es el axioma Aadir S S, P= (P S S)
Salida
Gramtica ampliada G de G

Construir el conjunto cannico LR(0)

Funcin cierre(I)
function cierre(I); begin
J:=I;
repeat do J := J (B ) ; until no pueden aadirse tems a J ; return J end for Ji (A B) J , p (B ) P | (B ) J
Ejemplo:
A B B id | C num | ( D ) C+D D id | num
cierre(A B) ? A B B id | C num | ( D ) C+D

Funcin goto(I, X)
Si I son items vlidos de , goto(I, X) son los items vlidos de X

J:=; Ii | (B X ) I, J := J cierre(B X ) ; return J
function goto(I, X); begin
end
Ejemplo:
A B B id | C num | ( D ) C+D D id | num
I = {B id, B ( D )} goto {I, ( }? B (D ) D id D num
La funcin elementos proporciona la coleccin cannica 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) C do C := C goto(I, X); until no pueden aadirse ms conjuntos de tems a C; return C end

Ejemplo:
1. 2. 3. 4. 5. 1. 2. 3. 4. 5. 6.
S A B end A tipo A id A B begin C C cdigo
items LR(0): I0: S S

S A B end A tipo A id A
I4: I5: I6: I7: I8: I9: I10:
A idA A tipo A id A S A Bend B beginC C cdigo A id A S A B end B begin C C cdigo
I1: I2: I3:
S S S AB end B begin C A tipo
S S S A B end A tipo A id A B begin C C cdigo

S A tipo
El conjunto cannico define un AFD que reconoce los prefijos viables de G, con I0 estado inicial e Ij j 0 estados finales
I0
I1 I2 I3
B begin tipo A id
I5 I6 I7
end
I8 I9 I10
C cdigo
id
I4
Para cada prefijo alcanzado, Ii define sus prefijos viables!
Construir la tabla SLR (por fin)

Entrada:
Gramtica aumentada G
Salida
Tabla SLR, funciones de accin e ir_a
Algoritmo
1. 2.
3. 4.
Construir C={I0, I1, ..., In} LR(0) de G El estado i se construye a partir de Ii, poner las operaciones adecuadas del analizador sintctico Las entradas no definidas son ERROR El estado inicial es el del conjunto con [SS]
Construir la tabla SLR

Operaciones asociadas a los tems
Desplazar
Si [Aa] Ii , a T, goto(Ii, a) = Ij accin[i, a] =
desplazar j
Reducir
Si [A] Ii , A S a SIGUIENTE(A),
accin[i, a] = reducir A
Aceptar
Si [SS] Ii accin[i,$] = aceptar
Ir_a
Si goto(Ii, A) = Ij, A N ir_a[i, A] = j
Construir la tabla SLR

ccLR(0)
I0: S S S A B end A tipo A id A I1: S S I2: S AB end B begin C I3: A tipo I4: A idA A tipo A id A ir_a[4,A]=7 accin[4,tipo]=d3 accin[4,id]=d4 accin[3,begin]=r(A tipo) ir_a[2,B]=5 accin[2,begin]=d6 accin[1,$]=aceptar ir_a[0,S]=1 ir_a[0,A]=2 accin[0,tipo]=d3 accin[0,id]=d4 I5: S A Bend I6: B beginC C cdigo I7: A id A I8: S A B end I9: B begin C I10: C cdigo N S A B C accin[9,end]=r(B begin C) accin[10,end]=r(C cdigo) accin[8,$]=r(S A B end) accin[7,begin]=r(A id) ir_a[6,C]=9 accin[6,cdigo]=d10 accin[5,end]=d8
Siguiente $ begin end end
Tabla SLR Resultante

accin
tipo
0 1 2 3 4 5 6 7 8 9 10 d3
ir_a
cdigo $ end S
1 ACP
id
d4
begin
A
2
B C
d6 r(A tipo) d3 d4 d8 d10 r(A id) r(S AB end) r(B begin C) r(C cdigo) 7
Resumen
El anlisis sintctico LR

El anlisis ascendente sin retroceso ms general Utiliza una pila y una tabla de anlisis Desplazamiento/Reduccin La tabla SLR se obtiene haciendo el conjunto cannico LR(0)
Analizador cannico LR
Motivacin
Tabla SLR tiene info insuficiente y pueden aparecer conflictos desplazamiento/reduccin Si el estado Ii contiene [A->] No es adecuada siempre la reduccin A->a para todos los terminales en Siguiente(A)
Dado prefijo viable con items vlidos en Ii puede ser que no
existan formas sentenciales Aa, con aSiguiente(A)
Ejemplo:
S L=R SR L *R L id RL
Conjunto LR(0)
Ejemplo:
1. 2. 3. 4. 5.
G
S L=R SR L *R L id RL
items LR(0): I0: S S

S L=R S R R L L *R L id
I4:
L*R R L L *R L id
I5: I6:
L id S L = R R L L *R L id
1. 2. 3. 4. 5. 6.
G
S L=R SR L *R L id RL S S
I1: I2: I3:
S S S L =R RL S R
I7: I8: I9:
L*R R L S L = R
Tabla de anlisis LR(0)

I0
S L R
I1 I2 I3
=
I6 I7
L
I9
I4
id id
I8
I5
Conflicto en la tabla SLR!

ccLR(0)
.... I2: S L =R RL ...
accin
accin[2,=]=d6 accin[2,=]=r5
$ est en Siguiente(R) pero no hay ninguna derivacin donde reducir L por R seguido de $ Esta informacin de contexto no se usa en el analizador SLR
N S L R
Siguiente $ $, = $, =
Items en LR(1)
tems: estados de AF que reconoce los
Elementos con ms informacin:
[A12, a] con A12P, aT
prefijos viables junto a smbolos posibles tras pivote
Definicin:
rm rm
[A12, a] es item vlido de =1 sii: - S * Aw12w a es el primer smbolo de w (o si w es , a es $)
Estado:
Conjunto de estados: coleccin cannica LR(1) Se aumentan los estados LR(0)
Items en LR(1)
Construccin: vara la funcin cierre(I)
[AB, a]I
rm
[AB, a] es item vlido de =: S * Aaxax=ax
Para cada item B: S * by, b|bPrimero(a)

rm
[B , b] cierre(I)

Funcin cierre(I)
function cierre(I); begin
J:=I;
repeat for Ji [A B,a] J , p (B ) P , bPrimero(a) |
[B , b] J
do J := J [B , b] ; until no pueden aadirse tems a J ; return J end
Ejemplo:
S S S CC C cC | d
cierre([S S,$])? [S S,$] [S CC,$] [C cC,c/d] [C d,c/d]
Primero $ C$ $ c, d

Funcin goto(I, X)
Si I son items vlidos de , goto(I, X) son los items vlidos de X

J:=; Ii | [B X , a] I, J := J cierre([B X , a]) ; return J
function goto(I, X); begin
end
Ejemplo:
S S S CC C cC | d
goto([C cC,c/d],c)? [C cC,c/d] [C cC,c/d] [C d,c/d]
Primero () c () d c d
La funcin elementos proporciona la coleccin cannica 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) C do C := C goto(I, X); until no pueden aadirse ms conjuntos de tems a C; return C end
Conj. LR(1) I : [S S,$]

1
I7: I8: I9: I10: I11: I12:
[L *R,=|$] [R L,=|$] [S L = R,$] [R L,$] [L id,$] [L * R,$] [R L,$] [L *R, $] [L id, $]
1. 2. 3. 4. 5. 6.
G
S L=R SR L *R L id RL S S
I2: I3: I4:
[S L =R,$] [R L,$] [S R,$] [L * R,=|$] [R L,=|$] [L *R,=|$] [L id, =|$]
items LR(1): I0: [SS,$]

[S L=R,$] [S R,$] [L *R,=|$] [L id,=|$] [R L,$]
I5: I6:
[L id,=|$] [S L=R,$] [R L,$] [L *R,$] [L id, $]
I13:
[L *R,$]
Estados de analizador cannico LR(1)

I0
S L R
I1 I2 I3
= R
I9 I6 I7
* L id L id R *
I10
L
I11 I12
R
I4
id
I8
I13
I5
Construir la tabla cannica LR

Entrada:
Gramtica aumentada G
Salida
Tabla LR, funciones de accin e ir_a
Algoritmo
1. 2.
3. 4.
Construir C={I0, I1, ..., In} LR(1) de G El estado i se construye a partir de Ii, poner las operaciones adecuadas del analizador sintctico Las entradas no definidas son ERROR El estado inicial es el del conjunto con [SS, $]
Construir la tabla cannica LR

accLR(1)
I0: [SS,$] [S L=R,$] [S R,$] [L *R,=] [L id,=] [R L,$] I1: [S S,$] I2: [S L =R,$] [R L,$] I3: [S R,$] I4: [L * R,=] [R L,=] [L *R,=] [L id, =] I5: [L id,=] ir_a(0,S)=1 ir_a(0,L)=2 ir_a(0,R)=3 acc(0,*) =d4 acc(0,id)=d5 acc(1,$)=ACP acc(2,=)=d6 acc(2,$)=r(RL) acc(3,$)=r(SR) ir_a(4, R)=7 ir_a(4, L)=8 acc(4,*)=d4 acc(4,id)=d5 acc(5,=)=r(Lid) I6: [S L=R,$] [R L,$] [L *R,$] [L id, $] 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,$] ir_a(6,R)=9 ir_a(6,L)=10 acc(6,*)= d12 acc(6,id)=d11 acc(7,=)=r(L *R) acc(8,=)=r(R L) acc(9,$)=r(SL=R) acc(10,$)=r(RL) acc(11,$)=r(Lid) ir_a(12,R)=13 ir_a(12,L)=10 acc(12,*)=d12 acc(12,id)=d11 acc(13,$)=r(L *R)
Analizador LALR
Motivacin
Utilizado en la prctica al reducir el nmero de estados del analizador cannico LR (mismo nmero que SLR)
Forma estados a partir de la unin de estados de LR(1) con el mismo ncleo
Las gramticas LALR(1) son un subconjunto de LR(1).
Si estado Ii contiene [A-> , ], estado Ij contiene [A-> , b] forma estado unin Iij con [A-> , a/b]
Pueden inducirse conflictos reduccin/reduccin pero nunca desplazamiento/reduccin Algunos errores se manifiestan ms tarde
Analizador LALR
Dos principios del analizador LALR(1)
El ncleo 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 ncleo
Si goto(x1, X)=t1 t2,| goto(x2,X)=t2 y (t1,t2) mismo
ncleo
Corolario: el nmero de estados del AFD del analizador LALR(1) coincide con el AFD LR(0)
Construir la tabla LALR

Algoritmo
1. 2.
3.
4.
Construir C={I0, I1, ..., In} LR(1) de G Para cada ncleo en el conjunto de items LR(1), buscar todos los conjuntos con ese ncleo y reemplazarlos por su estado unin 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 gramtica no es LALR(1) La tabla ir_a se forma sobre los conjuntos resultantes de efectuar las uniones de elementos LR(1) con el mismo ncleo
Ejemplo
Unir estados:

I0:
I1: I2: I3:
[S S,$] [S L =R,$] [R L,$] [S R,$]
I6:
[S L=R,$] [R L,$] [L *R,$] [L id, $]
4,12 8,10 5,11 7,13
I7_13:
[L *R,=/$]
estados LALR(1):
[SS,$] [S L=R,$] [S R,$] [L *R,=] [L id,=] [R L,$]
I4_12:
[L * R,=/$] [R L,=/$] [L *R,=/$] [L id, =/$]
I8_10:
[R L,=/$]
I9:
[S L = R,$]
I5_11:
[L id,=/$]
Estados de analizador LALR(1)

I0
S L R
I1 I2 I3
= R
I9 I6 I7
* L id L id R * a I5 a I4 a I8
I4
id
I8
I5
10 estados, igual que SLR(1)
Construir la tabla LALR

accLR(1)
I0: [SS,$] [S L=R,$] [S R,$] [L *R,=] [L id,=] [R L,$] I1: [S S,$] I2: [S L =R,$] [R L,$] I3: [S R,$] I4: [L * R,=/$] [R L,=/$] [L *R,=/$] [L id, =/$] I5: [L id,=/$] ir_a(0,S)=1 ir_a(0,L)=2 ir_a(0,R)=3 acc(0,*) =d4 acc(0,id)=d5 acc(1,$)=ACP acc(2,=)=d6 acc(2,$)=r(RL) acc(3,$)=r(SR) ir_a(4, R)=7 ir_a(4, L)=8 acc(4,*)=d4 acc(4,id)=d5 acc(5,=)=r(Lid) acc(5,$)=r(Lid) I6: [S L=R,$] [R L,$] [L *R,$] [L id, $] I7: [L *R,=/$] I8: [R L,=/$] I9: [S L = R,$] ir_a(6,R)=9 ir_a(6,L)=10 acc(6,*)= d12 acc(6,id)=d11 acc(7,=)=r(L R) acc(7,$)=r(L R) acc(8,=)=r(R L) acc(8,$)=r(RL) acc(9,$)=r(SL=R)
Uso de gramticas ambiguas

Una gramtica ambigua nunca puede ser LR A veces es til emplear una gramtica ambigua:

Construcciones ms naturales y concisas Aislar casos particulares que puede ser til tenerlos separados
Una gramtica ambigua puede generar lenguaje con reglas para deshacer la ambigedad
Idea similar a las reglas de prioridad en gramticas de operador Las gramticas ambiguas slo deben usarse de forma escasa y controlada, para asegurar qu lenguaje se reconoce
Ejemplo 1 gramtica ambigua

Sintaxis de condicional:

S if E then S else S S if E then S S other
Gramtica ambigua. Versin no Ambigua:

S S_emparejada | S_no_emparejada S_emparejada if E then S_emparejada else S_emparejada S_emparejada other S_no_emparejada if E then S S_no_emparejada if E then S_emparejada else S_no_emparejada
Conj. LR(0)
1. 2. 3. 4.
G
S iSeS S iS Sa S S
items LR(0): I0: [S S]

[S iSeS] [S iS] [S a]
I4: I5:
[S iSeS] [S i S] [S iSeS] [S iSeS] [S iS] [S a]
I1: I2:
[S S] [S i SeS] [S i S] [S iSeS] [S iS] [S a]
I6:
[S iSeS ]
I3:
[S a ]
Acciones analizador SLR(1)

Items LR(0)-acciones SLR (1):
I0:
[S S] [S iSeS] [S iS] [S a] acc(0,i)=d2 acc(0,a)=d3 acc(1,$)=ACP
I4:
[S iSeS] [S i S]
acc(4,e)=d5 acc(4,e)=r2 acc(4,$)=r2
I1: I2:
[S S] [S i SeS] [S i S] [S iSeS] [S iS] [S a]
I5:
[S iSeS] [S iSeS] [S iS] [S a] acc(5,i)=d2 acc(5,i)=d3 acc(6,e)=r1 acc(6,$)=r1 N S Siguiente $,e
acc(2,i)=d2 acc(2,a)=d3 acc(3,$)=r3 acc(3,e)=r3
I6:
[S iSeS ]
I3:
[S a ]
Tabla SLR sin conflictos

Resolucin conflicto: en estado 4, desplazamiento sobre else (prioridad para if ms anidado)
accin
i
0 1 2 3 4 5 6 d2
ir_a
$ S
1 ACP
a
d3
G:
1. 2. 3.
S iSeS S iS Sa
d2 r3 d5 d2 r1
d3 r3 r2 d3 r1

Gramtica de expresiones con sumas y productos:
E::=E+T | T T::=T*F | F F::=(E) | Id
Versin ambigua:
E:=E+E | E*E | (E) | Id
Dos ventajas:

Ms intuitiva Analizador ms rpido al evitar reducciones FId, TF
Deshacer la ambigedad con LR equivale aqu a fijar externamente la tabla de precedencia con analizador de precedencia
[E(E)] Conj. LR(0) I : [E E+ E]

2
1. 2. 3. 4. 5.
G
E E+E EE * E E(E) E Id EE
[EE * E] [E (E)] [E Id]
I6: I7: I8: I9:
[E(E )] [EE+ E] [EE * E] [EE+E] [EE+ E] [EE * E] [EE *E ] [EE+ E] [EE* E] [E(E) ]
I3: I4:
[EId] [EE+E] [EE+ E] [EE * E] [E(E)] [EId]
I0:
[EE] [EE+ E] [EE * E] [E (E)] [E Id] [EE] [EE+ E] [EE* E]
I5:
[EE *E] [EE+ E] [EE * E] [E(E)] [EId]
I1:
Conflictos en analizador SLR
1. 2. 3. 4. 5.
G
E E+E EE * E E(E) E Id EE Siguiente $,+,*,)
I7:
[EE+E]
acc(7,$)=r1 acc(7,+)=r1 acc(7,*)=r1 acc(7,))=r1 acc(7,+)=d4 acc(7,*)=d5 acc(8,$)=r2 acc(8,+)=r2 acc(8,*)=r2 acc(8,))=r2 acc(8,+)=d4 acc(8,*)=d5
[EE+ E] [EE * E]
N S
I8:
[EE*E]
[EE+ E] [EE * E]

Resolucin conflictos (desplaz/reduccin) sobre +,* {+,*} asociativos por la izquierda * ms 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)

accin
id
0 1 2 3 4 5 6 7 8 9 d3 d4 d3 r4 d3 d3 d4 r1 r2 r3 d5 d5 r2 r3 r4 d2 d2 d9 r1 r2 r3 r1 r2 r3 d5 d2 r4 r4 7 8
ir_a
* (
d2 ACP 6
E
1
G:
1. 2. 3. 4.
E E+E EE * E E(E) E Id

Gramtica de EQN, editor grfico de ecuaciones:
E::=EsubE supE E::=EsubE E::=EsupE E::={E } E::=c
Gramtica intencionadamente ambigua por doble motivo:
sub y sup tendrn conflictos desp/reduccin: se resuelve con asociatividad (a derecha)

Justificado por simplicidad en la gramtica y eficiencia en el anlisis
La primera produccin entra en conflicto desp/reduccin con la segunda Justificacin de produccin extra porque tiene sentido semntico:
b E sub a sup b representa E a , en lugar de Eab

Análisis Sintáctico: Conceptos y Tipos

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Análisis Sintáctico: Conceptos y Tipos

Uploaded by

Copyright:

Available Formats

Anlisis Sintctico

Cadena de Analizador Sintctico rbol Sintctico

Obtn otro componente lxico

Anlisis Sintctico. Procesadores de Lenguaje I

Ventajas de utilizar gramticas

Anlisis Sintctico. Procesadores de Lenguaje I

Analizador Sintctico, Tipos

Mtodos Universales: Cocke-Younger-Kasami y Earley

arriba Analizadores de Precedencia de Operador Analizadores LR(1)

Anlisis Sintctico. Procesadores de Lenguaje I

En general las gramticas sern LL y LR

Anlisis Sintctico. Procesadores de Lenguaje I

Gramtica: Expresin::= Expresin.*.Trmino | Expresin.+.Trmino | Trmino Trmino ::= Id | Nmero

Anlisis Sintctico. Procesadores de Lenguaje I

Anlisis Sintctico Descendente

Anlisis Sintctico. Procesadores de Lenguaje I

Anlisis Sintctico Ascendente

Analizadores Sintcticos, Problemas

Anlisis Sintctico. Procesadores de Lenguaje I

Mas de una opcin: A::= |

Ms de una opcin: A::= y es el pivote Problemas semnticos

Anlisis Sintctico. Procesadores de Lenguaje I

Anlisis Sintctico Predictivo

Disear bien la gramtica Eliminar la recursividad izquierda Factorizar por la izquierda

Anlisis Sintctico Predictivo: Descendente Recursivo

Anlisis Sintctico. Procesadores de Lenguaje I

Decide la produccin que utilizar analizando el smbolo de preanlisis,

Usa una produccin imitando al lado derecho

de otro token. Si el token no coincide entonces Error

Anlisis Sintctico Predictivo: Descendente Recursivo

Anlisis Sintctico. Procesadores de Lenguaje I

Anlisis Sintctico Predictivo, DEFINICIONES: PRIMERO

Anlisis Sintctico. Procesadores de Lenguaje I

Conjunto PRIMERO(X) para todos los smbolos gramaticales X

PRIMERO()={x | ( * x), (x T {}), (, *)}

Anlisis Sintctico Predictivo, DEFINICIONES: PRIMERO

Anlisis Sintctico. Procesadores de Lenguaje I

PRIMERO(E) = { (, Id } PRIMERO(T) = { (, Id } PRIMERO(F) = { (, Id } PRIMERO(E) = { +, }

PRIMERO(T.*.Id) = { (, Id } PRIMERO(Id.+.Id) = { Id } PRIMERO(Id) = { Id } PRIMERO(T) = { *, }

Anlisis Sintctico Predictivo, DEFINICIONES: SIGUIENTE

Anlisis Sintctico. Procesadores de Lenguaje I

Anlisis Sintctico Predictivo, DEFINICIONES: SIGUIENTE

Anlisis Sintctico. Procesadores de Lenguaje I

Anlisis Sintctico Predictivo: Condiciones

Anlisis Sintctico. Procesadores de Lenguaje I

Anlisis Sintctico Predictivo: Condiciones

Anlisis Sintctico. Procesadores de Lenguaje I

No puede haber conflictos PRIMERO/PRIMERO

No puede haber mltiples alternativas nulas

No puede haber conflictos PRIMERO/SIGUIENTE

disjunto de los conjuntos PRIMERO de todas sus alternativas

No puede haber entradas con definiciones mltiples en la tabla de anlisis

Anlisis Sintctico Predictivo: Tabla de Anlisis Sintctico

Anlisis Sintctico. Procesadores de Lenguaje I

Anlisis Sintctico Predictivo: Tabla de Anlisis Sintctico

Anlisis Sintctico. Procesadores de Lenguaje I

Anlisis Sintctico Predictivo No Recursivo; LL(1)

Anlisis Sintctico. Procesadores de Lenguaje I

Modelo de analizador sintctico predictivo no recursivo

Programa de Anlisis Sintctico Predictivo

Tabla de Anlisis Sintctico M

Anlisis Sintctico Predictivo No Recursivo; LL(1)

Anlisis Sintctico. Procesadores de Lenguaje I

PRIMERO(T..Id) = { (, Id } PRIMERO(Id.+.Id) = { Id } PRIMERO(Id) = { Id } PRIMERO(T) = { , }

Id+IdId E:=E+E | EE | (E) | Id

Cabecera(A) = { x | (A* x) (x T) (A N) ( N) ( )} ltimo(A) = { x | (A* x) (x T) (A N) ( ) ( N)}