compiladores achei na net

1Compiladores

Anlise sinttica (3)Anlise LL(1) com tabela preditiva.

proc First(: string of symbols)Repeat {

// seja X1 X2 X3 Xnif X1 T then // caso simples onde X1 um terminal

First() := {X1}else { // X1 um no-terminal

First() = First{X1} \ {};for (i=1 ; i* )

then First() := First() {}} until no change in any First()

proc Follow(B N)Follow(S) := {$};Repeat

foreach p P do {// Varre as produescase p == A B {

Follow(B) := Follow(B) First()\{};if First() then Follow(B) := Follow(B) Follow(A);

end}case p == A B

Follow(B) := Follow(B) Follow(A);}until no change in any Follow(N)

Exemplo First/FollowS 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) = {$}

Observaes First/Follow S terminais entram em First e Follow. O algoritmo de clculo de First():

trivial quando um terminal t. varre as produes X t quando um no-terminal X; chato quando o incio de ume derivao de X deriva em . Inclui apenas quando X pode derivar em .

O algoritmo de clculo de Follow(X) reservado aos no-terminais X Inclui o $ em alguns casos triviais (X == o start S) Varre as produes onde X aparece direita (A X ) chato quando X aparece no fim (ou logo antes de algo que

deriva em ) NUNCA inclui

Gramtica LL(1)Condies necessrias:

sem ambigidade sem recurso a esquerda

Uma gramtica G LL(1) sseA |* t

1. First() First() = 2. * implies !(* )3. * implies First() Follow(A) =

LL(1) = leitura Left -> right + derivao mais a esquerda (Left) + uso de 1 token lookahead.

2Anlise top-down com tabela preditiva

Os dois mtodos apresentados at agora para fazer anlise descendente usam recursividade. Cada no-terminal tem um procedimento associado; Chamadas com ou sem retrocesso.

Para gramticas LL1 no tem retrocesso.

Chamadas recursivas usam uma pilha implcita A pilha das chamadas! Sobrecusto!

Idia: de-recursificar o procedimento: Usa-se uma pilha para armazenar os no-terminais

encontrados; Usa-se uma tabela para orientar as derivaes.

Reconhecedor preditivo com Pilha Tem um buffer em entrada;

$ marca seu fim. Tem um fluxo de sada; Uma pilha cujo fundo marcado por $

Inicializada com S (Start) Uma tabela sinttica preditiva M

Parser preditivo top-down

0 * 1 0 $

S$

Sada

Tabela

Pilha

Buffer de entrada

Funcionamento do parser Seja X o smbolo no topo da pilha Seja a o smbolo de entrada (terminal!) a

analisar1. Se X = $ e a = $ : para e reconheceu uma

sentencia.2. Se X = a != $ : desempilha X e avana de um

smbolo na entrada.3. Se X no-terminal: Consulta a tabela M(X, a)

Se for vazia: ERRO Se contm X -> UVW, ento substitui na pilha X por UVW

(U no topo).

Algoritmo para construir a tabela

Re-escrever a gramtica para satisfazer condies de LL(1)

Calcular os conjuntos First e Follow Para cada produo A

1. Para cada a First() incluir a produo A em M[A,a]

2. Se First() incluir a produo A em M[A,b] para cada b

em Follow(A)3. Se First() e $ Follow(A)

incluir A to M[A,$] Todas entradas no definidas so erros

A tabela preditiva M(X, t) Tabela Bi-dimensional:

Dimenso 1: No-terminal X Dimenso 2: Caractere da entrada (terminal) t A entrada (X,t) contm a regra de produo a aplicar

BAS

$cba

S cAa

A cB | B

B bcB |

First(A) = {b, c, }

First(B) = {b, }

First(S) = {c}

Follow(A) = {a}

Follow(B) = {a}

Follow(S) = {$}

Exemplo de tabela M(X, t) Tabela Bi-dimensional:


BA

S cAaS$cba

S cAa

A cB | B

B bcB |

First(A) = {b, c, }

First(B) = {b, }

First(S) = {c}

Follow(A) = {a}

Follow(B) = {a}

Follow(S) = {$}

3Exemplo de tabela M(X, t) Tabela Bi-dimensional:


BA BA BA

S cAaS$cba

S cAa

A cB | B

B bcB |

First(A) = {b, c, }

First(B) = {b, }

First(S) = {c}

Follow(A) = {a}

Follow(B) = {a}

Follow(S) = {$}



BA cBA BA BA

S cAaS$cba

S cAa

A cB | B

B bcB |

First(A) = {b, c, }

First(B) = {b, }

First(S) = {c}

Follow(A) = {a}

Follow(B) = {a}

Follow(S) = {$}



B BA cBA BA BA

S cAaS$cba

S cAa

A cB | B

B bcB |

First(A) = {b, c, }

First(B) = {b, }

First(S) = {c}

Follow(A) = {a}

Follow(B) = {a}

Follow(S) = {$}



B bcBB BA cBA BA BA

S cAaS$cba

S cAa

A cB | B

B bcB |

First(A) = {b, c, }

First(B) = {b, }

First(S) = {c}

Follow(A) = {a}

Follow(B) = {a}

Follow(S) = {$}



ERROERROB bcBB BERROA cBA BA BAERROS cAaERROERROS

$cba

S cAa

A cB | B

B bcB |

First(A) = {b, c, }

First(B) = {b, }

First(S) = {c}

Follow(A) = {a}

Follow(B) = {a}

Follow(S) = {$}

Usando a tabela String: cbca

S->cAacasar cA->BB->bcBcasar bcasar cB-> casar acasar $, sucesso

cbca$cbca$bca$bca$bca$ca$a$a$$

S$cAa$Aa$Ba$

bcBa$cBa$Ba$

a$$

AoEntradaPilha

4Mais um exemplo...E TEE +TE| T FTT *FT | F (E)| Id

First

{(, id}{+, }{(, id}{*, }{(, id}

Smbolo

EETTF

Follow

{$, )}{$, )}{+, $, )}{+, $, )}{*, +, $, )}

Exemplo LL(1)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) = {$}

Construir TabelaAnalisar abcdfcf

Observao sobre a Tabela A tabela indica se h ambigidade!

Mais de uma regra numa entrada! Solues?

Tornar a gramtica LL(1) Eliminar ambiguidade, recursividade... Ver os slides

seguintes. Usar uma heurstica para desempatar as regras

Qual? Usar outros algoritmos do que os top-down!

Exemplo total: if... Then... Else:S i E t S | i E t S e S | aE b

Transformaes de GLCs Eliminao de produes vazias Eliminao de recursividade esquerda:

recurso direta recurso indireta

Fatorao de uma gramtica

Eliminao de produes vazias (1) Objetivo:

eliminar produes da forma A .

Algoritmo: seja G = (N,T,P,S) uma GLC Etapa 1:

construir N , o conjunto de no-terminais que geram a palavra vazia:

N = {A | A };Repita

N = N {X | X X1...Xn P tq X1,...,Xn N}

At que o cardinal de N no aumente.

Eliminao de produes vazias (2) Etapa 2:

construir o conjunto de produes sem produes vazias:

gera G1 = (N,T,P1,S), onde P1 construdo como segue:

P1 = {A | };Repita

Para toda A P1 e X N tal que = 1X2 e 12

Faa P1 = P1 {A 12} At que o cardinal de P1 no aumente

5Eliminao de produes vazias (3) Etapa 3:

incluir gerao da palavra vazia, se necessrio.

Se a palavra vazia pertence linguagem, ento a gramtica resultante

G2 = (N,T,P2,S), onde P2 = P1 {S }

Eliminao de recursividade esquerda Exemplo

A Aa | b

Sem a palavra vaziaA b | bXX a | aX

Com a palavra vaziaA bXX aX |

Obs: pode ainda haver recurso indireta!

Exemplo E -> E+T | T T -> T*F | F F -> (E)| IdA regra E -> E+T | T se torna:

E -> TEE -> +TE|

A regra T- > T*F | F se torna:T -> FTT-> *FT |

Convertendo recurso a esquerda para recurso a direita

X Xb | Xc | AB | C

Introduzir YX ABY | CYY bY | cY |

Fatorao de uma gramtica Elimina indeciso de qual produo

aplicar quando duas ou mais produes iniciam com a mesma forma sentencial

A 1 | 2 Se torna:A X X 1 |2

Exemplo de Fatorao a Esquerda

Cmd if Expr then Cmd else CmdCmd if Expr then CmdCmd Outro

Fatorando a esquerda: Cmd if Expr then Cmd ElseOpcCmd OutroElseOpc else Cmd |

6Gerenciamento de Erros Relatar erros & recuperar

Relatar erros assim que possvel Mensagens de erro adequadas Continua aps o erro Evitar a cascata de erros

Nvel-Frase (local) x Modo-Pnico Nvel frase: tenta-se alterar UM smbolo para

recuperar. Modo pnico: pula x tokens de entrada at poder

voltar a fazer a anlise. = at encontrar um token de sincronizao.

Recuperao em Modo Pnico Pula tokens at que um conjunto de

sincronizao encontrado Follow(A) (A sendo no topo da pilha) Smbolos de alta hierarquia na gramtica

{ , for, while, if First(A) Epsilon produo Pop/Insert um terminal no topo da pilha.

Adicione aes de sincronia para a tabela

Sumrio Anlise top-down possibilita o reconhecimento

eficiente e simples de gramticas LL(1): Implementao preditiva com tabela. Baseada nos clculos dos conjuntos First/Follow

Obs: tm casos que no foram tratados (e.g. o +) Limitao:

Quando a gramtica no LL(1) !

Por isso: usa-se tambm anlise ascendente(bottom-up).

compiladores achei na net

Documents