Aula 7 Analise Sint Desc Fir Fol

Compiladores
Análise Sintática Descendente

First e Follow
02/10/19
Ms. Alex Andrade
15/10/2019 1
Análise Sintática
• Para o analisador sintático reconhecer se uma sentença está

correta, ele constrói uma árvore de derivação da sentença. Caso
a sentença não seja válida, ele emite uma mensagem de erro.
• Tipos de Analisadores Sintáticos:

– Descendente (Top-Down)
• A árvore começa pela raiz (símbolo inicial) indo para as folhas.
– Ascendente (Bottom -up) - (redutiva)
• Para o analisador ascendente a árvore começa pelas folhas, até
a raiz (símbolo inicial).
15/10/2019 2
Analise Sintática
• O analisador descendente: Em cada passo, um lado
esquerdo da produção é substituído por um lado
direito ( expansão )
S E + F
• Análise ascendente: Em cada passo, um lado direito

da produção é substituído por símbolo não-terminal
( redução ) à esquerda.
S E + F
15/10/2019 3
Analise Sintática Descendente
• Dos analisadores sintáticos descendentes, destacamos os
tipos:
– Os descendentes recursivos;
– E os LL(1).
• O descendente recursivo é bastante versátil, e é o método

mais adequado para um analisador sintático escrito
manualmente.
• O analisador LL(1) não é usado com muita frequência,

porem serve como uma aplicação de uso de pilha.
15/10/2019 4
Análise Sintática Descendente Recursiva
• Um método de ASDR consiste em um conjunto de
procedimentos, um para cada não-terminal da gramática;
• A execução começa com o (procedimento do símbolo)
não-terminal que representa o símbolo inicial da
gramática;
• A execução avança caractere por caractere a medida que
os símbolos são reconhecidos. A execução indica um erro
quando o símbolo não é reconhecido.
15/10/2019 5
15/10/2019 6
• Exemplo: aplicar ASDR com a entrada w=cad e a
gramática:
– S -> cAd
– A -> ab | a
Demonstrar a derivação em árvore e o retorno do erro em A->ab

15/10/2019 7
• Como visto no exemplo anterior:
– a construção da árvore gramatical começa de cima para baixo
usando o símbolo de partida;
– a medida em que são encontrados os símbolos não-terminais
eles são expandidos;
– da mesma forma são consumidos, uma um, e os símbolos
terminais encontrados;
– quando um símbolo terminal não tem correspondência com a
produção em uso ocorre o retrocesso - tentativa e erro.
• O número de derivações pode ser uma função
exponencial do tamanho da cadeia.
15/10/2019 8
• Durante a análise descendente, as variáveis First e Follow
nos ajudam a escolher qual produção deve ser usada, com
base no próximo símbolo de entrada;
• Dada uma entrada ‘a’ e o não-terminal ‘A’, deve-se saber
qual das produções alternativas A -> B1|B2|B3|... deriva a
sequência que inicia por ‘a’;
• Calculasse então os conjuntos de primeiros símbolos
produzidos por todas as alternativas na gramática, ou seja,
os conjuntos FIRST;
• Durante a recuperação de erros, os valores retornados por
FOLLOW podem ser usados como tokens de sincronismo.
15/10/2019 9
• First( X ) - é um conjunto de terminais que iniciam
as sentenças derivadas a partir de X .
XaY então First(X)={a, }

XbZ então First(X)={a, b }
XW
W cU então First(X)={a, b, c }
Xd então First(X)={a, b, c, d }
15/10/2019 10
• First(X) - é um conjunto de terminais que iniciam as
sentenças derivadas a partir de X.
• Se XЄ, então Є faz parte deste conjunto, isto é,

First(X) ={Є, . . .}
Obs- Є não é um terminal !
15/10/2019 11
• Lembrando que, os símbolos terminais serão representados
por:
 Letras minúsculas do inicio do alfabeto como a,b,c,...

 Operadores + , - , * , / , =
 Símbolos delimitadores , ; . ( ) [ ]
 Dígitos 0,1,2...9
 Palavras chaves: if , else, then, begin , for, while, end ....
• Os símbolos terminais também serão representados por:

Usaremos negrito em um terminal que não foi citado em
nenhuma regra do slide anterior.
15/10/2019 12
Ex - A gramática
exp  exp soma termo | termo

soma  +| -
termo  termo mult fator | fator
mult  *
fator  ( exp ) | número
Terminais: + - * ( ) número
15/10/2019 13
Ex - A gramática
declaração  if-decl | outra
if-decl  if (exp) declaração else-parte
else-parte  else declaração | Є
exp  0 | 1
• Terminais: 0 1 ( ) outra if else
15/10/2019 14
Ex - A gramática
declaração  if-decl | outra
if-decl  if (exp) declaração else-parte
else-parte  else declaração | Є
exp  0 | 1
Obs: Por definição:

First(else-parte)={else } First(exp)={0,1}
First(if-decl)={if } First(declaração)={outra,if}
15/10/2019 15
Ex - Achar os First( ) , da gramática

soma  +| -
mult  *
15/10/2019 16
podemos escrever novamente
Inicialisar todos First(X) com vazio

(1) exp  exp soma termo
(2) exp  termo
No algoritmo temos:
(3) soma  + Para cada escolha de produção A  X1X2 . . .Xn
(4) soma  - faça
(5) termo  termo mult fator acrescente First(X1) em First(A)
(6) termo  fator A regra 1 First(exp )  First(exp)
(7) mult  * A regra 2 First(termo)  First(exp)
Não temos ainda nenhuma informação
(8) fator  ( exp )
(9) fator  número
15/10/2019 17
(1) exp  exp soma termo Regra 3 e 4 First(soma)= {+, -, . . .}

(2) exp  termo
(3) soma  + A regra 6 First(fator)  First(termo)
(4) soma  - A regra 5 e 6 não temos alterações
(5) termo  termo mult fator A regra 7 First(mult)={ * , . . .}
(6) termo  fator A regra 8 First(fator)= { (, . . . }
(7) mult  * A regra 9 First(fator)= { (, número, . . .}
(9) fator  número Precisamos faz uma nova passada, pois os
conjuntos foram alterados.
15/10/2019 18

(2) exp  termo Por enquanto temos
First(soma)= {+, -, . . .}
(3) soma  + First(mult) = {*, . . .}
(4) soma  - First(fator) = { ( , número, . . }
(5) termo  termo mult fator A regra 6
(6) termo  fator First(termo)={( , número, . .}
(7) mult  *
(8) fator  ( exp ) Precisamos faz uma nova passada, pois os
conjuntos foram alterados.
15/10/2019 19

(2) exp  termo Por enquanto temos
First(soma)= {+, -, . . .}
(3) soma  + First(mult) = {*, . . .}
(4) soma  - First(fator) = { ( , número, . . }
(5) termo  termo mult fator First(termo)={( , número, . .}
(6) termo  fator A regra 2
(7) mult  * First(exp)={( , número, . .}
(8) fator  ( exp ) Precisamos faz uma nova passada, pois os

(9) fator  número conjuntos foram alterados.
15/10/2019 20

(2) exp  termo Não teremos mais alterações:
Final do algoritmo.
(3) soma  +
(4) soma  -
First(soma)= {+, - }
(5) termo  termo mult fator First(mult) = { * }
(6) termo  fator First(fator) = { ( , número }
(7) mult  * First(termo)={ ( , número }
First(exp)={( , número}
15/10/2019 21
Regra Passada 1 Passada 2 Passada 3
exp exp soma termo
exp termo First(exp)={( , número}
soma + First(soma)={+}
soma - First(soma)={+, - }
termo termo mult fator
termo fator First(termo)={(, número}
mult * First(mult)={*}
fator ( exp ) First(fator)={( }
fator número First(fator)={(, número}
15/10/2019 22
• Follow(X) é um conjunto de terminais que podem aparecer
imediatamente à direita de X.
Ex - Considere a gramática
S ABc|BAc
A a|aA
B  b|bB
Então: como S  ABc então c é um elemento de Follow(B).

como S  BAc então c é um elemento de Follow(A).
como S  ABc  AbBc então b é um elemento de Follow(A).
como S  BAc  BaAc então a é um elemento de Follow(B).
15/10/2019 23
• Follow(X) é um conjunto de terminais que podem

aparecer imediatamente à direita de X.
Obs -
X é um não-terminal .
Є não faz parte de Follow(X).
Daremos em seguida uma definição mais formal.
15/10/2019 24
Definição:
• Dado um não-terminal X, o conjunto Follow(X), composto
por terminais e possivelmente o $, é definido como segue:
I) Se X for o símbolo inicial, então $ pertence a Follow(X)

II) Se houver uma produção YAXZ, então First(Z)-{ Є } está
contido no Follow(X).
III) Se houver uma produção Y AXZ tal que Z * Є, então
Follow(Y)  Follow(X)
15/10/2019 25
Observe o item (II) da definição
Se houver uma produção Y AXZ, então First(Z)-{ Є }

está contido no Follow(X).
• Se temos Y AXZ , seja a ( a ≠ Є ) elemento de

First(Z) então o elemento a estará após algumas
derivações à direita de X, por conseguinte, no
Follow(X).
15/10/2019 26
Observe o item (III) da definição
Se houver uma produção Y AXZ tal que Z *Є, então

Follow(Y) Follow(X)
Suponha que a seja um elemento de Follow(Y), isto é, ?Ya? então

?Ya?  ?AXZa?  . . .  ?AXЄa?  ?AXa?
Então a é um elemento do Follow(X)
Follow(Y)  Follow(X)
15/10/2019 27
Observe de maneira idêntica
Se temos uma produção Y  X

Suponha que a seja um elemento de Follow(Y), isto é, ?Ya?
Então ?Ya?  ?Xa? , logo a é um elemento de Follow(X), então
Follow(Y) Follow(X)
15/10/2019 28
Observe que:
Se temos uma produção Y  a
Esta produção não tem nenhuma informação sobre

o Follow(Y) já que não tem não-terminais à direita
15/10/2019 29
Ex - A gramática

soma  +| -
mult  *
15/10/2019 30
A gramática do Ex 1, podemos escrever novamente:

(2) exp  termo
(3) soma  +
(4) soma  -
(5) termo  termo mult fator
(6) Termo  fator
(7) mult  *
(3),(4),(7) e (9) não tem nenhuma informação sobre Follow

15/10/2019 31
• Exemplo: A partir da gramática a seguir:
• S > cAd
• A>b|a
• Calcule:
– First(S): { }
– First(A):{ }
– Follow(S): { }
– Follow(A): { }
15/10/2019 32
Um “pequeno” roteiro para achar os Follow(X)
1º Passo – Reconhecer os terminais

2º Passo – Separar as produções
3º Passo – Destacar as produções que não tem nenhuma informação
4º Passo – Inicializar todos Follow(X) com vazio
5º Passo – Para o símbolo inicial da gramática , temos Follow(X)={$, }
6º Passo – Verifique se tem produção do tipo X  Ya, pois conforme
a definição de Follow de Y temos Follow(Y)={a, }
7º Passo – Aplique as definições (II) e (III) para todas as produções
conforme o caso.(*)
8º Passo – Se houve alguma alteração vá para passo 7º senão final.
(*) No caso de uma nova passagem refaça apenas a definição (III), pois os
First(X) estão fixos
15/10/2019 33
Ex 1- Achar os Follow( ) , da gramática

soma  +| -
mult  *
15/10/2019 34
podemos reescrever First(soma)= {+, - }
First(mult) = { * }
First(fator) = { ( , número }
(1) exp  exp soma termo First(termo)={ ( , número }
(2) exp  termo First(exp)={( , número}
(3) soma  +
Inicialisar todos Follow(X) com vazio
(4) soma  - Follow(exp)={ $ , . . .}
A regras 3,4,7 e 9 não tem não-
(6) termo  fator terminais à direita, nenhuma
(7) mult  * informação.
Por II da definição
(8) fator  ( exp ) First(soma)  Follow(exp)
(9) fator  número First(termo)  Follow(soma) logo
Follow(exp)={ $, +, -, . . .}
Follow(soma)={( , número, . . .}
15/10/2019 35
First(soma)= {+, - }
(1) exp  exp soma termo First(mult) = { * }
(2) exp  termo First(termo)={ ( , número }
(3) soma  + First(exp)={( , número}
(4) soma  - Por III da definição
(5) termo  termo mult fator Follow(exp)  Follow(termo)
Follow(termo)={ $, +, -, . . .}
(6) termo  fator
(7) mult  * A regra 2, tem mesma informação
(8) fator  ( exp ) anterior.
A regra 5, temos
 por II da definição
(9) fator  número First(mult)  Follow(termo)
First(fator) Follow(mult)
Follow(termo)={ $, + , - , *, . . . }
Follow(mult)={ ( , número, . . .}
15/10/2019 36
(1) exp  exp soma termo First(soma)= {+, - }
(2) exp  termo First(mult) = { * }
(3) soma  + First(termo)={ ( , número }
First(exp)={( , número}
(4) soma  -
Já temos
(6) termo  fator Follow(termo)={ $, + , - , *, . . . }
(7) mult  *
A regra 5, temos por III da definição
(8) fator  ( exp ) Follow(termo)  Follow(fator)
Follow(fator)={ $, +, - , * , . . . }
A regra 6, tem a mesma informação
15/10/2019 37
(1) exp  exp soma termo First(soma)= {+, - }
(2) exp  termo First(mult) = { * }
(3) soma  + First(termo)={ ( , número }
(4) soma  - First(exp)={( , número}

Já temos
(6) termo  fator Follow(exp)={ $, +, -, . . .}
(7) mult  *
A regra 8, temos por definição
(8) fator  ( exp ) Follow(exp)={ $, +, -, ). . .}
15/10/2019 38
(1) exp  exp soma termo Por enquanto temos
(2) exp  termo Follow(exp)={ $, +, -, ). . .}
Follow(soma)={( , número, . . .}
(3) soma  + Follow(termo)={ $, + , - , *, . . . }
Follow(mult)={ ( , número, . . .}
(4) soma  -
(5) termo  termo mult fator Na segunda passada :
(6) termo  fator
A regra 1, temos por III
(7) mult  * Follow(exp)  Follow(termo)
(8) fator  ( exp ) Follow(termo)={ $, +, -, *, ). . .}
(9) fator  número A regra 5, temos por III

Follow(termo)  Follow(fator)
Follow(fator)={ $, +, -, *, ). . .}
15/10/2019 39
Na terceira passada, não teremos
(2) exp  termo mais alterações, fim do algoritmo.
(3) soma  + Follow(exp)={ $, +, -, ) }
(4) soma  - Follow(soma)={( , número }
Follow(termo)={ $, + , - , *, ) }
(5) termo  termo mult fator Follow(mult)={ ( , número }
(6) termo  fator Follow(fator)={ $, +, -, *, ) }
(7) mult  *
15/10/2019 40
First(soma)= {+, - } First(mult) = { * } First(fator) = { ( , número }
First(termo)={ ( , número } First(exp)={( , número}
Regra Passada 1 Passada 2

exp exp soma termo Follow(exp)={ $, +, - } Follow(termo)={$. + , - , )}
Follow(soma)={ ( , número }
Follow(termo)={$, +, -}
exp termo
termo termo mult fator Follow(termo)={$, +, - , * }
Follow(mult)={( , número} Follow(fator)={$, +, - , * , ) }
Follow(fator)={$, + , -, * }
termo fator
fator ( exp ) Follow(exp)={$. + , - , )}
15/10/2019 41
S →XYZ
X→aXb | ε
Y →cYZcX | d
Z →eZYe | f
First(X) = {a, ε} Follow(X) = {c, d, b, e, f}

First(Y) = {c, d} Follow(Y) = {e, f}
First(Z) = {e, f} Follow(Z) = {$, c, d}
First(S) = {a, c, d} Follow(S) = {$}
15/10/2019 42
Exercício: Calcule os conjuntos Follow e First para a seguinte

gramática:
E-> T E'
E’ -> + T E' | ε
T -> F T'
T’ -> * F T' | ε
F -> ( E ) | id
15/10/2019 43
• Só terminais entram em First e Follow.
• O algoritmo de cálculo de First(α):

• É trivial quando α é um terminal t;
• varre as produções X →tω quando α é um não-terminal X;
• é chato quando o início de ume derivação de X deriva em ε;
• Inclui ε apenas quando X pode derivar em ε.
• O algoritmo de cálculo de Follow(X):

• É reservado aos não-terminais X;
• Inclui o $ em alguns casos triviais (X == é o start S);
• Varre as produções onde X aparece à direita (A → ωXω’);
• É chato quando X aparece no fim (ou logo antes de algo que
deriva em ε)– NUNCA inclui ε.
15/10/2019 44
Analise Sintática Descendente LL(1)
• Os analisadores sintáticos preditivos podem ser construídos

para uma classe de gramática chamada LL(1).
– O primeiro L refere-se à maneira como os caracteres de
entrada são lidos -> da esquerda para a direita
– O segundo L indica que há uma derivação mais à
esquerda
– O ‘1’ indica que um símbolo de entrada é visto na
entrada, um símbolo por vez;
15/10/2019 45
• Uma gramática G é LL(1) se qualquer regra
A  B|C
são duas produções distintas de G, tal que:
– Dado um terminal 'a', ambos B e C não derivam uma
mesma string que inicia com 'a'.
– No máximo um entre B e C podem derivar a string vazia,
ou seja, B  ε ou C  ε.
– Se C  ε em zero ou mais passos, então Follow(A) não
contém nenhum First(B). O mesmo caso ocorre para B ε
em zero ou mais passos.
15/10/2019 46
• Utiliza uma pilha explícita
– Facilita e agiliza a visualização as ações do analisador sintático
LL(1)
15/10/2019 47
• Tanto o analisador sintático descendente recursivo como o
LL(1), é necessário o cálculo dos conjuntos First e Follow.
• Os analisadores Descendente (Top-Down) é necessário que

a gramática não tenha recursividade à esquerda nem
prefixo em comum, caso haja temos que eliminar.
– Quando temos uma produção no formato:
EE+T|T
– Diremos que esta gramática é recursiva à esquerda.
15/10/2019 48
Eliminando Prefixo em Comum
• Quando duas a mais escolhas de regras gramaticais
compartilham uma cadeia de prefixo comum, é necessário
uma fatoração à esquerda.
Ex A  aB
A  aC
Ex decl-seqüência  decl ; decl-seqüência
decl-seqüência  decl
decl  s
• Um analisador sintático LL(1) não pode diferenciar entre as
escolhas de produções desse tipo.
15/10/2019 49
A solução nesses casos simples é fatorar e reescrever
A  B A  A’

A  C A’ B|C
A   B| C
A   A’ A’  B|C
15/10/2019 50
Ex decl-seqüência  decl ; decl-seqüência

decl-seqüência  decl
decl  s
Ex decl-seqüência  decl decl-seq’

decl-seq’  ; decl-seqüência | Є
decl  s
15/10/2019 51
Eliminando Recursividade à Esquerda
• Quando temos uma produção no formato: E  E + T | T
– Diremos que esta gramática é recursiva à esquerda.
• A remoção da recursão à esquerda é efetuada
reescrevendo-se a regra gramatical dada como duas regras,
a repetições será obtida por meio da recursão à direita,
criando um novo não-terminal.
Ex E  Ea | b  E  bE’
E’  aE’ | Є
E  bE’ E’  aE’|Є
15/10/2019 52
Ex 1 -
Achar a tabela de análise sintática LL(1) da gramática

soma  +| -
mult  *
É recursiva à esquerda.
15/10/2019 53
• Teremos que eliminar as recursividades à esquerda para
construção da tabela de análise sintática LL(1).
• Ao introduzir novas variáveis auxiliares: exp’ e termo’,
teremos que achar os novos conjuntos First(X) e
Follow(X).
• Gramática equivalente:
exp  termo exp’
exp’  soma termo exp’ |Є Exercício: Achar o First(X) e
soma  +| - Follow(X) desta gramática,
termo  fator termo’ apresentamos somente a
termo’  mult fator termo’ | Є resposta (façam os passos)
no próximo slide .
mult  *
15/10/2019 54
First(exp)={ (, número} Follow(exp)={$, )}
First(exp’)={ +,-, Є } Follow(exp’)={$, )}
First(soma)={+, -} Follow(soma)={( , número }
First(termo)={ (, número} Follow(termo)={$, ) , + , - }
First(termo’)={ *, Є} Follow(termo’)={$, ) , + , - }
First(mult)={ * } Follow(mult)={ ( , número}
First(fator)={ ( , número } Follow(fator)={$, ) , + , - , *}
15/10/2019 55
• Utilizaremos as seguintes simplificações
exp = E exp’=E’ termo=T termo’=T’
mult=M soma=S fator=F número=n
• Gramática equivalente:
E  TE’
E’  STE’ |Є
S  +| -
T  FT’
T’  MFT’ | Є
M  *
F (E)|n
15/10/2019 56
• Construção de tabelas de análise sintática LL(1)
1º passo: listar dos terminais e não-terminais
T={ ( , n, ) , + , - , * } N={ E, E’ , T, T’ , M , S, F }
2º passo: construir a 1ª linha e 1ª coluna da tabela
M(N,T) ( n ) + - * $
E
E’
S
T
T’
M
F
15/10/2019 57
3º Passo: achar as células da matriz (tabela) M(N,T)
usando os First( ) e Follow( )
M(N,T) ( n ) + - * $
E
E’
As regras
S serão
T colocadas nas
células
T’ Algumas células
ficarão vazias
M
F
15/10/2019 58
E  TE’
E’  STE’ |Є
S  +| -
T  FT’
T’  MFT’ | Є
M  *
F (E)|n Temos E T E’ e First(T)={ ( , n}
( n ) + - * $
E ET E’ ET E’
E’
S
T
T’
M
F
15/10/2019 59
E  TE’
E’  STE’ |Є
S  +| -
T  FT’
T’  MFT’ | Є
M  *
F (E)|n Temos E’ STE’ e First(S)={ +, -}
( n ) + - * $
E’ E’STE’ E’STE’
S
T
T’
M
F
15/10/2019 60
E  TE’
E’  STE’ |Є
S  +| -
T  FT’
T’  MFT’ | Є
M  *
F (E)|n Temos E’ Є e Follow(E’)={ $ , ) }
( n ) + - * $
E’ E’ Є E’STE’ E’STE’ E’ Є
S
T
T’
M
F
15/10/2019 61
E  TE’
E’  STE’ |Є
S  +| -
T  FT’
T’  MFT’ | Є
M  *
F (E)|n Temos S + | -
( n ) + - * $
S S + S -
T
T’
M
F
15/10/2019 62
E  TE’
E’  STE’ |Є
S  +| -
T  FT’
T’  MFT’ | Є
M  * Temos T FT’ First(F)={( , n}
F (E)|n
( n ) + - * $
S S + S -
T TFT’ TFT’
T’
M
F
15/10/2019 63
E  TE’
E’  STE’ |Є
S  +| -
T  FT’
T’  MFT’ | Є
M  * Temos T’ MFT’ First(M)={ * }
F (E)|n
( n ) + - * $
S S + S -
T’ T’MFT’
M
F
15/10/2019 64
E  TE’
E’  STE’ |Є
S  +| -
T  FT’
T’  MFT’ | Є
M  *
F (E)|n Temos T’ Є Follow(T’)={ $, ) + , - }
( n ) + - * $
S S + S -
T’ T’ Є T’ Є T’ Є T’MFT’ T’ Є
M
F
15/10/2019 65
E  TE’
E’  STE’ |Є
S  +| -
T  FT’
T’  MFT’ | Є
M  *
F (E)|n Temos M *
( n ) + - * $
S S + S -
T’ T’ Є T’ Є T’ Є T’MFT’ T’ Є
M M *
F
15/10/2019 66
E  TE’
E’  STE’ |Є
S  +| -
T  FT’
T’  MFT’ | Є
M  *
F (E)|n Temos F ( E )
( n ) + - * $
S S + S -
T’ T’ Є T’ Є T’ Є T’MFT’ T’ Є
M M *
F F (E)
15/10/2019 67
• Se, depois de realizar esses passos, não houver
E  TE’ produção alguma em M[N,T], então defina M[N,T]
E’  STE’ |Є como 'ERRO!’.
S  +| - • Uma G é LL(1) se a tabela de AS LL(1) associada tiver
T  FT’ no máximo uma produção em cada célula.
T’  MFT’ | Є • Uma G LL(1) não pode ser ambigua.
M  *
F (E)|n Temos F n
( n ) + - * $
S S + S -
T’ T’ Є T’ Є T’ Є T’MFT’ T’ Є
M M *
F F (E) F n
15/10/2019 68
Ex : Faça todos movimentos do analisador sintático

LL(1), da gramática anterior, para a sentença 5*(8+7).
15/10/2019 69
Pilha Entrada Ação
$E 5*(8+7) $ E  TE’
$E’ T 5*(8+7) $ T FT’
$E’ T’ F 5*(8+7) $ F n
$E’ T’ n 5*(8+7) $ casamento
$E’ T’ *(8+7)$ T’  MFT’
$E’ T’ F M *(8+7)$ M *
$E’ T’ F * *(8+7)$ casamento
$E’ T’ F (8+7)$ F  (E)
$E’ T’ ) E ( (8+7)$ casamento
$E’ T’ ) E 8+7)$ E  TE’
$E’ T’ ) E’ T 8+7)$ T  FT’
( n ) + - * $
E ETE’ ETE’
E’ E’Є E’STE’ E’STE’ E’Є
S S+ S-
T’ T’Є T’Є T’Є T’MFT’ T’Є
M M*
F F(E) Fn
15/10/2019 70
$E’ T’ ) E’ T 8+7) $ T  FT’
$E’ T’ ) E’ T’ F 8+7) $ F n
$E’ T’ ) E’ T’ n 8+7) $ casamento
$E’ T’ ) E’ T’ +7) $ T’Є
$E’ T’ ) E’ +7)$ E’  STE’
$E’ T’ ) E’ T S +7)$ S +
$E’ T’ ) E’ T + +7)$ casamento
$E’ T’ ) E’ T 7)$ T  FT’
$E’ T’ ) E’ T’ F 7)$ Fn
$E’ T’ ) E’ T’ n 7)$ casamento
$E’ T’ ) E’ T’ )$ T’Є
( n ) + - * $
S S+ S-
M M*
F F(E) Fn
15/10/2019 71
$E’ T’ ) E’ T’ )$ T’Є
$E’ T’ ) E’ )$ E’Є
$E’ T’ ) )$ casamento
$E’ T’ $ T’Є
$E’ $ E’Є
$ $ ACEITA!
( n ) + - * $
S S+ S-
M M*
F F(E) Fn
15/10/2019 72
$E’ T’ ) E’ T’ )$ T’Є
$E’ T’ ) E’ )$ E’Є
$E’ T’ $ T’Є
$E’ $ E’Є
$ $ ACEITA!
Se no topo da pilha estivesse E’ e o terminal da entrada fosse * , TEMOS

UM ERRO, isto acontece em qualquer célula da tabela abaixo que não
contenha elemento. ( n ) + - * $
S S+ S-
M M*
F F(E) Fn
15/10/2019 73
Entrada: id v id & id
15/10/2019 74
15/10/2019 75
15/10/2019 76
15/10/2019 77
( n ) + - * $
S S+ S-
M M*
F F(E) Fn
Nosso objetivo sem seguida é colocar nas células vazias, da tabela

acima, uma indicação de recuperação de possíveis erros.
15/10/2019 78
Recuperação de erros
 A resposta de um analisador sintático a erros é frequentemente um
fator crítico em um compilador.
 O mínimo requerido é que um analisador sintático determine se um
programa está sintaticamente correto, ou não.
 Um analisador sintático que efetua apenas essa tarefa é
denominador de reconhecedor.
 É fundamental que o compilador prossiga na tradução, após a
detecção de erros, de modo que o texto seja totalmente analisado.
 Tenta-se colocar o analisador em um estado tal que o restante da
sentença possa ser analisada.
 Dependendo de como o processo é executado, erros falsos podem
ser gerados a partir de um erro reparado.
15/10/2019 79
 Em geral o analisador sintático tenta dar uma mensagem
significativa de erro, pelo menos para o primeiro erro
encontrado, e também o possível local do erro.
 Alguns analisadores podem até tentar alguma forma de
correção de erros. Na maioria das vezes, isso se limita aos
casos mais simples, como por exemplo, falta de ponto e
virgula ou parênteses ( delimitadores ).
modo pânico
recuperação local
15/10/2019 80
Modo pânico:
• Na ocorrência de um erro, o analisador despreza

símbolos, tenta encontrar o token de sincronização.
• No pior caso, ele pode consumir todo o resto do
programa.
• Simplicidade na implementação.
• Nunca leva a um laço infinito, durante a recuperação de
erros.
• Não é 100% satisfatório.
15/10/2019 81
Recuperação local :
• Na ocorrência de um erro, o analisador tenta

recuperar o erro, fazendo alterações : desprezando o
token atual ou substituindo por outro token ou
inserindo um novo token.
• Implementação mais complexa.
• As alterações em geral se limita aos casos mais simples.
• Na inserção pode provocar um laço infinito.
15/10/2019 82
• A recuperação de erros de modo pânico para analisadores

sintáticos LL(1), pode ser implementada.
• Dado um não-terminal A no topo da pilha e x o terminal de

entrada corrente:
1. Se x=$ ou x  Follow(A)  retirar A da pilha - “SAI”.
2. Se x  $ e x  First(A)  Follow(A)  Retirar sucessivamente
treminais da entrada até encontrar um terminal de
sincronização – “VARRE”.
15/10/2019 83
• Dado um não-terminal A no topo da pilha e x o terminal de
entrada corrente:
1. Se x=$ ou x  Follow(A)  retirar A da pilha - “SAI”.
2. Se x  $ e x  First(A)  Follow(A)  Retirar sucessivamente
treminais da entrada até encontrar um terminal de
sincronização – “VARRE”.

$....A x . . . .$ Célula M(A,x) vazia
sai varre
15/10/2019 84
1) Se x  $ ou x  Follow(A)  sai
2)Se x  $ e x  First(A)  Follow(A)  varre
( n ) + - * $
E’ varre E’Є E’STE’ E’STE’ E’Є
S S+ S-
M M*
F F(E) Fn
1- A=E’ e x=( (  First(E’)  Follow(E’)

First(E)={ (, n} Follow(E)={$, )}
First(E’)={ +,-, Є } Follow(E’)={$, )}
First(S)={+, -} Follow(S)={( , n }
First(T)={ (, n} Follow(T)={$, ) , + , - }
First(T’)={ *, Є} Follow(T’)={$, ) , + , - }
First(M)={ * } Follow(M)={ ( , n}
First(F)={ ( , n } Follow(F’)={$, ) , + , - , *}
15/10/2019 85
( n ) + - * $
S sai S+ S-
M M*
F F(E) Fn
2- A=S e x=( (  Follow(S)

First(E’)={ +,-, Є } Follow(E’)={$, )}
First(T)={ (, n} Follow(T)={$, ) , + , - }
First(T’)={ *, Є} Follow(T’)={$, ) , + , - }
First(F)={ ( , n } Follow(F’)={$, ) , + , - , *}
15/10/2019 86
( n ) + - * $
S sai S+ S-
T’ varre T’Є T’Є T’Є T’MFT’ T’Є
M M*
F F(E) Fn
3- A=T’ e x=( (  First(T’)  Follow(T’)

First(E’)={ +,-, Є } Follow(E’)={$, )}
First(T)={ (, n} Follow(T)={$, ) , + , - }
First(T’)={ *, Є} Follow(T’)={$, ) , + , - }
First(F)={ ( , n } Follow(F’)={$, ) , + , - , *}
15/10/2019 87
( n ) + - * $
S sai S+ S-
T’ varre T’Є T’Є T’Є T’MFT’ T’Є
M sai M*
F F(E) Fn
4- A=M e x=( ( Follow(M)

First(E’)={ +,-, Є } Follow(E’)={$, )}
First(T)={ (, n} Follow(T)={$, ) , + , - }
First(T’)={ *, Є} Follow(T’)={$, ) , + , - }
First(F)={ ( , n } Follow(F’)={$, ) , + , - , *}
15/10/2019 88
( n ) + - * $
E’ varre varre E’Є E’STE’ E’STE’ E’Є
S sai sai S+ S-
T’ varre varre T’Є T’Є T’Є T’MFT’ T’Є
M sai sai M*
F F(E) Fn
5- A=E’ e x=n n  First(E’)  Follow(E’)

First(E’)={ +,-, Є } Follow(E’)={$, )}
6- A=S e x=n n  Follow(S) First(S)={+, -} Follow(S)={( , n }
First(T)={ (, n} Follow(T)={$, ) , + , - }
First(T’)={ *, Є} Follow(T’)={$, ) , + , - }
7- A=T’ e x=n n  First(T’)  Follow(T’) First(M)={ * } Follow(M)={ ( , n}
First(F)={ ( , n } Follow(F’)={$, ) , + , - , *}
8- A=M e x=n n  Follow(M)
15/10/2019 89
( n ) + - * $
E ETE’ ETE’ sai varre varre varre sai
E’ varre varre E’Є E’STE’ E’STE’ varre E’Є
S sai sai varre S+ S- varre sai
T TFT’ TFT’ sai sai sai varre sai
T’ varre varre T’Є T’Є T’Є T’MFT’ T’Є
M sai sai varre varre varre M* sai
F F(E) Fn sai sai sai sai sai
First(E’)={ +,-, Є } Follow(E’)={$, )}
First(T)={ (, n} Follow(T)={$, ) , + , - }
First(T’)={ *, Є} Follow(T’)={$, ) , + , - }
First(F)={ ( , n } Follow(F’)={$, ) , + , - , *}
15/10/2019 90
Recuperação de erros LL(1)
Ex : Faça todos movimentos do analisador sintático

LL(1), da gramática anterior, para a sentença (2+*),
fazendo recuperação de erros.
15/10/2019 91
$E (2+*) $ E  TE’
$E’ T (2+*) $ T FT’
$E’ T’ F (2+*) $ F (E)
$E’ T’ ) E ( (2+*) $ casamento
$E’ T’ ) E 2+*)$ E  TE’
$E’ T’ ) E’ T 2+*)$ TFT’
$E’ T’ ) E’ T’ F 2+*)$ Fn
$E’ T’ ) E’ T’ n 2+*)$ casamento
$E’ T’ ) E’ T’ +*)$ T’  Є
$E’ T’ ) E’ +*)$ E’  STE’
$E’ T’ ) E’ T S +*)$ S+
( n ) + - * $
E ETE’ ETE’ SAI VARRE VARRE VARRE SAI
E’ VARRE VARRE E’Є E’STE’ E’STE’ VARRE E’Є
S SAI SAI VARRE S+ S- VARRE SAI
T TFT’ TFT’ SAI SAI SAI VARRE SAI
T’ VARRE VARRE T’Є T’Є T’Є T’MFT’ T’Є
M SAI SAI VARRE VARRE VARRE M* SAI
F F(E) Fn SAI SAI SAI SAI SAI
15/10/2019 92
$E’ T’ ) E’ T S +*)$ S+
$E’ T’ ) E’ T + +*)$ casamento
$E’ T’ ) E’ T *) $ ERRO (VARRE)
$E’ T’ ) E’ T )$ ERRO ( SAI )
$E’ T’ ) E’ )$ E’ Є
$E’ T’ $ T’  Є
$E’ $ E’  Є
$ $ Existem erros!
( n ) + - * $
E ETE’ ETE’ SAI VARRE VARRE VARRE SAI
E’ VARRE VARRE E’Є E’STE’ E’STE’ VARRE E’Є
S SAI SAI VARRE S+ S- VARRE SAI
T TFT’ TFT’ SAI SAI SAI VARRE SAI
T’ VARRE VARRE T’Є T’Є T’Є T’MFT’ T’Є
M SAI SAI VARRE VARRE VARRE M* SAI
F F(E) Fn SAI SAI SAI SAI SAI
15/10/2019 93
15/10/2019 94

Aula 7 Analise Sint Desc Fir Fol

Transféré par

Informations du document

Description originale:

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Aula 7 Analise Sint Desc Fir Fol

Transféré par

Droits d'auteur :

Formats disponibles

Compiladores

Análise Sintática Descendente

• Para o analisador sintático reconhecer se uma sentença está

• Tipos de Analisadores Sintáticos:

• Análise ascendente: Em cada passo, um lado direito

• O descendente recursivo é bastante versátil, e é o método

• O analisador LL(1) não é usado com muita frequência,

Demonstrar a derivação em árvore e o retorno do erro em A->ab

XaY então First(X)={a, }

• Se XЄ, então Є faz parte deste conjunto, isto é,

Obs- Є não é um terminal !

 Letras minúsculas do inicio do alfabeto como a,b,c,...

• Os símbolos terminais também serão representados por:

exp  exp soma termo | termo

• Terminais: 0 1 ( ) outra if else

Obs: Por definição:

exp  exp soma termo | termo

Inicialisar todos First(X) com vazio

(1) exp  exp soma termo Regra 3 e 4 First(soma)= {+, -, . . .}

(1) exp  exp soma termo

(1) exp  exp soma termo

(8) fator  ( exp ) Precisamos faz uma nova passada, pois os

(1) exp  exp soma termo

fator número First(fator)={(, número}

Então: como S  ABc então c é um elemento de Follow(B).

• Follow(X) é um conjunto de terminais que podem

I) Se X for o símbolo inicial, então $ pertence a Follow(X)

Se houver uma produção Y AXZ, então First(Z)-{ Є }

• Se temos Y AXZ , seja a ( a ≠ Є ) elemento de

Se houver uma produção Y AXZ tal que Z *Є, então

Suponha que a seja um elemento de Follow(Y), isto é, ?Ya? então

Se temos uma produção Y  X

Se temos uma produção Y  a

Esta produção não tem nenhuma informação sobre

exp  exp soma termo | termo

(1) exp  exp soma termo

(3),(4),(7) e (9) não tem nenhuma informação sobre Follow

1º Passo – Reconhecer os terminais

exp  exp soma termo | termo

(5) termo  termo mult fator

(9) fator  número A regra 5, temos por III

Regra Passada 1 Passada 2

First(X) = {a, ε} Follow(X) = {c, d, b, e, f}

Exercício: Calcule os conjuntos Follow e First para a seguinte

• O algoritmo de cálculo de First(α):

• O algoritmo de cálculo de Follow(X):

• Os analisadores sintáticos preditivos podem ser construídos

• Os analisadores Descendente (Top-Down) é necessário que

A solução nesses casos simples é fatorar e reescrever

Ex decl-seqüência  decl ; decl-seqüência

Ex decl-seqüência  decl decl-seq’

exp  exp soma termo | termo

Ex : Faça todos movimentos do analisador sintático

Se no topo da pilha estivesse E’ e o terminal da entrada fosse * , TEMOS

E’ E’Є E’STE’ E’STE’ E’Є

T’ T’Є T’Є T’Є T’MFT’ T’Є

Nosso objetivo sem seguida é colocar nas células vazias, da tabela

• Na ocorrência de um erro, o analisador despreza

• Na ocorrência de um erro, o analisador tenta

• A recuperação de erros de modo pânico para analisadores

• Dado um não-terminal A no topo da pilha e x o terminal de

Pilha Entrada Ação

1- A=E’ e x=( (  First(E’)  Follow(E’)